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 "CbmL1Hit.h"
#include "CbmL1Track.h"
#include "CbmMuchPixelHit.h"
#include "CbmMuchTrackingInterface.h"
#include "CbmMvdHit.h"
#include "CbmMvdTrackingInterface.h"
#include "CbmPixelHit.h"
#include "CbmStsHit.h"
#include "CbmStsTrackingInterface.h"
#include "CbmTofHit.h"
#include "CbmTofTrackingInterface.h"
#include "CbmTrdHit.h"
#include "CbmTrdTrackingInterface.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<CbmL1HitDebugInfo>& vQaHits) { fpvQaHits = &vQaHits; }
 
    void RegisterHitIndexContainer(ca::Vector<CbmL1HitId>& vHitIds) { fpvHitIds = &vHitIds; }
 
    void RegisterParameters(std::shared_ptr<ca::Parameters<float>>& 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);
 
    DetIdArr_t<const CbmTrackingDetectorInterfaceBase*> fvpDetInterface = {{nullptr}};
 
    // 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<CbmL1HitDebugInfo>* fpvQaHits            = nullptr;  
    ca::Vector<CbmL1Track>* fpvTracks                   = nullptr;  
    std::shared_ptr<ca::DataManager> fpIODataManager    = nullptr;  
    std::shared_ptr<ca::Parameters<float>> 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