ATLAS Offline Software
EventReaderBaseAlg.h
Go to the documentation of this file.
1 // Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
3 #ifndef LARCLUSTERCELLDUMPER_EVENTREADERBASEALG_H
4 #define LARCLUSTERCELLDUMPER_EVENTREADERBASEALG_H
5 
6 #include "AthenaBaseComps/AthAlgorithm.h"
7 
8 #include "GaudiKernel/ServiceHandle.h"
9 #include "GaudiKernel/ITHistSvc.h"
10 
11 #include "StoreGate/ReadHandleKey.h"
12 #include "StoreGate/WriteHandleKey.h"
13 #include "StoreGate/ReadCondHandleKey.h"
14 
15 #include "xAODEventInfo/EventInfo.h"
16 #include "xAODEgamma/ElectronContainer.h"
17 #include "xAODTracking/VertexContainer.h"
18 #include "xAODEgamma/EgammaxAODHelpers.h"
19 #include "CLHEP/Units/SystemOfUnits.h"
20 #include "CLHEP/Units/PhysicalConstants.h"
21 
22 #include <TTree.h>
23 
24 #include "CxxUtils/checker_macros.h"
25 
26 using CLHEP::GeV;
27 using CLHEP::pi;
28 using CLHEP::twopi;
29 
30 
31 class ATLAS_NOT_THREAD_SAFE EventReaderBaseAlg: public ::AthAlgorithm
32 {
33  public:
34 
35  EventReaderBaseAlg( const std::string& name, ISvcLocator* pSvcLocator );
36 
37  virtual ~EventReaderBaseAlg() override;
38 
39  virtual StatusCode initialize() override;
40  virtual StatusCode execute() override;
41  virtual StatusCode finalize() override;
42 
43  private:
44 
45  protected:
46  bool isEtaOutsideLArCrack(float absEta);
47  bool isTagElectron(const xAOD::Electron* electron);
48  bool isGoodProbeElectron(const xAOD::Electron* el);
49  bool trackSelectionElectrons(const xAOD::Electron *electron, SG::ReadHandle<xAOD::VertexContainer> &primVertexCnt, SG::ReadHandle<xAOD::EventInfo> &ei); // for Xtalk studies
50  bool eOverPElectron(const xAOD::Electron* electron);
51  int getCaloRegionIndex(const CaloCell* cell); //customized representative indexes of calo region
52  double fixPhi(double phi);
53  double deltaPhi(double phi1 , double phi2);
54  double deltaR( double eta, double phi);
55 
56  void clear();
57  void clearLBData();
58  void bookBranches(TTree *tree);
59  void bookDatabaseBranches(TTree *tree);
60 
61 
62  Gaudi::Property<float> m_elecEtaCut {this, "electronEtaCut", 1.4, "Electron |eta| cut value."};
63  Gaudi::Property<std::string> m_offTagTightness {this, "offTagTightness", "LHMedium"};
64  Gaudi::Property<std::string> m_offProbeTightness {this, "offProbeTightness", "Loose"};
65  Gaudi::Property<float> m_etMinProbe {this, "etMinProbe", 15 ,"Min electron Pt value for Zee probe selection loose (GeV)."}; // Et or pT ?
66  Gaudi::Property<float> m_etMinTag {this, "etMinTag", 15 ,"Min Et value for the electrons in Zee tag selection (GeV)."}; // Et?
67  Gaudi::Property<float> m_d0TagSig {this, "d0TagSig", 5, "d_0 transverse impact parameter significance."};
68  Gaudi::Property<float> m_z0Tag {this, "z0Tag", 0.5, "z0 longitudinal impact parameter (mm)"};// https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/TrackingCPEOYE2015
69  Gaudi::Property<bool> m_doElecSelectByTrackOnly {this, "doElecSelectByTrackOnly", false, "Perform electron selection by track only, witout tag and probe."};
70  Gaudi::Property<bool> m_doTagAndProbe {this, "doTagAndProbe", true, "First, the electrons are selected by track criteria, then, perform Tag and Probe selection for Zee."};
71  Gaudi::Property<bool> m_doPhotonDump {this, "doPhotonDump", false, "Perform a photon particle dump based on offline Photons Container."};
72  Gaudi::Property<bool> m_doTruthEventDump {this, "doTruthEventDump", false, "Dump the Truth Event variables."};
73  Gaudi::Property<bool> m_doTruthPartDump {this, "doTruthPartDump", false, "Perform a truth particle dump."};
74  Gaudi::Property<bool> m_doLArEMBHitsDump {this, "doLArEMBHitsDump", false, "Dump the EMB HITs container energy and time."};
75  Gaudi::Property<bool> m_isMC {this, "isMC", false, "Switch the dumper to MC sample mode."};
76  Gaudi::Property<bool> m_getLArCalibConstants {this, "getLArCalibConstants", false, "Get the LAr calorimeter calibration constants, related to cells energy and time (online and offline)."};
77  Gaudi::Property<bool> m_noBadCells {this, "noBadCells", true, "If True, skip the cells tagged as badCells/channels."};
78  Gaudi::Property<bool> m_doAssocTopoCluster711Dump {this, "doAssocTopoCluster711Dump", false, "Dump the 7x11 EMB2 window cells."};
79 
80  //#############################
81  // Global Variables in general
82  //#############################
83 
84  TTree *m_Tree;
85  TTree *m_secondTree;
86 
87  //##################
88  // Dumped Variables
89  //##################
90 
91  // ## Lumiblock variables
92  std::vector < std::vector < float > > *m_lb_bcidLuminosity = nullptr;
93  std::vector < int > *m_lb_lumiblock = nullptr;
94 
95  // ## EventInfo ##
96  unsigned int m_e_runNumber = 9999; //< Run number
97  unsigned int m_e_bcid = 9999; //< BCID number
98  unsigned long long m_e_eventNumber = 9999; //< Event number
99  int m_e_lumiBlock = 999; // lumiblock number
100  float m_e_inTimePileup = -999; //< avg_mu
101  float m_e_outOfTimePileUp = -999; // OOT pileup
102 
103  // ## Cluster (TOPOCLUSTER) ##
104  int m_c_clusterIndexCounter = 0; // cluster index counter, for the entire event
105  std::vector < int > *m_c_clusterIndex = nullptr; // cluster index, for each cluster in the same event. (they have the same number of inputs)
106  std::vector < int > *m_c_electronIndex_clusterLvl = nullptr; // electron index, for each cluster in the same event.
107  std::vector < double > *m_c_clusterEnergy = nullptr; //energy of the cluster
108  std::vector < double > *m_c_clusterTime = nullptr; //timing of the cluster
109  std::vector < double > *m_c_clusterEta = nullptr; // clus. baricenter eta
110  std::vector < double > *m_c_clusterPhi = nullptr; // clus. baricenter phi
111  std::vector < double > *m_c_clusterPt = nullptr; // clus. baricenter eta
112  // Cell
113  int m_c_cellIndexCounter = 0; // cell index counter inside a cluster, for the entire event
114  std::vector < int > *m_c_clusterIndex_cellLvl = nullptr; // cluster index, for each cell index. (they have the same number of inputs)
115  std::vector < int > *m_c_clusterCellIndex = nullptr; // cell index inside a cluster
116  std::vector < int > *m_c_cellGain = nullptr; // gain of cell signal, from 'CaloGain' standard.
117  std::vector < int > *m_c_cellLayer = nullptr; // layer index of cell signal, from caloDDE.
118  std::vector < int > *m_c_cellRegion = nullptr; // region of calorimeter system (custom index from 'getCaloRegionIndex')
119  std::vector < double > *m_c_cellEnergy = nullptr; // cell inside cluster energy
120  std::vector < double > *m_c_cellTime = nullptr; // cell inside cluster energy
121  std::vector < double > *m_c_cellEta = nullptr; // cell inside cluster baricenter eta
122  std::vector < double > *m_c_cellPhi = nullptr; // cell inside cluster baricenter phi
123  std::vector < double > *m_c_cellDEta = nullptr; // cell inside cluster delta_eta (granularity)
124  std::vector < double > *m_c_cellDPhi = nullptr; // cell inside cluster delta_phi (granularity)
125  std::vector < double > *m_c_cellToClusterDPhi = nullptr; // cell inside cluster delta_phi distance to cluster baricenter.
126  std::vector < double > *m_c_cellToClusterDEta = nullptr; // cell inside cluster delta_eta distance to cluster baricenter.
127  //**** Channel
128  std::vector < int > *m_c_clusterIndex_chLvl = nullptr; // cluster index, for each channel index. (they have the same number of inputs)
129  std::vector < int > *m_c_clusterChannelIndex = nullptr; // index for a sequence of channels. It is a float for identify PMTs: +0.0 LAr, +0.1 Tile PMT1, +0.2 Tile PMT2
130  std::vector < std::vector < int > > *m_c_channelChInfo = nullptr; // from both LAr (barrel_ec, pos_neg, feedthrough, slot, channel) and Tile (ros, drawer, channel, adc)
131  std::vector < std::vector < float > > *m_c_channelDigits = nullptr; // samples from LAr and Tile cells/channels
132  std::vector < double > *m_c_channelEnergy = nullptr; // energy of cell or readout channel inside cluster (MeV)
133  std::vector < double > *m_c_channelTime = nullptr; // time of channel inside cluster
134  std::vector < int > *m_c_channelLayer = nullptr; // layer index of channel signal, from caloDDE.
135  std::vector < bool > *m_c_channelBad = nullptr; // channel linked to a cluster, whitch is tagged as bad. (1 - bad, 0 - not bad)
136  std::vector < unsigned int > *m_c_channelHashMap = nullptr; //cell map of ALL cells inside a cluster. id 0x2d214a140000000. is a 64-bit number that represent the cell.
137  std::vector < unsigned int > *m_c_channelChannelIdMap = nullptr;
138  std::vector < float > *m_c_channelEffectiveSigma = nullptr;
139  std::vector < float > *m_c_channelNoise = nullptr;
140  std::vector < float > *m_c_channelDSPThreshold = nullptr; // get from Athena POOL Utilities
141  std::vector < std::vector < double > > *m_c_channelOFCa = nullptr;
142  std::vector < std::vector < double > > *m_c_channelOFCb = nullptr;
143  std::vector < std::vector < double > > *m_c_channelShape = nullptr; // shape
144  std::vector < std::vector < double > > *m_c_channelShapeDer = nullptr; // shape derivative
145  std::vector < double > *m_c_channelOFCTimeOffset = nullptr;
146  std::vector < float > *m_c_channelADC2MEV0 = nullptr; //ramp0
147  std::vector < float > *m_c_channelADC2MEV1 = nullptr; //ramp1
148  std::vector < float > *m_c_channelPed = nullptr; //pedestal from DB (LAr / maskedTile)
149  std::vector < float > *m_c_channelMinBiasAvg = nullptr; //cell minBias average
150  std::vector < float > *m_c_channelOfflHVScale = nullptr;
151  std::vector < float > *m_c_channelOfflEneRescaler = nullptr;
152 
153  // Raw channel
154  std::vector < std::vector < int > > *m_c_rawChannelChInfo = nullptr; // from both LAr (barrel_ec, pos_neg, feedthrough, slot, channel, provenance) and Tile (ros, drawer, channel, adc, pedestal)
155  std::vector < unsigned int > *m_c_rawChannelIdMap = nullptr;
156  std::vector < float > *m_c_rawChannelAmplitude = nullptr; // raw channel energy (adc)
157  std::vector < float > *m_c_rawChannelTime = nullptr; // ps
158  std::vector < int > *m_c_rawChannelLayer = nullptr; // layer index of cell signal, from caloDDE.
159  std::vector < float > *m_c_rawChannelPed = nullptr; // raw channel estimated pedestal (Tile) or LAr provenance
160  std::vector < float > *m_c_rawChannelProv = nullptr; // raw channel estimated pedestal (Tile) or LAr provenance
161  std::vector < float > *m_c_rawChannelQuality = nullptr; // raw channel quality
162  std::vector < float > *m_c_clusterRawChannelIndex = nullptr; // raw channel index
163  std::vector < int > *m_c_clusterIndex_rawChLvl = nullptr; // cluster index at raw channel level
164  std::vector < float > *m_c_rawChannelDSPThreshold = nullptr; // get from Athena POOL Utilities
165 
166  // LAr HITs
167  size_t m_ncell = 0;
168  const double m_minEnergy = 1e-9;
169  std::vector < int > *m_hits_sampling = nullptr;
170  std::vector < int > *m_hits_clusterIndex_chLvl = nullptr;
171  std::vector < int > *m_hits_clusterChannelIndex = nullptr;
172  std::vector < unsigned int > *m_hits_hash = nullptr;
173  std::vector < double > *m_hits_energy = nullptr;
174  std::vector < double > *m_hits_time = nullptr;
175  std::vector < float > *m_hits_sampFrac = nullptr; // sampling fraction from MC/data E_calibration
176  std::vector < double > *m_hits_energyConv = nullptr;
177  std::vector < double > *m_hits_cellEta = nullptr;
178  std::vector < double > *m_hits_cellPhi = nullptr;
179 
180 
181  // ## Cluster (EMB2 EGAMMA CALO CLUSTER 7_11) ##
182  int *m_c711_clusterIndexCounter = 0; // cluster index counter, for the entire event
183  std::vector < int > *m_c711_clusterIndex = nullptr; // cluster index, for each cluster in the same event. (they have the same number of inputs)
184  std::vector < int > *m_c711_electronIndex_clusterLvl = nullptr; // electron index, for each cluster in the same event.
185  std::vector < double > *m_c711_clusterEnergy = nullptr; //energy of the cluster
186  std::vector < double > *m_c711_clusterTime = nullptr; //timing of the cluster
187  std::vector < double > *m_c711_clusterEta = nullptr; // clus. baricenter eta
188  std::vector < double > *m_c711_clusterPhi = nullptr; // clus. baricenter phi
189  std::vector < double > *m_c711_clusterPt = nullptr; // clus. baricenter eta
190 
191  // Cell
192  int *m_c711_cellIndexCounter = nullptr; // cell index counter inside a cluster, for the entire event
193  std::vector < int > *m_c711_clusterIndex_cellLvl = nullptr; // cluster index, for each cell index. (they have the same number of inputs)
194  std::vector < int > *m_c711_clusterCellIndex = nullptr; // cell index inside a cluster
195  std::vector < int > *m_c711_cellGain = nullptr; // gain of cell signal, from 'CaloGain' standard.
196  std::vector < int > *m_c711_cellLayer = nullptr; // layer index of cell signal, from caloDDE.
197  std::vector < int > *m_c711_cellRegion = nullptr; // region of calorimeter system (custom index from 'getCaloRegionIndex')
198  std::vector < double > *m_c711_cellEnergy = nullptr; // cell inside cluster energy
199  std::vector < double > *m_c711_cellTime = nullptr; // cell inside cluster energy
200  std::vector < double > *m_c711_cellEta = nullptr; // cell inside cluster baricenter eta
201  std::vector < double > *m_c711_cellPhi = nullptr; // cell inside cluster baricenter phi
202  std::vector < double > *m_c711_cellDEta = nullptr; // cell inside cluster delta_eta (granularity)
203  std::vector < double > *m_c711_cellDPhi = nullptr; // cell inside cluster delta_phi (granularity)
204  std::vector < double > *m_c711_cellToClusterDPhi = nullptr; // cell inside cluster delta_phi distance to cluster baricenter.
205  std::vector < double > *m_c711_cellToClusterDEta = nullptr; // cell inside cluster delta_eta distance to cluster baricenter.
206  // Channel
207  std::vector < int > *m_c711_clusterIndex_chLvl = nullptr; // cluster index, for each channel index. (they have the same number of inputs)
208  std::vector < int > *m_c711_clusterChannelIndex = nullptr; // index for a sequence of channels. It is a float for identify PMTs: +0.0 LAr, +0.1 Tile PMT1, +0.2 Tile PMT2
209  std::vector < std::vector < int > > *m_c711_channelChInfo = nullptr; // from both LAr (barrel_ec, pos_neg, feedthrough, slot, channel) and Tile (ros, drawer, channel, adc)
210  std::vector < std::vector < float > > *m_c711_channelDigits = nullptr; // samples from LAr and Tile cells/channels
211  std::vector < double > *m_c711_channelEnergy = nullptr; // energy of cell or readout channel inside cluster (MeV)
212  std::vector < double > *m_c711_channelTime = nullptr; // time of channel inside cluster
213  std::vector < int > *m_c711_channelLayer = nullptr; // layer index of cell signal, from caloDDE.
214  std::vector < bool > *m_c711_channelBad = nullptr; // channel linked to a cluster, whitch is tagged as bad. (1 - bad, 0 - not bad)
215  std::vector < unsigned int > *m_c711_channelHashMap = nullptr; //cell map of ALL cells inside a cluster. id 0x2d214a140000000. is a 64-bit number that represent the cell.
216  std::vector < unsigned int > *m_c711_channelChannelIdMap = nullptr;
217  std::vector < float > *m_c711_channelEffectiveSigma = nullptr;
218  std::vector < float > *m_c711_channelNoise = nullptr;
219  std::vector < float > *m_c711_channelDSPThreshold = nullptr; // get from Athena POOL Utilities
220  std::vector < std::vector < double > > *m_c711_channelOFCa = nullptr;
221  std::vector < std::vector < double > > *m_c711_channelOFCb = nullptr;
222  std::vector < std::vector < double > > *m_c711_channelShape = nullptr; // shape
223  std::vector < std::vector < double > > *m_c711_channelShapeDer = nullptr; // shape derivative
224  std::vector < double > *m_c711_channelOFCTimeOffset = nullptr;
225  std::vector < float > *m_c711_channelADC2MEV0 = nullptr;
226  std::vector < float > *m_c711_channelADC2MEV1 = nullptr;
227  std::vector < float > *m_c711_channelPed = nullptr; //pedestal from DB (LAr / maskedTile)
228  std::vector < float > *m_c711_channelMinBiasAvg = nullptr;
229  std::vector < float > *m_c711_channelOfflHVScale = nullptr;
230  std::vector < float > *m_c711_channelOfflEneRescaler = nullptr;
231  // Raw channel
232  std::vector < std::vector < int > > *m_c711_rawChannelChInfo = nullptr; // from both LAr (barrel_ec, pos_neg, feedthrough, slot, channel, provenance) and Tile (ros, drawer, channel, adc, pedestal)
233  std::vector < unsigned int > *m_c711_rawChannelIdMap = nullptr;
234  std::vector < float > *m_c711_rawChannelAmplitude = nullptr; // raw channel energy (adc)
235  std::vector < float > *m_c711_rawChannelTime = nullptr; // raw channel time
236  std::vector < int > *m_c711_rawChannelLayer = nullptr; // layer index of cell signal, from caloDDE.
237  std::vector < float > *m_c711_rawChannelPed = nullptr; // raw channel estimated pedestal
238  std::vector < float > *m_c711_rawChannelProv = nullptr; // raw channel LAr provenance (tile masked)
239  std::vector < float > *m_c711_rawChannelQuality = nullptr; // raw channel quality
240  std::vector < float > *m_c711_clusterRawChannelIndex = nullptr; // raw channel index
241  std::vector < int > *m_c711_clusterIndex_rawChLvl = nullptr; // cluster index at raw channel level
242  std::vector < float > *m_c711_rawChannelDSPThreshold = nullptr; // get from Athena POOL utilities
243 
244  // ## Particle Truth ## (MC)
245  std::vector < float > *m_mc_part_energy = nullptr;
246  std::vector < float > *m_mc_part_pt = nullptr;
247  std::vector < float > *m_mc_part_m = nullptr;
248  std::vector < float > *m_mc_part_eta = nullptr;
249  std::vector < float > *m_mc_part_phi = nullptr;
250  std::vector < int > *m_mc_part_pdgId = nullptr;
251  std::vector < int > *m_mc_part_status = nullptr;
252  std::vector < int > *m_mc_part_barcode = nullptr;
253 
254  // ## Vertex Truth ## (MC)
255  std::vector < float > *m_mc_vert_x = nullptr;
256  std::vector < float > *m_mc_vert_y = nullptr;
257  std::vector < float > *m_mc_vert_z = nullptr;
258  std::vector < float > *m_mc_vert_time = nullptr;
259  std::vector < float > *m_mc_vert_perp = nullptr;
260  std::vector < float > *m_mc_vert_eta = nullptr;
261  std::vector < float > *m_mc_vert_phi = nullptr;
262  std::vector < int > *m_mc_vert_barcode = nullptr;
263  std::vector < int > *m_mc_vert_status = nullptr;
264 
265  // ## Primary Vertex ##
266  std::vector < float > *m_vtx_x = nullptr;
267  std::vector < float > *m_vtx_y = nullptr;
268  std::vector < float > *m_vtx_z = nullptr;
269  std::vector < float > *m_vtx_deltaZ0 = nullptr;
270  std::vector < float > *m_vtx_delta_z0_sin = nullptr;
271  std::vector < double > *m_vtx_d0sig = nullptr;
272 
273  // ## Photons Reco ##
274  std::vector < float > *m_ph_eta = nullptr;
275  std::vector < float > *m_ph_phi = nullptr;
276  std::vector < float > *m_ph_pt = nullptr;
277  std::vector < float > *m_ph_energy = nullptr;
278  std::vector < float > *m_ph_m = nullptr;
279 
280  // ## Electrons ##
281  std::vector < int > *m_el_index = nullptr;
282  std::vector < float > *m_el_Pt = nullptr;
283  std::vector < float > *m_el_et = nullptr;
284  std::vector < float > *m_el_Eta = nullptr;
285  std::vector < float > *m_el_Phi = nullptr;
286  std::vector < float > *m_el_m = nullptr;
287  std::vector < float > *m_el_eoverp = nullptr;
288  // offline shower shapes
289  std::vector < float > *m_el_f1 = nullptr;
290  std::vector < float > *m_el_f3 = nullptr;
291  std::vector < float > *m_el_eratio = nullptr;
292  std::vector < float > *m_el_weta1 = nullptr;
293  std::vector < float > *m_el_weta2 = nullptr;
294  std::vector < float > *m_el_fracs1 = nullptr;
295  std::vector < float > *m_el_wtots1 = nullptr;
296  std::vector < float > *m_el_e277 = nullptr;
297  std::vector < float > *m_el_reta = nullptr;
298  std::vector < float > *m_el_rphi = nullptr;
299  std::vector < float > *m_el_deltae = nullptr;
300  std::vector < float > *m_el_rhad = nullptr;
301  std::vector < float > *m_el_rhad1 = nullptr;
302 
303  // ## Tag and probe ##
304  std::vector < float > *m_tp_electronPt = nullptr;
305  std::vector < float > *m_tp_electronEt = nullptr;
306  std::vector < float > *m_tp_electronEta = nullptr;
307  std::vector < float > *m_tp_electronPhi = nullptr;
308  // indexes
309  std::vector < int > *m_tp_probeIndex = nullptr; // contains the electron indexes associated to each electron (tags). The vector position represent the Tags, the number on it, the associated Probe.
310  std::vector < int > *m_tp_tagIndex = nullptr; // index for each electron in the container
311  std::vector < bool > *m_tp_isTag = nullptr;
312  std::vector < bool > *m_tp_isProbe = nullptr;
313  // Zee
314  std::vector < double > *m_zee_M = nullptr;
315  std::vector < double > *m_zee_E = nullptr;
316  std::vector < double > *m_zee_pt = nullptr;
317  std::vector < double > *m_zee_px = nullptr;
318  std::vector < double > *m_zee_py = nullptr;
319  std::vector < double > *m_zee_pz = nullptr;
320  std::vector < double > *m_zee_T = nullptr;
321  std::vector < double > *m_zee_deltaR = nullptr;
322 };
323 
324 #endif
ReadHandleKey.h
Property holding a SG store/key/clid from which a ReadHandle is made.
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATLAS_NOT_THREAD_SAFE
#define ATLAS_NOT_THREAD_SAFE
getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats
Definition: checker_macros.h:212
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
initialize
void initialize()
Definition: run_EoverP.cxx:894
tree
TChain * tree
Definition: tile_monitor.h:30
pi
#define pi
Definition: TileMuonFitter.cxx:65
LArG4FSStartPointFilterLegacy.execute
execute
Definition: LArG4FSStartPointFilterLegacy.py:20
AthAlgorithm.h
EgammaxAODHelpers.h
ElectronContainer.h
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
AthAlgorithm
Definition: AthAlgorithm.h:47
ReadCondHandleKey.h
WriteHandleKey.h
Property holding a SG store/key/clid from which a WriteHandle is made.
twopi
constexpr double twopi
Definition: VertexPointEstimator.cxx:16
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
xAOD::Electron_v1
Definition: Electron_v1.h:34
EventInfo.h
EventReaderBaseAlg::m_secondTree
TTree * m_secondTree
Definition: EventReaderBaseAlg.h:85
VertexContainer.h
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
VKalVrtAthena::varHolder_detail::clear
void clear(T &var)
Definition: NtupleVars.h:48
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:232
EventReaderBaseAlg::m_Tree
TTree * m_Tree
Definition: EventReaderBaseAlg.h:84
checker_macros.h
Define macros for attributes used to control the static checker.
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
EventReaderBaseAlg
Definition: EventReaderBaseAlg.h:32
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
Generated on Fri Jul 5 2024 21:15:33 for ATLAS Offline Software by   doxygen 1.8.18