CbmTrdRecoSetupUnitFactory.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#include "CbmTrdRecoSetupUnitFactory.h"
 
#include "CbmGeoHelper.h"
#include "CbmRecoSetupUtils.h"
#include "CbmTrdParModDigi.h"
#include "CbmTrdParSetDigi.h"
 
#include <FairRunAna.h>
#include <FairRuntimeDb.h>
#include <Logger.h>
 
#include <TGeoManager.h>
#include <TString.h>
 
#include <limits>
#include <regex>
#include <set>
#include <sstream>
#include <utility>
 
 
using cbm::algo::GeoVolume;
using cbm::algo::trd::RecoSetupUnit;
using cbm::trd::RecoSetupUnitFactory;
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::RecoSetupUnitFactory()
try {
  //* Get the TOF digi parameters
  // NOTE: add a task CbmTofCreateDigiPar, if the parameters appear to be corrupted. But in the use-cases of the
  //       builder it should not be so.
  auto* runtimeDb = FairRunAna::Instance()->GetRuntimeDb();
  if (!runtimeDb) {
    throw std::runtime_error("the runtime database is not defined");
  }
  fTrdDigiPar = dynamic_cast<CbmTrdParSetDigi*>(runtimeDb->getContainer("CbmTrdParSetDigi"));
}
catch (const std::exception& err) {
  LOG(fatal) << "trd::RecoSetupUnitFactory cannot be constructed, because " << err.what() << ". Please ensure, if the "
             << "required parameters are defined before the point of the sts::RecoSetupUnitFactory object construction";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnit RecoSetupUnitFactory::Create() const
{
  RecoSetupUnit res{CreateStationVolumes(), CreateModuleMap()};
  if (!res.IsValid()) {
    LOG(fatal) << "trd::RecoSetupUnitFactory: creation of a valid TRD reco-setup unit failed";
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::ModuleInfoMap_t RecoSetupUnitFactory::CreateModuleMap() const
{
  ModuleInfoMap_t res;
 
  //* 1st loop: calculate total number of layers, check the assumption about the same number of modules in a layer
  auto& nModulesPerLayer = res.second;
  {
    std::unordered_map<int, uint32_t> nModulesInLayer;
    for (int iModule = 0; iModule < fTrdDigiPar->GetNrOfModules(); ++iModule) {
      ++nModulesInLayer[CbmTrdAddress::GetLayerId(fTrdDigiPar->GetModuleId(iModule))];
    }
    nModulesPerLayer = nModulesInLayer.begin()->second;
    if (std::any_of(nModulesInLayer.begin(), nModulesInLayer.end(),
                    [nModulesPerLayer](const auto& entry) -> bool { return entry.second != nModulesPerLayer; })) {
      LOG(fatal) << "trd::RecoSetupUnitFactory: TRD layers have different number of modules (assumption failure)";
    }
  }
 
  //* 2nd loop: Collect module info
  auto& modules = res.first;
  modules.resize(fTrdDigiPar->GetNrOfModules());
 
  for (int iModule = 0; iModule < fTrdDigiPar->GetNrOfModules(); ++iModule) {
    uint32_t address = fTrdDigiPar->GetModuleId(iModule);
    if (const auto* pDigiPar = dynamic_cast<const CbmTrdParModDigi*>(fTrdDigiPar->GetModulePar(address))) {
      uint32_t moduleId = CbmTrdAddress::GetModuleId(address);
      uint32_t layerId  = CbmTrdAddress::GetLayerId(address);
      modules[layerId * nModulesPerLayer + moduleId] =
        RecoSetupUnit_t::ModuleInfo{pDigiPar->GetOrientation(), pDigiPar->GetPadPlaneType()};
    }
    else {
      LOG(fatal) << "trd::RecoSetupUnitFactory: undefined digi parameters for module 0x" << std::hex << address;
    }
  }
 
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> RecoSetupUnitFactory::CreateStationVolumes() const
{
  auto vLayerPaths{GeoHelper::CollectNodes("trd", std::regex{"layer"}, "", gGeoManager->GetTopNode())};
  std::vector<GeoVolume> fullVolumes(vLayerPaths.size());
  std::vector<GeoVolume> activeVolumes(vLayerPaths.size());
  std::regex stationPattern{"layer(\\d+)_(\\d+)"};
  for (const auto& layerPath : vLayerPaths) {
    std::smatch match;
    std::string line{layerPath.Data()};
    if (std::regex_search(line, match, stationPattern)) {
      int iStation{std::stoi(match[1]) - 1};  // the tracking station is a TRD layer
      fullVolumes[iStation] = RecoSetupUtils::ReadVolume(layerPath);
      gGeoManager->cd(layerPath);
      auto vGasPaths{GeoHelper::CollectNodes("trd", std::regex{"gas"}, layerPath(0, layerPath.Last('/')),
                                             gGeoManager->GetCurrentNode())};
      for (const auto& gasPath : vGasPaths) {
        activeVolumes[iStation] += RecoSetupUtils::ReadVolume(gasPath);
      }
    }
  }
  return {std::move(fullVolumes), std::move(activeVolumes)};
}