CbmL1.cxx

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 [committer], Valentina Akishina, Igor Kulakov, Maksym Zyzak, Sergei Zharko */
 
/*
 *====================================================================
 *
 *  CBM Level 1 Reconstruction
 *
 *  Authors: I.Kisel,  S.Gorbunov
 *
 *  e-mail : ikisel@kip.uni-heidelberg.de
 *
 *====================================================================
 *
 *  L1 main program
 *
 *====================================================================
 */
 
#include "CbmL1.h"
 
#include "CaMcHitInfo.h"
#include "CbmKfTarget.h"
#include "CbmMCDataManager.h"
#include "CbmSetup.h"
#include "KfDefs.h"
 
#include <boost/filesystem.hpp>
// TODO: include of CbmSetup.h creates problems on Mac
// #include "CbmSetup.h"
#include "CaFramework.h"
#include "CaHit.h"
#include "CaToolsDebugger.h"
#include "CbmEvent.h"
#include "CbmKfTrackingGeoSetupFactory.h"
#include "CbmMCDataObject.h"
#include "CbmStsFindTracks.h"
#include "CbmStsHit.h"
#include "FairField.h"
#include "FairRunAna.h"
#include "KfRootUtils.h"
#include "KfToolsField.h"
#include "TGeoArb8.h"
#include "TGeoBoolNode.h"
#include "TGeoCompositeShape.h"
#include "TGeoManager.h"
#include "TGeoNode.h"
#include "TMatrixD.h"
#include "TNtuple.h"
#include "TProfile2D.h"
#include "TROOT.h"
#include "TRandom3.h"
#include "TSystem.h"
#include "TVector3.h"
#include "TVectorD.h"
 
#include <TFile.h>
 
#include <chrono>
#include <fstream>
#include <iomanip>
#include <list>
#include <sstream>
 
using namespace cbm::algo;  // TODO: remove this line
 
using CaTrack = cbm::algo::ca::Track;
using cbm::algo::ca::Parameters;
using cbm::algo::kf::EFieldMode;
using cbm::algo::kf::FloatTag;
using cbm::ca::MCModule;
using cbm::ca::TimeSliceReader;
 
 
ClassImp(CbmL1);
 
static ca::Framework gAlgo _fvecalignment;  // TODO: Change coupling logic between ca::Framework and CbmL1
 
CbmL1* CbmL1::fpInstance = nullptr;
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
CbmL1::CbmL1() : CbmL1("L1") {}
 
// ---------------------------------------------------------------------------------------------------------------------
//
CbmL1::CbmL1(const char* name, Int_t verbose, Int_t performance) : FairTask(name, verbose), fPerformance(performance)
{
  if (!fpInstance) fpInstance = this;
 
  switch (fSTAPDataMode) {
    case 1: LOG(info) << "CbmL1: input data will be written for a standalone usage"; break;
    case 2: LOG(info) << "CbmL1: input data will be read from external files"; break;
    default: LOG(info) << "CbmL1: tracking will be run without external data R/W"; break;
  }
 
  fpIODataManager = std::make_shared<ca::DataManager>();
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
CbmL1::~CbmL1()
{
  if (fpInstance == this) fpInstance = nullptr;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::DisableTrackingStation(ca::EDetectorID detID, int iSt)
{
  if (ca::EDetectorID::END != detID) {
    fvmDisabledStationIDs[detID].insert(iSt);
  }
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
InitStatus CbmL1::ReInit()
{
  SetParContainers();
  return Init();
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
InitStatus CbmL1::Init()
try {
  this->DefineSTAPNames();
 
  if (fVerbose > 1) {
    char y[20] = " [0;33;44m";         // yellow
    char Y[20] = " [1;33;44m";         // yellow bold
    char W[20] = " [1;37;44m";         // white bold
    char o[20] = " [0m\n";             // color off
    Y[0] = y[0] = W[0] = o[0] = 0x1B;  // escape character
    std::stringstream ss;
 
    ss << "\n\n";
    ss << "  " << W << "                                                                 " << o;
    ss << "  " << W << "  ===////======================================================  " << o;
    ss << "  " << W << "  =                                                           =  " << o;
    ss << "  " << W << "  =                   " << Y << "L1 on-line finder" << W << "                       =  " << o;
    ss << "  " << W << "  =                                                           =  " << o;
    ss << "  " << W << "  =  " << W << "Cellular Automaton 3.1 Vector" << y << " with " << W << "KF Quadro" << y
       << " technology" << W << "  =  " << o;
    ss << "  " << W << "  =                                                           =  " << o;
    ss << "  " << W << "  =  " << y << "Designed for CBM collaboration" << W << "                           =  " << o;
    ss << "  " << W << "  =  " << y << "All rights reserved" << W << "                                      =  " << o;
    ss << "  " << W << "  =                                                           =  " << o;
    ss << "  " << W << "  ========================================================////=  " << o;
    ss << "  " << W << "                                                                 " << o;
    ss << "\n\n";
 
    LOG(info) << ss.str();
  }
 
  cbm::kf::tools::SetOriginalCbmField();
 
  fHistoDir = gROOT->mkdir("L1");
  fHistoDir->mkdir("Input");
  fHistoDir->mkdir("Fit");
 
  fTableDir = gROOT->mkdir("L1Tables");
 
  // turn on reconstruction in sub-detectors
 
 
  // Create parameters shared pointer in double precision
  // NOTE: for now with interpolated magnetic field, but later it can be changed with a setter
  std::shared_ptr<const ca::Parameters<double>> pParameters{nullptr};
  if (2 == fSTAPDataMode) {  // Read parameters object from a binary file
    TString filename = fSTAPDataDir + "/" + fSTAPDataPrefix + "." + TString(kSTAPParamSuffix.data());
    pParameters =
      std::make_shared<const ca::Parameters<double>>(std::move(ca::ParametersIO::Load<double>(filename.Data())));
  }
  else {  // Create fresh parameters
    auto parBuilder = cbm::ca::ParametersBuilder{};
    parBuilder.SetRequireHitPresence(true);
    std::string mainConfig = std::string(gSystem->Getenv("VMCWORKDIR")) + "/macro/L1/configs/";
    switch (fTrackingMode) {
      case ca::TrackingMode::kSts: mainConfig += "ca_params_sts.yaml"; break;
      case ca::TrackingMode::kMcbm: mainConfig += "ca_params_mcbm.yaml"; break;
      case ca::TrackingMode::kGlobal: mainConfig += "ca_params_global.yaml"; break;
    }
    parBuilder.SetMainConfig(mainConfig);
    parBuilder.SetUserConfig(fsUserConfig);
 
    // Disable stations, if it is required by the framework
    for (auto detId : cbm::ca::kDetIds) {
      const auto& locIds = fvmDisabledStationIDs[detId];
      for (int locId : locIds) {
        parBuilder.DisableStation(detId, locId);
      }
    }
 
    // Explicitly disable MVD, if it is not required from the STSFindTracks task
    if (auto* pTrackFinderTask = dynamic_cast<CbmStsFindTracks*>(FairRunAna::Instance()->GetTask("STSFindTracks"))) {
      if (!pTrackFinderTask->MvdUsage()) {
        parBuilder.DisableStation(EDetectorID::kMvd, -1);
      }
    }
 
    // Build parameters
    pParameters = std::make_shared<const ca::Parameters<double>>(
      std::move(parBuilder.Build(FloatTag<double>{}, EFieldMode::Interpolated)));
 
    // Write parameters object to file if needed
    if (1 == fSTAPDataMode || 4 == fSTAPDataMode) {
      TString filename =
        fSTAPParamFile.IsNull()
          ? fSTAPDataDir + "/" + fSTAPDataPrefix + "." + TString(kSTAPParamSuffix.data())
          : (fSTAPDataDir == "." || fSTAPDataDir == "" ? fSTAPParamFile : fSTAPDataDir + "/" + fSTAPParamFile);
      cbm::algo::ca::ParametersIO::Store(*pParameters, filename.Data());
    }
  }
 
  if (fInitMode == EInitMode::Param) {
    LOG(info) << '\n' << pParameters->ToString(1);
    return kSUCCESS;
  }
 
 
  // Init L1 algo core
 
  // FIXME: SZh 22.08.2023:
  //   Re-organize the the relation between CbmL1 and ca::Framework. I believe, we don't need a global pointer to the ca::Framework
  //   instance.
  fpAlgo = &gAlgo;
 
  //
  // ** Send formed parameters object to ca::Framework instance **
  //
  fpAlgo->ReceiveParameters(std::move(ca::Parameters<fvec>(*pParameters)));
  fpAlgo->Init(fTrackingMode);
 
  cbm::ca::DetIdArr_t<bool> bUsed = {};  // Is detId used
  const auto& rSetup              = pParameters->GetSetup();
  for (auto detId : cbm::ca::kDetIds) {
    bUsed[detId] = rSetup.GetNofActStations(detId) > 0;
  }
 
  // Initialize time-slice reader
  fpTSReader = std::make_unique<TimeSliceReader>();
  for (auto detId : cbm::ca::kDetIds) {
    fpTSReader->SetDetector(detId, bUsed[detId]);
  }
  fpTSReader->RegisterParameters(pParameters);
  fpTSReader->RegisterHitIndexContainer(fvExternalHits);
  fpTSReader->RegisterIODataManager(fpIODataManager);
  fpTSReader->RegisterQaHitContainer(fvHitDebugInfo);
  if (!fpTSReader->InitRun()) {
    return kFATAL;
  }
 
  if (fPerformance) {
    fpMCModule = std::make_unique<MCModule>(fVerbose, fPerformance);
    for (auto detId : cbm::ca::kDetIds) {
      fpMCModule->SetDetector(detId, bUsed[detId]);
    }
 
    fpMCModule->RegisterMcData(fMCData);
    fpMCModule->RegisterRecoTrackContainer(fvRecoTracks);
    fpMCModule->RegisterHitIndexContainer(fvExternalHits);
    fpMCModule->RegisterParameters(pParameters);
    fpMCModule->RegisterQaHitContainer(fvHitDebugInfo);
    fpMCModule->RegisterFirstHitIndexes(fpTSReader->GetHitFirstIndexDet());
    if (!fpMCModule->InitRun()) {
      return kFATAL;
    }
  }
 
  LOG(info) << pParameters->ToString(1);
  LOG(info) << "----- Numbers of stations active in tracking -----";
  LOG(info) << "  MVD:   " << pParameters->GetNstationsActive(ca::EDetectorID::kMvd);
  LOG(info) << "  STS:   " << pParameters->GetNstationsActive(ca::EDetectorID::kSts);
  LOG(info) << "  MuCh:  " << pParameters->GetNstationsActive(ca::EDetectorID::kMuch);
  LOG(info) << "  TRD:   " << pParameters->GetNstationsActive(ca::EDetectorID::kTrd);
  LOG(info) << "  TOF:   " << pParameters->GetNstationsActive(ca::EDetectorID::kTof);
  LOG(info) << "  Total: " << pParameters->GetNstationsActive();
 
  fNStations = pParameters->GetNstationsActive();
 
  // TODO: Probably move from CbmL1 to a more proper place (e.g. kf::Setup)
  {
    //std::stringstream msg;
    //msg << " ----- Material budget map monitoring: active setup -----\n";
    const auto& activeSetup = pParameters->GetActiveSetup();
    for (int iSt = 0; iSt < activeSetup.GetNofLayers(); ++iSt) {
      fMaterialMonitor.emplace_back(&(activeSetup.GetMaterial(iSt)), Form("Station %d", iSt));
      //msg << monitor.ToString() << '\n';
    }
    //msg << " --------------------------------------------------------";
    //LOG(info) << '\n' << msg.str();
  }
 
  DumpMaterialToFile("L1material.root", pParameters);
 
  // Initialize monitor
  fMonitor.Reset();
 
  return kSUCCESS;
}
catch (const std::exception& err) {
  LOG(error) << "CbmL1: initialization failed. Reason: " << err.what();
  return kFATAL;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::Reconstruct(CbmEvent* event)
{
  ca::TrackingMonitorData monitorData;
  LOG(warning) << "CbmL1::Reconstruct called";
  fpTSReader->ReadEvent(event);
  if (fPerformance) {
    fpMCModule->InitEvent(event);  // reads points and MC tracks
    fpMCModule->MatchHits();       // matches points with hits
    fpMCModule->InitMcTrackInfo();
    fpAlgo->SetMcData(fpMCModule->GetMcData());
  }
 
  fpAlgo->ReceiveInputData(fpIODataManager->TakeInputData());
  LOG(warning) << "CbmL1::Reconstruct: after ReceiveInputData";
  //LOG(warning) << "CbmL1::Reconstruct: input data received, hits = " << fpAlgo->GetInputData().GetNofHits();
  // Material monitoring: mark active areas
  {
    for (const auto& hit : fpAlgo->GetInputData().GetHits()) {
      fMaterialMonitor[hit.Station()].MarkActiveBin(hit.X(), hit.Y());
    }
  }
  //LOG(info) << "CHECK: hit ids = " << fvExternalHits.size() << ", hits = " << fpIODataManager->GetNofHits()
  //<< ", dbg hits = " << fvHitDebugInfo.size();
 
  fpAlgo->SetMonitorData(monitorData);
 
  if (nullptr != event) {
    LOG_IF(debug, fVerbose > 0) << "\n=======  Ca Track finder: processing event " << event->GetNumber() << " ...";
  }
  else {
    LOG_IF(debug, fVerbose > 0) << "\n=======  Ca Track finder: processing timeslice ...";
  }
  LOG(warning) << "CbmL1::Reconstruct: before FindTracks";
  fpAlgo->FindTracks();
  LOG(warning) << "CbmL1::Reconstruct: after FindTracks";
  //       IdealTrackFinder();
  fTrackingTime = fpAlgo->fCaRecoTime;  // TODO: remove (not used)
 
  LOG_IF(debug, fVerbose > 0) << "Ca Track Finder finished, found " << fpAlgo->fRecoTracks.size() << " tracks";
 
  // Update monitor data after the actual tracking
  monitorData = fpAlgo->GetMonitorData();
 
  // save reconstructed tracks
 
  fvRecoTracks.clear();
  fvRecoTracks.reserve(fpAlgo->fRecoTracks.size());
 
  int trackFirstHit = 0;
 
  // FIXME: Rewrite
  for (const auto& caTrk : fpAlgo->fRecoTracks) {
    CbmL1Track t;
    t.Set(caTrk.fParFirst);
    t.TLast.Set(caTrk.fParLast);
    t.Tpv.Set(caTrk.fParPV);
    t.Hits.clear();
 
    for (int i = 0; i < caTrk.fNofHits; i++) {
      int caHitId  = fpAlgo->fRecoHits[trackFirstHit + i];
      int cbmHitID = fpAlgo->GetInputData().GetHit(caHitId).Id();
      t.Hits.push_back(cbmHitID);
    }
    fvRecoTracks.push_back(t);
    trackFirstHit += caTrk.fNofHits;
    //fMonitor.IncrementCounter(EMonitorKey::kRecoHit, it->fNofHits);
  }
 
  //fMonitor.IncrementCounter(EMonitorKey::kRecoTrack, fvRecoTracks.size());
  LOG(warning) << "CA Track Finder: " << fpAlgo->fCaRecoTime << " s/sub-ts";
 
  // output performance
  if (fPerformance) {
    LOG_IF(info, fVerbose) << "Performance...";
 
    fpMCModule->MatchTracks();  // matches reco and MC tracks, fills the MC-truth fields of reco tracks
 
    //
    // tracker input performance is moved to external QA tasks.
    // InputPerformance() method is not optimised to run with the event builder
    // TODO: verify QA tasks and remove InputPerformance()
    // InputPerformance();
    //
 
 
    EfficienciesPerformance();
    HistoPerformance();
    TrackFitPerformance();
    if (fsMcTripletsOutputFilename.size()) {
      DumpMCTripletsToTree();
    }
    // TimeHist();
    LOG_IF(info, fVerbose > 1) << "Tracking performance... done";
  }
  LOG(warning) << "End of CA";
 
  ++fEventNo;
  fMonitor.AddMonitorData(monitorData);
}
 
// -----   Finish CbmStsFitPerformanceTask task   -----------------------------
void CbmL1::Finish()
{
  if (fPerformance) {
    // FieldApproxCheck();
    // FieldIntegralCheck();
    EfficienciesPerformance(kTRUE);
  }
 
  {
    // monitor the material
    std::stringstream msg;
    msg << '\n';
    msg << "\033[31;1m ***************************\033[0m\n";
    msg << "\033[31;1m **  CA Tracking monitor  **\033[0m\n";
    msg << "\033[31;1m ***************************\033[0m\n";
 
    // TODO: Probably move from CbmL1 to a more proper place (e.g. kf::Setup)
    {
      msg << '\n';
      msg << " ----- Material budget map monitoring: active setup -----\n";
      for (auto& monitor : fMaterialMonitor) {
        msg << monitor.ToString() << '\n';
      }
      msg << " --------------------------------------------------------\n";
    }
 
    // monitor of the reconstructed tracks
    msg << '\n' << fMonitor.ToString();
    LOG(info) << msg.str();
  }
 
  TDirectory* curr   = gDirectory;
  TFile* currentFile = gFile;
 
 
  // Open output file and write histograms
  boost::filesystem::path p = (FairRunAna::Instance()->GetUserOutputFileName()).Data();
  std::string dir           = p.parent_path().string();
  if (dir.empty()) dir = ".";
  {
    std::string histoOutName = dir + "/L1_histo_" + p.filename().string();
    LOG(info) << "\033[31;1mL1 performance histograms will be saved to: \033[0m" << histoOutName;
    TFile* outfile = new TFile(histoOutName.c_str(), "RECREATE");
    outfile->cd();
    writedir2current(fHistoDir);
    outfile->Close();
    outfile->Delete();
  }
  {
    std::string tablesOutName = dir + "/L1_perftable_" + p.filename().string();
    LOG(info) << "\033[31;1mL1 performance tables will be saved to: \033[0m" << tablesOutName;
    TFile* outfile = new TFile(tablesOutName.c_str(), "RECREATE");
    outfile->cd();
    writedir2current(fTableDir);
    outfile->Close();
    outfile->Delete();
  }
 
  if (fpMcTripletsOutFile) {
    fpMcTripletsOutFile->cd();
    fpMcTripletsTree->Write();
    fpMcTripletsOutFile->Close();
    fpMcTripletsOutFile->Delete();
  }
 
  gFile      = currentFile;
  gDirectory = curr;
  fpAlgo->Finish();
  cbm::ca::tools::Debugger::Instance().Write();
}
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::writedir2current(TObject* obj)
{
  if (!obj->IsFolder())
    obj->Write();
  else {
    TDirectory* cur = gDirectory;
    TDirectory* sub = cur->mkdir(obj->GetName());
    sub->cd();
    TList* listSub = (dynamic_cast<TDirectory*>(obj))->GetList();
    TIter it(listSub);
    while (TObject* obj1 = it())
      writedir2current(obj1);
    cur->cd();
  }
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::IdealTrackFinder()
{
  fpAlgo->fRecoTracks.clear();
  fpAlgo->fRecoHits.clear();
 
  for (auto& MC : fMCData.GetTrackContainer()) {
    if (!MC.IsReconstructable()) continue;
    if (!(MC.GetId() >= 0)) continue;
 
    if (MC.GetNofHits() < 4) continue;
 
    CaTrack algoTr;
    algoTr.fNofHits = 0;
 
    ca::Vector<int> hitIndices("CbmL1::hitIndices", fpAlgo->GetParameters().GetNstationsActive(), -1);
 
    for (unsigned int iH : MC.GetHitIndexes()) {
      const cbm::algo::ca::McHitInfo& hit = fvHitDebugInfo[iH];
      const int iStation                  = hit.GetStationId();
      if (iStation >= 0) hitIndices[iStation] = iH;
    }
 
 
    for (int iH = 0; iH < fpAlgo->GetParameters().GetNstationsActive(); iH++) {
      const int hitI = hitIndices[iH];
      if (hitI < 0) continue;
 
      // fpAlgo->fRecoHits.push_back(hitI);
      algoTr.fNofHits++;
    }
 
 
    if (algoTr.fNofHits < 3) continue;
 
    for (int iH = 0; iH < fpAlgo->GetParameters().GetNstationsActive(); iH++) {
      const int hitI = hitIndices[iH];
      if (hitI < 0) continue;
      fpAlgo->fRecoHits.push_back(hitI);
    }
 
    algoTr.fParFirst.X()    = MC.GetStartX();
    algoTr.fParFirst.Y()    = MC.GetStartY();
    algoTr.fParFirst.Z()    = MC.GetStartZ();
    algoTr.fParFirst.Tx()   = MC.GetTx();
    algoTr.fParFirst.Ty()   = MC.GetTy();
    algoTr.fParFirst.Qp()   = MC.GetCharge() / MC.GetP();
    algoTr.fParFirst.Time() = MC.GetStartT();
    fpAlgo->fRecoTracks.push_back(algoTr);
  }
}  // void CbmL1::IdealTrackFinder()
 

 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::DefineSTAPNames()
{
  // FIXME: SZh 01.03.2023: Clean STAP names
  namespace bfs = boost::filesystem;
 
  if (fSTAPDataMode == 0) {
    return;
  }
 
  // Define file prefix (/path/to/data/setup.reco.root -> "setup.reco")
  bfs::path pathToRecoOutput = FairRunAna::Instance()->GetUserOutputFileName().Data();
  fSTAPDataPrefix            = pathToRecoOutput.filename().string();
  fSTAPDataPrefix.ReplaceAll(".root", "");
  fSTAPDataPrefix = fSTAPDataPrefix.Strip(TString::EStripType::kBoth, '.');
 
  if (fSTAPDataDir.Length() == 0) {
    fSTAPDataDir = pathToRecoOutput.parent_path().string();
  }
  else if (!bfs::exists(fSTAPDataDir.Data()) || !bfs::is_directory(fSTAPDataDir.Data())) {
    fSTAPDataDir = ".";
  }
 
  // TODO: Clean-up the names and pathes
  if (fSTAPDataDir.Length() == 0) {
    fSTAPDataDir = ".";
  }
 
  LOG(info) << "CbmL1: STAP data root directory is \033[1;32m" << bfs::system_complete(fSTAPDataDir.Data())
            << "\033[0m";
 
  if (fSTAPDataMode == 4) {
    return;
  }
 
  // Directory for handling L1InputData objects
  TString sInputDataDir = fSTAPDataDir + "/" + fSTAPDataPrefix + "_cainputdata";
  if (!bfs::exists(sInputDataDir.Data())) {
    LOG(warn) << "CbmL1: directory for tracking input data does not exist. It will be created";
    bfs::create_directories(sInputDataDir.Data());
  }
  LOG(info) << "CbmL1: STAP tracking input jobs directory is \033[1;32m" << bfs::system_complete(sInputDataDir.Data())
            << "\033[0m";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::WriteSTAPAlgoInputData(int iJob)  // must be called after ReadEvent
{
  TString filename =
    fSTAPDataDir + "/" + fSTAPDataPrefix + "_cainputdata/" + +TString::Format(kSTAPAlgoIDataSuffix.data(), iJob);
 
  // Write file
  fpIODataManager->WriteInputData(filename.Data());
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::WriteSTAPPerfInputData()  // must be called after ReadEvent
{
  LOG(fatal) << "CbmL1: Running in standalone mode is not available at the moment. It will be updated soon...";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::ReadSTAPAlgoInputData(int iJob)
{
  TString filename = fSTAPDataDir + "/" + TString(kSTAPAlgoIDataDir) + "/" + fSTAPDataPrefix + "."
                     + TString::Format(kSTAPAlgoIDataSuffix.data(), iJob);
 
  // Read file
  fpIODataManager->ReadInputData(filename.Data());
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::ReadSTAPPerfInputData()
{
  LOG(fatal) << "CbmL1: Running in standalone mode is not available at the moment. It will be updated soon...";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmL1::DumpMaterialToFile(TString fileName, std::shared_ptr<const ca::Parameters<double>> par)
{
  auto* currentFile = gFile;
  TFile f           = TFile{fileName, "RECREATE"};
  f.cd();
  // TODO: (!) replace CbmL1::Instance()->fpAlgo->GetParameters() with the cbm::ca::ParametersHandler::Instance()->Get()
  //           everywhere outside cbm::algo
  const auto& activeTrackingSetup = par->GetActiveSetup();
  for (int iSt = 0; iSt < activeTrackingSetup.GetNofLayers(); ++iSt) {
    const auto& material = activeTrackingSetup.GetMaterial(iSt);
    TString name         = Form("tracking_station%d", iSt);
    TString title        = Form("Tracking station %d: Rad. thickness in %%. Z region [%.2f, %.2f] cm.", iSt,
                         material.GetZmin(), material.GetZmax());
    if (fMatBudgetParallelProjection) {
      title += " Horizontal projection.";
    }
    else {
      title += " Radial projection.";
    }
    auto* h = ::kf::tools::RootUtils::ToHistogram(material, name, title);
    h->SetStats(kFALSE);
    h->SetDirectory(&f);
  }
  f.Write();
  currentFile->cd();
}