dd/d11/TileDigitsFromPulse_8h_source.html

/*

  Copyright (C) 2002-2023 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"


#include <string>


//Simulation includes

class TileSampleGenerator;

class TileSampleBuffer;

class TilePulseShape;


class TileHWID;

class TileInfo;

class IAthRNGSvc;


class TH1F;

class TFile;


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;

    TileFragHash::TYPE m_rChType;


    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;

    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;


    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<float> m_PUAmp;

    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);


};


#endif // TILESIMALGS_TILEDIGITSFROMPULSE_H