CbmL1.h

Go to the documentation of this file.

/* Copyright (C) 2006-2025 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 "CaMcData.h"
#include "CaMonitor.h"
#include "CaVector.h"
#include "CbmCaMCModule.h"
#include "CbmCaParametersBuilder.h"
#include "CbmCaTimeSliceReader.h"
#include "CbmL1DetectorID.h"
#include "CbmL1HitId.h"
#include "CbmL1Track.h"
#include "KfMaterialMonitor.h"
#include "KfTrackParam.h"
 
#include <FairDetector.h>
#include <FairRootManager.h>
#include <FairTask.h>
#include <Logger.h>
 
#include <TClonesArray.h>
#include <TH1.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 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 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::algo::ca::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) { fsUserConfig = path; }

  void SetParameterFilename(const char* filename) { fSTAPParamFile = TString(filename); }

  void SetSetupFilename(const char* filename) { fSTAPSetupFile = TString(filename); }

  void SetOutputDataDir(const char* dirname) { fSTAPDataDir = TString(dirname); }

  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)
  {
    LOG(warn) << "CbmL1::SetRandomSeed(unsigned int) does nothing! Please, remove it from your caller";
  }

  void EfficienciesPerformance(bool doFinish = kFALSE);

  void TrackFitPerformance();
 
  void FillFitHistos(cbm::algo::kf::TrackParamV& tr, const cbm::algo::ca::McPoint& mc, bool isTimeFitted, TH1F* h[]);

  void HistoPerformance();

  void DumpMCTripletsToTree();
 
 
  // ** STandAlone Package service-functions **

  void DefineSTAPNames();

  void WriteSTAPParamObject();

  void WriteSTAPAlgoInputData(int iJob = 0);
 
  void WriteSTAPPerfInputData();

  void ReadSTAPParamObject();
 
  void ReadSTAPAlgoInputData(int iJob = 0);
 
  void ReadSTAPPerfInputData();
 
  void WriteHistosCurFile(TObject* obj);
 
  static std::istream& eatwhite(std::istream& is);  // skip spaces
  static void writedir2current(TObject* obj);       // help procedure
 
  void DumpMaterialToFile(TString fileName, std::shared_ptr<const cbm::algo::ca::Parameters<double>> par);
 
 private:
  // ***************************
  // ** Member variables list **
  // ***************************
 
  std::string fInputDataFilename{};  
  std::string fsUserConfig{};        
 
  std::unique_ptr<cbm::ca::TimeSliceReader> fpTSReader = nullptr;  
  std::unique_ptr<cbm::ca::MCModule> fpMCModule        = nullptr;  
  cbm::algo::ca::McData fMCData;                                   
 
  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};  
 
  // TODO: remove
  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  = "";      
  TString fSTAPSetupFile  = "";      

  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<cbm::algo::ca::McHitInfo> fvHitDebugInfo = {
    "CbmL1::fvMcHitDebugInfo"};  
  // 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_