CbmRecoQaTask.h

Go to the documentation of this file.

/* Copyright (C) 2024 Hulubei National Institute of Physics and Nuclear Engineering - Horia Hulubei, Bucharest
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Alexandru Bercuci [committer], Omveer Singh */
 
#ifndef CBMRECOQATASK_H
#define CBMRECOQATASK_H 1
 
#include "CbmKfTrackFitter.h"
#include "CbmTrack.h"
 
#include <FairTask.h>
 
#include <TDirectoryFile.h>
#include <TGeoNode.h>
 
#include <bitset>
#include <map>
#include <vector>
 
class FairMCPoint;
class CbmEvent;
class CbmHit;
class CbmMCDataManager;
class CbmMCDataArray;
class CbmTimeSlice;
class TClonesArray;
class TH2;
class TH2D;
class TVector3;
class CbmRecoQaTask : public FairTask {
 public:
  enum eRecoConfig
  {
    kRecoEvents = 0,  
    kRecoTracks,      
    kStsHits,         
    kTrdHits,         
    kTofHits,         
    kRichHits,        
    kMuchHits,        
    kUseMC,           
    kRecoQaNConfigs   
  };
  enum eSetup
  {
    kMcbm22 = 0,
    kMcbm24,
    kDefault
  };
  enum class eViewType : int
  {
    kDetUnit = 0,  
    kTrkProj,      
    kPV            
  };
 
#define kNtrkProjections 6
  enum class eProjectionType : int
  {
    kXYa = 0,     
    kXYp,         
    kXdX,         
    kXdXMC,       
    kYdY,         
    kYdYMC,       
    kWdT,         
    kXpX,         
    kYpY,         
    kChdT,        
    kXYh,         
    kDmult,       
    kDmultMC,     
    kXYhMC,       
    kPullX,       
    kPullY,       
    kResidualX,   
    kResidualY,   
    kResidualTX,  
    kResidualTY,  
    kPVxy,        
    kPVxz,        
    kPVyz,        
    kPVmult,      
    kXYt0,        
    kXYt1,        
    kXYt2,        
    kXYt3,        
    kXYt4,        
    kXYt5         
  };
 
  // Generic view definition
  struct Detector;
  struct View {
    friend struct Detector;
    friend class CbmRecoQaTask;
 
    View() = default;
    View(const char* n, const char* p, std::vector<int> set) : name(n), path(p), fSelector(set) { ; }
    virtual ~View() = default;
    bool SetProjection(eProjectionType prj, float range, const char* unit);
    template<class Hit>
    bool HasAddress(const CbmHit* h, double& x, double& y, double& dx, double& dy) const;
    template<class Hit>
    bool Load(const CbmHit* h, const FairMCPoint* point, const CbmEvent* ev);
    bool Load(const CbmKfTrackFitter::TrajectoryNode* n, const FairMCPoint* point);
    bool Load(TVector3* p);
    std::string ToString() const;
    static std::string ToString(eProjectionType prj);
    void SetSetup(CbmRecoQaTask::eSetup setup) { fSetup = setup; }
    void SetType(CbmRecoQaTask::eViewType type) { fType = type; }
 
    std::string name           = "";    
    std::string path           = "";    
    double size[3]             = {0.};  
    double pos[3]              = {0.};  
    std::vector<int> fSelector = {};    
    std::map<eProjectionType, std::tuple<int, float, TH2*>> fProjection =
      {};                         
    int fMult               = 0;  
    mutable eSetup fSetup   = eSetup::kMcbm22;
    mutable eViewType fType = eViewType::kDetUnit;
 
   protected:
    bool AddProjection(eProjectionType prj, float range = -1, const char* unit = "cm");
    bool Init(const char* dname, bool mc = false);
    uint Register(TDirectoryFile* f);
    std::string makeTrange(const int scale, float& range);
    std::string makeYrange(const int scale, float& range);
    ClassDef(CbmRecoQaTask::View,
             1);  // Stand-alone detection set to which QA is applied
  };              // QA View definition
 
  // Detector unit definition
  struct Detector {
    struct Data {
      Data() = default;
      Data(ECbmDataType i, const char* n) : id(i), name(n) { ; }
      ECbmDataType id  = ECbmDataType::kUnknown;
      std::string name = "nn";
    };  // Identifier of data to be monitored
 
    Detector(ECbmModuleId did = ECbmModuleId::kNotExist);
    virtual ~Detector() = default;
    View* AddView(const char* n, const char* p, std::vector<int> set);
    View* GetView(const char* n);
    View* FindView(double x, double y, double z);
    bool Init(TDirectoryFile* f, bool mc = false);
    void Print() const;
 
    ECbmModuleId id;
    Data hit, point;
    Data trk;
    std::vector<View> fViews = {};
 
    ClassDef(CbmRecoQaTask::Detector,
             1);  // QA representation of a detector unit
  };              // Detection system agregate
 
  struct TrackFilter {
    enum class eTrackCut : int
    {
      kSts = 0,  
      kMuch,     
      kRich,     
      kTrd,      
      kTof,      
      kNone      
    };
    TrackFilter(eTrackCut typ = eTrackCut::kNone) : fType(typ) { ; }
    virtual ~TrackFilter() = default;
    bool Accept(const CbmGlobalTrack* ptr, const CbmRecoQaTask* lnk);
    bool SetFilter(std::vector<float> cuts);
    std::string ToString() const;
 
    eTrackCut fType = eTrackCut::kNone;
 
   private:
    // STS definition of track
    int fNSts                  = -1;
    std::vector<bool> fStsHits = {};
    // TRD definition of track
    int fNTrd = -1;
    // ToF definition of track
    int fNTof = -1;
    ClassDef(CbmRecoQaTask::TrackFilter, 1);  // Track cut implementation
  };                                          // TrackFilter definition
 
  struct EventFilter {
    enum class eEventCut : int
    {
      kMultTrk = 0,  
      kMultHit,      
      kTrigger,      
      kVertex,       
      kNone          
    };
    enum class eEventDef : int
    {
      kNofDetHit = 3  
    };
    EventFilter(eEventCut typ = eEventCut::kNone) : fType(typ) { ; }
    virtual ~EventFilter() = default;
    bool Accept(const CbmEvent* ptr, const CbmRecoQaTask* lnk);
    bool SetFilter(std::vector<float> cuts);
    std::string ToString() const;
 
    eEventCut fType = eEventCut::kNone;
 
   private:
    // track multiplicity cut definition
    int fMinTrack = 0;
    int fMaxTrack = 0;
    // hit multiplicity cut definition
    int fMultHit[(int) eEventDef::kNofDetHit] = {0};  
 
    void HelpMess() const;
 
    ClassDef(CbmRecoQaTask::EventFilter, 1);  // Event cut implementation
  };                                          // EventFilter definition
 
 public:
  CbmRecoQaTask();
  virtual ~CbmRecoQaTask() { ; }
  virtual Detector* AddDetector(ECbmModuleId did);
  virtual EventFilter* AddEventFilter(EventFilter::eEventCut cut);
  virtual TrackFilter* AddTrackFilter(TrackFilter::eTrackCut cut);
  virtual Detector* GetDetector(ECbmModuleId did);
  virtual const CbmTrack* GetTrack(ECbmModuleId did, int id) const;
  virtual InitStatus Init();
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
  // /** \brief Define the set of extra z positions where the track should be
  //  * projected in the x-y plane */
  // void SetProjections(std::vector<double> vzpj);
  void SetSetupClass(CbmRecoQaTask::eSetup setup) { fSetupClass = setup; }
  TString GetGeoTagForDetector(const TString& detector);
  std::vector<TString> GetPath(TGeoNode* node, TString, TString activeNodeName, int depth = 0,
                               const TString& path = "");
  void UseMC(bool set = true)
  {
    if (set) fuRecoConfig.set(kUseMC);
  }
 
 protected:
  static std::bitset<kRecoQaNConfigs> fuRecoConfig;
 
 private:
  CbmRecoQaTask(const CbmRecoQaTask&);
  CbmRecoQaTask& operator=(const CbmRecoQaTask&);
 
  virtual bool FilterEvent(const CbmEvent* ptr);
  virtual bool FilterTrack(const CbmGlobalTrack* ptr);
  int GetNviews(eViewType type) const;
  void InitMcbm22();
  void InitMcbm24();
  void InitDefault();
 
  CbmKfTrackFitter fFitter;
  TClonesArray* fGTracks                          = nullptr;  
  std::map<ECbmModuleId, TClonesArray*> fTracks   = {};       
  TClonesArray* fTrackMatches                     = nullptr;  
  TClonesArray* fEvents                           = nullptr;  
  CbmTimeSlice* fTimeSlice                        = nullptr;  
  std::map<ECbmModuleId, TClonesArray*> fHits     = {};       
  std::map<ECbmModuleId, CbmMCDataArray*> fPoints = {};       
  std::map<ECbmModuleId, TClonesArray*> fHitMatch = {};       
  std::vector<EventFilter> fFilterEv              = {};
  std::vector<TrackFilter> fFilterTrk             = {};
  CbmMCDataManager* cbm_mc_manager                = nullptr;
  TDirectoryFile fOutFolder                       = {"RecoQA", "CA track driven reco QA"};  
  eSetup fSetupClass                              = eSetup::kMcbm24;
  std::map<ECbmModuleId, Detector> fDetQa         = {};  
  std::map<const char*, View> fViews              = {};  
  std::vector<TVector3> fPrjPlanes = {};  
 
  ClassDef(CbmRecoQaTask, 1);  // Reconstruction QA analyzed from CA perspective
};
 
#endif  // CBMRECOQATASK_H