StorableRecoResults.h

Go to the documentation of this file.

/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Felix Weiglhofer [committer], P.-A. Loizeau */
#ifndef CBM_ALGO_GLOBAL_STORABLE_RECO_RESULTS_H
#define CBM_ALGO_GLOBAL_STORABLE_RECO_RESULTS_H
 
#include "CaTrack.h"
#include "CaVector.h"
#include "CbmDigiEvent.h"
#include "PartitionedVector.h"
#include "algo/data/sts/Cluster.h"
#include "algo/data/sts/Hit.h"
#include "algo/detectors/bmon/Hit.h"
#include "algo/detectors/tof/Hit.h"
#include "algo/detectors/trd/Hit.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/vector.hpp>
 
#include <cstdint>
 
namespace cbm::algo
{
 
  class StorableRecoResults {
 
   public:
    using TrackHitIndexContainer_t = ca::Vector<std::vector<std::pair<uint32_t, uint32_t>>>;

    StorableRecoResults() = default;
 
    StorableRecoResults(uint64_t tsIndex, uint64_t tsStartTime) : fTsIndex(tsIndex), fTsStartTime(tsStartTime) {}

    uint64_t TsIndex() const { return fTsIndex; }

    uint64_t index() const { return fTsIndex; }

    uint64_t TsStartTime() const { return fTsStartTime; }

    uint64_t start_time() const { return fTsStartTime; }

    size_t SizeBytes() const;
 
    std::vector<CbmBmonDigi>& BmonDigis() { return fBmonDigis; }
    const std::vector<CbmBmonDigi>& BmonDigis() const { return fBmonDigis; }
 
    std::vector<CbmStsDigi>& StsDigis() { return fStsDigis; }
    const std::vector<CbmStsDigi>& StsDigis() const { return fStsDigis; }
 
    std::vector<CbmMuchDigi>& MuchDigis() { return fMuchDigis; }
    const std::vector<CbmMuchDigi>& MuchDigis() const { return fMuchDigis; }
 
    std::vector<CbmTrdDigi>& Trd2dDigis() { return fTrd2dDigis; }
    const std::vector<CbmTrdDigi>& Trd2dDigis() const { return fTrd2dDigis; }
 
    std::vector<CbmTrdDigi>& TrdDigis() { return fTrdDigis; }
    const std::vector<CbmTrdDigi>& TrdDigis() const { return fTrdDigis; }
 
    std::vector<CbmTofDigi>& TofDigis() { return fTofDigis; }
    const std::vector<CbmTofDigi>& TofDigis() const { return fTofDigis; }
 
    std::vector<CbmRichDigi>& RichDigis() { return fRichDigis; }
    const std::vector<CbmRichDigi>& RichDigis() const { return fRichDigis; }
 
    std::vector<CbmMvdRawDigi>& MvdDigis() { return fMvdDigis; }
    const std::vector<CbmMvdRawDigi>& MvdDigis() const { return fMvdDigis; }
 
    std::vector<CbmFsdDigi>& FsdDigis() { return fFsdDigis; }
    const std::vector<CbmFsdDigi>& FsdDigis() const { return fFsdDigis; }
 
    std::vector<CbmDigiEvent>& DigiEvents() { return fDigiEvents; }
    const std::vector<CbmDigiEvent>& DigiEvents() const { return fDigiEvents; }
 
    PartitionedVector<sts::Cluster>& StsClusters() { return fStsClusters; }
    const PartitionedVector<sts::Cluster>& StsClusters() const { return fStsClusters; }
 
    PartitionedVector<bmon::Hit>& BmonHits() { return fBmonHits; }
    const PartitionedVector<bmon::Hit>& BmonHits() const { return fBmonHits; }
 
    PartitionedVector<sts::Hit>& StsHits() { return fStsHits; }
    const PartitionedVector<sts::Hit>& StsHits() const { return fStsHits; }
 
    PartitionedVector<tof::Hit>& TofHits() { return fTofHits; }
    const PartitionedVector<tof::Hit>& TofHits() const { return fTofHits; }
 
    PartitionedVector<trd::Hit>& TrdHits() { return fTrdHits; }
    const PartitionedVector<trd::Hit>& TrdHits() const { return fTrdHits; }
 
    ca::Vector<ca::Track>& Tracks() { return fTracks; }
    const ca::Vector<ca::Track>& Tracks() const { return fTracks; }
 
    TrackHitIndexContainer_t& TrackStsHitIndices() { return fTrackStsHitIndices; }
    const TrackHitIndexContainer_t& TrackStsHitIndices() const { return fTrackStsHitIndices; }
 
    TrackHitIndexContainer_t& TrackTofHitIndices() { return fTrackTofHitIndices; }
    const TrackHitIndexContainer_t& TrackTofHitIndices() const { return fTrackTofHitIndices; }
 
    TrackHitIndexContainer_t& TrackTrdHitIndices() { return fTrackTrdHitIndices; }
    const TrackHitIndexContainer_t& TrackTrdHitIndices() const { return fTrackTrdHitIndices; }
 
   private:
    uint64_t fTsIndex     = UINT64_MAX;
    uint64_t fTsStartTime = UINT64_MAX;
 
    // Unpackers output
    std::vector<CbmBmonDigi> fBmonDigis;
    std::vector<CbmStsDigi> fStsDigis;
    std::vector<CbmMuchDigi> fMuchDigis;
    std::vector<CbmTrdDigi> fTrd2dDigis;
    std::vector<CbmTrdDigi> fTrdDigis;
    std::vector<CbmTofDigi> fTofDigis;
    std::vector<CbmRichDigi> fRichDigis;
    std::vector<CbmMvdRawDigi> fMvdDigis;
    std::vector<CbmFsdDigi> fFsdDigis;
 
    // Event builder/filter output
    std::vector<CbmDigiEvent> fDigiEvents;
 
    // Local Reconstruction output
    PartitionedVector<sts::Cluster> fStsClusters;
    PartitionedVector<bmon::Hit> fBmonHits;
    PartitionedVector<sts::Hit> fStsHits;
    PartitionedVector<tof::Hit> fTofHits;
    PartitionedVector<trd::Hit> fTrdHits;
 
    // Tracking output
    ca::Vector<ca::Track> fTracks;

    TrackHitIndexContainer_t fTrackStsHitIndices;

    TrackHitIndexContainer_t fTrackTofHitIndices;

    TrackHitIndexContainer_t fTrackTrdHitIndices;
 
    friend class boost::serialization::access;
 
    template<class Archive>
    void serialize(Archive& ar, unsigned int /*version*/)
    {
      ar& fTsIndex;
      ar& fTsStartTime;
 
      ar& fBmonDigis;
      ar& fStsDigis;
      ar& fMuchDigis;
      ar& fTrd2dDigis;
      ar& fTrdDigis;
      ar& fTofDigis;
      ar& fRichDigis;
      ar& fMvdDigis;
      ar& fFsdDigis;
 
      ar& fDigiEvents;
 
      ar& fStsClusters;
      ar& fBmonHits;
      ar& fStsHits;
      ar& fTofHits;
      ar& fTrdHits;
 
      ar& fTracks;
      ar& fTrackStsHitIndices;
      ar& fTrackTofHitIndices;
      ar& fTrackTrdHitIndices;
    }
  };
 
}  // namespace cbm::algo
 
#endif  // CBM_ALGO_GLOBAL_STORABLE_RECO_RESULTS_H