ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
EventReaderBaseAlg Class Reference

#include <EventReaderBaseAlg.h>

Inheritance diagram for EventReaderBaseAlg:
Collaboration diagram for EventReaderBaseAlg:

Public Member Functions

 EventReaderBaseAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~EventReaderBaseAlg () override
 
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

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

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 19 of file EventReaderBaseAlg.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

◆ EventReaderBaseAlg()

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

Definition at line 16 of file EventReaderBaseAlg.cxx.

16  :
17  AthAlgorithm(name, pSvcLocator) {}

◆ ~EventReaderBaseAlg()

EventReaderBaseAlg::~EventReaderBaseAlg ( )
overridevirtual

Definition at line 19 of file EventReaderBaseAlg.cxx.

19 {}

Member Function Documentation

◆ bookBranches()

void EventReaderBaseAlg::bookBranches ( TTree *  tree)
protected

Definition at line 253 of file EventReaderBaseAlg.cxx.

253  {
254  // ## Event info
255  tree->Branch ("event_RunNumber", &m_e_runNumber);
256  tree->Branch ("event_EventNumber", &m_e_eventNumber);
257  tree->Branch ("event_BCID", &m_e_bcid);
258  tree->Branch ("event_Lumiblock",&m_e_lumiBlock);
259  tree->Branch ("event_avg_mu_inTimePU", &m_e_inTimePileup);
260  tree->Branch ("event_avg_mu_OOTimePU", &m_e_outOfTimePileUp);
261  // #############
262 
263  // ## Cluster
264  tree->Branch ("cluster_index",&m_c_clusterIndex);
265  tree->Branch ("c_electronIndex_clusterLvl",&m_c_electronIndex_clusterLvl);
266  tree->Branch ("cluster_et",&m_c_clusterEnergy);
267  tree->Branch ("cluster_time",&m_c_clusterTime);
268  tree->Branch ("cluster_pt",&m_c_clusterPt);
269  tree->Branch ("cluster_eta",&m_c_clusterEta);
270  tree->Branch ("cluster_phi",&m_c_clusterPhi);
271  // Cluster cell
272  tree->Branch ("cluster_index_cellLvl",&m_c_clusterIndex_cellLvl);
273  tree->Branch ("cluster_cell_index",&m_c_clusterCellIndex);
274  tree->Branch ("cluster_cell_caloGain",&m_c_cellGain);
275  tree->Branch ("cluster_cell_layer",&m_c_cellLayer);
276  tree->Branch ("cluster_cell_region",&m_c_cellRegion);
277  tree->Branch ("cluster_cell_energy",&m_c_cellEnergy);
278  tree->Branch ("cluster_cell_time",&m_c_cellTime);
279  tree->Branch ("cluster_cell_eta",&m_c_cellEta);
280  tree->Branch ("cluster_cell_phi",&m_c_cellPhi);
281  tree->Branch ("cluster_cell_deta",&m_c_cellDEta);
282  tree->Branch ("cluster_cell_dphi",&m_c_cellDPhi);
283  tree->Branch ("cluster_cellsDist_dphi",&m_c_cellToClusterDPhi);
284  tree->Branch ("cluster_cellsDist_deta",&m_c_cellToClusterDEta);
285  // Cluster channel (digits and cell ch)
286  tree->Branch ("cluster_index_chLvl",&m_c_clusterIndex_chLvl);
287  tree->Branch ("cluster_channel_index",&m_c_clusterChannelIndex);
288  tree->Branch ("cluster_channel_digits",&m_c_channelDigits);
289  tree->Branch ("cluster_channel_energy",&m_c_channelEnergy);
290  tree->Branch ("cluster_channel_time",&m_c_channelTime);
291  tree->Branch ("cluster_channel_layer",&m_c_channelLayer);
292  if (!m_noBadCells) tree->Branch ("cluster_channel_bad",&m_c_channelBad);
293  tree->Branch ("cluster_channel_chInfo", &m_c_channelChInfo);
294  tree->Branch ("cluster_channel_hash",&m_c_channelHashMap);
295  tree->Branch ("cluster_channel_id",&m_c_channelChannelIdMap);
296  if (m_getLArCalibConstants){
297  tree->Branch ("cluster_channel_effSigma",&m_c_channelEffectiveSigma);
298  tree->Branch ("cluster_channel_noise",&m_c_channelNoise);
299  tree->Branch ("cluster_channel_DSPThreshold",&m_c_channelDSPThreshold);
300  tree->Branch ("cluster_channel_OFCTimeOffset",&m_c_channelOFCTimeOffset);
301  tree->Branch ("cluster_channel_ADC2MeV0",&m_c_channelADC2MEV0);
302  tree->Branch ("cluster_channel_ADC2MeV1",&m_c_channelADC2MEV1);
303  tree->Branch ("cluster_channel_pedestal",&m_c_channelPed);
304  tree->Branch ("cluster_channel_OFCa",&m_c_channelOFCa);
305  tree->Branch ("cluster_channel_OFCb",&m_c_channelOFCb);
306  tree->Branch ("cluster_channel_MinBiasAvg",&m_c_channelMinBiasAvg);
307 
308  if (!m_isMC){
309  tree->Branch ("cluster_channel_OfflineEnergyRescaler",&m_c_channelOfflEneRescaler);
310  tree->Branch ("cluster_channel_OfflineHVScale",&m_c_channelOfflHVScale);
311  tree->Branch ("cluster_channel_shape",&m_c_channelShape);
312  tree->Branch ("cluster_channel_shapeDer",&m_c_channelShapeDer);
313  }
314  }
315 
316  // Cluster raw channel
317  tree->Branch ("cluster_index_rawChLvl",&m_c_clusterIndex_rawChLvl);
318  tree->Branch ("cluster_rawChannel_index",&m_c_clusterRawChannelIndex);
319  tree->Branch ("cluster_rawChannel_id",&m_c_rawChannelIdMap);
320  tree->Branch ("cluster_rawChannel_amplitude",&m_c_rawChannelAmplitude);
321  tree->Branch ("cluster_rawChannel_time",&m_c_rawChannelTime);
322  tree->Branch ("cluster_rawChannel_layer",&m_c_rawChannelLayer);
323  tree->Branch ("cluster_rawChannel_Ped",&m_c_rawChannelPed);
324  tree->Branch ("cluster_rawChannel_Prov",&m_c_rawChannelProv);
325  tree->Branch ("cluster_rawChannel_qual",&m_c_rawChannelQuality);
326  tree->Branch ("cluster_rawChannel_chInfo",&m_c_rawChannelChInfo); // tree->Branch ("cluster_cell_caloGain",&c_cellGain); //modify
327  if (!m_isMC){
328  tree->Branch ("cluster_rawChannel_DSPThreshold",&m_c_rawChannelDSPThreshold);
329  }
330 
331  // ## Cluster EMB2 7_11
332  if (m_doAssocTopoCluster711Dump){
333  tree->Branch ("cluster711_index",&m_c711_clusterIndex);
334  tree->Branch ("c711_electronIndex_clusterLvl",&m_c711_electronIndex_clusterLvl);
335  tree->Branch ("cluster711_et",&m_c711_clusterEnergy);
336  tree->Branch ("cluster711_pt",&m_c711_clusterPt);
337  tree->Branch ("cluster711_time",&m_c711_clusterTime);
338  tree->Branch ("cluster711_eta",&m_c711_clusterEta);
339  tree->Branch ("cluster711_phi",&m_c711_clusterPhi);
340  // Cluster cell
341  tree->Branch ("cluster711_index_cellLvl",&m_c711_clusterIndex_cellLvl);
342  tree->Branch ("cluster711_cell_index",&m_c711_clusterCellIndex);
343  tree->Branch ("cluster711_cell_caloGain",&m_c711_cellGain);
344  tree->Branch ("cluster711_cell_layer",&m_c711_cellLayer);
345  tree->Branch ("cluster711_cell_region",&m_c711_cellRegion);
346  tree->Branch ("cluster711_cell_energy",&m_c711_cellEnergy);
347  tree->Branch ("cluster711_cell_time",&m_c711_cellTime);
348  tree->Branch ("cluster711_cell_eta",&m_c711_cellEta);
349  tree->Branch ("cluster711_cell_phi",&m_c711_cellPhi);
350  tree->Branch ("cluster711_cell_deta",&m_c711_cellDEta);
351  tree->Branch ("cluster711_cell_dphi",&m_c711_cellDPhi);
352  tree->Branch ("cluster711_cellsDist_dphi",&m_c711_cellToClusterDPhi);
353  tree->Branch ("cluster711_cellsDist_deta",&m_c711_cellToClusterDEta);
354  // Cluster channel (digits and cell ch)
355  tree->Branch ("cluster711_index_chLvl",&m_c711_clusterIndex_chLvl);
356  tree->Branch ("cluster711_channel_index",&m_c711_clusterChannelIndex);
357  tree->Branch ("cluster711_channel_digits",&m_c711_channelDigits);
358  tree->Branch ("cluster711_channel_energy",&m_c711_channelEnergy);
359  tree->Branch ("cluster711_channel_time",&m_c711_channelTime);
360  tree->Branch ("cluster711_channel_layer", &m_c711_channelLayer);
361  if (!m_noBadCells) tree->Branch ("cluster711_channel_bad",&m_c711_channelBad);
362  tree->Branch ("cluster711_channel_chInfo", &m_c711_channelChInfo);
363  tree->Branch ("cluster711_channel_hash",&m_c711_channelHashMap);
364  tree->Branch ("cluster711_channel_id",&m_c711_channelChannelIdMap);
365  if (m_getLArCalibConstants){
366  tree->Branch ("cluster711_channel_effSigma",&m_c711_channelEffectiveSigma);
367  tree->Branch ("cluster711_channel_noise",&m_c711_channelNoise);
368  tree->Branch ("cluster711_channel_DSPThreshold",&m_c711_channelDSPThreshold);
369  tree->Branch ("cluster711_channel_OFCTimeOffset",&m_c711_channelOFCTimeOffset);
370  tree->Branch ("cluster711_channel_ADC2MeV0",&m_c711_channelADC2MEV0);
371  tree->Branch ("cluster711_channel_ADC2MeV1",&m_c711_channelADC2MEV1);
372  tree->Branch ("cluster711_channel_pedestal",&m_c711_channelPed);
373  tree->Branch ("cluster711_channel_OFCa",&m_c711_channelOFCa);
374  tree->Branch ("cluster711_channel_OFCb",&m_c711_channelOFCb);
375  tree->Branch ("cluster711_channel_MinBiasAvg",&m_c711_channelMinBiasAvg);
376 
377  if (!m_isMC){
378  tree->Branch ("cluster711_channel_OfflineEnergyRescaler",&m_c711_channelOfflEneRescaler);
379  tree->Branch ("cluster711_channel_OfflineHVScale",&m_c711_channelOfflHVScale);
380  tree->Branch ("cluster711_channel_shape",&m_c711_channelShape);
381  tree->Branch ("cluster711_channel_shapeDer",&m_c711_channelShapeDer);
382  }
383  }
384  // Cluster raw channel
385  tree->Branch ("cluster711_index_rawChLvl",&m_c711_clusterIndex_rawChLvl);
386  tree->Branch ("cluster711_rawChannel_index",&m_c711_clusterRawChannelIndex);
387  tree->Branch ("cluster711_rawChannel_id",&m_c711_rawChannelIdMap);
388  tree->Branch ("cluster711_rawChannel_amplitude",&m_c711_rawChannelAmplitude);
389  tree->Branch ("cluster711_rawChannel_time",&m_c711_rawChannelTime);
390  tree->Branch ("cluster711_rawChannel_layer",&m_c711_rawChannelLayer);
391  tree->Branch ("cluster711_rawChannel_Ped",&m_c711_rawChannelPed);
392  tree->Branch ("cluster711_rawChannel_Prov",&m_c711_rawChannelProv);
393  tree->Branch ("cluster711_rawChannel_qual",&m_c711_rawChannelQuality);
394  tree->Branch ("cluster711_rawChannel_chInfo",&m_c711_rawChannelChInfo);
395  if (!m_isMC){
396  tree->Branch ("cluster711_rawChannel_DSPThreshold",&m_c711_rawChannelDSPThreshold);
397  }
398  }
399  // #############
400 
401  // ## Particle Truth ##
402  if (m_isMC){
403  if (m_doLArEMBHitsDump){
404  tree->Branch("hits_sampling", &m_hits_sampling);
405  tree->Branch("hits_clusterIndex_chLvl", &m_hits_clusterIndex_chLvl);
406  tree->Branch("hits_clusterChannelIndex", &m_hits_clusterChannelIndex);
407  tree->Branch("hits_hash", &m_hits_hash);
408  tree->Branch("hits_energy", &m_hits_energy);
409  tree->Branch("hits_time", &m_hits_time);
410  tree->Branch("hits_sampFrac", &m_hits_sampFrac);
411  tree->Branch("hits_energyConv", &m_hits_energyConv);
412  tree->Branch("hits_cellEta", &m_hits_cellEta);
413  tree->Branch("hits_cellPhi", &m_hits_cellPhi);
414  }
415 
416  if (m_doTruthPartDump){
417  tree->Branch("mc_part_energy",&m_mc_part_energy);
418  tree->Branch("mc_part_pt",&m_mc_part_pt);
419  tree->Branch("mc_part_m",&m_mc_part_m);
420  tree->Branch("mc_part_eta",&m_mc_part_eta);
421  tree->Branch("mc_part_phi",&m_mc_part_phi);
422  tree->Branch("mc_part_pdgId",&m_mc_part_pdgId);
423  tree->Branch("mc_part_status", &m_mc_part_status);
424  tree->Branch("mc_part_barcode", &m_mc_part_barcode);
425  }
426  // ## Vertex Truth ##
427  if (m_doTruthEventDump){
428  tree->Branch("mc_vert_x", &m_mc_vert_x);
429  tree->Branch("mc_vert_y", &m_mc_vert_y);
430  tree->Branch("mc_vert_z", &m_mc_vert_z);
431  tree->Branch("mc_vert_time", &m_mc_vert_time);
432  tree->Branch("mc_vert_perp", &m_mc_vert_perp);
433  tree->Branch("mc_vert_eta", &m_mc_vert_eta);
434  tree->Branch("mc_vert_phi", &m_mc_vert_phi);
435  tree->Branch("mc_vert_barcode", &m_mc_vert_barcode);
436  tree->Branch("mc_vert_status", &m_mc_vert_status);
437  }
438  }
439 
440  // ## Photons ##
441  if (m_doPhotonDump){
442  tree->Branch("ph_energy",&m_ph_energy);
443  tree->Branch("ph_pt",&m_ph_pt);
444  tree->Branch("ph_eta",&m_ph_eta);
445  tree->Branch("ph_phi",&m_ph_phi);
446  tree->Branch("ph_m",&m_ph_m);
447  }
448  // ## Primary Vertex
449  tree->Branch("vtx_x",&m_vtx_x);
450  tree->Branch("vtx_y",&m_vtx_y);
451  tree->Branch("vtx_z",&m_vtx_z);
452  tree->Branch("vtx_deltaZ0",&m_vtx_deltaZ0);
453  tree->Branch("vtx_delta_z0_sin",&m_vtx_delta_z0_sin);
454  tree->Branch("vtx_d0sig",&m_vtx_d0sig);
455 
456  // ## Electrons ##
457  tree->Branch("el_index",&m_el_index);
458  tree->Branch("el_Pt",&m_el_Pt);
459  tree->Branch("el_et",&m_el_et);
460  tree->Branch("el_Eta",&m_el_Eta);
461  tree->Branch("el_Phi",&m_el_Phi);
462  tree->Branch("el_m",&m_el_m);
463  tree->Branch("el_eoverp",&m_el_eoverp);
464  tree->Branch("el_f1",&m_el_f1);
465  tree->Branch("el_f3",&m_el_f3);
466  tree->Branch("el_eratio",&m_el_eratio);
467  tree->Branch("el_weta1",&m_el_weta1);
468  tree->Branch("el_weta2",&m_el_weta2);
469  tree->Branch("el_fracs1",&m_el_fracs1);
470  tree->Branch("el_wtots1",&m_el_wtots1);
471  tree->Branch("el_e277",&m_el_e277);
472  tree->Branch("el_reta",&m_el_reta);
473  tree->Branch("el_rphi",&m_el_rphi);
474  tree->Branch("el_deltae",&m_el_deltae);
475  tree->Branch("el_rhad",&m_el_rhad);
476  tree->Branch("el_rhad1",&m_el_rhad1);
477 
478  // ## Tag and Probe ##
479  // zee
480  if (!m_doElecSelectByTrackOnly && m_doTagAndProbe){
481  tree->Branch("zee_M", &m_zee_M);
482  tree->Branch("zee_E", &m_zee_E);
483  tree->Branch("zee_pt", &m_zee_pt);
484  tree->Branch("zee_px", &m_zee_px);
485  tree->Branch("zee_py", &m_zee_py);
486  tree->Branch("zee_pz", &m_zee_pz);
487  tree->Branch("zee_T", &m_zee_T);
488  tree->Branch("zee_deltaR", &m_zee_deltaR);
489  }
490 }

◆ bookDatabaseBranches()

void EventReaderBaseAlg::bookDatabaseBranches ( TTree *  tree)
protected

Definition at line 237 of file EventReaderBaseAlg.cxx.

237  {
238  // ## BCID/Luminosity vector
239  tree->Branch ("lb_lumiblock",&m_lb_lumiblock);
240  if (!m_isMC){
241  tree->Branch ("lb_bcidLuminosity",&m_lb_bcidLuminosity);
242  }
243 }

◆ clear()

void EventReaderBaseAlg::clear ( )
protected

Definition at line 492 of file EventReaderBaseAlg.cxx.

492  {
493  // ## Event info
494  m_e_runNumber = 9999;
495  m_e_eventNumber = 9999;
496  m_e_bcid = 9999;
497  m_e_lumiBlock = 999;
498  m_e_inTimePileup = -999;
499  m_e_outOfTimePileUp = -999;
500  // ############
501 
502  ATH_MSG_DEBUG("Clear Clusters..");
503  // ## Cluster (TOPOCLUSTER or SUPERCLUSTER)
504  m_c_clusterIndexCounter = 0;
505  m_c_clusterIndex->clear();
506  m_c_electronIndex_clusterLvl->clear();
507  m_c_clusterEnergy->clear();
508  m_c_clusterTime->clear();
509  m_c_clusterPt->clear();
510  m_c_clusterEta->clear();
511  m_c_clusterPhi->clear();
512  // Cluster cell
513  ATH_MSG_DEBUG("Clear Clusters cell..");
514  m_c_cellIndexCounter = 0;
515  m_c_clusterIndex_cellLvl->clear();
516  m_c_clusterCellIndex->clear();
517  m_c_cellGain->clear();
518  m_c_cellLayer->clear();
519  m_c_cellRegion->clear();
520  m_c_cellEnergy->clear();
521  m_c_cellTime->clear();
522  m_c_cellEta->clear();
523  m_c_cellPhi->clear();
524  m_c_cellDEta->clear();
525  m_c_cellDPhi->clear();
526  m_c_cellToClusterDPhi->clear();
527  m_c_cellToClusterDEta->clear();
528  // Cluster channel
529  ATH_MSG_DEBUG("Clear Clusters channel..");
530  m_c_clusterIndex_chLvl->clear();
531  m_c_clusterChannelIndex->clear();
532  m_c_channelHashMap->clear(); //
533  m_c_channelChannelIdMap->clear();
534  m_c_channelDigits->clear();
535  m_c_channelEnergy->clear();
536  m_c_channelTime->clear();
537  m_c_channelLayer->clear();
538  if (!m_noBadCells) m_c_channelBad->clear();
539  m_c_channelChInfo->clear();
540  if (m_getLArCalibConstants){
541  ATH_MSG_DEBUG("Clear calib. constants..");
542  m_c_channelEffectiveSigma->clear();
543  m_c_channelNoise->clear();
544  m_c_channelDSPThreshold->clear();
545  m_c_channelOFCTimeOffset->clear();
546  m_c_channelADC2MEV0->clear();
547  m_c_channelADC2MEV1->clear();
548  m_c_channelPed->clear();
549  m_c_channelOFCa->clear();
550  m_c_channelOFCb->clear();
551  m_c_channelMinBiasAvg->clear();
552  if (!m_isMC){
553  m_c_channelOfflEneRescaler->clear();
554  m_c_channelOfflHVScale->clear();
555  m_c_channelShapeDer->clear();
556  m_c_channelShape->clear();
557  }
558  }
559  // Cluster raw channel
560  ATH_MSG_DEBUG("Clear Clusters rawch..");
561  m_c_rawChannelIdMap->clear();
562  m_c_rawChannelChInfo->clear();
563  m_c_rawChannelAmplitude->clear();
564  m_c_rawChannelTime->clear();
565  m_c_rawChannelLayer->clear();
566  m_c_rawChannelPed->clear();// raw channel estimated pedestal
567  m_c_rawChannelProv->clear();// raw channel LAr provenance (tile masked)
568  m_c_rawChannelQuality->clear();
569  m_c_clusterRawChannelIndex->clear();
570  m_c_clusterIndex_rawChLvl->clear();
571  if (!m_isMC){
572  m_c_rawChannelDSPThreshold->clear();
573  }
574  // ############
575 
576  // ## Cluster EMB2_711
577  if (m_doAssocTopoCluster711Dump){
578  *m_c711_clusterIndexCounter = 0;
579  m_c711_clusterIndex->clear();
580  m_c711_electronIndex_clusterLvl->clear();
581  m_c711_clusterEnergy->clear();
582  m_c711_clusterPt->clear();
583  m_c711_clusterTime->clear();
584  m_c711_clusterEta->clear();
585  m_c711_clusterPhi->clear();
586  // Cluster cell
587  ATH_MSG_DEBUG("Clear Clusters 7x11 cell..");
588  *m_c711_cellIndexCounter = 0;
589  m_c711_clusterIndex_cellLvl->clear();
590  m_c711_clusterCellIndex->clear();
591  m_c711_cellGain->clear();
592  m_c711_cellLayer->clear();
593  m_c711_cellRegion->clear();
594  m_c711_cellEnergy->clear();
595  m_c711_cellTime->clear();
596  m_c711_cellEta->clear();
597  m_c711_cellPhi->clear();
598  m_c711_cellDEta->clear();
599  m_c711_cellDPhi->clear();
600  m_c711_cellToClusterDPhi->clear();
601  m_c711_cellToClusterDEta->clear();
602  // Cluster channel
603  ATH_MSG_DEBUG("Clear Clusters 7x11 channel..");
604  m_c711_clusterIndex_chLvl->clear();
605  m_c711_clusterChannelIndex->clear();
606  m_c711_channelHashMap->clear(); //
607  m_c711_channelChannelIdMap->clear();
608  m_c711_channelDigits->clear();
609  m_c711_channelEnergy->clear();
610  m_c711_channelTime->clear();
611  m_c711_channelLayer->clear();
612  if (!m_noBadCells) m_c711_channelBad->clear();
613  m_c711_channelChInfo->clear();
614  if (m_getLArCalibConstants){
615  m_c711_channelEffectiveSigma->clear();
616  m_c711_channelNoise->clear();
617  m_c711_channelDSPThreshold->clear();
618  m_c711_channelOFCTimeOffset->clear();
619  m_c711_channelADC2MEV0->clear();
620  m_c711_channelADC2MEV1->clear();
621  m_c711_channelPed->clear();
622  m_c711_channelOFCa->clear();
623  m_c711_channelOFCb->clear();
624  m_c711_channelMinBiasAvg->clear();
625  if (!m_isMC){
626  m_c711_channelOfflEneRescaler->clear();
627  m_c711_channelOfflHVScale->clear();
628  m_c711_channelShapeDer->clear();
629  m_c711_channelShape->clear();
630  }
631  }
632  // Cluster raw channel
633  ATH_MSG_DEBUG("Clear Clusters 7x11 rawch..");
634  m_c711_rawChannelIdMap->clear();
635  m_c711_rawChannelChInfo->clear();
636  m_c711_rawChannelAmplitude->clear();
637  m_c711_rawChannelTime->clear();
638  m_c711_rawChannelLayer->clear();
639  m_c711_rawChannelPed->clear();// raw channel estimated pedestal
640  m_c711_rawChannelProv->clear();// raw channel LAr provenance (tile masked)
641  m_c711_rawChannelQuality->clear();
642  m_c711_clusterRawChannelIndex->clear();
643  m_c711_clusterIndex_rawChLvl->clear();
644  if (!m_isMC){
645  m_c711_rawChannelDSPThreshold->clear();
646  }
647 }
648 
649  // ## Particle Truth ##
650  if (m_isMC){
651  if (m_doLArEMBHitsDump){
652  m_hits_sampling->clear();
653  m_hits_clusterIndex_chLvl->clear();
654  m_hits_clusterChannelIndex->clear();
655  m_hits_hash->clear();
656  m_hits_energy->clear();
657  m_hits_time->clear();
658  m_hits_sampFrac->clear();
659  m_hits_energyConv->clear();
660  m_hits_cellEta->clear();
661  m_hits_cellPhi->clear();
662  }
663 
664  if (m_doTruthPartDump){
665  ATH_MSG_DEBUG("particle truth..");
666  m_mc_part_energy->clear();
667  m_mc_part_pt->clear();
668  m_mc_part_m->clear();
669  m_mc_part_eta->clear();
670  m_mc_part_phi->clear();
671  m_mc_part_pdgId->clear();
672  m_mc_part_status->clear();
673  m_mc_part_barcode->clear();
674  }
675  // ## Vertex Truth ##
676  if (m_doTruthEventDump){
677  m_mc_vert_x->clear();
678  m_mc_vert_y->clear();
679  m_mc_vert_z->clear();
680  m_mc_vert_time->clear();
681  m_mc_vert_perp->clear();
682  m_mc_vert_eta->clear();
683  m_mc_vert_phi->clear();
684  m_mc_vert_barcode->clear();
685  m_mc_vert_status->clear();
686  }
687  }
688  // ## Photons ##
689  if (m_doPhotonDump){
690  ATH_MSG_DEBUG("Clear Photons");
691  m_ph_energy->clear();
692  m_ph_eta->clear();
693  m_ph_phi->clear();
694  m_ph_pt->clear();
695  m_ph_m->clear();
696  }
697 
698  ATH_MSG_DEBUG("Clear: Vertexes");
699  m_vtx_x->clear();
700  m_vtx_y->clear();
701  m_vtx_z->clear();
702  m_vtx_deltaZ0->clear();
703  m_vtx_delta_z0_sin->clear();
704  m_vtx_d0sig->clear();
705 
706  // ## Electrons ##
707  ATH_MSG_DEBUG("Clear: Electrons");
708  m_el_index->clear();
709  m_el_Pt->clear();
710  m_el_et->clear();
711  m_el_Eta->clear();
712  m_el_Phi->clear();
713  m_el_m->clear();
714  m_el_eoverp->clear();
715 
716  // offline shower shapes
717  m_el_f1->clear();
718  m_el_f3->clear();
719  m_el_eratio->clear();
720  m_el_weta1->clear();
721  m_el_weta2->clear();
722  m_el_fracs1->clear();
723  m_el_wtots1->clear();
724  m_el_e277->clear();
725  m_el_reta->clear();
726  m_el_rphi->clear();
727  m_el_deltae->clear();
728  m_el_rhad->clear();
729  m_el_rhad1->clear();
730 
731  // ## Tag and Probe ##
732  //zee
733  if (!m_doElecSelectByTrackOnly && m_doTagAndProbe){
734  ATH_MSG_DEBUG("Clear: T&P");
735  m_zee_M->clear();
736  m_zee_E->clear();
737  m_zee_pt->clear();
738  m_zee_px->clear();
739  m_zee_py->clear();
740  m_zee_pz->clear();
741  m_zee_T->clear();
742  m_zee_deltaR->clear();
743  }
744 }

◆ clearLBData()

void EventReaderBaseAlg::clearLBData ( )
protected

Definition at line 245 of file EventReaderBaseAlg.cxx.

245  {
246  m_lb_lumiblock->clear();
247  if (!m_isMC){
248  m_lb_bcidLuminosity->clear();
249  }
250 }

◆ 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.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ 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.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ 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.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ 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.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ 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.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ deltaPhi()

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

Definition at line 224 of file EventReaderBaseAlg.cxx.

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

◆ deltaR()

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

Definition at line 230 of file EventReaderBaseAlg.cxx.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ eOverPElectron()

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

Definition at line 31 of file EventReaderBaseAlg.cxx.

31  {
32  // the E/p is calculated here based on Electron caloCluster and its associated trackParticle
33  // E_cluster/p_track
34  float eoverp = 0.;
35  float track_p = (electron->trackParticle())->pt()*std::cosh((electron->trackParticle())->eta());
36  if (track_p != 0.) eoverp = (electron->caloCluster())->e()/track_p;
37  else{
38  ATH_MSG_WARNING ("(eOverP) Track_p == 0");
39  return false;
40  }
41  if ((fabs(eoverp) < 0.7) || (fabs(eoverp) > 1.5) ){
42  ATH_MSG_DEBUG ("(eOverP) E/p is out of range! (eoverp="<<eoverp<<").");
43  return false;
44  }
45  else{
46  ATH_MSG_DEBUG ("(eOverP) Passed: E/p="<<eoverp);
47  return true;
48  }
49 }

◆ 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.

85 { 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.

90 { return m_evtStore; }

◆ execute()

StatusCode EventReaderBaseAlg::execute ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 24 of file EventReaderBaseAlg.cxx.

24  {
25  return StatusCode::SUCCESS;
26 }

◆ 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.

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

◆ finalize()

StatusCode EventReaderBaseAlg::finalize ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 27 of file EventReaderBaseAlg.cxx.

27  {
28  return StatusCode::SUCCESS;
29 }

◆ fixPhi()

double EventReaderBaseAlg::fixPhi ( double  phi)
protected

Definition at line 217 of file EventReaderBaseAlg.cxx.

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

◆ getCaloRegionIndex()

int EventReaderBaseAlg::getCaloRegionIndex ( const CaloCell *  cell)
protected

Definition at line 205 of file EventReaderBaseAlg.cxx.

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

◆ initialize()

StatusCode EventReaderBaseAlg::initialize ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 21 of file EventReaderBaseAlg.cxx.

21  {
22  return StatusCode::SUCCESS;
23 }

◆ 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)
protected

Definition at line 196 of file EventReaderBaseAlg.cxx.

196  {
197  if ( (absEta > 1.37 && absEta < 1.52) || (absEta > 2.47) ){
198  return false;
199  }
200  else{
201  return true;
202  }
203 }

◆ isGoodProbeElectron()

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

Definition at line 157 of file EventReaderBaseAlg.cxx.

157  {
158  // |eta| < 1.475
159  if ( fabs(el->eta()) > 1.475 ){ // EM Barrel
160  ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron |eta| > 1.475 (" << fabs(el->eta()) << ").");
161  return false;
162  }
163 
164  // electron object quality
165  ATH_MSG_DEBUG (" (isGoodProbeElectron) Checking Probe electron object quality...");
166  if ( !el->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)){
167  ATH_MSG_DEBUG (" (isGoodProbeElectron) \tProbe Electron is a BADCLUSELECTRON.");
168  return false;
169  }
170 
171  // Et > 15 GeV
172  float electronPt = el->pt();
173  if (electronPt * GeV < m_etMinProbe ){
174  ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Et/pT < " << m_etMinProbe << " GeV (pT="<< electronPt * GeV<<")");
175  return false;
176  }
177 
178  // is outside the crack
179  float absEta = fabs(el->caloCluster()->etaBE(2));
180  if ( !isEtaOutsideLArCrack(absEta) ){
181  ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Eta inside LAr crack region...");
182  return false;
183  }
184 
185  // loose ID Cut
186  bool isGood;
187  if (! el->passSelection(isGood, m_offProbeTightness)){
188  ATH_MSG_DEBUG("(isGoodProbeElectron) Misconfiguration: " << m_offProbeTightness << " is not a valid working point for electrons");
189  return false;
190  }
191 
192  ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron is a good probe!");
193  return true;
194 }

◆ isTagElectron()

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

Definition at line 116 of file EventReaderBaseAlg.cxx.

116  {
117  // |eta| < 1.475
118  if ( fabs(el->eta()) > 1.475 ){ // EM Barrel
119  ATH_MSG_DEBUG ("(isTagElectron) Electron |eta| > 1.475 (" << fabs(el->eta()) << ").");
120  return false;
121  }
122 
123  // LAr crack region
124  // ATH_MSG_DEBUG ("(isTagElectron) Selecting Tag Electron Eta outside crack region...");
125  float absEta = fabs(el->caloCluster()->etaBE(2));
126  if ( !isEtaOutsideLArCrack(absEta) ){
127  ATH_MSG_DEBUG ("(isTagElectron) Selecting Tag Electron Eta is inside crack region.");
128  return false;
129  }
130 
131  // Tag electron PID verify if is tight
132  bool isGood;
133  if (! el->passSelection(isGood, m_offTagTightness) ) {
134  ATH_MSG_DEBUG("(isTagElectron) Misconfiguration: " << m_offTagTightness << " is not a valid working point for electrons");
135  return false; // no point in continuing
136  }
137  ATH_MSG_DEBUG("(isTagElectron) Trigger " << m_offTagTightness << " is OK");
138 
139  // Et > 25 (or 15) GeV && Et < 180
140  float elTagEt = el->e()/(cosh(el->trackParticle()->eta()));
141  float elTagPt = el->pt();
142  if ( elTagPt < (m_etMinTag * GeV) ){
143  ATH_MSG_DEBUG ("(isTagElectron) Tag Electron Et/pT: "<< elTagEt << "/"<< elTagPt << ", threshold =" << m_etMinTag * GeV << ".");
144  return false;
145  }
146 
147  // electron object quality
148  ATH_MSG_DEBUG ("(isTagElectron) Checking electron object quality...");
149  if ( !el->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)){
150  ATH_MSG_DEBUG ("(isTagElectron) \tTag Electron is a BADCLUSELECTRON.");
151  return false;
152  }
153 
154  return true;
155 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ 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.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ 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.

364  {
365  handlesArray.renounce();
366  }

◆ 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.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ 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 
)
protected

Definition at line 52 of file EventReaderBaseAlg.cxx.

52  {
53 
54  const xAOD::TrackParticle *trackElectron = electron->trackParticle();
55  const xAOD::CaloCluster *elClus = electron->caloCluster();
56 
57  if (!trackElectron) { //is there track?
58  ATH_MSG_DEBUG ("(trackSelectionElectrons) No track particle for Tag check.");
59  return false;
60  }
61  // caloCluster
62  if (!elClus){ //is there a calo cluster associated to this electron?
63  ATH_MSG_DEBUG ("(trackSelectionElectrons) No caloCluster associated for Tag check.");
64  return false;
65  }
66 
67  // track_pt > 7 GeV
68  if (! ( (trackElectron->pt() * GeV ) > 7) ){
69  ATH_MSG_DEBUG ("(trackSelectionElectrons) Pt_Track of the electron is below 7 GeV. Electron rejected.");
70  return false;
71  }
72  // |eta| < 2.47
73  if (! (fabs(trackElectron->eta()) < 2.47 )){
74  ATH_MSG_DEBUG ("(trackSelectionElectrons) Electron track_eta is above 2.47. Electron rejected.");
75  return false;
76  }
77 
78  // check for primary vertex in the event
79  // *************** Primary vertex check ***************
80  //loop over vertices and look for good primary vertex
81  bool isPrimVtx = false;
82  bool passDeltaZ0sin = false;
83  // for (xAOD::VertexContainer::const_iterator vxIter = primVertexCnt->begin(); vxIter != primVertexCnt->end(); ++vxIter) {
84  for ( const xAOD::Vertex *vertex : *primVertexCnt){
85  // Select good primary vertex
86  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).
87  float delta_z0_sin = delta_z0 * sin(trackElectron->theta()); //where sin(trk.theta()) parameterises the uncertainty of the z0 measurement.
88 
89  if ((vertex->vertexType() == xAOD::VxType::PriVtx) && ( delta_z0_sin < m_z0Tag)){
90  isPrimVtx = true; //check for primary vertex in each vertex of the event.
91  passDeltaZ0sin = true; // and check if the longitudinal impact parameter difference for electron-to-vertex association.
92 
93  ATH_MSG_DEBUG ("(trackSelectionElectrons) delta_z0_sin < 0.5 mm ("<< delta_z0_sin << ")");
94  ATH_MSG_DEBUG ("(trackSelectionElectrons) There is a primary vertex in the event.");
95  break;
96  }
97  }
98 
99  // delta_z0_sin <= 0.5 mm
100  if (!( isPrimVtx && passDeltaZ0sin)){
101  ATH_MSG_DEBUG ("(trackSelectionElectrons) For this Tag, delta_z0_sin > 0.5mm, and there is NO primary vertices in the event. Rejecting electron.");
102  return false;
103  }
104 
105  // d0_sig - transverse impact parameter significance
106  double d0sig = fabs (xAOD::TrackingHelpers::d0significance( trackElectron, ei->beamPosSigmaX(), ei->beamPosSigmaY(), ei->beamPosSigmaXY() ));
107  if ( !( d0sig < m_d0TagSig)){
108  ATH_MSG_DEBUG("(trackSelectionElectrons) Electron rejected. |d0sig| > " << m_d0TagSig << " ("<< d0sig <<")");
109  return false;
110  }
111 
112  ATH_MSG_DEBUG("(trackSelectionElectrons) Electron accepted.");
113  return true; // if true, add electron to electronSelectionCnt container.
114 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_c711_cellDEta

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

Definition at line 191 of file EventReaderBaseAlg.h.

◆ m_c711_cellDPhi

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

Definition at line 192 of file EventReaderBaseAlg.h.

◆ m_c711_cellEnergy

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

Definition at line 187 of file EventReaderBaseAlg.h.

◆ m_c711_cellEta

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

Definition at line 189 of file EventReaderBaseAlg.h.

◆ m_c711_cellGain

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

Definition at line 184 of file EventReaderBaseAlg.h.

◆ m_c711_cellIndexCounter

int* EventReaderBaseAlg::m_c711_cellIndexCounter = nullptr
protected

Definition at line 181 of file EventReaderBaseAlg.h.

◆ m_c711_cellLayer

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

Definition at line 185 of file EventReaderBaseAlg.h.

◆ m_c711_cellPhi

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

Definition at line 190 of file EventReaderBaseAlg.h.

◆ m_c711_cellRegion

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

Definition at line 186 of file EventReaderBaseAlg.h.

◆ m_c711_cellTime

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

Definition at line 188 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDEta

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

Definition at line 194 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDPhi

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

Definition at line 193 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV0

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

Definition at line 214 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV1

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

Definition at line 215 of file EventReaderBaseAlg.h.

◆ m_c711_channelBad

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

Definition at line 203 of file EventReaderBaseAlg.h.

◆ m_c711_channelChannelIdMap

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

Definition at line 205 of file EventReaderBaseAlg.h.

◆ m_c711_channelChInfo

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

Definition at line 198 of file EventReaderBaseAlg.h.

◆ m_c711_channelDigits

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

Definition at line 199 of file EventReaderBaseAlg.h.

◆ m_c711_channelDSPThreshold

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

Definition at line 208 of file EventReaderBaseAlg.h.

◆ m_c711_channelEffectiveSigma

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

Definition at line 206 of file EventReaderBaseAlg.h.

◆ m_c711_channelEnergy

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

Definition at line 200 of file EventReaderBaseAlg.h.

◆ m_c711_channelHashMap

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

Definition at line 204 of file EventReaderBaseAlg.h.

◆ m_c711_channelLayer

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

Definition at line 202 of file EventReaderBaseAlg.h.

◆ m_c711_channelMinBiasAvg

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

Definition at line 217 of file EventReaderBaseAlg.h.

◆ m_c711_channelNoise

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

Definition at line 207 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCa

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

Definition at line 209 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCb

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

Definition at line 210 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCTimeOffset

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

Definition at line 213 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflEneRescaler

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

Definition at line 219 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflHVScale

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

Definition at line 218 of file EventReaderBaseAlg.h.

◆ m_c711_channelPed

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

Definition at line 216 of file EventReaderBaseAlg.h.

◆ m_c711_channelShape

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

Definition at line 211 of file EventReaderBaseAlg.h.

◆ m_c711_channelShapeDer

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

Definition at line 212 of file EventReaderBaseAlg.h.

◆ m_c711_channelTime

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

Definition at line 201 of file EventReaderBaseAlg.h.

◆ m_c711_clusterCellIndex

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

Definition at line 183 of file EventReaderBaseAlg.h.

◆ m_c711_clusterChannelIndex

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

Definition at line 197 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEnergy

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

Definition at line 174 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEta

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

Definition at line 176 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex

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

Definition at line 172 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_cellLvl

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

Definition at line 182 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_chLvl

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

Definition at line 196 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_rawChLvl

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

Definition at line 230 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndexCounter

int* EventReaderBaseAlg::m_c711_clusterIndexCounter = 0
protected

Definition at line 171 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPhi

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

Definition at line 177 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPt

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

Definition at line 178 of file EventReaderBaseAlg.h.

◆ m_c711_clusterRawChannelIndex

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

Definition at line 229 of file EventReaderBaseAlg.h.

◆ m_c711_clusterTime

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

Definition at line 175 of file EventReaderBaseAlg.h.

◆ m_c711_electronIndex_clusterLvl

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

Definition at line 173 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelAmplitude

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

Definition at line 223 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelChInfo

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

Definition at line 221 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelDSPThreshold

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

Definition at line 231 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelIdMap

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

Definition at line 222 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelLayer

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

Definition at line 225 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelPed

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

Definition at line 226 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelProv

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

Definition at line 227 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelQuality

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

Definition at line 228 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelTime

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

Definition at line 224 of file EventReaderBaseAlg.h.

◆ m_c_cellDEta

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

Definition at line 112 of file EventReaderBaseAlg.h.

◆ m_c_cellDPhi

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

Definition at line 113 of file EventReaderBaseAlg.h.

◆ m_c_cellEnergy

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

Definition at line 108 of file EventReaderBaseAlg.h.

◆ m_c_cellEta

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

Definition at line 110 of file EventReaderBaseAlg.h.

◆ m_c_cellGain

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

Definition at line 105 of file EventReaderBaseAlg.h.

◆ m_c_cellIndexCounter

int EventReaderBaseAlg::m_c_cellIndexCounter = 0
protected

Definition at line 102 of file EventReaderBaseAlg.h.

◆ m_c_cellLayer

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

Definition at line 106 of file EventReaderBaseAlg.h.

◆ m_c_cellPhi

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

Definition at line 111 of file EventReaderBaseAlg.h.

◆ m_c_cellRegion

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

Definition at line 107 of file EventReaderBaseAlg.h.

◆ m_c_cellTime

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

Definition at line 109 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDEta

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

Definition at line 115 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDPhi

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

Definition at line 114 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV0

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

Definition at line 135 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV1

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

Definition at line 136 of file EventReaderBaseAlg.h.

◆ m_c_channelBad

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

Definition at line 124 of file EventReaderBaseAlg.h.

◆ m_c_channelChannelIdMap

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

Definition at line 126 of file EventReaderBaseAlg.h.

◆ m_c_channelChInfo

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

Definition at line 119 of file EventReaderBaseAlg.h.

◆ m_c_channelDigits

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

Definition at line 120 of file EventReaderBaseAlg.h.

◆ m_c_channelDSPThreshold

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

Definition at line 129 of file EventReaderBaseAlg.h.

◆ m_c_channelEffectiveSigma

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

Definition at line 127 of file EventReaderBaseAlg.h.

◆ m_c_channelEnergy

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

Definition at line 121 of file EventReaderBaseAlg.h.

◆ m_c_channelHashMap

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

Definition at line 125 of file EventReaderBaseAlg.h.

◆ m_c_channelLayer

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

Definition at line 123 of file EventReaderBaseAlg.h.

◆ m_c_channelMinBiasAvg

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

Definition at line 138 of file EventReaderBaseAlg.h.

◆ m_c_channelNoise

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

Definition at line 128 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCa

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

Definition at line 130 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCb

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

Definition at line 131 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCTimeOffset

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

Definition at line 134 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflEneRescaler

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

Definition at line 140 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflHVScale

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

Definition at line 139 of file EventReaderBaseAlg.h.

◆ m_c_channelPed

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

Definition at line 137 of file EventReaderBaseAlg.h.

◆ m_c_channelShape

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

Definition at line 132 of file EventReaderBaseAlg.h.

◆ m_c_channelShapeDer

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

Definition at line 133 of file EventReaderBaseAlg.h.

◆ m_c_channelTime

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

Definition at line 122 of file EventReaderBaseAlg.h.

◆ m_c_clusterCellIndex

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

Definition at line 104 of file EventReaderBaseAlg.h.

◆ m_c_clusterChannelIndex

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

Definition at line 118 of file EventReaderBaseAlg.h.

◆ m_c_clusterEnergy

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

Definition at line 96 of file EventReaderBaseAlg.h.

◆ m_c_clusterEta

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

Definition at line 98 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex

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

Definition at line 94 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_cellLvl

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

Definition at line 103 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_chLvl

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

Definition at line 117 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_rawChLvl

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

Definition at line 152 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndexCounter

int EventReaderBaseAlg::m_c_clusterIndexCounter = 0
protected

Definition at line 93 of file EventReaderBaseAlg.h.

◆ m_c_clusterPhi

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

Definition at line 99 of file EventReaderBaseAlg.h.

◆ m_c_clusterPt

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

Definition at line 100 of file EventReaderBaseAlg.h.

◆ m_c_clusterRawChannelIndex

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

Definition at line 151 of file EventReaderBaseAlg.h.

◆ m_c_clusterTime

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

Definition at line 97 of file EventReaderBaseAlg.h.

◆ m_c_electronIndex_clusterLvl

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

Definition at line 95 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelAmplitude

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

Definition at line 145 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelChInfo

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

Definition at line 143 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelDSPThreshold

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

Definition at line 153 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelIdMap

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

Definition at line 144 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelLayer

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

Definition at line 147 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelPed

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

Definition at line 148 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelProv

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

Definition at line 149 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelQuality

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

Definition at line 150 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelTime

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

Definition at line 146 of file EventReaderBaseAlg.h.

◆ m_d0TagSig

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

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."}
protected

Definition at line 67 of file EventReaderBaseAlg.h.

◆ m_doElecSelectByTrackOnly

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

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."}
protected

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."}
protected

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."}
protected

Definition at line 59 of file EventReaderBaseAlg.h.

◆ m_doTruthEventDump

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

Definition at line 61 of file EventReaderBaseAlg.h.

◆ m_doTruthPartDump

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

Definition at line 62 of file EventReaderBaseAlg.h.

◆ m_e_bcid

unsigned int EventReaderBaseAlg::m_e_bcid = 9999
protected

Definition at line 86 of file EventReaderBaseAlg.h.

◆ m_e_eventNumber

unsigned long long EventReaderBaseAlg::m_e_eventNumber = 9999
protected

Definition at line 87 of file EventReaderBaseAlg.h.

◆ m_e_inTimePileup

float EventReaderBaseAlg::m_e_inTimePileup = -999
protected

Definition at line 89 of file EventReaderBaseAlg.h.

◆ m_e_lumiBlock

int EventReaderBaseAlg::m_e_lumiBlock = 999
protected

Definition at line 88 of file EventReaderBaseAlg.h.

◆ m_e_outOfTimePileUp

float EventReaderBaseAlg::m_e_outOfTimePileUp = -999
protected

Definition at line 90 of file EventReaderBaseAlg.h.

◆ m_e_runNumber

unsigned int EventReaderBaseAlg::m_e_runNumber = 9999
protected

Definition at line 85 of file EventReaderBaseAlg.h.

◆ m_el_deltae

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

Definition at line 288 of file EventReaderBaseAlg.h.

◆ m_el_e277

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

Definition at line 285 of file EventReaderBaseAlg.h.

◆ m_el_eoverp

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

Definition at line 276 of file EventReaderBaseAlg.h.

◆ m_el_eratio

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

Definition at line 280 of file EventReaderBaseAlg.h.

◆ m_el_et

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

Definition at line 272 of file EventReaderBaseAlg.h.

◆ m_el_Eta

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

Definition at line 273 of file EventReaderBaseAlg.h.

◆ m_el_f1

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

Definition at line 278 of file EventReaderBaseAlg.h.

◆ m_el_f3

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

Definition at line 279 of file EventReaderBaseAlg.h.

◆ m_el_fracs1

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

Definition at line 283 of file EventReaderBaseAlg.h.

◆ m_el_index

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

Definition at line 270 of file EventReaderBaseAlg.h.

◆ m_el_m

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

Definition at line 275 of file EventReaderBaseAlg.h.

◆ m_el_Phi

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

Definition at line 274 of file EventReaderBaseAlg.h.

◆ m_el_Pt

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

Definition at line 271 of file EventReaderBaseAlg.h.

◆ m_el_reta

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

Definition at line 286 of file EventReaderBaseAlg.h.

◆ m_el_rhad

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

Definition at line 289 of file EventReaderBaseAlg.h.

◆ m_el_rhad1

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

Definition at line 290 of file EventReaderBaseAlg.h.

◆ m_el_rphi

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

Definition at line 287 of file EventReaderBaseAlg.h.

◆ m_el_weta1

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

Definition at line 281 of file EventReaderBaseAlg.h.

◆ m_el_weta2

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

Definition at line 282 of file EventReaderBaseAlg.h.

◆ m_el_wtots1

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

Definition at line 284 of file EventReaderBaseAlg.h.

◆ m_elecEtaCut

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

Definition at line 51 of file EventReaderBaseAlg.h.

◆ m_etMinProbe

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

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)."}
protected

Definition at line 55 of file EventReaderBaseAlg.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_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)."}
protected

Definition at line 65 of file EventReaderBaseAlg.h.

◆ m_hits_cellEta

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

Definition at line 166 of file EventReaderBaseAlg.h.

◆ m_hits_cellPhi

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

Definition at line 167 of file EventReaderBaseAlg.h.

◆ m_hits_clusterChannelIndex

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

Definition at line 160 of file EventReaderBaseAlg.h.

◆ m_hits_clusterIndex_chLvl

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

Definition at line 159 of file EventReaderBaseAlg.h.

◆ m_hits_energy

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

Definition at line 162 of file EventReaderBaseAlg.h.

◆ m_hits_energyConv

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

Definition at line 165 of file EventReaderBaseAlg.h.

◆ m_hits_hash

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

Definition at line 161 of file EventReaderBaseAlg.h.

◆ m_hits_sampFrac

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

Definition at line 164 of file EventReaderBaseAlg.h.

◆ m_hits_sampling

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

Definition at line 158 of file EventReaderBaseAlg.h.

◆ m_hits_time

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

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."}
protected

Definition at line 64 of file EventReaderBaseAlg.h.

◆ m_lb_bcidLuminosity

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

Definition at line 81 of file EventReaderBaseAlg.h.

◆ m_lb_lumiblock

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

Definition at line 82 of file EventReaderBaseAlg.h.

◆ m_mc_part_barcode

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

Definition at line 241 of file EventReaderBaseAlg.h.

◆ m_mc_part_energy

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

Definition at line 234 of file EventReaderBaseAlg.h.

◆ m_mc_part_eta

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

Definition at line 237 of file EventReaderBaseAlg.h.

◆ m_mc_part_m

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

Definition at line 236 of file EventReaderBaseAlg.h.

◆ m_mc_part_pdgId

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

Definition at line 239 of file EventReaderBaseAlg.h.

◆ m_mc_part_phi

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

Definition at line 238 of file EventReaderBaseAlg.h.

◆ m_mc_part_pt

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

Definition at line 235 of file EventReaderBaseAlg.h.

◆ m_mc_part_status

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

Definition at line 240 of file EventReaderBaseAlg.h.

◆ m_mc_vert_barcode

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

Definition at line 251 of file EventReaderBaseAlg.h.

◆ m_mc_vert_eta

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

Definition at line 249 of file EventReaderBaseAlg.h.

◆ m_mc_vert_perp

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

Definition at line 248 of file EventReaderBaseAlg.h.

◆ m_mc_vert_phi

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

Definition at line 250 of file EventReaderBaseAlg.h.

◆ m_mc_vert_status

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

Definition at line 252 of file EventReaderBaseAlg.h.

◆ m_mc_vert_time

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

Definition at line 247 of file EventReaderBaseAlg.h.

◆ m_mc_vert_x

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

Definition at line 244 of file EventReaderBaseAlg.h.

◆ m_mc_vert_y

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

Definition at line 245 of file EventReaderBaseAlg.h.

◆ m_mc_vert_z

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

Definition at line 246 of file EventReaderBaseAlg.h.

◆ m_minEnergy

const double EventReaderBaseAlg::m_minEnergy = 1e-9
protected

Definition at line 157 of file EventReaderBaseAlg.h.

◆ m_ncell

size_t EventReaderBaseAlg::m_ncell = 0
protected

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."}
protected

Definition at line 66 of file EventReaderBaseAlg.h.

◆ m_offProbeTightness

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

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"}
protected

Definition at line 52 of file EventReaderBaseAlg.h.

◆ m_ph_energy

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

Definition at line 266 of file EventReaderBaseAlg.h.

◆ m_ph_eta

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

Definition at line 263 of file EventReaderBaseAlg.h.

◆ m_ph_m

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

Definition at line 267 of file EventReaderBaseAlg.h.

◆ m_ph_phi

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

Definition at line 264 of file EventReaderBaseAlg.h.

◆ m_ph_pt

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

Definition at line 265 of file EventReaderBaseAlg.h.

◆ m_secondTree

TTree* EventReaderBaseAlg::m_secondTree {}
protected

Definition at line 74 of file EventReaderBaseAlg.h.

◆ m_tp_electronEt

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

Definition at line 294 of file EventReaderBaseAlg.h.

◆ m_tp_electronEta

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

Definition at line 295 of file EventReaderBaseAlg.h.

◆ m_tp_electronPhi

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

Definition at line 296 of file EventReaderBaseAlg.h.

◆ m_tp_electronPt

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

Definition at line 293 of file EventReaderBaseAlg.h.

◆ m_tp_isProbe

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

Definition at line 301 of file EventReaderBaseAlg.h.

◆ m_tp_isTag

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

Definition at line 300 of file EventReaderBaseAlg.h.

◆ m_tp_probeIndex

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

Definition at line 298 of file EventReaderBaseAlg.h.

◆ m_tp_tagIndex

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

Definition at line 299 of file EventReaderBaseAlg.h.

◆ m_Tree

TTree* EventReaderBaseAlg::m_Tree {}
protected

Definition at line 73 of file EventReaderBaseAlg.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
protected

Definition at line 260 of file EventReaderBaseAlg.h.

◆ m_vtx_delta_z0_sin

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

Definition at line 259 of file EventReaderBaseAlg.h.

◆ m_vtx_deltaZ0

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

Definition at line 258 of file EventReaderBaseAlg.h.

◆ m_vtx_x

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

Definition at line 255 of file EventReaderBaseAlg.h.

◆ m_vtx_y

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

Definition at line 256 of file EventReaderBaseAlg.h.

◆ m_vtx_z

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

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)"}
protected

Definition at line 57 of file EventReaderBaseAlg.h.

◆ m_zee_deltaR

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

Definition at line 310 of file EventReaderBaseAlg.h.

◆ m_zee_E

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

Definition at line 304 of file EventReaderBaseAlg.h.

◆ m_zee_M

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

Definition at line 303 of file EventReaderBaseAlg.h.

◆ m_zee_pt

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

Definition at line 305 of file EventReaderBaseAlg.h.

◆ m_zee_px

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

Definition at line 306 of file EventReaderBaseAlg.h.

◆ m_zee_py

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

Definition at line 307 of file EventReaderBaseAlg.h.

◆ m_zee_pz

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

Definition at line 308 of file EventReaderBaseAlg.h.

◆ m_zee_T

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

Definition at line 309 of file EventReaderBaseAlg.h.

The documentation for this class was generated from the following files:
EventReaderBaseAlg::m_c711_clusterPt
std::vector< double > * m_c711_clusterPt
Definition: EventReaderBaseAlg.h:178
EventReaderBaseAlg::fixPhi
double fixPhi(double phi)
Definition: EventReaderBaseAlg.cxx:217
EventReaderBaseAlg::m_isMC
Gaudi::Property< bool > m_isMC
Definition: EventReaderBaseAlg.h:64
EventReaderBaseAlg::m_zee_E
std::vector< double > * m_zee_E
Definition: EventReaderBaseAlg.h:304
EventReaderBaseAlg::m_el_Phi
std::vector< float > * m_el_Phi
Definition: EventReaderBaseAlg.h:274
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
EventReaderBaseAlg::m_el_deltae
std::vector< float > * m_el_deltae
Definition: EventReaderBaseAlg.h:288
EventReaderBaseAlg::m_c711_channelDigits
std::vector< std::vector< float > > * m_c711_channelDigits
Definition: EventReaderBaseAlg.h:199
EventReaderBaseAlg::m_c711_channelBad
std::vector< bool > * m_c711_channelBad
Definition: EventReaderBaseAlg.h:203
EventReaderBaseAlg::m_el_eoverp
std::vector< float > * m_el_eoverp
Definition: EventReaderBaseAlg.h:276
EventReaderBaseAlg::m_noBadCells
Gaudi::Property< bool > m_noBadCells
Definition: EventReaderBaseAlg.h:66
EventReaderBaseAlg::m_zee_pz
std::vector< double > * m_zee_pz
Definition: EventReaderBaseAlg.h:308
EventReaderBaseAlg::m_c_channelShapeDer
std::vector< std::vector< double > > * m_c_channelShapeDer
Definition: EventReaderBaseAlg.h:133
EventReaderBaseAlg::m_ph_eta
std::vector< float > * m_ph_eta
Definition: EventReaderBaseAlg.h:263
EventReaderBaseAlg::m_c_clusterPhi
std::vector< double > * m_c_clusterPhi
Definition: EventReaderBaseAlg.h:99
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
EventReaderBaseAlg::m_c_cellRegion
std::vector< int > * m_c_cellRegion
Definition: EventReaderBaseAlg.h:107
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
EventReaderBaseAlg::m_c711_channelADC2MEV0
std::vector< float > * m_c711_channelADC2MEV0
Definition: EventReaderBaseAlg.h:214
EventReaderBaseAlg::m_mc_part_m
std::vector< float > * m_mc_part_m
Definition: EventReaderBaseAlg.h:236
EventReaderBaseAlg::m_c_clusterIndex_chLvl
std::vector< int > * m_c_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:117
EventReaderBaseAlg::m_mc_part_energy
std::vector< float > * m_mc_part_energy
Definition: EventReaderBaseAlg.h:234
EventReaderBaseAlg::m_c_rawChannelAmplitude
std::vector< float > * m_c_rawChannelAmplitude
Definition: EventReaderBaseAlg.h:145
EventReaderBaseAlg::m_hits_hash
std::vector< unsigned int > * m_hits_hash
Definition: EventReaderBaseAlg.h:161
EventReaderBaseAlg::m_c711_clusterRawChannelIndex
std::vector< float > * m_c711_clusterRawChannelIndex
Definition: EventReaderBaseAlg.h:229
EventReaderBaseAlg::m_c_channelPed
std::vector< float > * m_c_channelPed
Definition: EventReaderBaseAlg.h:137
EventReaderBaseAlg::isEtaOutsideLArCrack
bool isEtaOutsideLArCrack(float absEta)
Definition: EventReaderBaseAlg.cxx:196
EventReaderBaseAlg::m_c711_clusterEta
std::vector< double > * m_c711_clusterEta
Definition: EventReaderBaseAlg.h:176
EventReaderBaseAlg::m_mc_vert_z
std::vector< float > * m_mc_vert_z
Definition: EventReaderBaseAlg.h:246
EventReaderBaseAlg::m_c711_clusterEnergy
std::vector< double > * m_c711_clusterEnergy
Definition: EventReaderBaseAlg.h:174
EventReaderBaseAlg::m_c_rawChannelProv
std::vector< float > * m_c_rawChannelProv
Definition: EventReaderBaseAlg.h:149
EventReaderBaseAlg::m_c_channelChInfo
std::vector< std::vector< int > > * m_c_channelChInfo
Definition: EventReaderBaseAlg.h:119
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
EventReaderBaseAlg::m_c711_rawChannelLayer
std::vector< int > * m_c711_rawChannelLayer
Definition: EventReaderBaseAlg.h:225
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
EventReaderBaseAlg::m_c_channelBad
std::vector< bool > * m_c_channelBad
Definition: EventReaderBaseAlg.h:124
EventReaderBaseAlg::m_c711_channelOfflHVScale
std::vector< float > * m_c711_channelOfflHVScale
Definition: EventReaderBaseAlg.h:218
EventReaderBaseAlg::m_el_fracs1
std::vector< float > * m_el_fracs1
Definition: EventReaderBaseAlg.h:283
EventReaderBaseAlg::m_c_channelMinBiasAvg
std::vector< float > * m_c_channelMinBiasAvg
Definition: EventReaderBaseAlg.h:138
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
EventReaderBaseAlg::m_c711_rawChannelDSPThreshold
std::vector< float > * m_c711_rawChannelDSPThreshold
Definition: EventReaderBaseAlg.h:231
EventReaderBaseAlg::m_doLArEMBHitsDump
Gaudi::Property< bool > m_doLArEMBHitsDump
Definition: EventReaderBaseAlg.h:63
EventReaderBaseAlg::m_c711_cellTime
std::vector< double > * m_c711_cellTime
Definition: EventReaderBaseAlg.h:188
EventReaderBaseAlg::m_c711_channelChannelIdMap
std::vector< unsigned int > * m_c711_channelChannelIdMap
Definition: EventReaderBaseAlg.h:205
tree
TChain * tree
Definition: tile_monitor.h:30
EventReaderBaseAlg::m_c711_clusterIndex_rawChLvl
std::vector< int > * m_c711_clusterIndex_rawChLvl
Definition: EventReaderBaseAlg.h:230
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition: TrackParticlexAODHelpers.cxx:42
EventReaderBaseAlg::m_c_channelOfflHVScale
std::vector< float > * m_c_channelOfflHVScale
Definition: EventReaderBaseAlg.h:139
EventReaderBaseAlg::m_c_cellToClusterDPhi
std::vector< double > * m_c_cellToClusterDPhi
Definition: EventReaderBaseAlg.h:114
EventReaderBaseAlg::m_c_channelOFCa
std::vector< std::vector< double > > * m_c_channelOFCa
Definition: EventReaderBaseAlg.h:130
test_pyathena.pt
pt
Definition: test_pyathena.py:11
EventReaderBaseAlg::m_hits_cellPhi
std::vector< double > * m_hits_cellPhi
Definition: EventReaderBaseAlg.h:167
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
EventReaderBaseAlg::m_c711_rawChannelAmplitude
std::vector< float > * m_c711_rawChannelAmplitude
Definition: EventReaderBaseAlg.h:223
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
EventReaderBaseAlg::m_c_clusterIndexCounter
int m_c_clusterIndexCounter
Definition: EventReaderBaseAlg.h:93
EventReaderBaseAlg::m_c711_rawChannelTime
std::vector< float > * m_c711_rawChannelTime
Definition: EventReaderBaseAlg.h:224
xAOD::EventInfo_v1::beamPosSigmaX
float beamPosSigmaX() const
The width of the beam spot in the X direction.
EventReaderBaseAlg::m_mc_vert_status
std::vector< int > * m_mc_vert_status
Definition: EventReaderBaseAlg.h:252
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition: EgammaDefs.h:116
EventReaderBaseAlg::m_c_electronIndex_clusterLvl
std::vector< int > * m_c_electronIndex_clusterLvl
Definition: EventReaderBaseAlg.h:95
EventReaderBaseAlg::m_doPhotonDump
Gaudi::Property< bool > m_doPhotonDump
Definition: EventReaderBaseAlg.h:60
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
EventReaderBaseAlg::m_e_lumiBlock
int m_e_lumiBlock
Definition: EventReaderBaseAlg.h:88
EventReaderBaseAlg::m_el_weta2
std::vector< float > * m_el_weta2
Definition: EventReaderBaseAlg.h:282
EventReaderBaseAlg::m_c_cellPhi
std::vector< double > * m_c_cellPhi
Definition: EventReaderBaseAlg.h:111
EventReaderBaseAlg::m_doTruthPartDump
Gaudi::Property< bool > m_doTruthPartDump
Definition: EventReaderBaseAlg.h:62
EventReaderBaseAlg::m_c711_cellRegion
std::vector< int > * m_c711_cellRegion
Definition: EventReaderBaseAlg.h:186
EventReaderBaseAlg::m_c_channelTime
std::vector< double > * m_c_channelTime
Definition: EventReaderBaseAlg.h:122
EventReaderBaseAlg::m_hits_clusterChannelIndex
std::vector< int > * m_hits_clusterChannelIndex
Definition: EventReaderBaseAlg.h:160
EventReaderBaseAlg::m_c_clusterPt
std::vector< double > * m_c_clusterPt
Definition: EventReaderBaseAlg.h:100
EventReaderBaseAlg::m_c711_cellDPhi
std::vector< double > * m_c711_cellDPhi
Definition: EventReaderBaseAlg.h:192
EventReaderBaseAlg::m_c_cellEta
std::vector< double > * m_c_cellEta
Definition: EventReaderBaseAlg.h:110
EventReaderBaseAlg::m_el_m
std::vector< float > * m_el_m
Definition: EventReaderBaseAlg.h:275
EventReaderBaseAlg::m_mc_vert_phi
std::vector< float > * m_mc_vert_phi
Definition: EventReaderBaseAlg.h:250
EventReaderBaseAlg::m_hits_clusterIndex_chLvl
std::vector< int > * m_hits_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:159
EventReaderBaseAlg::m_el_f3
std::vector< float > * m_el_f3
Definition: EventReaderBaseAlg.h:279
EventReaderBaseAlg::m_c711_rawChannelPed
std::vector< float > * m_c711_rawChannelPed
Definition: EventReaderBaseAlg.h:226
pi
#define pi
Definition: TileMuonFitter.cxx:65
EventReaderBaseAlg::m_doAssocTopoCluster711Dump
Gaudi::Property< bool > m_doAssocTopoCluster711Dump
Definition: EventReaderBaseAlg.h:67
EventReaderBaseAlg::m_c711_clusterChannelIndex
std::vector< int > * m_c711_clusterChannelIndex
Definition: EventReaderBaseAlg.h:197
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EventReaderBaseAlg::m_e_outOfTimePileUp
float m_e_outOfTimePileUp
Definition: EventReaderBaseAlg.h:90
EventReaderBaseAlg::m_c711_cellToClusterDPhi
std::vector< double > * m_c711_cellToClusterDPhi
Definition: EventReaderBaseAlg.h:193
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
EventReaderBaseAlg::m_c711_electronIndex_clusterLvl
std::vector< int > * m_c711_electronIndex_clusterLvl
Definition: EventReaderBaseAlg.h:173
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
EventReaderBaseAlg::m_c_channelDSPThreshold
std::vector< float > * m_c_channelDSPThreshold
Definition: EventReaderBaseAlg.h:129
EventReaderBaseAlg::m_c_cellEnergy
std::vector< double > * m_c_cellEnergy
Definition: EventReaderBaseAlg.h:108
EventReaderBaseAlg::m_hits_sampFrac
std::vector< float > * m_hits_sampFrac
Definition: EventReaderBaseAlg.h:164
EventReaderBaseAlg::m_hits_time
std::vector< double > * m_hits_time
Definition: EventReaderBaseAlg.h:163
EventReaderBaseAlg::m_mc_part_eta
std::vector< float > * m_mc_part_eta
Definition: EventReaderBaseAlg.h:237
EventReaderBaseAlg::m_c711_rawChannelProv
std::vector< float > * m_c711_rawChannelProv
Definition: EventReaderBaseAlg.h:227
EventReaderBaseAlg::m_c_cellIndexCounter
int m_c_cellIndexCounter
Definition: EventReaderBaseAlg.h:102
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
EventReaderBaseAlg::m_c711_channelLayer
std::vector< int > * m_c711_channelLayer
Definition: EventReaderBaseAlg.h:202
EventReaderBaseAlg::m_mc_part_status
std::vector< int > * m_mc_part_status
Definition: EventReaderBaseAlg.h:240
EventReaderBaseAlg::m_c_channelADC2MEV0
std::vector< float > * m_c_channelADC2MEV0
Definition: EventReaderBaseAlg.h:135
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
EventReaderBaseAlg::m_c_channelLayer
std::vector< int > * m_c_channelLayer
Definition: EventReaderBaseAlg.h:123
EventReaderBaseAlg::m_el_eratio
std::vector< float > * m_el_eratio
Definition: EventReaderBaseAlg.h:280
EventReaderBaseAlg::m_el_reta
std::vector< float > * m_el_reta
Definition: EventReaderBaseAlg.h:286
AthCommonDataStore
Definition: AthCommonDataStore.h:52
EventReaderBaseAlg::m_c_rawChannelLayer
std::vector< int > * m_c_rawChannelLayer
Definition: EventReaderBaseAlg.h:147
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
EventReaderBaseAlg::m_c711_channelMinBiasAvg
std::vector< float > * m_c711_channelMinBiasAvg
Definition: EventReaderBaseAlg.h:217
EventReaderBaseAlg::m_el_f1
std::vector< float > * m_el_f1
Definition: EventReaderBaseAlg.h:278
EventReaderBaseAlg::m_c_cellDPhi
std::vector< double > * m_c_cellDPhi
Definition: EventReaderBaseAlg.h:113
EventReaderBaseAlg::m_el_weta1
std::vector< float > * m_el_weta1
Definition: EventReaderBaseAlg.h:281
EventReaderBaseAlg::m_hits_sampling
std::vector< int > * m_hits_sampling
Definition: EventReaderBaseAlg.h:158
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
EventReaderBaseAlg::m_c_clusterEnergy
std::vector< double > * m_c_clusterEnergy
Definition: EventReaderBaseAlg.h:96
EventReaderBaseAlg::m_mc_vert_time
std::vector< float > * m_mc_vert_time
Definition: EventReaderBaseAlg.h:247
EventReaderBaseAlg::m_vtx_delta_z0_sin
std::vector< float > * m_vtx_delta_z0_sin
Definition: EventReaderBaseAlg.h:259
EventReaderBaseAlg::m_c_channelChannelIdMap
std::vector< unsigned int > * m_c_channelChannelIdMap
Definition: EventReaderBaseAlg.h:126
EventReaderBaseAlg::m_c711_clusterIndex_cellLvl
std::vector< int > * m_c711_clusterIndex_cellLvl
Definition: EventReaderBaseAlg.h:182
EventReaderBaseAlg::m_vtx_d0sig
std::vector< double > * m_vtx_d0sig
Definition: EventReaderBaseAlg.h:260
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
EventReaderBaseAlg::m_c_cellToClusterDEta
std::vector< double > * m_c_cellToClusterDEta
Definition: EventReaderBaseAlg.h:115
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EventReaderBaseAlg::m_c711_channelEnergy
std::vector< double > * m_c711_channelEnergy
Definition: EventReaderBaseAlg.h:200
EventReaderBaseAlg::m_doTagAndProbe
Gaudi::Property< bool > m_doTagAndProbe
Definition: EventReaderBaseAlg.h:59
EventReaderBaseAlg::m_c_channelHashMap
std::vector< unsigned int > * m_c_channelHashMap
Definition: EventReaderBaseAlg.h:125
EventReaderBaseAlg::m_c_channelNoise
std::vector< float > * m_c_channelNoise
Definition: EventReaderBaseAlg.h:128
EventReaderBaseAlg::m_c_cellTime
std::vector< double > * m_c_cellTime
Definition: EventReaderBaseAlg.h:109
EventReaderBaseAlg::m_ph_pt
std::vector< float > * m_ph_pt
Definition: EventReaderBaseAlg.h:265
EventReaderBaseAlg::m_c_rawChannelTime
std::vector< float > * m_c_rawChannelTime
Definition: EventReaderBaseAlg.h:146
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
EventReaderBaseAlg::m_c_rawChannelIdMap
std::vector< unsigned int > * m_c_rawChannelIdMap
Definition: EventReaderBaseAlg.h:144
EventReaderBaseAlg::m_hits_energy
std::vector< double > * m_hits_energy
Definition: EventReaderBaseAlg.h:162
EventReaderBaseAlg::m_el_rphi
std::vector< float > * m_el_rphi
Definition: EventReaderBaseAlg.h:287
EventReaderBaseAlg::m_mc_vert_perp
std::vector< float > * m_mc_vert_perp
Definition: EventReaderBaseAlg.h:248
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
EventReaderBaseAlg::m_c_channelEnergy
std::vector< double > * m_c_channelEnergy
Definition: EventReaderBaseAlg.h:121
EventReaderBaseAlg::m_offProbeTightness
Gaudi::Property< std::string > m_offProbeTightness
Define the PID for tag electron.
Definition: EventReaderBaseAlg.h:53
EventReaderBaseAlg::m_c711_clusterIndex_chLvl
std::vector< int > * m_c711_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:196
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
EventReaderBaseAlg::m_mc_vert_y
std::vector< float > * m_mc_vert_y
Definition: EventReaderBaseAlg.h:245
EventReaderBaseAlg::m_mc_vert_x
std::vector< float > * m_mc_vert_x
Definition: EventReaderBaseAlg.h:244
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::EventInfo_v1::beamPosSigmaY
float beamPosSigmaY() const
The width of the beam spot in the Y direction.
EventReaderBaseAlg::m_c711_cellToClusterDEta
std::vector< double > * m_c711_cellToClusterDEta
Definition: EventReaderBaseAlg.h:194
EventReaderBaseAlg::m_etMinTag
Gaudi::Property< float > m_etMinTag
Definition: EventReaderBaseAlg.h:55
EventReaderBaseAlg::m_c711_cellEnergy
std::vector< double > * m_c711_cellEnergy
Definition: EventReaderBaseAlg.h:187
EventReaderBaseAlg::m_zee_T
std::vector< double > * m_zee_T
Definition: EventReaderBaseAlg.h:309
EventReaderBaseAlg::m_c_cellLayer
std::vector< int > * m_c_cellLayer
Definition: EventReaderBaseAlg.h:106
EventReaderBaseAlg::m_c_rawChannelChInfo
std::vector< std::vector< int > > * m_c_rawChannelChInfo
Definition: EventReaderBaseAlg.h:143
EventReaderBaseAlg::m_c711_channelShapeDer
std::vector< std::vector< double > > * m_c711_channelShapeDer
Definition: EventReaderBaseAlg.h:212
EventReaderBaseAlg::m_c_clusterIndex_cellLvl
std::vector< int > * m_c_clusterIndex_cellLvl
Definition: EventReaderBaseAlg.h:103
EventReaderBaseAlg::m_mc_vert_barcode
std::vector< int > * m_mc_vert_barcode
Definition: EventReaderBaseAlg.h:251
EventReaderBaseAlg::m_e_inTimePileup
float m_e_inTimePileup
Definition: EventReaderBaseAlg.h:89
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
EventReaderBaseAlg::m_mc_vert_eta
std::vector< float > * m_mc_vert_eta
Definition: EventReaderBaseAlg.h:249
EventReaderBaseAlg::m_e_runNumber
unsigned int m_e_runNumber
Definition: EventReaderBaseAlg.h:85
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
EventReaderBaseAlg::m_c711_channelChInfo
std::vector< std::vector< int > > * m_c711_channelChInfo
Definition: EventReaderBaseAlg.h:198
EventReaderBaseAlg::m_c_rawChannelDSPThreshold
std::vector< float > * m_c_rawChannelDSPThreshold
Definition: EventReaderBaseAlg.h:153
EventReaderBaseAlg::m_mc_part_phi
std::vector< float > * m_mc_part_phi
Definition: EventReaderBaseAlg.h:238
EventReaderBaseAlg::m_c711_channelOfflEneRescaler
std::vector< float > * m_c711_channelOfflEneRescaler
Definition: EventReaderBaseAlg.h:219
EventReaderBaseAlg::m_c_channelShape
std::vector< std::vector< double > > * m_c_channelShape
Definition: EventReaderBaseAlg.h:132
EventReaderBaseAlg::m_c711_channelShape
std::vector< std::vector< double > > * m_c711_channelShape
Definition: EventReaderBaseAlg.h:211
EventReaderBaseAlg::m_c_channelOFCTimeOffset
std::vector< double > * m_c_channelOFCTimeOffset
Definition: EventReaderBaseAlg.h:134
EventReaderBaseAlg::m_c_cellDEta
std::vector< double > * m_c_cellDEta
Definition: EventReaderBaseAlg.h:112
EventReaderBaseAlg::m_d0TagSig
Gaudi::Property< float > m_d0TagSig
Definition: EventReaderBaseAlg.h:56
EventReaderBaseAlg::deltaPhi
double deltaPhi(double phi1, double phi2)
Definition: EventReaderBaseAlg.cxx:224
EventReaderBaseAlg::m_zee_M
std::vector< double > * m_zee_M
Definition: EventReaderBaseAlg.h:303
EventReaderBaseAlg::m_el_wtots1
std::vector< float > * m_el_wtots1
Definition: EventReaderBaseAlg.h:284
EventReaderBaseAlg::m_ph_phi
std::vector< float > * m_ph_phi
Definition: EventReaderBaseAlg.h:264
EventReaderBaseAlg::m_c711_rawChannelChInfo
std::vector< std::vector< int > > * m_c711_rawChannelChInfo
Definition: EventReaderBaseAlg.h:221
EventReaderBaseAlg::m_vtx_z
std::vector< float > * m_vtx_z
Definition: EventReaderBaseAlg.h:257
EventReaderBaseAlg::m_c711_channelOFCa
std::vector< std::vector< double > > * m_c711_channelOFCa
Definition: EventReaderBaseAlg.h:209
EventReaderBaseAlg::m_el_et
std::vector< float > * m_el_et
Definition: EventReaderBaseAlg.h:272
EventReaderBaseAlg::m_zee_pt
std::vector< double > * m_zee_pt
Definition: EventReaderBaseAlg.h:305
EventReaderBaseAlg::m_c_channelOfflEneRescaler
std::vector< float > * m_c_channelOfflEneRescaler
Definition: EventReaderBaseAlg.h:140
EventReaderBaseAlg::m_c711_channelADC2MEV1
std::vector< float > * m_c711_channelADC2MEV1
Definition: EventReaderBaseAlg.h:215
EventReaderBaseAlg::m_c711_rawChannelQuality
std::vector< float > * m_c711_rawChannelQuality
Definition: EventReaderBaseAlg.h:228
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
EventReaderBaseAlg::m_c711_channelHashMap
std::vector< unsigned int > * m_c711_channelHashMap
Definition: EventReaderBaseAlg.h:204
EventReaderBaseAlg::m_c711_channelDSPThreshold
std::vector< float > * m_c711_channelDSPThreshold
Definition: EventReaderBaseAlg.h:208
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
EventReaderBaseAlg::m_offTagTightness
Gaudi::Property< std::string > m_offTagTightness
Definition: EventReaderBaseAlg.h:52
EventReaderBaseAlg::m_ph_energy
std::vector< float > * m_ph_energy
Definition: EventReaderBaseAlg.h:266
EventReaderBaseAlg::m_z0Tag
Gaudi::Property< float > m_z0Tag
Definition: EventReaderBaseAlg.h:57
EventReaderBaseAlg::m_c711_cellLayer
std::vector< int > * m_c711_cellLayer
Definition: EventReaderBaseAlg.h:185
xAOD::EventInfo_v1::beamPosSigmaXY
float beamPosSigmaXY() const
The beam spot shape's X-Y correlation.
EventReaderBaseAlg::m_el_Pt
std::vector< float > * m_el_Pt
Definition: EventReaderBaseAlg.h:271
a
TList * a
Definition: liststreamerinfos.cxx:10
EventReaderBaseAlg::m_c711_channelEffectiveSigma
std::vector< float > * m_c711_channelEffectiveSigma
Definition: EventReaderBaseAlg.h:206
EventReaderBaseAlg::m_c_cellGain
std::vector< int > * m_c_cellGain
Definition: EventReaderBaseAlg.h:105
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
EventReaderBaseAlg::m_c711_cellEta
std::vector< double > * m_c711_cellEta
Definition: EventReaderBaseAlg.h:189
EventReaderBaseAlg::m_c711_cellDEta
std::vector< double > * m_c711_cellDEta
Definition: EventReaderBaseAlg.h:191
EventReaderBaseAlg::m_c711_cellIndexCounter
int * m_c711_cellIndexCounter
Definition: EventReaderBaseAlg.h:181
EventReaderBaseAlg::m_c_rawChannelQuality
std::vector< float > * m_c_rawChannelQuality
Definition: EventReaderBaseAlg.h:150
EventReaderBaseAlg::m_c_clusterChannelIndex
std::vector< int > * m_c_clusterChannelIndex
Definition: EventReaderBaseAlg.h:118
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
EventReaderBaseAlg::m_c711_clusterTime
std::vector< double > * m_c711_clusterTime
Definition: EventReaderBaseAlg.h:175
EventReaderBaseAlg::m_c_clusterTime
std::vector< double > * m_c_clusterTime
Definition: EventReaderBaseAlg.h:97
EventReaderBaseAlg::m_el_index
std::vector< int > * m_el_index
Definition: EventReaderBaseAlg.h:270
EventReaderBaseAlg::m_c_clusterIndex
std::vector< int > * m_c_clusterIndex
Definition: EventReaderBaseAlg.h:94
EventReaderBaseAlg::m_el_e277
std::vector< float > * m_el_e277
Definition: EventReaderBaseAlg.h:285
EventReaderBaseAlg::m_vtx_y
std::vector< float > * m_vtx_y
Definition: EventReaderBaseAlg.h:256
EventReaderBaseAlg::m_mc_part_pdgId
std::vector< int > * m_mc_part_pdgId
Definition: EventReaderBaseAlg.h:239
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
EventReaderBaseAlg::m_c711_channelTime
std::vector< double > * m_c711_channelTime
Definition: EventReaderBaseAlg.h:201
EventReaderBaseAlg::m_c711_cellGain
std::vector< int > * m_c711_cellGain
Definition: EventReaderBaseAlg.h:184
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:234
EventReaderBaseAlg::m_doElecSelectByTrackOnly
Gaudi::Property< bool > m_doElecSelectByTrackOnly
Definition: EventReaderBaseAlg.h:58
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
EventReaderBaseAlg::m_c711_clusterPhi
std::vector< double > * m_c711_clusterPhi
Definition: EventReaderBaseAlg.h:177
EventReaderBaseAlg::m_vtx_x
std::vector< float > * m_vtx_x
Definition: EventReaderBaseAlg.h:255
EventReaderBaseAlg::m_c_clusterIndex_rawChLvl
std::vector< int > * m_c_clusterIndex_rawChLvl
Definition: EventReaderBaseAlg.h:152
EventReaderBaseAlg::m_ph_m
std::vector< float > * m_ph_m
Definition: EventReaderBaseAlg.h:267
EventReaderBaseAlg::m_lb_lumiblock
std::vector< int > * m_lb_lumiblock
Definition: EventReaderBaseAlg.h:82
EventReaderBaseAlg::m_el_rhad1
std::vector< float > * m_el_rhad1
Definition: EventReaderBaseAlg.h:290
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
EventReaderBaseAlg::m_c711_channelOFCTimeOffset
std::vector< double > * m_c711_channelOFCTimeOffset
Definition: EventReaderBaseAlg.h:213
EventReaderBaseAlg::m_c_channelDigits
std::vector< std::vector< float > > * m_c_channelDigits
Definition: EventReaderBaseAlg.h:120
EventReaderBaseAlg::m_el_Eta
std::vector< float > * m_el_Eta
Definition: EventReaderBaseAlg.h:273
EventReaderBaseAlg::m_vtx_deltaZ0
std::vector< float > * m_vtx_deltaZ0
Definition: EventReaderBaseAlg.h:258
EventReaderBaseAlg::m_c_clusterRawChannelIndex
std::vector< float > * m_c_clusterRawChannelIndex
Definition: EventReaderBaseAlg.h:151
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
EventReaderBaseAlg::m_e_eventNumber
unsigned long long m_e_eventNumber
Definition: EventReaderBaseAlg.h:87
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
EventReaderBaseAlg::m_hits_cellEta
std::vector< double > * m_hits_cellEta
Definition: EventReaderBaseAlg.h:166
EventReaderBaseAlg::m_c_clusterEta
std::vector< double > * m_c_clusterEta
Definition: EventReaderBaseAlg.h:98
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
EventReaderBaseAlg::m_c711_clusterIndex
std::vector< int > * m_c711_clusterIndex
Definition: EventReaderBaseAlg.h:172
EventReaderBaseAlg::m_el_rhad
std::vector< float > * m_el_rhad
Definition: EventReaderBaseAlg.h:289
EventReaderBaseAlg::m_mc_part_pt
std::vector< float > * m_mc_part_pt
Definition: EventReaderBaseAlg.h:235
EventReaderBaseAlg::m_c711_channelOFCb
std::vector< std::vector< double > > * m_c711_channelOFCb
Definition: EventReaderBaseAlg.h:210
EventReaderBaseAlg::m_c711_channelNoise
std::vector< float > * m_c711_channelNoise
Definition: EventReaderBaseAlg.h:207
EventReaderBaseAlg::m_c_channelEffectiveSigma
std::vector< float > * m_c_channelEffectiveSigma
Definition: EventReaderBaseAlg.h:127
EventReaderBaseAlg::m_doTruthEventDump
Gaudi::Property< bool > m_doTruthEventDump
Definition: EventReaderBaseAlg.h:61
EventReaderBaseAlg::m_c711_clusterCellIndex
std::vector< int > * m_c711_clusterCellIndex
Definition: EventReaderBaseAlg.h:183
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
EventReaderBaseAlg::m_c711_rawChannelIdMap
std::vector< unsigned int > * m_c711_rawChannelIdMap
Definition: EventReaderBaseAlg.h:222
EventReaderBaseAlg::m_c_rawChannelPed
std::vector< float > * m_c_rawChannelPed
Definition: EventReaderBaseAlg.h:148
EventReaderBaseAlg::m_zee_px
std::vector< double > * m_zee_px
Definition: EventReaderBaseAlg.h:306
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
EventReaderBaseAlg::m_e_bcid
unsigned int m_e_bcid
Definition: EventReaderBaseAlg.h:86
EventReaderBaseAlg::m_c_channelOFCb
std::vector< std::vector< double > > * m_c_channelOFCb
Definition: EventReaderBaseAlg.h:131
EventReaderBaseAlg::m_c711_clusterIndexCounter
int * m_c711_clusterIndexCounter
Definition: EventReaderBaseAlg.h:171
EventReaderBaseAlg::m_lb_bcidLuminosity
std::vector< std::vector< float > > * m_lb_bcidLuminosity
Definition: EventReaderBaseAlg.h:81
EventReaderBaseAlg::m_hits_energyConv
std::vector< double > * m_hits_energyConv
Definition: EventReaderBaseAlg.h:165
EventReaderBaseAlg::m_zee_py
std::vector< double > * m_zee_py
Definition: EventReaderBaseAlg.h:307
fitman.k
k
Definition: fitman.py:528
EventReaderBaseAlg::m_mc_part_barcode
std::vector< int > * m_mc_part_barcode
Definition: EventReaderBaseAlg.h:241
EventReaderBaseAlg::m_c711_cellPhi
std::vector< double > * m_c711_cellPhi
Definition: EventReaderBaseAlg.h:190
EventReaderBaseAlg::m_c711_channelPed
std::vector< float > * m_c711_channelPed
Definition: EventReaderBaseAlg.h:216
EventReaderBaseAlg::m_etMinProbe
Gaudi::Property< float > m_etMinProbe
define the Pid of Probe from the user
Definition: EventReaderBaseAlg.h:54
EventReaderBaseAlg::m_getLArCalibConstants
Gaudi::Property< bool > m_getLArCalibConstants
Definition: EventReaderBaseAlg.h:65
EventReaderBaseAlg::m_c_channelADC2MEV1
std::vector< float > * m_c_channelADC2MEV1
Definition: EventReaderBaseAlg.h:136
ServiceHandle< ICondSvc >
EventReaderBaseAlg::m_zee_deltaR
std::vector< double > * m_zee_deltaR
Definition: EventReaderBaseAlg.h:310
EventReaderBaseAlg::m_c_clusterCellIndex
std::vector< int > * m_c_clusterCellIndex
Definition: EventReaderBaseAlg.h:104
Generated on Thu Jan 9 2025 21:32:15 for ATLAS Offline Software by   doxygen 1.8.18