TileDigitsFromPulse.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
//****************************************************************************
// Filename : TileDigitsFromPulse.h
// Author   : Simon Molander <simon.molander@cern.ch>
// Created  : Feb 2013
//
// DESCRIPTION
// 
// Create TileDigits from pulse simulator
//
// Properties (JobOption Parameters):
//
//    OutputDigitsContainer        string   Name of container with TileDigits to write
//    ImperfectionMean             double   Mean value of pulse shape broadening
//    ImperfectionRMS              double   RMS of pulse shape broadening
//    InTimeAmp                    double   Amplitude of in-time pulse
//    OutOfTimeAmp                 double   Amplitude of out-of-time pulse
//    InTimeOffset                 double   In-time pulse offset from nominal time
//    OutOfTimeOffset              double   Out-of-time pulse offset from nominal time
//    UseGaussNoise                bool     Set to TRUE in order to create noise from double gaussian
//    GaussNoiseAmpOne             double   Amplitude of first gaussian of double gaussian noise.
//    GaussNoiseSigmaOne           double   Standard deviation of first gaussian of double gaussian noise.
//    GaussNoiseAmpTwo             double   Amplitude of second gaussian of double gaussian noise.
//    GaussNoiseSigmaTwo           double   Standard deviation of second gaussian of double gaussian noise.    
//    UseInTimeAmpDist             bool     Set to TRUE in order to use a distribution for the in-time amplitude instead of a const.
//    UseOutOfTimeAmpDist          bool     Set to TRUE in order to use a distribution for the out-of-time amplitude instead of a const.
//    InTimeAmpDistFileName        string   Filename of file to use for amplitude distribution of in-time pulses
//    OutOfTimeAmpDistFileName     string   Filename of file to use for amplitude distribution of out-of-time pulses
//    PileUpFraction               float    Probability that an out-of-time component will be added
//    GaussianC2CPhaseVariation    float    RMS for the in-time pulse offset (channel-to-channel phase variation)
//    ChannelSpecificPedestal      bool     Set to TRUE in order to use a channel specific value for the pedestal
//    ChannelSpecificNoise         bool     Set to TRUE in order to add channel specific noise
//    OutOfTimeOffsetHistogramFile string   Filename of file containing histogram of pile-up timing distribution
//    OutOfTimeOffsetHistogramName string   name of the histogram to use for pile-up timing distribution
//    AmpDistLowerLimit            int      Set all bins lower than this to zero. Default = 135.
//    InTimeAmpDistHistogramName   string   Name of the histogram to use for in-time amplitude distribution
//    OutOfTimeAmpDistHistogramName   string   Name of the histogram to use for out-of-time amplitude distribution
//
// BUGS:
//  
// History:
//  
//  
//****************************************************************************
 
#ifndef TILESIMALGS_TILEDIGITSFROMPULSE_H
#define TILESIMALGS_TILEDIGITSFROMPULSE_H
 
// Tile includes
#include "TileEvent/TileDigitsContainer.h"
#include "TileEvent/TileRawChannelContainer.h"
#include "TileConditions/TileCondToolNoiseSample.h"
 
// Athena includes
#include "AthenaBaseComps/AthAlgorithm.h"
#include "StoreGate/WriteHandleKey.h"
 
// Gaudi includes
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "CLHEP/Random/RandomEngine.h"
 
//C++ STL includes
#include <vector>
#include <string>
 
//Simulation includes
class TileSampleGenerator;
class TileSampleBuffer;
class TilePulseShape;
 
class TileHWID;
class TileInfo;
class IAthRNGSvc;
 
class TH1F;
class TFile;
class TRandom3;

class TileDigitsFromPulse : public AthAlgorithm {
public:
    // Constructor
    TileDigitsFromPulse(const std::string& name, ISvcLocator* pSvcLocator);
 
    //Destructor 
    virtual ~TileDigitsFromPulse();                         
    
    //Gaudi Hooks
    virtual StatusCode initialize() override; 
    virtual StatusCode execute() override;    
    virtual StatusCode finalize() override;   
 
private:
    std::string m_outputContainer; 
    
    const TileHWID* m_tileHWID{};
    
    // TileInfo
    std::string m_infoName;
    const TileInfo* m_tileInfo{};
    int m_i_ADCmax{};
    
    TileRawChannelUnit::UNIT m_rChUnit{TileRawChannelUnit::ADCcounts}; 
    TileFragHash::TYPE m_rChType{TileFragHash::Default}; 
    
    ToolHandle<TileCondToolNoiseSample> m_tileToolNoiseSample{this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"};
 
    SG::WriteHandleKey<TileDigitsContainer> m_digitsContainerKey{this,
        "TileDigitsContainer", "TileDigitsCnt", "Output Tile digits container key"};
 
    SG::WriteHandleKey<TileRawChannelContainer> m_rawChannelContainerKey{this,
        "TileRawChannelContainer", "TrueAmp", "Output Tile raw channel container key"};
    
    ServiceHandle <IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  
    Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "Tile_DigitsMaker", ""};
 
    
    //Parameters
    double m_imperfectionMean; 
    double m_imperfectionRms; 
    double m_inTimeAmp; 
    double m_ootAmp; 
    double m_itOffset; 
    double m_ootOffset; 
    double m_ped_HG; 
    double m_ped_LG; 
    bool m_gaussNoise; 
    double m_GNAmpOne; 
    double m_GNSigmaOne; 
    double m_GNAmpTwo; 
    double m_GNSigmaTwo; 
    bool m_useItADist; 
    double m_itAPulseProb; 
    bool m_useOotADist; 
    float m_pileUpFraction; 
    float m_gausC2C; 
    std::string m_itADistFileName; 
    std::string m_ootADistFileName; 
    bool m_chanPed; 
    bool m_chanNoise; 
    std::string m_ootOffsetFileName; 
    std::string m_ootOffsetHistName; 
    int m_AmpDistLowLim; 
    std::string m_itADistHistName; 
    std::string m_ootADistHistName; 
    
    bool m_simQIE; 
    bool m_simPulseChain; 
 
    int m_seed;
    int m_BunchSpacing; 
    int m_nSamples;  
    int m_nPul;  
    int m_nPul_eff{};  //Used for symetrization of PU in computation
    std::vector<std::vector<std::vector<std::vector<float>>>> m_PUAmp; // Used to store PU amplitudes
    bool m_PhaseII; //Use parameters of TilePhaseII if the option is set to true
    bool m_bigain; //If true, save the two gains in the ntuples
 
    bool m_simPUwPoisson; //If true, simulate PU overlapping amplitudes n times, with n being generated with a poissonian distribution 
    int m_avgMuForPU; //Mean of the poissonian distribution to generate the number of interactions per bunch crossing for PU simulation
    std::string m_pileupAmpDistFileName; 
 
    //Members for simulator
    TilePulseShape*      m_ps[2]; 
    TileSampleBuffer*    m_buf{}; 
    TileSampleGenerator* m_tsg{}; 
    
    //Histograms for distribution
    TH1F* m_ootDist; 
    TH1F* m_itDist; 
    TFile* m_itFile; 
    TFile* m_ootFile; 
    TH1F* m_ootOffsetDist; 
    TFile* m_ootOffsetFile; 
    bool m_useOffsetHisto; 
    TFile* m_pileup_AmpDistFile; 
    std::vector<std::vector<TH1F*>> m_pileup_AmpDists; 
 
    //Internal methods
    bool makeDist(TFile*& file, TH1F*& hist, const std::string& fileName, const std::string& histName="h_Eopt_hi"); 
    bool makeDist(TFile*& file, std::vector<std::vector<TH1F*>>& hists, const std::string& fileName);
 
    void addPileUp(double &n_inTimeAmp, int gain, int ros, int drawer, int channel); 
    void addPileUpSample(int gain, int ros, int drawer, int channel); 
 
    float m_sample_tru = 0;
 
    std::unique_ptr<TRandom3> m_random;
};
 
#endif // TILESIMALGS_TILEDIGITSFROMPULSE_H