CbmMatchRecoToMC.h

Go to the documentation of this file.

 
#ifndef CBMMATCHRECOTOMC_H_
#define CBMMATCHRECOTOMC_H_
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Bool_t, Option_t, kFALSE, kTRUE
 
#include <FairTask.h>  // for FairTask, InitStatus
 
#include <utility>  // for pair
#include <vector>   // for vector
 
#include "CbmDefs.h"  // for ECbmModuleId
 
class CbmDigiManager;
class CbmMCDataArray;
class CbmRichHit;
class TClonesArray;
 
class CbmMatchRecoToMC : public FairTask {
public:
  CbmMatchRecoToMC();
 
  virtual ~CbmMatchRecoToMC();
 
  virtual InitStatus Init();
 
  virtual void Exec(Option_t* opt);
 
  virtual void Finish();
 
  void SetIncludeMvdHitsInStsTrack(Bool_t includeMvdHitsInStsTrack);
 
private:
  void ReadAndCreateDataBranches();
 
 
  void MatchClusters(const TClonesArray* digiMatches,
                     const TClonesArray* clusters,
                     TClonesArray* clusterMatches);
 
 
  void MatchClusters(ECbmModuleId systemId,
                     const TClonesArray* clusters,
                     TClonesArray* clusterMatches);
 
 
  void MatchHits(const TClonesArray* matches,
                 const TClonesArray* hits,
                 TClonesArray* hitMatches);
 
  void MatchHitsSts(const TClonesArray* clusterMmatches,
                    const TClonesArray* hits,
                    TClonesArray* hitMatches);
 
  void MatchHitsMvd(const TClonesArray* hits, TClonesArray* hitMatches);
 
  void MatchHitsTof(const TClonesArray* HitDigiMatches,
                    const TClonesArray* hits,
                    TClonesArray* hitMatches);
 
  void MatchHitsToPoints(CbmMCDataArray* points,
                         const TClonesArray* hits,
                         TClonesArray* hitMatches);
 
  void MatchTracks(const TClonesArray* hitMatches,
                   CbmMCDataArray* points,
                   const TClonesArray* tracks,
                   TClonesArray* trackMatches);
 
  //Special case for STS: now evbased compatible
  void MatchStsTracks(const TClonesArray* mvdHitMatches,
                      const TClonesArray* stsHitMatches,
                      CbmMCDataArray* mvdPoints,
                      CbmMCDataArray* stsPoints,
                      const TClonesArray* tracks,
                      TClonesArray* trackMatches);
 
  void MatchRichRings(const TClonesArray* richRings,
                      const TClonesArray* richHits,
                      CbmMCDataArray* richMcPoints,
                      CbmMCDataArray* mcTracks,
                      TClonesArray* ringMatches);
 
public:
  static std::vector<std::pair<Int_t, Int_t>>
  GetMcTrackMotherIdsForRichHit(CbmDigiManager* digiMan,
                                const CbmRichHit* hit,
                                CbmMCDataArray* richPoints,
                                CbmMCDataArray* mcTracks,
                                Int_t eventNumber);
 
  static std::vector<Int_t>
  GetMcTrackMotherIdsForRichHit(CbmDigiManager* digiMan,
                                const CbmRichHit* hit,
                                const TClonesArray* richPoints,
                                const TClonesArray* mcTracks);
 
private:
  static Int_t fEventNumber;
 
  Bool_t fIncludeMvdHitsInStsTrack = kFALSE;
  Bool_t fbDigiExpUsed = kTRUE;  // Usage of CbmTofDigiExp instead of CbmTofDigi
 
  CbmMCDataArray* fMCTracks    = nullptr;  
  CbmDigiManager* fDigiManager = nullptr;  
 
  // MVD
  CbmMCDataArray* fMvdPoints       = nullptr;  
  TClonesArray* fMvdCluster        = nullptr;  
  TClonesArray* fMvdHits           = nullptr;  
  TClonesArray* fMvdClusterMatches = nullptr;  
  TClonesArray* fMvdHitMatches     = nullptr;  
 
  // STS
  CbmMCDataArray* fStsPoints       = nullptr;  
  TClonesArray* fStsClusters       = nullptr;  
  TClonesArray* fStsHits           = nullptr;  
  TClonesArray* fStsTracks         = nullptr;  
  TClonesArray* fStsClusterMatches = nullptr;  
  TClonesArray* fStsHitMatches     = nullptr;  
  TClonesArray* fStsTrackMatches   = nullptr;  
 
  // RICH
  CbmMCDataArray* fRichMcPoints   = nullptr;  
  TClonesArray* fRichHits         = nullptr;  
  TClonesArray* fRichRings        = nullptr;  
  TClonesArray* fRichTrackMatches = nullptr;  
 
  // MUCH
  CbmMCDataArray* fMuchPoints        = nullptr;  
  TClonesArray* fMuchClusters        = nullptr;  
  TClonesArray* fMuchPixelHits       = nullptr;  
  TClonesArray* fMuchTracks          = nullptr;  
  TClonesArray* fMuchClusterMatches  = nullptr;  
  TClonesArray* fMuchPixelHitMatches = nullptr;  
  TClonesArray* fMuchTrackMatches    = nullptr;  
 
  // TRD
  CbmMCDataArray* fTrdPoints       = nullptr;  
  TClonesArray* fTrdClusters       = nullptr;  
  TClonesArray* fTrdHits           = nullptr;  
  TClonesArray* fTrdTracks         = nullptr;  
  TClonesArray* fTrdClusterMatches = nullptr;  
  TClonesArray* fTrdHitMatches     = nullptr;  
  TClonesArray* fTrdTrackMatches   = nullptr;  
 
  // TOF
  CbmMCDataArray* fTofPoints       = nullptr;  
  TClonesArray* fTofHits           = nullptr;  
  TClonesArray* fTofHitDigiMatches = nullptr;  
  TClonesArray* fTofHitMatches     = nullptr;  
 
 
  CbmMatchRecoToMC(const CbmMatchRecoToMC&);
  CbmMatchRecoToMC& operator=(const CbmMatchRecoToMC&);
 
  ClassDef(CbmMatchRecoToMC, 1);
};
 
#endif /* CBMMATCHRECOTOMC_H_ */