CaToolsMCData.h

Go to the documentation of this file.

/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#ifndef CaToolsMCData_h
#define CaToolsMCData_h 1
 
#include "CaSimd.h"
#include "CaToolsDef.h"
#include "CaToolsLinkKey.h"
#include "CaToolsMCPoint.h"
#include "CaToolsMCTrack.h"
#include "CaVector.h"
 
#include <numeric>
#include <string>
#include <unordered_map>
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
}
 
using namespace cbm::algo::ca;  //TODO: remove
 
namespace cbm::ca::tools
{
  class MCData {
   public:
    // *********************************
    // ** Constructors and destructor **
    // *********************************
 
    MCData();
 
    ~MCData() = default;
 
    MCData(const MCData& other);
 
    MCData(MCData&& other) noexcept;
 
    MCData& operator=(const MCData& other);
 
    MCData& operator=(MCData&& other) noexcept;
 
    void Swap(MCData& other) noexcept;
 
    void AddPoint(const MCPoint& point);
 
    void AddTrack(const MCTrack& track);
 
    void Clear();
 
    int FindInternalPointIndex(ca::EDetectorID detID, int index, int event, int file) const
    {
      int indexGlob = GetPointGlobExtIndex(detID, index);
      auto it       = fmPointLinkMap.find(LinkKey(indexGlob, event, file));
      return (it != fmPointLinkMap.cend()) ? it->second : -1;
    }
 
    int FindInternalTrackIndex(int index, int event, int file) const
    {
      auto it = fmTrackLinkMap.find(LinkKey(index, event, file));
      return (it != fmTrackLinkMap.cend()) ? it->second : -1;
    }
 
    int GetFirstPointIndex(ca::EDetectorID detID) const
    {
      return std::accumulate(fvNofPointsUsed.cbegin(), fvNofPointsUsed.cbegin() + static_cast<int>(detID), 0);
    }
 
    int GetLastPointIndex(ca::EDetectorID detID) const
    {
      return std::accumulate(fvNofPointsUsed.cbegin(), fvNofPointsUsed.cbegin() + static_cast<int>(detID) + 1, 0);
    }
 
    int GetPointGlobExtIndex(ca::EDetectorID detID, int iPointLocal) const
    {
      return iPointLocal + std::accumulate(fvNofPointsOrig.cbegin(), fvNofPointsOrig.cbegin() + int(detID), 0);
    }
 
    int GetNofTracks() const { return fvTracks.size(); }
 
    int GetNofPoints() const { return fvPoints.size(); }
 
    int GetNofPointsOrig(ca::EDetectorID detID) const { return fvNofPointsOrig[static_cast<int>(detID)]; }
 
    int GetNofPointsUsed(ca::EDetectorID detID) const { return fvNofPointsUsed[static_cast<int>(detID)]; }
 
    const auto& GetPoint(int idx) const { return fvPoints[idx]; }
 
    // TODO: SZh 12.12.2022: Probably, the better solution is to write a specific accessor for
    //                       setting indexes to MC points
    auto& GetPoint(int idx) { return fvPoints[idx]; }
 
    const auto& GetPointContainer() const { return fvPoints; }
 
    const auto& GetTrack(int idx) const { return fvTracks[idx]; }
 
    auto& GetTrack(int idx) { return fvTracks[idx]; }
 
    const auto& GetTrackContainer() const { return fvTracks; }
 
    auto& GetTrackContainer() { return fvTracks; }
 
    void InitTrackInfo(const ca::Vector<CbmL1HitDebugInfo>& vHits);
 
    void ReserveNofTracks(int nTracks) { fvTracks.reserve(nTracks); }
 
    void ReserveNofPoints(int nPoints) { fvPoints.reserve(nPoints); }
 
    void SetNofPointsOrig(ca::EDetectorID detID, int nPoints) { fvNofPointsOrig[static_cast<int>(detID)] = nPoints; }
 
    std::string ToString(int verbose = 1) const;
 
   private:
    // ******************************
    // **     Member variables     **
    // ******************************
 
    ca::Vector<MCPoint> fvPoints = {"ca::tools::MCData::fvPoints"};  
    ca::Vector<MCTrack> fvTracks = {"ca::tools::MCData::fvTracks"};  
 
    std::array<int, constants::size::MaxNdetectors> fvNofPointsOrig = {0};  
    std::array<int, constants::size::MaxNdetectors> fvNofPointsUsed = {0};  
 
    std::unordered_map<LinkKey, int> fmPointLinkMap = {};  
    std::unordered_map<LinkKey, int> fmTrackLinkMap = {};  
  };
 
 
  // *********************************************************
  // **     Template and inline function implementation     **
  // *********************************************************
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline void MCData::AddPoint(const MCPoint& point)
  {
    fmPointLinkMap[point.GetLinkKey()] = point.GetId();
    fvPoints.push_back(point);
    ++fvNofPointsUsed[static_cast<int>(point.GetDetectorId())];
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline void MCData::AddTrack(const MCTrack& track)
  {
    fmTrackLinkMap[track.GetLinkKey()] = track.GetId();
    fvTracks.push_back(track);
  }
}  // namespace cbm::ca::tools
 
#endif  // CaToolsMCData_h