ATLAS Offline Software
egamma.h
Go to the documentation of this file.
1 // dear emacs, this is really -*- C++ -*-
2 
3 /*
4  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 #ifndef EGAMMAEVENT_EGAMMA_H
8 #define EGAMMAEVENT_EGAMMA_H 1
9 
16 /********************************************************************
17 NAME: egamma.h
18 PACKAGE: offline/Reconstruction/egammaRec
19 CREATED: Nov, 2000
20 REWRITTEN Nov, 2006
21 UPDATED:
22  Jun 14, 2007 (FD) Doxygen documentation
23  Nov 24, 2009 (FD) add isElectron, isPhoton and use unsigned int
24  Jan 20, 2010 (MS) add enumeration and code for uncombined 4mom
25 ********************************************************************/
26 
27 // INCLUDE HEADER FILES:
28 
31 
32 #include "AthLinks/ElementLink.h"
33 #include "AthLinks/ElementLinkVector.h"
34 
36 
37 #include "CaloEvent/CaloClusterContainer.h"
39 #include "VxVertex/VxContainer.h"
41 #include "egammaEvent/egDetail.h"
42 
43 #include "egammaEvent/egPID.h"
45 
47 
48 #include <any>
49 
50 class EMErrorDetail;
51 class CaloCluster;
53 
54 class egamma
55  : public ParticleImpl<
56  egammaNavigation, // not really a terminal node: done here
57  P4ImplEEtaPhiM >
58 {
59 
61  // Public typedefs:
63  public:
64 
65  // for readability and lazy people
72 
73  public:
74 
75  enum eg4MomType {
76  // standard cluster-track combined 4Mom
77  Combined = 0,
78  // uncombined cluster 4Mom
79  Uncombined = 1
80  };
81 
82  public:
83 
85  egamma();
87  egamma(unsigned int author);
89  virtual ~egamma();
90  egamma(const egamma &rhs, bool copyDetails=true, bool copyMinimal=false);
91  egamma& operator=(const egamma& rhs);
92 
94  void print() const;
95 
97  void setE (double theE);
99  void setEta (double theEta);
101  void setPhi (double thePhi);
103  void setM (double theM);
104 
106  void set4Mom (const I4Momentum & theI4Mom );
108  void set4Mom (const I4Momentum * const theI4Mom );
110  void set4Mom (const CLHEP::HepLorentzVector & theHlv );
111 
113  void setUncombinedE (double theE);
115  void setUncombinedEta (double theEta);
117  void setUncombinedPhi (double thePhi);
119  void setUncombinedM (double theM);
120 
122  void setUncombined4Mom (const I4Momentum & theI4Mom );
124  void setUncombined4Mom (const I4Momentum * const theI4Mom );
126  void setUncombined4Mom (const CLHEP::HepLorentzVector & theHlv );
127 
129  const CaloCluster* cluster() const;
131  const CaloRings* rings() const;
133  const Rec::TrackParticle* trackParticle (unsigned int index = 0) const;
134  unsigned int nTrackParticles() const;
136  const Trk::VxCandidate* conversion (unsigned int index = 0) const;
137  unsigned int nConversions() const;
138 
140  template <typename T>
141  const T* detail(const std::string& name = "", unsigned int index = 0) const;
142 
144  const egDetail* detail (const std::string& className,
145  const std::string& name = "",
146  unsigned int index = 0) const;
148  const egDetail* detail (int i) const;
153  std::string detailName (int i) const;
155  int nDetails() const;
158  const std::string& name = "",
159  unsigned int index = 0) const;
160 
167  ElementLink<VxContainer> conversionElementLink(unsigned int index = 0) const;
171 
174  double egammaID(egammaPIDObs::PID, bool *found) const;
175  double egammaID(egammaPIDObs::PID) const;
176  const egPID* pid() const;
177 
179  void setDetail(const egDetailContainer*, const egDetail*);
182 
185 
187  void set_pid(egPID* );
190  bool set_egammaID(egammaPIDObs::PID id, double result);
191 
193  bool set_egammaIDint(egammaPIDObs::PID id, unsigned int result);
194 
195  // move this in egPID and just provide return of egPID
196  // const std::vector< std::pair<egammaPIDObs::PID,double> > & get_egammaID() const;
197 
198  // to save pointers to access the different objects of the e/g data class
199 
201  void setCluster(const CaloClusterContainer*, int);
203  void setCluster(const CaloClusterContainer*, const CaloCluster*);
207  void resetCluster();
208 
210  void setRings(const CaloRingsContainer*, int);
212  void setRings(const CaloRingsContainer*, const CaloRings*);
216  void resetRings();
217 
218 
220  void setTrackParticle(const Rec::TrackParticleContainer *, int) ;
226  void resetTrackParticle(unsigned int index = 0);
227 
230 
232  void setConversion(const VxContainer *, int) ;
234  void setConversion(const VxContainer*, const Trk::VxCandidate*);
238  void resetConversion(unsigned int index = 0);
239 
242 
244  unsigned int author() const {return m_author; }
246  bool author(const unsigned int author) const;
248  void addAuthor(unsigned int author) {m_author |= author; }
250  void resetAuthor() {m_author = 0; }
251 
252 
254  virtual void fillToken( INavigationToken & thisToken ) const;
256  virtual void fillToken( INavigationToken & thisToken, const std::any& ) const;
257 
259  bool isElectron(unsigned int mask= egammaPIDObs::ALL,
261  bool *found = nullptr) const;
262  bool isPhoton(unsigned int mask= egammaPIDObs::ALL,
264  bool *found = nullptr) const; // exactly the same as isElectron
265 
267  bool passID(egammaPIDObs::egammaIDQuality id) const;
268 
270  bool isSofte(unsigned int mask= egammaPIDObs::ALL, bool *found = nullptr) const;
271 
273  unsigned int isem(unsigned int mask= egammaPIDObs::ALL,
275  unsigned int isem(unsigned int mask,
277  bool *found) const;
279  unsigned int isemse(unsigned int mask= egammaPIDObs::ALL) const;
280  unsigned int isemse(unsigned int mask, bool *found) const;
281 
283  bool isGoodOQ(unsigned int mask= egammaPIDObs::ALLOQ, bool *found = nullptr) const;
284  unsigned int isgoodoq(unsigned int mask= egammaPIDObs::ALLOQ, bool *found = nullptr) const;
285 
286 
288  virtual const I4MomentumError* errors() const;
289 
292 
294  // P4ImplEEtaPhiM& get4Mom() { return m_momentumCluster; }
296 
297  private:
298 
304 
305  unsigned int m_author;
306 
308 
309  protected:
310 
311  // extra 4 momentum for the cluster based egamma object
312  // P4ImplEEtaPhiM m_momentumCluster;
314 
315 };
316 
317 template <typename T>
318 const T* egamma::detail(const std::string& key, unsigned int index) const {
319  std::size_t nsize = m_egDetails.size();
320  std::size_t iloop = 0;
321 // int nptr = 0;
322  const T* ptr = 0;
323 // const T* tmp = 0;
324 
325  for (; iloop != nsize; iloop++) {
326  if (key.empty()) {
327  if(!m_egDetails[iloop]) continue;
328  ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
329  if (0 != ptr && ptr->linkIndex() == (int)index) {
330 // nptr++; //this is potentially highly confusing now with the ElementLinkVectors and the conversion refits, rather return the first match if there are multiple matches
331 // ptr = tmp;
332  return ptr;
333  }
334  }
335  else if (m_egDetails[iloop].isValid() &&
336  key == m_egDetails.elementDataID(iloop))
337  {
338  if(!m_egDetails[iloop]) continue;
339  ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
340  if (0 != ptr && ptr->linkIndex() == (int)index){
341  return ptr;
342  }
343  }
344  }
345  return ptr;
346 // return (nptr==1) ? ptr : 0;
347 }
348 
349 // inline methods
350 
352 inline
353 void
354 egamma::setE (double ene)
355 { this->momentumBase().setE (ene); }
356 
358 inline
359 void
361 { this->momentumBase().setEta (eta); }
362 
364 inline
365 void
367 { this->momentumBase().setPhi (phi); }
368 
370 inline
371 void
372 egamma::setM (double m)
373 { this->momentumBase().setM (m); }
374 
376 inline
377 void
379 { this->momentumBase().set4Mom (mom); }
380 
382 inline
383 void
385 { this->momentumBase().set4Mom (mom); }
386 
388 inline
389 void
390 egamma::set4Mom (const CLHEP::HepLorentzVector & hlv )
391 { this->momentumBase().set4Mom (hlv); }
392 
394 inline
396 {
397  if ( type==egamma::Combined ) return this->momentumBase();
398  else return m_momentumCluster;
399 }
400 
401 
402 
403 
404 #endif
405 
egamma::trackParticle
const Rec::TrackParticle * trackParticle(unsigned int index=0) const
pointer to TrackParticle
Definition: egamma.cxx:391
egamma::setConversionElementLinkVector
void setConversionElementLinkVector(const ElementLinkVector< VxContainer > &link)
Definition: egamma.cxx:595
egamma::egammaImpl_t
ParticleImpl< egammaNavigation, P4ImplEEtaPhiM > egammaImpl_t
Definition: egamma.h:68
egamma::resetCluster
void resetCluster()
Reset Cluster.
Definition: egamma.cxx:499
egamma::setE
void setE(double theE)
set energy data member
Definition: egamma.h:354
egamma::addAuthor
void addAuthor(unsigned int author)
Add author.
Definition: egamma.h:248
egammaPIDdefsObs.h
egammaPIDObs::IsEM
@ IsEM
cut-based identification for egamma objects (cluster and track-based)
Definition: egammaPIDdefsObs.h:55
egamma::resetConversion
void resetConversion(unsigned int index=0)
Reset Conversion.
Definition: egamma.cxx:563
I4Momentum
Definition: I4Momentum.h:31
egamma::setDetailElementLinkVector
void setDetailElementLinkVector(const ElementLinkVector< egDetailContainer > &v)
Definition: egamma.cxx:627
egamma::setUncombinedE
void setUncombinedE(double theE)
set uncombined energy data member
Definition: egamma.cxx:923
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
egamma::set_egammaIDint
bool set_egammaIDint(egammaPIDObs::PID id, unsigned int result)
set_egamma ID, for usigned int values
Definition: egamma.cxx:340
egamma::errors
virtual const I4MomentumError * errors() const
override standard errors to allow lazy loading (lazy loading NOW DISABLED)
Definition: egamma.cxx:964
get_generator_info.result
result
Definition: get_generator_info.py:21
egamma::setUncombinedPhi
void setUncombinedPhi(double thePhi)
set uncombined phi data member
Definition: egamma.cxx:935
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
egamma::trackParticleElementLink
ElementLink< Rec::TrackParticleContainer > trackParticleElementLink(unsigned int index=0) const
element link to trackParticle
Definition: egamma.cxx:433
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
egamma::setErrorMatrix
void setErrorMatrix(Amg::MatrixX)
Definition: egamma.cxx:970
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
INavigable4Momentum.h
egamma::resetAuthor
void resetAuthor()
set_egamma ID
Definition: egamma.h:250
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
index
Definition: index.py:1
egamma::detailName
std::string detailName(int i) const
name of detail i
Definition: egamma.cxx:883
CaloClusterContainer
Storable container for CaloCluster.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloClusterContainer.h:37
egamma::egamma
egamma()
Default constructor.
Definition: egamma.cxx:24
egamma::setCluster
void setCluster(const CaloClusterContainer *, int)
Set cluster.
Definition: egamma.cxx:467
egammaPIDObs::PID
PID
Definition: egammaPIDdefsObs.h:53
egamma::setDetailElementLink
void setDetailElementLink(const ElementLink< egDetailContainer > &link)
set detailElementLink
Definition: egamma.cxx:619
egamma::setDetail
void setDetail(const egDetailContainer *, const egDetail *)
set detail
Definition: egamma.cxx:609
egamma::detailElementLink
ElementLink< egDetailContainer > detailElementLink(int i) const
ElementLink for detail i.
Definition: egamma.cxx:869
egamma::Uncombined
@ Uncombined
Definition: egamma.h:79
NavigableTerminalNode
Dummy type needed fro specialized implementation.
Definition: NavigableTerminalNode.h:19
P4ImplEEtaPhiM::setM
void setM(const double theM)
set mass data member
Definition: P4ImplEEtaPhiM.h:236
CaloRingsContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/CaloRingsContainer.h:15
egammaParameters::ParamDef
ParamDef
Definition: egammaParamDefs.h:99
egDetailContainer.h
ElementLinkVector< egDetailContainer >
egamma::ringsElementLink
const ElementLink< CaloRingsContainer > & ringsElementLink() const
element link to rings
Definition: egamma.cxx:379
CaloRings
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/CaloRings.h:58
egamma::isSofte
bool isSofte(unsigned int mask=egammaPIDObs::ALL, bool *found=nullptr) const
uses special softe cuts
Definition: egamma.cxx:681
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:620
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
egamma::m_rings
ElementLink< CaloRingsContainer > m_rings
Definition: egamma.h:303
egamma::detailValue
double detailValue(egammaParameters::ParamDef key, const std::string &name="", unsigned int index=0) const
get the float value of key in the container name
Definition: egamma.cxx:899
P4ImplEEtaPhiM.h
egamma::conversionElementLinkVector
const ElementLinkVector< VxContainer > & conversionElementLinkVector() const
Definition: egamma.cxx:461
egamma::momentum_type
egammaImpl_t::momentum_type momentum_type
Definition: egamma.h:70
egamma::fillToken
virtual void fillToken(INavigationToken &thisToken) const
fill token
Definition: egamma.cxx:118
egamma::passID
bool passID(egammaPIDObs::egammaIDQuality id) const
does electron/photon pass the given quality
Definition: egamma.cxx:692
egamma::set_pid
void set_pid(egPID *)
set particle ID
Definition: egamma.cxx:648
egamma::detail
const T * detail(const std::string &name="", unsigned int index=0) const
retrieve eg-detail objects:
Definition: egamma.h:318
egamma::print
void print() const
print method
Definition: egamma.cxx:106
egamma::isem
unsigned int isem(unsigned int mask=egammaPIDObs::ALL, egammaPIDObs::PID pid=egammaPIDObs::IsEM) const
ID flag with cuts, 0:e, >1:jet
Definition: egamma.cxx:769
P4ImplEEtaPhiM::setEta
void setEta(const double theEta)
set eta data member
Definition: P4ImplEEtaPhiM.h:226
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
egamma
Definition: egamma.h:58
egamma::m_egDetails
ElementLinkVector< egDetailContainer > m_egDetails
Definition: egamma.h:302
P4ImplEEtaPhiM::set4Mom
void set4Mom(const I4Momentum &theI4Mom)
set all 4-mom from another I4Momentum reference
Definition: P4ImplEEtaPhiM.h:241
ParticleImpl
Definition: ParticleImpl.h:39
JetTagCalibConfig.className
string className
Definition: JetTagCalibConfig.py:36
egamma::particle_type
egammaImpl_t::particle_type particle_type
Definition: egamma.h:71
P4ImplEEtaPhiM
Definition: P4ImplEEtaPhiM.h:40
egamma::m_egPID
egPID * m_egPID
Definition: egamma.h:307
egamma::eg4MomType
eg4MomType
Definition: egamma.h:75
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
egamma::operator=
egamma & operator=(const egamma &rhs)
Definition: egamma.cxx:83
egamma::m_cluster
ElementLink< CaloClusterContainer > m_cluster
Definition: egamma.h:299
egamma::nTrackParticles
unsigned int nTrackParticles() const
Definition: egamma.cxx:405
egamma::detailElementLinkVector
const ElementLinkVector< egDetailContainer > & detailElementLinkVector() const
Definition: egamma.cxx:877
egamma::m_trackParticle
ElementLinkVector< Rec::TrackParticleContainer > m_trackParticle
Definition: egamma.h:300
egamma::get4Mom
const momentum_type & get4Mom(egamma::eg4MomType type=egamma::Combined) const
return the combined or additional uncombined cluster 4mom
Definition: egamma.h:395
egamma::resetRings
void resetRings()
Reset Cluster.
Definition: egamma.cxx:479
ParticleEvent::Base
Definition: Base.h:34
egamma::pid
const egPID * pid() const
Definition: egamma.cxx:642
lumiFormat.i
int i
Definition: lumiFormat.py:85
I4MomentumError
Definition: I4MomentumError.h:28
egamma::cluster
const CaloCluster * cluster() const
pointer to CaloCluster
Definition: egamma.cxx:360
INavigationToken
Definition: INavigationToken.h:24
CaloCluster
Principal data class for CaloCell clusters.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloCluster.h:79
VxContainer.h
egPID.h
egamma::setPhi
void setPhi(double thePhi)
set phi data member
Definition: egamma.h:366
VxContainer
Definition: VxContainer.h:28
egamma::setTrackParticleElementLink
void setTrackParticleElementLink(const ElementLink< Rec::TrackParticleContainer > &link)
Set Track Particle Link.
Definition: egamma.cxx:543
EMErrorDetail
Definition: EMErrorDetail.h:30
egDetail.h
egamma::isGoodOQ
bool isGoodOQ(unsigned int mask=egammaPIDObs::ALLOQ, bool *found=nullptr) const
OQ flag
Definition: egamma.cxx:817
ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >::momentumBase
const momentum_type & momentumBase() const
access to underlying base type (I4Momentum-like)
Definition: ParticleImpl.h:393
CaloRingsContainer.h
egammaPIDObs::egammaIDQuality
egammaIDQuality
Definition: egammaPIDdefsObs.h:96
egamma::isemse
unsigned int isemse(unsigned int mask=egammaPIDObs::ALL) const
ID flag with cuts for softe, 0:e, >1:jet.
Definition: egamma.cxx:794
egamma::setEta
void setEta(double theEta)
set eta data member
Definition: egamma.h:360
egamma::author
unsigned int author() const
Reconstruction Author
Definition: egamma.h:244
ElementLinkVector::elementDataID
ID_type elementDataID(size_type index) const
dataID (long ref) of an element, given its ElementLinkVector index. O(1)
Definition: AthLinks/ElementLinkVector.h:157
egamma::setRings
void setRings(const CaloRingsContainer *, int)
Set rings object.
Definition: egamma.cxx:473
egamma::setTrackParticleElementLinkVector
void setTrackParticleElementLinkVector(const ElementLinkVector< Rec::TrackParticleContainer > &v)
Definition: egamma.cxx:550
egamma::isPhoton
bool isPhoton(unsigned int mask=egammaPIDObs::ALL, egammaPIDObs::PID pid=egammaPIDObs::IsEM, bool *found=nullptr) const
Definition: egamma.cxx:668
egamma::setM
void setM(double theM)
set mass data member
Definition: egamma.h:372
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
egamma::Combined
@ Combined
Definition: egamma.h:77
egamma::rings
const CaloRings * rings() const
pointer to CaloRings
Definition: egamma.cxx:370
egamma::m_author
unsigned int m_author
Definition: egamma.h:305
egammaPIDObs::ALL
const unsigned int ALL
all cuts
Definition: egammaPIDdefsObs.h:950
Rec::TrackParticleContainer
Definition: Reconstruction/Particle/Particle/TrackParticleContainer.h:33
egamma::conversionElementLink
ElementLink< VxContainer > conversionElementLink(unsigned int index=0) const
element link to conversion
Definition: egamma.cxx:450
egamma::set_egammaID
bool set_egammaID(egammaPIDObs::PID id, double result)
set_egamma ID, for doubles and all possible weights as likelihood
Definition: egamma.cxx:329
egamma::egammaID
double egammaID(egammaPIDObs::PID, bool *found) const
access to PID information, as double to work for IsEM and all possible weights as likelihood
Definition: egamma.cxx:308
egamma::isElectron
bool isElectron(unsigned int mask=egammaPIDObs::ALL, egammaPIDObs::PID pid=egammaPIDObs::IsEM, bool *found=nullptr) const
ID flag with cuts, true:e/phot, false:bkg
Definition: egamma.cxx:655
Rec::TrackParticle
Definition: Reconstruction/Particle/Particle/TrackParticle.h:47
egamma::setConversion
void setConversion(const VxContainer *, int)
Set Conversion.
Definition: egamma.cxx:571
python.PyAthena.v
v
Definition: PyAthena.py:154
egamma::setUncombinedEta
void setUncombinedEta(double theEta)
set uncombined eta data member
Definition: egamma.cxx:929
P4ImplEEtaPhiM::setE
void setE(const double theE)
set energy data member
Definition: P4ImplEEtaPhiM.h:221
egamma::setClusterElementLink
void setClusterElementLink(const ElementLink< CaloClusterContainer > &link)
Set Cluster Element Link.
Definition: egamma.cxx:512
egamma::setUncombinedErrorMatrix
void setUncombinedErrorMatrix(Amg::MatrixX)
Definition: egamma.cxx:984
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
egamma::conversion
const Trk::VxCandidate * conversion(unsigned int index=0) const
pointer to Conversion
Definition: egamma.cxx:411
egamma::resetTrackParticle
void resetTrackParticle(unsigned int index=0)
Reset Track Particle.
Definition: egamma.cxx:518
Trk::VxCandidate
Definition: VxCandidate.h:27
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ElementLinkVector::size
size_type size() const
Definition: AthLinks/ElementLinkVector.h:294
egamma::navigable_type
egammaImpl_t::navigable_type navigable_type
Definition: egamma.h:69
egamma::setUncombinedM
void setUncombinedM(double theM)
set uncombined mass data member
Definition: egamma.cxx:941
egamma::~egamma
virtual ~egamma()
Destructor.
Definition: egamma.cxx:52
egamma::isgoodoq
unsigned int isgoodoq(unsigned int mask=egammaPIDObs::ALLOQ, bool *found=nullptr) const
Definition: egamma.cxx:823
egamma::clusterElementLink
const ElementLink< CaloClusterContainer > & clusterElementLink() const
element link to cluster
Definition: egamma.cxx:427
egamma::m_conversion
ElementLinkVector< VxContainer > m_conversion
Definition: egamma.h:301
egamma::setTrackParticle
void setTrackParticle(const Rec::TrackParticleContainer *, int)
Set Track Particle.
Definition: egamma.cxx:526
P4ImplEEtaPhiM::setPhi
void setPhi(const double thePhi)
set phi data member
Definition: P4ImplEEtaPhiM.h:231
egamma::nConversions
unsigned int nConversions() const
Definition: egamma.cxx:421
egamma::nDetails
int nDetails() const
number of details in egamma object
Definition: egamma.cxx:891
egamma::m_momentumCluster
momentum_type m_momentumCluster
Definition: egamma.h:313
egDetail
Definition: egDetail.h:29
egPID
Definition: egPID.h:32
egammaPIDObs::ALLOQ
const unsigned int ALLOQ
Definition: egammaPIDdefsObs.h:729
egDetailContainer
Definition: egDetailContainer.h:18
ParticleImpl.h
egammaNavigation
NavigableTerminalNode egammaNavigation
Definition: egamma.h:51
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
egamma::setConversionElementLink
void setConversionElementLink(const ElementLink< VxContainer > &link)
Set Conversion.
Definition: egamma.cxx:588
egamma::trackParticleElementLinkVector
const ElementLinkVector< Rec::TrackParticleContainer > & trackParticleElementLinkVector() const
Definition: egamma.cxx:444
egamma::setRingsElementLink
void setRingsElementLink(const ElementLink< CaloRingsContainer > &link)
Set Rings Element Link.
Definition: egamma.cxx:492
egamma::set4Mom
void set4Mom(const I4Momentum &theI4Mom)
set all 4-mom from another I4Momentum reference
Definition: egamma.h:378
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
TrackParticleContainer.h
egamma::setUncombined4Mom
void setUncombined4Mom(const I4Momentum &theI4Mom)
set uncombined all 4-mom from another I4Momentum reference
Definition: egamma.cxx:947