CbmRecoSts.h

Go to the documentation of this file.

/* Copyright (C) 2020-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */
 
#ifndef CBMRECOSTS_H
#define CBMRECOSTS_H 1
 
#include "sts/HitfinderChain.h"
 
#include <FairTask.h>
 
#include <TClonesArray.h>
#include <TStopwatch.h>
 
class CbmDigiManager;
class CbmEvent;
class CbmStsElement;
class CbmStsParAsic;
class CbmStsParModule;
class CbmStsParSensor;
class CbmStsParSensorCond;
class CbmStsParSetModule;
class CbmStsParSetSensor;
class CbmStsParSetSensorCond;
class CbmStsParSim;
class CbmStsRecoModule;
class CbmStsSensor;
class CbmStsSetup;
 
 
class CbmRecoSts : public FairTask {
 
 public:
  CbmRecoSts(ECbmRecoMode mode = ECbmRecoMode::Timeslice, Bool_t writeClusters = kFALSE);
 
 
  CbmRecoSts(const CbmRecoSts&) = delete;
 
 
  CbmRecoSts operator=(const CbmRecoSts&) = delete;
 
 
  virtual ~CbmRecoSts();
 
 
  virtual void Exec(Option_t* opt);
 
 
  virtual void Finish();
 
 
  TClonesArray* GetClusters() { return fClusters; }
 
 
  virtual InitStatus Init();
 
 
  void SetEventMode(Bool_t choice = kTRUE) { fMode = (choice ? ECbmRecoMode::EventByEvent : ECbmRecoMode::Timeslice); }
 
 
  void SetMode(ECbmRecoMode mode) { fMode = mode; }
 
  void SetUseGpuReco(bool useGPU);
 
  virtual void SetParContainers();
 
 
  void SetTimeCutClustersAbs(Double_t value) { fTimeCutClustersAbs = value; }
 
 
  void SetTimeCutClustersSig(Double_t value) { fTimeCutClustersSig = value; }
 
 
  void SetTimeCutDigisAbs(Double_t value) { fTimeCutDigisAbs = value; }
 
 
  void SetTimeCutDigisSig(Double_t value) { fTimeCutDigisSig = value; }
 
 
  void UseModulePar(CbmStsParModule* modulePar) { fUserParModule = modulePar; }
 
 
  void UseModuleParSet(CbmStsParSetModule* moduleParSet) { fUserParSetModule = moduleParSet; }
 
 
  void UseSensorCond(CbmStsParSensorCond* sensorCond) { fUserParCond = sensorCond; }
 
  void UseSensorCondSet(CbmStsParSetSensorCond* sensorCondSet) { fUserParSetCond = sensorCondSet; }
 
 
  void UseSensorPar(CbmStsParSensor* sensorPar) { fUserParSensor = sensorPar; }
 
 
  void UseSensorParSet(CbmStsParSetSensor* sensorParSet) { fUserParSetSensor = sensorParSet; }
 
  void DumpNewHits();
  void DumpOldHits();
 
 private:
  std::pair<Double_t, Double_t> LorentzShift(const CbmStsParSensorCond& conditions, Double_t dZ, Double_t bY);
 
 
  UInt_t CreateModules();
 
 
  void GetSensorParameters(CbmStsElement* geoSensor);
 
 
  void InitParams();
 
 
  void ProcessData(CbmEvent* event = nullptr);
 
  void ProcessDataGpu();
 
 private:
  // --- I/O
  TClonesArray* fEvents        = nullptr;  
  CbmDigiManager* fDigiManager = nullptr;  
  TClonesArray* fClusters      = nullptr;  
  TClonesArray* fHits          = nullptr;  
 
  // --- Setup and parameters
  CbmStsSetup* fSetup                 = nullptr;  
  CbmStsParSim* fParSim               = nullptr;  
  CbmStsParSetModule* fParSetModule   = nullptr;  
  CbmStsParSetSensor* fParSetSensor   = nullptr;  
  CbmStsParSetSensorCond* fParSetCond = nullptr;  
 
  // --- User-defined parameters, not from database
  CbmStsParAsic* fUserParAsic       = nullptr;
  CbmStsParModule* fUserParModule   = nullptr;
  CbmStsParSensor* fUserParSensor   = nullptr;
  CbmStsParSensorCond* fUserParCond = nullptr;
 
  // --- User-defined parameter sets, not from database
  CbmStsParSetModule* fUserParSetModule   = nullptr;
  CbmStsParSetSensor* fUserParSetSensor   = nullptr;
  CbmStsParSetSensorCond* fUserParSetCond = nullptr;
 
  // --- Settings
  ECbmRecoMode fMode           = ECbmRecoMode::Timeslice;  
  Double_t fTimeCutDigisSig    = 3.;                       
  Double_t fTimeCutDigisAbs    = -1.;                      
  Double_t fTimeCutClustersSig = 4.;                       
  Double_t fTimeCutClustersAbs = -1.;                      
  Bool_t fWriteClusters        = kFALSE;                   
 
  // --- Timeslice counters
  Long64_t fNofDigis        = 0;   
  Long64_t fNofDigisUsed    = 0;   
  Long64_t fNofDigisIgnored = 0;   
  Long64_t fNofClusters     = 0;   
  Long64_t fNofHits         = 0;   
  Double_t fTimeTot         = 0.;  
  Double_t fTime1           = 0.;  
  Double_t fTime2           = 0.;  
  Double_t fTime3           = 0.;  
  Double_t fTime4           = 0.;  
  double fTimeSortDigis     = 0.;
  double fTimeFindClusters  = 0.;
  double fTimeSortClusters  = 0.;
  double fTimeFindHits      = 0.;
 
  // --- Run counters
  TStopwatch fTimer{};                
  Int_t fNofTs                 = 0;   
  Int_t fNofEvents             = 0;   
  Double_t fNofDigisRun        = 0;   
  Double_t fNofDigisUsedRun    = 0;   
  Double_t fNofDigisIgnoredRun = 0;   
  Double_t fNofClustersRun     = 0;   
  Double_t fNofHitsRun         = 0;   
  Double_t fTimeRun            = 0.;  
  Double_t fTime1Run           = 0.;  
  Double_t fTime2Run           = 0.;  
  Double_t fTime3Run           = 0.;  
  Double_t fTime4Run           = 0.;  
 
 
  // --- Reconstruction modules
  std::map<UInt_t, CbmStsRecoModule*> fModules{};  
  std::vector<CbmStsRecoModule*> fModuleIndex{};   
 
  bool fUseGpuReco = false;
  cbm::algo::sts::HitfinderChain fGpuReco;
 
  std::pair<size_t, size_t> ForwardGpuClusterAndHits();
 
  ClassDef(CbmRecoSts, 1);
};
 
#endif