CbmStsRecoSetupUnitFactory.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 "CbmStsRecoSetupUnitFactory.h"
 
#include "CbmStsParSetModule.h"
#include "CbmStsParSetSensor.h"
#include "CbmStsParSetSensorCond.h"
#include "CbmStsSetup.h"
#include "CbmStsStation.h"
#include "algo/setup/RecoSetupHeader.h"
 
#include <FairRunAna.h>
#include <FairRuntimeDb.h>
#include <Logger.h>
 
#include <TGeoManager.h>
#include <TString.h>
 
#include <set>
#include <sstream>
#include <utility>
 
using cbm::algo::GeoVolume;
using cbm::algo::sts::RecoSetupUnit;
using cbm::sts::RecoSetupUnitFactory;
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::RecoSetupUnitFactory()
try {
  auto* stsSetup = CbmStsSetup::Instance();
  if (!stsSetup->IsInit()) {
    stsSetup->Init(nullptr);
  }
}
catch (const std::exception& err) {
  LOG(fatal) << "sts::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) << "sts::RecoSetupUnitFactory: creation of a valid STS reco-setup unit failed";
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::StationIdMap_t RecoSetupUnitFactory::CreateStationIdMap() const
{
  StationIdMap_t res;
 
  auto* stsSetup = CbmStsSetup::Instance();
 
  // Fill a set of (stationId, ladderId) pairs, corresponding to a given unit
  std::vector<std::set<std::pair<int, uint32_t>>> units(stsSetup->GetNofDaughters());
  for (int iSt = 0; iSt < stsSetup->GetNofStations(); ++iSt) {
    CbmStsStation* station = stsSetup->GetStation(iSt);
    for (int iLadder = 0; iLadder < station->GetNofLadders(); ++iLadder) {
      const CbmStsElement* ladder = station->GetLadder(iLadder);
      units[ladder->GetMother()->GetIndex()].insert({iSt, ladder->GetIndex()});
    }
  }
 
  // Fill the stationId map
  res.resize(units.size(), std::pair{std::numeric_limits<uint32_t>::max(), -1});
  for (size_t iUnit = 0; iUnit < units.size(); ++iUnit) {
    const auto& unit = units[iUnit];
    if (!unit.size()) continue;  // formally
 
    auto& stationIdMapElement  = res[iUnit];
    stationIdMapElement.second = (*unit.begin()).first;
    int curStationId           = stationIdMapElement.second;
    for (const auto& [stationId, ladderId] : unit) {
      if (stationId != curStationId) {
        stationIdMapElement.first = ladderId;
        curStationId              = stationId;
      }
    }
 
    // A difference between the minimal and maximal station ID within a unit. It reflects the convention,
    // that ladders are sorted in a unit by a station ID, and there are can be no more then two units attached
    // to a single station, so the valid values are either 0 or 1.
    int diffStationId = curStationId - stationIdMapElement.second;
    if (diffStationId != 0 && diffStationId != 1) {
      std::stringstream msg;
      msg << "Failed to build a map of STS address to STS station index for unitId=" << iUnit << ". "
          << "The convention for distribution ladders over units was corrupted, and the current mapping"
          << "scheme cannot be initialized. "
          << "NOTE: the current map implementation relies on the next points:\n"
          << " (1) ladders on a unit are attached to a single or two neighboring stations;\n"
          << " (2) ladders within a unit are ordered in stationId\n"
          << "Ladders, attached to the unitId=" << iUnit << " : ";
      for (const auto& p : units[iUnit]) {
        msg << "(stationId=" << p.first << ", ladderId=" << p.second << ")";
      }
      throw std::logic_error(msg.str());
    }
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> RecoSetupUnitFactory::CreateStationVolumes() const
{
  auto* stsSetup = CbmStsSetup::Instance();
  int nStations  = stsSetup->GetNofStations();
  std::vector<GeoVolume> fullVolumes;
  fullVolumes.reserve(nStations);
  for (int iSt = 0; iSt < nStations; ++iSt) {
    const auto* pStation{stsSetup->GetStation(iSt)};
    fullVolumes.emplace_back(pStation->GetXmin(), pStation->GetXmax(), pStation->GetYmin(), pStation->GetYmax(),
                             pStation->GetZmin(), pStation->GetZmax());
  }
 
  std::vector<GeoVolume> activeVolumes = fullVolumes;
  return {std::move(fullVolumes), std::move(activeVolumes)};
}