ATLAS Offline Software
EgammaFactory.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #ifdef XAOD_STANDALONE
6 #include "ElectronPhotonFourMomentumCorrection/EgammaFactory.h"
7 
8 #include <AthLinks/ElementLink.h>
9 #include <xAODCaloEvent/CaloCluster.h>
10 #include <xAODCaloEvent/CaloClusterAuxContainer.h>
11 #include <xAODCaloEvent/CaloClusterContainer.h>
12 #include <xAODRootAccess/Init.h>
13 #include <xAODRootAccess/TEvent.h>
14 #include <xAODRootAccess/TStore.h>
15 
16 #include <cassert>
17 #include <cmath>
18 #include <string>
19 #include <vector>
20 
21 #include "PathResolver/PathResolver.h"
22 #include "xAODTracking/Vertex.h"
23 #include "xAODTracking/VertexAuxContainer.h"
24 #include "xAODTracking/VertexContainer.h"
25 
26 void EgammaFactory::create_structure() {
27  ATH_MSG_DEBUG("Creating calo cluster container");
28  m_clusters = new xAOD::CaloClusterContainer();
29  m_clAux = new xAOD::CaloClusterAuxContainer();
30  m_clusters->setStore(m_clAux);
31  if (!m_store.record(m_clusters, "Clusters").isSuccess()) {
32  ATH_MSG_ERROR("Cannot create cluster collection");
33  }
34  if (!m_store.record(m_clAux, "ClustersAux.").isSuccess()) {
35  ATH_MSG_ERROR("Canno create cluster aux collection");
36  };
37 
38  ATH_MSG_DEBUG("Creating vertex container");
39  m_vertexes = new xAOD::VertexContainer();
40  m_vxAux = new xAOD::VertexAuxContainer();
41  m_vertexes->setStore(m_vxAux);
42  if (!m_store.record(m_vertexes, "Vertexes").isSuccess()) {
43  ATH_MSG_ERROR("Cannot create vertex collection");
44  };
45  if (!m_store.record(m_vxAux, "VertexesAux.").isSuccess()) {
46  ATH_MSG_ERROR("Cannot create vertex aux collection");
47  };
48 
49  ATH_MSG_DEBUG("Creating track container");
50  m_tracks = new xAOD::TrackParticleContainer();
51  m_tracksAux = new xAOD::TrackParticleAuxContainer();
52  m_tracks->setStore(m_tracksAux);
53  if (!m_store.record(m_tracks, "Tracks").isSuccess()) {
54  ATH_MSG_ERROR("Cannot create track collection");
55  };
56  if (!m_store.record(m_tracksAux, "TracksAux.").isSuccess()) {
57  ATH_MSG_ERROR("Cannot create track aux collection");
58  };
59 
60  ATH_MSG_DEBUG("Creating photon container");
61  m_photons = new xAOD::PhotonContainer();
62  m_photonsAux = new xAOD::PhotonAuxContainer();
63  m_photons->setStore(m_photonsAux);
64  if (!m_store.record(m_photons, "Photons").isSuccess()) {
65  ATH_MSG_ERROR("Cannot create photon collection");
66  };
67  if (!m_store.record(m_photonsAux, "PhotonsAux.").isSuccess()) {
68  ATH_MSG_ERROR("Cannot create photon aux collection");
69  };
70 
71  ATH_MSG_DEBUG("Creating electron container");
72  m_electrons = new xAOD::ElectronContainer();
73  m_electronsAux = new xAOD::ElectronAuxContainer();
74  m_electrons->setStore(m_electronsAux);
75  if (!m_store.record(m_electrons, "Electrons").isSuccess()) {
76  ATH_MSG_ERROR("Cannot create electron collection");
77  };
78  if (!m_store.record(m_electronsAux, "ElectronsAux.").isSuccess()) {
79  ATH_MSG_ERROR("Cannot create electron aux collection");
80  };
81 }
82 
83 EgammaFactory::EgammaFactory() : asg::AsgMessaging("EgammaFactory") {
84  create_structure();
85 
86  TFile* f = TFile::Open(
87  PathResolverFindCalibFile(
88  "ElectronPhotonFourMomentumCorrection/v8/average_layers.root")
89  .c_str(),
90  "READ");
91  if (not f) {
92  ATH_MSG_ERROR(
93  "cannot open file "
94  << PathResolverFindCalibFile(
95  "ElectronPhotonFourMomentumCorrection/v8/average_layers.root")
96  .c_str());
97  } else {
98  m_fave.reset(f);
99  }
100  m_histos_electron = std::array<TProfile2D*, 4>{
101  static_cast<TProfile2D*>(m_fave->Get("histo_electron_ratio_Es0_true_E")),
102  static_cast<TProfile2D*>(m_fave->Get("histo_electron_ratio_Es1_true_E")),
103  static_cast<TProfile2D*>(m_fave->Get("histo_electron_ratio_Es2_true_E")),
104  static_cast<TProfile2D*>(m_fave->Get("histo_electron_ratio_Es3_true_E"))};
105  m_histos_conv = std::array<TProfile2D*, 4>{
106  static_cast<TProfile2D*>(m_fave->Get("histo_conv_ratio_Es0_true_E")),
107  static_cast<TProfile2D*>(m_fave->Get("histo_conv_ratio_Es1_true_E")),
108  static_cast<TProfile2D*>(m_fave->Get("histo_conv_ratio_Es2_true_E")),
109  static_cast<TProfile2D*>(m_fave->Get("histo_conv_ratio_Es3_true_E"))};
110  m_histos_unconv = std::array<TProfile2D*, 4>{
111  static_cast<TProfile2D*>(m_fave->Get("histo_unconv_ratio_Es0_true_E")),
112  static_cast<TProfile2D*>(m_fave->Get("histo_unconv_ratio_Es1_true_E")),
113  static_cast<TProfile2D*>(m_fave->Get("histo_unconv_ratio_Es2_true_E")),
114  static_cast<TProfile2D*>(m_fave->Get("histo_unconv_ratio_Es3_true_E"))};
115  m_histo_rconv = static_cast<TProfile2D*>(m_fave->Get("histo_conv_ph_Rconv"));
116  m_histo_zconv = static_cast<TProfile2D*>(m_fave->Get("histo_conv_ph_zconv"));
117 }
118 
119 std::array<double, 4> EgammaFactory::get_layers_fraction(
120  const std::array<TProfile2D*, 4>& prof, double eta, double pt) const {
121  std::array<double, 4> result;
122  for (int i = 0; i != 4; ++i) {
123  TProfile2D* p = prof[i];
124  assert(p);
125  result[i] = p->GetBinContent(p->FindBin(pt, std::abs(eta)));
126  }
127  return result;
128 }
129 
130 void EgammaFactory::clear() {
131  m_store.clear();
132  create_structure();
133 }
134 
135 EgammaFactory::~EgammaFactory() {
136  m_store.clear();
137 }
138 
139 xAOD::EventInfo* EgammaFactory::create_eventinfo(
140  bool simulation, int runnumber, int eventnumber,
141  int average_interaction_per_crossing) {
142  xAOD::EventInfo* ei = new xAOD::EventInfo();
143  ei->makePrivateStore();
144  ei->setRunNumber(runnumber);
145  ei->setEventNumber(eventnumber);
146  ei->setEventTypeBitmask(simulation);
147  ei->setAverageInteractionsPerCrossing(average_interaction_per_crossing);
148  return ei;
149 }
150 
151 xAOD::CaloCluster* EgammaFactory::create_cluster(float eta, float phi, float e0,
152  float e1, float e2, float e3,
153  float e) {
154  ATH_MSG_DEBUG("creating cluster");
155  // create cluster
156  xAOD::CaloCluster* cluster = new xAOD::CaloCluster();
157  cluster->makePrivateStore();
158 
159  ATH_MSG_DEBUG("setting cluster properties");
160  // set cluster properties
161 
162  {
163  // set eta, phi for all the layers (barrel / endcap)
164  const std::set<CaloSampling::CaloSample> samplings{
165  CaloSampling::PreSamplerB, CaloSampling::EMB1,
166  CaloSampling::EMB2, CaloSampling::EMB3,
167  CaloSampling::PreSamplerE, CaloSampling::EME1,
168  CaloSampling::EME2, CaloSampling::EME3};
169  unsigned sampling_pattern = 0;
170  for (auto sample : samplings) {
171  sampling_pattern |= 0x1U << sample;
172  }
173  ATH_MSG_DEBUG("setting sampling pattern");
174  cluster->setSamplingPattern(sampling_pattern);
175  ATH_MSG_DEBUG("nsamples = " << cluster->nSamples());
176  for (auto sample : samplings) {
177  ATH_MSG_DEBUG("setting eta sampling");
178  cluster->setEta(sample, eta);
179  cluster->setPhi(sample, phi);
180  }
181 
182  ATH_MSG_DEBUG("setting energies sampling");
183 
184  if (std::abs(eta) < 1.45) {
185  cluster->setEnergy(CaloSampling::PreSamplerB, e0);
186  cluster->setEnergy(CaloSampling::EMB1, e1);
187  cluster->setEnergy(CaloSampling::EMB2, e2);
188  cluster->setEnergy(CaloSampling::EMB3, e3);
189  } else {
190  cluster->setEnergy(CaloSampling::PreSamplerE, e0);
191  cluster->setEnergy(CaloSampling::EME1, e1);
192  cluster->setEnergy(CaloSampling::EME2, e2);
193  cluster->setEnergy(CaloSampling::EME3, e3);
194  }
195  ATH_MSG_DEBUG("setting energy cluster");
196  cluster->setE(e > 0 ? e : e0 + e1 + e2 + e3);
197  ATH_MSG_DEBUG("setting eta cluster");
198  cluster->setEta(eta);
199  ATH_MSG_DEBUG("setting phi cluster");
200  cluster->setPhi(phi);
201  ATH_MSG_DEBUG("decorate cluster for etaCalo, phiCalo");
202  cluster->auxdata<float>("etaCalo") = eta;
203  cluster->auxdata<float>("phiCalo") = phi;
204  // void insertMoment( MomentType type, double value );
205  cluster->insertMoment(xAOD::CaloCluster::ETACALOFRAME, eta);
206  cluster->insertMoment(xAOD::CaloCluster::PHICALOFRAME, phi);
207  }
208  ATH_MSG_DEBUG("pushing cluster collection");
209  m_clusters->push_back(cluster);
210  return cluster;
211 }
212 
213 xAOD::Photon* EgammaFactory::create_unconverted_photon(float eta, float phi,
214  float e) {
215  return create_photon(eta, phi, e, 0., 0.);
216 }
217 
218 xAOD::Photon* EgammaFactory::create_converted_photon(float eta, float phi,
219  float e) {
220  assert(m_histo_rconv);
221  assert(m_histo_zconv);
222  const int bin = m_histo_rconv->FindBin(e / cosh(eta), std::abs(eta));
223  if (m_histo_rconv->IsBinOverflow(bin)) {
224  return create_photon(eta, phi, e, 0, 0);
225  } else {
226  const double rconv = m_histo_rconv->GetBinContent(bin);
227  const double zconv = m_histo_zconv->GetBinContent(
228  m_histo_zconv->FindBin(e / cosh(eta), std::abs(eta)));
229  assert(rconv > 0);
230  return create_photon(eta, phi, e, rconv, zconv);
231  }
232 }
233 
234 xAOD::Photon* EgammaFactory::create_photon(float eta, float phi, float e,
235  float rconv, float zconv) {
236  const bool isconv = (rconv > 0 and rconv < 800);
237  const auto l = get_layers_fraction(isconv ? m_histos_conv : m_histos_unconv,
238  eta, e / cosh(eta));
239  return create_photon(eta, phi, l[0] * e, l[1] * e, l[2] * e, l[3] * e, e,
240  rconv, zconv);
241 }
242 
243 xAOD::Electron* EgammaFactory::create_electron(float eta, float phi, float e) {
244  const auto l = get_layers_fraction(m_histos_electron, eta, e / cosh(eta));
245  return create_electron(eta, phi, l[0] * e, l[1] * e, l[2] * e, l[3] * e, e);
246 }
247 
248 xAOD::Photon* EgammaFactory::create_photon(float eta, float phi, float e0,
249  float e1, float e2, float e3,
250  float e, float rconv, float zconv) {
251  xAOD::CaloCluster* cluster = create_cluster(eta, phi, e0, e1, e2, e3, e);
252  // create Vertex
253  xAOD::Vertex* vertex = nullptr;
254  if (rconv > 0 and rconv < 800) {
255  ATH_MSG_DEBUG("creating vertex");
256  vertex = new xAOD::Vertex();
257  vertex->makePrivateStore();
258  vertex->setZ(zconv);
259  vertex->setX(rconv);
260  vertex->setY(0);
261  // decorate with pt1, pt2
262  vertex->auxdata<float>("pt1") = e / cosh(eta) * 0.7;
263  vertex->auxdata<float>("pt2") = e / cosh(eta) * 0.3;
264  m_vertexes->push_back(vertex);
265  }
266 
267  ATH_MSG_DEBUG("creating photon");
268  xAOD::Photon* ph = new xAOD::Photon();
269  ph->makePrivateStore();
270  m_photons->push_back(ph);
271 
272  ATH_MSG_DEBUG("link cluster to photon");
273  // set link to clusters
274  std::vector<ElementLink<xAOD::CaloClusterContainer>> links_clusters;
275  ATH_MSG_DEBUG("push back cluster = " << cluster);
276  links_clusters.push_back(
277  ElementLink<xAOD::CaloClusterContainer>(cluster, *m_clusters));
278  ATH_MSG_DEBUG("set link");
279  ph->setCaloClusterLinks(links_clusters);
280 
281  // set link to vertex
282  if (vertex) {
283  ATH_MSG_DEBUG("link vertex to photon");
284  std::vector<ElementLink<xAOD::VertexContainer>> links_vertexes;
285  links_vertexes.push_back(
286  ElementLink<xAOD::VertexContainer>(vertex, *m_vertexes));
287  ph->setVertexLinks(links_vertexes);
288  } else {
289  ATH_MSG_DEBUG("not converted");
290  }
291 
292  // set particle properties
293 
294  ph->setEta(eta);
295  ph->setPhi(phi);
296  ph->setM(0);
297  ph->setPt(e / cosh(eta));
298 
299  return ph;
300 }
301 
302 xAOD::Electron* EgammaFactory::create_electron(float eta, float phi, float e0,
303  float e1, float e2, float e3,
304  float e) {
305  ATH_MSG_DEBUG("creating cluster");
306  xAOD::CaloCluster* cluster = create_cluster(eta, phi, e0, e1, e2, e3, e);
307 
308  ATH_MSG_DEBUG("creating track");
309  xAOD::TrackParticle* track = new xAOD::TrackParticle();
310  track->makePrivateStore();
311  track->setDefiningParameters(0., 0., phi, 2 * atan(exp(-eta)), 1.);
312  m_tracks->push_back(track);
313 
314  ATH_MSG_DEBUG("creating electron");
315  xAOD::Electron* el = new xAOD::Electron();
316  el->makePrivateStore();
317  m_electrons->push_back(el);
318 
319  ATH_MSG_DEBUG("link track to electron");
320  std::vector<ElementLink<xAOD::TrackParticleContainer>> links_tracks;
321  links_tracks.push_back(
322  ElementLink<xAOD::TrackParticleContainer>(track, *m_tracks));
323  el->setTrackParticleLinks(links_tracks);
324 
325  ATH_MSG_DEBUG("link cluster to electron");
326  std::vector<ElementLink<xAOD::CaloClusterContainer>> links_clusters;
327  ATH_MSG_DEBUG("push back cluster = " << cluster);
328  links_clusters.push_back(
329  ElementLink<xAOD::CaloClusterContainer>(cluster, *m_clusters));
330  ATH_MSG_DEBUG("set link");
331  el->setCaloClusterLinks(links_clusters);
332 
333  // set particle properties
334 
335  el->setEta(eta);
336  el->setPhi(phi);
337  el->setM(0);
338  el->setPt(e / cosh(eta));
339 
340  return el;
341 }
342 #endif
xAOD::CaloCluster_v1::nSamples
unsigned nSamples() const
Definition: CaloCluster_v1.h:884
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
get_generator_info.result
result
Definition: get_generator_info.py:21
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
xAOD::EventInfo_v1::setEventNumber
void setEventNumber(uint64_t value)
Set the current event's event number.
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition: IEventInfoCnvTool.h:17
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition: Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
xAOD::TrackParticleAuxContainer
TrackParticleAuxContainer_v5 TrackParticleAuxContainer
Definition of the current TrackParticle auxiliary container.
Definition: TrackParticleAuxContainer.h:19
TProfile2D
Definition: rootspy.cxx:531
xAOD::Egamma_v1::setM
void setM(float m)
set the Mass
Definition: Egamma_v1.cxx:130
xAOD::Photon_v1::setVertexLinks
void setVertexLinks(const VxELVec_t &links)
set Pointer to the xAOD::vertex/vertices that match the photon candidate
asg
Definition: DataHandleTestTool.h:28
test_pyathena.pt
pt
Definition: test_pyathena.py:11
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14
bin
Definition: BinsDiffFromStripMedian.h:43
xAOD::CaloCluster_v1::insertMoment
void insertMoment(MomentType type, double value)
Definition: CaloCluster_v1.cxx:754
xAOD::PhotonAuxContainer
PhotonAuxContainer_v3 PhotonAuxContainer
Definition of the current photon auxiliary container.
Definition: PhotonAuxContainer.h:22
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
xAOD::CaloCluster_v1::setSamplingPattern
void setSamplingPattern(const unsigned sp, const bool clearSamplingVars=false)
Set sampling pattern (one bit per sampling.
Definition: CaloCluster_v1.cxx:81
xAOD::CaloCluster_v1::setEnergy
bool setEnergy(const CaloSample sampling, const float e)
Set energy for a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:526
CaloClusterAuxContainer.h
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::CaloCluster_v1::setE
void setE(flt_t)
Definition: CaloCluster_v1.cxx:375
xAOD::CaloClusterContainer
CaloClusterContainer_v1 CaloClusterContainer
Define the latest version of the calorimeter cluster container.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloClusterContainer.h:17
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
xAOD::EventInfo_v1::setEventTypeBitmask
void setEventTypeBitmask(uint32_t value)
Set the event type bitmask.
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition: VertexAuxContainer.h:19
lumiFormat.i
int i
Definition: lumiFormat.py:92
CaloCluster.h
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::Egamma_v1::setPhi
void setPhi(float phi)
set the phi
Definition: Egamma_v1.cxx:125
TEvent.h
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
Init.h
Vertex.h
xAOD::Egamma_v1::setCaloClusterLinks
void setCaloClusterLinks(const CLELVec_t &links)
set Pointer to the xAOD::CaloCluster
DeMoScan.runnumber
runnumber
Definition: DeMoScan.py:266
xAOD::ElectronAuxContainer
ElectronAuxContainer_v3 ElectronAuxContainer
Definition of the current electron auxiliary container.
Definition: ElectronAuxContainer.h:22
xAOD::ElectronContainer
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/ElectronContainer.h:17
xAOD::Egamma_v1::setPt
void setPt(float pt)
set the Pt
Definition: Egamma_v1.cxx:115
PathResolver.h
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
xAOD::PhotonContainer
PhotonContainer_v1 PhotonContainer
Definition of the current "photon container version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/PhotonContainer.h:17
xAOD::CaloClusterAuxContainer
CaloClusterAuxContainer_v2 CaloClusterAuxContainer
Define the latest version of the calorimeter cluster auxiliary container.
Definition: CaloClusterAuxContainer.h:16
xAOD::EventInfo_v1::setAverageInteractionsPerCrossing
void setAverageInteractionsPerCrossing(float value)
Set average interactions per crossing for all BCIDs.
Definition: EventInfo_v1.cxx:408
xAOD::Egamma_v1::setEta
void setEta(float eta)
set the eta
Definition: Egamma_v1.cxx:120
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:172
xAOD::Electron_v1
Definition: Electron_v1.h:34
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:188
EgammaFactory.h
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
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
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::Photon_v1
Definition: Photon_v1.h:37
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
xAOD::EventInfo_v1::setRunNumber
void setRunNumber(uint32_t value)
Set the current event's run number.
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
xAOD::IParticle::auxdata
T & auxdata(const std::string &name, const std::string &clsname="")
Fetch an aux data variable, as a non-const reference.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:96
CaloClusterContainer.h
xAOD::CaloCluster_v1::setPhi
bool setPhi(const CaloSample sampling, const float phi)
Set in a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:556
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
egammaEnergyPositionAllSamples::e0
double e0(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in pre-sampler
xAOD::CaloCluster_v1::setEta
bool setEta(const CaloSample sampling, const float eta)
Set in a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:541
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:187
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
TStore.h
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
VertexAuxContainer.h
Generated on Fri Jul 5 2024 21:14:47 for ATLAS Offline Software by   doxygen 1.8.18