CbmRichDigitizer.h

Go to the documentation of this file.

/* Copyright (C) 2015-2024 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Semen Lebedev, Andrey Lebedev [committer], Martin Beyer */
 
#ifndef CBM_RICH_DIGITIZER
#define CBM_RICH_DIGITIZER
 
#include "CbmDefs.h"
#include "CbmDigitize.h"
#include "CbmRichDigi.h"
#include "CbmRichPmt.h"
#include "CbmRichPmtType.h"
 
#include <map>
 
class TClonesArray;
class CbmRichPoint;
class CbmLink;
 
class CbmRichDigitizer : public CbmDigitize<CbmRichDigi> {
public:
  CbmRichDigitizer() : CbmDigitize<CbmRichDigi>("RichDigitize") {};
 
  virtual ~CbmRichDigitizer() = default;
 
  CbmRichDigitizer(const CbmRichDigitizer&) = delete;
 
  CbmRichDigitizer& operator=(const CbmRichDigitizer&) = delete;
 
  ECbmModuleId GetSystemId() const { return ECbmModuleId::kRich; }
 
  virtual InitStatus Init();
 
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
  void SetDetectorType(CbmRichPmtTypeEnum detType) { fDetectorType = detType; }
 
  void SetTimeResolution(Double_t dt) { fTimeResolution = dt; }
 
  void SetPixelDeadTime(Double_t dt) { fPixelDeadTime = dt; }
 
  void SetCrossTalkProbability(Double_t horizontal, Double_t vertical, Double_t diagonal)
  {
    fCrossTalkProbability[0] = horizontal;
    fCrossTalkProbability[1] = vertical;
    fCrossTalkProbability[2] = diagonal;
  }
 
  void SetEventNoiseRate(Double_t noise) { fEventNoiseRate = noise; }
 
  void SetEventNoiseInterval(Double_t dT) { fEventNoiseInterval = dT; }
 
  void SetDarkRatePerPixel(Double_t darkRate) { fDarkRatePerPixel = darkRate; }
 
  void SetClusterSignalProbability(Double_t intensity) { fClusterSignalProbability = intensity; }
 
  void SetClusterSize(UInt_t size) { fClusterSize = size; }
 
  void SetCollectionEfficiency(Double_t collEff) { fPmt.SetCollectionEfficiency(collEff); }
 
  // void SetSigmaMirror(Double_t sigMirror) {fSigmaMirror = sigMirror;}
 
private:
  Int_t fEventNum {};
 
  TClonesArray* fRichPoints {nullptr};       // RICH MC points
  TClonesArray* fRichDigis {nullptr};        // RICH digis (output array)
  TClonesArray* fRichDigiMatches {nullptr};  // RICH digi matches (output array)
  TClonesArray* fMcTracks {nullptr};         // Monte-Carlo tracks
 
  Int_t fNofPoints {};   // total number of MCPoints processed
  Int_t fNofDigis {};    // total number of digis created
  Double_t fTimeTot {};  // sum of execution time
 
  CbmRichPmt fPmt {};
  CbmRichPmtTypeEnum fDetectorType {CbmRichPmtTypeCosy17NoWls};
 
  Double_t fTimeResolution {1.};              // in ns, time resolution for digis
  Double_t fPixelDeadTime {50.};              // in ns, deadtime for one pixel
  // probability of crosstalk depending on direction of neighbour pixel
  // index 0: horizontal, 1: vertical, 2: diagonal
  std::array<Double_t, 3> fCrossTalkProbability{0.02, 0.02, 0.005};
  Double_t fEventNoiseRate {5.};              // noise rate per McRichPoint / per  pixel / per second
  Double_t fEventNoiseInterval {50.};         // in ns, interval to generate event noise signals
  Double_t fDarkRatePerPixel {1000.};         // dark rate per pixel in Hz
  Double_t fClusterSignalProbability {0.37};  // cluster intensity
  UInt_t fClusterSize {0};                    // cluster size
 
  std::map<Int_t, std::vector<std::pair<Double_t, CbmLink*>>>
    fSignalBuffer {};  // first: pixel address, second: signal buffer
 
  std::map<Int_t, Double_t> fPixelsLastFiredTime {};  // first: pixel address, second: last fired time
 
  Int_t ProcessMcEvent();
 
  void ProcessPoint(CbmRichPoint* point, Int_t pointId, Int_t eventNum, Int_t inputNum);
 
  void AddSignalToBuffer(Int_t address, Double_t time, const CbmLink& link);
 
  void AddCrossTalk(Int_t address, Double_t time, const CbmLink& link);
 
  void AddChargedParticleCluster(Int_t address, Double_t time, Int_t eventNum, Int_t inputNum);
 
  void AddEventNoise(Int_t eventNum, Int_t inputNum);
 
  void AddDarkRateNoise(Double_t oldEventTime, Double_t newEventTime);
 
  Int_t ProcessBuffers(Double_t processTime);
 
  ClassDef(CbmRichDigitizer, 3)
};
 
#endif