CbmL1.h

Go to the documentation of this file.

/* Copyright (C) 2006-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ivan Kisel,  Sergey Gorbunov, Maksym Zyzak, Valentina Akishina, Igor Kulakov, Denis Bertini [committer], Sergei Zharko */
 
/*
 *====================================================================
 *
 *  CBM Level 1 Reconstruction
 *
 *  Authors: I.Kisel,  S.Gorbunov
 *
 *  e-mail : ikisel@kip.uni-heidelberg.de
 *
 *====================================================================
 *
 *  CbmL1 header file
 *
 *====================================================================
 */
 
#ifndef _CbmL1_h_
#define _CbmL1_h_
 
#include "CaDataManager.h"
#include "CaFramework.h"
#include "CaInitManager.h"
#include "CaMonitor.h"
#include "CaVector.h"
#include "CbmCaMCModule.h"
#include "CbmCaTimeSliceReader.h"
#include "CbmL1DetectorID.h"
#include "CbmL1Hit.h"
#include "CbmL1MCPoint.h"
#include "CbmL1MCTrack.h"
#include "CbmL1Track.h"
#include "FairDetector.h"
#include "FairRootManager.h"
#include "FairTask.h"
#include "KfMaterialMonitor.h"
#include "KfTrackParam.h"
#include "TClonesArray.h"
#include "TH1.h"
 
#include <Logger.h>
 
#include <boost/functional/hash.hpp>
 
#include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <string_view>
#include <unordered_map>
#include <utility>
 
class CbmL1MCTrack;
class CbmMCDataObject;
class CbmEvent;
class TProfile2D;
class TNtuple;
class TGeoNode;
 
 
namespace
{
  namespace ca = cbm::algo::ca;
  namespace kf = cbm::algo::kf;
}
 
struct CbmL1LinkKey {
  CbmL1LinkKey(int32_t index, int32_t entry, int32_t file) : fIndex(index), fEntry(entry), fFile(file) {}
  bool operator==(const CbmL1LinkKey& other) const
  {
    return fFile == other.fFile && fEntry == other.fEntry && fIndex == other.fIndex;
  }
 
  int32_t fIndex = -1;  
  int32_t fEntry = -1;  
  int32_t fFile  = -1;  
};
 
namespace std
{
  template<>
  struct hash<CbmL1LinkKey> {
    std::size_t operator()(const CbmL1LinkKey& key) const
    {
      std::size_t res = 0;
      boost::hash_combine(res, key.fFile);
      boost::hash_combine(res, key.fEntry);
      boost::hash_combine(res, key.fIndex);
      return res;
    }
  };
}  // namespace std
 
 
// TODO: insert documentation! (S.Zh.)
//
class CbmL1 : public FairTask {
 public:
  // **********************
  // ** Types definition **
  // **********************
 
  using DFSET = std::set<std::pair<int, int>>;
 
  // **************************
  // ** Friends classes list **
  // **************************
 
  friend class L1AlgoDraw;
  friend class L1AlgoPulls;
 
  template<int NHits>
  friend class L1AlgoEfficiencyPerformance;
 
  friend class CbmL1MCTrack;
  friend class CbmL1PFFitter;
 
  enum class EInitMode
  {
    Full,  
    Param  
  };
 
  // **********************************
  // ** Member functions declaration **
  // **********************************
 
  // ** Constructors and destructor **
 
  CbmL1();
 
  CbmL1(const char* name, Int_t verbose = 1, Int_t performance = 0);
 
  CbmL1(const CbmL1&) = delete;
 
  CbmL1(CbmL1&&) = delete;
 
  CbmL1& operator=(const CbmL1&) = delete;
 
  CbmL1& operator=(CbmL1&&) = delete;
 
  ~CbmL1();
 
  static CbmL1* Instance() { return fpInstance; }
 
  // ** Member functions override from FairTask **
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
  void Finish();
 
  const cbm::ca::tools::MCData& GetMCData() const { return fMCData; }
 
  // ** Specific member functions **
 
  void DisableTrackingStation(ca::EDetectorID detID, int iSt);
 
  void SetInitMode(EInitMode mode) { fInitMode = mode; }
 
  void SetSafeMaterialInitialization(bool val = true) { fDoSafeMaterialInitialization = val; }
 
  void SetMaterialBudgetNbins(int nBinsPerDimension) { fMatBudgetNbins = nBinsPerDimension; }
 
  void SetMaterialBudgetNrays(int nRaysPerDimension) { fMatBudgetNrays = nRaysPerDimension; }
 
  void SetMaterialBudgetPitch(double pitchCm) { fMatBudgetPitch = pitchCm; }
 
  void SetMaterialBudgetParallelProjection() { fMatBudgetParallelProjection = true; }
 
  void SetConfigUser(const char* path) { fInitManager.SetConfigUser(path); }
 
  void SetInputSearchWindowFilename(const char* filename) { fsInputSearchWindowsFilename = filename; }
 
  void SetOutputConfigName(const char* filename) { fInitManager.SetOutputConfigName(std::string(filename)); }
 
  void SetParameterFilename(const char* filename) { fSTAPParamFile = TString(filename); }
 
  void SetOutputMcTripletsTreeFilename(const char* filename) { fsMcTripletsOutputFilename = std::string(filename); }
 
  const auto& GetQaHits() const { return fvHitDebugInfo; }
 
  static constexpr const char* GetDetectorName(ca::EDetectorID detectorID)
  {
    switch (detectorID) {
      case ca::EDetectorID::kMvd: return "MVD";
      case ca::EDetectorID::kSts: return "STS";
      case ca::EDetectorID::kMuch: return "MuCh";
      case ca::EDetectorID::kTrd: return "TRD";
      case ca::EDetectorID::kTof: return "TOF";
      case ca::EDetectorID::END: break;
    }
    return "";
  }
 
  void SetExtrapolateToTheEndOfSTS(bool b) { fExtrapolateToTheEndOfSTS = b; }
  void SetStsOnlyMode() { fTrackingMode = ca::TrackingMode::kSts; }
  void SetMcbmMode() { fTrackingMode = ca::TrackingMode::kMcbm; }
  void SetGlobalMode() { fTrackingMode = ca::TrackingMode::kGlobal; }
 
  ca::TrackingMonitor fMonitor{};  
 
  //   void SetTrackingLevel( Int_t iLevel ){ fTrackingLevel = iLevel; }
  //   void MomentumCutOff( Double_t cut ){ fMomentumCutOff = cut; }
  //   void SetDetectorEfficiency( Double_t eff ){ fDetectorEfficiency = eff; }
 
  void Reconstruct(CbmEvent* event = nullptr);
 
  static double boundedGaus(double sigma);
 
 
  void SetMvdMaterialBudgetFileName(const TString&)
  {
    LOG(warning) << "CbmL1::SetMvdMaterialBudgetFileName() is obsolete and will be deleted soon, don't call it\n"
                 << "   !  The material budget files are not used anymore  !";
  }
 
  void SetStsMaterialBudgetFileName(const TString&)
  {
    LOG(warning) << "CbmL1::SetStsMaterialBudgetFileName() is obsolete and will be deleted soon, don't call it\n"
                 << "   !  The material budget files are not used anymore  !";
  }
 
  void SetMuchMaterialBudgetFileName(const TString&)
  {
    LOG(warning) << "CbmL1::SetMuchMaterialBudgetFileName() is obsolete and will be deleted soon, don't call it\n"
                 << "   !  The material budget files are not used anymore  !";
  }
 
  void SetTrdMaterialBudgetFileName(const TString&)
  {
    LOG(warning) << "CbmL1::SetTrdMaterialBudgetFileName() is obsolete and will be deleted soon, don't call it\n"
                 << "   !  The material budget files are not used anymore  !";
  }
 
  void SetTofMaterialBudgetFileName(const TString&)
  {
    LOG(warning) << "CbmL1::SetTofMaterialBudgetFileName() is obsolete and will be deleted soon, don't call it\n"
                 << "   !  The material budget files are not used anymore  !";
  }
 
 private:
  struct TH1FParameters {
    TString name, title;
    int nbins;
    float xMin, xMax;
  };
 
  void IdealTrackFinder();
 
  void Fill_vMCTracks();
 
  /*
   * Input Performance
   */
 
  template<ca::EDetectorID DetId>
  std::tuple<int, std::vector<int>> MatchHitWithMc(int iHit) const;
 
  void FieldApproxCheck();    // Build histograms with difference between Field map and approximated field
  void FieldIntegralCheck();  // Build 2D histogram: dependence of the field integral on phi and theta
  void TimeHist();
 
  // ********************************
  // ** Reconstruction Performance **
  // ********************************
 
  void SetRandomSeed(unsigned int seed) { fInitManager.SetRandomSeed(seed); }
 
  void EfficienciesPerformance(bool doFinish = kFALSE);
 
  void TrackFitPerformance();
 
  void FillFitHistos(cbm::algo::kf::TrackParamV& tr, const cbm::ca::tools::MCPoint& mc, bool isTimeFitted, TH1F* h[]);
 
  void HistoPerformance();
 
  void DumpMCTripletsToTree();
 
 
  // ** STandAlone Package service-functions **
 
  void DefineSTAPNames(const char* dirName);
 
  void WriteSTAPParamObject();
 
  void WriteSTAPAlgoInputData(int iJob = 0);
 
  void WriteSTAPPerfInputData();
 
  void ReadSTAPParamObject();
 
  void ReadSTAPAlgoInputData(int iJob = 0);
 
  void ReadSTAPPerfInputData();
 
  ca::InitManager* GetInitManager() { return &fInitManager; }
 
  void WriteHistosCurFile(TObject* obj);
 
  static std::istream& eatwhite(std::istream& is);  // skip spaces
  static void writedir2current(TObject* obj);       // help procedure
 
  void DumpMaterialToFile(TString fileName);
 
 private:
  // ***************************
  // ** Member variables list **
  // ***************************
 
  std::string fInputDataFilename           = "";  
  std::string fsInputSearchWindowsFilename = "";  
 
  std::unique_ptr<cbm::ca::TimeSliceReader> fpTSReader = nullptr;  
  std::unique_ptr<cbm::ca::MCModule> fpMCModule        = nullptr;  
  cbm::ca::tools::MCData fMCData;                                  
 
  ca::InitManager fInitManager;                                
  std::shared_ptr<ca::DataManager> fpIODataManager = nullptr;  
 
 public:
  // ** Basic data members **
 
  ca::Framework* fpAlgo = nullptr;  
 
  ca::TrackingMode fTrackingMode = ca::TrackingMode::kSts;  
 
  ca::Vector<CbmL1Track> fvRecoTracks = {"CbmL1::fvRecoTracks"};  
 
 private:
  static CbmL1* fpInstance;  
 
  bool fDoSafeMaterialInitialization{false};  
 
  double fTargetX{1.e10};  
  double fTargetY{1.e10};  
  double fTargetZ{1.e10};  
 
  int fNStations = 0;  
 
  Int_t fPerformance   = 0;   
  double fTrackingTime = 0.;  
 
  int fSTAPDataMode = 4;  
 
  TString fSTAPDataDir    = ".";     
  TString fSTAPDataPrefix = "test";  
  TString fSTAPParamFile  = "";      
 
  static constexpr std::string_view kSTAPParamSuffix = "ca.par";
  static constexpr std::string_view kSTAPSetupSuffix = "kf.setup";
 
  static constexpr std::string_view kSTAPAlgoIDataSuffix = "job%d.ca.input.dat";
 
  static constexpr std::string_view kSTAPAlgoIDataDir = "input_hits";
 
 
  Int_t fTrackingLevel     = 2;    // currently not used
  Double_t fMomentumCutOff = 0.1;  // currently not used
 
  int fEventNo       = 0;  
  int fNofRecoTracks = 0;  
 
 public:
  // ** Repacked input data **
 
  ca::Vector<CbmL1HitId> fvExternalHits = {"CbmL1::fvExternalHits"};  
 
 private:
  ca::Vector<CbmL1HitDebugInfo> fvHitDebugInfo = {
    "CbmL1::fvHitDebugInfo"};  
  // indices of MCPoints in fvMCPoints, indexed by index of hit in algo->vHits array. According to StsMatch. Used for IdealResponce
  //    ca::Vector<int>          vHitMCRef1;
  //   CbmMatch HitMatch;
 
  cbm::ca::DetIdArr_t<std::set<int>> fvmDisabledStationIDs;  
 
  // *****************************
  // ** Tracking performance QA **
  // *****************************
  // TODO: move to a separate class (S.Zharko)
  TFile* fPerfFile{nullptr};
  TDirectory* fHistoDir{nullptr};
  TDirectory* fTableDir{nullptr};
 
  static const int fNTimeHistos = 22;
  TH1F* fTimeHisto[fNTimeHistos]{nullptr};
 
  static const int fNGhostHistos = 9;
  TH1F* fGhostHisto[fNGhostHistos]{nullptr};
 
  TFile* fpMcTripletsOutFile             = nullptr;  
  TTree* fpMcTripletsTree                = nullptr;  
  std::string fsMcTripletsOutputFilename = "";       
 
  int fMatBudgetNbins{100};     
  int fMatBudgetNrays{3};       
  double fMatBudgetPitch{0.1};  
 
  EInitMode fInitMode = EInitMode::Full;  
 
  bool fMatBudgetParallelProjection{false};  
 
  bool fExtrapolateToTheEndOfSTS{false};
 
  std::vector<cbm::algo::kf::MaterialMonitor> fMaterialMonitor{};  
 
  ClassDef(CbmL1, 0);
};
 
 
#endif  //_CbmL1_h_