CbmTofDigitize.h

Go to the documentation of this file.

 
#ifndef CBMTOFDIGITIZE_H
#define CBMTOFDIGITIZE_H 1
 
#include "CbmDefs.h"
#include "CbmDigitize.h"
#include "CbmTofDigi.h"
#include "TH1.h"
#include "TH2.h"
#include "TStopwatch.h"
#include "TTimeStamp.h"
#include <vector>
 
class TClonesArray;
class TRandom3;
class CbmTofCell;
class CbmTofDigiBdfPar;
class CbmTofDetectorId;
class CbmTofDigiPar;
class CbmTofGeoHandler;
class CbmTofPoint;
 
 
class CbmTofDigitize : public CbmDigitize<CbmTofDigi> {
public:
  CbmTofDigitize();
 
  CbmTofDigitize(const char* name, Int_t verbose = 1);
  virtual ~CbmTofDigitize();
 
 
  ECbmModuleId GetSystemId() const { return ECbmModuleId::kTof; }
 
  virtual InitStatus Init();
 
  virtual void SetParContainers();
 
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
 
  void SetInputFileName(TString FileName) { fsBeamInputFile = FileName; }
 
  Bool_t SetHistoFileName(TString sFilenameIn = "./tofDigiBdf.hst.root");
 
  void SetMonitorHistograms(Bool_t bMonitor = kTRUE) {
    fbMonitorHistos = bMonitor;
  }
 
  void UseMcTrackMonitoring(Bool_t bMcTrkMonitor = kTRUE) {
    fbMcTrkMonitor = bMcTrkMonitor;
  }
 
  void AllowPointsWithoutTrack(Bool_t bAllow = kTRUE) {
    fbAllowPointsWithoutTrack = bAllow;
  }
 
  inline void SetDigiTimeConvFactor(Double_t dfac) {
    fdDigiTimeConvFactor = dfac;
  }
 
 
private:
  CbmTofDigitize(const CbmTofDigitize&);
  CbmTofDigitize& operator=(const CbmTofDigitize&);
 
  // Functions common for all clusters approximations
  Bool_t RegisterInputs();
  Bool_t InitParameters();
  Bool_t LoadBeamtimeValues();
 
  // Histogramming functions
  Bool_t CreateHistos();
  Bool_t FillHistos();
  Bool_t WriteHistos();
  Bool_t DeleteHistos();
 
  // Functions for the merging of "gap digis" and "multiple hits digis" into "channel digis"
  Bool_t MergeSameChanDigis();
 
  // Functions for the Cluster Radius generation
  Double_t GenerateClusterRadius(Int_t iSmType, Int_t iRpc);
 
  // Functions for a direct use of the cluster size
  Bool_t DigitizeDirectClusterSize();
 
  // Functions for a simple "Flat disc" cluster approximation
  Bool_t DigitizeFlatDisc();
 
  Double_t ComputeClusterAreaOnChannel(Int_t iChanId,
                                       Double_t dClustRadius,
                                       Double_t dClustCentX,
                                       Double_t dClustCentY);
 
  // Functions for a 2D Gauss cluster approximation
  Bool_t DigitizeGaussCharge();
 
  // Auxiliary functions
  // Area
  Double_t TriangleArea(Double_t dXa,
                        Double_t dYa,
                        Double_t dXb,
                        Double_t dYb,
                        Double_t dXc,
                        Double_t dYc);
  Double_t DiscSectionArea(Double_t dDiscRadius, Double_t dDistBaseToCenter);
  // Points
  Double_t CircleIntersectPosX(Int_t iChanId,
                               Double_t dClustRadius,
                               Double_t dClustCentX,
                               Double_t dClustCentY,
                               Bool_t bUpperSide);
  Double_t CircleIntersectPosY(Int_t iChanId,
                               Double_t dClustRadius,
                               Double_t dClustCentX,
                               Double_t dClustCentY,
                               Bool_t bRightSide);
  Double_t DistanceCircleToBase(Double_t dClustRadius,
                                Double_t dBaseXa,
                                Double_t dBaseYa,
                                Double_t dBaseXb,
                                Double_t dBaseYb);
 
  Bool_t CompareTimes(CbmTofDigi* p1, CbmTofDigi* p2);
 
  // Fee properties and constants
  Double_t fdFeeGainSigma;
  Double_t fdFeeTotThr;
  Double_t fdTimeResElec;
  Double_t fdSignalPropSpeed;
 
  // Beamtime variables [nbSmType]
  std::vector<TH1*> fh1ClusterSizeProb;
  std::vector<TH1*> fh1ClusterTotProb;
 
  // RPC variables from beamtime [nbSmType][NbSm][NbRpc]
  std::vector<std::vector<std::vector<Double_t>>> fvdSignalVelocityRpc;
 
  // Channel variables [nbSmType][NbSm*NbRpc][NbChannel*NbSides]
  std::vector<std::vector<std::vector<Double_t>>>
    fdChannelGain;  // <- Generated from parameter FeeGainSigma
 
  // ToF geometry variables
  CbmTofGeoHandler* fGeoHandler;
  CbmTofDetectorId* fTofId;
  CbmTofDigiPar* fDigiPar;
  CbmTofCell* fChannelInfo;
  CbmTofDigiBdfPar* fDigiBdfPar;
  Int_t fiNbElecChTot;
  std::vector<std::vector<std::vector<Int_t>>>
    fvRpcChOffs;  // Offset in channel index for first channel of each RPC
 
  // Input variables
  TClonesArray* fTofPointsColl;  // TOF MC points
  TClonesArray* fMcTracksColl;   // MC tracks
 
  // Intermediate storage variables
  // Store all digis to allow merging
  std::vector<
    std::vector<std::vector<std::vector<std::pair<CbmTofDigi*, CbmMatch*>>>>>
    fStorDigi;  //[nbType][nbSm*nbRpc][nbCh*NbSide][nDigis]
  std::vector<std::vector<std::vector<std::vector<Int_t>>>>
    fStorDigiMatch;  //[nbType][nbSm*nbRpc][nbCh*NbSide][nDigis]
  // Temporary storing of the Track/Point/Digi info to make sure all gap/Tofpoint
  // linked to same track in same channel give same result (single cluster per track/channel pair)
  std::vector<std::vector<ULong64_t>>
    fvlTrckChAddr;  // [nbMcTracks][nbChannelFiredByTrk]
    // Temporary storing of the Track/Rpc info to make sure all clusters
    // linked to same track in same detector give the same results for timing
  std::vector<std::vector<ULong64_t>>
    fvlTrckRpcAddr;  // [nbMcTracks][nbRpcFiredByTrk]
  std::vector<std::vector<Double_t>>
    fvlTrckRpcTime;  // [nbMcTracks][nbRpcFiredByTrk]
 
  // Output variables
  Int_t fiNbDigis;  // Index of the CbmTofDigi TClonesArray
 
  // Output file name and path
  TString fsHistoOutFilename;
  // Histograms
  TH1* fhTofPointsPerTrack;
  TH2* fhTofPtsInTrkVsGapInd;
  TH2* fhTofPtsInTrkVsGapIndPrm;
  TH2* fhTofPtsInTrkVsGapIndSec;
  TH2* fhTofPtsPosVsGap[10];
  /*
      TH2 * fhTofPointsPerTrackVsPdg;
      TH1 * fhMeanPointPerTrack;
      TH2 * fhMeanPointPerTrack2d;
      TH1 * fhMeanDigiPerPoint;
      TH1 * fhMeanFiredPerPoint;
      */
  TH1* fhEvtProcTime;
  TH1* fhDigiMergeTime;
  TH1* fhDigiNbElecCh;
  TH2* fhProcTimeEvtSize;
  TH1* fhMeanDigiPerTrack;
  TH1* fhMeanFiredPerTrack;
  TH1* fhPtTime;
  TH1* fhDigiTime;
  TH1* fhDigiTimeRes;
  TH2* fhDigiTimeResB;
  TH1* fhToTDist;
 
  TH1* fhElecChOccup;
  TH1* fhMultiDigiEvtElCh;
  TH2* fhNbDigiEvtElCh;
  TH2* fhNbTracksEvtElCh;
  TH1* fhFiredEvtElCh;
  TH1* fhMultiProbElCh;
 
  TTimeStamp fStart;
  TTimeStamp fStop;
  Double_t fdDigitizeTime;
  Double_t fdMergeTime;
  // --- Run counters
  TStopwatch fTimer;          
  Int_t fiNofEvents;          
  Double_t fdNofTofMcTrkTot;  
  Double_t fdNofPointsTot;    
  Double_t fdNofDigisTot;     
  Double_t fdTimeTot;         
 
  TString fsBeamInputFile;
 
  Bool_t fbMonitorHistos;
  Bool_t fbMcTrkMonitor;
  Bool_t fbTimeBasedOutput;
  Bool_t fbAllowPointsWithoutTrack;
 
  //Int_t fiCurrentFileId;   is now in base class
  //Int_t fiCurrentEventId;  is now in base class
  //Double_t fdCurrentEventTime; is now in base class
  Double_t fdDigiTimeConvFactor;
 
  ClassDef(CbmTofDigitize, 1);
};
 
#endif  // CBMTOFDIGITIZE_H