BSEmcMCHitProductionProcess.h

Go to the documentation of this file.

#ifndef BSEMCMCHITPRODUCTIONPROCESS_HH
#define BSEMCMCHITPRODUCTIONPROCESS_HH

#include <map>
#include <string>
#include <vector>

#include "Rtypes.h"
#include "RtypesCore.h"
#include "TClonesArray.h"
#include "TVector3.h"

#include "FairMultiLinkedData.h"

#include "PndContainerI.h"
#include "PndParameterRegister.h"
#include "PndProcess.h"

#include "BSEmcCrystalPositionPar.h"
#include "BSEmcMCHitProductionData.h"
#include "BSEmcSortMCTruthAlgo.h"

class PndMCTrack;
class BSEmcMCPoint;
class BSEmcMCHit;
class BSEmcCrystalPositionPar;
class PndParameterRegister;
class TBuffer;
class TClass;
class TMemberInspector;
struct BSEmcMCHitProductionData;
template <class T>
class PndInputContainerI;
template <class T>
class PndOutputContainerI;

struct BSEmcVolume {
  virtual Bool_t InsideVolume(const TVector3 &t_point) const = 0;
  virtual ~BSEmcVolume(){};
};

struct BSEmcVolumeDisk : public BSEmcVolume { // needed for MC matching. Assume barrel structure
  Double_t fMinR{-1};
  Double_t fMaxR{-1};
  Double_t fMinZ{-1};
  Double_t fMaxZ{-1};
  BSEmcVolumeDisk(Double_t t_minR, Double_t t_maxR, Double_t t_minZ, Double_t t_maxZ) : fMinR(t_minR), fMaxR(t_maxR), fMinZ(t_minZ), fMaxZ(t_maxZ){};
  virtual ~BSEmcVolumeDisk(){};

  Bool_t InsideVolume(const TVector3 &t_point) const
  {
    if (t_point.Z() > fMinZ && t_point.Z() < fMaxZ) {
      if (t_point.Perp() > fMinR && t_point.Perp() < fMaxR) {
        return kTRUE;
      }
    }
    return kFALSE;
  };
};

struct BSEmcVolumeBox : public BSEmcVolume {
  Double_t fMinX{-1}, fMaxX{-1};
  Double_t fMinY{-1}, fMaxY{-1};
  Double_t fMinZ{-1}, fMaxZ{-1};

  BSEmcVolumeBox(Double_t t_minX, Double_t t_maxX, Double_t t_minY, Double_t t_maxY, Double_t t_minZ, Double_t t_maxZ)
    : fMinX(t_minX), fMaxX(t_maxX), fMinY(t_minY), fMaxY(t_maxY), fMinZ(t_minZ), fMaxZ(t_maxZ){};
  virtual ~BSEmcVolumeBox(){};

  Bool_t InsideVolume(const TVector3 &t_point) const
  {
    if (t_point.Z() > fMinZ && t_point.Z() < fMaxZ) {
      if (t_point.Y() > fMinY && t_point.Y() < fMaxY) {
        if (t_point.X() > fMinX && t_point.X() < fMaxX) {
          return kTRUE;
        }
      }
    }
    return kFALSE;
  };
};

class BSEmcMCHitProductionProcess : private BSEmcSortMCTruthAlgo, public PndProcess<BSEmcMCHitProductionData> {
 public:
  BSEmcMCHitProductionProcess();
  virtual ~BSEmcMCHitProductionProcess();
  virtual void SetData(BSEmcMCHitProductionData *t_pdata) /*override*/;
  virtual void SetupParameters(const PndParameterRegister *t_parameter) /*override*/;
  virtual void SetDetectorName(const std::string &t_detectorname) /*override*/;
  virtual void Process() /*override*/;
  void SetHitParName(const std::string &t_parName) { fHitParName = t_parName; }
  void SetPositionParName(const std::string &t_parName) { fPositionParName = t_parName; }
  void SetVolume(BSEmcVolume *t_volume) { fBoundaryVolume = t_volume; }

 private:
  virtual Double_t GetEnergy(const BSEmcMCPoint *t_point) const;
  virtual Double_t GetTime(const BSEmcMCPoint *t_point) const;
  virtual Bool_t GetEntering(const BSEmcMCPoint *t_point) const;
  virtual Bool_t GetExiting(const BSEmcMCPoint *t_point) const;
  virtual FairMultiLinkedData GetTracks(const BSEmcMCPoint *t_point) const;
  virtual Int_t GetMCTrackID(const BSEmcMCPoint *t_point) const;
  virtual Bool_t SkipPoint(const BSEmcMCPoint *t_point) const;

  virtual void CreateHits(std::vector<BSEmcMCPoint *> t_points);
  void Reset();
  Int_t FindMCIndex(const BSEmcMCPoint *t_point);
  Int_t FindMCIndexIterative(const BSEmcMCPoint *t_point, Int_t t_mcIndex);

  void SetClusterIdForPoint(BSEmcMCPoint *t_point);
  void StoreHits();
  virtual void StoreHit(Int_t t_detId, Double_t t_time, std::vector<Int_t> &t_mctrackIds, const FairMultiLinkedData &t_entering, const FairMultiLinkedData &t_exiting);

 protected:
  std::string fHitParName{""};
  std::string fPositionParName{""};
  PndInputContainerI<PndMCTrack> *fMCTrackArray{nullptr};
  PndOutputContainerI<BSEmcMCPoint> *fPointArray{nullptr};
  PndOutputContainerI<BSEmcMCHit> *fHitArray{nullptr};
  Double_t fEnergyThreshold{-1};
  Double_t fCutMotherParticle{-1};
  Double_t fCutSameTrack{-1};
  BSEmcCrystalPositionPar *fPositionPar{nullptr};
  BSEmcVolume *fBoundaryVolume{nullptr};

  std::map<Int_t, Float_t> fTrackEnergy{};
  std::map<Int_t, Float_t> fTrackTime{};                      // time of first point
  std::map<Int_t, std::vector<Int_t>> fTrackMcTruth{};        // McTruth MC track which deposited energy in the crystal
  std::map<Int_t, std::vector<Int_t>> fPointMatch{};          // DetId , PointIds with same DetId
  std::map<Int_t, FairMultiLinkedData> fTrackEntering{};      // DetId, link to tracks entering same DetId
  std::map<Int_t, FairMultiLinkedData> fTrackExiting{};       // DetId, link to track exiting same DetId
  std::map<Int_t, const BSEmcMCPoint *> fLastPointForTrack{}; // <mcTrackId, last point of track seen>
  std::map<Int_t, std::map<Int_t, Double_t>> fShower{};       // <DetId <MCTrackIndex, DepositedEnergy>> MCTruth deposited energy per crystal and (primary) mc particle type

  ClassDef(BSEmcMCHitProductionProcess, 1);
};

#endif /*BSEMCMCHITPRODUCTIONPROCESS_HH*/