KfModuleIndexMap.h

Go to the documentation of this file.

/* Copyright (C) 2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#pragma once
 
#include "KfDefs.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/utility.hpp>
 
#include <set>
#include <sstream>
#include <string>
#include <vector>
 
#include <fmt/format.h>
 
namespace cbm::algo::kf
{
 
  class alignas(VcMemAlign) ModuleIndexMap {
    friend class ModuleIndexMapFactory;
    friend class boost::serialization::access;
 
   public:
    int GetNofLayers() const { return fvGlbToLoc.size(); }
 
    template<class EDetID = int>
    std::pair<EDetID, int> GlobalToLocal(int globId) const;
 
    template<class EDetID>
    int LocalToGlobal(EDetID detId, int locId) const
    {
      return fvLocToGlb[fvDetLocOffset[fvDetExtToInt[static_cast<int>(detId)]] + locId];
    }
 
    template<class EDetID>
    void Disable(EDetID detId, int locId);
 
    void Reset();
 
    std::string ToString(int indentLevel = 0) const;
 
   private:
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fvLocToGlb;
      ar& fvGlbToLoc;
      ar& fvDetLocOffset;
      ar& fvDetIntToExt;
      ar& fvDetExtToInt;
    }
 
    std::vector<int> fvLocToGlb{};
    std::vector<std::pair<int, int>> fvGlbToLoc{};
    std::vector<int> fvDetLocOffset{};  
    std::vector<int> fvDetIntToExt{};   
    std::vector<int> fvDetExtToInt{};   
  };
 
  class ModuleIndexMapFactory {
    struct Component {
      Component(int detId, int locId, double z) : fZ(z), fLocId(locId), fDetId(detId) {}
      double fZ;   
      int fLocId;  
      int fDetId;  
      bool operator<(const Component& rhs) const { return fZ < rhs.fZ; }
    };
 
   public:
    template<class EDetID>
    void AddComponent(EDetID detId, int locId, double z);
 
    ModuleIndexMap MakeIndexMap() const;
 
    void Reset();
 
   private:
    std::set<Component> fvComponentLayers;
  };
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class EDetID>
  void ModuleIndexMap::Disable(EDetID detIdDisable, int locIdDisable)
  {
    // Check, if the detector id is there
    auto iDetIntDsbl{fvDetExtToInt[static_cast<int>(detIdDisable)]};
    if (iDetIntDsbl >= static_cast<int>(fvDetIntToExt.size())) {
      return;  // Nothing to disable, detector is already not in the map
    }
 
    auto& iGlbDsbl = fvLocToGlb[fvDetLocOffset[iDetIntDsbl] + locIdDisable];
    if (iGlbDsbl < 0) {
      return;  // Nothing to disable, component is already inactive
    }
 
    fvGlbToLoc.erase(fvGlbToLoc.begin() + iGlbDsbl);  // Removing component from glob->(det, loc) map
    for (auto& val : fvLocToGlb) {
      if (val > iGlbDsbl) {
        --val;
      }
    }
    iGlbDsbl = -1;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class EDetID>
  inline std::pair<EDetID, int> ModuleIndexMap::GlobalToLocal(int globId) const
  {
    const auto& [iDetExt, iLoc] = fvGlbToLoc[globId];
    return std::pair(static_cast<EDetID>(iDetExt), iLoc);
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class EDetID>
  void ModuleIndexMapFactory::AddComponent(EDetID detId, int locId, double z)
  {
    if (!fvComponentLayers.emplace(static_cast<int>(detId), locId, z).second) {
      std::stringstream msg;
      msg << "ModuleIndexMapFactory: attempt of adding a duplicating component with z = " << z
          << ", detID = " << static_cast<int>(detId) << " and locId = " << locId
          << ".\n The next components were already added:";
      for (const auto& c : fvComponentLayers) {
        msg << "\n\t- {z, detId, locId} = {" << c.fZ << ", " << c.fDetId << ", " << c.fLocId << "}";
      }
      throw std::logic_error(msg.str());
    }
  }
 
 
}  // namespace cbm::algo::kf