TileDigitsFromPulse Class Reference

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

#include <TileDigitsFromPulse.h>

Inheritance diagram for TileDigitsFromPulse:

Collaboration diagram for TileDigitsFromPulse:

Public Member Functions
	TileDigitsFromPulse (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TileDigitsFromPulse ()
virtual StatusCode	initialize () override
	initialize method More...
virtual StatusCode	execute () override
	execute method More...
virtual StatusCode	finalize () override
	finalize method More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

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. More...
bool	makeDist (TFile *&file, std::vector< std::vector< TH1F * >> &hists, const std::string &fileName)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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

Detailed Description

This algorithm creates TileDigits from pulses provided by pulse simulator.

Definition at line 86 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),
  m_tileHWID(0),
  m_tileInfo(0),
  m_i_ADCmax(0),
  m_nPul_eff(0),
  m_buf(nullptr),
  m_tsg(nullptr)
{
    m_rChUnit = TileRawChannelUnit::ADCcounts;
    m_rChType = TileFragHash::Default;
 
    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("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("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 132 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

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  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.

{ return m_detStore; }

evtStore() [1/2]

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.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TileDigitsFromPulse::execute ( )

overridevirtual

execute method

< Local loop variable for amplitude of in-time pulse

Definition at line 252 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());
 
    TRandom3 *random = new TRandom3(m_seed); //Randomizer for pulse-shape imperfection
    double tFit = 0, ped = 100; //Settings for simulation 
    double mu = 0; //Interaction per bunch crossing for PU 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
 
    double amp_1;
    double amp_2;
 
    ATH_MSG_DEBUG("Starting loop");
    int gain = 1;
    double n_inTimeAmp = 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) { //3-in-1 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 (gain == 1) {
                            n_inTimeAmp = m_useItADist ? m_itDist->GetRandom() : m_inTimeAmp;
 
                            if (m_chanPed){
                                ped = m_tileToolNoiseSample->getPed(drawerIdx, channel, gain, TileRawChannelUnit::ADCcounts, ctx);
                            }
                            else{
                                ped = m_ped_HG;
                            }
                            if (random->Rndm() >= m_pileUpFraction)
                              m_ootAmp = 0; //Set oot amplitude to 0 if no pile-up.
                            tFit = random->Gaus(0., m_gausC2C); //C2C phase variation
                            double deformatedTime = 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
 
                            //Pileup samples
                            m_PUAmp.clear();
                            m_PUAmp.resize(m_nPul);
 
                            for (int i = 0; i <= m_nPul_eff; i++) {
                                if (((i * 25) % m_BunchSpacing) == 0) {
                                    if(m_simPUwPoisson){
                                        mu=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++){
 
                                            amp_1 = m_pileup_AmpDists[ros-1][channel]->GetRandom();
                                            amp_2 = m_pileup_AmpDists[ros-1][channel]->GetRandom();
 
                                            ATH_MSG_VERBOSE("Random amplitudes for PU: " << amp_1 << " " << amp_2);
 
                                            if(i==0){
                                                m_PUAmp.at(m_nPul_eff) += abs(amp_1);
                                            }
                                            else{
                                                m_PUAmp.at(m_nPul_eff + i) += abs(amp_1);
                                                m_PUAmp.at(m_nPul_eff - i) += abs(amp_2);
                                            }
                                        }
 
                                        ATH_MSG_VERBOSE("Final amplitudes for pulse " << m_PUAmp.at(m_nPul_eff + i) << " " << m_PUAmp.at(m_nPul_eff - i));
                                    }
                                    else{
                                        m_PUAmp.at(m_nPul_eff + i) = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp;
                                        m_PUAmp.at(m_nPul_eff - i) = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp;
                                    }
                                } else {
                                    m_PUAmp.at(m_nPul_eff + i) = 0;
                                    m_PUAmp.at(m_nPul_eff - i) = 0;
                                }
                            }
                            
                        
                        } else {
                            if (m_chanPed)
                                ped = m_tileToolNoiseSample->getPed(drawerIdx, channel, gain, TileRawChannelUnit::ADCcounts, ctx);
                            double deformatedTime = 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_chanPed)
                                ped = m_tileToolNoiseSample->getPed(drawerIdx, channel, gain, TileRawChannelUnit::ADCcounts, ctx);
 
                            else{
                                ped=m_ped_LG;
                            }
                            
                            if(!m_PhaseII){
                              n_inTimeAmp /= 64;
                              for (int i = 0; i <= m_nPul_eff; i++) {
                                m_PUAmp.at(m_nPul_eff + i) /= 64;
                                m_PUAmp.at(m_nPul_eff - i) /= 64;
                              }
                            } else{
                              n_inTimeAmp /= 40; 
                              for (int i = 0; i <= m_nPul_eff; i++) {
                                m_PUAmp.at(m_nPul_eff + i) /= 40;
                                m_PUAmp.at(m_nPul_eff - i) /= 40;
                              }
                            }
                        }
 
                        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, 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){
                          if (!isHGSaturated)
                            break;
                        }
                        
                        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 { //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]; //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
                                //m_PUAmp.at(i) = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp; //out-of-time pulses
                                my_PUAmp[i] = m_useOotADist ? m_ootDist->GetRandom() : m_ootAmp; //out-of-time pulses
                            } else {
                                //m_PUAmp.at(i) = 0; //it-time pulse
                                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);
                }
 
                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)) );
                }
            }
        }
    }
 
        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;
    }
    delete random;
 
    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 555 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 146 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());
 
    //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");
            //m_pileupAmpDistFileName = PathResolver::find_file("Distributions_small_h2000_177531_ZeroBias.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.
 
    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 589 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 571 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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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, PyAthena::Alg, and AthHistogramAlgorithm.

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 150 of file TileDigitsFromPulse.h.

m_avgMuForPU

int TileDigitsFromPulse::m_avgMuForPU

private

Definition at line 166 of file TileDigitsFromPulse.h.

m_bigain

bool TileDigitsFromPulse::m_bigain

private

Definition at line 163 of file TileDigitsFromPulse.h.

m_buf

TileSampleBuffer* TileDigitsFromPulse::m_buf

private

Buffer class to hold generated pulses.

Definition at line 171 of file TileDigitsFromPulse.h.

m_BunchSpacing

int TileDigitsFromPulse::m_BunchSpacing

private

Time between pulses in ms 25, 50 or 75.

Definition at line 157 of file TileDigitsFromPulse.h.

m_chanNoise

bool TileDigitsFromPulse::m_chanNoise

private

Add channel specific noise.

Definition at line 147 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 146 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 115 of file TileDigitsFromPulse.h.

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 143 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 135 of file TileDigitsFromPulse.h.

m_GNAmpOne

double TileDigitsFromPulse::m_GNAmpOne

private

Amplitude of first gaussian of double gaussian noise.

Definition at line 136 of file TileDigitsFromPulse.h.

m_GNAmpTwo

double TileDigitsFromPulse::m_GNAmpTwo

private

Amplitude of second gaussian of double gaussian noise.

Definition at line 138 of file TileDigitsFromPulse.h.

m_GNSigmaOne

double TileDigitsFromPulse::m_GNSigmaOne

private

Standard deviation of first gaussian of double gaussian noise.

Definition at line 137 of file TileDigitsFromPulse.h.

m_GNSigmaTwo

double TileDigitsFromPulse::m_GNSigmaTwo

private

Standard deviation of second gaussian of double gaussian noise.

Definition at line 139 of file TileDigitsFromPulse.h.

m_i_ADCmax

int TileDigitsFromPulse::m_i_ADCmax

private

Definition at line 107 of file TileDigitsFromPulse.h.

m_imperfectionMean

double TileDigitsFromPulse::m_imperfectionMean

private

Mean value of pulse shape broadening.

Definition at line 127 of file TileDigitsFromPulse.h.

m_imperfectionRms

double TileDigitsFromPulse::m_imperfectionRms

private

RMS of pulse shape broadening.

Definition at line 128 of file TileDigitsFromPulse.h.

m_infoName

std::string TileDigitsFromPulse::m_infoName

private

Definition at line 105 of file TileDigitsFromPulse.h.

m_inTimeAmp

double TileDigitsFromPulse::m_inTimeAmp

private

Amplitude of in-time pulse.

Definition at line 129 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 144 of file TileDigitsFromPulse.h.

m_itADistHistName

std::string TileDigitsFromPulse::m_itADistHistName

private

Name of histogram for in-time amplitude distribution.

Definition at line 151 of file TileDigitsFromPulse.h.

m_itDist

TH1F* TileDigitsFromPulse::m_itDist

private

Histogram to hold the distribution of in-time amplitudes.

Definition at line 176 of file TileDigitsFromPulse.h.

m_itFile

TFile* TileDigitsFromPulse::m_itFile

private

File that holds the distribution of in-time amplitudes.

Definition at line 177 of file TileDigitsFromPulse.h.

m_itOffset

double TileDigitsFromPulse::m_itOffset

private

In-time pulse offset from nominal time.

Definition at line 131 of file TileDigitsFromPulse.h.

m_nPul

int TileDigitsFromPulse::m_nPul

private

number of pileup pulses

Definition at line 159 of file TileDigitsFromPulse.h.

m_nPul_eff

int TileDigitsFromPulse::m_nPul_eff

private

Definition at line 160 of file TileDigitsFromPulse.h.

m_nSamples

int TileDigitsFromPulse::m_nSamples

private

number of read out samples

Definition at line 158 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 145 of file TileDigitsFromPulse.h.

m_ootADistHistName

std::string TileDigitsFromPulse::m_ootADistHistName

private

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

Definition at line 152 of file TileDigitsFromPulse.h.

m_ootAmp

double TileDigitsFromPulse::m_ootAmp

private

Amplitude of out-of-time pulse.

Definition at line 130 of file TileDigitsFromPulse.h.

m_ootDist

TH1F* TileDigitsFromPulse::m_ootDist

private

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

Definition at line 175 of file TileDigitsFromPulse.h.

m_ootFile

TFile* TileDigitsFromPulse::m_ootFile

private

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

Definition at line 178 of file TileDigitsFromPulse.h.

m_ootOffset

double TileDigitsFromPulse::m_ootOffset

private

Out-of-time pulse offset from nominal time.

Definition at line 132 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 179 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 180 of file TileDigitsFromPulse.h.

m_ootOffsetFileName

std::string TileDigitsFromPulse::m_ootOffsetFileName

private

File name for offset timing distribution histogram.

Definition at line 148 of file TileDigitsFromPulse.h.

m_ootOffsetHistName

std::string TileDigitsFromPulse::m_ootOffsetHistName

private

Name of the histogram for timing offset distribution.

Definition at line 149 of file TileDigitsFromPulse.h.

m_outputContainer

std::string TileDigitsFromPulse::m_outputContainer

private

Name of the output TileDigitsContainer.

Definition at line 100 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 133 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 134 of file TileDigitsFromPulse.h.

m_PhaseII

bool TileDigitsFromPulse::m_PhaseII

private

Definition at line 162 of file TileDigitsFromPulse.h.

m_pileup_AmpDistFile

TFile* TileDigitsFromPulse::m_pileup_AmpDistFile

private

File containing amplitude histograms for PU pulses.

Definition at line 182 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 183 of file TileDigitsFromPulse.h.

m_pileupAmpDistFileName

std::string TileDigitsFromPulse::m_pileupAmpDistFileName

private

Filename for PU amplitude distribution histograms.

Definition at line 167 of file TileDigitsFromPulse.h.

m_pileUpFraction

float TileDigitsFromPulse::m_pileUpFraction

private

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

Definition at line 142 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 170 of file TileDigitsFromPulse.h.

m_PUAmp

std::vector<float> TileDigitsFromPulse::m_PUAmp

private

Definition at line 161 of file TileDigitsFromPulse.h.

m_randomStreamName

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

private

Random Stream Name.

Definition at line 123 of file TileDigitsFromPulse.h.

m_rawChannelContainerKey

SG::WriteHandleKey<TileRawChannelContainer> TileDigitsFromPulse::m_rawChannelContainerKey

private

Initial value:

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

Definition at line 118 of file TileDigitsFromPulse.h.

m_rChType

TileFragHash::TYPE TileDigitsFromPulse::m_rChType

private

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

Definition at line 110 of file TileDigitsFromPulse.h.

m_rChUnit

TileRawChannelUnit::UNIT TileDigitsFromPulse::m_rChUnit

private

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

Definition at line 109 of file TileDigitsFromPulse.h.

m_rndmSvc

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

private

Random number service to use.

Definition at line 121 of file TileDigitsFromPulse.h.

m_seed

int TileDigitsFromPulse::m_seed

private

Definition at line 156 of file TileDigitsFromPulse.h.

m_simPUwPoisson

bool TileDigitsFromPulse::m_simPUwPoisson

private

Definition at line 165 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 154 of file TileDigitsFromPulse.h.

m_tileHWID

const TileHWID* TileDigitsFromPulse::m_tileHWID

private

Definition at line 102 of file TileDigitsFromPulse.h.

m_tileInfo

const TileInfo* TileDigitsFromPulse::m_tileInfo

private

Definition at line 106 of file TileDigitsFromPulse.h.

m_tileToolNoiseSample

ToolHandle<TileCondToolNoiseSample> TileDigitsFromPulse::m_tileToolNoiseSample

private

Initial value:

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

Definition at line 112 of file TileDigitsFromPulse.h.

m_tsg

TileSampleGenerator* TileDigitsFromPulse::m_tsg

private

Pulse generating class.

Definition at line 172 of file TileDigitsFromPulse.h.

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 140 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 181 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 141 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:

• TileDigitsFromPulse.h
• TileDigitsFromPulse.cxx