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 SetReadoutInterval(Double_t value) { fReadoutInterval = value; }
 

  void SetSensorConditionFile(const char* fileName);
 

  void SetSensorParameterFile(const char* fileName);
 

  /*
  void SetSensorStripPitch(Double_t pitch) {
    fDigiPar->SetStripPitch(pitch);
  }
  */

  void UseOnlyPrimaries(Bool_t flag = kTRUE);

  bool SetAsicParamsFromFile(const char* filename);
 
 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;                                 
  Double_t fReadoutInterval = -1.;                   

  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 stamps
  Double_t fTimePointLast;    
  Double_t fTimeLastReadout;  
  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();
 
 
  // --- File name for parsing ASIC parameters from ASCII file for particular Asics setting
  const char* fAsicParamsFileName = nullptr;

  std::map<std::tuple<UInt_t, Int_t, Int_t>, std::unique_ptr<CbmStsParAsic>> fModuleAsicParams;
 

  void ResetCounters();
 

  void SetGlobalDefaults();
 

  CbmStsDigitize(const CbmStsDigitize&);
  CbmStsDigitize operator=(const CbmStsDigitize&);
 
 
  ClassDef(CbmStsDigitize, 5);
};
 
#endif