CbmStsDigitize.h

Go to the documentation of this file.

 
#ifndef CBMSTSDIGITIZE_H
#define CBMSTSDIGITIZE_H 1
 
#include "TStopwatch.h"
#include <map>
 
#include "CbmDefs.h"
#include "CbmDigitize.h"
#include "CbmMatch.h"
#include "CbmStsDefs.h"
#include "CbmStsDigi.h"
#include "CbmStsPhysics.h"
#include "CbmStsSimModule.h"
#include "CbmStsSimSensor.h"
 
class TClonesArray;
class CbmStsPoint;
class CbmStsParAsic;
class CbmStsParModule;
class CbmStsParSensor;
class CbmStsParSensorCond;
class CbmStsParSetModule;
class CbmStsParSetSensor;
class CbmStsParSetSensorCond;
class CbmStsParSim;
class CbmStsSetup;
class CbmStsSimSensorFactory;
 
 
class CbmStsDigitize : public CbmDigitize<CbmStsDigi> {
 
public:
  CbmStsDigitize();
 
 
  virtual ~CbmStsDigitize();
 
 
  void CreateDigi(Int_t address,
                  UShort_t channel,
                  Long64_t time,
                  UShort_t adc,
                  const CbmMatch& match);
 
 
  ECbmModuleId GetSystemId() const { return ECbmModuleId::kSts; }
 
  virtual void SetParContainers();
 
 
  virtual void Exec(Option_t* opt);
 
 
  Int_t GetNofSignalsF() const { return fNofSignalsF; }
 
 
  Int_t GetNofSignalsB() const { return fNofSignalsB; }
 
 
  void InitSetup();
 
 
  virtual InitStatus ReInit();
 
 
  /*
  void SetModuleParameterMap(std::map<Int_t, CbmStsDigitizeParameters*> parMap) {
    fModuleParameterMap = parMap;
  }
  */
 
 
  void SetGlobalAsicParams(UInt_t nAdc,
                           Double_t dynRange,
                           Double_t threshold,
                           Double_t timeResolution,
                           Double_t deadTime,
                           Double_t noise,
                           Double_t zeroNoiseRate);
 
 
  void SetGlobalModuleParams(UInt_t nChannels, UInt_t nAsicChannels);
 
 
  void SetGlobalSensorConditions(Double_t vDep,
                                 Double_t vBias,
                                 Double_t temperature,
                                 Double_t cCoupling,
                                 Double_t cInterstrip);
 
 
  void SetModuleParameterFile(const char* fileName);
 
 
  void SetProcesses(CbmStsELoss eLossModel,
                    Bool_t useLorentzShift = kTRUE,
                    Bool_t useDiffusion    = kTRUE,
                    Bool_t useCrossTalk    = kTRUE);
 
 
  void SetSensorConditionFile(const char* fileName);
 
 
  void SetSensorParameterFile(const char* fileName);
 
 
  /*
  void SetSensorStripPitch(Double_t pitch) {
    fDigiPar->SetStripPitch(pitch);
  }
  */
 
  void UseOnlyPrimaries(Bool_t flag = kTRUE);
 
 
private:
  Bool_t fIsInitialised;  
 
  //std::map<Int_t, CbmStsDigitizeParameters*> fModuleParameterMap; ///< Individual module parameter map
  CbmStsSetup* fSetup;                               
  CbmStsSimSensorFactory* fSensorFactory = nullptr;  
  TClonesArray* fPoints;  
  TClonesArray* fTracks;  
  TStopwatch fTimer;      
 
  std::map<UInt_t, CbmStsSimModule*> fModules {};
 
  std::map<UInt_t, std::unique_ptr<CbmStsSimSensor>> fSensors {};
 
  // --- Global user-defined parameter settings
  CbmStsParSim* fUserParSim         = nullptr;  
  CbmStsParAsic* fUserParAsic       = nullptr;  
  CbmStsParModule* fUserParModule   = nullptr;  
  CbmStsParSensor* fUserParSensor   = nullptr;  
  CbmStsParSensorCond* fUserParCond = nullptr;  
  Double_t fUserDinactive = 0.;  
 
  // --- Module and sensor parameters for runtime DB output
  CbmStsParSim* fParSim               = nullptr;  
  CbmStsParSetModule* fParSetModule   = nullptr;  
  CbmStsParSetSensor* fParSetSensor   = nullptr;  
  CbmStsParSetSensorCond* fParSetCond = nullptr;  
 
  // --- Default sensor parameters (apply to SensorDssdStereo)
  Double_t fSensorDinact;   
  Double_t fSensorPitch;    
  Double_t fSensorStereoF;  
  Double_t fSensorStereoB;  
 
  // --- Input parameter files
  TString fSensorParameterFile;  
  TString fSensorConditionFile;  
  TString fModuleParameterFile;  
 
  // --- Time of last processed StsPoint (for stream mode)
  Double_t fTimePointLast;
 
  // --- Digi times (for stream mode, in each step)
  Double_t fTimeDigiFirst;  
  Double_t fTimeDigiLast;   
 
  // --- Event counters
  Int_t fNofPointsProc = 0;  
  Int_t fNofPointsIgno = 0;  
  Int_t fNofSignalsF   = 0;  
  Int_t fNofSignalsB   = 0;  
  Int_t fNofDigis      = 0;  
 
  // --- Run counters
  Int_t fNofEvents           = 0;   
  Double_t fNofPointsProcTot = 0;   
  Double_t fNofPointsIgnoTot = 0;   
  Double_t fNofSignalsFTot   = 0;   
  Double_t fNofSignalsBTot   = 0;   
  Double_t fNofDigisTot      = 0;   
  Double_t fNofNoiseTot      = 0;   
  Double_t fTimeTot          = 0.;  
 
 
  Int_t BufferSize() const;
 
 
  std::string BufferStatus() const;
 
 
  virtual void Finish();
 
 
  virtual InitStatus Init();
 
 
  UInt_t InitModules();
 
 
  void InitParams();
 
 
  UInt_t InitSensors();
 
 
  void ProcessAnalogBuffers(Double_t readoutTime);
 
 
  void ProcessMCEvent();
 
 
  void ProcessPoint(const CbmStsPoint* point,
                    Double_t eventTime = 0.,
                    CbmLink* link      = NULL);
 
 
  void ResetCounters();
 
 
  void SetGlobalDefaults();
 
 
  CbmStsDigitize(const CbmStsDigitize&);
  CbmStsDigitize operator=(const CbmStsDigitize&);
 
 
  ClassDef(CbmStsDigitize, 5);
};
 
#endif