EventReaderAlg Class Reference

#include <EventReaderAlg.h>

Inheritance diagram for EventReaderAlg:

Collaboration diagram for EventReaderAlg:

Public Member Functions
	EventReaderAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~EventReaderAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
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
bool	isEtaOutsideLArCrack (float absEta)
bool	isTagElectron (const xAOD::Electron *electron)
bool	isGoodProbeElectron (const xAOD::Electron *el)
bool	trackSelectionElectrons (const xAOD::Electron *electron, SG::ReadHandle< xAOD::VertexContainer > &primVertexCnt, SG::ReadHandle< xAOD::EventInfo > &ei)
bool	eOverPElectron (const xAOD::Electron *electron)
int	getCaloRegionIndex (const CaloCell *cell)
double	fixPhi (double phi)
double	deltaPhi (double phi1, double phi2)
double	deltaR (double eta, double phi)
void	clear ()
void	clearLBData ()
void	bookBranches (TTree *tree)
void	bookDatabaseBranches (TTree *tree)
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...

Protected Attributes
Gaudi::Property< float >	m_elecEtaCut {this, "electronEtaCut", 1.4, "Electron |eta| cut value."}
Gaudi::Property< std::string >	m_offTagTightness {this, "offTagTightness", "LHMedium"}
Gaudi::Property< std::string >	m_offProbeTightness {this, "offProbeTightness", "Loose"}
	Define the PID for tag electron. More...
Gaudi::Property< float >	m_etMinProbe {this, "etMinProbe", 15 ,"Min electron Pt value for Zee probe selection loose (GeV)."}
	define the Pid of Probe from the user More...
Gaudi::Property< float >	m_etMinTag {this, "etMinTag", 15 ,"Min Et value for the electrons in Zee tag selection (GeV)."}
Gaudi::Property< float >	m_d0TagSig {this, "d0TagSig", 5, "d_0 transverse impact parameter significance."}
Gaudi::Property< float >	m_z0Tag {this, "z0Tag", 0.5, "z0 longitudinal impact parameter (mm)"}
Gaudi::Property< bool >	m_doElecSelectByTrackOnly {this, "doElecSelectByTrackOnly", false, "Perform electron selection by track only, witout tag and probe."}
Gaudi::Property< bool >	m_doTagAndProbe {this, "doTagAndProbe", true, "First, the electrons are selected by track criteria, then, perform Tag and Probe selection for Zee."}
Gaudi::Property< bool >	m_doPhotonDump {this, "doPhotonDump", false, "Perform a photon particle dump based on offline Photons Container."}
Gaudi::Property< bool >	m_doTruthEventDump {this, "doTruthEventDump", false, "Dump the Truth Event variables."}
Gaudi::Property< bool >	m_doTruthPartDump {this, "doTruthPartDump", false, "Perform a truth particle dump."}
Gaudi::Property< bool >	m_doLArEMBHitsDump {this, "doLArEMBHitsDump", false, "Dump the EMB HITs container energy and time."}
Gaudi::Property< bool >	m_isMC {this, "isMC", false, "Switch the dumper to MC sample mode."}
Gaudi::Property< bool >	m_getLArCalibConstants {this, "getLArCalibConstants", false, "Get the LAr calorimeter calibration constants, related to cells energy and time (online and offline)."}
Gaudi::Property< bool >	m_noBadCells {this, "noBadCells", true, "If True, skip the cells tagged as badCells/channels."}
Gaudi::Property< bool >	m_doAssocTopoCluster711Dump {this, "doAssocTopoCluster711Dump", false, "Dump the 7x11 EMB2 window cells."}
TTree *	m_Tree {}
TTree *	m_secondTree {}
std::vector< std::vector< float > > *	m_lb_bcidLuminosity = nullptr
std::vector< int > *	m_lb_lumiblock = nullptr
unsigned int	m_e_runNumber = 9999
unsigned int	m_e_bcid = 9999
unsigned long long	m_e_eventNumber = 9999
int	m_e_lumiBlock = 999
float	m_e_inTimePileup = -999
float	m_e_outOfTimePileUp = -999
int	m_c_clusterIndexCounter = 0
std::vector< int > *	m_c_clusterIndex = nullptr
std::vector< int > *	m_c_electronIndex_clusterLvl = nullptr
std::vector< double > *	m_c_clusterEnergy = nullptr
std::vector< double > *	m_c_clusterTime = nullptr
std::vector< double > *	m_c_clusterEta = nullptr
std::vector< double > *	m_c_clusterPhi = nullptr
std::vector< double > *	m_c_clusterPt = nullptr
int	m_c_cellIndexCounter = 0
std::vector< int > *	m_c_clusterIndex_cellLvl = nullptr
std::vector< int > *	m_c_clusterCellIndex = nullptr
std::vector< int > *	m_c_cellGain = nullptr
std::vector< int > *	m_c_cellLayer = nullptr
std::vector< int > *	m_c_cellRegion = nullptr
std::vector< double > *	m_c_cellEnergy = nullptr
std::vector< double > *	m_c_cellTime = nullptr
std::vector< double > *	m_c_cellEta = nullptr
std::vector< double > *	m_c_cellPhi = nullptr
std::vector< double > *	m_c_cellDEta = nullptr
std::vector< double > *	m_c_cellDPhi = nullptr
std::vector< double > *	m_c_cellToClusterDPhi = nullptr
std::vector< double > *	m_c_cellToClusterDEta = nullptr
std::vector< int > *	m_c_clusterIndex_chLvl = nullptr
std::vector< int > *	m_c_clusterChannelIndex = nullptr
std::vector< std::vector< int > > *	m_c_channelChInfo = nullptr
std::vector< std::vector< float > > *	m_c_channelDigits = nullptr
std::vector< double > *	m_c_channelEnergy = nullptr
std::vector< double > *	m_c_channelTime = nullptr
std::vector< int > *	m_c_channelLayer = nullptr
std::vector< bool > *	m_c_channelBad = nullptr
std::vector< unsigned int > *	m_c_channelHashMap = nullptr
std::vector< unsigned int > *	m_c_channelChannelIdMap = nullptr
std::vector< float > *	m_c_channelEffectiveSigma = nullptr
std::vector< float > *	m_c_channelNoise = nullptr
std::vector< float > *	m_c_channelDSPThreshold = nullptr
std::vector< std::vector< double > > *	m_c_channelOFCa = nullptr
std::vector< std::vector< double > > *	m_c_channelOFCb = nullptr
std::vector< std::vector< double > > *	m_c_channelShape = nullptr
std::vector< std::vector< double > > *	m_c_channelShapeDer = nullptr
std::vector< double > *	m_c_channelOFCTimeOffset = nullptr
std::vector< float > *	m_c_channelADC2MEV0 = nullptr
std::vector< float > *	m_c_channelADC2MEV1 = nullptr
std::vector< float > *	m_c_channelPed = nullptr
std::vector< float > *	m_c_channelMinBiasAvg = nullptr
std::vector< float > *	m_c_channelOfflHVScale = nullptr
std::vector< float > *	m_c_channelOfflEneRescaler = nullptr
std::vector< std::vector< int > > *	m_c_rawChannelChInfo = nullptr
std::vector< unsigned int > *	m_c_rawChannelIdMap = nullptr
std::vector< float > *	m_c_rawChannelAmplitude = nullptr
std::vector< float > *	m_c_rawChannelTime = nullptr
std::vector< int > *	m_c_rawChannelLayer = nullptr
std::vector< float > *	m_c_rawChannelPed = nullptr
std::vector< float > *	m_c_rawChannelProv = nullptr
std::vector< float > *	m_c_rawChannelQuality = nullptr
std::vector< float > *	m_c_clusterRawChannelIndex = nullptr
std::vector< int > *	m_c_clusterIndex_rawChLvl = nullptr
std::vector< float > *	m_c_rawChannelDSPThreshold = nullptr
size_t	m_ncell = 0
const double	m_minEnergy = 1e-9
std::vector< int > *	m_hits_sampling = nullptr
std::vector< int > *	m_hits_clusterIndex_chLvl = nullptr
std::vector< int > *	m_hits_clusterChannelIndex = nullptr
std::vector< unsigned int > *	m_hits_hash = nullptr
std::vector< double > *	m_hits_energy = nullptr
std::vector< double > *	m_hits_time = nullptr
std::vector< float > *	m_hits_sampFrac = nullptr
std::vector< double > *	m_hits_energyConv = nullptr
std::vector< double > *	m_hits_cellEta = nullptr
std::vector< double > *	m_hits_cellPhi = nullptr
int *	m_c711_clusterIndexCounter = 0
std::vector< int > *	m_c711_clusterIndex = nullptr
std::vector< int > *	m_c711_electronIndex_clusterLvl = nullptr
std::vector< double > *	m_c711_clusterEnergy = nullptr
std::vector< double > *	m_c711_clusterTime = nullptr
std::vector< double > *	m_c711_clusterEta = nullptr
std::vector< double > *	m_c711_clusterPhi = nullptr
std::vector< double > *	m_c711_clusterPt = nullptr
int *	m_c711_cellIndexCounter = nullptr
std::vector< int > *	m_c711_clusterIndex_cellLvl = nullptr
std::vector< int > *	m_c711_clusterCellIndex = nullptr
std::vector< int > *	m_c711_cellGain = nullptr
std::vector< int > *	m_c711_cellLayer = nullptr
std::vector< int > *	m_c711_cellRegion = nullptr
std::vector< double > *	m_c711_cellEnergy = nullptr
std::vector< double > *	m_c711_cellTime = nullptr
std::vector< double > *	m_c711_cellEta = nullptr
std::vector< double > *	m_c711_cellPhi = nullptr
std::vector< double > *	m_c711_cellDEta = nullptr
std::vector< double > *	m_c711_cellDPhi = nullptr
std::vector< double > *	m_c711_cellToClusterDPhi = nullptr
std::vector< double > *	m_c711_cellToClusterDEta = nullptr
std::vector< int > *	m_c711_clusterIndex_chLvl = nullptr
std::vector< int > *	m_c711_clusterChannelIndex = nullptr
std::vector< std::vector< int > > *	m_c711_channelChInfo = nullptr
std::vector< std::vector< float > > *	m_c711_channelDigits = nullptr
std::vector< double > *	m_c711_channelEnergy = nullptr
std::vector< double > *	m_c711_channelTime = nullptr
std::vector< int > *	m_c711_channelLayer = nullptr
std::vector< bool > *	m_c711_channelBad = nullptr
std::vector< unsigned int > *	m_c711_channelHashMap = nullptr
std::vector< unsigned int > *	m_c711_channelChannelIdMap = nullptr
std::vector< float > *	m_c711_channelEffectiveSigma = nullptr
std::vector< float > *	m_c711_channelNoise = nullptr
std::vector< float > *	m_c711_channelDSPThreshold = nullptr
std::vector< std::vector< double > > *	m_c711_channelOFCa = nullptr
std::vector< std::vector< double > > *	m_c711_channelOFCb = nullptr
std::vector< std::vector< double > > *	m_c711_channelShape = nullptr
std::vector< std::vector< double > > *	m_c711_channelShapeDer = nullptr
std::vector< double > *	m_c711_channelOFCTimeOffset = nullptr
std::vector< float > *	m_c711_channelADC2MEV0 = nullptr
std::vector< float > *	m_c711_channelADC2MEV1 = nullptr
std::vector< float > *	m_c711_channelPed = nullptr
std::vector< float > *	m_c711_channelMinBiasAvg = nullptr
std::vector< float > *	m_c711_channelOfflHVScale = nullptr
std::vector< float > *	m_c711_channelOfflEneRescaler = nullptr
std::vector< std::vector< int > > *	m_c711_rawChannelChInfo = nullptr
std::vector< unsigned int > *	m_c711_rawChannelIdMap = nullptr
std::vector< float > *	m_c711_rawChannelAmplitude = nullptr
std::vector< float > *	m_c711_rawChannelTime = nullptr
std::vector< int > *	m_c711_rawChannelLayer = nullptr
std::vector< float > *	m_c711_rawChannelPed = nullptr
std::vector< float > *	m_c711_rawChannelProv = nullptr
std::vector< float > *	m_c711_rawChannelQuality = nullptr
std::vector< float > *	m_c711_clusterRawChannelIndex = nullptr
std::vector< int > *	m_c711_clusterIndex_rawChLvl = nullptr
std::vector< float > *	m_c711_rawChannelDSPThreshold = nullptr
std::vector< float > *	m_mc_part_energy = nullptr
std::vector< float > *	m_mc_part_pt = nullptr
std::vector< float > *	m_mc_part_m = nullptr
std::vector< float > *	m_mc_part_eta = nullptr
std::vector< float > *	m_mc_part_phi = nullptr
std::vector< int > *	m_mc_part_pdgId = nullptr
std::vector< int > *	m_mc_part_status = nullptr
std::vector< int > *	m_mc_part_barcode = nullptr
std::vector< float > *	m_mc_vert_x = nullptr
std::vector< float > *	m_mc_vert_y = nullptr
std::vector< float > *	m_mc_vert_z = nullptr
std::vector< float > *	m_mc_vert_time = nullptr
std::vector< float > *	m_mc_vert_perp = nullptr
std::vector< float > *	m_mc_vert_eta = nullptr
std::vector< float > *	m_mc_vert_phi = nullptr
std::vector< int > *	m_mc_vert_barcode = nullptr
std::vector< int > *	m_mc_vert_status = nullptr
std::vector< float > *	m_vtx_x = nullptr
std::vector< float > *	m_vtx_y = nullptr
std::vector< float > *	m_vtx_z = nullptr
std::vector< float > *	m_vtx_deltaZ0 = nullptr
std::vector< float > *	m_vtx_delta_z0_sin = nullptr
std::vector< double > *	m_vtx_d0sig = nullptr
std::vector< float > *	m_ph_eta = nullptr
std::vector< float > *	m_ph_phi = nullptr
std::vector< float > *	m_ph_pt = nullptr
std::vector< float > *	m_ph_energy = nullptr
std::vector< float > *	m_ph_m = nullptr
std::vector< int > *	m_el_index = nullptr
std::vector< float > *	m_el_Pt = nullptr
std::vector< float > *	m_el_et = nullptr
std::vector< float > *	m_el_Eta = nullptr
std::vector< float > *	m_el_Phi = nullptr
std::vector< float > *	m_el_m = nullptr
std::vector< float > *	m_el_eoverp = nullptr
std::vector< float > *	m_el_f1 = nullptr
std::vector< float > *	m_el_f3 = nullptr
std::vector< float > *	m_el_eratio = nullptr
std::vector< float > *	m_el_weta1 = nullptr
std::vector< float > *	m_el_weta2 = nullptr
std::vector< float > *	m_el_fracs1 = nullptr
std::vector< float > *	m_el_wtots1 = nullptr
std::vector< float > *	m_el_e277 = nullptr
std::vector< float > *	m_el_reta = nullptr
std::vector< float > *	m_el_rphi = nullptr
std::vector< float > *	m_el_deltae = nullptr
std::vector< float > *	m_el_rhad = nullptr
std::vector< float > *	m_el_rhad1 = nullptr
std::vector< float > *	m_tp_electronPt = nullptr
std::vector< float > *	m_tp_electronEt = nullptr
std::vector< float > *	m_tp_electronEta = nullptr
std::vector< float > *	m_tp_electronPhi = nullptr
std::vector< int > *	m_tp_probeIndex = nullptr
std::vector< int > *	m_tp_tagIndex = nullptr
std::vector< bool > *	m_tp_isTag = nullptr
std::vector< bool > *	m_tp_isProbe = nullptr
std::vector< double > *	m_zee_M = nullptr
std::vector< double > *	m_zee_E = nullptr
std::vector< double > *	m_zee_pt = nullptr
std::vector< double > *	m_zee_px = nullptr
std::vector< double > *	m_zee_py = nullptr
std::vector< double > *	m_zee_pz = nullptr
std::vector< double > *	m_zee_T = nullptr
std::vector< double > *	m_zee_deltaR = nullptr

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual StatusCode	dumpEventInfo (SG::ReadHandle< xAOD::EventInfo > &ei)
virtual StatusCode	dumpLumiblockInfo (SG::ReadHandle< xAOD::EventInfo > &ei)
virtual StatusCode	dumpClusterCells (const xAOD::CaloCluster *cl, int clusIndex, const EventContext &ctx)
virtual StatusCode	dumpOfflineSS (const xAOD::Electron *electron)
virtual StatusCode	dumpTruthParticle (SG::ReadHandle< xAOD::ElectronContainer > &electronSelectionCnt, SG::ReadHandle< xAOD::TruthParticleContainer > &truthParticleCnt)
virtual StatusCode	dumpElectrons (const xAOD::Electron *electron)
virtual StatusCode	dumpZeeCut (SG::ReadHandle< xAOD::EventInfo > &ei, SG::ReadHandle< xAOD::VertexContainer > &primVertexCnt, const EventContext &ctx)
virtual StatusCode	dumpPrimVertexAssocToElectron (const xAOD::Electron *el, SG::ReadHandle< xAOD::VertexContainer > &primVertexCnt, SG::ReadHandle< xAOD::EventInfo > &evtInfo)
virtual StatusCode	FillNTupleWithSelectedElectrons (SG::ReadHandle< xAOD::EventInfo > &ei, SG::ReadHandle< xAOD::VertexContainer > &primVertexCnt, SG::ReadHandle< xAOD::ElectronContainer > &electronSelectionCnt, std::string &eSelectionText, const EventContext &ctx)
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
Gaudi::Property< bool >	m_printCellsClus {this, "printCellsClus", false, "Print out the cluster cells basic info during the dump."}
Gaudi::Property< bool >	m_doClusterDump {this, "doClusterDump", false, "Perform a cluster cell dump based on Cluster Container name m_clusterName"}
Gaudi::Property< bool >	m_getAssociatedTopoCluster {this, "getAssociatedTopoCluster", true, "Get the topo cluster associated to a super cluster, which was linked to an Electron."}
Gaudi::Property< bool >	m_skipEmptyEvents {this, "skipEmptyEvents", true, "If true, do not fill the event that has no reco electrons."}
Gaudi::Property< float >	m_minZeeMassTP {this, "minZeeMassTP", 66, "Minimum value of Zee mass for checking the TP pairs (GeV)."}
Gaudi::Property< float >	m_maxZeeMassTP {this, "maxZeeMassTP", 116, "Maximum value of Zee mass for checking the TP pairs (GeV)."}
ServiceHandle< ITHistSvc >	m_ntsvc
SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}
SG::ReadCondHandleKey< AthenaAttributeList >	m_run2DSPThresholdsKey {this, "Run2DSPThresholdsKey","", "SG Key for thresholds to compute time and quality, run 2"}
SG::ReadCondHandleKey< AthenaAttributeList >	m_EneRescalerFldr {this,"OflEneRescalerKey","/LAR/CellCorrOfl/EnergyCorr", "Key (=foldername) of AttrListCollection"}
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LumiKey", "LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< ILArPedestal >	m_pedestalKey {this,"PedestalKey","LArPedestal","SG Key of Pedestal conditions object"}
SG::ReadCondHandleKey< LArADC2MeV >	m_adc2MeVKey {this,"ADC2MeVKey","LArADC2MeV","SG Key of ADC2MeV conditions object"}
SG::ReadCondHandleKey< ILArOFC >	m_ofcKey {this,"OFCKey","LArOFC","SG Key of OFC conditions object"}
SG::ReadCondHandleKey< ILArShape >	m_shapeKey {this,"ShapeKey","LArShape","SG Key of Shape conditions object"}
SG::ReadCondHandleKey< ILArMinBiasAverage >	m_minBiasAvgKey {this, "MinBiasAvgKey", "LArPileupAverageSym", "SGKey of LArMinBiasAverage object"}
SG::ReadCondHandleKey< LArHVCorr >	m_offlineHVScaleCorrKey {this, "keyOfflineHVCorr", "LArHVScaleCorrRecomputed","Key for LArHVScaleCorr"}
SG::ReadCondHandleKey< ILArfSampl >	m_fSamplKey {this, "fSamplKey", "LArfSamplSym","SG key of LArfSampl object."}
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_larCablingKey {this,"LArOnOffMapKey","LArOnOffIdMap"," SG Key of LArOnOffIdMapping object."}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoSgKey {this, "EventInfoContainerKey", "EventInfo", "Name of the EventInfo Container"}
SG::ReadHandleKey< xAOD::VertexContainer >	m_primVertSgKey {this, "PrimaryVertexContainerKey", "PrimaryVertices", "Name of the PrimaryVertices Container"}
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_caloClusSgKey {this, "CaloClusterContainerKey", "CaloCalTopoClusters", "Name of the CaloCluster Container"}
SG::ReadHandleKey< xAOD::ElectronContainer >	m_myElecSelectionSgKey {this, "MyElectronSelectionKey", "MySelectedElectrons", "Name of the MySelectedElectrons Container"}
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_truthParticleCntSgKey {this, "TruthParticleContainerKey", "TruthParticles", "Name of the TruthParticles Container"}
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronCntSgKey {this, "ElectronContainerKey", "Electrons", "Name of the Electrons Container"}
SG::ReadHandleKey< xAOD::TruthEventContainer >	m_truthEventCntSgKey {this, "TruthEventContainerKey", "TruthEvents", "Name of the TruthEvents Container"}
SG::ReadHandleKey< LArHitContainer >	m_larEMBHitCntSgKey {this, "LArEMBHitContainerKey", "LArHitEMB", "Name of the LArHitEMB container"}
SG::ReadHandleKey< LArDigitContainer >	m_larDigitCntSgKey {this, "LArDigitContainerKey", "LArDigitContainer_MC", "Name of the LArDigits container"}
SG::ReadHandleKey< LArRawChannelContainer >	m_larRawChCntSgKey {this, "LArRawChannelContainerKey", "LArRawChannels", "Name of the LArRawChannel container"}
SG::ReadHandleKey< CaloCellContainer >	m_allCaloCellCntSgKey {this, "CaloCellContainerKey", "AllCalo", "Name of the CaloCell container"}
std::unique_ptr< LArDSPThresholdsFlat >	m_run2DSPThresh = nullptr
const CaloNoise *	m_noiseCDO = nullptr
const LuminosityCondData *	m_lumis = nullptr
const ILArPedestal *	m_peds = nullptr
const LArADC2MeV *	m_adc2MeVs = nullptr
const ILArOFC *	m_ofcs = nullptr
const ILArShape *	m_shapes = nullptr
const ILArMinBiasAverage *	m_minBiasAvgs = nullptr
const LArHVCorr *	m_oflHVCorr = nullptr
const CaloCondBlobFlt *	m_EneRescaler = nullptr
const ILArfSampl *	m_fSampl = nullptr
const LArOnlineID *	m_onlineLArID = nullptr
const LArOnOffIdMapping *	m_larCabling = nullptr
const CaloIdManager *	m_caloIdMgr = nullptr
const LArEM_ID *	m_larem_id = nullptr
const LArHEC_ID *	m_larhec_id = nullptr
const LArFCAL_ID *	m_larfcal_id = nullptr
const CaloCell_ID *	m_calocell_id = nullptr
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

Definition at line 45 of file EventReaderAlg.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

EventReaderAlg()

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

Definition at line 29 of file EventReaderAlg.cxx.

                                                                                : 
    EventReaderBaseAlg(name, pSvcLocator)
    , m_ntsvc("THistSvc/THistSvc", name)
    {}

~EventReaderAlg()

virtual EventReaderAlg::~EventReaderAlg ( )

virtualdefault

Member Function Documentation

bookBranches()

void EventReaderBaseAlg::bookBranches ( TTree *  tree )

protectedinherited

Definition at line 253 of file EventReaderBaseAlg.cxx.

                                                {
  // ## Event info
  tree->Branch ("event_RunNumber", &m_e_runNumber);
  tree->Branch ("event_EventNumber", &m_e_eventNumber);
  tree->Branch ("event_BCID", &m_e_bcid);
  tree->Branch ("event_Lumiblock",&m_e_lumiBlock);
  tree->Branch ("event_avg_mu_inTimePU", &m_e_inTimePileup);
  tree->Branch ("event_avg_mu_OOTimePU", &m_e_outOfTimePileUp);
  // #############
 
  // ## Cluster 
  tree->Branch ("cluster_index",&m_c_clusterIndex);
  tree->Branch ("c_electronIndex_clusterLvl",&m_c_electronIndex_clusterLvl);
  tree->Branch ("cluster_et",&m_c_clusterEnergy);
  tree->Branch ("cluster_time",&m_c_clusterTime);
  tree->Branch ("cluster_pt",&m_c_clusterPt);
  tree->Branch ("cluster_eta",&m_c_clusterEta);
  tree->Branch ("cluster_phi",&m_c_clusterPhi);
  // Cluster cell
  tree->Branch ("cluster_index_cellLvl",&m_c_clusterIndex_cellLvl);
  tree->Branch ("cluster_cell_index",&m_c_clusterCellIndex);
  tree->Branch ("cluster_cell_caloGain",&m_c_cellGain);
  tree->Branch ("cluster_cell_layer",&m_c_cellLayer);
  tree->Branch ("cluster_cell_region",&m_c_cellRegion);
  tree->Branch ("cluster_cell_energy",&m_c_cellEnergy);
  tree->Branch ("cluster_cell_time",&m_c_cellTime);
  tree->Branch ("cluster_cell_eta",&m_c_cellEta);
  tree->Branch ("cluster_cell_phi",&m_c_cellPhi);
  tree->Branch ("cluster_cell_deta",&m_c_cellDEta);
  tree->Branch ("cluster_cell_dphi",&m_c_cellDPhi);
  tree->Branch ("cluster_cellsDist_dphi",&m_c_cellToClusterDPhi);
  tree->Branch ("cluster_cellsDist_deta",&m_c_cellToClusterDEta);
  // Cluster channel (digits and cell ch)
  tree->Branch ("cluster_index_chLvl",&m_c_clusterIndex_chLvl);
  tree->Branch ("cluster_channel_index",&m_c_clusterChannelIndex);
  tree->Branch ("cluster_channel_digits",&m_c_channelDigits);
  tree->Branch ("cluster_channel_energy",&m_c_channelEnergy);
  tree->Branch ("cluster_channel_time",&m_c_channelTime);
  tree->Branch ("cluster_channel_layer",&m_c_channelLayer);
  if (!m_noBadCells) tree->Branch ("cluster_channel_bad",&m_c_channelBad);
  tree->Branch ("cluster_channel_chInfo", &m_c_channelChInfo);
  tree->Branch ("cluster_channel_hash",&m_c_channelHashMap); 
  tree->Branch ("cluster_channel_id",&m_c_channelChannelIdMap);
  if (m_getLArCalibConstants){
    tree->Branch ("cluster_channel_effSigma",&m_c_channelEffectiveSigma);
    tree->Branch ("cluster_channel_noise",&m_c_channelNoise);
    tree->Branch ("cluster_channel_DSPThreshold",&m_c_channelDSPThreshold);
    tree->Branch ("cluster_channel_OFCTimeOffset",&m_c_channelOFCTimeOffset);
    tree->Branch ("cluster_channel_ADC2MeV0",&m_c_channelADC2MEV0);
    tree->Branch ("cluster_channel_ADC2MeV1",&m_c_channelADC2MEV1);
    tree->Branch ("cluster_channel_pedestal",&m_c_channelPed);
    tree->Branch ("cluster_channel_OFCa",&m_c_channelOFCa);
    tree->Branch ("cluster_channel_OFCb",&m_c_channelOFCb);
    tree->Branch ("cluster_channel_MinBiasAvg",&m_c_channelMinBiasAvg);
    
    if (!m_isMC){
      tree->Branch ("cluster_channel_OfflineEnergyRescaler",&m_c_channelOfflEneRescaler);
      tree->Branch ("cluster_channel_OfflineHVScale",&m_c_channelOfflHVScale);
      tree->Branch ("cluster_channel_shape",&m_c_channelShape);
      tree->Branch ("cluster_channel_shapeDer",&m_c_channelShapeDer);
    }
  }
 
  // Cluster raw channel
  tree->Branch ("cluster_index_rawChLvl",&m_c_clusterIndex_rawChLvl);
  tree->Branch ("cluster_rawChannel_index",&m_c_clusterRawChannelIndex);
  tree->Branch ("cluster_rawChannel_id",&m_c_rawChannelIdMap);
  tree->Branch ("cluster_rawChannel_amplitude",&m_c_rawChannelAmplitude);
  tree->Branch ("cluster_rawChannel_time",&m_c_rawChannelTime);
  tree->Branch ("cluster_rawChannel_layer",&m_c_rawChannelLayer);
  tree->Branch ("cluster_rawChannel_Ped",&m_c_rawChannelPed);
  tree->Branch ("cluster_rawChannel_Prov",&m_c_rawChannelProv);
  tree->Branch ("cluster_rawChannel_qual",&m_c_rawChannelQuality);  
  tree->Branch ("cluster_rawChannel_chInfo",&m_c_rawChannelChInfo); // tree->Branch ("cluster_cell_caloGain",&c_cellGain); //modify
  if (!m_isMC){
    tree->Branch ("cluster_rawChannel_DSPThreshold",&m_c_rawChannelDSPThreshold);
  }  
 
  // ## Cluster EMB2 7_11
  if (m_doAssocTopoCluster711Dump){
    tree->Branch ("cluster711_index",&m_c711_clusterIndex);
    tree->Branch ("c711_electronIndex_clusterLvl",&m_c711_electronIndex_clusterLvl);
    tree->Branch ("cluster711_et",&m_c711_clusterEnergy);
    tree->Branch ("cluster711_pt",&m_c711_clusterPt);
    tree->Branch ("cluster711_time",&m_c711_clusterTime);
    tree->Branch ("cluster711_eta",&m_c711_clusterEta);
    tree->Branch ("cluster711_phi",&m_c711_clusterPhi);
    // Cluster cell
    tree->Branch ("cluster711_index_cellLvl",&m_c711_clusterIndex_cellLvl);
    tree->Branch ("cluster711_cell_index",&m_c711_clusterCellIndex);
    tree->Branch ("cluster711_cell_caloGain",&m_c711_cellGain);
    tree->Branch ("cluster711_cell_layer",&m_c711_cellLayer);
    tree->Branch ("cluster711_cell_region",&m_c711_cellRegion);
    tree->Branch ("cluster711_cell_energy",&m_c711_cellEnergy);
    tree->Branch ("cluster711_cell_time",&m_c711_cellTime);
    tree->Branch ("cluster711_cell_eta",&m_c711_cellEta);
    tree->Branch ("cluster711_cell_phi",&m_c711_cellPhi);
    tree->Branch ("cluster711_cell_deta",&m_c711_cellDEta);
    tree->Branch ("cluster711_cell_dphi",&m_c711_cellDPhi);
    tree->Branch ("cluster711_cellsDist_dphi",&m_c711_cellToClusterDPhi);
    tree->Branch ("cluster711_cellsDist_deta",&m_c711_cellToClusterDEta);
    // Cluster channel (digits and cell ch)
    tree->Branch ("cluster711_index_chLvl",&m_c711_clusterIndex_chLvl);
    tree->Branch ("cluster711_channel_index",&m_c711_clusterChannelIndex);
    tree->Branch ("cluster711_channel_digits",&m_c711_channelDigits);
    tree->Branch ("cluster711_channel_energy",&m_c711_channelEnergy);
    tree->Branch ("cluster711_channel_time",&m_c711_channelTime);
    tree->Branch ("cluster711_channel_layer", &m_c711_channelLayer);
    if (!m_noBadCells) tree->Branch ("cluster711_channel_bad",&m_c711_channelBad);
    tree->Branch ("cluster711_channel_chInfo", &m_c711_channelChInfo);
    tree->Branch ("cluster711_channel_hash",&m_c711_channelHashMap); 
    tree->Branch ("cluster711_channel_id",&m_c711_channelChannelIdMap);
    if (m_getLArCalibConstants){
      tree->Branch ("cluster711_channel_effSigma",&m_c711_channelEffectiveSigma);
      tree->Branch ("cluster711_channel_noise",&m_c711_channelNoise);
      tree->Branch ("cluster711_channel_DSPThreshold",&m_c711_channelDSPThreshold);
      tree->Branch ("cluster711_channel_OFCTimeOffset",&m_c711_channelOFCTimeOffset);
      tree->Branch ("cluster711_channel_ADC2MeV0",&m_c711_channelADC2MEV0);
      tree->Branch ("cluster711_channel_ADC2MeV1",&m_c711_channelADC2MEV1);
      tree->Branch ("cluster711_channel_pedestal",&m_c711_channelPed);
      tree->Branch ("cluster711_channel_OFCa",&m_c711_channelOFCa);
      tree->Branch ("cluster711_channel_OFCb",&m_c711_channelOFCb);
      tree->Branch ("cluster711_channel_MinBiasAvg",&m_c711_channelMinBiasAvg);
      
      if (!m_isMC){
        tree->Branch ("cluster711_channel_OfflineEnergyRescaler",&m_c711_channelOfflEneRescaler);
        tree->Branch ("cluster711_channel_OfflineHVScale",&m_c711_channelOfflHVScale);
        tree->Branch ("cluster711_channel_shape",&m_c711_channelShape);
        tree->Branch ("cluster711_channel_shapeDer",&m_c711_channelShapeDer);
      }
    }
    // Cluster raw channel
    tree->Branch ("cluster711_index_rawChLvl",&m_c711_clusterIndex_rawChLvl);
    tree->Branch ("cluster711_rawChannel_index",&m_c711_clusterRawChannelIndex);
    tree->Branch ("cluster711_rawChannel_id",&m_c711_rawChannelIdMap);
    tree->Branch ("cluster711_rawChannel_amplitude",&m_c711_rawChannelAmplitude);
    tree->Branch ("cluster711_rawChannel_time",&m_c711_rawChannelTime);
    tree->Branch ("cluster711_rawChannel_layer",&m_c711_rawChannelLayer);
    tree->Branch ("cluster711_rawChannel_Ped",&m_c711_rawChannelPed);
    tree->Branch ("cluster711_rawChannel_Prov",&m_c711_rawChannelProv);
    tree->Branch ("cluster711_rawChannel_qual",&m_c711_rawChannelQuality);  
    tree->Branch ("cluster711_rawChannel_chInfo",&m_c711_rawChannelChInfo);
    if (!m_isMC){
      tree->Branch ("cluster711_rawChannel_DSPThreshold",&m_c711_rawChannelDSPThreshold);
    }
  }
  // #############
 
  // ## Particle Truth ##
  if (m_isMC){
    if (m_doLArEMBHitsDump){
      tree->Branch("hits_sampling", &m_hits_sampling);
      tree->Branch("hits_clusterIndex_chLvl", &m_hits_clusterIndex_chLvl);
      tree->Branch("hits_clusterChannelIndex", &m_hits_clusterChannelIndex);
      tree->Branch("hits_hash", &m_hits_hash);
      tree->Branch("hits_energy", &m_hits_energy);
      tree->Branch("hits_time", &m_hits_time);
      tree->Branch("hits_sampFrac", &m_hits_sampFrac);
      tree->Branch("hits_energyConv", &m_hits_energyConv);
      tree->Branch("hits_cellEta", &m_hits_cellEta);
      tree->Branch("hits_cellPhi", &m_hits_cellPhi);
    }
 
    if (m_doTruthPartDump){
      tree->Branch("mc_part_energy",&m_mc_part_energy);
      tree->Branch("mc_part_pt",&m_mc_part_pt);
      tree->Branch("mc_part_m",&m_mc_part_m);
      tree->Branch("mc_part_eta",&m_mc_part_eta);
      tree->Branch("mc_part_phi",&m_mc_part_phi);
      tree->Branch("mc_part_pdgId",&m_mc_part_pdgId);
      tree->Branch("mc_part_status", &m_mc_part_status);
      tree->Branch("mc_part_barcode", &m_mc_part_barcode);
    }
    // ## Vertex Truth ##
    if (m_doTruthEventDump){
      tree->Branch("mc_vert_x", &m_mc_vert_x);
      tree->Branch("mc_vert_y", &m_mc_vert_y);
      tree->Branch("mc_vert_z", &m_mc_vert_z);
      tree->Branch("mc_vert_time", &m_mc_vert_time);
      tree->Branch("mc_vert_perp", &m_mc_vert_perp);
      tree->Branch("mc_vert_eta", &m_mc_vert_eta);
      tree->Branch("mc_vert_phi", &m_mc_vert_phi);
      tree->Branch("mc_vert_barcode", &m_mc_vert_barcode);
      tree->Branch("mc_vert_status", &m_mc_vert_status);
    }
  }
  
  // ## Photons ##
  if (m_doPhotonDump){
    tree->Branch("ph_energy",&m_ph_energy);
    tree->Branch("ph_pt",&m_ph_pt);  
    tree->Branch("ph_eta",&m_ph_eta);
    tree->Branch("ph_phi",&m_ph_phi);
    tree->Branch("ph_m",&m_ph_m);
  }  
  // ## Primary Vertex
  tree->Branch("vtx_x",&m_vtx_x);
  tree->Branch("vtx_y",&m_vtx_y);
  tree->Branch("vtx_z",&m_vtx_z);
  tree->Branch("vtx_deltaZ0",&m_vtx_deltaZ0);
  tree->Branch("vtx_delta_z0_sin",&m_vtx_delta_z0_sin);
  tree->Branch("vtx_d0sig",&m_vtx_d0sig);
 
  // ## Electrons ##
  tree->Branch("el_index",&m_el_index);
  tree->Branch("el_Pt",&m_el_Pt);
  tree->Branch("el_et",&m_el_et);
  tree->Branch("el_Eta",&m_el_Eta);
  tree->Branch("el_Phi",&m_el_Phi);
  tree->Branch("el_m",&m_el_m);
  tree->Branch("el_eoverp",&m_el_eoverp);
  tree->Branch("el_f1",&m_el_f1);
  tree->Branch("el_f3",&m_el_f3);
  tree->Branch("el_eratio",&m_el_eratio);
  tree->Branch("el_weta1",&m_el_weta1);
  tree->Branch("el_weta2",&m_el_weta2);
  tree->Branch("el_fracs1",&m_el_fracs1);
  tree->Branch("el_wtots1",&m_el_wtots1);
  tree->Branch("el_e277",&m_el_e277);
  tree->Branch("el_reta",&m_el_reta);
  tree->Branch("el_rphi",&m_el_rphi);
  tree->Branch("el_deltae",&m_el_deltae);
  tree->Branch("el_rhad",&m_el_rhad);
  tree->Branch("el_rhad1",&m_el_rhad1);
 
  // ## Tag and Probe ##
  // zee
  if (!m_doElecSelectByTrackOnly && m_doTagAndProbe){
    tree->Branch("zee_M", &m_zee_M);
    tree->Branch("zee_E", &m_zee_E);
    tree->Branch("zee_pt", &m_zee_pt);
    tree->Branch("zee_px", &m_zee_px);
    tree->Branch("zee_py", &m_zee_py);
    tree->Branch("zee_pz", &m_zee_pz);
    tree->Branch("zee_T", &m_zee_T);
    tree->Branch("zee_deltaR", &m_zee_deltaR);
  }
}

bookDatabaseBranches()

void EventReaderBaseAlg::bookDatabaseBranches ( TTree *  tree )

protectedinherited

Definition at line 237 of file EventReaderBaseAlg.cxx.

                                                        {
  // ## BCID/Luminosity vector
  tree->Branch ("lb_lumiblock",&m_lb_lumiblock);
  if (!m_isMC){
    tree->Branch ("lb_bcidLuminosity",&m_lb_bcidLuminosity);
  }
}

clear()

void EventReaderBaseAlg::clear ( )

protectedinherited

Definition at line 492 of file EventReaderBaseAlg.cxx.

                              {
  // ## Event info
  m_e_runNumber       = 9999;
  m_e_eventNumber     = 9999;
  m_e_bcid            = 9999;
  m_e_lumiBlock       = 999; 
  m_e_inTimePileup    = -999;
  m_e_outOfTimePileUp = -999;
  // ############
 
  ATH_MSG_DEBUG("Clear Clusters..");
  // ## Cluster (TOPOCLUSTER or SUPERCLUSTER)
  m_c_clusterIndexCounter = 0;
  m_c_clusterIndex->clear();
  m_c_electronIndex_clusterLvl->clear();
  m_c_clusterEnergy->clear();
  m_c_clusterTime->clear();
  m_c_clusterPt->clear();
  m_c_clusterEta->clear();
  m_c_clusterPhi->clear();
  // Cluster cell
  ATH_MSG_DEBUG("Clear Clusters cell..");
  m_c_cellIndexCounter = 0;
  m_c_clusterIndex_cellLvl->clear();
  m_c_clusterCellIndex->clear();
  m_c_cellGain->clear(); 
  m_c_cellLayer->clear();
  m_c_cellRegion->clear();
  m_c_cellEnergy->clear();
  m_c_cellTime->clear();
  m_c_cellEta->clear();
  m_c_cellPhi->clear();
  m_c_cellDEta->clear();
  m_c_cellDPhi->clear();
  m_c_cellToClusterDPhi->clear();
  m_c_cellToClusterDEta->clear();   
  // Cluster channel
  ATH_MSG_DEBUG("Clear Clusters channel..");
  m_c_clusterIndex_chLvl->clear();
  m_c_clusterChannelIndex->clear();
  m_c_channelHashMap->clear(); // 
  m_c_channelChannelIdMap->clear();
  m_c_channelDigits->clear();
  m_c_channelEnergy->clear();
  m_c_channelTime->clear();
  m_c_channelLayer->clear();
  if (!m_noBadCells) m_c_channelBad->clear();
  m_c_channelChInfo->clear();
  if (m_getLArCalibConstants){
    ATH_MSG_DEBUG("Clear calib. constants..");
    m_c_channelEffectiveSigma->clear();
    m_c_channelNoise->clear();
    m_c_channelDSPThreshold->clear();
    m_c_channelOFCTimeOffset->clear();
    m_c_channelADC2MEV0->clear();
    m_c_channelADC2MEV1->clear();
    m_c_channelPed->clear();
    m_c_channelOFCa->clear();
    m_c_channelOFCb->clear();
    m_c_channelMinBiasAvg->clear();    
    if (!m_isMC){
      m_c_channelOfflEneRescaler->clear();
      m_c_channelOfflHVScale->clear();
      m_c_channelShapeDer->clear();
      m_c_channelShape->clear();
    }
  }
  // Cluster raw channel
  ATH_MSG_DEBUG("Clear Clusters rawch..");
  m_c_rawChannelIdMap->clear();
  m_c_rawChannelChInfo->clear();
  m_c_rawChannelAmplitude->clear();
  m_c_rawChannelTime->clear();
  m_c_rawChannelLayer->clear();
  m_c_rawChannelPed->clear();// raw channel estimated pedestal 
  m_c_rawChannelProv->clear();// raw channel LAr provenance (tile masked)
  m_c_rawChannelQuality->clear();
  m_c_clusterRawChannelIndex->clear();
  m_c_clusterIndex_rawChLvl->clear();
  if (!m_isMC){
    m_c_rawChannelDSPThreshold->clear();
  }
  // ############
 
  // ## Cluster EMB2_711
  if (m_doAssocTopoCluster711Dump){    
    *m_c711_clusterIndexCounter = 0;
    m_c711_clusterIndex->clear();
    m_c711_electronIndex_clusterLvl->clear();
    m_c711_clusterEnergy->clear();
    m_c711_clusterPt->clear();
    m_c711_clusterTime->clear();
    m_c711_clusterEta->clear();
    m_c711_clusterPhi->clear();
    // Cluster cell
    ATH_MSG_DEBUG("Clear Clusters 7x11 cell..");
    *m_c711_cellIndexCounter = 0;
    m_c711_clusterIndex_cellLvl->clear();
    m_c711_clusterCellIndex->clear();
    m_c711_cellGain->clear(); 
    m_c711_cellLayer->clear();
    m_c711_cellRegion->clear();
    m_c711_cellEnergy->clear();
    m_c711_cellTime->clear();
    m_c711_cellEta->clear();
    m_c711_cellPhi->clear();
    m_c711_cellDEta->clear();
    m_c711_cellDPhi->clear();
    m_c711_cellToClusterDPhi->clear();
    m_c711_cellToClusterDEta->clear();   
    // Cluster channel
    ATH_MSG_DEBUG("Clear Clusters 7x11 channel..");
    m_c711_clusterIndex_chLvl->clear();
    m_c711_clusterChannelIndex->clear();
    m_c711_channelHashMap->clear(); // 
    m_c711_channelChannelIdMap->clear();
    m_c711_channelDigits->clear();
    m_c711_channelEnergy->clear();
    m_c711_channelTime->clear();
    m_c711_channelLayer->clear();
    if (!m_noBadCells) m_c711_channelBad->clear();
    m_c711_channelChInfo->clear();
    if (m_getLArCalibConstants){
      m_c711_channelEffectiveSigma->clear();
      m_c711_channelNoise->clear();
      m_c711_channelDSPThreshold->clear();
      m_c711_channelOFCTimeOffset->clear();
      m_c711_channelADC2MEV0->clear();
      m_c711_channelADC2MEV1->clear();
      m_c711_channelPed->clear();
      m_c711_channelOFCa->clear();
      m_c711_channelOFCb->clear();
      m_c711_channelMinBiasAvg->clear();    
      if (!m_isMC){
        m_c711_channelOfflEneRescaler->clear();
        m_c711_channelOfflHVScale->clear();
        m_c711_channelShapeDer->clear();
        m_c711_channelShape->clear();
      }      
    }
    // Cluster raw channel
    ATH_MSG_DEBUG("Clear Clusters 7x11 rawch..");
    m_c711_rawChannelIdMap->clear();
    m_c711_rawChannelChInfo->clear();
    m_c711_rawChannelAmplitude->clear();
    m_c711_rawChannelTime->clear();
    m_c711_rawChannelLayer->clear();
    m_c711_rawChannelPed->clear();// raw channel estimated pedestal 
    m_c711_rawChannelProv->clear();// raw channel LAr provenance (tile masked)
    m_c711_rawChannelQuality->clear();
    m_c711_clusterRawChannelIndex->clear();
    m_c711_clusterIndex_rawChLvl->clear();
    if (!m_isMC){
      m_c711_rawChannelDSPThreshold->clear();
    }
}
 
  // ## Particle Truth ##
  if (m_isMC){
    if (m_doLArEMBHitsDump){
      m_hits_sampling->clear();
      m_hits_clusterIndex_chLvl->clear();
      m_hits_clusterChannelIndex->clear();
      m_hits_hash->clear();
      m_hits_energy->clear();
      m_hits_time->clear();
      m_hits_sampFrac->clear();
      m_hits_energyConv->clear();
      m_hits_cellEta->clear();
      m_hits_cellPhi->clear();
    }
 
    if (m_doTruthPartDump){
      ATH_MSG_DEBUG("particle truth..");
      m_mc_part_energy->clear();
      m_mc_part_pt->clear();
      m_mc_part_m->clear();
      m_mc_part_eta->clear();
      m_mc_part_phi->clear();
      m_mc_part_pdgId->clear();
      m_mc_part_status->clear();
      m_mc_part_barcode->clear();
    }
    // ## Vertex Truth ##
    if (m_doTruthEventDump){
      m_mc_vert_x->clear();
      m_mc_vert_y->clear();
      m_mc_vert_z->clear();
      m_mc_vert_time->clear();
      m_mc_vert_perp->clear();
      m_mc_vert_eta->clear();
      m_mc_vert_phi->clear();
      m_mc_vert_barcode->clear();
      m_mc_vert_status->clear();
    }
  }
  // ## Photons ##
  if (m_doPhotonDump){
    ATH_MSG_DEBUG("Clear Photons");
    m_ph_energy->clear();
    m_ph_eta->clear();
    m_ph_phi->clear();
    m_ph_pt->clear();
    m_ph_m->clear();
  }
 
  ATH_MSG_DEBUG("Clear: Vertexes");
  m_vtx_x->clear();
  m_vtx_y->clear();
  m_vtx_z->clear();
  m_vtx_deltaZ0->clear();
  m_vtx_delta_z0_sin->clear();
  m_vtx_d0sig->clear();
 
  // ## Electrons ##
  ATH_MSG_DEBUG("Clear: Electrons");
  m_el_index->clear();
  m_el_Pt->clear();
  m_el_et->clear();
  m_el_Eta->clear();
  m_el_Phi->clear();
  m_el_m->clear();
  m_el_eoverp->clear();
  
  // offline shower shapes 
  m_el_f1->clear();
  m_el_f3->clear();
  m_el_eratio->clear();
  m_el_weta1->clear();
  m_el_weta2->clear();
  m_el_fracs1->clear();
  m_el_wtots1->clear();
  m_el_e277->clear();
  m_el_reta->clear();
  m_el_rphi->clear();
  m_el_deltae->clear();
  m_el_rhad->clear();
  m_el_rhad1->clear();
 
  // ## Tag and Probe ##
  //zee
  if (!m_doElecSelectByTrackOnly && m_doTagAndProbe){
    ATH_MSG_DEBUG("Clear: T&P");
    m_zee_M->clear();
    m_zee_E->clear();
    m_zee_pt->clear();
    m_zee_px->clear();
    m_zee_py->clear();
    m_zee_pz->clear();
    m_zee_T->clear();
    m_zee_deltaR->clear();
  }
}

clearLBData()

void EventReaderBaseAlg::clearLBData ( )

protectedinherited

Definition at line 245 of file EventReaderBaseAlg.cxx.

                                    {
  m_lb_lumiblock->clear();
  if (!m_isMC){
    m_lb_bcidLuminosity->clear();
  }  
}

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

deltaPhi()

double EventReaderBaseAlg::deltaPhi ( double  phi1, double  phi2  )

protectedinherited

Definition at line 224 of file EventReaderBaseAlg.cxx.

                                                           {
  // Fix phi value for delta_phi calculation, to -pi,+pi interval.
  double deltaPhi = fixPhi(phi1) - fixPhi(phi2);
  return fixPhi(deltaPhi);
}

deltaR()

double EventReaderBaseAlg::deltaR ( double  eta, double  phi  )

protectedinherited

Definition at line 230 of file EventReaderBaseAlg.cxx.

                                                          {
  return sqrt( deta*deta + fixPhi(dphi)*fixPhi(dphi) );
}

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

dumpClusterCells()

StatusCode EventReaderAlg::dumpClusterCells ( const xAOD::CaloCluster *  cl, int  clusIndex, const EventContext &  ctx  )

privatevirtual

Definition at line 546 of file EventReaderAlg.cxx.

                                                                                                            {
 
  SG::ReadHandle<LArDigitContainer>       LarDigCnt  = SG::makeHandle(m_larDigitCntSgKey,ctx);
  if(!LarDigCnt.isValid()) ATH_MSG_ERROR("LArDigitContainer is not a valid container!");
  SG::ReadHandle<LArRawChannelContainer>  LArRawCnt  = SG::makeHandle(m_larRawChCntSgKey,ctx);
  if(!LArRawCnt.isValid()) ATH_MSG_ERROR("LArRawChannelContainer is not a valid container!");
  
  // calorimeter level
  std::bitset<200000>       larClusteredDigits;
  std::vector<size_t>       caloHashMap;
  std::vector<HWIdentifier> channelHwidInClusterMap; //unique for any readout in the ATLAS
  std::vector<int>          cellIndexMap;
  std::vector<float>        channelIndexMap;
  std::vector<int>          cellLayerMap;
  // cell level
  std::vector<double>       clusCellEtaMap;//unused
  std::vector<double>       clusCellPhiMap; //unused
  // channel level
  std::vector<double>       channelEnergyInClusterMap;
  std::vector<double>       channelTimeInClusterMap;
  std::vector<double>       channelEtaInClusterMap;
  std::vector<double>       channelPhiInClusterMap;
  std::vector<float>        channelEffectiveSigmaClusterMap;
  std::vector<float>        channelNoiseClusterMap;
 
  std::vector<int>          channelCaloRegionMap;
  std::vector<bool>         badChannelMap;
 
  // cluster
  double  clusEta           = cl->eta();
  double  clusPhi           = cl->phi();
  double  clusEt            = cl->et();
  double  clusPt            = cl->pt();
  double  clusTime          = cl->time();
 
  ATH_MSG_DEBUG (" (Cluster) Cluster: "<< clusIndex <<", numberCells: " << cl->numberCells() << ", e = " << cl->e() << ", time = "<< clusTime << ", pt = " << cl->pt() << " , eta = " << cl->eta() << " , phi = " << cl->phi());
 
  // loop over cells in cluster
  auto itrCellsBegin = cl->cell_begin();
  auto itrCellsEnd = cl->cell_end();
  int cellNum = 0; //cell number just for printing out
 
  for (auto itCells=itrCellsBegin; itCells != itrCellsEnd; ++itCells){
    const CaloCell* cell = (*itCells); //get the caloCells
    if (cell){ // check for empty clusters
      Identifier cellId = cell->ID();
 
      int caloRegionIndex = getCaloRegionIndex(cell); // custom caloRegionIndex based on caloDDE
 
      double  eneCell   = cell->energy();
      double  timeCell  = cell->time();
      double  etaCell   = cell->eta();
      double  phiCell   = cell->phi();          
      int     gainCell  = cell->gain(); // CaloGain type
      int     layerCell = m_calocell_id->calo_sample(cell->ID());
      bool    badCell   = cell->badcell(); // applied to LAR channels. For Tile, we use TileCell* tCell->badch1() or 2.
      bool    isTile    = cell->caloDDE()->is_tile();
      bool    isLAr     = cell->caloDDE()->is_lar_em();
      bool    isLArFwd  = cell->caloDDE()->is_lar_fcal();
      bool    isLArHEC  = cell->caloDDE()->is_lar_hec();
      double  detaCell  = cell->caloDDE()->deta(); //delta eta - granularity
      double  dphiCell  = cell->caloDDE()->dphi(); //delta phi - granularity
      float   effSigma  = m_noiseCDO->getEffectiveSigma(cell->ID(), cell->gain(), cell->energy()); // effective sigma of cell related to its noise.
      float   cellNoise = m_noiseCDO->getNoise(cell->ID(), cell->gain()); // cell noise value
 
      IdentifierHash chidHash;
      HWIdentifier chhwid;
      size_t index;
 
      // ========= TileCal ==========
      if (isTile) continue;
    
      // ========= LAr ==========
      else if ((isLAr) || (isLArFwd) || (isLArHEC)) { //LAr
        chhwid = m_larCabling->createSignalChannelID(cellId);
        chidHash =  m_onlineLArID->channel_Hash(chhwid);
        index = (size_t) (chidHash);
 
        if (larClusteredDigits.test(index)) {
          ATH_MSG_ERROR (" ##### (Cluster) Error LAr: Conflict index position in Channel map. Position was already filled in this event. Skipping the cell of index: " << index << " and hwid: " << chhwid << ". Cell_E/t="<<cell->energy() << "/"<< cell->time() << ". Eta/Phi: "<< cell->eta() << "/" << cell->phi());
          continue;
          }
        if (badCell && m_noBadCells){
          ATH_MSG_INFO (" (Cluster)(LAr) Cell "<< cellNum <<" in cluster is a bad LAr channel! Skipping the cell.");
          continue;
        }
        larClusteredDigits.set(index);
        caloHashMap.push_back(index);
        cellIndexMap.push_back(m_c_cellIndexCounter);
        clusCellEtaMap.push_back(etaCell);
        clusCellPhiMap.push_back(phiCell);
        cellLayerMap.push_back(layerCell);
        channelIndexMap.push_back( m_c_cellIndexCounter ); 
        channelHwidInClusterMap.push_back(chhwid);
        channelTimeInClusterMap.push_back(timeCell);
        channelEnergyInClusterMap.push_back(eneCell);
        channelCaloRegionMap.push_back(caloRegionIndex);
        channelEffectiveSigmaClusterMap.push_back(effSigma);
        channelNoiseClusterMap.push_back(cellNoise);
        if (!m_noBadCells) badChannelMap.push_back(badCell);
 
        if (m_printCellsClus){ //optional to help debugging
          ATH_MSG_INFO (" (Cluster) in IsLAr: Cell (layer) "<< cellNum << " (" << layerCell <<") ID: " << cellId << "). HwId (B_EC/P_N/FeedTr/slot/ch) " <<  chhwid << " (" << m_onlineLArID->barrel_ec(chhwid) << "/" << m_onlineLArID->pos_neg(chhwid) << "/"<< m_onlineLArID->feedthrough(chhwid) << "/" << m_onlineLArID->slot(chhwid) << "/" << m_onlineLArID->channel(chhwid) << ") . Index: " << index << ". ene " << eneCell << ". time " << timeCell << ". D_eta: " << detaCell << ". D_phi: " << dphiCell << " ):" << ". Eta/Phi: "<< cell->eta() << "/" << cell->phi());
        }
      } //end else LAr
 
      else {
        ATH_MSG_ERROR (" ####### (Cluster) ERROR ! No CaloCell region was found!");
        continue;
      }
 
      // ##############################
      //  CELL INFO DUMP (CLUSTER)
      // ##############################
      const double clusterDphiRaw = clusPhi - phiCell;      
      double cluster_dphi = 0.;
 
      if (clusterDphiRaw  < -pi) {
        cluster_dphi = twopi + clusterDphiRaw;
      }
      else if (clusterDphiRaw > pi) {
        cluster_dphi = clusterDphiRaw - twopi;
      }
      else {
        cluster_dphi = clusterDphiRaw;
      }
 
      m_c_clusterIndex_cellLvl->push_back(clusIndex);
      m_c_clusterCellIndex->push_back(m_c_cellIndexCounter);
      m_c_cellGain->push_back(gainCell);
      m_c_cellLayer->push_back(layerCell);
      m_c_cellEnergy->push_back(eneCell);
      m_c_cellTime->push_back(timeCell);
      m_c_cellEta->push_back(etaCell);
      m_c_cellPhi->push_back(phiCell);
      m_c_cellDEta->push_back(detaCell);
      m_c_cellDPhi->push_back(dphiCell);
      m_c_cellToClusterDEta->push_back(clusEta - etaCell);
      m_c_cellToClusterDPhi->push_back(cluster_dphi);
      m_c_cellRegion->push_back(caloRegionIndex);
      
      m_c_cellIndexCounter++;
      cellNum++;
    } // end if-cell is empty verification
  } // end loop at cells inside cluster
 
  // ##############################
  //  CLUSTER INFO DUMP (CLUSTER)
  // // ##############################
  m_c_clusterIndex->push_back(clusIndex);
  m_c_clusterEnergy->push_back(clusEt);
  m_c_clusterTime->push_back(clusTime);
  m_c_clusterEta->push_back(clusEta);
  m_c_clusterPhi->push_back(clusPhi);
  m_c_clusterPt->push_back(clusPt);
 
  // ##############################
  //  DIGITS CHANNEL INFO DUMP (CLUSTER)
  // ##############################
  // Loop over ALL channels in LAr Digit Container.
  // Dump only the channels inside the previous clusters
 
  // ========= LAr ==========
  if (larClusteredDigits.any()){    
    // -- LAr_Hits --
    if (m_isMC && m_doLArEMBHitsDump){
      ATH_MSG_DEBUG (" (Cluster-HITS) Dumping LAr EMB Hits...");
 
      m_ncell = m_calocell_id->calo_cell_hash_max();
 
      SG::ReadHandle<LArHitContainer> larHitCnt = SG::makeHandle(m_larEMBHitCntSgKey,ctx);
      if(!larHitCnt.isValid()) ATH_MSG_ERROR("LAr EMB Hit container is not valid!");
 
      for (unsigned int k=0 ; k < channelHwidInClusterMap.size() ; k++){
        double cell_total_ene       = 0.0;
        double cell_total_eneCalib  = 0.0;
        double cell_hit_tof         = -999.0;
        double hit_ene              = 0.;
        double hit_time             = 0.;
        float  hit_fSampCalib       = 1.;
        int hit_sampling            = 0;
        size_t hit_index1           = 0;
        bool thereIsOneHitToDump    = false;
        std::vector<double>         hitEnergiesFromMap;
        std::vector<double>         hitTimesFromMap  ;
        
        for (const LArHit* hit : *larHitCnt){
          Identifier hit_cellID         = hit->cellID();
          HWIdentifier hit_hwid         = m_larCabling->createSignalChannelID(hit_cellID);
          IdentifierHash hit_idHash     = m_onlineLArID->channel_Hash(hit_hwid);
          hit_index1                    = (size_t) (hit_idHash);//(m_calocell_id->calo_cell_hash(hit_cellID));          
 
          if (larClusteredDigits.test(hit_index1)){
            if (channelHwidInClusterMap[k]==hit_hwid){
          
              hit_ene                   = hit->energy();
              hit_time                  = hit->time();
              hit_sampling              = m_calocell_id->calo_sample(hit_cellID);
 
              if (hit_index1 < m_ncell && fabs(hit_time) < 25.){ // time < 25 ns (current BC)
                hitEnergiesFromMap.push_back(hit_ene);
                hitTimesFromMap.push_back(hit_time);
                hit_fSampCalib = m_fSampl->FSAMPL(hit_cellID);                
                thereIsOneHitToDump = true;
 
                ATH_MSG_DEBUG ("(HITS) Match in "<< k <<"/"<< channelHwidInClusterMap.size() <<"! Sampling "<< hit_sampling << ",  Cell (clus): "<< channelIndexMap[k] <<" ("<< clusIndex <<"), ID (mapHwid / hwid / hash ): "<< hit_cellID << " ("<< channelHwidInClusterMap[k] << " / "<< hit_hwid << " / "<< hit_index1 <<"), hitEne: "<< hit_ene <<", hitTime: "<< hit_time << ", m_fSampl: "<< hit_fSampCalib <<". eta="<< clusCellEtaMap[k]<< ", phi="<<clusCellPhiMap[k]<<".");             
 
              }// end-if caloHashMap matches
            }// end-if cluster map has this hit_index 
          }// end-if current bc test
        }// end-if current bc test
 
        if (thereIsOneHitToDump){
          for (auto hitE : hitEnergiesFromMap){
            cell_total_ene      += hitE;
            cell_total_eneCalib += hitE / hit_fSampCalib; //calib energy from hits
          }
          cell_hit_tof = *std::min_element(hitTimesFromMap.begin(), hitTimesFromMap.end());
          
          m_hits_energy->push_back(cell_total_ene);
          m_hits_time->push_back(cell_hit_tof);
          m_hits_sampling->push_back(hit_sampling);
          m_hits_clusterIndex_chLvl->push_back(clusIndex);
          m_hits_clusterChannelIndex->push_back(channelIndexMap[k]);
          m_hits_hash->push_back(hit_index1);
          m_hits_sampFrac->push_back(hit_fSampCalib);
          m_hits_energyConv->push_back(cell_total_eneCalib);
          m_hits_cellEta->push_back(clusCellEtaMap[k]);
          m_hits_cellPhi->push_back(clusCellPhiMap[k]);
        }
        else{
          ATH_MSG_DEBUG("(HITS) Hit from cell "<< k <<"/"<< channelHwidInClusterMap.size() <<" not found! Sampling "<< hit_sampling << ",  Cell (clus): "<< channelIndexMap[k] <<" ("<< clusIndex <<"), mapHwid: "<< channelHwidInClusterMap[k]<<". eta="<< clusCellEtaMap[k]<< ", phi="<<clusCellPhiMap[k]<<".");
        }
        hitEnergiesFromMap.clear();
        hitTimesFromMap.clear();
        
      }// end for loop over caloHashMaps
    }// end-if isMC and dumpHits 
 
 
    // -- LAr_Digits --
    ATH_MSG_DEBUG (" (Cluster) Dumping LAr Digits...");
 
    for (const LArDigit* dig : *LarDigCnt) {
      HWIdentifier channelID  = dig->channelID();
      IdentifierHash idHash   = m_onlineLArID->channel_Hash(channelID);
      size_t index = (size_t) (idHash);
 
      if (larClusteredDigits.test(index)) {
        for (unsigned int k=0 ; k < channelHwidInClusterMap.size() ; k++){
          if (channelHwidInClusterMap[k]==channelID){
            
            // digits
            std::vector<short> larDigitShort = dig->samples();
            std::vector<float> larDigit( larDigitShort.begin(), larDigitShort.end() ); // get vector conversion from 'short int' to 'float'
            m_c_channelDigits->push_back(larDigit);
 
            const HWIdentifier   digId           = dig->hardwareID();
            const int            digGain         = dig->gain();
            auto                 ofc_a           = m_ofcs->OFC_a(digId, digGain);
            auto                 ofc_b           = m_ofcs->OFC_b(digId, digGain);
 
            std::vector<double>   ofca, ofcb, shape, shapeDer;
            const IdentifierHash& dig_cell_hashId = m_onlineLArID->channel_Hash(channelID);
            for (size_t k=0; k < ofc_a.size(); k++) ofca.push_back((double) ofc_a[k]);
            for (size_t k=0; k < ofc_b.size(); k++) ofcb.push_back((double) ofc_b[k]);
 
            const auto&          adc2mev            = m_adc2MeVs->ADC2MEV(digId, digGain);
            const float          pedLAr             = m_peds->pedestal(digId, digGain);
            const auto&          minBiasLAr         = m_minBiasAvgs->minBiasAverage(digId);
            
              // Remark: Looks like the EC does not have this rescale in DB (?)            
            if (!m_isMC){
              auto                 sig_shape       = m_shapes->Shape(digId, digGain);
              auto                 sig_shapeDer    = m_shapes->ShapeDer(digId, digGain);
              for (size_t k=0; k < sig_shape.size(); k++) shape.push_back((double) sig_shape[k]);
              for (size_t k=0; k < sig_shapeDer.size(); k++) shapeDer.push_back((double) sig_shapeDer[k]);
 
              float                offl_EneRescaler   = 1.0; // if the channel is outside of hash_id limits from DB, set scale to 1.0 (energy remains unchanged).
              const auto&          offl_hv            = m_oflHVCorr->HVScaleCorr(digId);
              if (dig_cell_hashId < m_EneRescaler->getNChans()){ // if the channel is INSIDE the hash_id limit, get the data from DB.
                offl_EneRescaler   = m_EneRescaler->getData(dig_cell_hashId,0,0); // IMPORTANT REMARK: There was an update in Athena v23, compared to v22. There is a new <T> for getData() instance, which no longer needs the 2nd and 3rd accessor (adc, gain).
              }
              m_c_channelDSPThreshold->push_back(m_run2DSPThresh->tQThr(digId));
              m_c_channelOfflEneRescaler->push_back(offl_EneRescaler);
              m_c_channelOfflHVScale->push_back(offl_hv);
              m_c_channelShape->push_back(shape);
              m_c_channelShapeDer->push_back(shapeDer);
            }
            // Cell / readout data
            m_c_channelEnergy->push_back(channelEnergyInClusterMap[k]);
            m_c_channelTime->push_back(channelTimeInClusterMap[k]);
            m_c_channelLayer->push_back(cellLayerMap[k]);
            m_c_channelEffectiveSigma->push_back(channelEffectiveSigmaClusterMap[k]);
            m_c_channelNoise->push_back(channelNoiseClusterMap[k]);
            if (!m_noBadCells) m_c_channelBad->push_back(badChannelMap[k]);
            // Calibration constants         
            m_c_channelOFCa->push_back(ofca);
            m_c_channelOFCb->push_back(ofcb);
            m_c_channelOFCTimeOffset->push_back(m_ofcs->timeOffset(digId,digGain));
            m_c_channelADC2MEV0->push_back(adc2mev[0]);
            m_c_channelADC2MEV1->push_back(adc2mev[1]);
            m_c_channelPed->push_back(pedLAr);
            m_c_channelMinBiasAvg->push_back(minBiasLAr);
 
            // Channel info
            int barrelEc = m_onlineLArID->barrel_ec(channelID);
            int posNeg = m_onlineLArID->pos_neg(channelID);
            int feedThr = m_onlineLArID->feedthrough(channelID); // feedthrough - cabling interface from cold and hot side. in barrel, there are 2 feedThr for each crate.
            int slot = m_onlineLArID->slot(channelID);
            int chn = m_onlineLArID->channel(channelID);      
            std::vector<int> chInfo {barrelEc, posNeg, feedThr, slot, chn } ; //unite info
            m_c_channelChInfo->push_back(chInfo); //add to the list of cell info (both calo)
 
            // important indexes
            m_c_clusterChannelIndex->push_back(channelIndexMap[k]);//each LAr cell is an individual read out.
            m_c_clusterIndex_chLvl->push_back(clusIndex);  // what roi this cell belongs at the actual event: 0, 1, 2 ... 
            m_c_channelHashMap->push_back(index); // online id hash for channel
            m_c_channelChannelIdMap->push_back(channelID.get_identifier32().get_compact());
 
 
            if (m_printCellsClus){
 
              ATH_MSG_INFO ("(Cluster) In DumpLAr Digits: ReadOutIndex "<< channelIndexMap[k]  << ". HwId " <<  channelID);
              ATH_MSG_INFO ("(Cluster) In DumpLAr Digits: ReadOutIndex "<< channelIndexMap[k]  << " HwId.get_compact() " << channelID.get_compact());
              ATH_MSG_INFO ("(Cluster) In DumpLAr Digits: ReadOutIndex "<< channelIndexMap[k]  <<  " HwId.get_identifier32().get_compact() " << channelID.get_identifier32().get_compact());
 
              ATH_MSG_INFO("(Cluster) LAr OFC timeOffset: "<< m_ofcs->timeOffset(digId, digGain)  <<", dig->hardwareID: " << digId << ", dig->channelID: "<< channelID);
              ATH_MSG_INFO("\tOFCa ("<< ofca.size()<<"): ["<< ofca[0] <<", " << ofca[1] <<", " << ofca[2]<<", "  << ofca[3] <<"]");
              ATH_MSG_INFO("\tOFCb ("<< ofcb.size()<<"): ["<< ofcb[0] <<", " << ofcb[1] <<", " << ofcb[2]<<", "  << ofcb[3] <<"]");
              
              ATH_MSG_DEBUG ("(Cluster) In DumpLAr Digits: ReadOutIndex "<< channelIndexMap[k]  << ". HwId (B_EC/P_N/FeedTr/slot/ch) " <<  channelID << " (" << barrelEc << "/" << posNeg << "/"<< feedThr << "/" << slot << "/" << chn << ". Dig (float): " << larDigit);
 
            }
          } //end-if caloHashMap matches
        } //end for loop over caloHashMaps
      } // end-if clustBits Test
    } //end loop over LAr digits container
  } //end-if larClustBits is not empty
 
  // ##############################
  //  RAW CHANNEL INFO DUMP (CLUSTER)
  // ##############################
 
  // ========= LAr ==========
  if (larClusteredDigits.any()) {
    ATH_MSG_INFO ("(Cluster) Dumping LAr Raw Channel...");
 
    for (const LArRawChannel& LArChannel : *LArRawCnt){
 
      HWIdentifier    channelID   = LArChannel.channelID();
      IdentifierHash  chHwidHash  = m_onlineLArID->channel_Hash(channelID);
 
      size_t index = static_cast<size_t>(chHwidHash);
 
      if (larClusteredDigits.test(index)){ //if this channel index is inside 
        for (unsigned int k=0 ; k < channelHwidInClusterMap.size() ; k++){  //loop over the vector of hashIndex, and verify if the cell index match.
          if (channelHwidInClusterMap[k] == channelID){
            
            //RawCh info
            int rawEnergy        = LArChannel.energy(); // energy in MeV (rounded to integer)
            int rawTime          = LArChannel.time();    // time in ps (rounded to integer)            
            uint16_t rawQuality  = LArChannel.quality(); // quality from pulse reconstruction
            int provenance       = static_cast<int>(LArChannel.provenance()); // its uint16_t
            float rawEnergyConv  = static_cast<float>(rawEnergy); 
            float rawTimeConv    = static_cast<float>(rawTime);
            float rawQualityConv = static_cast<float>(rawQuality);
 
            // Channel info
            int barrelEc = m_onlineLArID->barrel_ec(channelID);
            int posNeg = m_onlineLArID->pos_neg(channelID);
            int feedThr = m_onlineLArID->feedthrough(channelID); // feedthrough - cabling interface from cold and hot side. in barrel, there are 2 feedThr for each crate.
            int slot = m_onlineLArID->slot(channelID);
            int chn = m_onlineLArID->channel(channelID);      
            std::vector<int> chInfo {barrelEc, posNeg, feedThr, slot, chn } ; //unite info
            m_c_rawChannelChInfo->push_back(chInfo); //add to the list of cell info (both calo)
 
            if ( (rawEnergy != rawEnergyConv) || (rawTime != rawTimeConv) || (rawQuality != rawQualityConv) ){
              ATH_MSG_ERROR (" ###### (Cluster) LAR RAW CHANNEL: Value conversion from int to float of amplitude, time or quality (uint16_t) had changed its actual value !!!");
            }
            m_c_rawChannelAmplitude->push_back(rawEnergyConv);
            m_c_rawChannelTime->push_back(rawTimeConv);
            m_c_rawChannelLayer->push_back(cellLayerMap[k]);
            m_c_rawChannelQuality->push_back(rawQualityConv);
            m_c_rawChannelProv->push_back(provenance);
            m_c_rawChannelPed->push_back(-8888); // masked LAr
            if (!m_isMC){
              m_c_rawChannelDSPThreshold->push_back(m_run2DSPThresh->tQThr(channelID));
            }
 
            // important indexes
            m_c_clusterRawChannelIndex->push_back(channelIndexMap[k]);
            m_c_clusterIndex_rawChLvl->push_back(clusIndex); // what roi this ch belongs
            m_c_rawChannelIdMap->push_back(channelID.get_identifier32().get_compact());
 
            if (m_printCellsClus){ //optional to help debugging
 
              HWIdentifier hardwareID = LArChannel.hardwareID();
 
              if (!m_isMC){
                ATH_MSG_INFO ("(Cluster) In DumpLAr Raw "<< channelIndexMap[k] <<": hardwareID (B_EC/P_N/feedThr/slot/chn): " << hardwareID << "(" << barrelEc << "/" << posNeg << "/" << feedThr << "/" << slot << "/" << chn << ")" << ". Energy: " << rawEnergyConv << ". Time: " << rawTimeConv << ". Provenance: " << provenance << ". Quality: " << rawQualityConv <<" ecut (DSPThr) = " << m_run2DSPThresh->tQThr(channelID));
              }
              else{
                ATH_MSG_INFO ("(Cluster) In DumpLAr Raw "<< channelIndexMap[k] <<": hardwareID (B_EC/P_N/feedThr/slot/chn): " << hardwareID << "(" << barrelEc << "/" << posNeg << "/" << feedThr << "/" << slot << "/" << chn << ")" << ". Energy: " << rawEnergyConv << ". Time: " << rawTimeConv << ". Provenance: " << provenance << ". Quality: " << rawQualityConv);
              }
              
            } // end-if optional cell print
          } // end-if hwid match rawChID
        } // end loop over HWIDClusterMap
      } // end-if clust.test
    } //end loop LArRawChannelContainer
  } // end-if clustBits have Cells
 
  larClusteredDigits.reset();
 
  caloHashMap.clear();
 
  channelHwidInClusterMap.clear();
  cellIndexMap.clear();
  cellLayerMap.clear();
  clusCellEtaMap.clear();
  clusCellPhiMap.clear();
  channelIndexMap.clear();
  channelEnergyInClusterMap.clear();
  channelTimeInClusterMap.clear();
  channelEtaInClusterMap.clear();
  channelPhiInClusterMap.clear();
  channelEffectiveSigmaClusterMap.clear();
  channelNoiseClusterMap.clear();
  channelCaloRegionMap.clear();
  if (!m_noBadCells) badChannelMap.clear();
  
  ATH_MSG_INFO ("  (Cluster) RawChannel: "<< m_c_rawChannelAmplitude->size() <<" channels dumped, from " << m_c_cellEta->size() <<" cluster cells. ");
  ATH_MSG_INFO ("  (Cluster) Digits: "<< m_c_channelDigits->size() <<" channels dumped, out of " << m_c_rawChannelAmplitude->size() <<" raw channel cluster channels. ");
  if (m_c_channelDigits->size() == m_c_rawChannelAmplitude->size()){
    ATH_MSG_INFO ("  (Cluster) ALL Digits from the cluster were dumped successfully!");}
  else{
    ATH_MSG_INFO ("  (Cluster) The digits from "<< (m_c_rawChannelAmplitude->size() - m_c_channelDigits->size()) <<" channels are missing!");}
 
 
  return StatusCode::SUCCESS;
}

dumpElectrons()

StatusCode EventReaderAlg::dumpElectrons ( const xAOD::Electron *  electron )

privatevirtual

Definition at line 307 of file EventReaderAlg.cxx.

                                                                     {
  float electronEt = electron->e()/(cosh(electron->trackParticle()->eta()));
  float track_p = (electron->trackParticle())->pt()*std::cosh((electron->trackParticle())->eta());
  float eoverp  = (electron->caloCluster())->e()/track_p;
  m_el_eoverp->push_back(eoverp);
  m_el_Pt->push_back(electron->pt());
  m_el_et->push_back(electronEt);
  m_el_Eta->push_back(electron->eta());
  m_el_Phi->push_back(electron->phi());
  m_el_m->push_back(electron->m());
 
  return StatusCode::SUCCESS;
}

dumpEventInfo()

StatusCode EventReaderAlg::dumpEventInfo ( SG::ReadHandle< xAOD::EventInfo > &  ei )

privatevirtual

Definition at line 391 of file EventReaderAlg.cxx.

                                                                       {
  m_e_runNumber       = ei->runNumber();
  m_e_eventNumber     = ei->eventNumber();
  m_e_bcid            = ei->bcid();
  m_e_lumiBlock       = ei->lumiBlock();
  m_e_inTimePileup    = ei->actualInteractionsPerCrossing();
  m_e_outOfTimePileUp = ei->averageInteractionsPerCrossing();
 
  ATH_MSG_INFO ("in execute, runNumber = " << m_e_runNumber << ", eventNumber = " << m_e_eventNumber << ", bcid: " << m_e_bcid );
  
  return StatusCode::SUCCESS;
}

dumpLumiblockInfo()

StatusCode EventReaderAlg::dumpLumiblockInfo ( SG::ReadHandle< xAOD::EventInfo > &  ei )

privatevirtual

Definition at line 379 of file EventReaderAlg.cxx.

                                                                           {
 
  if (!m_isMC){
    m_lb_bcidLuminosity->push_back(m_lumis->lbLuminosityPerBCIDVector());
    ATH_MSG_INFO ("LB_data: lbLuminosityPerBCIDVector stored into ntuple." );
  }
  m_lb_lumiblock->push_back( ei->lumiBlock() );
  ATH_MSG_INFO ("LB_data: Lumiblock "<< ei->lumiBlock() << " stored into ntuple." );
 
  return StatusCode::SUCCESS;
}

dumpOfflineSS()

StatusCode EventReaderAlg::dumpOfflineSS ( const xAOD::Electron *  electron )

privatevirtual

Definition at line 289 of file EventReaderAlg.cxx.

                                                                    {
    m_el_f1->push_back(electron->showerShapeValue(xAOD::EgammaParameters::f1));
    m_el_f3->push_back(electron->showerShapeValue(xAOD::EgammaParameters::f3));
    m_el_eratio->push_back(electron->showerShapeValue(xAOD::EgammaParameters::Eratio));
    m_el_weta1->push_back(electron->showerShapeValue(xAOD::EgammaParameters::weta1));
    m_el_weta2->push_back(electron->showerShapeValue(xAOD::EgammaParameters::weta2));
    m_el_fracs1->push_back(electron->showerShapeValue(xAOD::EgammaParameters::fracs1));
    m_el_wtots1->push_back(electron->showerShapeValue(xAOD::EgammaParameters::wtots1));
    m_el_e277->push_back(electron->showerShapeValue(xAOD::EgammaParameters::e277));
    m_el_reta->push_back(electron->showerShapeValue(xAOD::EgammaParameters::Reta));
    m_el_rphi->push_back(electron->showerShapeValue(xAOD::EgammaParameters::Rphi));
    m_el_deltae->push_back(electron->showerShapeValue(xAOD::EgammaParameters::DeltaE));
    m_el_rhad->push_back(electron->showerShapeValue(xAOD::EgammaParameters::Rhad));
    m_el_rhad1->push_back(electron->showerShapeValue(xAOD::EgammaParameters::Rhad1));
   
  return StatusCode::SUCCESS;
}

dumpPrimVertexAssocToElectron()

StatusCode EventReaderAlg::dumpPrimVertexAssocToElectron ( const xAOD::Electron *  el, SG::ReadHandle< xAOD::VertexContainer > &  primVertexCnt, SG::ReadHandle< xAOD::EventInfo > &  evtInfo  )

privatevirtual

Definition at line 321 of file EventReaderAlg.cxx.

                                                                                                                                                                       {
 
  const xAOD::TrackParticle *trackElectron =  el->trackParticle();
 
  // check for primary vertex in the event
  // *************** Primary vertex check ***************
  //loop over vertices and look for good primary vertex
  float   bestDeltaZ0Sin  = 9999.0, bestZfromVertex = 9999.0, bestXFromVertex = 9999.0, bestYFromVertex = 9999.0, bestDeltaZ0 = 9999.0;
  double  bestD0Sig       = 9999.0;
  int     vtxCounter      = 0;//, bestVtxCounter = 0;
  bool    isAnyClosestVtx = false;
  for (const xAOD::Vertex *vxIter : *primVertexCnt) {
 
    // Select good primary vertex
    float zFromVertex   = vxIter->z();
    float delta_z0      = fabs(trackElectron->z0() + trackElectron->vz() - zFromVertex); //where trk.vz() represents the point of reference for the z0 calculation (in this case, the beamspot position along the z axis).
    float delta_z0_sin  = delta_z0 * sin(trackElectron->theta()); //where sin(trk.theta()) parameterises the uncertainty of the z0 measurement. 
    double d0sig = xAOD::TrackingHelpers::d0significance( trackElectron, evtInfo->beamPosSigmaX(), evtInfo->beamPosSigmaY(), evtInfo->beamPosSigmaXY() );
 
 
    if ((vxIter->vertexType() == xAOD::VxType::PriVtx) && ( fabs(delta_z0_sin) < m_z0Tag) && (fabs(d0sig) < m_d0TagSig) ){ //is this vertex passed into d0sig and dz0Sin conditions?
      isAnyClosestVtx = true;
      
      ATH_MSG_DEBUG ("(dumpPrimVertexAssocToElectron) Vertex "<< vtxCounter << ": This is a primary vertex. |delta_z0_sin| < 0.5 mm ("<< delta_z0_sin << "). |d0sig| < 5 (" << d0sig << ")");
      if ( (fabs(delta_z0_sin) < fabs(bestDeltaZ0Sin) ) &&  (fabs(d0sig) < fabs(bestD0Sig)) ) // is this vertex the closest one to that electron track?
      {
        // assign all variables to dump:
        ATH_MSG_DEBUG ("(dumpPrimVertexAssocToElectron) New best associated Vertex. Vertex "<< vtxCounter << ": |delta_z0_sin| < 0.5 mm ("<< delta_z0_sin << "). |d0sig| < 5 (" << d0sig << ")");
 
        bestDeltaZ0Sin      = delta_z0_sin;
        bestD0Sig           = d0sig;
 
        bestXFromVertex = vxIter->x();
        bestYFromVertex = vxIter->y();
        bestZfromVertex = zFromVertex;
        bestDeltaZ0     = delta_z0;
      }
    }
    vtxCounter++;
  }
  // --------- Dump here: ---------
  if (isAnyClosestVtx){
    m_vtx_x->push_back(bestXFromVertex);
    m_vtx_y->push_back(bestYFromVertex);
    m_vtx_z->push_back(bestZfromVertex);
    m_vtx_deltaZ0->push_back(bestDeltaZ0);
    m_vtx_delta_z0_sin->push_back(bestDeltaZ0Sin);
    m_vtx_d0sig->push_back(bestD0Sig);
  }
  else{
    ATH_MSG_ERROR("A pre-selected electron track has no closest vertex to dump! (weird?)");
  }
  // -------------------------------
 
 
  return StatusCode::SUCCESS;
}

dumpTruthParticle()

StatusCode EventReaderAlg::dumpTruthParticle ( SG::ReadHandle< xAOD::ElectronContainer > &  electronSelectionCnt, SG::ReadHandle< xAOD::TruthParticleContainer > &  truthParticleCnt  )

privatevirtual

Definition at line 500 of file EventReaderAlg.cxx.

                                                                                                                                                                 {
  ATH_MSG_INFO("Dumping Truth Particle...");
 
  auto elecCandidates = std::make_unique<ConstDataVector<xAOD::TruthParticleContainer>> (SG::VIEW_ELEMENTS);
 
  if (truthParticleCnt->size() == 0) ATH_MSG_INFO("truthParticleCnt is empty!");
  else{
    for (const xAOD::Electron *recElectron : *electronSelectionCnt){
 
      const xAOD::TruthParticle *truth = xAOD::TruthHelpers::getTruthParticle(*recElectron);
      elecCandidates->push_back( truth ); 
 
      ATH_MSG_INFO("(TruthParticle) Reco pt="<< recElectron->pt()<<" , Truth pt= "<< truth->pt());
      }
    }
 
    if (elecCandidates->size() > 0)  ATH_MSG_INFO("(TruthParticle) Size of elecCandidates is "<< elecCandidates->size()<<" !");
 
    for (const xAOD::TruthParticle *elecSelected : *elecCandidates){
      const xAOD::TruthVertex* vertex = elecSelected->prodVtx();
 
      TLorentzVector elecCandidateLorentz;
      elecCandidateLorentz.SetPtEtaPhiE(elecSelected->pt(),elecSelected->eta(),elecSelected->phi(),elecSelected->e()); 
 
      m_mc_vert_x->push_back(vertex->x());  // vertex displacement
      m_mc_vert_y->push_back(vertex->y());  // vertex displacement
      m_mc_vert_z->push_back(vertex->z());  // vertex displacement in beam direction
      m_mc_vert_time->push_back(vertex->t());  // vertex time
      m_mc_vert_perp->push_back(vertex->perp());  // Vertex transverse distance from the beam line
      m_mc_vert_eta->push_back(vertex->eta());  // Vertex pseudorapidity
      m_mc_vert_phi->push_back(vertex->phi());  // Vertex azimuthal angle
      m_mc_vert_barcode->push_back(HepMC::barcode(vertex));  // FIXME barcode-based
      m_mc_vert_status->push_back(HepMC::status(vertex));
 
      m_mc_part_energy->push_back(elecSelected->e());
      m_mc_part_pt->push_back(elecSelected->pt());
      m_mc_part_pdgId->push_back(elecSelected->pdgId());
      m_mc_part_m->push_back(elecSelected->m());
      m_mc_part_phi->push_back(elecSelected->phi());
      m_mc_part_eta->push_back(elecSelected->eta());
    }
  ATH_CHECK (evtStore()->record( elecCandidates.release(), "MyMatchedTruthElectrons"));
  return StatusCode::SUCCESS;
  
}

dumpZeeCut()

StatusCode EventReaderAlg::dumpZeeCut ( SG::ReadHandle< xAOD::EventInfo > &  ei, SG::ReadHandle< xAOD::VertexContainer > &  primVertexCnt, const EventContext &  ctx  )

privatevirtual

Definition at line 404 of file EventReaderAlg.cxx.

                                                                                                                                               {
  ATH_MSG_INFO("Dumping Zee cut region...");
  
  auto electronSelectionCnt             = std::make_unique<ConstDataVector<xAOD::ElectronContainer>> (SG::VIEW_ELEMENTS);
  auto TagAndProbeElectronSelectionCnt  = std::make_unique<ConstDataVector<xAOD::ElectronContainer>> (SG::VIEW_ELEMENTS);
  
  SG::ReadHandle<xAOD::ElectronContainer> electronsCnt = SG::makeHandle(m_electronCntSgKey,ctx);
 
  if (!electronsCnt.isValid()) {
    ATH_MSG_ERROR("Electron container is not valid!");
    return StatusCode::FAILURE;
  }
   
  // Pre-selection of electrons
  for (auto el : *electronsCnt){
    if (std::abs(el->eta()) > m_elecEtaCut){ // apply electron |eta| cut
      continue;
    }
    if (trackSelectionElectrons(el, primVertexCnt, ei) == true){
      if (eOverPElectron(el) == true){ // if 0.7 < E/p < 1.4
        electronSelectionCnt->push_back( el );
      }
    }
    else continue;
  }
 
  if (m_doElecSelectByTrackOnly){ // do not proceed to T&P
    ATH_CHECK (evtStore()->record( electronSelectionCnt.release(), "MySelectedElectrons"));
    return StatusCode::SUCCESS;
  }
 
  if (electronSelectionCnt->size() < 2){
    ATH_MSG_DEBUG("(TagAndProbe) Not enough Electrons for T&P (nElectrons="<<electronSelectionCnt->size() << "). Storing "<<electronSelectionCnt->size()<<" electron on MyTagAndProbeElectrons container. This will not be dumped!");
    ATH_CHECK (evtStore()->record( TagAndProbeElectronSelectionCnt.release(), "MyTagAndProbeElectrons"));
    return StatusCode::SUCCESS;
  }
 
  // ## Loop over electron container in search of Zee pairs ##
    for (const xAOD::Electron *elTag : *electronSelectionCnt){
      
    if (! isTagElectron(elTag)) continue;
    ATH_MSG_DEBUG("(TagAndProbe) Electron is a Tag!");
 
    for (const xAOD::Electron *elProbe : *electronSelectionCnt){
      if (elTag==elProbe) continue;
 
      //check for charge (opposite charges for Zee)
      if ( elTag->charge() == elProbe->charge() ) continue;      
      ATH_MSG_DEBUG ("(TagAndProbe) Electron Pair Charges are opposite! Good.");
 
      //check for Zee mass    
      TLorentzVector el1;
      TLorentzVector el2;
      el1.SetPtEtaPhiE(elTag->pt(), elTag->trackParticle()->eta(), elTag->trackParticle()->phi(), elTag->e());
      el2.SetPtEtaPhiE(elProbe->pt(), elProbe->trackParticle()->eta(), elProbe->trackParticle()->phi(), elProbe->e());
 
      float tpPairMass = (el1 + el2).M(); // mass of the electron pair
      ATH_MSG_DEBUG ("(TagAndProbe) Electron Pair mass: " << tpPairMass << ". Min: "<< m_minZeeMassTP*GeV << ". Max: " << m_maxZeeMassTP*GeV);
      if (!((tpPairMass > m_minZeeMassTP*GeV) && (tpPairMass < m_maxZeeMassTP*GeV))){
        ATH_MSG_DEBUG ("(TagAndProbe) Electron pair not in Z mass window.");
        continue;
      }
      else{
        ATH_MSG_INFO ("(TagAndProbe) Electron-positron pair are in Z mass window.");
        // test for goodProbeElectron
        if (!isGoodProbeElectron(elProbe)){
          ATH_MSG_DEBUG (" Probe electron not passed in Goodnes of Probe test.");
          continue;
        }
        ATH_MSG_INFO("(TagAndProbe) Electron is a good probe.");
        ATH_MSG_INFO ("Tag and probe pair found.");
 
        ATH_MSG_INFO ("TAG: pt="<< elTag->pt() << " e="<< elTag->e());
        ATH_MSG_INFO ("PRO: pt="<< elProbe->pt() << " e="<< elProbe->e());
        ATH_MSG_INFO ("Zee: M="<< tpPairMass << " E="<< (el1 + el2).E());
        m_zee_M->push_back((el1 + el2).M());
        m_zee_E->push_back((el1 + el2).E());
        m_zee_pt->push_back((el1 + el2).Pt());
        m_zee_px->push_back((el1 + el2).Px());
        m_zee_py->push_back((el1 + el2).Py());
        m_zee_pz->push_back((el1 + el2).Pz());
        m_zee_T->push_back((el1 + el2).T());
        m_zee_deltaR->push_back(el1.DeltaR(el2));
 
        // ****************************************************************
        // store electrons in a container to dump their clusters and cells.
        TagAndProbeElectronSelectionCnt->push_back( (elTag) );
        // ****************************************************************
      }      
    } //end-loop probe electrons    
  } //end-loop tag electrons
 
  ATH_CHECK (evtStore()->record( TagAndProbeElectronSelectionCnt.release(), "MyTagAndProbeElectrons"));
  return StatusCode::SUCCESS;
}

eOverPElectron()

bool EventReaderBaseAlg::eOverPElectron ( const xAOD::Electron *  electron )

protectedinherited

Definition at line 31 of file EventReaderBaseAlg.cxx.

                                                                   {
  // the E/p is calculated here based on Electron caloCluster and its associated trackParticle
  // E_cluster/p_track
  float eoverp = 0.;
  float track_p = (electron->trackParticle())->pt()*std::cosh((electron->trackParticle())->eta());
  if (track_p != 0.) eoverp = (electron->caloCluster())->e()/track_p;
  else{
    ATH_MSG_WARNING ("(eOverP) Track_p == 0");
    return false;
  }
  if ((fabs(eoverp) < 0.7) || (fabs(eoverp) > 1.5) ){
    ATH_MSG_DEBUG ("(eOverP) E/p is out of range! (eoverp="<<eoverp<<").");
    return false;
  }
  else{
    ATH_MSG_DEBUG ("(eOverP) Passed: E/p="<<eoverp);
    return true;
  }
}

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 EventReaderAlg::execute ( )

overridevirtual

Reimplemented from EventReaderBaseAlg.

Definition at line 110 of file EventReaderAlg.cxx.

                                  {  
  ATH_MSG_DEBUG ("Executing " << name() << "...");
  ATH_MSG_DEBUG("Cleanning of event variables...");
  const EventContext& ctx = getContext();
  clear();  // clear all variables selected to dump to the output NTuple.
 
  // Conditions
  if (!m_isMC){
  
    if (!m_EneRescalerFldr.empty()){
      SG::ReadCondHandle<AthenaAttributeList> EneRescalerHdl  (m_EneRescalerFldr,ctx);
      const coral::Blob& blob = (**EneRescalerHdl)["CaloCondBlob16M"].data<coral::Blob>();
      if (blob.size()<3)  ATH_MSG_WARNING("Found empty blob, no correction needed");
      m_EneRescaler = CaloCondBlobFlt::getInstance(blob); // offline egamma cell correction (due from 5 to 4 downsampling rate)
      ATH_MSG_DEBUG("offlineEnergyRescaler is set!");
    }
 
    if (!m_run2DSPThresholdsKey.empty()) {
      SG::ReadCondHandle<AthenaAttributeList> dspThrshAttrHdl (m_run2DSPThresholdsKey,ctx);
      m_run2DSPThresh   = std::unique_ptr<LArDSPThresholdsFlat>(new LArDSPThresholdsFlat(*dspThrshAttrHdl));
      ATH_MSG_DEBUG("DSPThreshold has set!");
    }
 
    if (!m_lumiDataKey.empty()){
      SG::ReadCondHandle<LuminosityCondData>  lumiHdl  (m_lumiDataKey,ctx);
      m_lumis =*lumiHdl;
      ATH_MSG_DEBUG("LuminosityCondData is set!");
    }
 
    if (!m_offlineHVScaleCorrKey.empty()){
      SG::ReadCondHandle<LArHVCorr>  oflHVCorrHdl (m_offlineHVScaleCorrKey,ctx);
      m_oflHVCorr =*oflHVCorrHdl;
      ATH_MSG_DEBUG("OfflineHVCorrection is set!");
    }
  }
  else{
    if (!m_fSamplKey.empty()){ // MC
      SG::ReadCondHandle<ILArfSampl> fSamplHdl (m_fSamplKey,ctx);
      m_fSampl = *fSamplHdl;
      ATH_MSG_DEBUG("SamplingFraction is set!");
    }
  }  
 
  SG::ReadCondHandle<LArOnOffIdMapping>     larCablingHdl       (m_larCablingKey,ctx);
  SG::ReadCondHandle<CaloNoise>             noiseHdl            (m_noiseCDOKey,ctx);
  SG::ReadCondHandle<ILArPedestal>          pedHdl              (m_pedestalKey,ctx);
  SG::ReadCondHandle<LArADC2MeV>            adc2mevHdl          (m_adc2MeVKey,ctx);
  SG::ReadCondHandle<ILArOFC>               ofcHdl              (m_ofcKey,ctx);
  SG::ReadCondHandle<ILArShape>             shapeHdl            (m_shapeKey,ctx);
  SG::ReadCondHandle<ILArMinBiasAverage>    minBiasAvgHdl       (m_minBiasAvgKey,ctx);
 
  m_larCabling    = *larCablingHdl;
  m_noiseCDO      = *noiseHdl;
  m_peds          = *pedHdl;
  m_adc2MeVs      = *adc2mevHdl;
  m_ofcs          = *ofcHdl;
  m_shapes        = *shapeHdl;
  m_minBiasAvgs   = *minBiasAvgHdl;
 
  SG::ReadHandle<xAOD::EventInfo> ei = SG::makeHandle(m_eventInfoSgKey,ctx);
  if (!ei.isValid()) ATH_MSG_ERROR(" EventInfo container is not valid!");
 
  if (ei->errorState(xAOD::EventInfo::LAr) == xAOD::EventInfo::Error) {
    ATH_MSG_WARNING("Event not passing LAr! Skipping event.");
    return StatusCode::SUCCESS;
  }
 
  SG::ReadHandle<xAOD::VertexContainer> primVertexCnt = SG::makeHandle(m_primVertSgKey,ctx);
  if (!primVertexCnt.isValid()) ATH_MSG_ERROR(" Primary Vertex container is not valid!");  
 
  // *** Lumiblock data ***
  //    Verify if ei->lumiBlock() was dumped into lb_lumiblock. if not, add it.
  //     Each LB entry should be dumped just once, since their content doesnt change per event.
  if (std::count(m_lb_lumiblock->begin(), m_lb_lumiblock->end(), ei->lumiBlock()) == 0){
    if(!dumpLumiblockInfo(ei)) ATH_MSG_INFO("Lumiblock information cannot be collected!");
  }
 
  // EventInfo
  if(!dumpEventInfo(ei)) ATH_MSG_INFO("Event information cannot be collected!");
 
  // Clusters
  if (m_doClusterDump){
 
    SG::ReadHandle<xAOD::CaloClusterContainer> cls = SG::makeHandle(m_caloClusSgKey,ctx);
 
    if(!cls.isValid()){
      ATH_MSG_ERROR("CaloCluster container is not valid!");
      return StatusCode::FAILURE;
    } 
 
    for (const xAOD::CaloCluster *cl : *cls){
      ATH_MSG_DEBUG ("Cluster "<< m_c_clusterIndexCounter << ", Total size: " << cl->numberCells() << "/  "<< cl->clusterSize() << ", etaBE: " << cl->etaBE(2) << ", numberCellsInSampling: " << cl->numberCellsInSampling(CaloSampling::EMB2) <<", eta size: " << cl->etasize(CaloSampling::EMB2) << ", phi size: " << cl->phisize(CaloSampling::EMB2) );
 
      if (! dumpClusterCells(cl, m_c_clusterIndexCounter , ctx) )  ATH_MSG_WARNING ("CaloCluster Cells cannot be dumped for Zee.");
 
      (m_c_clusterIndexCounter)++;
    }
  }
 
  // Apply the Zee cut
  if (m_doTagAndProbe && !m_doClusterDump){
 
    if(!dumpZeeCut(ei,primVertexCnt, ctx)) ATH_MSG_DEBUG("Zee cut algorithm cannot be executed!");
 
    std::string eSelectionText = "";
    SG::ReadHandle<xAOD::ElectronContainer> myElectronsSelection;
 
    if (m_doElecSelectByTrackOnly) eSelectionText  = "Number of myElectronsSelection single electrons: ";
    else                           eSelectionText  = "Number of myElectronsSelection tagAndProbe Zee candidates: ";
 
    myElectronsSelection = SG::makeHandle(m_myElecSelectionSgKey,ctx);
    // Optional: Skip empty events.
    if (m_skipEmptyEvents && (myElectronsSelection->size() == 0)){
      ATH_MSG_INFO("This event has no selected electrons! Cleanning event variables and skipping writing to NTuple...");
      clear();  // clear all variables selected to dump to the output NTuple.
      return StatusCode::SUCCESS;
    }
 
    if(!FillNTupleWithSelectedElectrons(ei, primVertexCnt, myElectronsSelection, eSelectionText, ctx)) ATH_MSG_DEBUG("FillNTupleWithElectrons cannot be executed!");
    
    if (m_isMC){
      // Particle Truth
      if (m_doTruthPartDump){
        SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleCnt = SG::makeHandle(m_truthParticleCntSgKey,ctx);
        if (!truthParticleCnt.isValid()) ATH_MSG_ERROR("TruthParticleContainer is not valid!");
 
        if(!dumpTruthParticle(myElectronsSelection, truthParticleCnt)) ATH_MSG_DEBUG("Truth Particle information cannot be collected!");
      }
    }
  } // end if-start TagAndProbe chain
  
  m_Tree->Fill();
  
  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();
}

FillNTupleWithSelectedElectrons()

StatusCode EventReaderAlg::FillNTupleWithSelectedElectrons ( SG::ReadHandle< xAOD::EventInfo > &  ei, SG::ReadHandle< xAOD::VertexContainer > &  primVertexCnt, SG::ReadHandle< xAOD::ElectronContainer > &  electronSelectionCnt, std::string &  eSelectionText, const EventContext &  ctx  )

privatevirtual

Definition at line 246 of file EventReaderAlg.cxx.

                                                                                                                                                                                                                                                 {
 
  ATH_MSG_INFO(eSelectionText << elContainer->size() );
 
  int electronIndex = 0;
  for (const xAOD::Electron *elec : *elContainer){
 
    const auto& clusLinks = elec->caloClusterLinks(); // get the cluster links for the electron
    
    // loop over clusters and dump cells
    for (const auto& clusLink : clusLinks){
 
      // get associated topoclusters from superclusters        
      if (m_getAssociatedTopoCluster){
        auto assocCls = xAOD::EgammaHelpers::getAssociatedTopoClusters( (*clusLink) );
 
        for ( auto assocCl : assocCls){
          ATH_MSG_DEBUG ("AssociatedTopoCluster " << m_c_clusterIndexCounter << ": e: "<< assocCl->e() << ", eta: " << assocCl->eta() << ", phi: " << assocCl->phi() <<". Total size: " << assocCl->numberCells() << "/  "<< assocCl->clusterSize() << ", etaBE: " << assocCl->etaBE(2) << ", numberCellsInSampling: " << assocCl->numberCellsInSampling(CaloSampling::EMB2) <<", eta size: " << assocCl->etasize(CaloSampling::EMB2) << ", phi size: " << assocCl->phisize(CaloSampling::EMB2) );
          if (! dumpClusterCells(assocCl, m_c_clusterIndexCounter, ctx ) )  ATH_MSG_WARNING ("CaloCluster Cells cannot be dumped for Zee.");
          
          m_c_clusterIndexCounter++;
        }
      }
      else{ // dump only the superclusters
        if (! dumpClusterCells((*clusLink), m_c_clusterIndexCounter, ctx ) )  ATH_MSG_WARNING ("CaloCluster Cells cannot be dumped for Zee.");
        m_c_clusterIndexCounter++;
      }
      m_c_electronIndex_clusterLvl->push_back(electronIndex); // electron indexes for each cluster
    } //end-for loop in clusLinks
 
    // dump tag and probe electrons
    if (!dumpElectrons(elec)) ATH_MSG_WARNING ("Cannot dump ordinary electrons...");
    if (!dumpOfflineSS(elec)) ATH_MSG_WARNING ("Cannot dump offline shower shapes for electrons...");
    if (!dumpPrimVertexAssocToElectron(elec, primVertexCnt, ei)) ATH_MSG_WARNING ("Cannot dump primary vertexes info associated to electrons...");
    m_el_index->push_back(electronIndex);
 
    electronIndex++;
 
  } // end-for loop in m_electronsSelectedByTrack electrons
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode EventReaderAlg::finalize ( )

overridevirtual

Reimplemented from EventReaderBaseAlg.

Definition at line 990 of file EventReaderAlg.cxx.

                                    {
  ATH_MSG_DEBUG ("Finalizing " << name() << "...");
  m_secondTree->Fill();
 
  return StatusCode::SUCCESS;
}

fixPhi()

double EventReaderBaseAlg::fixPhi ( double  phi )

protectedinherited

Definition at line 217 of file EventReaderBaseAlg.cxx.

                                           {
  // Verify the phi value, if its in -pi,pi interval, then shifts 2pi in the correct direction.
  if (phi < -1*pi) return (phi + 2*pi);
  if (phi >  1*pi) return (phi - 2*pi);
  return phi;
}

getCaloRegionIndex()

int EventReaderBaseAlg::getCaloRegionIndex ( const CaloCell *  cell )

protectedinherited

Definition at line 205 of file EventReaderBaseAlg.cxx.

                                                              {
  if (cell->caloDDE()->is_tile()) return 0; //belongs to Tile
  else if (cell->caloDDE()->is_lar_em_barrel()) return 1; //belongs to EM barrel
  else if (cell->caloDDE()->is_lar_em_endcap_inner()) return 2; //belongs to the inner wheel of EM end cap
  else if (cell->caloDDE()->is_lar_em_endcap_outer()) return 3; //belongs to the outer wheel of EM end cap
  else if (cell->caloDDE()->is_lar_hec()) return 4; //belongs to HEC
  else if (cell->caloDDE()->is_lar_fcal()) return 5; //belongs to FCAL
    
  ATH_MSG_ERROR (" #### Region not found for cell offline ID "<< cell->ID() <<" ! Returning -999.");
  return -999; //region not found
}

initialize()

StatusCode EventReaderAlg::initialize ( )

overridevirtual

Reimplemented from EventReaderBaseAlg.

Definition at line 34 of file EventReaderAlg.cxx.

                                      {
  ATH_MSG_INFO ("Initializing " << name() << "...");
  ATH_MSG_INFO ("(EventReader) Initializing conditions...");
 
  // Conditions  
  ATH_CHECK(m_run2DSPThresholdsKey.initialize(!m_isMC));
  ATH_CHECK(m_EneRescalerFldr.initialize(!m_isMC));
  ATH_CHECK(m_noiseCDOKey.initialize());  //---- retrieve the noise CDO
  ATH_CHECK(m_lumiDataKey.initialize() );
  ATH_CHECK(m_pedestalKey.initialize());     
  ATH_CHECK(m_adc2MeVKey.initialize());  
  ATH_CHECK(m_ofcKey.initialize());  
  ATH_CHECK(m_shapeKey.initialize());
  ATH_CHECK(m_minBiasAvgKey.initialize());
  ATH_CHECK(m_fSamplKey.initialize());
  ATH_CHECK(m_offlineHVScaleCorrKey.initialize());
  ATH_MSG_DEBUG(" (EventReader) Condition Keys initialized!");
 
  // Containers
  ATH_CHECK(m_eventInfoSgKey.initialize());
  ATH_CHECK(m_primVertSgKey.initialize());
  ATH_CHECK(m_caloClusSgKey.initialize());
  ATH_CHECK(m_myElecSelectionSgKey.initialize());
  ATH_CHECK(m_truthParticleCntSgKey.initialize());
  ATH_CHECK(m_electronCntSgKey.initialize());
  ATH_CHECK(m_truthEventCntSgKey.initialize());
  ATH_CHECK(m_larEMBHitCntSgKey.initialize());
  ATH_CHECK(m_larDigitCntSgKey.initialize());
  ATH_CHECK(m_larRawChCntSgKey.initialize());
  ATH_CHECK(m_allCaloCellCntSgKey.initialize());
  ATH_MSG_DEBUG(" (EventReader) Container Keys initialized!");
 
  // -- Retrieve ID Helpers --
  ATH_CHECK( detStore()->retrieve(m_onlineLArID, "LArOnlineID") ); // get online ID info from LAr (online)  
  ATH_CHECK( detStore()->retrieve (m_calocell_id, "CaloCell_ID") );
  ATH_CHECK( m_larCablingKey.initialize());
 
  StatusCode sc = detStore()->retrieve(m_caloIdMgr);
  if (sc.isFailure()) {
    ATH_MSG_ERROR(" Unable to retrieve CaloIdManager from DetectoreStore");
    return StatusCode::FAILURE;
  }
  else{
    m_larem_id   = m_caloIdMgr->getEM_ID();
    m_larhec_id  = m_caloIdMgr->getHEC_ID();
    m_larfcal_id = m_caloIdMgr->getFCAL_ID();
  }
  // -------------------------
  
  // Book the variables to save in the *.root 
  m_Tree        = new TTree("dumpedData", "dumpedData");
  m_secondTree  = new TTree("lumiblockData", "lumiblockData");
 
  ATH_MSG_DEBUG("Booking branches...");
  bookBranches(m_Tree); // book TTree with branches
  bookDatabaseBranches(m_secondTree);
 
  if (!m_ntsvc->regTree("/rec/tree1", m_Tree).isSuccess()) {
      ATH_MSG_ERROR("could not register tree [dumpedData]");
      return StatusCode::FAILURE;
    }
  if (!m_ntsvc->regTree("/rec/tree2", m_secondTree).isSuccess()) {
      ATH_MSG_ERROR("could not register tree [database]");
      return StatusCode::FAILURE;
    }
 
  if      (m_doTagAndProbe && m_doElecSelectByTrackOnly)  ATH_MSG_INFO("Entering single_e mode...");
  else if (m_doTagAndProbe && !m_doElecSelectByTrackOnly) ATH_MSG_INFO("Entering Zee T&P mode...");
  else {
    ATH_MSG_ERROR("No valid electron chain selected!");
    return StatusCode::FAILURE;
  }
 
  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.

isEtaOutsideLArCrack()

bool EventReaderBaseAlg::isEtaOutsideLArCrack ( float  absEta )

protectedinherited

Definition at line 196 of file EventReaderBaseAlg.cxx.

                                                         {
  if ( (absEta > 1.37 && absEta < 1.52) || (absEta > 2.47) ){
    return false;
  }
  else{
    return true;
  }  
}

isGoodProbeElectron()

bool EventReaderBaseAlg::isGoodProbeElectron ( const xAOD::Electron *  el )

protectedinherited

Definition at line 157 of file EventReaderBaseAlg.cxx.

                                                                  {
  // |eta| < 1.475
  if ( fabs(el->eta()) > 1.475 ){ // EM Barrel
    ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron |eta| > 1.475 (" << fabs(el->eta()) << ").");
    return false;
  }
 
  // electron object quality
  ATH_MSG_DEBUG (" (isGoodProbeElectron) Checking Probe electron object quality...");
  if ( !el->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)){
    ATH_MSG_DEBUG (" (isGoodProbeElectron) \tProbe Electron is a BADCLUSELECTRON.");
    return false;
  }
 
  // Et > 15 GeV
  float electronPt = el->pt();
  if (electronPt * GeV < m_etMinProbe ){
    ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Et/pT < " << m_etMinProbe << " GeV (pT="<< electronPt * GeV<<")");
    return false;
  }
 
  // is outside the crack
  float absEta = fabs(el->caloCluster()->etaBE(2));
  if ( !isEtaOutsideLArCrack(absEta) ){
    ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Eta inside LAr crack region...");
    return false;
  }
 
  // loose ID Cut
  bool isGood;
  if (! el->passSelection(isGood, m_offProbeTightness)){
    ATH_MSG_DEBUG("(isGoodProbeElectron) Misconfiguration: " << m_offProbeTightness << " is not a valid working point for electrons");
    return false;
  }
 
  ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron is a good probe!");
  return true;
}

isTagElectron()

bool EventReaderBaseAlg::isTagElectron ( const xAOD::Electron *  electron )

protectedinherited

Definition at line 116 of file EventReaderBaseAlg.cxx.

                                                            {
  // |eta| < 1.475
  if ( fabs(el->eta()) > 1.475 ){ // EM Barrel
    ATH_MSG_DEBUG ("(isTagElectron) Electron |eta| > 1.475 (" << fabs(el->eta()) << ").");
    return false;
  }
 
  // LAr crack region
  // ATH_MSG_DEBUG ("(isTagElectron) Selecting Tag Electron Eta outside crack region...");
  float absEta = fabs(el->caloCluster()->etaBE(2));
  if ( !isEtaOutsideLArCrack(absEta) ){
    ATH_MSG_DEBUG ("(isTagElectron) Selecting Tag Electron Eta is inside crack region.");
    return false;
  }
 
  // Tag electron PID verify if is tight
  bool isGood;
  if (! el->passSelection(isGood, m_offTagTightness) ) {
    ATH_MSG_DEBUG("(isTagElectron) Misconfiguration: " << m_offTagTightness << " is not a valid working point for electrons");
    return false; // no point in continuing
    }
  ATH_MSG_DEBUG("(isTagElectron) Trigger " << m_offTagTightness << " is OK");
 
  // Et > 25 (or 15) GeV && Et < 180
  float elTagEt = el->e()/(cosh(el->trackParticle()->eta()));
  float elTagPt = el->pt();
  if ( elTagPt < (m_etMinTag * GeV) ){
    ATH_MSG_DEBUG ("(isTagElectron) Tag Electron Et/pT: "<< elTagEt << "/"<< elTagPt << ", threshold =" << m_etMinTag * GeV << ".");
    return false;
  }
 
  // electron object quality
  ATH_MSG_DEBUG ("(isTagElectron) Checking electron object quality...");
  if ( !el->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)){
    ATH_MSG_DEBUG ("(isTagElectron) \tTag Electron is a BADCLUSELECTRON.");
    return false;
  }
 
  return true;
}

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.

trackSelectionElectrons()

bool EventReaderBaseAlg::trackSelectionElectrons ( const xAOD::Electron *  electron, SG::ReadHandle< xAOD::VertexContainer > &  primVertexCnt, SG::ReadHandle< xAOD::EventInfo > &  ei  )

protectedinherited

Definition at line 52 of file EventReaderBaseAlg.cxx.

                                                                                                                                                               {
  
  const xAOD::TrackParticle *trackElectron =  electron->trackParticle();
  const xAOD::CaloCluster *elClus = electron->caloCluster();
 
  if (!trackElectron) { //is there track?
    ATH_MSG_DEBUG ("(trackSelectionElectrons) No track particle for Tag check."); 
    return false;
  }
  // caloCluster  
  if (!elClus){ //is there a calo cluster associated to this electron?
    ATH_MSG_DEBUG ("(trackSelectionElectrons) No caloCluster associated for Tag check.");
    return false;
  }
 
  // track_pt > 7 GeV
  if (! ( (trackElectron->pt() * GeV ) > 7) ){
    ATH_MSG_DEBUG ("(trackSelectionElectrons) Pt_Track of the electron is below 7 GeV. Electron rejected.");
    return false;
  }
  // |eta| < 2.47
  if (! (fabs(trackElectron->eta()) < 2.47 )){
    ATH_MSG_DEBUG ("(trackSelectionElectrons) Electron track_eta is above 2.47. Electron rejected.");
    return false;
  }
 
  // check for primary vertex in the event
  // *************** Primary vertex check ***************
  //loop over vertices and look for good primary vertex
  bool  isPrimVtx      = false;
  bool  passDeltaZ0sin = false;
  // for (xAOD::VertexContainer::const_iterator vxIter = primVertexCnt->begin(); vxIter != primVertexCnt->end(); ++vxIter) {
  for ( const xAOD::Vertex *vertex : *primVertexCnt){
    // Select good primary vertex          
    float delta_z0      = fabs(trackElectron->z0() + trackElectron->vz() - vertex->z()); //where trk.vz() represents the point of reference for the z0 calculation (in this case, the beamspot position along the z axis).
    float delta_z0_sin  = delta_z0 * sin(trackElectron->theta()); //where sin(trk.theta()) parameterises the uncertainty of the z0 measurement. 
 
    if ((vertex->vertexType() == xAOD::VxType::PriVtx) && ( delta_z0_sin < m_z0Tag)){
      isPrimVtx       = true; //check for primary vertex in each vertex of the event.
      passDeltaZ0sin  = true; // and check if the longitudinal impact parameter difference for electron-to-vertex association.
 
      ATH_MSG_DEBUG ("(trackSelectionElectrons) delta_z0_sin < 0.5 mm ("<< delta_z0_sin << ")");
      ATH_MSG_DEBUG ("(trackSelectionElectrons) There is a primary vertex in the event.");
      break;
    }
  }
 
  // delta_z0_sin <= 0.5 mm
  if (!( isPrimVtx && passDeltaZ0sin)){
    ATH_MSG_DEBUG ("(trackSelectionElectrons) For this Tag, delta_z0_sin > 0.5mm, and there is NO primary vertices in the event. Rejecting electron.");
    return false;
  }  
  
  // d0_sig - transverse impact parameter significance
  double d0sig = fabs (xAOD::TrackingHelpers::d0significance( trackElectron, ei->beamPosSigmaX(), ei->beamPosSigmaY(), ei->beamPosSigmaXY() )); 
  if ( !( d0sig < m_d0TagSig)){
    ATH_MSG_DEBUG("(trackSelectionElectrons) Electron rejected. |d0sig| > " << m_d0TagSig << " ("<< d0sig <<")");
    return false;
  }
 
  ATH_MSG_DEBUG("(trackSelectionElectrons) Electron accepted.");
  return true; // if true, add electron to electronSelectionCnt 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_adc2MeVKey

SG::ReadCondHandleKey<LArADC2MeV> EventReaderAlg::m_adc2MeVKey {this,"ADC2MeVKey","LArADC2MeV","SG Key of ADC2MeV conditions object"}

private

Definition at line 86 of file EventReaderAlg.h.

m_adc2MeVs

const LArADC2MeV* EventReaderAlg::m_adc2MeVs = nullptr

private

Definition at line 111 of file EventReaderAlg.h.

m_allCaloCellCntSgKey

SG::ReadHandleKey<CaloCellContainer> EventReaderAlg::m_allCaloCellCntSgKey {this, "CaloCellContainerKey", "AllCalo", "Name of the CaloCell container"}

private

Definition at line 104 of file EventReaderAlg.h.

m_c711_cellDEta

std::vector< double >* EventReaderBaseAlg::m_c711_cellDEta = nullptr

protectedinherited

Definition at line 191 of file EventReaderBaseAlg.h.

m_c711_cellDPhi

std::vector< double >* EventReaderBaseAlg::m_c711_cellDPhi = nullptr

protectedinherited

Definition at line 192 of file EventReaderBaseAlg.h.

m_c711_cellEnergy

std::vector< double >* EventReaderBaseAlg::m_c711_cellEnergy = nullptr

protectedinherited

Definition at line 187 of file EventReaderBaseAlg.h.

m_c711_cellEta

std::vector< double >* EventReaderBaseAlg::m_c711_cellEta = nullptr

protectedinherited

Definition at line 189 of file EventReaderBaseAlg.h.

m_c711_cellGain

std::vector< int >* EventReaderBaseAlg::m_c711_cellGain = nullptr

protectedinherited

Definition at line 184 of file EventReaderBaseAlg.h.

m_c711_cellIndexCounter

int* EventReaderBaseAlg::m_c711_cellIndexCounter = nullptr

protectedinherited

Definition at line 181 of file EventReaderBaseAlg.h.

m_c711_cellLayer

std::vector< int >* EventReaderBaseAlg::m_c711_cellLayer = nullptr

protectedinherited

Definition at line 185 of file EventReaderBaseAlg.h.

m_c711_cellPhi

std::vector< double >* EventReaderBaseAlg::m_c711_cellPhi = nullptr

protectedinherited

Definition at line 190 of file EventReaderBaseAlg.h.

m_c711_cellRegion

std::vector< int >* EventReaderBaseAlg::m_c711_cellRegion = nullptr

protectedinherited

Definition at line 186 of file EventReaderBaseAlg.h.

m_c711_cellTime

std::vector< double >* EventReaderBaseAlg::m_c711_cellTime = nullptr

protectedinherited

Definition at line 188 of file EventReaderBaseAlg.h.

m_c711_cellToClusterDEta

std::vector< double >* EventReaderBaseAlg::m_c711_cellToClusterDEta = nullptr

protectedinherited

Definition at line 194 of file EventReaderBaseAlg.h.

m_c711_cellToClusterDPhi

std::vector< double >* EventReaderBaseAlg::m_c711_cellToClusterDPhi = nullptr

protectedinherited

Definition at line 193 of file EventReaderBaseAlg.h.

m_c711_channelADC2MEV0

std::vector< float >* EventReaderBaseAlg::m_c711_channelADC2MEV0 = nullptr

protectedinherited

Definition at line 214 of file EventReaderBaseAlg.h.

m_c711_channelADC2MEV1

std::vector< float >* EventReaderBaseAlg::m_c711_channelADC2MEV1 = nullptr

protectedinherited

Definition at line 215 of file EventReaderBaseAlg.h.

m_c711_channelBad

std::vector< bool >* EventReaderBaseAlg::m_c711_channelBad = nullptr

protectedinherited

Definition at line 203 of file EventReaderBaseAlg.h.

m_c711_channelChannelIdMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c711_channelChannelIdMap = nullptr

protectedinherited

Definition at line 205 of file EventReaderBaseAlg.h.

m_c711_channelChInfo

std::vector< std::vector < int > >* EventReaderBaseAlg::m_c711_channelChInfo = nullptr

protectedinherited

Definition at line 198 of file EventReaderBaseAlg.h.

m_c711_channelDigits

std::vector< std::vector < float > >* EventReaderBaseAlg::m_c711_channelDigits = nullptr

protectedinherited

Definition at line 199 of file EventReaderBaseAlg.h.

m_c711_channelDSPThreshold

std::vector< float >* EventReaderBaseAlg::m_c711_channelDSPThreshold = nullptr

protectedinherited

Definition at line 208 of file EventReaderBaseAlg.h.

m_c711_channelEffectiveSigma

std::vector< float >* EventReaderBaseAlg::m_c711_channelEffectiveSigma = nullptr

protectedinherited

Definition at line 206 of file EventReaderBaseAlg.h.

m_c711_channelEnergy

std::vector< double >* EventReaderBaseAlg::m_c711_channelEnergy = nullptr

protectedinherited

Definition at line 200 of file EventReaderBaseAlg.h.

m_c711_channelHashMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c711_channelHashMap = nullptr

protectedinherited

Definition at line 204 of file EventReaderBaseAlg.h.

m_c711_channelLayer

std::vector< int >* EventReaderBaseAlg::m_c711_channelLayer = nullptr

protectedinherited

Definition at line 202 of file EventReaderBaseAlg.h.

m_c711_channelMinBiasAvg

std::vector< float >* EventReaderBaseAlg::m_c711_channelMinBiasAvg = nullptr

protectedinherited

Definition at line 217 of file EventReaderBaseAlg.h.

m_c711_channelNoise

std::vector< float >* EventReaderBaseAlg::m_c711_channelNoise = nullptr

protectedinherited

Definition at line 207 of file EventReaderBaseAlg.h.

m_c711_channelOFCa

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c711_channelOFCa = nullptr

protectedinherited

Definition at line 209 of file EventReaderBaseAlg.h.

m_c711_channelOFCb

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c711_channelOFCb = nullptr

protectedinherited

Definition at line 210 of file EventReaderBaseAlg.h.

m_c711_channelOFCTimeOffset

std::vector< double >* EventReaderBaseAlg::m_c711_channelOFCTimeOffset = nullptr

protectedinherited

Definition at line 213 of file EventReaderBaseAlg.h.

m_c711_channelOfflEneRescaler

std::vector< float >* EventReaderBaseAlg::m_c711_channelOfflEneRescaler = nullptr

protectedinherited

Definition at line 219 of file EventReaderBaseAlg.h.

m_c711_channelOfflHVScale

std::vector< float >* EventReaderBaseAlg::m_c711_channelOfflHVScale = nullptr

protectedinherited

Definition at line 218 of file EventReaderBaseAlg.h.

m_c711_channelPed

std::vector< float >* EventReaderBaseAlg::m_c711_channelPed = nullptr

protectedinherited

Definition at line 216 of file EventReaderBaseAlg.h.

m_c711_channelShape

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c711_channelShape = nullptr

protectedinherited

Definition at line 211 of file EventReaderBaseAlg.h.

m_c711_channelShapeDer

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c711_channelShapeDer = nullptr

protectedinherited

Definition at line 212 of file EventReaderBaseAlg.h.

m_c711_channelTime

std::vector< double >* EventReaderBaseAlg::m_c711_channelTime = nullptr

protectedinherited

Definition at line 201 of file EventReaderBaseAlg.h.

m_c711_clusterCellIndex

std::vector< int >* EventReaderBaseAlg::m_c711_clusterCellIndex = nullptr

protectedinherited

Definition at line 183 of file EventReaderBaseAlg.h.

m_c711_clusterChannelIndex

std::vector< int >* EventReaderBaseAlg::m_c711_clusterChannelIndex = nullptr

protectedinherited

Definition at line 197 of file EventReaderBaseAlg.h.

m_c711_clusterEnergy

std::vector< double >* EventReaderBaseAlg::m_c711_clusterEnergy = nullptr

protectedinherited

Definition at line 174 of file EventReaderBaseAlg.h.

m_c711_clusterEta

std::vector< double >* EventReaderBaseAlg::m_c711_clusterEta = nullptr

protectedinherited

Definition at line 176 of file EventReaderBaseAlg.h.

m_c711_clusterIndex

std::vector< int >* EventReaderBaseAlg::m_c711_clusterIndex = nullptr

protectedinherited

Definition at line 172 of file EventReaderBaseAlg.h.

m_c711_clusterIndex_cellLvl

std::vector< int >* EventReaderBaseAlg::m_c711_clusterIndex_cellLvl = nullptr

protectedinherited

Definition at line 182 of file EventReaderBaseAlg.h.

m_c711_clusterIndex_chLvl

std::vector< int >* EventReaderBaseAlg::m_c711_clusterIndex_chLvl = nullptr

protectedinherited

Definition at line 196 of file EventReaderBaseAlg.h.

m_c711_clusterIndex_rawChLvl

std::vector< int >* EventReaderBaseAlg::m_c711_clusterIndex_rawChLvl = nullptr

protectedinherited

Definition at line 230 of file EventReaderBaseAlg.h.

m_c711_clusterIndexCounter

int* EventReaderBaseAlg::m_c711_clusterIndexCounter = 0

protectedinherited

Definition at line 171 of file EventReaderBaseAlg.h.

m_c711_clusterPhi

std::vector< double >* EventReaderBaseAlg::m_c711_clusterPhi = nullptr

protectedinherited

Definition at line 177 of file EventReaderBaseAlg.h.

m_c711_clusterPt

std::vector< double >* EventReaderBaseAlg::m_c711_clusterPt = nullptr

protectedinherited

Definition at line 178 of file EventReaderBaseAlg.h.

m_c711_clusterRawChannelIndex

std::vector< float >* EventReaderBaseAlg::m_c711_clusterRawChannelIndex = nullptr

protectedinherited

Definition at line 229 of file EventReaderBaseAlg.h.

m_c711_clusterTime

std::vector< double >* EventReaderBaseAlg::m_c711_clusterTime = nullptr

protectedinherited

Definition at line 175 of file EventReaderBaseAlg.h.

m_c711_electronIndex_clusterLvl

std::vector< int >* EventReaderBaseAlg::m_c711_electronIndex_clusterLvl = nullptr

protectedinherited

Definition at line 173 of file EventReaderBaseAlg.h.

m_c711_rawChannelAmplitude

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelAmplitude = nullptr

protectedinherited

Definition at line 223 of file EventReaderBaseAlg.h.

m_c711_rawChannelChInfo

std::vector< std::vector < int > >* EventReaderBaseAlg::m_c711_rawChannelChInfo = nullptr

protectedinherited

Definition at line 221 of file EventReaderBaseAlg.h.

m_c711_rawChannelDSPThreshold

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelDSPThreshold = nullptr

protectedinherited

Definition at line 231 of file EventReaderBaseAlg.h.

m_c711_rawChannelIdMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c711_rawChannelIdMap = nullptr

protectedinherited

Definition at line 222 of file EventReaderBaseAlg.h.

m_c711_rawChannelLayer

std::vector< int >* EventReaderBaseAlg::m_c711_rawChannelLayer = nullptr

protectedinherited

Definition at line 225 of file EventReaderBaseAlg.h.

m_c711_rawChannelPed

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelPed = nullptr

protectedinherited

Definition at line 226 of file EventReaderBaseAlg.h.

m_c711_rawChannelProv

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelProv = nullptr

protectedinherited

Definition at line 227 of file EventReaderBaseAlg.h.

m_c711_rawChannelQuality

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelQuality = nullptr

protectedinherited

Definition at line 228 of file EventReaderBaseAlg.h.

m_c711_rawChannelTime

std::vector< float >* EventReaderBaseAlg::m_c711_rawChannelTime = nullptr

protectedinherited

Definition at line 224 of file EventReaderBaseAlg.h.

m_c_cellDEta

std::vector< double >* EventReaderBaseAlg::m_c_cellDEta = nullptr

protectedinherited

Definition at line 112 of file EventReaderBaseAlg.h.

m_c_cellDPhi

std::vector< double >* EventReaderBaseAlg::m_c_cellDPhi = nullptr

protectedinherited

Definition at line 113 of file EventReaderBaseAlg.h.

m_c_cellEnergy

std::vector< double >* EventReaderBaseAlg::m_c_cellEnergy = nullptr

protectedinherited

Definition at line 108 of file EventReaderBaseAlg.h.

m_c_cellEta

std::vector< double >* EventReaderBaseAlg::m_c_cellEta = nullptr

protectedinherited

Definition at line 110 of file EventReaderBaseAlg.h.

m_c_cellGain

std::vector< int >* EventReaderBaseAlg::m_c_cellGain = nullptr

protectedinherited

Definition at line 105 of file EventReaderBaseAlg.h.

m_c_cellIndexCounter

int EventReaderBaseAlg::m_c_cellIndexCounter = 0

protectedinherited

Definition at line 102 of file EventReaderBaseAlg.h.

m_c_cellLayer

std::vector< int >* EventReaderBaseAlg::m_c_cellLayer = nullptr

protectedinherited

Definition at line 106 of file EventReaderBaseAlg.h.

m_c_cellPhi

std::vector< double >* EventReaderBaseAlg::m_c_cellPhi = nullptr

protectedinherited

Definition at line 111 of file EventReaderBaseAlg.h.

m_c_cellRegion

std::vector< int >* EventReaderBaseAlg::m_c_cellRegion = nullptr

protectedinherited

Definition at line 107 of file EventReaderBaseAlg.h.

m_c_cellTime

std::vector< double >* EventReaderBaseAlg::m_c_cellTime = nullptr

protectedinherited

Definition at line 109 of file EventReaderBaseAlg.h.

m_c_cellToClusterDEta

std::vector< double >* EventReaderBaseAlg::m_c_cellToClusterDEta = nullptr

protectedinherited

Definition at line 115 of file EventReaderBaseAlg.h.

m_c_cellToClusterDPhi

std::vector< double >* EventReaderBaseAlg::m_c_cellToClusterDPhi = nullptr

protectedinherited

Definition at line 114 of file EventReaderBaseAlg.h.

m_c_channelADC2MEV0

std::vector< float >* EventReaderBaseAlg::m_c_channelADC2MEV0 = nullptr

protectedinherited

Definition at line 135 of file EventReaderBaseAlg.h.

m_c_channelADC2MEV1

std::vector< float >* EventReaderBaseAlg::m_c_channelADC2MEV1 = nullptr

protectedinherited

Definition at line 136 of file EventReaderBaseAlg.h.

m_c_channelBad

std::vector< bool >* EventReaderBaseAlg::m_c_channelBad = nullptr

protectedinherited

Definition at line 124 of file EventReaderBaseAlg.h.

m_c_channelChannelIdMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c_channelChannelIdMap = nullptr

protectedinherited

Definition at line 126 of file EventReaderBaseAlg.h.

m_c_channelChInfo

std::vector< std::vector < int > >* EventReaderBaseAlg::m_c_channelChInfo = nullptr

protectedinherited

Definition at line 119 of file EventReaderBaseAlg.h.

m_c_channelDigits

std::vector< std::vector < float > >* EventReaderBaseAlg::m_c_channelDigits = nullptr

protectedinherited

Definition at line 120 of file EventReaderBaseAlg.h.

m_c_channelDSPThreshold

std::vector< float >* EventReaderBaseAlg::m_c_channelDSPThreshold = nullptr

protectedinherited

Definition at line 129 of file EventReaderBaseAlg.h.

m_c_channelEffectiveSigma

std::vector< float >* EventReaderBaseAlg::m_c_channelEffectiveSigma = nullptr

protectedinherited

Definition at line 127 of file EventReaderBaseAlg.h.

m_c_channelEnergy

std::vector< double >* EventReaderBaseAlg::m_c_channelEnergy = nullptr

protectedinherited

Definition at line 121 of file EventReaderBaseAlg.h.

m_c_channelHashMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c_channelHashMap = nullptr

protectedinherited

Definition at line 125 of file EventReaderBaseAlg.h.

m_c_channelLayer

std::vector< int >* EventReaderBaseAlg::m_c_channelLayer = nullptr

protectedinherited

Definition at line 123 of file EventReaderBaseAlg.h.

m_c_channelMinBiasAvg

std::vector< float >* EventReaderBaseAlg::m_c_channelMinBiasAvg = nullptr

protectedinherited

Definition at line 138 of file EventReaderBaseAlg.h.

m_c_channelNoise

std::vector< float >* EventReaderBaseAlg::m_c_channelNoise = nullptr

protectedinherited

Definition at line 128 of file EventReaderBaseAlg.h.

m_c_channelOFCa

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c_channelOFCa = nullptr

protectedinherited

Definition at line 130 of file EventReaderBaseAlg.h.

m_c_channelOFCb

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c_channelOFCb = nullptr

protectedinherited

Definition at line 131 of file EventReaderBaseAlg.h.

m_c_channelOFCTimeOffset

std::vector< double >* EventReaderBaseAlg::m_c_channelOFCTimeOffset = nullptr

protectedinherited

Definition at line 134 of file EventReaderBaseAlg.h.

m_c_channelOfflEneRescaler

std::vector< float >* EventReaderBaseAlg::m_c_channelOfflEneRescaler = nullptr

protectedinherited

Definition at line 140 of file EventReaderBaseAlg.h.

m_c_channelOfflHVScale

std::vector< float >* EventReaderBaseAlg::m_c_channelOfflHVScale = nullptr

protectedinherited

Definition at line 139 of file EventReaderBaseAlg.h.

m_c_channelPed

std::vector< float >* EventReaderBaseAlg::m_c_channelPed = nullptr

protectedinherited

Definition at line 137 of file EventReaderBaseAlg.h.

m_c_channelShape

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c_channelShape = nullptr

protectedinherited

Definition at line 132 of file EventReaderBaseAlg.h.

m_c_channelShapeDer

std::vector< std::vector < double > >* EventReaderBaseAlg::m_c_channelShapeDer = nullptr

protectedinherited

Definition at line 133 of file EventReaderBaseAlg.h.

m_c_channelTime

std::vector< double >* EventReaderBaseAlg::m_c_channelTime = nullptr

protectedinherited

Definition at line 122 of file EventReaderBaseAlg.h.

m_c_clusterCellIndex

std::vector< int >* EventReaderBaseAlg::m_c_clusterCellIndex = nullptr

protectedinherited

Definition at line 104 of file EventReaderBaseAlg.h.

m_c_clusterChannelIndex

std::vector< int >* EventReaderBaseAlg::m_c_clusterChannelIndex = nullptr

protectedinherited

Definition at line 118 of file EventReaderBaseAlg.h.

m_c_clusterEnergy

std::vector< double >* EventReaderBaseAlg::m_c_clusterEnergy = nullptr

protectedinherited

Definition at line 96 of file EventReaderBaseAlg.h.

m_c_clusterEta

std::vector< double >* EventReaderBaseAlg::m_c_clusterEta = nullptr

protectedinherited

Definition at line 98 of file EventReaderBaseAlg.h.

m_c_clusterIndex

std::vector< int >* EventReaderBaseAlg::m_c_clusterIndex = nullptr

protectedinherited

Definition at line 94 of file EventReaderBaseAlg.h.

m_c_clusterIndex_cellLvl

std::vector< int >* EventReaderBaseAlg::m_c_clusterIndex_cellLvl = nullptr

protectedinherited

Definition at line 103 of file EventReaderBaseAlg.h.

m_c_clusterIndex_chLvl

std::vector< int >* EventReaderBaseAlg::m_c_clusterIndex_chLvl = nullptr

protectedinherited

Definition at line 117 of file EventReaderBaseAlg.h.

m_c_clusterIndex_rawChLvl

std::vector< int >* EventReaderBaseAlg::m_c_clusterIndex_rawChLvl = nullptr

protectedinherited

Definition at line 152 of file EventReaderBaseAlg.h.

m_c_clusterIndexCounter

int EventReaderBaseAlg::m_c_clusterIndexCounter = 0

protectedinherited

Definition at line 93 of file EventReaderBaseAlg.h.

m_c_clusterPhi

std::vector< double >* EventReaderBaseAlg::m_c_clusterPhi = nullptr

protectedinherited

Definition at line 99 of file EventReaderBaseAlg.h.

m_c_clusterPt

std::vector< double >* EventReaderBaseAlg::m_c_clusterPt = nullptr

protectedinherited

Definition at line 100 of file EventReaderBaseAlg.h.

m_c_clusterRawChannelIndex

std::vector< float >* EventReaderBaseAlg::m_c_clusterRawChannelIndex = nullptr

protectedinherited

Definition at line 151 of file EventReaderBaseAlg.h.

m_c_clusterTime

std::vector< double >* EventReaderBaseAlg::m_c_clusterTime = nullptr

protectedinherited

Definition at line 97 of file EventReaderBaseAlg.h.

m_c_electronIndex_clusterLvl

std::vector< int >* EventReaderBaseAlg::m_c_electronIndex_clusterLvl = nullptr

protectedinherited

Definition at line 95 of file EventReaderBaseAlg.h.

m_c_rawChannelAmplitude

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelAmplitude = nullptr

protectedinherited

Definition at line 145 of file EventReaderBaseAlg.h.

m_c_rawChannelChInfo

std::vector< std::vector < int > >* EventReaderBaseAlg::m_c_rawChannelChInfo = nullptr

protectedinherited

Definition at line 143 of file EventReaderBaseAlg.h.

m_c_rawChannelDSPThreshold

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelDSPThreshold = nullptr

protectedinherited

Definition at line 153 of file EventReaderBaseAlg.h.

m_c_rawChannelIdMap

std::vector< unsigned int >* EventReaderBaseAlg::m_c_rawChannelIdMap = nullptr

protectedinherited

Definition at line 144 of file EventReaderBaseAlg.h.

m_c_rawChannelLayer

std::vector< int >* EventReaderBaseAlg::m_c_rawChannelLayer = nullptr

protectedinherited

Definition at line 147 of file EventReaderBaseAlg.h.

m_c_rawChannelPed

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelPed = nullptr

protectedinherited

Definition at line 148 of file EventReaderBaseAlg.h.

m_c_rawChannelProv

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelProv = nullptr

protectedinherited

Definition at line 149 of file EventReaderBaseAlg.h.

m_c_rawChannelQuality

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelQuality = nullptr

protectedinherited

Definition at line 150 of file EventReaderBaseAlg.h.

m_c_rawChannelTime

std::vector< float >* EventReaderBaseAlg::m_c_rawChannelTime = nullptr

protectedinherited

Definition at line 146 of file EventReaderBaseAlg.h.

m_calocell_id

const CaloCell_ID* EventReaderAlg::m_calocell_id = nullptr

private

Definition at line 126 of file EventReaderAlg.h.

m_caloClusSgKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> EventReaderAlg::m_caloClusSgKey {this, "CaloClusterContainerKey", "CaloCalTopoClusters", "Name of the CaloCluster Container"}

private

Definition at line 96 of file EventReaderAlg.h.

m_caloIdMgr

const CaloIdManager* EventReaderAlg::m_caloIdMgr = nullptr

private

Definition at line 122 of file EventReaderAlg.h.

m_d0TagSig

Gaudi::Property<float> EventReaderBaseAlg::m_d0TagSig {this, "d0TagSig", 5, "d_0 transverse impact parameter significance."}

protectedinherited

Definition at line 56 of file EventReaderBaseAlg.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_doAssocTopoCluster711Dump

Gaudi::Property<bool> EventReaderBaseAlg::m_doAssocTopoCluster711Dump {this, "doAssocTopoCluster711Dump", false, "Dump the 7x11 EMB2 window cells."}

protectedinherited

Definition at line 67 of file EventReaderBaseAlg.h.

m_doClusterDump

Gaudi::Property<bool> EventReaderAlg::m_doClusterDump {this, "doClusterDump", false, "Perform a cluster cell dump based on Cluster Container name m_clusterName"}

private

Definition at line 68 of file EventReaderAlg.h.

m_doElecSelectByTrackOnly

Gaudi::Property<bool> EventReaderBaseAlg::m_doElecSelectByTrackOnly {this, "doElecSelectByTrackOnly", false, "Perform electron selection by track only, witout tag and probe."}

protectedinherited

Definition at line 58 of file EventReaderBaseAlg.h.

m_doLArEMBHitsDump

Gaudi::Property<bool> EventReaderBaseAlg::m_doLArEMBHitsDump {this, "doLArEMBHitsDump", false, "Dump the EMB HITs container energy and time."}

protectedinherited

Definition at line 63 of file EventReaderBaseAlg.h.

m_doPhotonDump

Gaudi::Property<bool> EventReaderBaseAlg::m_doPhotonDump {this, "doPhotonDump", false, "Perform a photon particle dump based on offline Photons Container."}

protectedinherited

Definition at line 60 of file EventReaderBaseAlg.h.

m_doTagAndProbe

Gaudi::Property<bool> EventReaderBaseAlg::m_doTagAndProbe {this, "doTagAndProbe", true, "First, the electrons are selected by track criteria, then, perform Tag and Probe selection for Zee."}

protectedinherited

Definition at line 59 of file EventReaderBaseAlg.h.

m_doTruthEventDump

Gaudi::Property<bool> EventReaderBaseAlg::m_doTruthEventDump {this, "doTruthEventDump", false, "Dump the Truth Event variables."}

protectedinherited

Definition at line 61 of file EventReaderBaseAlg.h.

m_doTruthPartDump

Gaudi::Property<bool> EventReaderBaseAlg::m_doTruthPartDump {this, "doTruthPartDump", false, "Perform a truth particle dump."}

protectedinherited

Definition at line 62 of file EventReaderBaseAlg.h.

m_e_bcid

unsigned int EventReaderBaseAlg::m_e_bcid = 9999

protectedinherited

Definition at line 86 of file EventReaderBaseAlg.h.

m_e_eventNumber

unsigned long long EventReaderBaseAlg::m_e_eventNumber = 9999

protectedinherited

Definition at line 87 of file EventReaderBaseAlg.h.

m_e_inTimePileup

float EventReaderBaseAlg::m_e_inTimePileup = -999

protectedinherited

Definition at line 89 of file EventReaderBaseAlg.h.

m_e_lumiBlock

int EventReaderBaseAlg::m_e_lumiBlock = 999

protectedinherited

Definition at line 88 of file EventReaderBaseAlg.h.

m_e_outOfTimePileUp

float EventReaderBaseAlg::m_e_outOfTimePileUp = -999

protectedinherited

Definition at line 90 of file EventReaderBaseAlg.h.

m_e_runNumber

unsigned int EventReaderBaseAlg::m_e_runNumber = 9999

protectedinherited

Definition at line 85 of file EventReaderBaseAlg.h.

m_el_deltae

std::vector< float >* EventReaderBaseAlg::m_el_deltae = nullptr

protectedinherited

Definition at line 288 of file EventReaderBaseAlg.h.

m_el_e277

std::vector< float >* EventReaderBaseAlg::m_el_e277 = nullptr

protectedinherited

Definition at line 285 of file EventReaderBaseAlg.h.

m_el_eoverp

std::vector< float >* EventReaderBaseAlg::m_el_eoverp = nullptr

protectedinherited

Definition at line 276 of file EventReaderBaseAlg.h.

m_el_eratio

std::vector< float >* EventReaderBaseAlg::m_el_eratio = nullptr

protectedinherited

Definition at line 280 of file EventReaderBaseAlg.h.

m_el_et

std::vector< float >* EventReaderBaseAlg::m_el_et = nullptr

protectedinherited

Definition at line 272 of file EventReaderBaseAlg.h.

m_el_Eta

std::vector< float >* EventReaderBaseAlg::m_el_Eta = nullptr

protectedinherited

Definition at line 273 of file EventReaderBaseAlg.h.

m_el_f1

std::vector< float >* EventReaderBaseAlg::m_el_f1 = nullptr

protectedinherited

Definition at line 278 of file EventReaderBaseAlg.h.

m_el_f3

std::vector< float >* EventReaderBaseAlg::m_el_f3 = nullptr

protectedinherited

Definition at line 279 of file EventReaderBaseAlg.h.

m_el_fracs1

std::vector< float >* EventReaderBaseAlg::m_el_fracs1 = nullptr

protectedinherited

Definition at line 283 of file EventReaderBaseAlg.h.

m_el_index

std::vector< int >* EventReaderBaseAlg::m_el_index = nullptr

protectedinherited

Definition at line 270 of file EventReaderBaseAlg.h.

m_el_m

std::vector< float >* EventReaderBaseAlg::m_el_m = nullptr

protectedinherited

Definition at line 275 of file EventReaderBaseAlg.h.

m_el_Phi

std::vector< float >* EventReaderBaseAlg::m_el_Phi = nullptr

protectedinherited

Definition at line 274 of file EventReaderBaseAlg.h.

m_el_Pt

std::vector< float >* EventReaderBaseAlg::m_el_Pt = nullptr

protectedinherited

Definition at line 271 of file EventReaderBaseAlg.h.

m_el_reta

std::vector< float >* EventReaderBaseAlg::m_el_reta = nullptr

protectedinherited

Definition at line 286 of file EventReaderBaseAlg.h.

m_el_rhad

std::vector< float >* EventReaderBaseAlg::m_el_rhad = nullptr

protectedinherited

Definition at line 289 of file EventReaderBaseAlg.h.

m_el_rhad1

std::vector< float >* EventReaderBaseAlg::m_el_rhad1 = nullptr

protectedinherited

Definition at line 290 of file EventReaderBaseAlg.h.

m_el_rphi

std::vector< float >* EventReaderBaseAlg::m_el_rphi = nullptr

protectedinherited

Definition at line 287 of file EventReaderBaseAlg.h.

m_el_weta1

std::vector< float >* EventReaderBaseAlg::m_el_weta1 = nullptr

protectedinherited

Definition at line 281 of file EventReaderBaseAlg.h.

m_el_weta2

std::vector< float >* EventReaderBaseAlg::m_el_weta2 = nullptr

protectedinherited

Definition at line 282 of file EventReaderBaseAlg.h.

m_el_wtots1

std::vector< float >* EventReaderBaseAlg::m_el_wtots1 = nullptr

protectedinherited

Definition at line 284 of file EventReaderBaseAlg.h.

m_elecEtaCut

Gaudi::Property<float> EventReaderBaseAlg::m_elecEtaCut {this, "electronEtaCut", 1.4, "Electron |eta| cut value."}

protectedinherited

Definition at line 51 of file EventReaderBaseAlg.h.

m_electronCntSgKey

SG::ReadHandleKey<xAOD::ElectronContainer> EventReaderAlg::m_electronCntSgKey {this, "ElectronContainerKey", "Electrons", "Name of the Electrons Container"}

private

Definition at line 99 of file EventReaderAlg.h.

m_EneRescaler

const CaloCondBlobFlt* EventReaderAlg::m_EneRescaler = nullptr

private

Definition at line 116 of file EventReaderAlg.h.

m_EneRescalerFldr

SG::ReadCondHandleKey<AthenaAttributeList> EventReaderAlg::m_EneRescalerFldr {this,"OflEneRescalerKey","/LAR/CellCorrOfl/EnergyCorr", "Key (=foldername) of AttrListCollection"}

private

Definition at line 83 of file EventReaderAlg.h.

m_etMinProbe

Gaudi::Property<float> EventReaderBaseAlg::m_etMinProbe {this, "etMinProbe", 15 ,"Min electron Pt value for Zee probe selection loose (GeV)."}

protectedinherited

define the Pid of Probe from the user

Definition at line 54 of file EventReaderBaseAlg.h.

m_etMinTag

Gaudi::Property<float> EventReaderBaseAlg::m_etMinTag {this, "etMinTag", 15 ,"Min Et value for the electrons in Zee tag selection (GeV)."}

protectedinherited

Definition at line 55 of file EventReaderBaseAlg.h.

m_eventInfoSgKey

SG::ReadHandleKey<xAOD::EventInfo> EventReaderAlg::m_eventInfoSgKey {this, "EventInfoContainerKey", "EventInfo", "Name of the EventInfo Container"}

private

Definition at line 94 of file EventReaderAlg.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_fSampl

const ILArfSampl* EventReaderAlg::m_fSampl = nullptr

private

Definition at line 117 of file EventReaderAlg.h.

m_fSamplKey

SG::ReadCondHandleKey<ILArfSampl> EventReaderAlg::m_fSamplKey {this, "fSamplKey", "LArfSamplSym","SG key of LArfSampl object."}

private

Definition at line 91 of file EventReaderAlg.h.

m_getAssociatedTopoCluster

Gaudi::Property<bool> EventReaderAlg::m_getAssociatedTopoCluster {this, "getAssociatedTopoCluster", true, "Get the topo cluster associated to a super cluster, which was linked to an Electron."}

private

Definition at line 69 of file EventReaderAlg.h.

m_getLArCalibConstants

Gaudi::Property<bool> EventReaderBaseAlg::m_getLArCalibConstants {this, "getLArCalibConstants", false, "Get the LAr calorimeter calibration constants, related to cells energy and time (online and offline)."}

protectedinherited

Definition at line 65 of file EventReaderBaseAlg.h.

m_hits_cellEta

std::vector< double >* EventReaderBaseAlg::m_hits_cellEta = nullptr

protectedinherited

Definition at line 166 of file EventReaderBaseAlg.h.

m_hits_cellPhi

std::vector< double >* EventReaderBaseAlg::m_hits_cellPhi = nullptr

protectedinherited

Definition at line 167 of file EventReaderBaseAlg.h.

m_hits_clusterChannelIndex

std::vector< int >* EventReaderBaseAlg::m_hits_clusterChannelIndex = nullptr

protectedinherited

Definition at line 160 of file EventReaderBaseAlg.h.

m_hits_clusterIndex_chLvl

std::vector< int >* EventReaderBaseAlg::m_hits_clusterIndex_chLvl = nullptr

protectedinherited

Definition at line 159 of file EventReaderBaseAlg.h.

m_hits_energy

std::vector< double >* EventReaderBaseAlg::m_hits_energy = nullptr

protectedinherited

Definition at line 162 of file EventReaderBaseAlg.h.

m_hits_energyConv

std::vector< double >* EventReaderBaseAlg::m_hits_energyConv = nullptr

protectedinherited

Definition at line 165 of file EventReaderBaseAlg.h.

m_hits_hash

std::vector< unsigned int >* EventReaderBaseAlg::m_hits_hash = nullptr

protectedinherited

Definition at line 161 of file EventReaderBaseAlg.h.

m_hits_sampFrac

std::vector< float >* EventReaderBaseAlg::m_hits_sampFrac = nullptr

protectedinherited

Definition at line 164 of file EventReaderBaseAlg.h.

m_hits_sampling

std::vector< int >* EventReaderBaseAlg::m_hits_sampling = nullptr

protectedinherited

Definition at line 158 of file EventReaderBaseAlg.h.

m_hits_time

std::vector< double >* EventReaderBaseAlg::m_hits_time = nullptr

protectedinherited

Definition at line 163 of file EventReaderBaseAlg.h.

m_isMC

Gaudi::Property<bool> EventReaderBaseAlg::m_isMC {this, "isMC", false, "Switch the dumper to MC sample mode."}

protectedinherited

Definition at line 64 of file EventReaderBaseAlg.h.

m_larCabling

const LArOnOffIdMapping* EventReaderAlg::m_larCabling = nullptr

private

Definition at line 121 of file EventReaderAlg.h.

m_larCablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> EventReaderAlg::m_larCablingKey {this,"LArOnOffMapKey","LArOnOffIdMap"," SG Key of LArOnOffIdMapping object."}

private

Definition at line 92 of file EventReaderAlg.h.

m_larDigitCntSgKey

SG::ReadHandleKey<LArDigitContainer> EventReaderAlg::m_larDigitCntSgKey {this, "LArDigitContainerKey", "LArDigitContainer_MC", "Name of the LArDigits container"}

private

Definition at line 102 of file EventReaderAlg.h.

m_larem_id

const LArEM_ID* EventReaderAlg::m_larem_id = nullptr

private

Definition at line 123 of file EventReaderAlg.h.

m_larEMBHitCntSgKey

SG::ReadHandleKey<LArHitContainer> EventReaderAlg::m_larEMBHitCntSgKey {this, "LArEMBHitContainerKey", "LArHitEMB", "Name of the LArHitEMB container"}

private

Definition at line 101 of file EventReaderAlg.h.

m_larfcal_id

const LArFCAL_ID* EventReaderAlg::m_larfcal_id = nullptr

private

Definition at line 125 of file EventReaderAlg.h.

m_larhec_id

const LArHEC_ID* EventReaderAlg::m_larhec_id = nullptr

private

Definition at line 124 of file EventReaderAlg.h.

m_larRawChCntSgKey

SG::ReadHandleKey<LArRawChannelContainer> EventReaderAlg::m_larRawChCntSgKey {this, "LArRawChannelContainerKey", "LArRawChannels", "Name of the LArRawChannel container"}

private

Definition at line 103 of file EventReaderAlg.h.

m_lb_bcidLuminosity

std::vector< std::vector < float > >* EventReaderBaseAlg::m_lb_bcidLuminosity = nullptr

protectedinherited

Definition at line 81 of file EventReaderBaseAlg.h.

m_lb_lumiblock

std::vector< int >* EventReaderBaseAlg::m_lb_lumiblock = nullptr

protectedinherited

Definition at line 82 of file EventReaderBaseAlg.h.

m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> EventReaderAlg::m_lumiDataKey {this,"LumiKey", "LuminosityCondData","SG Key of LuminosityCondData object"}

private

Definition at line 84 of file EventReaderAlg.h.

m_lumis

const LuminosityCondData* EventReaderAlg::m_lumis = nullptr

private

Definition at line 109 of file EventReaderAlg.h.

m_maxZeeMassTP

Gaudi::Property<float> EventReaderAlg::m_maxZeeMassTP {this, "maxZeeMassTP", 116, "Maximum value of Zee mass for checking the TP pairs (GeV)."}

private

Definition at line 72 of file EventReaderAlg.h.

m_mc_part_barcode

std::vector< int >* EventReaderBaseAlg::m_mc_part_barcode = nullptr

protectedinherited

Definition at line 241 of file EventReaderBaseAlg.h.

m_mc_part_energy

std::vector< float >* EventReaderBaseAlg::m_mc_part_energy = nullptr

protectedinherited

Definition at line 234 of file EventReaderBaseAlg.h.

m_mc_part_eta

std::vector< float >* EventReaderBaseAlg::m_mc_part_eta = nullptr

protectedinherited

Definition at line 237 of file EventReaderBaseAlg.h.

m_mc_part_m

std::vector< float >* EventReaderBaseAlg::m_mc_part_m = nullptr

protectedinherited

Definition at line 236 of file EventReaderBaseAlg.h.

m_mc_part_pdgId

std::vector< int >* EventReaderBaseAlg::m_mc_part_pdgId = nullptr

protectedinherited

Definition at line 239 of file EventReaderBaseAlg.h.

m_mc_part_phi

std::vector< float >* EventReaderBaseAlg::m_mc_part_phi = nullptr

protectedinherited

Definition at line 238 of file EventReaderBaseAlg.h.

m_mc_part_pt

std::vector< float >* EventReaderBaseAlg::m_mc_part_pt = nullptr

protectedinherited

Definition at line 235 of file EventReaderBaseAlg.h.

m_mc_part_status

std::vector< int >* EventReaderBaseAlg::m_mc_part_status = nullptr

protectedinherited

Definition at line 240 of file EventReaderBaseAlg.h.

m_mc_vert_barcode

std::vector< int >* EventReaderBaseAlg::m_mc_vert_barcode = nullptr

protectedinherited

Definition at line 251 of file EventReaderBaseAlg.h.

m_mc_vert_eta

std::vector< float >* EventReaderBaseAlg::m_mc_vert_eta = nullptr

protectedinherited

Definition at line 249 of file EventReaderBaseAlg.h.

m_mc_vert_perp

std::vector< float >* EventReaderBaseAlg::m_mc_vert_perp = nullptr

protectedinherited

Definition at line 248 of file EventReaderBaseAlg.h.

m_mc_vert_phi

std::vector< float >* EventReaderBaseAlg::m_mc_vert_phi = nullptr

protectedinherited

Definition at line 250 of file EventReaderBaseAlg.h.

m_mc_vert_status

std::vector< int >* EventReaderBaseAlg::m_mc_vert_status = nullptr

protectedinherited

Definition at line 252 of file EventReaderBaseAlg.h.

m_mc_vert_time

std::vector< float >* EventReaderBaseAlg::m_mc_vert_time = nullptr

protectedinherited

Definition at line 247 of file EventReaderBaseAlg.h.

m_mc_vert_x

std::vector< float >* EventReaderBaseAlg::m_mc_vert_x = nullptr

protectedinherited

Definition at line 244 of file EventReaderBaseAlg.h.

m_mc_vert_y

std::vector< float >* EventReaderBaseAlg::m_mc_vert_y = nullptr

protectedinherited

Definition at line 245 of file EventReaderBaseAlg.h.

m_mc_vert_z

std::vector< float >* EventReaderBaseAlg::m_mc_vert_z = nullptr

protectedinherited

Definition at line 246 of file EventReaderBaseAlg.h.

m_minBiasAvgKey

SG::ReadCondHandleKey<ILArMinBiasAverage> EventReaderAlg::m_minBiasAvgKey {this, "MinBiasAvgKey", "LArPileupAverageSym", "SGKey of LArMinBiasAverage object"}

private

Definition at line 89 of file EventReaderAlg.h.

m_minBiasAvgs

const ILArMinBiasAverage* EventReaderAlg::m_minBiasAvgs = nullptr

private

Definition at line 114 of file EventReaderAlg.h.

m_minEnergy

const double EventReaderBaseAlg::m_minEnergy = 1e-9

protectedinherited

Definition at line 157 of file EventReaderBaseAlg.h.

m_minZeeMassTP

Gaudi::Property<float> EventReaderAlg::m_minZeeMassTP {this, "minZeeMassTP", 66, "Minimum value of Zee mass for checking the TP pairs (GeV)."}

private

Definition at line 71 of file EventReaderAlg.h.

m_myElecSelectionSgKey

SG::ReadHandleKey<xAOD::ElectronContainer> EventReaderAlg::m_myElecSelectionSgKey {this, "MyElectronSelectionKey", "MySelectedElectrons", "Name of the MySelectedElectrons Container"}

private

Definition at line 97 of file EventReaderAlg.h.

m_ncell

size_t EventReaderBaseAlg::m_ncell = 0

protectedinherited

Definition at line 156 of file EventReaderBaseAlg.h.

m_noBadCells

Gaudi::Property<bool> EventReaderBaseAlg::m_noBadCells {this, "noBadCells", true, "If True, skip the cells tagged as badCells/channels."}

protectedinherited

Definition at line 66 of file EventReaderBaseAlg.h.

m_noiseCDO

const CaloNoise* EventReaderAlg::m_noiseCDO = nullptr

private

Definition at line 108 of file EventReaderAlg.h.

m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> EventReaderAlg::m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}

private

Definition at line 81 of file EventReaderAlg.h.

m_ntsvc

ServiceHandle<ITHistSvc> EventReaderAlg::m_ntsvc

private

Definition at line 78 of file EventReaderAlg.h.

m_ofcKey

SG::ReadCondHandleKey<ILArOFC> EventReaderAlg::m_ofcKey {this,"OFCKey","LArOFC","SG Key of OFC conditions object"}

private

Definition at line 87 of file EventReaderAlg.h.

m_ofcs

const ILArOFC* EventReaderAlg::m_ofcs = nullptr

private

Definition at line 112 of file EventReaderAlg.h.

m_offlineHVScaleCorrKey

SG::ReadCondHandleKey<LArHVCorr> EventReaderAlg::m_offlineHVScaleCorrKey {this, "keyOfflineHVCorr", "LArHVScaleCorrRecomputed","Key for LArHVScaleCorr"}

private

Definition at line 90 of file EventReaderAlg.h.

m_offProbeTightness

Gaudi::Property<std::string> EventReaderBaseAlg::m_offProbeTightness {this, "offProbeTightness", "Loose"}

protectedinherited

Define the PID for tag electron.

Definition at line 53 of file EventReaderBaseAlg.h.

m_offTagTightness

Gaudi::Property<std::string> EventReaderBaseAlg::m_offTagTightness {this, "offTagTightness", "LHMedium"}

protectedinherited

Definition at line 52 of file EventReaderBaseAlg.h.

m_oflHVCorr

const LArHVCorr* EventReaderAlg::m_oflHVCorr = nullptr

private

Definition at line 115 of file EventReaderAlg.h.

m_onlineLArID

const LArOnlineID* EventReaderAlg::m_onlineLArID = nullptr

private

Definition at line 120 of file EventReaderAlg.h.

m_pedestalKey

SG::ReadCondHandleKey<ILArPedestal> EventReaderAlg::m_pedestalKey {this,"PedestalKey","LArPedestal","SG Key of Pedestal conditions object"}

private

Definition at line 85 of file EventReaderAlg.h.

m_peds

const ILArPedestal* EventReaderAlg::m_peds = nullptr

private

Definition at line 110 of file EventReaderAlg.h.

m_ph_energy

std::vector< float >* EventReaderBaseAlg::m_ph_energy = nullptr

protectedinherited

Definition at line 266 of file EventReaderBaseAlg.h.

m_ph_eta

std::vector< float >* EventReaderBaseAlg::m_ph_eta = nullptr

protectedinherited

Definition at line 263 of file EventReaderBaseAlg.h.

m_ph_m

std::vector< float >* EventReaderBaseAlg::m_ph_m = nullptr

protectedinherited

Definition at line 267 of file EventReaderBaseAlg.h.

m_ph_phi

std::vector< float >* EventReaderBaseAlg::m_ph_phi = nullptr

protectedinherited

Definition at line 264 of file EventReaderBaseAlg.h.

m_ph_pt

std::vector< float >* EventReaderBaseAlg::m_ph_pt = nullptr

protectedinherited

Definition at line 265 of file EventReaderBaseAlg.h.

m_primVertSgKey

SG::ReadHandleKey<xAOD::VertexContainer> EventReaderAlg::m_primVertSgKey {this, "PrimaryVertexContainerKey", "PrimaryVertices", "Name of the PrimaryVertices Container"}

private

Definition at line 95 of file EventReaderAlg.h.

m_printCellsClus

Gaudi::Property<bool> EventReaderAlg::m_printCellsClus {this, "printCellsClus", false, "Print out the cluster cells basic info during the dump."}

private

Definition at line 67 of file EventReaderAlg.h.

m_run2DSPThresh

std::unique_ptr<LArDSPThresholdsFlat> EventReaderAlg::m_run2DSPThresh = nullptr

private

Definition at line 106 of file EventReaderAlg.h.

m_run2DSPThresholdsKey

SG::ReadCondHandleKey<AthenaAttributeList> EventReaderAlg::m_run2DSPThresholdsKey {this, "Run2DSPThresholdsKey","", "SG Key for thresholds to compute time and quality, run 2"}

private

Definition at line 82 of file EventReaderAlg.h.

m_secondTree

TTree* EventReaderBaseAlg::m_secondTree {}

protectedinherited

Definition at line 74 of file EventReaderBaseAlg.h.

m_shapeKey

SG::ReadCondHandleKey<ILArShape> EventReaderAlg::m_shapeKey {this,"ShapeKey","LArShape","SG Key of Shape conditions object"}

private

Definition at line 88 of file EventReaderAlg.h.

m_shapes

const ILArShape* EventReaderAlg::m_shapes = nullptr

private

Definition at line 113 of file EventReaderAlg.h.

m_skipEmptyEvents

Gaudi::Property<bool> EventReaderAlg::m_skipEmptyEvents {this, "skipEmptyEvents", true, "If true, do not fill the event that has no reco electrons."}

private

Definition at line 70 of file EventReaderAlg.h.

m_tp_electronEt

std::vector< float >* EventReaderBaseAlg::m_tp_electronEt = nullptr

protectedinherited

Definition at line 294 of file EventReaderBaseAlg.h.

m_tp_electronEta

std::vector< float >* EventReaderBaseAlg::m_tp_electronEta = nullptr

protectedinherited

Definition at line 295 of file EventReaderBaseAlg.h.

m_tp_electronPhi

std::vector< float >* EventReaderBaseAlg::m_tp_electronPhi = nullptr

protectedinherited

Definition at line 296 of file EventReaderBaseAlg.h.

m_tp_electronPt

std::vector< float >* EventReaderBaseAlg::m_tp_electronPt = nullptr

protectedinherited

Definition at line 293 of file EventReaderBaseAlg.h.

m_tp_isProbe

std::vector< bool >* EventReaderBaseAlg::m_tp_isProbe = nullptr

protectedinherited

Definition at line 301 of file EventReaderBaseAlg.h.

m_tp_isTag

std::vector< bool >* EventReaderBaseAlg::m_tp_isTag = nullptr

protectedinherited

Definition at line 300 of file EventReaderBaseAlg.h.

m_tp_probeIndex

std::vector< int >* EventReaderBaseAlg::m_tp_probeIndex = nullptr

protectedinherited

Definition at line 298 of file EventReaderBaseAlg.h.

m_tp_tagIndex

std::vector< int >* EventReaderBaseAlg::m_tp_tagIndex = nullptr

protectedinherited

Definition at line 299 of file EventReaderBaseAlg.h.

m_Tree

TTree* EventReaderBaseAlg::m_Tree {}

protectedinherited

Definition at line 73 of file EventReaderBaseAlg.h.

m_truthEventCntSgKey

SG::ReadHandleKey<xAOD::TruthEventContainer> EventReaderAlg::m_truthEventCntSgKey {this, "TruthEventContainerKey", "TruthEvents", "Name of the TruthEvents Container"}

private

Definition at line 100 of file EventReaderAlg.h.

m_truthParticleCntSgKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> EventReaderAlg::m_truthParticleCntSgKey {this, "TruthParticleContainerKey", "TruthParticles", "Name of the TruthParticles Container"}

private

Definition at line 98 of file EventReaderAlg.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.

m_vtx_d0sig

std::vector< double >* EventReaderBaseAlg::m_vtx_d0sig = nullptr

protectedinherited

Definition at line 260 of file EventReaderBaseAlg.h.

m_vtx_delta_z0_sin

std::vector< float >* EventReaderBaseAlg::m_vtx_delta_z0_sin = nullptr

protectedinherited

Definition at line 259 of file EventReaderBaseAlg.h.

m_vtx_deltaZ0

std::vector< float >* EventReaderBaseAlg::m_vtx_deltaZ0 = nullptr

protectedinherited

Definition at line 258 of file EventReaderBaseAlg.h.

m_vtx_x

std::vector< float >* EventReaderBaseAlg::m_vtx_x = nullptr

protectedinherited

Definition at line 255 of file EventReaderBaseAlg.h.

m_vtx_y

std::vector< float >* EventReaderBaseAlg::m_vtx_y = nullptr

protectedinherited

Definition at line 256 of file EventReaderBaseAlg.h.

m_vtx_z

std::vector< float >* EventReaderBaseAlg::m_vtx_z = nullptr

protectedinherited

Definition at line 257 of file EventReaderBaseAlg.h.

m_z0Tag

Gaudi::Property<float> EventReaderBaseAlg::m_z0Tag {this, "z0Tag", 0.5, "z0 longitudinal impact parameter (mm)"}

protectedinherited

Definition at line 57 of file EventReaderBaseAlg.h.

m_zee_deltaR

std::vector< double >* EventReaderBaseAlg::m_zee_deltaR = nullptr

protectedinherited

Definition at line 310 of file EventReaderBaseAlg.h.

m_zee_E

std::vector< double >* EventReaderBaseAlg::m_zee_E = nullptr

protectedinherited

Definition at line 304 of file EventReaderBaseAlg.h.

m_zee_M

std::vector< double >* EventReaderBaseAlg::m_zee_M = nullptr

protectedinherited

Definition at line 303 of file EventReaderBaseAlg.h.

m_zee_pt

std::vector< double >* EventReaderBaseAlg::m_zee_pt = nullptr

protectedinherited

Definition at line 305 of file EventReaderBaseAlg.h.

m_zee_px

std::vector< double >* EventReaderBaseAlg::m_zee_px = nullptr

protectedinherited

Definition at line 306 of file EventReaderBaseAlg.h.

m_zee_py

std::vector< double >* EventReaderBaseAlg::m_zee_py = nullptr

protectedinherited

Definition at line 307 of file EventReaderBaseAlg.h.

m_zee_pz

std::vector< double >* EventReaderBaseAlg::m_zee_pz = nullptr

protectedinherited

Definition at line 308 of file EventReaderBaseAlg.h.

m_zee_T

std::vector< double >* EventReaderBaseAlg::m_zee_T = nullptr

protectedinherited

Definition at line 309 of file EventReaderBaseAlg.h.

---

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

• EventReaderAlg.h
• EventReaderAlg.cxx