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

7  :
8  AthAlgorithm(name, pSvcLocator) {}

◆ ~EventReaderBaseAlg()

EventReaderBaseAlg::~EventReaderBaseAlg ( )
overridevirtual

Definition at line 10 of file EventReaderBaseAlg.cxx.

10 {}

Member Function Documentation

◆ bookBranches()

void EventReaderBaseAlg::bookBranches ( TTree *  tree)
protected

Definition at line 244 of file EventReaderBaseAlg.cxx.

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

◆ bookDatabaseBranches()

void EventReaderBaseAlg::bookDatabaseBranches ( TTree *  tree)
protected

Definition at line 228 of file EventReaderBaseAlg.cxx.

228  {
229  // ## BCID/Luminosity vector
230  tree->Branch ("lb_lumiblock",&m_lb_lumiblock);
231  if (!m_isMC){
232  tree->Branch ("lb_bcidLuminosity",&m_lb_bcidLuminosity);
233  }
234 }

◆ clear()

void EventReaderBaseAlg::clear ( )
protected

Definition at line 483 of file EventReaderBaseAlg.cxx.

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

◆ clearLBData()

void EventReaderBaseAlg::clearLBData ( )
protected

Definition at line 236 of file EventReaderBaseAlg.cxx.

236  {
237  m_lb_lumiblock->clear();
238  if (!m_isMC){
239  m_lb_bcidLuminosity->clear();
240  }
241 }

◆ 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 215 of file EventReaderBaseAlg.cxx.

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

◆ deltaR()

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

Definition at line 221 of file EventReaderBaseAlg.cxx.

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

◆ 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 22 of file EventReaderBaseAlg.cxx.

22  {
23  // the E/p is calculated here based on Electron caloCluster and its associated trackParticle
24  // E_cluster/p_track
25  float eoverp = 0.;
26  float track_p = (electron->trackParticle())->pt()*std::cosh((electron->trackParticle())->eta());
27  if (track_p != 0.) eoverp = (electron->caloCluster())->e()/track_p;
28  else{
29  ATH_MSG_WARNING ("(eOverP) Track_p == 0");
30  return false;
31  }
32  if ((fabs(eoverp) < 0.7) || (fabs(eoverp) > 1.5) ){
33  ATH_MSG_DEBUG ("(eOverP) E/p is out of range! (eoverp="<<eoverp<<").");
34  return false;
35  }
36  else{
37  ATH_MSG_DEBUG ("(eOverP) Passed: E/p="<<eoverp);
38  return true;
39  }
40 }

◆ 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 15 of file EventReaderBaseAlg.cxx.

15  {
16  return StatusCode::SUCCESS;
17 }

◆ 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 18 of file EventReaderBaseAlg.cxx.

18  {
19  return StatusCode::SUCCESS;
20 }

◆ fixPhi()

double EventReaderBaseAlg::fixPhi ( double  phi)
protected

Definition at line 208 of file EventReaderBaseAlg.cxx.

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

◆ getCaloRegionIndex()

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

Definition at line 196 of file EventReaderBaseAlg.cxx.

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

◆ initialize()

StatusCode EventReaderBaseAlg::initialize ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 12 of file EventReaderBaseAlg.cxx.

12  {
13  return StatusCode::SUCCESS;
14 }

◆ 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 187 of file EventReaderBaseAlg.cxx.

187  {
188  if ( (absEta > 1.37 && absEta < 1.52) || (absEta > 2.47) ){
189  return false;
190  }
191  else{
192  return true;
193  }
194 }

◆ isGoodProbeElectron()

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

Definition at line 148 of file EventReaderBaseAlg.cxx.

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

◆ isTagElectron()

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

Definition at line 107 of file EventReaderBaseAlg.cxx.

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

◆ 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 43 of file EventReaderBaseAlg.cxx.

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

◆ 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 202 of file EventReaderBaseAlg.h.

◆ m_c711_cellDPhi

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

Definition at line 203 of file EventReaderBaseAlg.h.

◆ m_c711_cellEnergy

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

Definition at line 198 of file EventReaderBaseAlg.h.

◆ m_c711_cellEta

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

Definition at line 200 of file EventReaderBaseAlg.h.

◆ m_c711_cellGain

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

Definition at line 195 of file EventReaderBaseAlg.h.

◆ m_c711_cellIndexCounter

int* EventReaderBaseAlg::m_c711_cellIndexCounter = nullptr
protected

Definition at line 192 of file EventReaderBaseAlg.h.

◆ m_c711_cellLayer

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

Definition at line 196 of file EventReaderBaseAlg.h.

◆ m_c711_cellPhi

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

Definition at line 201 of file EventReaderBaseAlg.h.

◆ m_c711_cellRegion

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

Definition at line 197 of file EventReaderBaseAlg.h.

◆ m_c711_cellTime

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

Definition at line 199 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDEta

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

Definition at line 205 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDPhi

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

Definition at line 204 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV0

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

Definition at line 225 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV1

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

Definition at line 226 of file EventReaderBaseAlg.h.

◆ m_c711_channelBad

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

Definition at line 214 of file EventReaderBaseAlg.h.

◆ m_c711_channelChannelIdMap

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

Definition at line 216 of file EventReaderBaseAlg.h.

◆ m_c711_channelChInfo

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

Definition at line 209 of file EventReaderBaseAlg.h.

◆ m_c711_channelDigits

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

Definition at line 210 of file EventReaderBaseAlg.h.

◆ m_c711_channelDSPThreshold

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

Definition at line 219 of file EventReaderBaseAlg.h.

◆ m_c711_channelEffectiveSigma

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

Definition at line 217 of file EventReaderBaseAlg.h.

◆ m_c711_channelEnergy

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

Definition at line 211 of file EventReaderBaseAlg.h.

◆ m_c711_channelHashMap

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

Definition at line 215 of file EventReaderBaseAlg.h.

◆ m_c711_channelLayer

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

Definition at line 213 of file EventReaderBaseAlg.h.

◆ m_c711_channelMinBiasAvg

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

Definition at line 228 of file EventReaderBaseAlg.h.

◆ m_c711_channelNoise

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

Definition at line 218 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCa

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

Definition at line 220 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCb

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

Definition at line 221 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCTimeOffset

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

Definition at line 224 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflEneRescaler

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

Definition at line 230 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflHVScale

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

Definition at line 229 of file EventReaderBaseAlg.h.

◆ m_c711_channelPed

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

Definition at line 227 of file EventReaderBaseAlg.h.

◆ m_c711_channelShape

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

Definition at line 222 of file EventReaderBaseAlg.h.

◆ m_c711_channelShapeDer

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

Definition at line 223 of file EventReaderBaseAlg.h.

◆ m_c711_channelTime

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

Definition at line 212 of file EventReaderBaseAlg.h.

◆ m_c711_clusterCellIndex

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

Definition at line 194 of file EventReaderBaseAlg.h.

◆ m_c711_clusterChannelIndex

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

Definition at line 208 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEnergy

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

Definition at line 185 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEta

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

Definition at line 187 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex

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

Definition at line 183 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_cellLvl

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

Definition at line 193 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_chLvl

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

Definition at line 207 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_rawChLvl

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

Definition at line 241 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndexCounter

int* EventReaderBaseAlg::m_c711_clusterIndexCounter = 0
protected

Definition at line 182 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPhi

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

Definition at line 188 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPt

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

Definition at line 189 of file EventReaderBaseAlg.h.

◆ m_c711_clusterRawChannelIndex

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

Definition at line 240 of file EventReaderBaseAlg.h.

◆ m_c711_clusterTime

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

Definition at line 186 of file EventReaderBaseAlg.h.

◆ m_c711_electronIndex_clusterLvl

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

Definition at line 184 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelAmplitude

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

Definition at line 234 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelChInfo

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

Definition at line 232 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelDSPThreshold

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

Definition at line 242 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelIdMap

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

Definition at line 233 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelLayer

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

Definition at line 236 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelPed

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

Definition at line 237 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelProv

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

Definition at line 238 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelQuality

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

Definition at line 239 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelTime

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

Definition at line 235 of file EventReaderBaseAlg.h.

◆ m_c_cellDEta

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

Definition at line 123 of file EventReaderBaseAlg.h.

◆ m_c_cellDPhi

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

Definition at line 124 of file EventReaderBaseAlg.h.

◆ m_c_cellEnergy

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

Definition at line 119 of file EventReaderBaseAlg.h.

◆ m_c_cellEta

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

Definition at line 121 of file EventReaderBaseAlg.h.

◆ m_c_cellGain

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

Definition at line 116 of file EventReaderBaseAlg.h.

◆ m_c_cellIndexCounter

int EventReaderBaseAlg::m_c_cellIndexCounter = 0
protected

Definition at line 113 of file EventReaderBaseAlg.h.

◆ m_c_cellLayer

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

Definition at line 117 of file EventReaderBaseAlg.h.

◆ m_c_cellPhi

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

Definition at line 122 of file EventReaderBaseAlg.h.

◆ m_c_cellRegion

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

Definition at line 118 of file EventReaderBaseAlg.h.

◆ m_c_cellTime

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

Definition at line 120 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDEta

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

Definition at line 126 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDPhi

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

Definition at line 125 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV0

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

Definition at line 146 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV1

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

Definition at line 147 of file EventReaderBaseAlg.h.

◆ m_c_channelBad

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

Definition at line 135 of file EventReaderBaseAlg.h.

◆ m_c_channelChannelIdMap

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

Definition at line 137 of file EventReaderBaseAlg.h.

◆ m_c_channelChInfo

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

Definition at line 130 of file EventReaderBaseAlg.h.

◆ m_c_channelDigits

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

Definition at line 131 of file EventReaderBaseAlg.h.

◆ m_c_channelDSPThreshold

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

Definition at line 140 of file EventReaderBaseAlg.h.

◆ m_c_channelEffectiveSigma

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

Definition at line 138 of file EventReaderBaseAlg.h.

◆ m_c_channelEnergy

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

Definition at line 132 of file EventReaderBaseAlg.h.

◆ m_c_channelHashMap

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

Definition at line 136 of file EventReaderBaseAlg.h.

◆ m_c_channelLayer

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

Definition at line 134 of file EventReaderBaseAlg.h.

◆ m_c_channelMinBiasAvg

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

Definition at line 149 of file EventReaderBaseAlg.h.

◆ m_c_channelNoise

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

Definition at line 139 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCa

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

Definition at line 141 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCb

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

Definition at line 142 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCTimeOffset

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

Definition at line 145 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflEneRescaler

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

Definition at line 151 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflHVScale

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

Definition at line 150 of file EventReaderBaseAlg.h.

◆ m_c_channelPed

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

Definition at line 148 of file EventReaderBaseAlg.h.

◆ m_c_channelShape

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

Definition at line 143 of file EventReaderBaseAlg.h.

◆ m_c_channelShapeDer

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

Definition at line 144 of file EventReaderBaseAlg.h.

◆ m_c_channelTime

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

Definition at line 133 of file EventReaderBaseAlg.h.

◆ m_c_clusterCellIndex

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

Definition at line 115 of file EventReaderBaseAlg.h.

◆ m_c_clusterChannelIndex

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

Definition at line 129 of file EventReaderBaseAlg.h.

◆ m_c_clusterEnergy

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

Definition at line 107 of file EventReaderBaseAlg.h.

◆ m_c_clusterEta

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

Definition at line 109 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex

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

Definition at line 105 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_cellLvl

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

Definition at line 114 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_chLvl

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

Definition at line 128 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_rawChLvl

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

Definition at line 163 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndexCounter

int EventReaderBaseAlg::m_c_clusterIndexCounter = 0
protected

Definition at line 104 of file EventReaderBaseAlg.h.

◆ m_c_clusterPhi

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

Definition at line 110 of file EventReaderBaseAlg.h.

◆ m_c_clusterPt

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

Definition at line 111 of file EventReaderBaseAlg.h.

◆ m_c_clusterRawChannelIndex

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

Definition at line 162 of file EventReaderBaseAlg.h.

◆ m_c_clusterTime

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

Definition at line 108 of file EventReaderBaseAlg.h.

◆ m_c_electronIndex_clusterLvl

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

Definition at line 106 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelAmplitude

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

Definition at line 156 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelChInfo

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

Definition at line 154 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelDSPThreshold

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

Definition at line 164 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelIdMap

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

Definition at line 155 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelLayer

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

Definition at line 158 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelPed

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

Definition at line 159 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelProv

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

Definition at line 160 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelQuality

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

Definition at line 161 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelTime

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

Definition at line 157 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 67 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 78 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 69 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 74 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 71 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 70 of file EventReaderBaseAlg.h.

◆ m_doTruthEventDump

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

Definition at line 72 of file EventReaderBaseAlg.h.

◆ m_doTruthPartDump

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

Definition at line 73 of file EventReaderBaseAlg.h.

◆ m_e_bcid

unsigned int EventReaderBaseAlg::m_e_bcid = 9999
protected

Definition at line 97 of file EventReaderBaseAlg.h.

◆ m_e_eventNumber

unsigned long long EventReaderBaseAlg::m_e_eventNumber = 9999
protected

Definition at line 98 of file EventReaderBaseAlg.h.

◆ m_e_inTimePileup

float EventReaderBaseAlg::m_e_inTimePileup = -999
protected

Definition at line 100 of file EventReaderBaseAlg.h.

◆ m_e_lumiBlock

int EventReaderBaseAlg::m_e_lumiBlock = 999
protected

Definition at line 99 of file EventReaderBaseAlg.h.

◆ m_e_outOfTimePileUp

float EventReaderBaseAlg::m_e_outOfTimePileUp = -999
protected

Definition at line 101 of file EventReaderBaseAlg.h.

◆ m_e_runNumber

unsigned int EventReaderBaseAlg::m_e_runNumber = 9999
protected

Definition at line 96 of file EventReaderBaseAlg.h.

◆ m_el_deltae

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

Definition at line 299 of file EventReaderBaseAlg.h.

◆ m_el_e277

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

Definition at line 296 of file EventReaderBaseAlg.h.

◆ m_el_eoverp

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

Definition at line 287 of file EventReaderBaseAlg.h.

◆ m_el_eratio

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

Definition at line 291 of file EventReaderBaseAlg.h.

◆ m_el_et

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

Definition at line 283 of file EventReaderBaseAlg.h.

◆ m_el_Eta

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

Definition at line 284 of file EventReaderBaseAlg.h.

◆ m_el_f1

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

Definition at line 289 of file EventReaderBaseAlg.h.

◆ m_el_f3

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

Definition at line 290 of file EventReaderBaseAlg.h.

◆ m_el_fracs1

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

Definition at line 294 of file EventReaderBaseAlg.h.

◆ m_el_index

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

Definition at line 281 of file EventReaderBaseAlg.h.

◆ m_el_m

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

Definition at line 286 of file EventReaderBaseAlg.h.

◆ m_el_Phi

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

Definition at line 285 of file EventReaderBaseAlg.h.

◆ m_el_Pt

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

Definition at line 282 of file EventReaderBaseAlg.h.

◆ m_el_reta

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

Definition at line 297 of file EventReaderBaseAlg.h.

◆ m_el_rhad

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

Definition at line 300 of file EventReaderBaseAlg.h.

◆ m_el_rhad1

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

Definition at line 301 of file EventReaderBaseAlg.h.

◆ m_el_rphi

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

Definition at line 298 of file EventReaderBaseAlg.h.

◆ m_el_weta1

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

Definition at line 292 of file EventReaderBaseAlg.h.

◆ m_el_weta2

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

Definition at line 293 of file EventReaderBaseAlg.h.

◆ m_el_wtots1

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

Definition at line 295 of file EventReaderBaseAlg.h.

◆ m_elecEtaCut

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

Definition at line 62 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 65 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 66 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 76 of file EventReaderBaseAlg.h.

◆ m_hits_cellEta

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

Definition at line 177 of file EventReaderBaseAlg.h.

◆ m_hits_cellPhi

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

Definition at line 178 of file EventReaderBaseAlg.h.

◆ m_hits_clusterChannelIndex

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

Definition at line 171 of file EventReaderBaseAlg.h.

◆ m_hits_clusterIndex_chLvl

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

Definition at line 170 of file EventReaderBaseAlg.h.

◆ m_hits_energy

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

Definition at line 173 of file EventReaderBaseAlg.h.

◆ m_hits_energyConv

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

Definition at line 176 of file EventReaderBaseAlg.h.

◆ m_hits_hash

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

Definition at line 172 of file EventReaderBaseAlg.h.

◆ m_hits_sampFrac

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

Definition at line 175 of file EventReaderBaseAlg.h.

◆ m_hits_sampling

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

Definition at line 169 of file EventReaderBaseAlg.h.

◆ m_hits_time

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

Definition at line 174 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 75 of file EventReaderBaseAlg.h.

◆ m_lb_bcidLuminosity

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

Definition at line 92 of file EventReaderBaseAlg.h.

◆ m_lb_lumiblock

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

Definition at line 93 of file EventReaderBaseAlg.h.

◆ m_mc_part_barcode

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

Definition at line 252 of file EventReaderBaseAlg.h.

◆ m_mc_part_energy

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

Definition at line 245 of file EventReaderBaseAlg.h.

◆ m_mc_part_eta

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

Definition at line 248 of file EventReaderBaseAlg.h.

◆ m_mc_part_m

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

Definition at line 247 of file EventReaderBaseAlg.h.

◆ m_mc_part_pdgId

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

Definition at line 250 of file EventReaderBaseAlg.h.

◆ m_mc_part_phi

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

Definition at line 249 of file EventReaderBaseAlg.h.

◆ m_mc_part_pt

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

Definition at line 246 of file EventReaderBaseAlg.h.

◆ m_mc_part_status

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

Definition at line 251 of file EventReaderBaseAlg.h.

◆ m_mc_vert_barcode

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

Definition at line 262 of file EventReaderBaseAlg.h.

◆ m_mc_vert_eta

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

Definition at line 260 of file EventReaderBaseAlg.h.

◆ m_mc_vert_perp

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

Definition at line 259 of file EventReaderBaseAlg.h.

◆ m_mc_vert_phi

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

Definition at line 261 of file EventReaderBaseAlg.h.

◆ m_mc_vert_status

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

Definition at line 263 of file EventReaderBaseAlg.h.

◆ m_mc_vert_time

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

Definition at line 258 of file EventReaderBaseAlg.h.

◆ m_mc_vert_x

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

Definition at line 255 of file EventReaderBaseAlg.h.

◆ m_mc_vert_y

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

Definition at line 256 of file EventReaderBaseAlg.h.

◆ m_mc_vert_z

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

Definition at line 257 of file EventReaderBaseAlg.h.

◆ m_minEnergy

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

Definition at line 168 of file EventReaderBaseAlg.h.

◆ m_ncell

size_t EventReaderBaseAlg::m_ncell = 0
protected

Definition at line 167 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 77 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 64 of file EventReaderBaseAlg.h.

◆ m_offTagTightness

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

Definition at line 63 of file EventReaderBaseAlg.h.

◆ m_ph_energy

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

Definition at line 277 of file EventReaderBaseAlg.h.

◆ m_ph_eta

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

Definition at line 274 of file EventReaderBaseAlg.h.

◆ m_ph_m

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

Definition at line 278 of file EventReaderBaseAlg.h.

◆ m_ph_phi

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

Definition at line 275 of file EventReaderBaseAlg.h.

◆ m_ph_pt

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

Definition at line 276 of file EventReaderBaseAlg.h.

◆ m_secondTree

TTree* EventReaderBaseAlg::m_secondTree
protected

Definition at line 85 of file EventReaderBaseAlg.h.

◆ m_tp_electronEt

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

Definition at line 305 of file EventReaderBaseAlg.h.

◆ m_tp_electronEta

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

Definition at line 306 of file EventReaderBaseAlg.h.

◆ m_tp_electronPhi

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

Definition at line 307 of file EventReaderBaseAlg.h.

◆ m_tp_electronPt

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

Definition at line 304 of file EventReaderBaseAlg.h.

◆ m_tp_isProbe

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

Definition at line 312 of file EventReaderBaseAlg.h.

◆ m_tp_isTag

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

Definition at line 311 of file EventReaderBaseAlg.h.

◆ m_tp_probeIndex

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

Definition at line 309 of file EventReaderBaseAlg.h.

◆ m_tp_tagIndex

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

Definition at line 310 of file EventReaderBaseAlg.h.

◆ m_Tree

TTree* EventReaderBaseAlg::m_Tree
protected

Definition at line 84 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 271 of file EventReaderBaseAlg.h.

◆ m_vtx_delta_z0_sin

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

Definition at line 270 of file EventReaderBaseAlg.h.

◆ m_vtx_deltaZ0

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

Definition at line 269 of file EventReaderBaseAlg.h.

◆ m_vtx_x

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

Definition at line 266 of file EventReaderBaseAlg.h.

◆ m_vtx_y

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

Definition at line 267 of file EventReaderBaseAlg.h.

◆ m_vtx_z

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

Definition at line 268 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 68 of file EventReaderBaseAlg.h.

◆ m_zee_deltaR

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

Definition at line 321 of file EventReaderBaseAlg.h.

◆ m_zee_E

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

Definition at line 315 of file EventReaderBaseAlg.h.

◆ m_zee_M

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

Definition at line 314 of file EventReaderBaseAlg.h.

◆ m_zee_pt

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

Definition at line 316 of file EventReaderBaseAlg.h.

◆ m_zee_px

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

Definition at line 317 of file EventReaderBaseAlg.h.

◆ m_zee_py

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

Definition at line 318 of file EventReaderBaseAlg.h.

◆ m_zee_pz

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

Definition at line 319 of file EventReaderBaseAlg.h.

◆ m_zee_T

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

Definition at line 320 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:189
EventReaderBaseAlg::fixPhi
double fixPhi(double phi)
Definition: EventReaderBaseAlg.cxx:208
EventReaderBaseAlg::m_isMC
Gaudi::Property< bool > m_isMC
Definition: EventReaderBaseAlg.h:75
EventReaderBaseAlg::m_zee_E
std::vector< double > * m_zee_E
Definition: EventReaderBaseAlg.h:315
EventReaderBaseAlg::m_el_Phi
std::vector< float > * m_el_Phi
Definition: EventReaderBaseAlg.h:285
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
EventReaderBaseAlg::m_el_deltae
std::vector< float > * m_el_deltae
Definition: EventReaderBaseAlg.h:299
EventReaderBaseAlg::m_c711_channelDigits
std::vector< std::vector< float > > * m_c711_channelDigits
Definition: EventReaderBaseAlg.h:210
EventReaderBaseAlg::m_c711_channelBad
std::vector< bool > * m_c711_channelBad
Definition: EventReaderBaseAlg.h:214
EventReaderBaseAlg::m_el_eoverp
std::vector< float > * m_el_eoverp
Definition: EventReaderBaseAlg.h:287
EventReaderBaseAlg::m_noBadCells
Gaudi::Property< bool > m_noBadCells
Definition: EventReaderBaseAlg.h:77
EventReaderBaseAlg::m_zee_pz
std::vector< double > * m_zee_pz
Definition: EventReaderBaseAlg.h:319
EventReaderBaseAlg::m_c_channelShapeDer
std::vector< std::vector< double > > * m_c_channelShapeDer
Definition: EventReaderBaseAlg.h:144
EventReaderBaseAlg::m_ph_eta
std::vector< float > * m_ph_eta
Definition: EventReaderBaseAlg.h:274
EventReaderBaseAlg::m_c_clusterPhi
std::vector< double > * m_c_clusterPhi
Definition: EventReaderBaseAlg.h:110
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
EventReaderBaseAlg::m_c_cellRegion
std::vector< int > * m_c_cellRegion
Definition: EventReaderBaseAlg.h:118
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
EventReaderBaseAlg::m_c711_channelADC2MEV0
std::vector< float > * m_c711_channelADC2MEV0
Definition: EventReaderBaseAlg.h:225
EventReaderBaseAlg::m_mc_part_m
std::vector< float > * m_mc_part_m
Definition: EventReaderBaseAlg.h:247
EventReaderBaseAlg::m_c_clusterIndex_chLvl
std::vector< int > * m_c_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:128
EventReaderBaseAlg::m_mc_part_energy
std::vector< float > * m_mc_part_energy
Definition: EventReaderBaseAlg.h:245
EventReaderBaseAlg::m_c_rawChannelAmplitude
std::vector< float > * m_c_rawChannelAmplitude
Definition: EventReaderBaseAlg.h:156
EventReaderBaseAlg::m_hits_hash
std::vector< unsigned int > * m_hits_hash
Definition: EventReaderBaseAlg.h:172
EventReaderBaseAlg::m_c711_clusterRawChannelIndex
std::vector< float > * m_c711_clusterRawChannelIndex
Definition: EventReaderBaseAlg.h:240
EventReaderBaseAlg::m_c_channelPed
std::vector< float > * m_c_channelPed
Definition: EventReaderBaseAlg.h:148
EventReaderBaseAlg::isEtaOutsideLArCrack
bool isEtaOutsideLArCrack(float absEta)
Definition: EventReaderBaseAlg.cxx:187
EventReaderBaseAlg::m_c711_clusterEta
std::vector< double > * m_c711_clusterEta
Definition: EventReaderBaseAlg.h:187
EventReaderBaseAlg::m_mc_vert_z
std::vector< float > * m_mc_vert_z
Definition: EventReaderBaseAlg.h:257
EventReaderBaseAlg::m_c711_clusterEnergy
std::vector< double > * m_c711_clusterEnergy
Definition: EventReaderBaseAlg.h:185
EventReaderBaseAlg::m_c_rawChannelProv
std::vector< float > * m_c_rawChannelProv
Definition: EventReaderBaseAlg.h:160
EventReaderBaseAlg::m_c_channelChInfo
std::vector< std::vector< int > > * m_c_channelChInfo
Definition: EventReaderBaseAlg.h:130
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:236
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:135
EventReaderBaseAlg::m_c711_channelOfflHVScale
std::vector< float > * m_c711_channelOfflHVScale
Definition: EventReaderBaseAlg.h:229
EventReaderBaseAlg::m_el_fracs1
std::vector< float > * m_el_fracs1
Definition: EventReaderBaseAlg.h:294
EventReaderBaseAlg::m_c_channelMinBiasAvg
std::vector< float > * m_c_channelMinBiasAvg
Definition: EventReaderBaseAlg.h:149
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:242
EventReaderBaseAlg::m_doLArEMBHitsDump
Gaudi::Property< bool > m_doLArEMBHitsDump
Definition: EventReaderBaseAlg.h:74
EventReaderBaseAlg::m_c711_cellTime
std::vector< double > * m_c711_cellTime
Definition: EventReaderBaseAlg.h:199
EventReaderBaseAlg::m_c711_channelChannelIdMap
std::vector< unsigned int > * m_c711_channelChannelIdMap
Definition: EventReaderBaseAlg.h:216
tree
TChain * tree
Definition: tile_monitor.h:30
EventReaderBaseAlg::m_c711_clusterIndex_rawChLvl
std::vector< int > * m_c711_clusterIndex_rawChLvl
Definition: EventReaderBaseAlg.h:241
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:150
EventReaderBaseAlg::m_c_cellToClusterDPhi
std::vector< double > * m_c_cellToClusterDPhi
Definition: EventReaderBaseAlg.h:125
EventReaderBaseAlg::m_c_channelOFCa
std::vector< std::vector< double > > * m_c_channelOFCa
Definition: EventReaderBaseAlg.h:141
test_pyathena.pt
pt
Definition: test_pyathena.py:11
EventReaderBaseAlg::m_hits_cellPhi
std::vector< double > * m_hits_cellPhi
Definition: EventReaderBaseAlg.h:178
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:234
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:104
EventReaderBaseAlg::m_c711_rawChannelTime
std::vector< float > * m_c711_rawChannelTime
Definition: EventReaderBaseAlg.h:235
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:263
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:106
EventReaderBaseAlg::m_doPhotonDump
Gaudi::Property< bool > m_doPhotonDump
Definition: EventReaderBaseAlg.h:71
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
EventReaderBaseAlg::m_e_lumiBlock
int m_e_lumiBlock
Definition: EventReaderBaseAlg.h:99
EventReaderBaseAlg::m_el_weta2
std::vector< float > * m_el_weta2
Definition: EventReaderBaseAlg.h:293
EventReaderBaseAlg::m_c_cellPhi
std::vector< double > * m_c_cellPhi
Definition: EventReaderBaseAlg.h:122
EventReaderBaseAlg::m_doTruthPartDump
Gaudi::Property< bool > m_doTruthPartDump
Definition: EventReaderBaseAlg.h:73
EventReaderBaseAlg::m_c711_cellRegion
std::vector< int > * m_c711_cellRegion
Definition: EventReaderBaseAlg.h:197
EventReaderBaseAlg::m_c_channelTime
std::vector< double > * m_c_channelTime
Definition: EventReaderBaseAlg.h:133
EventReaderBaseAlg::m_hits_clusterChannelIndex
std::vector< int > * m_hits_clusterChannelIndex
Definition: EventReaderBaseAlg.h:171
EventReaderBaseAlg::m_c_clusterPt
std::vector< double > * m_c_clusterPt
Definition: EventReaderBaseAlg.h:111
EventReaderBaseAlg::m_c711_cellDPhi
std::vector< double > * m_c711_cellDPhi
Definition: EventReaderBaseAlg.h:203
EventReaderBaseAlg::m_c_cellEta
std::vector< double > * m_c_cellEta
Definition: EventReaderBaseAlg.h:121
EventReaderBaseAlg::m_el_m
std::vector< float > * m_el_m
Definition: EventReaderBaseAlg.h:286
EventReaderBaseAlg::m_mc_vert_phi
std::vector< float > * m_mc_vert_phi
Definition: EventReaderBaseAlg.h:261
EventReaderBaseAlg::m_hits_clusterIndex_chLvl
std::vector< int > * m_hits_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:170
EventReaderBaseAlg::m_el_f3
std::vector< float > * m_el_f3
Definition: EventReaderBaseAlg.h:290
EventReaderBaseAlg::m_c711_rawChannelPed
std::vector< float > * m_c711_rawChannelPed
Definition: EventReaderBaseAlg.h:237
pi
#define pi
Definition: TileMuonFitter.cxx:65
EventReaderBaseAlg::m_doAssocTopoCluster711Dump
Gaudi::Property< bool > m_doAssocTopoCluster711Dump
Definition: EventReaderBaseAlg.h:78
EventReaderBaseAlg::m_c711_clusterChannelIndex
std::vector< int > * m_c711_clusterChannelIndex
Definition: EventReaderBaseAlg.h:208
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EventReaderBaseAlg::m_e_outOfTimePileUp
float m_e_outOfTimePileUp
Definition: EventReaderBaseAlg.h:101
EventReaderBaseAlg::m_c711_cellToClusterDPhi
std::vector< double > * m_c711_cellToClusterDPhi
Definition: EventReaderBaseAlg.h:204
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
EventReaderBaseAlg::m_c711_electronIndex_clusterLvl
std::vector< int > * m_c711_electronIndex_clusterLvl
Definition: EventReaderBaseAlg.h:184
EventReaderBaseAlg::m_c_channelDSPThreshold
std::vector< float > * m_c_channelDSPThreshold
Definition: EventReaderBaseAlg.h:140
EventReaderBaseAlg::m_c_cellEnergy
std::vector< double > * m_c_cellEnergy
Definition: EventReaderBaseAlg.h:119
EventReaderBaseAlg::m_hits_sampFrac
std::vector< float > * m_hits_sampFrac
Definition: EventReaderBaseAlg.h:175
EventReaderBaseAlg::m_hits_time
std::vector< double > * m_hits_time
Definition: EventReaderBaseAlg.h:174
EventReaderBaseAlg::m_mc_part_eta
std::vector< float > * m_mc_part_eta
Definition: EventReaderBaseAlg.h:248
EventReaderBaseAlg::m_c711_rawChannelProv
std::vector< float > * m_c711_rawChannelProv
Definition: EventReaderBaseAlg.h:238
EventReaderBaseAlg::m_c_cellIndexCounter
int m_c_cellIndexCounter
Definition: EventReaderBaseAlg.h:113
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:213
EventReaderBaseAlg::m_mc_part_status
std::vector< int > * m_mc_part_status
Definition: EventReaderBaseAlg.h:251
EventReaderBaseAlg::m_c_channelADC2MEV0
std::vector< float > * m_c_channelADC2MEV0
Definition: EventReaderBaseAlg.h:146
EventReaderBaseAlg::m_c_channelLayer
std::vector< int > * m_c_channelLayer
Definition: EventReaderBaseAlg.h:134
EventReaderBaseAlg::m_el_eratio
std::vector< float > * m_el_eratio
Definition: EventReaderBaseAlg.h:291
EventReaderBaseAlg::m_el_reta
std::vector< float > * m_el_reta
Definition: EventReaderBaseAlg.h:297
AthCommonDataStore
Definition: AthCommonDataStore.h:52
EventReaderBaseAlg::m_c_rawChannelLayer
std::vector< int > * m_c_rawChannelLayer
Definition: EventReaderBaseAlg.h:158
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:228
EventReaderBaseAlg::m_el_f1
std::vector< float > * m_el_f1
Definition: EventReaderBaseAlg.h:289
EventReaderBaseAlg::m_c_cellDPhi
std::vector< double > * m_c_cellDPhi
Definition: EventReaderBaseAlg.h:124
EventReaderBaseAlg::m_el_weta1
std::vector< float > * m_el_weta1
Definition: EventReaderBaseAlg.h:292
EventReaderBaseAlg::m_hits_sampling
std::vector< int > * m_hits_sampling
Definition: EventReaderBaseAlg.h:169
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:107
EventReaderBaseAlg::m_mc_vert_time
std::vector< float > * m_mc_vert_time
Definition: EventReaderBaseAlg.h:258
EventReaderBaseAlg::m_vtx_delta_z0_sin
std::vector< float > * m_vtx_delta_z0_sin
Definition: EventReaderBaseAlg.h:270
EventReaderBaseAlg::m_c_channelChannelIdMap
std::vector< unsigned int > * m_c_channelChannelIdMap
Definition: EventReaderBaseAlg.h:137
EventReaderBaseAlg::m_c711_clusterIndex_cellLvl
std::vector< int > * m_c711_clusterIndex_cellLvl
Definition: EventReaderBaseAlg.h:193
EventReaderBaseAlg::m_vtx_d0sig
std::vector< double > * m_vtx_d0sig
Definition: EventReaderBaseAlg.h:271
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:126
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:211
EventReaderBaseAlg::m_doTagAndProbe
Gaudi::Property< bool > m_doTagAndProbe
Definition: EventReaderBaseAlg.h:70
EventReaderBaseAlg::m_c_channelHashMap
std::vector< unsigned int > * m_c_channelHashMap
Definition: EventReaderBaseAlg.h:136
EventReaderBaseAlg::m_c_channelNoise
std::vector< float > * m_c_channelNoise
Definition: EventReaderBaseAlg.h:139
EventReaderBaseAlg::m_c_cellTime
std::vector< double > * m_c_cellTime
Definition: EventReaderBaseAlg.h:120
EventReaderBaseAlg::m_ph_pt
std::vector< float > * m_ph_pt
Definition: EventReaderBaseAlg.h:276
EventReaderBaseAlg::m_c_rawChannelTime
std::vector< float > * m_c_rawChannelTime
Definition: EventReaderBaseAlg.h:157
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
EventReaderBaseAlg::m_c_rawChannelIdMap
std::vector< unsigned int > * m_c_rawChannelIdMap
Definition: EventReaderBaseAlg.h:155
EventReaderBaseAlg::m_hits_energy
std::vector< double > * m_hits_energy
Definition: EventReaderBaseAlg.h:173
EventReaderBaseAlg::m_el_rphi
std::vector< float > * m_el_rphi
Definition: EventReaderBaseAlg.h:298
EventReaderBaseAlg::m_mc_vert_perp
std::vector< float > * m_mc_vert_perp
Definition: EventReaderBaseAlg.h:259
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
EventReaderBaseAlg::m_c_channelEnergy
std::vector< double > * m_c_channelEnergy
Definition: EventReaderBaseAlg.h:132
EventReaderBaseAlg::m_offProbeTightness
Gaudi::Property< std::string > m_offProbeTightness
Define the PID for tag electron.
Definition: EventReaderBaseAlg.h:64
EventReaderBaseAlg::m_c711_clusterIndex_chLvl
std::vector< int > * m_c711_clusterIndex_chLvl
Definition: EventReaderBaseAlg.h:207
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:256
EventReaderBaseAlg::m_mc_vert_x
std::vector< float > * m_mc_vert_x
Definition: EventReaderBaseAlg.h:255
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:205
EventReaderBaseAlg::m_etMinTag
Gaudi::Property< float > m_etMinTag
Definition: EventReaderBaseAlg.h:66
EventReaderBaseAlg::m_c711_cellEnergy
std::vector< double > * m_c711_cellEnergy
Definition: EventReaderBaseAlg.h:198
EventReaderBaseAlg::m_zee_T
std::vector< double > * m_zee_T
Definition: EventReaderBaseAlg.h:320
EventReaderBaseAlg::m_c_cellLayer
std::vector< int > * m_c_cellLayer
Definition: EventReaderBaseAlg.h:117
EventReaderBaseAlg::m_c_rawChannelChInfo
std::vector< std::vector< int > > * m_c_rawChannelChInfo
Definition: EventReaderBaseAlg.h:154
EventReaderBaseAlg::m_c711_channelShapeDer
std::vector< std::vector< double > > * m_c711_channelShapeDer
Definition: EventReaderBaseAlg.h:223
EventReaderBaseAlg::m_c_clusterIndex_cellLvl
std::vector< int > * m_c_clusterIndex_cellLvl
Definition: EventReaderBaseAlg.h:114
EventReaderBaseAlg::m_mc_vert_barcode
std::vector< int > * m_mc_vert_barcode
Definition: EventReaderBaseAlg.h:262
EventReaderBaseAlg::m_e_inTimePileup
float m_e_inTimePileup
Definition: EventReaderBaseAlg.h:100
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:260
EventReaderBaseAlg::m_e_runNumber
unsigned int m_e_runNumber
Definition: EventReaderBaseAlg.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
EventReaderBaseAlg::m_c711_channelChInfo
std::vector< std::vector< int > > * m_c711_channelChInfo
Definition: EventReaderBaseAlg.h:209
EventReaderBaseAlg::m_c_rawChannelDSPThreshold
std::vector< float > * m_c_rawChannelDSPThreshold
Definition: EventReaderBaseAlg.h:164
EventReaderBaseAlg::m_mc_part_phi
std::vector< float > * m_mc_part_phi
Definition: EventReaderBaseAlg.h:249
EventReaderBaseAlg::m_c711_channelOfflEneRescaler
std::vector< float > * m_c711_channelOfflEneRescaler
Definition: EventReaderBaseAlg.h:230
EventReaderBaseAlg::m_c_channelShape
std::vector< std::vector< double > > * m_c_channelShape
Definition: EventReaderBaseAlg.h:143
EventReaderBaseAlg::m_c711_channelShape
std::vector< std::vector< double > > * m_c711_channelShape
Definition: EventReaderBaseAlg.h:222
EventReaderBaseAlg::m_c_channelOFCTimeOffset
std::vector< double > * m_c_channelOFCTimeOffset
Definition: EventReaderBaseAlg.h:145
EventReaderBaseAlg::m_c_cellDEta
std::vector< double > * m_c_cellDEta
Definition: EventReaderBaseAlg.h:123
EventReaderBaseAlg::m_d0TagSig
Gaudi::Property< float > m_d0TagSig
Definition: EventReaderBaseAlg.h:67
EventReaderBaseAlg::deltaPhi
double deltaPhi(double phi1, double phi2)
Definition: EventReaderBaseAlg.cxx:215
EventReaderBaseAlg::m_zee_M
std::vector< double > * m_zee_M
Definition: EventReaderBaseAlg.h:314
EventReaderBaseAlg::m_el_wtots1
std::vector< float > * m_el_wtots1
Definition: EventReaderBaseAlg.h:295
EventReaderBaseAlg::m_ph_phi
std::vector< float > * m_ph_phi
Definition: EventReaderBaseAlg.h:275
EventReaderBaseAlg::m_c711_rawChannelChInfo
std::vector< std::vector< int > > * m_c711_rawChannelChInfo
Definition: EventReaderBaseAlg.h:232
EventReaderBaseAlg::m_vtx_z
std::vector< float > * m_vtx_z
Definition: EventReaderBaseAlg.h:268
EventReaderBaseAlg::m_c711_channelOFCa
std::vector< std::vector< double > > * m_c711_channelOFCa
Definition: EventReaderBaseAlg.h:220
EventReaderBaseAlg::m_el_et
std::vector< float > * m_el_et
Definition: EventReaderBaseAlg.h:283
EventReaderBaseAlg::m_zee_pt
std::vector< double > * m_zee_pt
Definition: EventReaderBaseAlg.h:316
EventReaderBaseAlg::m_c_channelOfflEneRescaler
std::vector< float > * m_c_channelOfflEneRescaler
Definition: EventReaderBaseAlg.h:151
EventReaderBaseAlg::m_c711_channelADC2MEV1
std::vector< float > * m_c711_channelADC2MEV1
Definition: EventReaderBaseAlg.h:226
EventReaderBaseAlg::m_c711_rawChannelQuality
std::vector< float > * m_c711_rawChannelQuality
Definition: EventReaderBaseAlg.h:239
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
EventReaderBaseAlg::m_c711_channelHashMap
std::vector< unsigned int > * m_c711_channelHashMap
Definition: EventReaderBaseAlg.h:215
EventReaderBaseAlg::m_c711_channelDSPThreshold
std::vector< float > * m_c711_channelDSPThreshold
Definition: EventReaderBaseAlg.h:219
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
EventReaderBaseAlg::m_offTagTightness
Gaudi::Property< std::string > m_offTagTightness
Definition: EventReaderBaseAlg.h:63
EventReaderBaseAlg::m_ph_energy
std::vector< float > * m_ph_energy
Definition: EventReaderBaseAlg.h:277
EventReaderBaseAlg::m_z0Tag
Gaudi::Property< float > m_z0Tag
Definition: EventReaderBaseAlg.h:68
EventReaderBaseAlg::m_c711_cellLayer
std::vector< int > * m_c711_cellLayer
Definition: EventReaderBaseAlg.h:196
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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:282
a
TList * a
Definition: liststreamerinfos.cxx:10
EventReaderBaseAlg::m_c711_channelEffectiveSigma
std::vector< float > * m_c711_channelEffectiveSigma
Definition: EventReaderBaseAlg.h:217
EventReaderBaseAlg::m_c_cellGain
std::vector< int > * m_c_cellGain
Definition: EventReaderBaseAlg.h:116
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:200
EventReaderBaseAlg::m_c711_cellDEta
std::vector< double > * m_c711_cellDEta
Definition: EventReaderBaseAlg.h:202
EventReaderBaseAlg::m_c711_cellIndexCounter
int * m_c711_cellIndexCounter
Definition: EventReaderBaseAlg.h:192
EventReaderBaseAlg::m_c_rawChannelQuality
std::vector< float > * m_c_rawChannelQuality
Definition: EventReaderBaseAlg.h:161
EventReaderBaseAlg::m_c_clusterChannelIndex
std::vector< int > * m_c_clusterChannelIndex
Definition: EventReaderBaseAlg.h:129
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:186
EventReaderBaseAlg::m_c_clusterTime
std::vector< double > * m_c_clusterTime
Definition: EventReaderBaseAlg.h:108
EventReaderBaseAlg::m_el_index
std::vector< int > * m_el_index
Definition: EventReaderBaseAlg.h:281
EventReaderBaseAlg::m_c_clusterIndex
std::vector< int > * m_c_clusterIndex
Definition: EventReaderBaseAlg.h:105
EventReaderBaseAlg::m_el_e277
std::vector< float > * m_el_e277
Definition: EventReaderBaseAlg.h:296
EventReaderBaseAlg::m_vtx_y
std::vector< float > * m_vtx_y
Definition: EventReaderBaseAlg.h:267
EventReaderBaseAlg::m_mc_part_pdgId
std::vector< int > * m_mc_part_pdgId
Definition: EventReaderBaseAlg.h:250
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
EventReaderBaseAlg::m_c711_channelTime
std::vector< double > * m_c711_channelTime
Definition: EventReaderBaseAlg.h:212
EventReaderBaseAlg::m_c711_cellGain
std::vector< int > * m_c711_cellGain
Definition: EventReaderBaseAlg.h:195
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:232
EventReaderBaseAlg::m_doElecSelectByTrackOnly
Gaudi::Property< bool > m_doElecSelectByTrackOnly
Definition: EventReaderBaseAlg.h:69
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
EventReaderBaseAlg::m_c711_clusterPhi
std::vector< double > * m_c711_clusterPhi
Definition: EventReaderBaseAlg.h:188
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
EventReaderBaseAlg::m_vtx_x
std::vector< float > * m_vtx_x
Definition: EventReaderBaseAlg.h:266
EventReaderBaseAlg::m_c_clusterIndex_rawChLvl
std::vector< int > * m_c_clusterIndex_rawChLvl
Definition: EventReaderBaseAlg.h:163
EventReaderBaseAlg::m_ph_m
std::vector< float > * m_ph_m
Definition: EventReaderBaseAlg.h:278
EventReaderBaseAlg::m_lb_lumiblock
std::vector< int > * m_lb_lumiblock
Definition: EventReaderBaseAlg.h:93
EventReaderBaseAlg::m_el_rhad1
std::vector< float > * m_el_rhad1
Definition: EventReaderBaseAlg.h:301
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
EventReaderBaseAlg::m_c711_channelOFCTimeOffset
std::vector< double > * m_c711_channelOFCTimeOffset
Definition: EventReaderBaseAlg.h:224
EventReaderBaseAlg::m_c_channelDigits
std::vector< std::vector< float > > * m_c_channelDigits
Definition: EventReaderBaseAlg.h:131
EventReaderBaseAlg::m_el_Eta
std::vector< float > * m_el_Eta
Definition: EventReaderBaseAlg.h:284
EventReaderBaseAlg::m_vtx_deltaZ0
std::vector< float > * m_vtx_deltaZ0
Definition: EventReaderBaseAlg.h:269
EventReaderBaseAlg::m_c_clusterRawChannelIndex
std::vector< float > * m_c_clusterRawChannelIndex
Definition: EventReaderBaseAlg.h:162
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:98
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
EventReaderBaseAlg::m_hits_cellEta
std::vector< double > * m_hits_cellEta
Definition: EventReaderBaseAlg.h:177
EventReaderBaseAlg::m_c_clusterEta
std::vector< double > * m_c_clusterEta
Definition: EventReaderBaseAlg.h:109
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
EventReaderBaseAlg::m_c711_clusterIndex
std::vector< int > * m_c711_clusterIndex
Definition: EventReaderBaseAlg.h:183
EventReaderBaseAlg::m_el_rhad
std::vector< float > * m_el_rhad
Definition: EventReaderBaseAlg.h:300
EventReaderBaseAlg::m_mc_part_pt
std::vector< float > * m_mc_part_pt
Definition: EventReaderBaseAlg.h:246
EventReaderBaseAlg::m_c711_channelOFCb
std::vector< std::vector< double > > * m_c711_channelOFCb
Definition: EventReaderBaseAlg.h:221
EventReaderBaseAlg::m_c711_channelNoise
std::vector< float > * m_c711_channelNoise
Definition: EventReaderBaseAlg.h:218
EventReaderBaseAlg::m_c_channelEffectiveSigma
std::vector< float > * m_c_channelEffectiveSigma
Definition: EventReaderBaseAlg.h:138
EventReaderBaseAlg::m_doTruthEventDump
Gaudi::Property< bool > m_doTruthEventDump
Definition: EventReaderBaseAlg.h:72
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
EventReaderBaseAlg::m_c711_clusterCellIndex
std::vector< int > * m_c711_clusterCellIndex
Definition: EventReaderBaseAlg.h:194
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:233
EventReaderBaseAlg::m_c_rawChannelPed
std::vector< float > * m_c_rawChannelPed
Definition: EventReaderBaseAlg.h:159
EventReaderBaseAlg::m_zee_px
std::vector< double > * m_zee_px
Definition: EventReaderBaseAlg.h:317
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:97
EventReaderBaseAlg::m_c_channelOFCb
std::vector< std::vector< double > > * m_c_channelOFCb
Definition: EventReaderBaseAlg.h:142
EventReaderBaseAlg::m_c711_clusterIndexCounter
int * m_c711_clusterIndexCounter
Definition: EventReaderBaseAlg.h:182
EventReaderBaseAlg::m_lb_bcidLuminosity
std::vector< std::vector< float > > * m_lb_bcidLuminosity
Definition: EventReaderBaseAlg.h:92
EventReaderBaseAlg::m_hits_energyConv
std::vector< double > * m_hits_energyConv
Definition: EventReaderBaseAlg.h:176
EventReaderBaseAlg::m_zee_py
std::vector< double > * m_zee_py
Definition: EventReaderBaseAlg.h:318
fitman.k
k
Definition: fitman.py:528
EventReaderBaseAlg::m_mc_part_barcode
std::vector< int > * m_mc_part_barcode
Definition: EventReaderBaseAlg.h:252
EventReaderBaseAlg::m_c711_cellPhi
std::vector< double > * m_c711_cellPhi
Definition: EventReaderBaseAlg.h:201
EventReaderBaseAlg::m_c711_channelPed
std::vector< float > * m_c711_channelPed
Definition: EventReaderBaseAlg.h:227
EventReaderBaseAlg::m_etMinProbe
Gaudi::Property< float > m_etMinProbe
define the Pid of Probe from the user
Definition: EventReaderBaseAlg.h:65
EventReaderBaseAlg::m_getLArCalibConstants
Gaudi::Property< bool > m_getLArCalibConstants
Definition: EventReaderBaseAlg.h:76
EventReaderBaseAlg::m_c_channelADC2MEV1
std::vector< float > * m_c_channelADC2MEV1
Definition: EventReaderBaseAlg.h:147
ServiceHandle< ICondSvc >
EventReaderBaseAlg::m_zee_deltaR
std::vector< double > * m_zee_deltaR
Definition: EventReaderBaseAlg.h:321
EventReaderBaseAlg::m_c_clusterCellIndex
std::vector< int > * m_c_clusterCellIndex
Definition: EventReaderBaseAlg.h:115
Generated on Fri Jul 5 2024 21:45:10 for ATLAS Offline Software by   doxygen 1.8.18