CbmTofRecoSetupUnitFactory.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 "CbmTofRecoSetupUnitFactory.h"
 
#include "CbmGeoHelper.h"
#include "CbmRecoSetupUtils.h"
#include "CbmTofDigiBdfPar.h"
 
#include <FairRunAna.h>
#include <FairRuntimeDb.h>
#include <Logger.h>
 
#include <TGeoManager.h>
#include <TString.h>
 
#include <iomanip>
#include <limits>
#include <regex>
#include <set>
#include <sstream>
#include <unordered_set>
#include <utility>
 
using cbm::algo::GeoVolume;
using cbm::algo::tof::RecoSetupUnit;
using cbm::tof::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");
  }
 
  fDigiBdfPar = dynamic_cast<CbmTofDigiBdfPar*>(runtimeDb->getContainer("CbmTofDigiBdfPar"));
  if (!fDigiBdfPar) {
    throw std::runtime_error("TOF Digi BDF par. instance was not found in the runtime database");
  }
 
  if (fDigiBdfPar->GetNbSmTypes() == 0) {
    throw std::runtime_error("TOF Digi BDF par. instance was not initialized (NbSmTypes = 0)");
  }
}
catch (const std::exception& err) {
  LOG(fatal) << "tof::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(), CreateStationIdMap()};
  if (!res.IsValid()) {
    LOG(fatal) << "tof::RecoSetupUnitFactory: creation of a valid TOF reco-setup unit failed";
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::TrkStationIdMap_t RecoSetupUnitFactory::CreateStationIdMap() const
{
  using SmTypeInfo_t = algo::tof::TrkStationIdMap::SmTypeInfo;
 
  // 1. Fill the smTypeRpcMap
  std::vector<SmTypeInfo_t> smTypeRpcMap(fDigiBdfPar->GetNbSmTypes());
  uint16_t nRpcTot = 0;
  for (uint16_t iSmType = 0; iSmType < smTypeRpcMap.size(); ++iSmType) {
    auto& smt = smTypeRpcMap[iSmType];
    smt.nSm   = fDigiBdfPar->GetNbSm(iSmType);
    smt.nRpc  = fDigiBdfPar->GetNbRpc(iSmType);
    nRpcTot += smt.nSm * smt.nRpc;
  }
 
  // 2. Fill the offsets in smTypeRpcMap
  for (uint16_t iSmtThis = 0, iSmtNext = iSmtThis + 1; iSmtNext < smTypeRpcMap.size(); ++iSmtThis, ++iSmtNext) {
    const auto smtThis{smTypeRpcMap[iSmtThis]};
    smTypeRpcMap[iSmtNext].offset = smtThis.offset + smtThis.nSm * smtThis.nRpc;
  }
 
  // 3. Fill the tracking staiton indices
  // NOTE: it is important to nest the loop in this direction: iSmType -> iSm -> iRpc!
  std::vector<int> trkStationId;
  trkStationId.reserve(nRpcTot);
  for (uint16_t iSmType = 0; iSmType < smTypeRpcMap.size(); ++iSmType) {
    const auto smt{smTypeRpcMap[iSmType]};
    for (uint16_t iSm = 0; iSm < smt.nSm; ++iSm) {
      for (uint16_t iRpc = 0; iRpc < smt.nRpc; ++iRpc) {
        trkStationId.push_back(fDigiBdfPar->GetTrackingStation(iSmType, iSm, iRpc));
      }
    }
  }
 
  return algo::tof::TrkStationIdMap(std::move(smTypeRpcMap), std::move(trkStationId));
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> RecoSetupUnitFactory::CreateStationVolumes() const
{
  int nStations = fDigiBdfPar->GetNbTrackingStations();
  if (nStations == 0) {
    return {};
  }
 
  std::vector<algo::GeoVolume> fullVolumes(nStations);
  std::vector<algo::GeoVolume> activeVolumes(nStations);
  auto vRpcPaths{GeoHelper::CollectNodes("tof", std::regex{"counter"}, "", gGeoManager->GetTopNode())};
  std::regex rpcPattern{"module_(\\d+)_(\\d+)/gas_box_(\\d+)/counter_(\\d+)"};
 
  for (const auto& rpcPath : vRpcPaths) {
    std::smatch match;
    std::string line{rpcPath.Data()};
    if (std::regex_search(line, match, rpcPattern)) {
      int iSmType{std::stoi(match[1])};
      int iSm{std::stoi(match[2])};
      int iRpc{std::stoi(match[4])};
      int iStation{fDigiBdfPar->GetTrackingStation(iSmType, iSm, iRpc)};
      if (iStation > -1) {
        auto rpcVol = RecoSetupUtils::ReadVolume(rpcPath);  // Adding RPC as a passive volume
        fullVolumes[iStation] += rpcVol;                    // Adding RPC as a passive volume
        gGeoManager->cd(rpcPath);
        auto vCellPaths{GeoHelper::CollectNodes("tof", std::regex{"Cell_(\\d+)"}, rpcPath(0, rpcPath.Last('/')),
                                                gGeoManager->GetCurrentNode())};
        if (vCellPaths.empty()) {
          throw std::runtime_error("Could not find nodes containing \"Cell\" in their paths");
        }
 
        for (const auto& cellPath : vCellPaths) {
          activeVolumes[iStation] += RecoSetupUtils::ReadVolume(cellPath);
        }
      }
    }
  }
 
  return {std::move(fullVolumes), std::move(activeVolumes)};
}