ATLAS Offline Software
Loading...
Searching...
No Matches
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.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

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

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.
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
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_uniqueID = 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_uniqueID = 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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

DataObjIDColl m_extendedExtraObjects
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 19 of file EventReaderBaseAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ EventReaderBaseAlg()

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

Definition at line 16 of file EventReaderBaseAlg.cxx.

16 :
17 AthAlgorithm(name, pSvcLocator) {}
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:

◆ ~EventReaderBaseAlg()

EventReaderBaseAlg::~EventReaderBaseAlg ( )
overridevirtual

Definition at line 19 of file EventReaderBaseAlg.cxx.

19{}

Member Function Documentation

◆ bookBranches()

void EventReaderBaseAlg::bookBranches ( TTree * tree)
protected

Definition at line 253 of file EventReaderBaseAlg.cxx.

253 {
254 // ## Event info
255 tree->Branch ("event_RunNumber", &m_e_runNumber);
256 tree->Branch ("event_EventNumber", &m_e_eventNumber);
257 tree->Branch ("event_BCID", &m_e_bcid);
258 tree->Branch ("event_Lumiblock",&m_e_lumiBlock);
259 tree->Branch ("event_avg_mu_inTimePU", &m_e_inTimePileup);
260 tree->Branch ("event_avg_mu_OOTimePU", &m_e_outOfTimePileUp);
261 // #############
262
263 // ## Cluster
264 tree->Branch ("cluster_index",&m_c_clusterIndex);
265 tree->Branch ("c_electronIndex_clusterLvl",&m_c_electronIndex_clusterLvl);
266 tree->Branch ("cluster_et",&m_c_clusterEnergy);
267 tree->Branch ("cluster_time",&m_c_clusterTime);
268 tree->Branch ("cluster_pt",&m_c_clusterPt);
269 tree->Branch ("cluster_eta",&m_c_clusterEta);
270 tree->Branch ("cluster_phi",&m_c_clusterPhi);
271 // Cluster cell
272 tree->Branch ("cluster_index_cellLvl",&m_c_clusterIndex_cellLvl);
273 tree->Branch ("cluster_cell_index",&m_c_clusterCellIndex);
274 tree->Branch ("cluster_cell_caloGain",&m_c_cellGain);
275 tree->Branch ("cluster_cell_layer",&m_c_cellLayer);
276 tree->Branch ("cluster_cell_region",&m_c_cellRegion);
277 tree->Branch ("cluster_cell_energy",&m_c_cellEnergy);
278 tree->Branch ("cluster_cell_time",&m_c_cellTime);
279 tree->Branch ("cluster_cell_eta",&m_c_cellEta);
280 tree->Branch ("cluster_cell_phi",&m_c_cellPhi);
281 tree->Branch ("cluster_cell_deta",&m_c_cellDEta);
282 tree->Branch ("cluster_cell_dphi",&m_c_cellDPhi);
283 tree->Branch ("cluster_cellsDist_dphi",&m_c_cellToClusterDPhi);
284 tree->Branch ("cluster_cellsDist_deta",&m_c_cellToClusterDEta);
285 // Cluster channel (digits and cell ch)
286 tree->Branch ("cluster_index_chLvl",&m_c_clusterIndex_chLvl);
287 tree->Branch ("cluster_channel_index",&m_c_clusterChannelIndex);
288 tree->Branch ("cluster_channel_digits",&m_c_channelDigits);
289 tree->Branch ("cluster_channel_energy",&m_c_channelEnergy);
290 tree->Branch ("cluster_channel_time",&m_c_channelTime);
291 tree->Branch ("cluster_channel_layer",&m_c_channelLayer);
292 if (!m_noBadCells) tree->Branch ("cluster_channel_bad",&m_c_channelBad);
293 tree->Branch ("cluster_channel_chInfo", &m_c_channelChInfo);
294 tree->Branch ("cluster_channel_hash",&m_c_channelHashMap);
295 tree->Branch ("cluster_channel_id",&m_c_channelChannelIdMap);
296 if (m_getLArCalibConstants){
297 tree->Branch ("cluster_channel_effSigma",&m_c_channelEffectiveSigma);
298 tree->Branch ("cluster_channel_noise",&m_c_channelNoise);
299 tree->Branch ("cluster_channel_DSPThreshold",&m_c_channelDSPThreshold);
300 tree->Branch ("cluster_channel_OFCTimeOffset",&m_c_channelOFCTimeOffset);
301 tree->Branch ("cluster_channel_ADC2MeV0",&m_c_channelADC2MEV0);
302 tree->Branch ("cluster_channel_ADC2MeV1",&m_c_channelADC2MEV1);
303 tree->Branch ("cluster_channel_pedestal",&m_c_channelPed);
304 tree->Branch ("cluster_channel_OFCa",&m_c_channelOFCa);
305 tree->Branch ("cluster_channel_OFCb",&m_c_channelOFCb);
306 tree->Branch ("cluster_channel_MinBiasAvg",&m_c_channelMinBiasAvg);
307
308 if (!m_isMC){
309 tree->Branch ("cluster_channel_OfflineEnergyRescaler",&m_c_channelOfflEneRescaler);
310 tree->Branch ("cluster_channel_OfflineHVScale",&m_c_channelOfflHVScale);
311 tree->Branch ("cluster_channel_shape",&m_c_channelShape);
312 tree->Branch ("cluster_channel_shapeDer",&m_c_channelShapeDer);
313 }
314 }
315
316 // Cluster raw channel
317 tree->Branch ("cluster_index_rawChLvl",&m_c_clusterIndex_rawChLvl);
318 tree->Branch ("cluster_rawChannel_index",&m_c_clusterRawChannelIndex);
319 tree->Branch ("cluster_rawChannel_id",&m_c_rawChannelIdMap);
320 tree->Branch ("cluster_rawChannel_amplitude",&m_c_rawChannelAmplitude);
321 tree->Branch ("cluster_rawChannel_time",&m_c_rawChannelTime);
322 tree->Branch ("cluster_rawChannel_layer",&m_c_rawChannelLayer);
323 tree->Branch ("cluster_rawChannel_Ped",&m_c_rawChannelPed);
324 tree->Branch ("cluster_rawChannel_Prov",&m_c_rawChannelProv);
325 tree->Branch ("cluster_rawChannel_qual",&m_c_rawChannelQuality);
326 tree->Branch ("cluster_rawChannel_chInfo",&m_c_rawChannelChInfo); // tree->Branch ("cluster_cell_caloGain",&c_cellGain); //modify
327 if (!m_isMC){
328 tree->Branch ("cluster_rawChannel_DSPThreshold",&m_c_rawChannelDSPThreshold);
329 }
330
331 // ## Cluster EMB2 7_11
332 if (m_doAssocTopoCluster711Dump){
333 tree->Branch ("cluster711_index",&m_c711_clusterIndex);
334 tree->Branch ("c711_electronIndex_clusterLvl",&m_c711_electronIndex_clusterLvl);
335 tree->Branch ("cluster711_et",&m_c711_clusterEnergy);
336 tree->Branch ("cluster711_pt",&m_c711_clusterPt);
337 tree->Branch ("cluster711_time",&m_c711_clusterTime);
338 tree->Branch ("cluster711_eta",&m_c711_clusterEta);
339 tree->Branch ("cluster711_phi",&m_c711_clusterPhi);
340 // Cluster cell
341 tree->Branch ("cluster711_index_cellLvl",&m_c711_clusterIndex_cellLvl);
342 tree->Branch ("cluster711_cell_index",&m_c711_clusterCellIndex);
343 tree->Branch ("cluster711_cell_caloGain",&m_c711_cellGain);
344 tree->Branch ("cluster711_cell_layer",&m_c711_cellLayer);
345 tree->Branch ("cluster711_cell_region",&m_c711_cellRegion);
346 tree->Branch ("cluster711_cell_energy",&m_c711_cellEnergy);
347 tree->Branch ("cluster711_cell_time",&m_c711_cellTime);
348 tree->Branch ("cluster711_cell_eta",&m_c711_cellEta);
349 tree->Branch ("cluster711_cell_phi",&m_c711_cellPhi);
350 tree->Branch ("cluster711_cell_deta",&m_c711_cellDEta);
351 tree->Branch ("cluster711_cell_dphi",&m_c711_cellDPhi);
352 tree->Branch ("cluster711_cellsDist_dphi",&m_c711_cellToClusterDPhi);
353 tree->Branch ("cluster711_cellsDist_deta",&m_c711_cellToClusterDEta);
354 // Cluster channel (digits and cell ch)
355 tree->Branch ("cluster711_index_chLvl",&m_c711_clusterIndex_chLvl);
356 tree->Branch ("cluster711_channel_index",&m_c711_clusterChannelIndex);
357 tree->Branch ("cluster711_channel_digits",&m_c711_channelDigits);
358 tree->Branch ("cluster711_channel_energy",&m_c711_channelEnergy);
359 tree->Branch ("cluster711_channel_time",&m_c711_channelTime);
360 tree->Branch ("cluster711_channel_layer", &m_c711_channelLayer);
361 if (!m_noBadCells) tree->Branch ("cluster711_channel_bad",&m_c711_channelBad);
362 tree->Branch ("cluster711_channel_chInfo", &m_c711_channelChInfo);
363 tree->Branch ("cluster711_channel_hash",&m_c711_channelHashMap);
364 tree->Branch ("cluster711_channel_id",&m_c711_channelChannelIdMap);
365 if (m_getLArCalibConstants){
366 tree->Branch ("cluster711_channel_effSigma",&m_c711_channelEffectiveSigma);
367 tree->Branch ("cluster711_channel_noise",&m_c711_channelNoise);
368 tree->Branch ("cluster711_channel_DSPThreshold",&m_c711_channelDSPThreshold);
369 tree->Branch ("cluster711_channel_OFCTimeOffset",&m_c711_channelOFCTimeOffset);
370 tree->Branch ("cluster711_channel_ADC2MeV0",&m_c711_channelADC2MEV0);
371 tree->Branch ("cluster711_channel_ADC2MeV1",&m_c711_channelADC2MEV1);
372 tree->Branch ("cluster711_channel_pedestal",&m_c711_channelPed);
373 tree->Branch ("cluster711_channel_OFCa",&m_c711_channelOFCa);
374 tree->Branch ("cluster711_channel_OFCb",&m_c711_channelOFCb);
375 tree->Branch ("cluster711_channel_MinBiasAvg",&m_c711_channelMinBiasAvg);
376
377 if (!m_isMC){
378 tree->Branch ("cluster711_channel_OfflineEnergyRescaler",&m_c711_channelOfflEneRescaler);
379 tree->Branch ("cluster711_channel_OfflineHVScale",&m_c711_channelOfflHVScale);
380 tree->Branch ("cluster711_channel_shape",&m_c711_channelShape);
381 tree->Branch ("cluster711_channel_shapeDer",&m_c711_channelShapeDer);
382 }
383 }
384 // Cluster raw channel
385 tree->Branch ("cluster711_index_rawChLvl",&m_c711_clusterIndex_rawChLvl);
386 tree->Branch ("cluster711_rawChannel_index",&m_c711_clusterRawChannelIndex);
387 tree->Branch ("cluster711_rawChannel_id",&m_c711_rawChannelIdMap);
388 tree->Branch ("cluster711_rawChannel_amplitude",&m_c711_rawChannelAmplitude);
389 tree->Branch ("cluster711_rawChannel_time",&m_c711_rawChannelTime);
390 tree->Branch ("cluster711_rawChannel_layer",&m_c711_rawChannelLayer);
391 tree->Branch ("cluster711_rawChannel_Ped",&m_c711_rawChannelPed);
392 tree->Branch ("cluster711_rawChannel_Prov",&m_c711_rawChannelProv);
393 tree->Branch ("cluster711_rawChannel_qual",&m_c711_rawChannelQuality);
394 tree->Branch ("cluster711_rawChannel_chInfo",&m_c711_rawChannelChInfo);
395 if (!m_isMC){
396 tree->Branch ("cluster711_rawChannel_DSPThreshold",&m_c711_rawChannelDSPThreshold);
397 }
398 }
399 // #############
400
401 // ## Particle Truth ##
402 if (m_isMC){
403 if (m_doLArEMBHitsDump){
404 tree->Branch("hits_sampling", &m_hits_sampling);
405 tree->Branch("hits_clusterIndex_chLvl", &m_hits_clusterIndex_chLvl);
406 tree->Branch("hits_clusterChannelIndex", &m_hits_clusterChannelIndex);
407 tree->Branch("hits_hash", &m_hits_hash);
408 tree->Branch("hits_energy", &m_hits_energy);
409 tree->Branch("hits_time", &m_hits_time);
410 tree->Branch("hits_sampFrac", &m_hits_sampFrac);
411 tree->Branch("hits_energyConv", &m_hits_energyConv);
412 tree->Branch("hits_cellEta", &m_hits_cellEta);
413 tree->Branch("hits_cellPhi", &m_hits_cellPhi);
414 }
415
416 if (m_doTruthPartDump){
417 tree->Branch("mc_part_energy",&m_mc_part_energy);
418 tree->Branch("mc_part_pt",&m_mc_part_pt);
419 tree->Branch("mc_part_m",&m_mc_part_m);
420 tree->Branch("mc_part_eta",&m_mc_part_eta);
421 tree->Branch("mc_part_phi",&m_mc_part_phi);
422 tree->Branch("mc_part_pdgId",&m_mc_part_pdgId);
423 tree->Branch("mc_part_status", &m_mc_part_status);
424 tree->Branch("mc_part_barcode", &m_mc_part_uniqueID); // TODO Rename variable name to be consistent?
425 }
426 // ## Vertex Truth ##
427 if (m_doTruthEventDump){
428 tree->Branch("mc_vert_x", &m_mc_vert_x);
429 tree->Branch("mc_vert_y", &m_mc_vert_y);
430 tree->Branch("mc_vert_z", &m_mc_vert_z);
431 tree->Branch("mc_vert_time", &m_mc_vert_time);
432 tree->Branch("mc_vert_perp", &m_mc_vert_perp);
433 tree->Branch("mc_vert_eta", &m_mc_vert_eta);
434 tree->Branch("mc_vert_phi", &m_mc_vert_phi);
435 tree->Branch("mc_vert_barcode", &m_mc_vert_uniqueID); // TODO Rename variable name to be consistent?
436 tree->Branch("mc_vert_status", &m_mc_vert_status);
437 }
438 }
439
440 // ## Photons ##
441 if (m_doPhotonDump){
442 tree->Branch("ph_energy",&m_ph_energy);
443 tree->Branch("ph_pt",&m_ph_pt);
444 tree->Branch("ph_eta",&m_ph_eta);
445 tree->Branch("ph_phi",&m_ph_phi);
446 tree->Branch("ph_m",&m_ph_m);
447 }
448 // ## Primary Vertex
449 tree->Branch("vtx_x",&m_vtx_x);
450 tree->Branch("vtx_y",&m_vtx_y);
451 tree->Branch("vtx_z",&m_vtx_z);
452 tree->Branch("vtx_deltaZ0",&m_vtx_deltaZ0);
453 tree->Branch("vtx_delta_z0_sin",&m_vtx_delta_z0_sin);
454 tree->Branch("vtx_d0sig",&m_vtx_d0sig);
455
456 // ## Electrons ##
457 tree->Branch("el_index",&m_el_index);
458 tree->Branch("el_Pt",&m_el_Pt);
459 tree->Branch("el_et",&m_el_et);
460 tree->Branch("el_Eta",&m_el_Eta);
461 tree->Branch("el_Phi",&m_el_Phi);
462 tree->Branch("el_m",&m_el_m);
463 tree->Branch("el_eoverp",&m_el_eoverp);
464 tree->Branch("el_f1",&m_el_f1);
465 tree->Branch("el_f3",&m_el_f3);
466 tree->Branch("el_eratio",&m_el_eratio);
467 tree->Branch("el_weta1",&m_el_weta1);
468 tree->Branch("el_weta2",&m_el_weta2);
469 tree->Branch("el_fracs1",&m_el_fracs1);
470 tree->Branch("el_wtots1",&m_el_wtots1);
471 tree->Branch("el_e277",&m_el_e277);
472 tree->Branch("el_reta",&m_el_reta);
473 tree->Branch("el_rphi",&m_el_rphi);
474 tree->Branch("el_deltae",&m_el_deltae);
475 tree->Branch("el_rhad",&m_el_rhad);
476 tree->Branch("el_rhad1",&m_el_rhad1);
477
478 // ## Tag and Probe ##
479 // zee
480 if (!m_doElecSelectByTrackOnly && m_doTagAndProbe){
481 tree->Branch("zee_M", &m_zee_M);
482 tree->Branch("zee_E", &m_zee_E);
483 tree->Branch("zee_pt", &m_zee_pt);
484 tree->Branch("zee_px", &m_zee_px);
485 tree->Branch("zee_py", &m_zee_py);
486 tree->Branch("zee_pz", &m_zee_pz);
487 tree->Branch("zee_T", &m_zee_T);
488 tree->Branch("zee_deltaR", &m_zee_deltaR);
489 }
490}
EventReaderBaseAlg::m_vtx_x
std::vector< float > * m_vtx_x
Definition EventReaderBaseAlg.h:255
EventReaderBaseAlg::m_doTruthEventDump
Gaudi::Property< bool > m_doTruthEventDump
Definition EventReaderBaseAlg.h:61
EventReaderBaseAlg::m_c_channelShape
std::vector< std::vector< double > > * m_c_channelShape
Definition EventReaderBaseAlg.h:132
EventReaderBaseAlg::m_el_deltae
std::vector< float > * m_el_deltae
Definition EventReaderBaseAlg.h:288
EventReaderBaseAlg::m_c_channelPed
std::vector< float > * m_c_channelPed
Definition EventReaderBaseAlg.h:137
EventReaderBaseAlg::m_doAssocTopoCluster711Dump
Gaudi::Property< bool > m_doAssocTopoCluster711Dump
Definition EventReaderBaseAlg.h:67
EventReaderBaseAlg::m_c_clusterIndex_rawChLvl
std::vector< int > * m_c_clusterIndex_rawChLvl
Definition EventReaderBaseAlg.h:152
EventReaderBaseAlg::m_c_clusterEnergy
std::vector< double > * m_c_clusterEnergy
Definition EventReaderBaseAlg.h:96
EventReaderBaseAlg::m_e_eventNumber
unsigned long long m_e_eventNumber
Definition EventReaderBaseAlg.h:87
EventReaderBaseAlg::m_c711_cellEnergy
std::vector< double > * m_c711_cellEnergy
Definition EventReaderBaseAlg.h:187
EventReaderBaseAlg::m_c_rawChannelQuality
std::vector< float > * m_c_rawChannelQuality
Definition EventReaderBaseAlg.h:150
EventReaderBaseAlg::m_c711_cellRegion
std::vector< int > * m_c711_cellRegion
Definition EventReaderBaseAlg.h:186
EventReaderBaseAlg::m_el_fracs1
std::vector< float > * m_el_fracs1
Definition EventReaderBaseAlg.h:283
EventReaderBaseAlg::m_c711_channelTime
std::vector< double > * m_c711_channelTime
Definition EventReaderBaseAlg.h:201
EventReaderBaseAlg::m_c_cellRegion
std::vector< int > * m_c_cellRegion
Definition EventReaderBaseAlg.h:107
EventReaderBaseAlg::m_c_channelChannelIdMap
std::vector< unsigned int > * m_c_channelChannelIdMap
Definition EventReaderBaseAlg.h:126
EventReaderBaseAlg::m_ph_energy
std::vector< float > * m_ph_energy
Definition EventReaderBaseAlg.h:266
EventReaderBaseAlg::m_zee_py
std::vector< double > * m_zee_py
Definition EventReaderBaseAlg.h:307
EventReaderBaseAlg::m_el_wtots1
std::vector< float > * m_el_wtots1
Definition EventReaderBaseAlg.h:284
EventReaderBaseAlg::m_hits_cellPhi
std::vector< double > * m_hits_cellPhi
Definition EventReaderBaseAlg.h:167
EventReaderBaseAlg::m_c711_cellLayer
std::vector< int > * m_c711_cellLayer
Definition EventReaderBaseAlg.h:185
EventReaderBaseAlg::m_c711_cellToClusterDEta
std::vector< double > * m_c711_cellToClusterDEta
Definition EventReaderBaseAlg.h:194
EventReaderBaseAlg::m_el_Phi
std::vector< float > * m_el_Phi
Definition EventReaderBaseAlg.h:274
EventReaderBaseAlg::m_c_channelShapeDer
std::vector< std::vector< double > > * m_c_channelShapeDer
Definition EventReaderBaseAlg.h:133
EventReaderBaseAlg::m_doLArEMBHitsDump
Gaudi::Property< bool > m_doLArEMBHitsDump
Definition EventReaderBaseAlg.h:63
EventReaderBaseAlg::m_c_clusterChannelIndex
std::vector< int > * m_c_clusterChannelIndex
Definition EventReaderBaseAlg.h:118
EventReaderBaseAlg::m_zee_px
std::vector< double > * m_zee_px
Definition EventReaderBaseAlg.h:306
EventReaderBaseAlg::m_ph_eta
std::vector< float > * m_ph_eta
Definition EventReaderBaseAlg.h:263
EventReaderBaseAlg::m_zee_deltaR
std::vector< double > * m_zee_deltaR
Definition EventReaderBaseAlg.h:310
EventReaderBaseAlg::m_c711_clusterCellIndex
std::vector< int > * m_c711_clusterCellIndex
Definition EventReaderBaseAlg.h:183
EventReaderBaseAlg::m_c_channelBad
std::vector< bool > * m_c_channelBad
Definition EventReaderBaseAlg.h:124
EventReaderBaseAlg::m_c711_rawChannelLayer
std::vector< int > * m_c711_rawChannelLayer
Definition EventReaderBaseAlg.h:225
EventReaderBaseAlg::m_c711_channelOfflHVScale
std::vector< float > * m_c711_channelOfflHVScale
Definition EventReaderBaseAlg.h:218
EventReaderBaseAlg::m_hits_energyConv
std::vector< double > * m_hits_energyConv
Definition EventReaderBaseAlg.h:165
EventReaderBaseAlg::m_c_cellTime
std::vector< double > * m_c_cellTime
Definition EventReaderBaseAlg.h:109
EventReaderBaseAlg::m_c711_rawChannelAmplitude
std::vector< float > * m_c711_rawChannelAmplitude
Definition EventReaderBaseAlg.h:223
EventReaderBaseAlg::m_c711_clusterIndex
std::vector< int > * m_c711_clusterIndex
Definition EventReaderBaseAlg.h:172
EventReaderBaseAlg::m_c_rawChannelProv
std::vector< float > * m_c_rawChannelProv
Definition EventReaderBaseAlg.h:149
EventReaderBaseAlg::m_el_e277
std::vector< float > * m_el_e277
Definition EventReaderBaseAlg.h:285
EventReaderBaseAlg::m_c711_cellGain
std::vector< int > * m_c711_cellGain
Definition EventReaderBaseAlg.h:184
EventReaderBaseAlg::m_el_rhad
std::vector< float > * m_el_rhad
Definition EventReaderBaseAlg.h:289
EventReaderBaseAlg::m_c711_clusterTime
std::vector< double > * m_c711_clusterTime
Definition EventReaderBaseAlg.h:175
EventReaderBaseAlg::m_c711_rawChannelQuality
std::vector< float > * m_c711_rawChannelQuality
Definition EventReaderBaseAlg.h:228
EventReaderBaseAlg::m_vtx_d0sig
std::vector< double > * m_vtx_d0sig
Definition EventReaderBaseAlg.h:260
EventReaderBaseAlg::m_mc_vert_status
std::vector< int > * m_mc_vert_status
Definition EventReaderBaseAlg.h:252
EventReaderBaseAlg::m_c_channelOFCb
std::vector< std::vector< double > > * m_c_channelOFCb
Definition EventReaderBaseAlg.h:131
EventReaderBaseAlg::m_c711_clusterIndex_rawChLvl
std::vector< int > * m_c711_clusterIndex_rawChLvl
Definition EventReaderBaseAlg.h:230
EventReaderBaseAlg::m_mc_vert_phi
std::vector< float > * m_mc_vert_phi
Definition EventReaderBaseAlg.h:250
EventReaderBaseAlg::m_c_channelOFCa
std::vector< std::vector< double > > * m_c_channelOFCa
Definition EventReaderBaseAlg.h:130
EventReaderBaseAlg::m_mc_part_pdgId
std::vector< int > * m_mc_part_pdgId
Definition EventReaderBaseAlg.h:239
EventReaderBaseAlg::m_c711_clusterRawChannelIndex
std::vector< float > * m_c711_clusterRawChannelIndex
Definition EventReaderBaseAlg.h:229
EventReaderBaseAlg::m_c_rawChannelAmplitude
std::vector< float > * m_c_rawChannelAmplitude
Definition EventReaderBaseAlg.h:145
EventReaderBaseAlg::m_mc_vert_z
std::vector< float > * m_mc_vert_z
Definition EventReaderBaseAlg.h:246
EventReaderBaseAlg::m_c711_rawChannelPed
std::vector< float > * m_c711_rawChannelPed
Definition EventReaderBaseAlg.h:226
EventReaderBaseAlg::m_c_cellPhi
std::vector< double > * m_c_cellPhi
Definition EventReaderBaseAlg.h:111
EventReaderBaseAlg::m_c711_electronIndex_clusterLvl
std::vector< int > * m_c711_electronIndex_clusterLvl
Definition EventReaderBaseAlg.h:173
EventReaderBaseAlg::m_vtx_delta_z0_sin
std::vector< float > * m_vtx_delta_z0_sin
Definition EventReaderBaseAlg.h:259
EventReaderBaseAlg::m_c_cellEnergy
std::vector< double > * m_c_cellEnergy
Definition EventReaderBaseAlg.h:108
EventReaderBaseAlg::m_c711_channelDigits
std::vector< std::vector< float > > * m_c711_channelDigits
Definition EventReaderBaseAlg.h:199
EventReaderBaseAlg::m_c711_channelOFCTimeOffset
std::vector< double > * m_c711_channelOFCTimeOffset
Definition EventReaderBaseAlg.h:213
EventReaderBaseAlg::m_c_clusterIndex_chLvl
std::vector< int > * m_c_clusterIndex_chLvl
Definition EventReaderBaseAlg.h:117
EventReaderBaseAlg::m_mc_vert_y
std::vector< float > * m_mc_vert_y
Definition EventReaderBaseAlg.h:245
EventReaderBaseAlg::m_zee_pt
std::vector< double > * m_zee_pt
Definition EventReaderBaseAlg.h:305
EventReaderBaseAlg::m_hits_sampFrac
std::vector< float > * m_hits_sampFrac
Definition EventReaderBaseAlg.h:164
EventReaderBaseAlg::m_c_cellLayer
std::vector< int > * m_c_cellLayer
Definition EventReaderBaseAlg.h:106
EventReaderBaseAlg::m_c_clusterPt
std::vector< double > * m_c_clusterPt
Definition EventReaderBaseAlg.h:100
EventReaderBaseAlg::m_c_rawChannelPed
std::vector< float > * m_c_rawChannelPed
Definition EventReaderBaseAlg.h:148
EventReaderBaseAlg::m_mc_part_pt
std::vector< float > * m_mc_part_pt
Definition EventReaderBaseAlg.h:235
EventReaderBaseAlg::m_c_clusterIndex
std::vector< int > * m_c_clusterIndex
Definition EventReaderBaseAlg.h:94
EventReaderBaseAlg::m_c_cellToClusterDPhi
std::vector< double > * m_c_cellToClusterDPhi
Definition EventReaderBaseAlg.h:114
EventReaderBaseAlg::m_c_channelNoise
std::vector< float > * m_c_channelNoise
Definition EventReaderBaseAlg.h:128
EventReaderBaseAlg::m_hits_clusterChannelIndex
std::vector< int > * m_hits_clusterChannelIndex
Definition EventReaderBaseAlg.h:160
EventReaderBaseAlg::m_c711_channelPed
std::vector< float > * m_c711_channelPed
Definition EventReaderBaseAlg.h:216
EventReaderBaseAlg::m_c711_clusterEta
std::vector< double > * m_c711_clusterEta
Definition EventReaderBaseAlg.h:176
EventReaderBaseAlg::m_el_f1
std::vector< float > * m_el_f1
Definition EventReaderBaseAlg.h:278
EventReaderBaseAlg::m_c_clusterRawChannelIndex
std::vector< float > * m_c_clusterRawChannelIndex
Definition EventReaderBaseAlg.h:151
EventReaderBaseAlg::m_el_Pt
std::vector< float > * m_el_Pt
Definition EventReaderBaseAlg.h:271
EventReaderBaseAlg::m_c711_channelEffectiveSigma
std::vector< float > * m_c711_channelEffectiveSigma
Definition EventReaderBaseAlg.h:206
EventReaderBaseAlg::m_c_clusterCellIndex
std::vector< int > * m_c_clusterCellIndex
Definition EventReaderBaseAlg.h:104
EventReaderBaseAlg::m_ph_pt
std::vector< float > * m_ph_pt
Definition EventReaderBaseAlg.h:265
EventReaderBaseAlg::m_c_channelEffectiveSigma
std::vector< float > * m_c_channelEffectiveSigma
Definition EventReaderBaseAlg.h:127
EventReaderBaseAlg::m_c_channelHashMap
std::vector< unsigned int > * m_c_channelHashMap
Definition EventReaderBaseAlg.h:125
EventReaderBaseAlg::m_c711_clusterChannelIndex
std::vector< int > * m_c711_clusterChannelIndex
Definition EventReaderBaseAlg.h:197
EventReaderBaseAlg::m_c_rawChannelLayer
std::vector< int > * m_c_rawChannelLayer
Definition EventReaderBaseAlg.h:147
EventReaderBaseAlg::m_c711_cellDPhi
std::vector< double > * m_c711_cellDPhi
Definition EventReaderBaseAlg.h:192
EventReaderBaseAlg::m_c711_channelLayer
std::vector< int > * m_c711_channelLayer
Definition EventReaderBaseAlg.h:202
EventReaderBaseAlg::m_c_channelDigits
std::vector< std::vector< float > > * m_c_channelDigits
Definition EventReaderBaseAlg.h:120
EventReaderBaseAlg::m_c_cellEta
std::vector< double > * m_c_cellEta
Definition EventReaderBaseAlg.h:110
EventReaderBaseAlg::m_c_cellDEta
std::vector< double > * m_c_cellDEta
Definition EventReaderBaseAlg.h:112
EventReaderBaseAlg::m_c711_channelMinBiasAvg
std::vector< float > * m_c711_channelMinBiasAvg
Definition EventReaderBaseAlg.h:217
EventReaderBaseAlg::m_c711_rawChannelTime
std::vector< float > * m_c711_rawChannelTime
Definition EventReaderBaseAlg.h:224
EventReaderBaseAlg::m_c711_cellTime
std::vector< double > * m_c711_cellTime
Definition EventReaderBaseAlg.h:188
EventReaderBaseAlg::m_c711_channelShapeDer
std::vector< std::vector< double > > * m_c711_channelShapeDer
Definition EventReaderBaseAlg.h:212
EventReaderBaseAlg::m_ph_phi
std::vector< float > * m_ph_phi
Definition EventReaderBaseAlg.h:264
EventReaderBaseAlg::m_hits_cellEta
std::vector< double > * m_hits_cellEta
Definition EventReaderBaseAlg.h:166
EventReaderBaseAlg::m_doTruthPartDump
Gaudi::Property< bool > m_doTruthPartDump
Definition EventReaderBaseAlg.h:62
EventReaderBaseAlg::m_c_channelOfflEneRescaler
std::vector< float > * m_c_channelOfflEneRescaler
Definition EventReaderBaseAlg.h:140
EventReaderBaseAlg::m_zee_M
std::vector< double > * m_zee_M
Definition EventReaderBaseAlg.h:303
EventReaderBaseAlg::m_c711_channelDSPThreshold
std::vector< float > * m_c711_channelDSPThreshold
Definition EventReaderBaseAlg.h:208
EventReaderBaseAlg::m_zee_pz
std::vector< double > * m_zee_pz
Definition EventReaderBaseAlg.h:308
EventReaderBaseAlg::m_c711_clusterPhi
std::vector< double > * m_c711_clusterPhi
Definition EventReaderBaseAlg.h:177
EventReaderBaseAlg::m_c711_rawChannelChInfo
std::vector< std::vector< int > > * m_c711_rawChannelChInfo
Definition EventReaderBaseAlg.h:221
EventReaderBaseAlg::m_c_cellDPhi
std::vector< double > * m_c_cellDPhi
Definition EventReaderBaseAlg.h:113
EventReaderBaseAlg::m_el_rhad1
std::vector< float > * m_el_rhad1
Definition EventReaderBaseAlg.h:290
EventReaderBaseAlg::m_el_weta1
std::vector< float > * m_el_weta1
Definition EventReaderBaseAlg.h:281
EventReaderBaseAlg::m_c711_channelBad
std::vector< bool > * m_c711_channelBad
Definition EventReaderBaseAlg.h:203
EventReaderBaseAlg::m_el_et
std::vector< float > * m_el_et
Definition EventReaderBaseAlg.h:272
EventReaderBaseAlg::m_c711_clusterPt
std::vector< double > * m_c711_clusterPt
Definition EventReaderBaseAlg.h:178
EventReaderBaseAlg::m_c711_channelChInfo
std::vector< std::vector< int > > * m_c711_channelChInfo
Definition EventReaderBaseAlg.h:198
EventReaderBaseAlg::m_vtx_z
std::vector< float > * m_vtx_z
Definition EventReaderBaseAlg.h:257
EventReaderBaseAlg::m_c_channelLayer
std::vector< int > * m_c_channelLayer
Definition EventReaderBaseAlg.h:123
EventReaderBaseAlg::m_zee_T
std::vector< double > * m_zee_T
Definition EventReaderBaseAlg.h:309
EventReaderBaseAlg::m_c711_clusterIndex_cellLvl
std::vector< int > * m_c711_clusterIndex_cellLvl
Definition EventReaderBaseAlg.h:182
EventReaderBaseAlg::m_c_clusterPhi
std::vector< double > * m_c_clusterPhi
Definition EventReaderBaseAlg.h:99
EventReaderBaseAlg::m_c711_clusterEnergy
std::vector< double > * m_c711_clusterEnergy
Definition EventReaderBaseAlg.h:174
EventReaderBaseAlg::m_el_index
std::vector< int > * m_el_index
Definition EventReaderBaseAlg.h:270
EventReaderBaseAlg::m_c_rawChannelChInfo
std::vector< std::vector< int > > * m_c_rawChannelChInfo
Definition EventReaderBaseAlg.h:143
EventReaderBaseAlg::m_c711_cellPhi
std::vector< double > * m_c711_cellPhi
Definition EventReaderBaseAlg.h:190
EventReaderBaseAlg::m_c711_cellEta
std::vector< double > * m_c711_cellEta
Definition EventReaderBaseAlg.h:189
EventReaderBaseAlg::m_mc_part_status
std::vector< int > * m_mc_part_status
Definition EventReaderBaseAlg.h:240
EventReaderBaseAlg::m_doTagAndProbe
Gaudi::Property< bool > m_doTagAndProbe
Definition EventReaderBaseAlg.h:59
EventReaderBaseAlg::m_c711_channelOFCa
std::vector< std::vector< double > > * m_c711_channelOFCa
Definition EventReaderBaseAlg.h:209
EventReaderBaseAlg::m_isMC
Gaudi::Property< bool > m_isMC
Definition EventReaderBaseAlg.h:64
EventReaderBaseAlg::m_mc_vert_uniqueID
std::vector< int > * m_mc_vert_uniqueID
Definition EventReaderBaseAlg.h:251
EventReaderBaseAlg::m_hits_energy
std::vector< double > * m_hits_energy
Definition EventReaderBaseAlg.h:162
EventReaderBaseAlg::m_c_channelADC2MEV1
std::vector< float > * m_c_channelADC2MEV1
Definition EventReaderBaseAlg.h:136
EventReaderBaseAlg::m_mc_part_eta
std::vector< float > * m_mc_part_eta
Definition EventReaderBaseAlg.h:237
EventReaderBaseAlg::m_mc_part_energy
std::vector< float > * m_mc_part_energy
Definition EventReaderBaseAlg.h:234
EventReaderBaseAlg::m_c711_channelShape
std::vector< std::vector< double > > * m_c711_channelShape
Definition EventReaderBaseAlg.h:211
EventReaderBaseAlg::m_el_Eta
std::vector< float > * m_el_Eta
Definition EventReaderBaseAlg.h:273
EventReaderBaseAlg::m_c_channelOfflHVScale
std::vector< float > * m_c_channelOfflHVScale
Definition EventReaderBaseAlg.h:139
EventReaderBaseAlg::m_c_channelTime
std::vector< double > * m_c_channelTime
Definition EventReaderBaseAlg.h:122
EventReaderBaseAlg::m_c711_cellDEta
std::vector< double > * m_c711_cellDEta
Definition EventReaderBaseAlg.h:191
EventReaderBaseAlg::m_getLArCalibConstants
Gaudi::Property< bool > m_getLArCalibConstants
Definition EventReaderBaseAlg.h:65
EventReaderBaseAlg::m_c_clusterIndex_cellLvl
std::vector< int > * m_c_clusterIndex_cellLvl
Definition EventReaderBaseAlg.h:103
EventReaderBaseAlg::m_c_clusterTime
std::vector< double > * m_c_clusterTime
Definition EventReaderBaseAlg.h:97
EventReaderBaseAlg::m_c_channelMinBiasAvg
std::vector< float > * m_c_channelMinBiasAvg
Definition EventReaderBaseAlg.h:138
EventReaderBaseAlg::m_mc_vert_time
std::vector< float > * m_mc_vert_time
Definition EventReaderBaseAlg.h:247
EventReaderBaseAlg::m_c711_clusterIndex_chLvl
std::vector< int > * m_c711_clusterIndex_chLvl
Definition EventReaderBaseAlg.h:196
EventReaderBaseAlg::m_c_channelDSPThreshold
std::vector< float > * m_c_channelDSPThreshold
Definition EventReaderBaseAlg.h:129
EventReaderBaseAlg::m_c711_channelNoise
std::vector< float > * m_c711_channelNoise
Definition EventReaderBaseAlg.h:207
EventReaderBaseAlg::m_c_clusterEta
std::vector< double > * m_c_clusterEta
Definition EventReaderBaseAlg.h:98
EventReaderBaseAlg::m_c_cellGain
std::vector< int > * m_c_cellGain
Definition EventReaderBaseAlg.h:105
EventReaderBaseAlg::m_mc_part_phi
std::vector< float > * m_mc_part_phi
Definition EventReaderBaseAlg.h:238
EventReaderBaseAlg::m_c711_channelEnergy
std::vector< double > * m_c711_channelEnergy
Definition EventReaderBaseAlg.h:200
EventReaderBaseAlg::m_c_channelADC2MEV0
std::vector< float > * m_c_channelADC2MEV0
Definition EventReaderBaseAlg.h:135
EventReaderBaseAlg::m_c_electronIndex_clusterLvl
std::vector< int > * m_c_electronIndex_clusterLvl
Definition EventReaderBaseAlg.h:95
EventReaderBaseAlg::m_mc_part_m
std::vector< float > * m_mc_part_m
Definition EventReaderBaseAlg.h:236
EventReaderBaseAlg::m_zee_E
std::vector< double > * m_zee_E
Definition EventReaderBaseAlg.h:304
EventReaderBaseAlg::m_c711_channelOFCb
std::vector< std::vector< double > > * m_c711_channelOFCb
Definition EventReaderBaseAlg.h:210
EventReaderBaseAlg::m_mc_vert_x
std::vector< float > * m_mc_vert_x
Definition EventReaderBaseAlg.h:244
EventReaderBaseAlg::m_c711_channelADC2MEV0
std::vector< float > * m_c711_channelADC2MEV0
Definition EventReaderBaseAlg.h:214
EventReaderBaseAlg::m_c711_channelOfflEneRescaler
std::vector< float > * m_c711_channelOfflEneRescaler
Definition EventReaderBaseAlg.h:219
EventReaderBaseAlg::m_vtx_deltaZ0
std::vector< float > * m_vtx_deltaZ0
Definition EventReaderBaseAlg.h:258
EventReaderBaseAlg::m_c711_cellToClusterDPhi
std::vector< double > * m_c711_cellToClusterDPhi
Definition EventReaderBaseAlg.h:193
EventReaderBaseAlg::m_hits_sampling
std::vector< int > * m_hits_sampling
Definition EventReaderBaseAlg.h:158
EventReaderBaseAlg::m_c_channelChInfo
std::vector< std::vector< int > > * m_c_channelChInfo
Definition EventReaderBaseAlg.h:119
EventReaderBaseAlg::m_c_rawChannelDSPThreshold
std::vector< float > * m_c_rawChannelDSPThreshold
Definition EventReaderBaseAlg.h:153
EventReaderBaseAlg::m_vtx_y
std::vector< float > * m_vtx_y
Definition EventReaderBaseAlg.h:256
EventReaderBaseAlg::m_c_channelEnergy
std::vector< double > * m_c_channelEnergy
Definition EventReaderBaseAlg.h:121
EventReaderBaseAlg::m_el_rphi
std::vector< float > * m_el_rphi
Definition EventReaderBaseAlg.h:287
EventReaderBaseAlg::m_doElecSelectByTrackOnly
Gaudi::Property< bool > m_doElecSelectByTrackOnly
Definition EventReaderBaseAlg.h:58
EventReaderBaseAlg::m_doPhotonDump
Gaudi::Property< bool > m_doPhotonDump
Definition EventReaderBaseAlg.h:60
EventReaderBaseAlg::m_c_channelOFCTimeOffset
std::vector< double > * m_c_channelOFCTimeOffset
Definition EventReaderBaseAlg.h:134
EventReaderBaseAlg::m_c711_rawChannelIdMap
std::vector< unsigned int > * m_c711_rawChannelIdMap
Definition EventReaderBaseAlg.h:222
EventReaderBaseAlg::m_el_eratio
std::vector< float > * m_el_eratio
Definition EventReaderBaseAlg.h:280
EventReaderBaseAlg::m_hits_hash
std::vector< unsigned int > * m_hits_hash
Definition EventReaderBaseAlg.h:161
EventReaderBaseAlg::m_c_rawChannelTime
std::vector< float > * m_c_rawChannelTime
Definition EventReaderBaseAlg.h:146
EventReaderBaseAlg::m_noBadCells
Gaudi::Property< bool > m_noBadCells
Definition EventReaderBaseAlg.h:66
EventReaderBaseAlg::m_ph_m
std::vector< float > * m_ph_m
Definition EventReaderBaseAlg.h:267
EventReaderBaseAlg::m_c711_rawChannelDSPThreshold
std::vector< float > * m_c711_rawChannelDSPThreshold
Definition EventReaderBaseAlg.h:231
EventReaderBaseAlg::m_mc_vert_eta
std::vector< float > * m_mc_vert_eta
Definition EventReaderBaseAlg.h:249
EventReaderBaseAlg::m_c711_rawChannelProv
std::vector< float > * m_c711_rawChannelProv
Definition EventReaderBaseAlg.h:227
EventReaderBaseAlg::m_mc_part_uniqueID
std::vector< int > * m_mc_part_uniqueID
Definition EventReaderBaseAlg.h:241
EventReaderBaseAlg::m_el_f3
std::vector< float > * m_el_f3
Definition EventReaderBaseAlg.h:279
EventReaderBaseAlg::m_el_reta
std::vector< float > * m_el_reta
Definition EventReaderBaseAlg.h:286
EventReaderBaseAlg::m_c711_channelChannelIdMap
std::vector< unsigned int > * m_c711_channelChannelIdMap
Definition EventReaderBaseAlg.h:205
EventReaderBaseAlg::m_hits_clusterIndex_chLvl
std::vector< int > * m_hits_clusterIndex_chLvl
Definition EventReaderBaseAlg.h:159
EventReaderBaseAlg::m_mc_vert_perp
std::vector< float > * m_mc_vert_perp
Definition EventReaderBaseAlg.h:248
EventReaderBaseAlg::m_c711_channelADC2MEV1
std::vector< float > * m_c711_channelADC2MEV1
Definition EventReaderBaseAlg.h:215
EventReaderBaseAlg::m_el_weta2
std::vector< float > * m_el_weta2
Definition EventReaderBaseAlg.h:282
EventReaderBaseAlg::m_el_eoverp
std::vector< float > * m_el_eoverp
Definition EventReaderBaseAlg.h:276
EventReaderBaseAlg::m_el_m
std::vector< float > * m_el_m
Definition EventReaderBaseAlg.h:275
EventReaderBaseAlg::m_c_cellToClusterDEta
std::vector< double > * m_c_cellToClusterDEta
Definition EventReaderBaseAlg.h:115
EventReaderBaseAlg::m_c_rawChannelIdMap
std::vector< unsigned int > * m_c_rawChannelIdMap
Definition EventReaderBaseAlg.h:144
EventReaderBaseAlg::m_hits_time
std::vector< double > * m_hits_time
Definition EventReaderBaseAlg.h:163
EventReaderBaseAlg::m_c711_channelHashMap
std::vector< unsigned int > * m_c711_channelHashMap
Definition EventReaderBaseAlg.h:204
tree
TChain * tree
Definition tile_monitor.h:30

◆ bookDatabaseBranches()

void EventReaderBaseAlg::bookDatabaseBranches ( TTree * tree)
protected

Definition at line 237 of file EventReaderBaseAlg.cxx.

237 {
238 // ## BCID/Luminosity vector
239 tree->Branch ("lb_lumiblock",&m_lb_lumiblock);
240 if (!m_isMC){
241 tree->Branch ("lb_bcidLuminosity",&m_lb_bcidLuminosity);
242 }
243}
EventReaderBaseAlg::m_lb_bcidLuminosity
std::vector< std::vector< float > > * m_lb_bcidLuminosity
Definition EventReaderBaseAlg.h:81
EventReaderBaseAlg::m_lb_lumiblock
std::vector< int > * m_lb_lumiblock
Definition EventReaderBaseAlg.h:82

◆ clear()

void EventReaderBaseAlg::clear ( )
protected

Definition at line 492 of file EventReaderBaseAlg.cxx.

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

◆ clearLBData()

void EventReaderBaseAlg::clearLBData ( )
protected

Definition at line 245 of file EventReaderBaseAlg.cxx.

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

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ deltaPhi()

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

Definition at line 224 of file EventReaderBaseAlg.cxx.

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

◆ deltaR()

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

Definition at line 230 of file EventReaderBaseAlg.cxx.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ eOverPElectron()

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

Definition at line 31 of file EventReaderBaseAlg.cxx.

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

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode EventReaderBaseAlg::execute ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 24 of file EventReaderBaseAlg.cxx.

24 {
25 return StatusCode::SUCCESS;
26}

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ finalize()

StatusCode EventReaderBaseAlg::finalize ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 27 of file EventReaderBaseAlg.cxx.

27 {
28 return StatusCode::SUCCESS;
29}

◆ fixPhi()

double EventReaderBaseAlg::fixPhi ( double phi)
protected

Definition at line 217 of file EventReaderBaseAlg.cxx.

217 {
218 // Verify the phi value, if its in -pi,pi interval, then shifts 2pi in the correct direction.
219 if (phi < -1*pi) return (phi + 2*pi);
220 if (phi > 1*pi) return (phi - 2*pi);
221 return phi;
222}
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
pi
#define pi
Definition TileMuonFitter.cxx:65

◆ getCaloRegionIndex()

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

Definition at line 205 of file EventReaderBaseAlg.cxx.

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

◆ initialize()

StatusCode EventReaderBaseAlg::initialize ( )
overridevirtual

Reimplemented in EventReaderAlg.

Definition at line 21 of file EventReaderBaseAlg.cxx.

21 {
22 return StatusCode::SUCCESS;
23}

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isEtaOutsideLArCrack()

bool EventReaderBaseAlg::isEtaOutsideLArCrack ( float absEta)
protected

Definition at line 196 of file EventReaderBaseAlg.cxx.

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

◆ isGoodProbeElectron()

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

Definition at line 157 of file EventReaderBaseAlg.cxx.

157 {
158 // |eta| < 1.475
159 if ( fabs(el->eta()) > 1.475 ){ // EM Barrel
160 ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron |eta| > 1.475 (" << fabs(el->eta()) << ").");
161 return false;
162 }
163
164 // electron object quality
165 ATH_MSG_DEBUG (" (isGoodProbeElectron) Checking Probe electron object quality...");
166 if ( !el->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)){
167 ATH_MSG_DEBUG (" (isGoodProbeElectron) \tProbe Electron is a BADCLUSELECTRON.");
168 return false;
169 }
170
171 // Et > 15 GeV
172 float electronPt = el->pt();
173 if (electronPt * GeV < m_etMinProbe ){
174 ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Et/pT < " << m_etMinProbe << " GeV (pT="<< electronPt * GeV<<")");
175 return false;
176 }
177
178 // is outside the crack
179 float absEta = fabs(el->caloCluster()->etaBE(2));
180 if ( !isEtaOutsideLArCrack(absEta) ){
181 ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron Eta inside LAr crack region...");
182 return false;
183 }
184
185 // loose ID Cut
186 bool isGood;
187 if (! el->passSelection(isGood, m_offProbeTightness)){
188 ATH_MSG_DEBUG("(isGoodProbeElectron) Misconfiguration: " << m_offProbeTightness << " is not a valid working point for electrons");
189 return false;
190 }
191
192 ATH_MSG_DEBUG ("(isGoodProbeElectron) Electron is a good probe!");
193 return true;
194}
EventReaderBaseAlg::isEtaOutsideLArCrack
bool isEtaOutsideLArCrack(float absEta)
Definition EventReaderBaseAlg.cxx:196
EventReaderBaseAlg::m_offProbeTightness
Gaudi::Property< std::string > m_offProbeTightness
Define the PID for tag electron.
Definition EventReaderBaseAlg.h:53
EventReaderBaseAlg::m_etMinProbe
Gaudi::Property< float > m_etMinProbe
define the Pid of Probe from the user
Definition EventReaderBaseAlg.h:54
TauScalarVars::absEta
bool absEta(const xAOD::TauJet &tau, float &out)
Definition TauGNNDataLoader.cxx:118
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition EgammaDefs.h:116

◆ isTagElectron()

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

Definition at line 116 of file EventReaderBaseAlg.cxx.

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

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ 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 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

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

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}
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition AthAlgorithm.cxx:66
AthCommonDataStore< AthCommonMsg< Algorithm > >::AthCommonDataStore
AthCommonDataStore(const std::string &name, T... args)
Definition AthCommonDataStore.h:55
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ sysStart()

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

Handle START transition.

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

◆ trackSelectionElectrons()

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

Definition at line 52 of file EventReaderBaseAlg.cxx.

52 {
53
54 const xAOD::TrackParticle *trackElectron = electron->trackParticle();
55 const xAOD::CaloCluster *elClus = electron->caloCluster();
56
57 if (!trackElectron) { //is there track?
58 ATH_MSG_DEBUG ("(trackSelectionElectrons) No track particle for Tag check.");
59 return false;
60 }
61 // caloCluster
62 if (!elClus){ //is there a calo cluster associated to this electron?
63 ATH_MSG_DEBUG ("(trackSelectionElectrons) No caloCluster associated for Tag check.");
64 return false;
65 }
66
67 // track_pt > 7 GeV
68 if (! ( (trackElectron->pt() * GeV ) > 7) ){
69 ATH_MSG_DEBUG ("(trackSelectionElectrons) Pt_Track of the electron is below 7 GeV. Electron rejected.");
70 return false;
71 }
72 // |eta| < 2.47
73 if (! (fabs(trackElectron->eta()) < 2.47 )){
74 ATH_MSG_DEBUG ("(trackSelectionElectrons) Electron track_eta is above 2.47. Electron rejected.");
75 return false;
76 }
77
78 // check for primary vertex in the event
79 // *************** Primary vertex check ***************
80 //loop over vertices and look for good primary vertex
81 bool isPrimVtx = false;
82 bool passDeltaZ0sin = false;
83 // for (xAOD::VertexContainer::const_iterator vxIter = primVertexCnt->begin(); vxIter != primVertexCnt->end(); ++vxIter) {
84 for ( const xAOD::Vertex *vertex : *primVertexCnt){
85 // Select good primary vertex
86 float delta_z0 = fabs(trackElectron->z0() + trackElectron->vz() - vertex->z()); //where trk.vz() represents the point of reference for the z0 calculation (in this case, the beamspot position along the z axis).
87 float delta_z0_sin = delta_z0 * sin(trackElectron->theta()); //where sin(trk.theta()) parameterises the uncertainty of the z0 measurement.
88
89 if ((vertex->vertexType() == xAOD::VxType::PriVtx) && ( delta_z0_sin < m_z0Tag)){
90 isPrimVtx = true; //check for primary vertex in each vertex of the event.
91 passDeltaZ0sin = true; // and check if the longitudinal impact parameter difference for electron-to-vertex association.
92
93 ATH_MSG_DEBUG ("(trackSelectionElectrons) delta_z0_sin < 0.5 mm ("<< delta_z0_sin << ")");
94 ATH_MSG_DEBUG ("(trackSelectionElectrons) There is a primary vertex in the event.");
95 break;
96 }
97 }
98
99 // delta_z0_sin <= 0.5 mm
100 if (!( isPrimVtx && passDeltaZ0sin)){
101 ATH_MSG_DEBUG ("(trackSelectionElectrons) For this Tag, delta_z0_sin > 0.5mm, and there is NO primary vertices in the event. Rejecting electron.");
102 return false;
103 }
104
105 // d0_sig - transverse impact parameter significance
106 double d0sig = fabs (xAOD::TrackingHelpers::d0significance( trackElectron, ei->beamPosSigmaX(), ei->beamPosSigmaY(), ei->beamPosSigmaXY() ));
107 if ( !( d0sig < m_d0TagSig)){
108 ATH_MSG_DEBUG("(trackSelectionElectrons) Electron rejected. |d0sig| > " << m_d0TagSig << " ("<< d0sig <<")");
109 return false;
110 }
111
112 ATH_MSG_DEBUG("(trackSelectionElectrons) Electron accepted.");
113 return true; // if true, add electron to electronSelectionCnt container.
114}
EventReaderBaseAlg::m_d0TagSig
Gaudi::Property< float > m_d0TagSig
Definition EventReaderBaseAlg.h:56
EventReaderBaseAlg::m_z0Tag
Gaudi::Property< float > m_z0Tag
Definition EventReaderBaseAlg.h:57
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TrackParticle_v1.cxx:75
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TrackParticle_v1.cxx:79
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition TrackParticlexAODHelpers.cxx:42
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition TrackingPrimitives.h:572
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16

◆ 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 }
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_c711_cellDEta

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

Definition at line 191 of file EventReaderBaseAlg.h.

◆ m_c711_cellDPhi

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

Definition at line 192 of file EventReaderBaseAlg.h.

◆ m_c711_cellEnergy

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

Definition at line 187 of file EventReaderBaseAlg.h.

◆ m_c711_cellEta

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

Definition at line 189 of file EventReaderBaseAlg.h.

◆ m_c711_cellGain

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

Definition at line 184 of file EventReaderBaseAlg.h.

◆ m_c711_cellIndexCounter

int* EventReaderBaseAlg::m_c711_cellIndexCounter = nullptr
protected

Definition at line 181 of file EventReaderBaseAlg.h.

◆ m_c711_cellLayer

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

Definition at line 185 of file EventReaderBaseAlg.h.

◆ m_c711_cellPhi

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

Definition at line 190 of file EventReaderBaseAlg.h.

◆ m_c711_cellRegion

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

Definition at line 186 of file EventReaderBaseAlg.h.

◆ m_c711_cellTime

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

Definition at line 188 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDEta

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

Definition at line 194 of file EventReaderBaseAlg.h.

◆ m_c711_cellToClusterDPhi

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

Definition at line 193 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV0

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

Definition at line 214 of file EventReaderBaseAlg.h.

◆ m_c711_channelADC2MEV1

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

Definition at line 215 of file EventReaderBaseAlg.h.

◆ m_c711_channelBad

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

Definition at line 203 of file EventReaderBaseAlg.h.

◆ m_c711_channelChannelIdMap

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

Definition at line 205 of file EventReaderBaseAlg.h.

◆ m_c711_channelChInfo

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

Definition at line 198 of file EventReaderBaseAlg.h.

◆ m_c711_channelDigits

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

Definition at line 199 of file EventReaderBaseAlg.h.

◆ m_c711_channelDSPThreshold

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

Definition at line 208 of file EventReaderBaseAlg.h.

◆ m_c711_channelEffectiveSigma

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

Definition at line 206 of file EventReaderBaseAlg.h.

◆ m_c711_channelEnergy

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

Definition at line 200 of file EventReaderBaseAlg.h.

◆ m_c711_channelHashMap

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

Definition at line 204 of file EventReaderBaseAlg.h.

◆ m_c711_channelLayer

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

Definition at line 202 of file EventReaderBaseAlg.h.

◆ m_c711_channelMinBiasAvg

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

Definition at line 217 of file EventReaderBaseAlg.h.

◆ m_c711_channelNoise

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

Definition at line 207 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCa

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

Definition at line 209 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCb

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

Definition at line 210 of file EventReaderBaseAlg.h.

◆ m_c711_channelOFCTimeOffset

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

Definition at line 213 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflEneRescaler

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

Definition at line 219 of file EventReaderBaseAlg.h.

◆ m_c711_channelOfflHVScale

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

Definition at line 218 of file EventReaderBaseAlg.h.

◆ m_c711_channelPed

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

Definition at line 216 of file EventReaderBaseAlg.h.

◆ m_c711_channelShape

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

Definition at line 211 of file EventReaderBaseAlg.h.

◆ m_c711_channelShapeDer

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

Definition at line 212 of file EventReaderBaseAlg.h.

◆ m_c711_channelTime

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

Definition at line 201 of file EventReaderBaseAlg.h.

◆ m_c711_clusterCellIndex

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

Definition at line 183 of file EventReaderBaseAlg.h.

◆ m_c711_clusterChannelIndex

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

Definition at line 197 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEnergy

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

Definition at line 174 of file EventReaderBaseAlg.h.

◆ m_c711_clusterEta

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

Definition at line 176 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex

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

Definition at line 172 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_cellLvl

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

Definition at line 182 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_chLvl

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

Definition at line 196 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndex_rawChLvl

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

Definition at line 230 of file EventReaderBaseAlg.h.

◆ m_c711_clusterIndexCounter

int* EventReaderBaseAlg::m_c711_clusterIndexCounter = 0
protected

Definition at line 171 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPhi

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

Definition at line 177 of file EventReaderBaseAlg.h.

◆ m_c711_clusterPt

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

Definition at line 178 of file EventReaderBaseAlg.h.

◆ m_c711_clusterRawChannelIndex

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

Definition at line 229 of file EventReaderBaseAlg.h.

◆ m_c711_clusterTime

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

Definition at line 175 of file EventReaderBaseAlg.h.

◆ m_c711_electronIndex_clusterLvl

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

Definition at line 173 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelAmplitude

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

Definition at line 223 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelChInfo

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

Definition at line 221 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelDSPThreshold

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

Definition at line 231 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelIdMap

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

Definition at line 222 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelLayer

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

Definition at line 225 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelPed

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

Definition at line 226 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelProv

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

Definition at line 227 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelQuality

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

Definition at line 228 of file EventReaderBaseAlg.h.

◆ m_c711_rawChannelTime

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

Definition at line 224 of file EventReaderBaseAlg.h.

◆ m_c_cellDEta

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

Definition at line 112 of file EventReaderBaseAlg.h.

◆ m_c_cellDPhi

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

Definition at line 113 of file EventReaderBaseAlg.h.

◆ m_c_cellEnergy

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

Definition at line 108 of file EventReaderBaseAlg.h.

◆ m_c_cellEta

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

Definition at line 110 of file EventReaderBaseAlg.h.

◆ m_c_cellGain

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

Definition at line 105 of file EventReaderBaseAlg.h.

◆ m_c_cellIndexCounter

int EventReaderBaseAlg::m_c_cellIndexCounter = 0
protected

Definition at line 102 of file EventReaderBaseAlg.h.

◆ m_c_cellLayer

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

Definition at line 106 of file EventReaderBaseAlg.h.

◆ m_c_cellPhi

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

Definition at line 111 of file EventReaderBaseAlg.h.

◆ m_c_cellRegion

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

Definition at line 107 of file EventReaderBaseAlg.h.

◆ m_c_cellTime

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

Definition at line 109 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDEta

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

Definition at line 115 of file EventReaderBaseAlg.h.

◆ m_c_cellToClusterDPhi

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

Definition at line 114 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV0

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

Definition at line 135 of file EventReaderBaseAlg.h.

◆ m_c_channelADC2MEV1

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

Definition at line 136 of file EventReaderBaseAlg.h.

◆ m_c_channelBad

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

Definition at line 124 of file EventReaderBaseAlg.h.

◆ m_c_channelChannelIdMap

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

Definition at line 126 of file EventReaderBaseAlg.h.

◆ m_c_channelChInfo

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

Definition at line 119 of file EventReaderBaseAlg.h.

◆ m_c_channelDigits

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

Definition at line 120 of file EventReaderBaseAlg.h.

◆ m_c_channelDSPThreshold

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

Definition at line 129 of file EventReaderBaseAlg.h.

◆ m_c_channelEffectiveSigma

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

Definition at line 127 of file EventReaderBaseAlg.h.

◆ m_c_channelEnergy

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

Definition at line 121 of file EventReaderBaseAlg.h.

◆ m_c_channelHashMap

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

Definition at line 125 of file EventReaderBaseAlg.h.

◆ m_c_channelLayer

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

Definition at line 123 of file EventReaderBaseAlg.h.

◆ m_c_channelMinBiasAvg

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

Definition at line 138 of file EventReaderBaseAlg.h.

◆ m_c_channelNoise

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

Definition at line 128 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCa

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

Definition at line 130 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCb

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

Definition at line 131 of file EventReaderBaseAlg.h.

◆ m_c_channelOFCTimeOffset

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

Definition at line 134 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflEneRescaler

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

Definition at line 140 of file EventReaderBaseAlg.h.

◆ m_c_channelOfflHVScale

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

Definition at line 139 of file EventReaderBaseAlg.h.

◆ m_c_channelPed

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

Definition at line 137 of file EventReaderBaseAlg.h.

◆ m_c_channelShape

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

Definition at line 132 of file EventReaderBaseAlg.h.

◆ m_c_channelShapeDer

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

Definition at line 133 of file EventReaderBaseAlg.h.

◆ m_c_channelTime

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

Definition at line 122 of file EventReaderBaseAlg.h.

◆ m_c_clusterCellIndex

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

Definition at line 104 of file EventReaderBaseAlg.h.

◆ m_c_clusterChannelIndex

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

Definition at line 118 of file EventReaderBaseAlg.h.

◆ m_c_clusterEnergy

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

Definition at line 96 of file EventReaderBaseAlg.h.

◆ m_c_clusterEta

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

Definition at line 98 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex

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

Definition at line 94 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_cellLvl

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

Definition at line 103 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_chLvl

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

Definition at line 117 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndex_rawChLvl

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

Definition at line 152 of file EventReaderBaseAlg.h.

◆ m_c_clusterIndexCounter

int EventReaderBaseAlg::m_c_clusterIndexCounter = 0
protected

Definition at line 93 of file EventReaderBaseAlg.h.

◆ m_c_clusterPhi

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

Definition at line 99 of file EventReaderBaseAlg.h.

◆ m_c_clusterPt

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

Definition at line 100 of file EventReaderBaseAlg.h.

◆ m_c_clusterRawChannelIndex

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

Definition at line 151 of file EventReaderBaseAlg.h.

◆ m_c_clusterTime

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

Definition at line 97 of file EventReaderBaseAlg.h.

◆ m_c_electronIndex_clusterLvl

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

Definition at line 95 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelAmplitude

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

Definition at line 145 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelChInfo

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

Definition at line 143 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelDSPThreshold

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

Definition at line 153 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelIdMap

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

Definition at line 144 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelLayer

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

Definition at line 147 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelPed

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

Definition at line 148 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelProv

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

Definition at line 149 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelQuality

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

Definition at line 150 of file EventReaderBaseAlg.h.

◆ m_c_rawChannelTime

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

Definition at line 146 of file EventReaderBaseAlg.h.

◆ m_d0TagSig

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

Definition at line 56 of file EventReaderBaseAlg.h.

56{this, "d0TagSig", 5, "d_0 transverse impact parameter significance."};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doAssocTopoCluster711Dump

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

Definition at line 67 of file EventReaderBaseAlg.h.

67{this, "doAssocTopoCluster711Dump", false, "Dump the 7x11 EMB2 window cells."};

◆ m_doElecSelectByTrackOnly

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

Definition at line 58 of file EventReaderBaseAlg.h.

58{this, "doElecSelectByTrackOnly", false, "Perform electron selection by track only, witout tag and probe."};

◆ m_doLArEMBHitsDump

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

Definition at line 63 of file EventReaderBaseAlg.h.

63{this, "doLArEMBHitsDump", false, "Dump the EMB HITs container energy and time."};

◆ m_doPhotonDump

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

Definition at line 60 of file EventReaderBaseAlg.h.

60{this, "doPhotonDump", false, "Perform a photon particle dump based on offline Photons Container."};

◆ m_doTagAndProbe

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

Definition at line 59 of file EventReaderBaseAlg.h.

59{this, "doTagAndProbe", true, "First, the electrons are selected by track criteria, then, perform Tag and Probe selection for Zee."};

◆ m_doTruthEventDump

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

Definition at line 61 of file EventReaderBaseAlg.h.

61{this, "doTruthEventDump", false, "Dump the Truth Event variables."};

◆ m_doTruthPartDump

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

Definition at line 62 of file EventReaderBaseAlg.h.

62{this, "doTruthPartDump", false, "Perform a truth particle dump."};

◆ m_e_bcid

unsigned int EventReaderBaseAlg::m_e_bcid = 9999
protected

Definition at line 86 of file EventReaderBaseAlg.h.

◆ m_e_eventNumber

unsigned long long EventReaderBaseAlg::m_e_eventNumber = 9999
protected

Definition at line 87 of file EventReaderBaseAlg.h.

◆ m_e_inTimePileup

float EventReaderBaseAlg::m_e_inTimePileup = -999
protected

Definition at line 89 of file EventReaderBaseAlg.h.

◆ m_e_lumiBlock

int EventReaderBaseAlg::m_e_lumiBlock = 999
protected

Definition at line 88 of file EventReaderBaseAlg.h.

◆ m_e_outOfTimePileUp

float EventReaderBaseAlg::m_e_outOfTimePileUp = -999
protected

Definition at line 90 of file EventReaderBaseAlg.h.

◆ m_e_runNumber

unsigned int EventReaderBaseAlg::m_e_runNumber = 9999
protected

Definition at line 85 of file EventReaderBaseAlg.h.

◆ m_el_deltae

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

Definition at line 288 of file EventReaderBaseAlg.h.

◆ m_el_e277

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

Definition at line 285 of file EventReaderBaseAlg.h.

◆ m_el_eoverp

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

Definition at line 276 of file EventReaderBaseAlg.h.

◆ m_el_eratio

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

Definition at line 280 of file EventReaderBaseAlg.h.

◆ m_el_et

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

Definition at line 272 of file EventReaderBaseAlg.h.

◆ m_el_Eta

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

Definition at line 273 of file EventReaderBaseAlg.h.

◆ m_el_f1

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

Definition at line 278 of file EventReaderBaseAlg.h.

◆ m_el_f3

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

Definition at line 279 of file EventReaderBaseAlg.h.

◆ m_el_fracs1

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

Definition at line 283 of file EventReaderBaseAlg.h.

◆ m_el_index

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

Definition at line 270 of file EventReaderBaseAlg.h.

◆ m_el_m

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

Definition at line 275 of file EventReaderBaseAlg.h.

◆ m_el_Phi

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

Definition at line 274 of file EventReaderBaseAlg.h.

◆ m_el_Pt

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

Definition at line 271 of file EventReaderBaseAlg.h.

◆ m_el_reta

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

Definition at line 286 of file EventReaderBaseAlg.h.

◆ m_el_rhad

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

Definition at line 289 of file EventReaderBaseAlg.h.

◆ m_el_rhad1

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

Definition at line 290 of file EventReaderBaseAlg.h.

◆ m_el_rphi

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

Definition at line 287 of file EventReaderBaseAlg.h.

◆ m_el_weta1

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

Definition at line 281 of file EventReaderBaseAlg.h.

◆ m_el_weta2

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

Definition at line 282 of file EventReaderBaseAlg.h.

◆ m_el_wtots1

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

Definition at line 284 of file EventReaderBaseAlg.h.

◆ m_elecEtaCut

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

Definition at line 51 of file EventReaderBaseAlg.h.

51{this, "electronEtaCut", 1.4, "Electron |eta| cut value."};

◆ m_etMinProbe

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

define the Pid of Probe from the user

Definition at line 54 of file EventReaderBaseAlg.h.

54{this, "etMinProbe", 15 ,"Min electron Pt value for Zee probe selection loose (GeV)."}; // Et or pT ?

◆ m_etMinTag

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

Definition at line 55 of file EventReaderBaseAlg.h.

55{this, "etMinTag", 15 ,"Min Et value for the electrons in Zee tag selection (GeV)."}; // Et?

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_getLArCalibConstants

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

Definition at line 65 of file EventReaderBaseAlg.h.

65{this, "getLArCalibConstants", false, "Get the LAr calorimeter calibration constants, related to cells energy and time (online and offline)."};

◆ m_hits_cellEta

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

Definition at line 166 of file EventReaderBaseAlg.h.

◆ m_hits_cellPhi

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

Definition at line 167 of file EventReaderBaseAlg.h.

◆ m_hits_clusterChannelIndex

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

Definition at line 160 of file EventReaderBaseAlg.h.

◆ m_hits_clusterIndex_chLvl

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

Definition at line 159 of file EventReaderBaseAlg.h.

◆ m_hits_energy

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

Definition at line 162 of file EventReaderBaseAlg.h.

◆ m_hits_energyConv

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

Definition at line 165 of file EventReaderBaseAlg.h.

◆ m_hits_hash

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

Definition at line 161 of file EventReaderBaseAlg.h.

◆ m_hits_sampFrac

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

Definition at line 164 of file EventReaderBaseAlg.h.

◆ m_hits_sampling

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

Definition at line 158 of file EventReaderBaseAlg.h.

◆ m_hits_time

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

Definition at line 163 of file EventReaderBaseAlg.h.

◆ m_isMC

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

Definition at line 64 of file EventReaderBaseAlg.h.

64{this, "isMC", false, "Switch the dumper to MC sample mode."};

◆ m_lb_bcidLuminosity

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

Definition at line 81 of file EventReaderBaseAlg.h.

◆ m_lb_lumiblock

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

Definition at line 82 of file EventReaderBaseAlg.h.

◆ m_mc_part_energy

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

Definition at line 234 of file EventReaderBaseAlg.h.

◆ m_mc_part_eta

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

Definition at line 237 of file EventReaderBaseAlg.h.

◆ m_mc_part_m

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

Definition at line 236 of file EventReaderBaseAlg.h.

◆ m_mc_part_pdgId

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

Definition at line 239 of file EventReaderBaseAlg.h.

◆ m_mc_part_phi

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

Definition at line 238 of file EventReaderBaseAlg.h.

◆ m_mc_part_pt

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

Definition at line 235 of file EventReaderBaseAlg.h.

◆ m_mc_part_status

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

Definition at line 240 of file EventReaderBaseAlg.h.

◆ m_mc_part_uniqueID

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

Definition at line 241 of file EventReaderBaseAlg.h.

◆ m_mc_vert_eta

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

Definition at line 249 of file EventReaderBaseAlg.h.

◆ m_mc_vert_perp

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

Definition at line 248 of file EventReaderBaseAlg.h.

◆ m_mc_vert_phi

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

Definition at line 250 of file EventReaderBaseAlg.h.

◆ m_mc_vert_status

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

Definition at line 252 of file EventReaderBaseAlg.h.

◆ m_mc_vert_time

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

Definition at line 247 of file EventReaderBaseAlg.h.

◆ m_mc_vert_uniqueID

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

Definition at line 251 of file EventReaderBaseAlg.h.

◆ m_mc_vert_x

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

Definition at line 244 of file EventReaderBaseAlg.h.

◆ m_mc_vert_y

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

Definition at line 245 of file EventReaderBaseAlg.h.

◆ m_mc_vert_z

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

Definition at line 246 of file EventReaderBaseAlg.h.

◆ m_minEnergy

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

Definition at line 157 of file EventReaderBaseAlg.h.

◆ m_ncell

size_t EventReaderBaseAlg::m_ncell = 0
protected

Definition at line 156 of file EventReaderBaseAlg.h.

◆ m_noBadCells

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

Definition at line 66 of file EventReaderBaseAlg.h.

66{this, "noBadCells", true, "If True, skip the cells tagged as badCells/channels."};

◆ m_offProbeTightness

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

Define the PID for tag electron.

Definition at line 53 of file EventReaderBaseAlg.h.

53{this, "offProbeTightness", "Loose"};

◆ m_offTagTightness

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

Definition at line 52 of file EventReaderBaseAlg.h.

52{this, "offTagTightness", "LHMedium"};

◆ m_ph_energy

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

Definition at line 266 of file EventReaderBaseAlg.h.

◆ m_ph_eta

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

Definition at line 263 of file EventReaderBaseAlg.h.

◆ m_ph_m

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

Definition at line 267 of file EventReaderBaseAlg.h.

◆ m_ph_phi

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

Definition at line 264 of file EventReaderBaseAlg.h.

◆ m_ph_pt

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

Definition at line 265 of file EventReaderBaseAlg.h.

◆ m_secondTree

TTree* EventReaderBaseAlg::m_secondTree {}
protected

Definition at line 74 of file EventReaderBaseAlg.h.

74{};

◆ m_tp_electronEt

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

Definition at line 294 of file EventReaderBaseAlg.h.

◆ m_tp_electronEta

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

Definition at line 295 of file EventReaderBaseAlg.h.

◆ m_tp_electronPhi

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

Definition at line 296 of file EventReaderBaseAlg.h.

◆ m_tp_electronPt

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

Definition at line 293 of file EventReaderBaseAlg.h.

◆ m_tp_isProbe

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

Definition at line 301 of file EventReaderBaseAlg.h.

◆ m_tp_isTag

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

Definition at line 300 of file EventReaderBaseAlg.h.

◆ m_tp_probeIndex

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

Definition at line 298 of file EventReaderBaseAlg.h.

◆ m_tp_tagIndex

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

Definition at line 299 of file EventReaderBaseAlg.h.

◆ m_Tree

TTree* EventReaderBaseAlg::m_Tree {}
protected

Definition at line 73 of file EventReaderBaseAlg.h.

73{};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vtx_d0sig

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

Definition at line 260 of file EventReaderBaseAlg.h.

◆ m_vtx_delta_z0_sin

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

Definition at line 259 of file EventReaderBaseAlg.h.

◆ m_vtx_deltaZ0

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

Definition at line 258 of file EventReaderBaseAlg.h.

◆ m_vtx_x

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

Definition at line 255 of file EventReaderBaseAlg.h.

◆ m_vtx_y

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

Definition at line 256 of file EventReaderBaseAlg.h.

◆ m_vtx_z

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

Definition at line 257 of file EventReaderBaseAlg.h.

◆ m_z0Tag

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

Definition at line 57 of file EventReaderBaseAlg.h.

57{this, "z0Tag", 0.5, "z0 longitudinal impact parameter (mm)"};// https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/TrackingCPEOYE2015

◆ m_zee_deltaR

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

Definition at line 310 of file EventReaderBaseAlg.h.

◆ m_zee_E

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

Definition at line 304 of file EventReaderBaseAlg.h.

◆ m_zee_M

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

Definition at line 303 of file EventReaderBaseAlg.h.

◆ m_zee_pt

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

Definition at line 305 of file EventReaderBaseAlg.h.

◆ m_zee_px

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

Definition at line 306 of file EventReaderBaseAlg.h.

◆ m_zee_py

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

Definition at line 307 of file EventReaderBaseAlg.h.

◆ m_zee_pz

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

Definition at line 308 of file EventReaderBaseAlg.h.

◆ m_zee_T

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

Definition at line 309 of file EventReaderBaseAlg.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0