CbmMatchRecoToMC.h

Go to the documentation of this file.

/* Copyright (C) 2013-2023 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev [committer], Volker Friese */
 
#ifndef CBMMATCHRECOTOMC_H_
#define CBMMATCHRECOTOMC_H_
 
#include "CbmDefs.h"  // for ECbmModuleId
#include "CbmMatch.h"
#include "CbmTofDigi.h"
 
#include <FairTask.h>  // for FairTask, InitStatus
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Bool_t, Option_t, kFALSE, kTRUE
 
#include <utility>  // for pair
#include <vector>   // for vector
 
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();
 
 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 MatchHitsFsd(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<CbmLink> GetMcTrackMotherIdsForRichHit(CbmDigiManager* digiMan, const CbmRichHit* hit,
                                                            CbmMCDataArray* richPoints, CbmMCDataArray* mcTracks);
  [[deprecated]] static std::vector<std::pair<Int_t, Int_t>>
  GetMcTrackMotherIdsForRichHit(CbmDigiManager* digiMan, const CbmRichHit* hit, CbmMCDataArray* richPoints,
                                CbmMCDataArray* mcTracks, Int_t eventNumber);
 
  [[deprecated]] static std::vector<Int_t> GetMcTrackMotherIdsForRichHit(CbmDigiManager* digiMan, const CbmRichHit* hit,
                                                                         const TClonesArray* richPoints,
                                                                         const TClonesArray* mcTracks);
 
  void SuppressHitReMatching() { fbSuppressHitReMatching = true; }
 
 private:
  static Int_t fEventNumber;
 
  Bool_t fIsMvdActive          = kTRUE;  // is the Mvd module active
  Bool_t fbDigiExpUsed         = kTRUE;  // Usage of CbmTofDigiExp instead of CbmTofDigi
  bool fbSuppressHitReMatching = false;  // Suppression of MC->hit matching, if the matches are already there
 
  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;  
  const std::vector<CbmTofDigi>* fTofDigis   = nullptr;  // TOF MC point matches
  const std::vector<CbmMatch>* fTofDigiMatch = nullptr;  // TOF MC point matches
  TClonesArray* fTofHits                     = nullptr;  
  TClonesArray* fTofHitDigiMatches           = nullptr;  
  TClonesArray* fTofHitMatches               = nullptr;  
 
  // FSD
  CbmMCDataArray* fFsdPoints   = nullptr;  
  TClonesArray* fFsdHits       = nullptr;  
  TClonesArray* fFsdHitMatches = nullptr;  
 
  CbmMatchRecoToMC(const CbmMatchRecoToMC&);
  CbmMatchRecoToMC& operator=(const CbmMatchRecoToMC&);
 
  ClassDef(CbmMatchRecoToMC, 1);
};
 
#endif /* CBMMATCHRECOTOMC_H_ */