CaMcData.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 CaMcData_h
#define CaMcData_h 1
 
#include "CaDefs.h"
#include "CaMcHitInfo.h"
#include "CaMcLinkKey.h"
#include "CaMcMatch.h"
#include "CaMcPoint.h"
#include "CaMcTrack.h"
#include "CaSimd.h"
#include "CaVector.h"
 
#include <numeric>
#include <string>
#include <unordered_map>
 
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
  class McHitInfo;

  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(McLinkKey(indexGlob, event, file));
      return (it != fmPointLinkMap.cend()) ? it->second : -1;
    }

    int FindInternalTrackIndex(int index, int event, int file) const
    {
      auto it = fmTrackLinkMap.find(McLinkKey(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 SetMcHitInfo(const ca::Vector<cbm::algo::ca::McHitInfo>& 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; }

    const ca::Vector<cbm::algo::ca::McHitInfo>* GetMcHitInfo() const { return fpMcHitInfos; }
 
    int GetBestMcPointIdForCaHit(int iHit) const
    {
      if (fpMcHitInfos) {
        return (*fpMcHitInfos)[iHit].GetBestMcPointId();
      }
      return -1;
    }
 
    int GetBestMcTrackIdForCaHit(int iHit) const
    {
      if (fpMcHitInfos) {
        int iPoint = (*fpMcHitInfos)[iHit].GetBestMcPointId();
        if (iPoint >= 0 && iPoint < GetNofPoints()) {
          return GetPoint(iPoint).GetTrackId();
        }
      }
      return -1;
    }
 
    McMatch GetMcMatchForCaHit(int iHit) const
    {
      McMatch match;
      if (fpMcHitInfos) {
        const auto& pointIds = (*fpMcHitInfos)[iHit].GetMcPointIds();
        for (int iPoint : pointIds) {
          if (iPoint >= 0 && iPoint < GetNofPoints()) {
            const auto& point = GetPoint(iPoint);
            match.AddLink(point.GetTrackId(), 1.0f);  // TODO: Define a better weight
          }
        }
      }
      return match;
    }

    std::string ToString(int verbose = 1) const;
 
   private:
    // ******************************
    // **     Member variables     **
    // ******************************
 
    ca::Vector<McPoint> fvPoints = {"ca::algo::ca::McData::fvPoints"};  
    ca::Vector<McTrack> fvTracks = {"ca::algo::ca::McData::fvTracks"};  
 
    std::array<int, constants::size::MaxNdetectors> fvNofPointsOrig = {0};  
    std::array<int, constants::size::MaxNdetectors> fvNofPointsUsed = {0};  
 
    std::unordered_map<McLinkKey, int> fmPointLinkMap = {};  
    std::unordered_map<McLinkKey, int> fmTrackLinkMap = {};  
 
    const ca::Vector<cbm::algo::ca::McHitInfo>* fpMcHitInfos = {nullptr};
  };
 
 
  // *********************************************************
  // **     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::algo::ca
 
#endif  // CaMcData_h