CbmMuchDigitizeGem.h

Go to the documentation of this file.

 
#ifndef CBMMUCHDIGITIZEGEM_H
#define CBMMUCHDIGITIZEGEM_H 1
#define NTIMEBINS 200
#include "CbmDigitize.h"
 
#include "TArrayD.h"
#include "TClonesArray.h"
#include "TMath.h"
#include "TPolyLine.h"
#include "TStopwatch.h"
#include "TString.h"
//#include "TH1D.h"
 
#include "CbmDefs.h"  // for ECbmModuleId
#include "CbmMuchDigi.h"
#include "CbmMuchDigiMatch.h"
#include "CbmMuchGeoScheme.h"
#include "CbmMuchSignal.h"
#include "TF1.h"
#include "TH1.h"
#include <map>
class CbmMuchSector;
class CbmMuchPoint;
class CbmMuchPad;
class CbmMuchSectorRadial;
class TChain;
 
enum DetectorType { kGEM, kMICROMEGAS };
 
static const Double_t gkResponsePeriod = 400.;
//static const Int_t gkResponseBin = 1;
 
class CbmMuchDigitizeGem : public CbmDigitize<CbmMuchDigi> {
public:
  CbmMuchDigitizeGem();
 
  CbmMuchDigitizeGem(const char* digiFileName, Int_t flag);
 
  CbmMuchDigitizeGem(const CbmMuchDigitizeGem&) = delete;
  CbmMuchDigitizeGem& operator=(const CbmMuchDigitizeGem&) = delete;
 
  virtual ~CbmMuchDigitizeGem();
 
  virtual void Exec(Option_t* opt);
 
  virtual void Finish();
 
  ECbmModuleId GetSystemId() const { return ECbmModuleId::kMuch; }
 
 
  void SetSpotRadius(Double_t spotRadius = 0.05) { fSpotRadius = spotRadius; }
 
  void SetMeanGasGain(Double_t gasGain) { fMeanGasGain = gasGain; }
 
  void SetQMaximum(UInt_t qMax) { fQMax = qMax; }
 
  void SetQThreshold(UInt_t qThreshold) { fQThreshold = qThreshold; }
 
  void SetNADCChannels(UInt_t nADCChannels) { fNADCChannels = nADCChannels; }
 
  void SetMeanNoise(UInt_t meanNoise) { fMeanNoise = meanNoise; }
 
  void SetDeadPadsFrac(Double_t deadPadsFrac) { fDeadPadsFrac = deadPadsFrac; }
 
  void SetDTime(Double_t dTime) { fDTime = dTime; }
 
  Double_t GetDTime() { return fDTime; }
 
  Double_t Sigma_n_e(Double_t Tkin, Double_t mass);
 
  Double_t MPV_n_e(Double_t Tkin, Double_t mass);
 
  void ReadAndRegister(
    Long_t);  //Read from CbmMuchReadoutBuffer and Register as per mode
  Int_t GetNofSignals() const { return fNofSignals; }
 
  //Iteriate on each element of fAddressCharge, create a CbmMuchSignal and store in CbmMuchReadoutBuffer.
  Bool_t BufferSignals(Int_t, Double_t, Double_t);
  CbmMuchDigi* ConvertSignalToDigi(
    CbmMuchSignal*);  //Converting Analog Signal to Digital Digi
 
  void SetMcChain(TChain* mcChain) { fMcChain = mcChain; }
  //void SetDeadTime(Double_t deadTime) {fDeadTime = deadTime; }
  void SetDriftVelocity(Double_t velocity) { fDriftVelocity = velocity; }
  //void SetPeakingTime(Double_t peakingTime) {fPeakingTime = peakingTime; }
  //void SetRemainderTime(Double_t remainderTime) {fRemainderTime = remainderTime; }
  void SetTimeBinWidth(Double_t timeBinWidth) { fTimeBinWidth = timeBinWidth; }
  void SetAlgorithm(Int_t algorithm) { fAlgorithm = algorithm; }
  void SetTimeOverThreshold(Bool_t tot) { fTOT = tot; }
  //TArrayD fgDeltaResponse; // Signal shape on delta function response
  void SetLight(Bool_t islight) { fIsLight = islight; }
 
  //------------------------Noise Generation-----------------------//
 
  void SetGenerateNoise(Bool_t Noise) {
    fGenerateElectronicsNoise = Noise;
  }  // Setting Generate Noise for Time Based Mode
  void SetPerPadNoiseRate(Double_t noiserate) {
    fPerPadNoiseRate = noiserate;
  }  // Setting Generate Noise for Time Based Mode
  Int_t GenerateNoise(Double_t, Double_t);
  Int_t GenerateNoisePerModule(CbmMuchModuleGem*, Double_t, Double_t);
  void AddNoiseSignal(CbmMuchPad*, Double_t, Double_t);
 
  //-------------------------------------------------------------//
 
 
private:
  Int_t fAlgorithm;              // Algorithm
  CbmMuchGeoScheme* fGeoScheme;  // Main object responsible for geometry
  TString fDigiFile;             // Digitization file
  TClonesArray* fPoints;         // Input array of CbmMuchPoint
  TClonesArray* fMCTracks;       // Input array of MCTrack
    //std::vector<CbmMuchDigi>* fDigis;  //< Output array of CbmMuchDigi and will be stored in vector
    //std::vector<CbmMatch>* fDigiMatches; //< Output array of CbmMatch and will be stored in vector
  //TClonesArray*      fDigis;         // Output array of CbmMuchDigi
  //TClonesArray*      fDigiMatches;   // Output array of CbmMuchDigiMatches
  Int_t fNFailed;   // Total number of points which digitization has failed
  Int_t fNOutside;  // Total number of points which was found outside a detector
  Int_t fNMulti;    // Total number of channels that was hitby several points
  Int_t fFlag;      // flag to distinguish geometry
 
 
  /*
    TH1D* hPriElAfterDriftpathgem;
    TH1D* hPriElAfterDriftpathrpc;
    TH1F * hadcGEM;
    TH1F * hadcRPC;
*/
 
  UInt_t fNADCChannels;  // Number of ADC channels
  UInt_t fQMax;          // Maximum charge that a pad can collect [electrons]
  UInt_t fQThreshold;    // Charge threshold [electrons]
  UInt_t
    fMeanNoise;  // Mean electronics noise value [electrons] different than fGenerateElectronicsNoise
  Double_t fSpotRadius;     // Spot radius from secondary electrons [cm]
  Double_t fMeanGasGain;    // Mean gas gain value (1e4 by default)
  Double_t fDTime;          // Time resolution [ns]
  Double_t fDeadPadsFrac;   // Probability to find a dead pad
  TStopwatch fTimer;        // Timer
  TChain* fMcChain;         // Chain of McFiles with McTrack info
  Double_t fDeadTime;       // Channel dead time [ns]
  Double_t fDriftVelocity;  // Drift Velocity [um/ns]
  //Double_t           fPeakingTime;   // Peaking time [ns]
  //Double_t           fRemainderTime; // Remainder time = t_r [ns]: remainder is simulated as exp(-t/t_r)
  Double_t fTimeBinWidth;  // Width of the bin for signal shape simulation
  Int_t fNTimeBins;        // Number of bins for signal shape simulation
  //    Int_t              fNdigis;        // Number of created digis
  Bool_t
    fTOT;  // Flag to switch between time over threshold/direct amplitude measurement
  Double_t
    fTotalDriftTime;  // Total drift time (calculated from drift velocity and drift volume width)
 
  TF1* fSigma[3];
  TF1* fMPV[3];
  Bool_t fIsLight;  //Default fIsLight = 1
 
  // --- Time of last processed Much Point (for time mode)
  Double_t fTimePointLast;
 
  // --- Digi times (for stream mode, in each step)
  Double_t fTimeDigiFirst;  
  Double_t fTimeDigiLast;   
  // --- Event counters
  Int_t fNofPoints;   
  Int_t fNofSignals;  
  Int_t fNofDigis;    
 
  // --- Run counters
  Int_t fNofEvents;         
  Double_t fNofPointsTot;   
  Double_t fNofSignalsTot;  
  Double_t fNofDigisTot;    
  Double_t fTimeTot;        
 
  //Data members for Electronics Noise Generation
  Double_t fPerPadNoiseRate;         //Noise rate per pad
  Double_t fPreviousEventTime = -1;  
  // Double_t       fCurrentEventTime = 0;  //!Current Event Time
  Bool_t
    fGenerateElectronicsNoise;  
  Int_t fNofNoiseTot     = 0;
  Int_t fNofNoiseSignals = 0;
  TF1* fNoiseCharge;  
  //TH1D*           noise;
 
  //Storing all the charges which is generated from the same MCPoint in a map<address, charge>
  std::map<UInt_t, UInt_t> fAddressCharge;
 
  virtual InitStatus Init();
 
  Bool_t ExecPoint(const CbmMuchPoint* point, Int_t);
 
  // Bool_t AddDigi(CbmMuchPad* pad);
  inline Int_t GasGain();
  void DetectorParameters(CbmMuchModule* module);
  Double_t GetNPrimaryElectronsPerCm(const CbmMuchPoint* point,
                                     int detectortype);
  Bool_t AddCharge(CbmMuchSectorRadial* s,
                   UInt_t ne,
                   Int_t iPoint,
                   Double_t time,
                   Double_t driftTime,
                   Double_t phi1,
                   Double_t phi2);
  void AddCharge(CbmMuchPad* pad,
                 UInt_t charge,
                 Int_t iPoint,
                 Double_t time,
                 Double_t driftTime);
  void Reset();
 
  ClassDef(CbmMuchDigitizeGem, 1)
};
#endif