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
{
  // TODO: Account for undefined detId and locId

  class alignas(VcMemAlign) ModuleIndexMap {
    friend class ModuleIndexMapFactory;
    friend class boost::serialization::access;
 
   public:
    int GetNofLayers() const { return fvGlbToLoc.size(); }

    template<class EDetId>
    int GetNofLayers(EDetId detId) const
    {
      int iDet = GetIntDetIndex(detId);
      return iDet > -1 ? fvNofLayersIntDet[iDet] : 0;
    }

    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 EDetId>
    int GetIntDetIndex(EDetId detId) const
    {
      return static_cast<size_t>(detId) < fvDetExtToInt.size() ? fvDetExtToInt[static_cast<int>(detId)] : -1;
    }
 
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fvLocToGlb;
      ar& fvGlbToLoc;
      ar& fvDetLocOffset;
      ar& fvDetIntToExt;
      ar& fvDetExtToInt;
      ar& fvNofLayersIntDet;
    }
 
    std::vector<int> fvLocToGlb{};
    std::vector<std::pair<int, int>> fvGlbToLoc{};
    std::vector<int> fvDetLocOffset{};     
    std::vector<int> fvDetIntToExt{};      
    std::vector<int> fvDetExtToInt{};      
    std::vector<int> fvNofLayersIntDet{};  
  };

  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;
    --fvNofLayersIntDet[iDetIntDsbl];
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  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