This algorithm creates TileDigits from pulses provided by pulse simulator. More...

#include <TileDigitsFromPulse.h>

Inheritance diagram for TileDigitsFromPulse:

Public Member Functions
	TileDigitsFromPulse (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TileDigitsFromPulse ()
virtual StatusCode	initialize () override
	initialize method
virtual StatusCode	execute () override
	execute method
virtual StatusCode	finalize () override
	finalize method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	makeDist (TFile &file, TH1F &hist, const std::string &fileName, const std::string &histName="h_Eopt_hi")
	Method to read distribution from file.
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)
	Fill vector with pile-up amplitudes.
void	addPileUpSample (int gain, int ros, int drawer, int channel)
	Fill only a BC with pile-up amplitude.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_outputContainer
	Name of the output TileDigitsContainer.
const TileHWID *	m_tileHWID {}
std::string	m_infoName
const TileInfo *	m_tileInfo {}
int	m_i_ADCmax {}
TileRawChannelUnit::UNIT	m_rChUnit {TileRawChannelUnit::ADCcounts}
	Units used for the TileRawChannels (ADC, pCb, etc.)(see TileInfo.h)
TileFragHash::TYPE	m_rChType {TileFragHash::Default}
	Type of TileRawChannels (Digitizar, OF1, OF2, Fit, etc.)(see TileFragHash.h)
ToolHandle< TileCondToolNoiseSample >	m_tileToolNoiseSample
SG::WriteHandleKey< TileDigitsContainer >	m_digitsContainerKey
SG::WriteHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service to use.
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Tile_DigitsMaker", ""}
	Random Stream Name.
double	m_imperfectionMean
	Mean value of pulse shape broadening.
double	m_imperfectionRms
	RMS of pulse shape broadening.
double	m_inTimeAmp
	Amplitude of in-time pulse.
double	m_ootAmp
	Amplitude of out-of-time pulse.
double	m_itOffset
	In-time pulse offset from nominal time.
double	m_ootOffset
	Out-of-time pulse offset from nominal time.
double	m_ped_HG
	Pedestal value for HG if specific channel pedestal is not used.
double	m_ped_LG
	Pedestal value for LG if specific channel pedestal is not used.
bool	m_gaussNoise
	Set to TRUE in order to create noise from double gaussian.
double	m_GNAmpOne
	Amplitude of first gaussian of double gaussian noise.
double	m_GNSigmaOne
	Standard deviation of first gaussian of double gaussian noise.
double	m_GNAmpTwo
	Amplitude of second gaussian of double gaussian noise.
double	m_GNSigmaTwo
	Standard deviation of second gaussian of double gaussian noise.
bool	m_useItADist
	Set to TRUE in order to use a distribution for the in-time amplitude instead of a constant value.
double	m_itAPulseProb
	Probability to add an in-time pulse.
bool	m_useOotADist
	Set to TRUE in order to use a distribution for the out-of-time amplitude instead of a constant value.
float	m_pileUpFraction
	Probability that an out-of-time component will be added.
float	m_gausC2C
	RMS for the in-time pulse offset (channel-to-channel phase variation)
std::string	m_itADistFileName
	Filename of file to use for amplitude distribution of in-time pulses.
std::string	m_ootADistFileName
	Filename of file to use for amplitude distribution of out-of-time pulses.
bool	m_chanPed
	Use channel specific pedestal value if true.
bool	m_chanNoise
	Add channel specific noise.
std::string	m_ootOffsetFileName
	File name for offset timing distribution histogram.
std::string	m_ootOffsetHistName
	Name of the histogram for timing offset distribution.
int	m_AmpDistLowLim
	Set all bins to the left of this bin to 0 in the amplitude distribution histograms.
std::string	m_itADistHistName
	Name of histogram for in-time amplitude distribution.
std::string	m_ootADistHistName
	Name of histogram for out-of-time amplitude distribution.
bool	m_simQIE
	Raw PMT pulses are generated if the option is set to true.
bool	m_simPulseChain
	Simulate continous output of readout for HL-LHC paradigm.
int	m_seed
int	m_BunchSpacing
	Time between pulses in ms 25, 50 or 75.
int	m_nSamples
	number of read out samples
int	m_nPul
	number of pileup pulses
int	m_nPul_eff {}
std::vector< std::vector< std::vector< std::vector< float > > > >	m_PUAmp
bool	m_PhaseII
bool	m_bigain
bool	m_simPUwPoisson
int	m_avgMuForPU
std::string	m_pileupAmpDistFileName
	Filename for PU amplitude distribution histograms.
TilePulseShape *	m_ps [2]
	Class for defining pulse.
TileSampleBuffer *	m_buf {}
	Buffer class to hold generated pulses.
TileSampleGenerator *	m_tsg {}
	Pulse generating class.
TH1F *	m_ootDist
	Histogram to hold the distribution of out-of-time amplitudes.
TH1F *	m_itDist
	Histogram to hold the distribution of in-time amplitudes.
TFile *	m_itFile
	File that holds the distribution of in-time amplitudes.
TFile *	m_ootFile
	File that holds the distribution of out-of-time amplitudes.
TH1F *	m_ootOffsetDist
	Histogram to hold the distribution of out-of-time timing offsets.
TFile *	m_ootOffsetFile
	File that holds the distribution of out-of-time timing offsets.
bool	m_useOffsetHisto
	Internally used to keep track of wether a histogram has been opened or not.
TFile *	m_pileup_AmpDistFile
	File containing amplitude histograms for PU pulses.
std::vector< std::vector< TH1F * > >	m_pileup_AmpDists
	Matrix of PU amplitude distribution histograms (PU per partition and channel)
float	m_sample_tru = 0
std::unique_ptr< TRandom3 >	m_random
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This algorithm creates TileDigits from pulses provided by pulse simulator.

Definition at line 89 of file TileDigitsFromPulse.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileDigitsFromPulse()

TileDigitsFromPulse::TileDigitsFromPulse	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 61 of file TileDigitsFromPulse.cxx.

                                                                                        :
  AthAlgorithm(name, pSvcLocator)
{
 
    declareProperty("ImperfectionMean", m_imperfectionMean = 1.01);
    declareProperty("ImperfectionRms", m_imperfectionRms = 0.02);
    declareProperty("InTimeAmp", m_inTimeAmp = 300.);
    declareProperty("OutOfTimeAmp", m_ootAmp = 150.);
    declareProperty("InTimeOffset", m_itOffset = 0.);
    declareProperty("OutOfTimeOffset", m_ootOffset = 50.);
    declareProperty("OutOfTimeOffsetHistogramFile", m_ootOffsetFileName = "");
    declareProperty("OutOfTimeOffsetHistogramName", m_ootOffsetHistName = "");
    declareProperty("UseGaussNoise", m_gaussNoise = kFALSE);
    declareProperty("GaussNoiseAmpOne", m_GNAmpOne = 1 / 1.039);
    declareProperty("GaussNoiseSigmaOne", m_GNSigmaOne = 1.6);
    declareProperty("GaussNoiseAmpTwo", m_GNAmpTwo = 0.039);
    declareProperty("GaussNoiseSigmaTwo", m_GNSigmaTwo = 3.6);
    declareProperty("UseInTimeAmpDist", m_useItADist = kFALSE);
    declareProperty("UseOutOfTimeAmpDist", m_useOotADist = kFALSE);
    declareProperty("InTimeAmpDistFileName", m_itADistFileName = "");
    declareProperty("InTimeAmpPulseProb", m_itAPulseProb = 0);
    declareProperty("OutOfTimeAmpDistFileName", m_ootADistFileName = "");
    declareProperty("PileUpFraction", m_pileUpFraction = 1);
    declareProperty("GaussianC2CPhaseVariation", m_gausC2C = 0);
    declareProperty("ChannelSpecificPedestal", m_chanPed = kFALSE);
    declareProperty("ChannelSpecificNoise", m_chanNoise = kFALSE);
    declareProperty("PedestalValueHG", m_ped_HG = 100);
    declareProperty("PedestalValueLG", m_ped_LG = 100);
    declareProperty("AmpDistLowerLimit", m_AmpDistLowLim = 135);
    declareProperty("InTimeAmpDistHistogramName", m_itADistHistName = "h_Eopt_hi");
    declareProperty("OutOfTimeAmpDistHistogramName", m_ootADistHistName = "h_Eopt_hi");
 
    declareProperty("SimulatePileUpWithPoiss", m_simPUwPoisson = kFALSE); 
    declareProperty("AvgMuForPileUpSimulation", m_avgMuForPU = 40);
    declareProperty("PileUpAmpDistFileName", m_pileupAmpDistFileName = "");
 
    declareProperty("RandomSeed", m_seed = 4357);
    declareProperty("BunchSpacing", m_BunchSpacing = 25.); // 25, 50 or 75
    declareProperty("SimulateQIE", m_simQIE = kFALSE);
    declareProperty("SimulatePulseChain",m_simPulseChain = kFALSE);
 
    declareProperty("TileInfoName", m_infoName = "TileInfo");
    declareProperty("TilePhaseII", m_PhaseII = kFALSE);
    declareProperty("Bigain", m_bigain = kFALSE);
    declareProperty("NSamples", m_nSamples = 7); 
    declareProperty("NPulses", m_nPul = 21);
 
    //Initialisations
    m_ps[0] = new TilePulseShape(msgSvc(), "TilePulseShapeLo"); //Low Gain
    m_ps[1] = new TilePulseShape(msgSvc(), "TilePulseShapeHi"); //High Gain
 
    
    m_itFile = new TFile();
    m_itDist = new TH1F();
    m_ootFile = new TFile();
    m_ootDist = new TH1F();
    m_ootOffsetDist = new TH1F();
    m_ootOffsetFile = new TFile();
 
    m_pileup_AmpDistFile = new TFile();
 
    m_useOffsetHisto = kFALSE;
 
}

◆ ~TileDigitsFromPulse()

TileDigitsFromPulse::~TileDigitsFromPulse ( )

virtual

Definition at line 126 of file TileDigitsFromPulse.cxx.

                                          {
 
    delete m_ootOffsetFile;
    delete m_ootFile;
    delete m_itFile;
    delete m_pileup_AmpDistFile;
    
    delete m_ps[0];
    delete m_ps[1];
}

Member Function Documentation

◆ addPileUp()

void TileDigitsFromPulse::addPileUp	(	double &	n_inTimeAmp,
		int	gain,
		int	ros,
		int	drawer,
		int	channel )

private

Fill vector with pile-up amplitudes.

Definition at line 711 of file TileDigitsFromPulse.cxx.

                                                                                                   {
        //Pileup samples
        double amp_1;
        double amp_2;
        double mu = 0; //Interaction per bunch crossing for PU simulation
        if(gain == 1){
                for (int i = 0; i <= m_nPul_eff; i++) {
                        if (((i * 25) % m_BunchSpacing) == 0) {
                                if(m_simPUwPoisson){
                                        mu=m_random->Poisson(m_avgMuForPU);
                                        ATH_MSG_VERBOSE("Effective pulse number " << i);
                                        ATH_MSG_VERBOSE("Number of interactions for simulation: " << mu );
 
                                        for (int imu = 0; imu<mu; imu++){
 
                                                if (m_random->Rndm() < m_pileUpFraction){
                                                        amp_1 = m_pileup_AmpDists[ros-1][channel]->GetRandom();
                                                }
                                                else{
                                                        amp_1 = 0;
                                                }
 
                                                if (m_random->Rndm() < m_pileUpFraction){
                                                        amp_2 = m_pileup_AmpDists[ros-1][channel]->GetRandom();
                                                }
                                                else{
                                                        amp_2 = 0;
                                                }
 
                                                ATH_MSG_VERBOSE("Random amplitudes for PU: " << amp_1 << " " << amp_2);
                                                if(i==0){
                                                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff] += amp_1;
                                                }
                                                else{
                                                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] += amp_1;
                                                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] += amp_2;
                                                }
                                        }
 
                                        if(m_PUAmp[ros-1][drawer][channel][m_nPul_eff] < 0) m_PUAmp[ros-1][drawer][channel][m_nPul_eff] = 0;
                                        if(m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] < 0) m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] = 0;
                                        if(m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] < 0) m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] = 0;
 
                                        ATH_MSG_VERBOSE("Final amplitudes for pulse " << m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] << " " << m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i]);
                                }
                                else{
                                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp;
                                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp;
                                }
 
                if(m_simPulseChain){ // Special treatment for pulse-chain simulation, add in-time pulses when initializing true-amp vector
                  if (m_random->Rndm() < m_itAPulseProb){
                    amp_1 = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
                  } else{
                    amp_1 = 0;
                  }
 
                  if (m_random->Rndm() < m_itAPulseProb){
                    amp_2 = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
                  } else{
                    amp_2 = 0;
                  }
 
                  if(i==0){
                    m_PUAmp[ros-1][drawer][channel][m_nPul_eff] += amp_1;
                  }
                  else{
                    m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] += amp_1;
                    m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] += amp_2;
                  }
                }
                        } else {
                                m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] = 0;
                                m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] = 0;
                        }
                }
        }
        else if (gain == 0)
        {
                double scaleFactor = m_PhaseII ? 40 : 64;
                n_inTimeAmp /= scaleFactor;
                for (int i = 0; i <= m_nPul_eff; i++) {
                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff + i] /= scaleFactor;
                        m_PUAmp[ros-1][drawer][channel][m_nPul_eff - i] /= scaleFactor;
                }
        }
}

◆ addPileUpSample()

void TileDigitsFromPulse::addPileUpSample	(	int	gain,
		int	ros,
		int	drawer,
		int	channel )

private

Fill only a BC with pile-up amplitude.

Definition at line 799 of file TileDigitsFromPulse.cxx.

                                                                                    {
 
    double amp = 0;
    double mu = 0; //Interaction per bunch crossing for PU simulation
 
    auto random = std::make_unique<TRandom3>(m_seed);
 
    mu=random->Poisson(m_avgMuForPU);
 
    if(gain == 1){
        for (int imu = 0; imu<mu; imu++){
            if (random->Rndm() < m_pileUpFraction){
                amp = m_pileup_AmpDists[ros-1][channel]->GetRandom();
            }
            else{
                amp = 0;
            }
 
            m_PUAmp[ros-1][drawer][channel].front() += amp;
        }
    }
    else if (gain == 0)
    {
        if(!m_PhaseII){
            m_PUAmp[ros-1][drawer][channel].front() /= 64;
        }
        else{
            m_PUAmp[ros-1][drawer][channel].front() /= 40;
        }
    }
 
    if(m_PUAmp[ros-1][drawer][channel].front() < 0) m_PUAmp[ros-1][drawer][channel].front() = 0;
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode TileDigitsFromPulse::execute ( )

overridevirtual

execute method

< Local loop variable for amplitude of in-time pulse

Definition at line 271 of file TileDigitsFromPulse.cxx.

                                        {
 
    ATH_MSG_DEBUG("in execute()");
 
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    // Prepare RNG service
    ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
    rngWrapper->setSeed( m_randomStreamName, ctx );
 
    // Create new container for digits
    auto digitsContainer = std::make_unique<TileMutableDigitsContainer>(true,
                                                                            TileFragHash::Digitizer,
                                                                            TileRawChannelUnit::ADCcounts,
                                                                            SG::VIEW_ELEMENTS);
 
        ATH_CHECK( digitsContainer->status() );
 
    //Create RawChannel for truth values.
    auto rawChannelContainer = std::make_unique<TileMutableRawChannelContainer>(true, m_rChType, m_rChUnit);
        ATH_CHECK( rawChannelContainer->status() );
 
    DataPool < TileDigits > tileDigitsPool(m_tileHWID->adc_hash_max());
 
    double tFit = 0, ped = 100; //Settings for simulation 
 
    TF1 *pdf = new TF1();
    TF1 *pdf_PhaseI = new TF1();
    TF1 *pdf_lo = new TF1();
    TF1 *pdf_hi = new TF1();
    if (!m_simQIE) {
        
 
        if(m_PhaseII){
          Double_t sigma_lo = 1; //Noise value obtained from ATL-COM-TILECAL-2020-031
            pdf_lo = new TF1("pdf_lo","(1/(sqrt(2*pi)*[0])) * (exp(-0.5*(x/[0])**2)/(sqrt(2*pi)*[0]))", -100, 100);
            pdf_lo->SetParameter(0,sigma_lo);
 
            Double_t sigma_hi = 2.5; //Noise value obtained from ATL-COM-TILECAL-2020-031
            pdf_hi = new TF1("pdf_hi","(1/(sqrt(2*pi)*[0])) * (exp(-0.5*(x/[0])**2)/(sqrt(2*pi)*[0]))", -100, 100);
            pdf_hi->SetParameter(0,sigma_hi);
        }
        else{
            //Noise pdf for general noise. Maybe use as a member and put in init.
            //pdf = new TF1("pdf", "[0] * (Gaus(x,0,[1]) + [2] * Gaus(x,0,[3]))", -100., 100.); //Root goes not like "Gaus"     
 
            pdf_PhaseI = new TF1("pdf_PhaseI", "[0] * (exp(-0.5*(x/[1])**2)/(sqrt(2*pi)*[1]) + [2] *exp(-0.5*(x/[3])**2)/(sqrt(2*pi)*[3]))", -100., 100.);
            pdf_PhaseI->SetParameters(m_GNAmpOne, m_GNSigmaOne, m_GNAmpTwo, m_GNSigmaTwo);
        }
    }
 
    std::vector<float> samples(m_nSamples);
 
    double Rndm[16]; // Can't use variable size array,
    double Rndm_dG[1]; // uniform random number for the double gaussian
 
    ATH_MSG_DEBUG("Starting loop");
    int gain = 1;
    double n_inTimeAmp = 0.0; 
    float sample = 0.0;
 
    for (int ros = 1; ros < 5; ++ros) {
        for (int drawer = 0; drawer < 64; ++drawer) {
            unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
            for (int channel = 0; channel < 48; ++channel) {
 
                if (!m_simQIE && !m_simPulseChain) { //3-in-1 or FENICS is simulated below
 
                    if(m_PhaseII){
                        ATH_MSG_VERBOSE("executing FENICS code");
                    }
                    else{
                        ATH_MSG_VERBOSE("executing 3-in-1 code");
                    }
                    
 
                    bool isHGSaturated = false;
 
                    for (int igain = 1; igain >= 0; igain--) {
 
                        gain = igain;
                        if (m_chanPed){
                          ped = m_tileToolNoiseSample->getPed(drawerIdx, channel, gain, TileRawChannelUnit::ADCcounts, ctx);
                        }
                        else{
                          ped = (gain == 1) ? m_ped_HG : m_ped_LG;
                        }
 
                        if (gain == 1) {
                            n_inTimeAmp = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
 
                            if (m_random->Rndm() >= m_pileUpFraction){
                                    m_ootAmp = 0; //Set oot amplitude to 0 if no pile-up.
                            }
                            tFit = m_random->Gaus(0., m_gausC2C); //C2C phase variation
                            double deformatedTime = m_random->Gaus(m_imperfectionMean, m_imperfectionRms); //Widening of pulseshape
                            m_ps[gain]->scalePulse(deformatedTime, deformatedTime); // Deformation of pulse shape by changing its width
                            //if(m_useOffsetHisto) m_ootOffset = m_ootOffsetDist->GetRandom();  //OLD Remove for 7 samples -> BunchSpacing
 
                            // Make sure m_PUAmp[ros-1][drawer][channel] has m_nPul elements, all zero
                            m_PUAmp[ros-1][drawer][channel].assign(m_nPul, 0.0);
                            
                            // Fill amplitudes (including pile-up) for HG
                            addPileUp(n_inTimeAmp, gain, ros, drawer, channel);
 
                        } else {
                            double deformatedTime = m_random->Gaus(m_imperfectionMean, m_imperfectionRms); //Widening of pulseshape
                            m_ps[gain]->scalePulse(deformatedTime, deformatedTime); // Deformation of pulse shape by changing its width
 
                            double scaleFactor = (m_PhaseII ? 40.0 : 64.0);
                            n_inTimeAmp /= scaleFactor;
                            for (auto &ampValue : m_PUAmp[ros-1][drawer][channel]) {
                                    ampValue /= scaleFactor;
                            }
                        }
 
                        if(m_PhaseII && m_gaussNoise){
                            pdf = (gain==1) ? pdf_hi : pdf_lo;
                        }
                        else if(m_gaussNoise){
                            pdf = pdf_PhaseI;
                        }
 
                        m_tsg->setPulseShape(m_ps[gain]);
                        m_tsg->fillNSamples(tFit, ped, n_inTimeAmp, m_PUAmp[ros-1][drawer][channel], pdf, m_gaussNoise, m_itOffset, m_nSamples, m_nPul); // Sum of Intime + PU pulses
 
                        samples.clear();
                        samples.resize(m_nSamples);
                        m_buf->getValueVector(samples);
 
                        if (m_chanNoise) {
                            double Hfn1 = m_tileToolNoiseSample->getHfn1(drawerIdx, channel, gain, ctx);
                            double Hfn2 = m_tileToolNoiseSample->getHfn2(drawerIdx, channel, gain, ctx);
                            double Norm = m_tileToolNoiseSample->getHfnNorm(drawerIdx, channel, gain, ctx);
                            RandGaussQ::shootArray(*rngWrapper, samples.size(), Rndm, 0.0, 1.0);
                            RandFlat::shootArray(*rngWrapper, 1, Rndm_dG, 0.0, 1.0);
                            for (unsigned int js = 0; js < samples.size(); ++js) {
                                //using the same gaussian(sigma) for all samples in one channel in one event
                                if (Rndm_dG[0] < Norm)
                                    samples[js] += (float) Hfn1 * Rndm[js];
                                else
                                    samples[js] += (float) Hfn2 * Rndm[js];
                            }
                        }
 
                        for (unsigned int i = 0; i < samples.size(); ++i) {
                          if (samples[i] >= m_i_ADCmax){
                            isHGSaturated = true;
                            if(m_bigain) samples[i]=m_i_ADCmax;
                          }
                            
                        }
                        
                        if(!m_bigain && !isHGSaturated){
                                break;
                        }
                        
                        ATH_MSG_VERBOSE("New ADC " << ros << "/" << drawer << "/" << channel << "/   saving gain  " << gain);
 
                        TileDigits * digit = tileDigitsPool.nextElementPtr();
                        *digit = TileDigits (m_tileHWID->adc_id(ros, drawer, channel, gain),
                                     std::move(samples));
 
                        ATH_CHECK( digitsContainer->push_back(digit) );
                          
                        auto rawChannel = std::make_unique<TileRawChannel>(digit->adc_HWID(),
                                                     n_inTimeAmp,
                                                     tFit,
                                                     m_ootAmp,
                                                     m_ootOffset);
                          
                        ATH_CHECK( rawChannelContainer->push_back(std::move(rawChannel)) );
 
                    }
 
                    if(!m_bigain){
                            ATH_MSG_VERBOSE("New ADC " << ros << "/" << drawer << "/" << channel << "/   saving gain  " << gain);
 
                        TileDigits * digit = tileDigitsPool.nextElementPtr();
                        *digit = TileDigits (m_tileHWID->adc_id(ros, drawer, channel, gain),
                                     std::move(samples));
 
                        ATH_CHECK( digitsContainer->push_back(digit) );
 
                        auto rawChannel = std::make_unique<TileRawChannel>(digit->adc_HWID(),
                                                     n_inTimeAmp,
                                                     tFit,
                                                     m_ootAmp,
                                                     m_ootOffset);
 
                        ATH_CHECK( rawChannelContainer->push_back(std::move(rawChannel)) );
                    }
 
                } else if (m_simQIE) { //QIE is simulated here --------------------------------------------
 
                    //ATH_MSG_DEBUG("executing QIE code");
 
                    gain = 1; //This is just a place holder. The gain is not used in QIE.
                    n_inTimeAmp = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
                    //if (random->Rndm() >= m_pileUpFraction) //m_pileUpFraction is 1 by default
                    m_ootAmp = 0; //Set oot amplitude to 0 if no pile-up.
                    tFit = 0; //TODO: Introduce jitter of the PMT pulse; random->Gaus(0., m_gausC2C); //C2C phase variation
 
                    //Pileup samples
                    //m_PUAmp.clear();
                    //m_PUAmp.resize(nPul);
                    float my_PUAmp[7] = {0}; //I use an array to store the energies/charges of the out-of-time pulses
 
                    for (int i = 0; i < 7; i++)
                        if ((((i - 3) * 25) % (int) m_BunchSpacing) == 0) {
                            if (i != 3) { //index 3 corresponds to the in-time pulse, the signal
                                my_PUAmp[i] = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp; //out-of-time pulses
                            } else {
                                my_PUAmp[i] = 0;
                            }
                        }
 
                    //fill7SamplesQIE(float t0, float amp_it, float *amp_pu, bool addNoise);
                    m_tsg->fill7SamplesQIE((float) n_inTimeAmp, my_PUAmp); // Sum of In time + out-of-time PU pulses
 
                    samples.clear();
                    samples.resize(m_nSamples);
                    m_buf->getValueVector(samples);
 
                    ATH_MSG_VERBOSE("New ADC " << ros << "/" << drawer << "/" << channel << "/   saving gain  " << gain);
 
                    TileDigits * digit = tileDigitsPool.nextElementPtr();
                    *digit = TileDigits (m_tileHWID->adc_id(ros, drawer, channel, gain),
                             std::move(samples));
                
                    ATH_CHECK( digitsContainer->push_back(digit) );
                
                    auto rawChannel = std::make_unique<TileRawChannel>(digit->adc_HWID(),
                                           n_inTimeAmp,
                                           tFit,
                                           m_ootAmp,
                                           m_ootOffset);
                
                    ATH_CHECK( rawChannelContainer->push_back(std::move(rawChannel)) );
                }
                else if (m_simPulseChain) {
                        ATH_MSG_VERBOSE("executing chain-of-pulses code");
 
                    bool isHGSaturated = false;
 
                    for (int igain = 1; igain >= 0; --igain) {
                              gain = igain;
                              n_inTimeAmp = 0.0;
                              m_ootAmp = 0.0;
                              m_ootOffset = 0.0;
 
                          if (m_random->Rndm() < m_itAPulseProb){
                            n_inTimeAmp = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
                          } else{
                            n_inTimeAmp = 0;
                          }
 
                          // PDF logic for noise
                          if (m_gaussNoise) {
                            if (m_PhaseII) {
                              pdf = (gain == 1) ? pdf_hi : pdf_lo;
                            } else {
                              pdf = pdf_PhaseI;
                            }
                          }
 
                          if (gain == 1) {
                            ped = m_chanPed
                              ? m_tileToolNoiseSample->getPed(drawerIdx, channel, gain,
                                              TileRawChannelUnit::ADCcounts, ctx)
                              : m_ped_HG;
 
                            tFit = m_random->Gaus(0., m_gausC2C);
                            double deformatedTime = m_random->Gaus(m_imperfectionMean, m_imperfectionRms);
                            m_ps[gain]->scalePulse(deformatedTime, deformatedTime);
 
                            // Shift the stored pulses to simulate consecutive BC
                            m_PUAmp[ros-1][drawer][channel].pop_back();
                            m_PUAmp[ros-1][drawer][channel].insert(m_PUAmp[ros-1][drawer][channel].begin(), 0);
 
                            // m_sample_tru is the amplitude for the central BC
                            m_sample_tru = m_PUAmp[ros-1][drawer][channel][(m_nPul - 1) / 2];
 
                            // Fill the new BC at the front
                            addPileUpSample(gain, ros, drawer, channel);
                            m_PUAmp[ros-1][drawer][channel].front() += n_inTimeAmp; // Add amplitude from in-time pulse to true-amp vector
 
                            sample = m_tsg->fillSample(tFit, ped,
                                           m_PUAmp[ros-1][drawer][channel],
                                           pdf, m_gaussNoise,
                                           (int)m_PUAmp[ros-1][drawer][channel].size(),
                                           gain);
                          } else {
                            // Low gain
                            ped = m_chanPed
                              ? m_tileToolNoiseSample->getPed(drawerIdx, channel, gain,
                                              TileRawChannelUnit::ADCcounts, ctx)
                              : m_ped_LG;
 
                            sample = m_tsg->fillSample(tFit, ped,
                                           m_PUAmp[ros-1][drawer][channel],
                                           pdf, m_gaussNoise,
                                           (int)m_PUAmp[ros-1][drawer][channel].size(),
                                           gain);
 
                            // Scale truth amplitude from HG to LG
                            if (m_PhaseII) {
                              m_sample_tru /= 40.0;
                            } else {
                              m_sample_tru /= 64.0;
                            }
                          }
 
                          // Clip the sample
                          if (sample < 0.0) {
                            sample = 0.0;
                          } else if (sample >= m_i_ADCmax) {
                            isHGSaturated = true;
                            if (m_bigain) sample = m_i_ADCmax;
                          }
 
                          samples.clear();
                          samples.push_back(sample);
 
                          ATH_MSG_VERBOSE("New chain ADC " << ros << "/" << drawer << "/" << channel << " - saving gain " << gain);
 
                          TileDigits* digit = tileDigitsPool.nextElementPtr();
                          *digit = TileDigits(m_tileHWID->adc_id(ros, drawer, channel, gain),
                                      std::move(samples));
                          ATH_CHECK(digitsContainer->push_back(digit));
 
                          // Use the “truth” amplitude for rawChannel
                          auto rawChannel = std::make_unique<TileRawChannel>(
                                                     digit->adc_HWID(),
                                                     m_sample_tru,
                                                     tFit,
                                                     m_ootAmp,
                                                     ped);
                          ATH_CHECK(rawChannelContainer->push_back(std::move(rawChannel)));
 
                          // If not bigain, break if HG didn't saturate
                          if (!m_bigain && !isHGSaturated) {
                            break;
                          }
                    }
                }
            }
        }
    }
 
        SG::WriteHandle<TileRawChannelContainer> rawChannelCnt(m_rawChannelContainerKey, ctx);
        ATH_CHECK( rawChannelCnt.record(std::move(rawChannelContainer)) );
 
        SG::WriteHandle<TileDigitsContainer> digitsCnt(m_digitsContainerKey, ctx);
        ATH_CHECK( digitsCnt.record(std::move(digitsContainer)) );
 
    if (!m_simQIE) {
        //delete pdf;
        delete pdf_PhaseI;
        delete pdf_hi;
        delete pdf_lo;
    }
 
    ATH_MSG_DEBUG("Execution completed");
 
    return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

StatusCode TileDigitsFromPulse::finalize ( )

overridevirtual

finalize method

Definition at line 639 of file TileDigitsFromPulse.cxx.

                                         {
    ATH_MSG_DEBUG("in finalize()");
    delete m_buf;
    delete m_tsg;
    
 
    if (m_useItADist)
        m_itFile->Close();
    if (m_useOotADist)
        m_ootFile->Close();
    if (m_simPUwPoisson)
        m_pileup_AmpDistFile->Close();
 
    return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode TileDigitsFromPulse::initialize ( )

overridevirtual

initialize method

Definition at line 140 of file TileDigitsFromPulse.cxx.

                                           {
 
    ATH_MSG_DEBUG("in initialize()");
 
    m_buf = new TileSampleBuffer(m_nSamples, -(m_nSamples-1)*25/2, 25.);
    
    m_tsg = new TileSampleGenerator(m_ps[0], m_buf, false); //Set third parameter to true for debug of the sum of pulses
 
    m_nPul_eff = (m_nPul - 1) / 2; //Used for symetrization of PU in computation
 
    ATH_CHECK(detStore()->retrieve(m_tileHWID, "TileHWID"));
    ATH_CHECK(detStore()->retrieve(m_tileInfo, m_infoName));
    m_i_ADCmax = m_tileInfo->ADCmax();
    ATH_MSG_DEBUG("Max ADC counts TileDigitsFromPulse: " << m_i_ADCmax);
 
        ATH_CHECK(m_tileToolNoiseSample.retrieve());
 
        ATH_CHECK(m_digitsContainerKey.initialize());
        ATH_MSG_INFO("Output digits container: " <<  m_digitsContainerKey.key());
 
        ATH_CHECK(m_rawChannelContainerKey.initialize());
    ATH_MSG_INFO("Output raw channel container: " << m_rawChannelContainerKey.key());
 
 
    //Build pulse shapes
    m_ps[0]->setPulseShape(m_tileInfo->digitsFullShapeLo());
    m_ps[1]->setPulseShape(m_tileInfo->digitsFullShapeHi());
 
    m_random = std::make_unique<TRandom3>(m_seed);
 
    //Initialise distribution histograms if in use
    if (m_useItADist) {
        if (m_itADistFileName.size() == 0) {
            m_itADistFileName = PathResolver::find_file("Distributions_small_h2000_177531_JetTauEtmiss.root", "DATAPATH");
            if (m_itADistFileName.size() == 0) {
                ATH_MSG_FATAL("Could not find input file Distributions_small_h2000_177531_JetTauEtmiss.root");
                return StatusCode::FAILURE;
            }
        }
        if (makeDist(m_itFile, m_itDist, m_itADistFileName, m_itADistHistName) == kFALSE)
            return StatusCode::FAILURE;
        ATH_MSG_DEBUG("Made in-time distribution");
    } else
        delete m_itDist;
 
    if (m_simPUwPoisson){
 
        if (m_pileupAmpDistFileName.size() == 0) {
            m_pileupAmpDistFileName = PathResolver::find_file("Distributions_MB_minbias_inelastic_lowjetphoton_e8314_e7400_s3508.root", "DATAPATH");
            if (m_pileupAmpDistFileName.size() == 0 ) {
                ATH_MSG_FATAL("Could not find input file Distributions_MB_minbias_inelastic_lowjetphoton_e8314_e7400_s3508.root");
                return StatusCode::FAILURE;
            }
 
        }
        if (makeDist(m_pileup_AmpDistFile, m_pileup_AmpDists, m_pileupAmpDistFileName) == kFALSE)
            return StatusCode::FAILURE;
        ATH_MSG_DEBUG("Made PU amp distributions for each partition and channel");
 
    }
 
    if (m_useOotADist) {
        if (m_ootADistFileName.size() == 0) {
            m_ootADistFileName = PathResolver::find_file("Distributions_small_h2000_177531_ZeroBias.root", "DATAPATH");
            if (m_ootADistFileName.size() == 0) {
                ATH_MSG_FATAL("Could not find input file Distributions_small_h2000_177531_ZeroBias.root");
                return StatusCode::FAILURE;
            }
        }
        if (makeDist(m_ootFile, m_ootDist, m_ootADistFileName, m_ootADistHistName) == kFALSE)
            return StatusCode::FAILURE;
        ATH_MSG_DEBUG("Made Oot distribution");
    } else
        delete m_ootDist;
 
    //Initialise timing offset distribution. If filename is empty, use static offset
    if (m_ootOffsetFileName.size() != 0) {
        m_ootOffsetFile = TFile::Open(m_ootOffsetFileName.c_str());
        if (m_ootOffsetFile->IsZombie()) {
            ATH_MSG_WARNING("Error reading offset timing distribution from " << m_ootOffsetFileName << ". Using static timing offset.");
        } else {
            TKey *key = m_ootOffsetFile->FindKey(m_ootOffsetHistName.c_str());
            if (key == 0) {
                ATH_MSG_WARNING("Histogram " << m_ootOffsetHistName << " not found in file " << m_ootOffsetFileName << ". Using static timing offset.");
            } else {
                m_ootOffsetDist = (TH1F*) m_ootOffsetFile->Get(m_ootOffsetHistName.c_str());
                m_useOffsetHisto = kTRUE;
            }
        }
    }
 
    //Start the random number service used to create channel specific noise
    if (!m_rndmSvc.retrieve().isSuccess()) {
        ATH_MSG_FATAL("Could not initialize find Random Number Service.");
        return StatusCode::FAILURE;
    }
    if (m_chanNoise)
        m_gaussNoise = kFALSE; //Make sure channel noise overrides gaussian noise.
 
    m_PUAmp.clear();
    m_PUAmp.resize(4);
    for (int ros = 1; ros < 5; ++ros){
      m_PUAmp[ros-1].clear();
      m_PUAmp[ros-1].resize(64);
 
      for (int drawer = 0; drawer < 64; ++drawer){
        m_PUAmp[ros-1][drawer].clear();
        m_PUAmp[ros-1][drawer].resize(48);
        for (int channel = 0; channel < 48; channel++){
          m_PUAmp[ros-1][drawer][channel].clear();
          m_PUAmp[ros-1][drawer][channel].resize(m_nPul);
        }
      }
    }
 
    for (int ros = 1; ros < 5; ++ros) { // initialize the vector of PU amplitudes
      for (int drawer = 0; drawer < 64; ++drawer){
        for (int channel = 0; channel < 48; ++channel) {
          addPileUp(m_inTimeAmp, 1, ros, drawer, channel); // Initialized for HG, for LG  use the same divided by the HG/LG ratio
        }
      }
    }
 
    ATH_MSG_DEBUG("initialize() successful");
 
    return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ makeDist() [1/2]

bool TileDigitsFromPulse::makeDist	(	TFile *&	file,
		std::vector< std::vector< TH1F * > > &	hists,
		const std::string &	fileName )

private

Definition at line 673 of file TileDigitsFromPulse.cxx.

                                                                                                              {
 
    std::string histName;
    TKey *key;
    TH1F* hist;
 
    file = new TFile(fileName.c_str());
    if (file->IsZombie()) {
      ATH_MSG_FATAL("Error reading amplitude distributions from " << fileName << ".");
      return kFALSE;
    }
 
    for(int ros=0; ros<4; ros++){
 
      hists.push_back(std::vector<TH1F*>());
      for(int channel=0; channel<48; channel++){
 
        histName = "ene_ros_" + std::to_string(ros+1) + "_channel_" + std::to_string(channel+1);
 
        key = file->FindKey(histName.c_str());
        if (key == 0) {
          ATH_MSG_FATAL("Could not find histogram " << histName << " in file " << fileName << ".");
          return kFALSE;
        }
 
        hist = (TH1F*) file->Get(histName.c_str());
 
        for (int i = 0; i < m_AmpDistLowLim; i++)
          hist->SetBinContent(i, 0.); // Puts a cut on the amplitude distribution.
 
        hists[ros].push_back(hist);
        hist->Clear();
      }
    }
 
    return kTRUE;
}

◆ makeDist() [2/2]

bool TileDigitsFromPulse::makeDist	(	TFile *&	file,
		TH1F *&	hist,
		const std::string &	fileName,
		const std::string &	histName = "h_Eopt_hi" )

private

Method to read distribution from file.

Definition at line 655 of file TileDigitsFromPulse.cxx.

                                                                                                                  {
    file = new TFile(fileName.c_str());
    if (file->IsZombie()) {
        ATH_MSG_FATAL("Error reading amplitude distribution from " << fileName << ".");
        return kFALSE;
    }
    TKey *key = file->FindKey(histName.c_str());
    if (key == 0) {
        ATH_MSG_FATAL("Could not find histogram " << histName << " in file " << fileName << ".");
        return kFALSE;
    }
    hist = (TH1F*) file->Get(histName.c_str());
    for (int i = 0; i < m_AmpDistLowLim; i++)
        hist->SetBinContent(i, 0.); // Puts a cut on the amplitude distribution.
    return kTRUE;
 
}

◆ msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_AmpDistLowLim

int TileDigitsFromPulse::m_AmpDistLowLim

private

Set all bins to the left of this bin to 0 in the amplitude distribution histograms.

Definition at line 154 of file TileDigitsFromPulse.h.

◆ m_avgMuForPU

int TileDigitsFromPulse::m_avgMuForPU

private

Definition at line 171 of file TileDigitsFromPulse.h.

◆ m_bigain

bool TileDigitsFromPulse::m_bigain

private

Definition at line 168 of file TileDigitsFromPulse.h.

◆ m_buf

TileSampleBuffer* TileDigitsFromPulse::m_buf {}

private

Buffer class to hold generated pulses.

Definition at line 176 of file TileDigitsFromPulse.h.

176{};

◆ m_BunchSpacing

int TileDigitsFromPulse::m_BunchSpacing

private

Time between pulses in ms 25, 50 or 75.

Definition at line 162 of file TileDigitsFromPulse.h.

◆ m_chanNoise

bool TileDigitsFromPulse::m_chanNoise

private

Add channel specific noise.

Definition at line 151 of file TileDigitsFromPulse.h.

◆ m_chanPed

bool TileDigitsFromPulse::m_chanPed

private

Use channel specific pedestal value if true.

Otherwise, same for all channels.

Definition at line 150 of file TileDigitsFromPulse.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_digitsContainerKey

SG::WriteHandleKey<TileDigitsContainer> TileDigitsFromPulse::m_digitsContainerKey

private

Initial value:

{this,

"TileDigitsContainer", "TileDigitsCnt", "Output Tile digits container key"}

Definition at line 118 of file TileDigitsFromPulse.h.

118 {this,

119 "TileDigitsContainer", "TileDigitsCnt", "Output Tile digits container key"};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_gausC2C

float TileDigitsFromPulse::m_gausC2C

private

RMS for the in-time pulse offset (channel-to-channel phase variation)

Definition at line 147 of file TileDigitsFromPulse.h.

◆ m_gaussNoise

bool TileDigitsFromPulse::m_gaussNoise

private

Set to TRUE in order to create noise from double gaussian.

Definition at line 138 of file TileDigitsFromPulse.h.

◆ m_GNAmpOne

double TileDigitsFromPulse::m_GNAmpOne

private

Amplitude of first gaussian of double gaussian noise.

Definition at line 139 of file TileDigitsFromPulse.h.

◆ m_GNAmpTwo

double TileDigitsFromPulse::m_GNAmpTwo

private

Amplitude of second gaussian of double gaussian noise.

Definition at line 141 of file TileDigitsFromPulse.h.

◆ m_GNSigmaOne

double TileDigitsFromPulse::m_GNSigmaOne

private

Standard deviation of first gaussian of double gaussian noise.

Definition at line 140 of file TileDigitsFromPulse.h.

◆ m_GNSigmaTwo

double TileDigitsFromPulse::m_GNSigmaTwo

private

Standard deviation of second gaussian of double gaussian noise.

Definition at line 142 of file TileDigitsFromPulse.h.

◆ m_i_ADCmax

int TileDigitsFromPulse::m_i_ADCmax {}

private

Definition at line 110 of file TileDigitsFromPulse.h.

110{};

◆ m_imperfectionMean

double TileDigitsFromPulse::m_imperfectionMean

private

Mean value of pulse shape broadening.

Definition at line 130 of file TileDigitsFromPulse.h.

◆ m_imperfectionRms

double TileDigitsFromPulse::m_imperfectionRms

private

RMS of pulse shape broadening.

Definition at line 131 of file TileDigitsFromPulse.h.

◆ m_infoName

std::string TileDigitsFromPulse::m_infoName

private

Definition at line 108 of file TileDigitsFromPulse.h.

◆ m_inTimeAmp

double TileDigitsFromPulse::m_inTimeAmp

private

Amplitude of in-time pulse.

Definition at line 132 of file TileDigitsFromPulse.h.

◆ m_itADistFileName

std::string TileDigitsFromPulse::m_itADistFileName

private

Filename of file to use for amplitude distribution of in-time pulses.

Definition at line 148 of file TileDigitsFromPulse.h.

◆ m_itADistHistName

std::string TileDigitsFromPulse::m_itADistHistName

private

Name of histogram for in-time amplitude distribution.

Definition at line 155 of file TileDigitsFromPulse.h.

◆ m_itAPulseProb

double TileDigitsFromPulse::m_itAPulseProb

private

Probability to add an in-time pulse.

Definition at line 144 of file TileDigitsFromPulse.h.

◆ m_itDist

TH1F* TileDigitsFromPulse::m_itDist

private

Histogram to hold the distribution of in-time amplitudes.

Definition at line 181 of file TileDigitsFromPulse.h.

◆ m_itFile

TFile* TileDigitsFromPulse::m_itFile

private

File that holds the distribution of in-time amplitudes.

Definition at line 182 of file TileDigitsFromPulse.h.

◆ m_itOffset

double TileDigitsFromPulse::m_itOffset

private

In-time pulse offset from nominal time.

Definition at line 134 of file TileDigitsFromPulse.h.

◆ m_nPul

int TileDigitsFromPulse::m_nPul

private

number of pileup pulses

Definition at line 164 of file TileDigitsFromPulse.h.

◆ m_nPul_eff

int TileDigitsFromPulse::m_nPul_eff {}

private

Definition at line 165 of file TileDigitsFromPulse.h.

165{}; //Used for symetrization of PU in computation

◆ m_nSamples

int TileDigitsFromPulse::m_nSamples

private

number of read out samples

Definition at line 163 of file TileDigitsFromPulse.h.

◆ m_ootADistFileName

std::string TileDigitsFromPulse::m_ootADistFileName

private

Filename of file to use for amplitude distribution of out-of-time pulses.

Definition at line 149 of file TileDigitsFromPulse.h.

◆ m_ootADistHistName

std::string TileDigitsFromPulse::m_ootADistHistName

private

Name of histogram for out-of-time amplitude distribution.

Definition at line 156 of file TileDigitsFromPulse.h.

◆ m_ootAmp

double TileDigitsFromPulse::m_ootAmp

private

Amplitude of out-of-time pulse.

Definition at line 133 of file TileDigitsFromPulse.h.

◆ m_ootDist

TH1F* TileDigitsFromPulse::m_ootDist

private

Histogram to hold the distribution of out-of-time amplitudes.

Definition at line 180 of file TileDigitsFromPulse.h.

◆ m_ootFile

TFile* TileDigitsFromPulse::m_ootFile

private

File that holds the distribution of out-of-time amplitudes.

Definition at line 183 of file TileDigitsFromPulse.h.

◆ m_ootOffset

double TileDigitsFromPulse::m_ootOffset

private

Out-of-time pulse offset from nominal time.

Definition at line 135 of file TileDigitsFromPulse.h.

◆ m_ootOffsetDist

TH1F* TileDigitsFromPulse::m_ootOffsetDist

private

Histogram to hold the distribution of out-of-time timing offsets.

Definition at line 184 of file TileDigitsFromPulse.h.

◆ m_ootOffsetFile

TFile* TileDigitsFromPulse::m_ootOffsetFile

private

File that holds the distribution of out-of-time timing offsets.

Definition at line 185 of file TileDigitsFromPulse.h.

◆ m_ootOffsetFileName

std::string TileDigitsFromPulse::m_ootOffsetFileName

private

File name for offset timing distribution histogram.

Definition at line 152 of file TileDigitsFromPulse.h.

◆ m_ootOffsetHistName

std::string TileDigitsFromPulse::m_ootOffsetHistName

private

Name of the histogram for timing offset distribution.

Definition at line 153 of file TileDigitsFromPulse.h.

◆ m_outputContainer

std::string TileDigitsFromPulse::m_outputContainer

private

Name of the output TileDigitsContainer.

Definition at line 103 of file TileDigitsFromPulse.h.

◆ m_ped_HG

double TileDigitsFromPulse::m_ped_HG

private

Pedestal value for HG if specific channel pedestal is not used.

Definition at line 136 of file TileDigitsFromPulse.h.

◆ m_ped_LG

double TileDigitsFromPulse::m_ped_LG

private

Pedestal value for LG if specific channel pedestal is not used.

Definition at line 137 of file TileDigitsFromPulse.h.

◆ m_PhaseII

bool TileDigitsFromPulse::m_PhaseII

private

Definition at line 167 of file TileDigitsFromPulse.h.

◆ m_pileup_AmpDistFile

TFile* TileDigitsFromPulse::m_pileup_AmpDistFile

private

File containing amplitude histograms for PU pulses.

Definition at line 187 of file TileDigitsFromPulse.h.

◆ m_pileup_AmpDists

std::vector<std::vector<TH1F*> > TileDigitsFromPulse::m_pileup_AmpDists

private

Matrix of PU amplitude distribution histograms (PU per partition and channel)

Definition at line 188 of file TileDigitsFromPulse.h.

◆ m_pileupAmpDistFileName

std::string TileDigitsFromPulse::m_pileupAmpDistFileName

private

Filename for PU amplitude distribution histograms.

Definition at line 172 of file TileDigitsFromPulse.h.

◆ m_pileUpFraction

float TileDigitsFromPulse::m_pileUpFraction

private

Probability that an out-of-time component will be added.

Definition at line 146 of file TileDigitsFromPulse.h.

◆ m_ps

TilePulseShape* TileDigitsFromPulse::m_ps[2]

private

Class for defining pulse.

One element for lo gain and one for hi.

Definition at line 175 of file TileDigitsFromPulse.h.

◆ m_PUAmp

std::vector<std::vector<std::vector<std::vector<float> > > > TileDigitsFromPulse::m_PUAmp

private

Definition at line 166 of file TileDigitsFromPulse.h.

◆ m_random

std::unique_ptr<TRandom3> TileDigitsFromPulse::m_random

private

Definition at line 199 of file TileDigitsFromPulse.h.

◆ m_randomStreamName

Gaudi::Property<std::string> TileDigitsFromPulse::m_randomStreamName {this, "RandomStreamName", "Tile_DigitsMaker", ""}

private

Random Stream Name.

Definition at line 126 of file TileDigitsFromPulse.h.

126{this, "RandomStreamName", "Tile_DigitsMaker", ""};

◆ m_rawChannelContainerKey

SG::WriteHandleKey<TileRawChannelContainer> TileDigitsFromPulse::m_rawChannelContainerKey

private

Initial value:

{this,

"TileRawChannelContainer", "TrueAmp", "Output Tile raw channel container key"}

Definition at line 121 of file TileDigitsFromPulse.h.

121 {this,

122 "TileRawChannelContainer", "TrueAmp", "Output Tile raw channel container key"};

◆ m_rChType

TileFragHash::TYPE TileDigitsFromPulse::m_rChType {TileFragHash::Default}

private

Type of TileRawChannels (Digitizar, OF1, OF2, Fit, etc.)(see TileFragHash.h)

Definition at line 113 of file TileDigitsFromPulse.h.

113{TileFragHash::Default};

TileFragHash::Default

@ Default

Definition TileFragHash.h:33

◆ m_rChUnit

TileRawChannelUnit::UNIT TileDigitsFromPulse::m_rChUnit {TileRawChannelUnit::ADCcounts}

private

Units used for the TileRawChannels (ADC, pCb, etc.)(see TileInfo.h)

Definition at line 112 of file TileDigitsFromPulse.h.

112{TileRawChannelUnit::ADCcounts};

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> TileDigitsFromPulse::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Random number service to use.

Definition at line 124 of file TileDigitsFromPulse.h.

124{this, "RndmSvc", "AthRNGSvc", ""};

◆ m_sample_tru

float TileDigitsFromPulse::m_sample_tru = 0

private

Definition at line 197 of file TileDigitsFromPulse.h.

◆ m_seed

int TileDigitsFromPulse::m_seed

private

Definition at line 161 of file TileDigitsFromPulse.h.

◆ m_simPulseChain

bool TileDigitsFromPulse::m_simPulseChain

private

Simulate continous output of readout for HL-LHC paradigm.

Definition at line 159 of file TileDigitsFromPulse.h.

◆ m_simPUwPoisson

bool TileDigitsFromPulse::m_simPUwPoisson

private

Definition at line 170 of file TileDigitsFromPulse.h.

◆ m_simQIE

bool TileDigitsFromPulse::m_simQIE

private

Raw PMT pulses are generated if the option is set to true.

The option is intended to simulate the QIE FEB.

Definition at line 158 of file TileDigitsFromPulse.h.

◆ m_tileHWID

const TileHWID* TileDigitsFromPulse::m_tileHWID {}

private

Definition at line 105 of file TileDigitsFromPulse.h.

105{};

◆ m_tileInfo

const TileInfo* TileDigitsFromPulse::m_tileInfo {}

private

Definition at line 109 of file TileDigitsFromPulse.h.

109{};

◆ m_tileToolNoiseSample

ToolHandle<TileCondToolNoiseSample> TileDigitsFromPulse::m_tileToolNoiseSample

private

Initial value:

{this,

"TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"}

Definition at line 115 of file TileDigitsFromPulse.h.

115 {this,

116 "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"};

◆ m_tsg

TileSampleGenerator* TileDigitsFromPulse::m_tsg {}

private

Pulse generating class.

Definition at line 177 of file TileDigitsFromPulse.h.

177{};

◆ m_useItADist

bool TileDigitsFromPulse::m_useItADist

private

Set to TRUE in order to use a distribution for the in-time amplitude instead of a constant value.

Definition at line 143 of file TileDigitsFromPulse.h.

◆ m_useOffsetHisto

bool TileDigitsFromPulse::m_useOffsetHisto

private

Internally used to keep track of wether a histogram has been opened or not.

Definition at line 186 of file TileDigitsFromPulse.h.

◆ m_useOotADist

bool TileDigitsFromPulse::m_useOotADist

private

Set to TRUE in order to use a distribution for the out-of-time amplitude instead of a constant value.

Definition at line 145 of file TileDigitsFromPulse.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TileDigitsFromPulse()

◆ ~TileDigitsFromPulse()

Member Function Documentation

◆ addPileUp()

◆ addPileUpSample()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ makeDist() [1/2]

◆ makeDist() [2/2]

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_AmpDistLowLim

◆ m_avgMuForPU

◆ m_bigain

◆ m_buf

◆ m_BunchSpacing

◆ m_chanNoise

◆ m_chanPed

◆ m_detStore

◆ m_digitsContainerKey

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_gausC2C

◆ m_gaussNoise

◆ m_GNAmpOne

◆ m_GNAmpTwo

◆ m_GNSigmaOne

◆ m_GNSigmaTwo

◆ m_i_ADCmax

◆ m_imperfectionMean

◆ m_imperfectionRms

◆ m_infoName

◆ m_inTimeAmp

◆ m_itADistFileName

◆ m_itADistHistName

◆ m_itAPulseProb

◆ m_itDist

◆ m_itFile

◆ m_itOffset

◆ m_nPul

◆ m_nPul_eff

◆ m_nSamples

◆ m_ootADistFileName

◆ m_ootADistHistName

◆ m_ootAmp

◆ m_ootDist

◆ m_ootFile

◆ m_ootOffset

◆ m_ootOffsetDist

◆ m_ootOffsetFile

◆ m_ootOffsetFileName

◆ m_ootOffsetHistName

◆ m_outputContainer

◆ m_ped_HG

◆ m_ped_LG

◆ m_PhaseII