CbmStsDigitize.h

Go to the documentation of this file.

/* Copyright (C) 2014-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */
 
#ifndef CBMSTSDIGITIZE_H
#define CBMSTSDIGITIZE_H 1
 
#include "CbmDefs.h"
#include "CbmDigitize.h"
#include "CbmMatch.h"
#include "CbmStsDefs.h"
#include "CbmStsDigi.h"
#include "CbmStsPhysics.h"
#include "CbmStsSimModule.h"
#include "CbmStsSimSensor.h"
 
#include "TStopwatch.h"
 
#include <map>
 
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(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold,
                           Double_t timeResolution, Double_t deadTime, Double_t noise, Double_t zeroNoiseRate);
 
 
  void SetGlobalFracDeadChannels(Double_t fraction) { fUserFracDeadChan = fraction; }
 
 
  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.;       
  Double_t fUserFracDeadChan        = 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.;  
 
  // --- List of inactive channels
  // --- We do not use the base class here since STS channels are identified not only by
  // --- CbmAddress like in all other detectors, but by address plus channel number.
  std::map<Int_t, std::set<UShort_t>> fInactiveChannelsSts = {};
 
 
  Int_t BufferSize() const;
 
 
  std::string BufferStatus() const;
 
 
  virtual void Finish();
 
 
  virtual InitStatus Init();
 
 
  UInt_t InitModules();
 
 
  void InitParams();
 
 
  UInt_t InitSensors();
 
 
  bool IsChannelActiveSts(Int_t address, UShort_t channel);
 
 
  void ProcessAnalogBuffers(Double_t readoutTime);
 
 
  void ProcessMCEvent();
 
 
  void ProcessPoint(const CbmStsPoint* point, Double_t eventTime, const CbmLink& link);
 
 
  std::pair<size_t, bool> ReadInactiveChannels();
 
 
  void ResetCounters();
 
 
  void SetGlobalDefaults();
 
 
  CbmStsDigitize(const CbmStsDigitize&);
  CbmStsDigitize operator=(const CbmStsDigitize&);
 
 
  ClassDef(CbmStsDigitize, 5);
};
 
#endif