PadOriginal.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef O2_MCH_PADORIGINAL_H_
#define O2_MCH_PADORIGINAL_H_
 
#include <algorithm>
#include <stdexcept>
#include <vector>
 
#include <TMath.h>
 
namespace o2
{
namespace mch
{
 
class PadOriginal
{
 public:
  enum padStatus {
    kZero = 0x0,       
    kUseForFit = 0x1,  
    kCoupled = 0x10,   
    kOver = 0x100,     
    kMustKeep = 0x1000 
  };
 
  PadOriginal() = delete;
  PadOriginal(double x, double y, double dx, double dy, double charge,
              bool isSaturated = false, int plane = -1, int digitIdx = -1, int status = kZero)
    : mx(x), my(y), mdx(dx), mdy(dy), mCharge(charge), mIsSaturated(isSaturated), mPlane(plane), mDigitIdx(digitIdx), mStatus(status) {}
  ~PadOriginal() = default;
 
  PadOriginal(const PadOriginal& cl) = default;
  PadOriginal& operator=(const PadOriginal& cl) = default;
  PadOriginal(PadOriginal&&) = default;
  PadOriginal& operator=(PadOriginal&&) = default;
 
  void setx(double x) { mx = x; }
  void sety(double y) { my = y; }
  double x() const { return mx; }
  double y() const { return my; }
  double xy(int ixy) const { return (ixy == 0) ? mx : my; }
 
  void setdx(double dx) { mdx = dx; }
  void setdy(double dy) { mdy = dy; }
  double dx() const { return mdx; }
  double dy() const { return mdy; }
  double dxy(int ixy) const { return (ixy == 0) ? mdx : mdy; }
 
  void setCharge(double charge) { mCharge = charge; }
  double charge() const { return mCharge; }
 
  int plane() const { return mPlane; }
 
  int digitIndex() const { return mDigitIdx; }
  bool isReal() const { return mDigitIdx >= 0; }
 
  void setStatus(int status) { mStatus = status; }
  int status() const { return mStatus; }
 
  bool isSaturated() const { return mIsSaturated; }
 
 private:
  double mx = 0.;            
  double my = 0.;            
  double mdx = 0.;           
  double mdy = 0.;           
  double mCharge = 0.;       
  bool mIsSaturated = false; 
  int mPlane = -1;           
  int mDigitIdx = -1;        
  int mStatus = kZero;       
};
 
//_________________________________________________________________________________________________
inline auto findPad(std::vector<PadOriginal>& pads, double x, double y, double minCharge)
{
 
  auto match = [x, y, minCharge](const PadOriginal& pad) {
    return pad.charge() >= minCharge && TMath::Abs(pad.x() - x) < 1.e-3 && TMath::Abs(pad.y() - y) < 1.e-3;
  };
 
  auto itPad = std::find_if(pads.begin(), pads.end(), match);
 
  if (itPad == pads.end()) {
    throw std::runtime_error("Pad not found");
  }
 
  return itPad;
}
 
//_____________________________________________________________________________
inline bool areOverlapping(const PadOriginal& pad1, const PadOriginal& pad2, double precision)
{
 
  if (pad1.x() - pad1.dx() > pad2.x() + pad2.dx() - precision ||
      pad1.x() + pad1.dx() < pad2.x() - pad2.dx() + precision ||
      pad1.y() - pad1.dy() > pad2.y() + pad2.dy() - precision ||
      pad1.y() + pad1.dy() < pad2.y() - pad2.dy() + precision) {
    return false;
  }
 
  return true;
}
 
} // namespace mch
} // namespace o2
 
#endif // O2_MCH_PADORIGINAL_H_