SimParam.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef ALICEO2_EMCAL_SIMPARAM_H_
#define ALICEO2_EMCAL_SIMPARAM_H_
 
#include <iosfwd>
#include "CommonUtils/ConfigurableParam.h"
#include "CommonUtils/ConfigurableParamHelper.h"
#include "Rtypes.h"
 
namespace o2
{
namespace emcal
{
 
class SimParam : public o2::conf::ConfigurableParamHelper<SimParam>
{
 public:
  ~SimParam() override = default;
 
  // Parameters used in Digitizer
  Int_t getDigitThreshold() const { return mDigitThreshold; }
  Float_t getPinNoise() const { return mPinNoise; }
  Float_t getPinNoiseLG() const { return mPinNoiseLG; }
  Float_t getTimeResolutionPar0() const { return mTimeResolutionPar0; }
  Float_t getTimeResolutionPar1() const { return mTimeResolutionPar1; }
  Double_t getTimeResolution(Double_t energy) const;
  Int_t getNADCEC() const { return mNADCEC; }
  Int_t getMeanPhotonElectron() const { return mMeanPhotonElectron; }
  Float_t getGainFluctuations() const { return mGainFluctuations; }
  Float_t getTimeResponseTau() const { return mTimeResponseTau; }
  Float_t getTimeResponsePower() const { return mTimeResponsePower; }
  Float_t getTimeResponseThreshold() const { return mTimeResponseThreshold; }
  Int_t getBCPhaseSwap() const { return mSwapPhase; }
 
  // Parameters used in TRU Digitizer
  Float_t getPinNoiseTRU() const { return mPinNoiseTRU; }
  Float_t getTimeResponseTauTRU() const { return mTimeResponseTauTRU; }
  Float_t getTimeResponsePowerTRU() const { return mTimeResponsePowerTRU; }
  Float_t getTimeResponseNormalisationTRU() const { return mTimeResponseNormalisationTRU; }
 
  // Parameters used in LZERO
  Float_t getThresholdLZERO() const { return mThresholdLZERO; }
 
  // Parameters used in SDigitizer
  Float_t getA() const { return mA; }
  Float_t getB() const { return mB; }
  Float_t getECPrimaryThreshold() const { return mECPrimThreshold; }
 
  Float_t getSignalDelay() const { return mSignalDelay; }
  unsigned int getTimeBinOffset() const { return mTimeWindowStart; }
  Float_t getLiveTime() const { return mLiveTime; }
  Float_t getBusyTime() const { return mBusyTime; }
  Float_t getPreTriggerTime() const { return mPreTriggerTime; }
 
  Bool_t doSmearEnergy() const { return mSmearEnergy; }
  Bool_t doSimulateTimeResponse() const { return mSimulateTimeResponse; }
  Bool_t doRemoveDigitsBelowThreshold() const { return mRemoveDigitsBelowThreshold; }
  Bool_t doSimulateNoiseDigits() const { return mSimulateNoiseDigits; }
  Bool_t doSimulateL1Phase() const { return mSimulateL1Phase; }
 
  Bool_t isDisablePileup() const { return mDisablePileup; }
 
  void PrintStream(std::ostream& stream) const;
 
  // Digitizer
  Int_t mDigitThreshold{3};              
  Int_t mMeanPhotonElectron{4400};       
  Float_t mGainFluctuations{15.};        
  Float_t mPinNoise{0.012};              
  Float_t mPinNoiseLG{0.1};              
  Float_t mTimeResolutionPar0{0.26666};  
  Float_t mTimeResolutionPar1{1.4586};   
  Int_t mNADCEC{0x10000};                
  Float_t mTimeResponseTau{2.35};        
  Float_t mTimeResponsePower{2};         
  Float_t mTimeResponseThreshold{0.001}; 
  Int_t mSwapPhase{0};                   
 
  // TRU Digitizer
  Float_t mPinNoiseTRU{0.04};                                         
  Float_t mTimeResponseTauTRU{61.45 / 25.};                           
  Float_t mTimeResponsePowerTRU{2.};                                  
  Float_t mTimeResponseNormalisationTRU{(5. / 3.93) * (45. / 39.25)}; 
 
  // LZERO peak finding
  Float_t mThresholdLZERO{132.}; 
 
  // SDigitizer
  Float_t mA{0.};                 
  Float_t mB{1.e+6};              
  Float_t mECPrimThreshold{0.05}; 
 
  // Timing
  Float_t mSignalDelay{600};          
  unsigned int mTimeWindowStart{400}; 
  Float_t mLiveTime{1500};            
  Float_t mBusyTime{35000};           
  Float_t mPreTriggerTime{600};       
 
  // Processing
  Bool_t mSmearEnergy{true};                
  Bool_t mSimulateTimeResponse{true};       
  Bool_t mRemoveDigitsBelowThreshold{true}; 
  Bool_t mSimulateNoiseDigits{true};        
  bool mSimulateL1Phase{true};              
 
  // DigitizerSpec
  Bool_t mDisablePileup{false}; 
 
  O2ParamDef(SimParam, "EMCSimParam");
};
 
std::ostream& operator<<(std::ostream& stream, const SimParam& s);
 
} // namespace emcal
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::emcal::SimParam> : std::true_type {
};
} // namespace framework
 
} // namespace o2
 
#endif