CbmCaTimeSliceReader.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once
 
#include "CaDataManager.h"
#include "CaDefs.h"
#include "CaToolsHitRecord.h"
#include "CaVector.h"
#include "CbmCaMCModule.h"
#include "CbmEvent.h"
#include "CbmL1DetectorID.h"
#include "CbmL1HitId.h"
#include "CbmL1Track.h"
#include "CbmMuchPixelHit.h"
#include "CbmMvdHit.h"
#include "CbmPixelHit.h"
#include "CbmStsHit.h"
#include "CbmTofHit.h"
#include "CbmTrdHit.h"
#include "TClonesArray.h"
 
class CbmTimeSlice;
namespace cbm::algo::ca
{
  class DataManager;
  template<typename DataT>
  class Parameters;
}  // namespace cbm::algo::ca
 
namespace cbm::ca
{
  class TimeSliceReader {
   public:
    TimeSliceReader() = default;

    ~TimeSliceReader() = default;

    TimeSliceReader(const TimeSliceReader&) = delete;

    TimeSliceReader(TimeSliceReader&&) = delete;

    TimeSliceReader& operator=(const TimeSliceReader&) = delete;

    TimeSliceReader& operator=(TimeSliceReader&&) = delete;

    void Clear();

    const auto& GetHitFirstIndexDet() const { return fvHitFirstIndexDet; }

    int GetNofHits(ca::EDetectorID iDet) const
    {
      return fvHitFirstIndexDet[int(iDet) + 1] - fvHitFirstIndexDet[int(iDet)];
    }

    ECbmCaTrackingMode GetTrackingMode() const { return fTrackingMode; }

    bool InitRun();

    void ReadEvent(CbmEvent* pEvent = nullptr);

    void RegisterQaHitContainer(ca::Vector<cbm::algo::ca::McHitInfo>& vQaHits) { fpvQaHits = &vQaHits; }

    void RegisterHitIndexContainer(ca::Vector<CbmL1HitId>& vHitIds) { fpvHitIds = &vHitIds; }

    void RegisterParameters(std::shared_ptr<const ca::Parameters<double>>& pParameters) { fpParameters = pParameters; }

    void RegisterIODataManager(std::shared_ptr<ca::DataManager>& ioDataManager);

    void RegisterTracksContainer(ca::Vector<CbmL1Track>& vTracks) { fpvTracks = &vTracks; }

    void SetDetector(ca::EDetectorID detID, bool flag = true) { fvbUseDet[detID] = flag; }

    void SetTrackingMode(ECbmCaTrackingMode mode) { fTrackingMode = mode; }

    void SetSortQaHits(bool doSortQaHits) { fbSortQaHits = doSortQaHits; }
 
   private:
    void CheckInit() const;

    void ReadHits();

    void ReadRecoTracks();

    template<ca::EDetectorID DetID>
    int ReadHitsForDetector();

    void SortQaHits();

    void StoreHitRecord(const tools::HitRecord& hitRecord);
 
    // Input data branches
    // CbmTimeSlice* fpBrTimeSlice         = nullptr;      ///< Pointer to the TS object
    CbmEvent* fpEvent                   = nullptr;      
    DetIdArr_t<TClonesArray*> fvpBrHits = {{nullptr}};  
 
    // Branches for reconstructed tracks. The input at the moment (as for 27.02.2023) depends on the selected
    // tracking mode. For simulations in CBM, the CA tracking is used only in STS + MVD detectors. In this case
    // the reconstructed tracks are saved to the "StsTrack" branch as CbmStsTrack objects. For mCBM, the tracks from
    // CA are saved as global tracks, and the local ones are used to keep indexes of hits in different subsystems
    TClonesArray* fpBrRecoTracks = nullptr;  
    TClonesArray* fpBrStsTracks  = nullptr;  
    TClonesArray* fpBrMuchTracks = nullptr;  
    TClonesArray* fpBrTrdTracks  = nullptr;  
    TClonesArray* fpBrTofTracks  = nullptr;  
 
    // Pointers to output data containers
    ca::Vector<CbmL1HitId>* fpvHitIds                          = nullptr;  
    ca::Vector<cbm::algo::ca::McHitInfo>* fpvQaHits            = nullptr;  
    ca::Vector<CbmL1Track>* fpvTracks                          = nullptr;  
    std::shared_ptr<ca::DataManager> fpIODataManager           = nullptr;  
    std::shared_ptr<const ca::Parameters<double>> fpParameters = nullptr;  
 
    // Maps of hit indexes: ext -> int
    DetIdArr_t<std::unordered_map<int, int>> fvmHitExtToIntIndexMap;  
 
    DetIdArr_t<int> fvNofHitsTotal = {{0}};      
    DetIdArr_t<int> fvNofHitsUsed  = {{0}};      
    DetIdArr_t<bool> fvbUseDet     = {{false}};  
 
    ECbmCaTrackingMode fTrackingMode = ECbmCaTrackingMode::kSTS;  
 
    bool fbSortQaHits = false;  
 
    // Variables for storing cache
    int fNofHits     = 0;  
    int fNofHitKeys  = 0;  
    int fFirstHitKey = 0;  
 
    std::array<int, constants::size::MaxNdetectors + 1> fvHitFirstIndexDet = {{0}};  
  };
}  // namespace cbm::ca