egamma Class Reference

elec/gamma data class. More...

#include <egamma.h>

Inheritance diagram for egamma:

Collaboration diagram for egamma:

Public Types
enum	eg4MomType { Combined = 0 , Uncombined = 1 }
typedef ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >	egammaImpl_t
typedef egammaImpl_t::navigable_type	navigable_type
typedef egammaImpl_t::momentum_type	momentum_type
typedef egammaImpl_t::particle_type	particle_type
typedef ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >	self_type
	publish the type of the base class (ie: 'traits-itize' it)
enum	Kind {   P4EETAPHIM , P4IPTCOTTHPHIM , P4PTETAPHIM , P4PXPYPZE ,   UNKNOWN }

Public Member Functions
	egamma ()
	Default constructor.
	egamma (unsigned int author)
	Default constructor.
virtual	~egamma ()
	Destructor.
	egamma (const egamma &rhs, bool copyDetails=true, bool copyMinimal=false)
egamma &	operator= (const egamma &rhs)
egamma &	operator= (egamma &&rhs)=default
void	print () const
	print method
void	setE (double theE)
	set energy data member
void	setEta (double theEta)
	set eta data member
void	setPhi (double thePhi)
	set phi data member
void	setM (double theM)
	set mass data member
void	set4Mom (const I4Momentum &theI4Mom)
	set all 4-mom from another I4Momentum reference
void	set4Mom (const I4Momentum *const theI4Mom)
	set all 4-mom from another I4Momentum pointer
void	set4Mom (const CLHEP::HepLorentzVector &theHlv)
	set all 4-mom from a CLHEP HepLorentzVector
void	setUncombinedE (double theE)
	set uncombined energy data member
void	setUncombinedEta (double theEta)
	set uncombined eta data member
void	setUncombinedPhi (double thePhi)
	set uncombined phi data member
void	setUncombinedM (double theM)
	set uncombined mass data member
void	setUncombined4Mom (const I4Momentum &theI4Mom)
	set uncombined all 4-mom from another I4Momentum reference
void	setUncombined4Mom (const I4Momentum *const theI4Mom)
	set uncombined all 4-mom from another I4Momentum pointer
void	setUncombined4Mom (const CLHEP::HepLorentzVector &theHlv)
	set uncombined all 4-mom from a CLHEP HepLorentzVector
const CaloCluster *	cluster () const
	pointer to CaloCluster
const CaloRings *	rings () const
	pointer to CaloRings
const Rec::TrackParticle *	trackParticle (unsigned int index=0) const
	pointer to TrackParticle
unsigned int	nTrackParticles () const
const Trk::VxCandidate *	conversion (unsigned int index=0) const
	pointer to Conversion
unsigned int	nConversions () const
template<typename T>
const T *	detail (const std::string &name="", unsigned int index=0) const
	retrieve eg-detail objects:
const egDetail *	detail (const std::string &className, const std::string &name="", unsigned int index=0) const
	pointer to detail className of container name
const egDetail *	detail (int i) const
	pointer to detail i
ElementLink< egDetailContainer >	detailElementLink (int i) const
	ElementLink for detail i.
const ElementLinkVector< egDetailContainer > &	detailElementLinkVector () const
std::string	detailName (int i) const
	name of detail i
int	nDetails () const
	number of details in egamma object
double	detailValue (egammaParameters::ParamDef key, const std::string &name="", unsigned int index=0) const
	get the float value of key in the container name
ElementLink< Rec::TrackParticleContainer >	trackParticleElementLink (unsigned int index=0) const
	element link to trackParticle
const ElementLinkVector< Rec::TrackParticleContainer > &	trackParticleElementLinkVector () const
const ElementLink< CaloClusterContainer > &	clusterElementLink () const
	element link to cluster
ElementLink< VxContainer >	conversionElementLink (unsigned int index=0) const
	element link to conversion
const ElementLinkVector< VxContainer > &	conversionElementLinkVector () const
const ElementLink< CaloRingsContainer > &	ringsElementLink () const
	element link to rings
double	egammaID (egammaPIDObs::PID, bool *found) const
	access to PID information, as double to work for IsEM and all possible weights as likelihood
double	egammaID (egammaPIDObs::PID) const
const egPID *	pid () const
void	setDetail (const egDetailContainer *, const egDetail *)
	set detail
void	setDetailElementLink (const ElementLink< egDetailContainer > &link)
	set detailElementLink
void	setDetailElementLinkVector (const ElementLinkVector< egDetailContainer > &v)
void	setDetailElementLinkVector (ElementLinkVector< egDetailContainer > &&v)
bool	set_egammaID (egammaPIDObs::PID id, double result)
	set_egamma ID, for doubles and all possible weights as likelihood
bool	set_egammaIDint (egammaPIDObs::PID id, unsigned int result)
	set_egamma ID, for usigned int values
void	setCluster (const CaloClusterContainer *, int)
	Set cluster.
void	setCluster (const CaloClusterContainer *, const CaloCluster *)
	Set cluster.
void	setClusterElementLink (const ElementLink< CaloClusterContainer > &link)
	Set Cluster Element Link.
void	resetCluster ()
	Reset Cluster.
void	setRings (const CaloRingsContainer *, int)
	Set rings object.
void	setRings (const CaloRingsContainer *, const CaloRings *)
	Set rings object.
void	setRingsElementLink (const ElementLink< CaloRingsContainer > &link)
	Set Rings Element Link.
void	resetRings ()
	Reset Cluster.
void	setTrackParticle (const Rec::TrackParticleContainer *, int)
	Set Track Particle.
void	setTrackParticle (const Rec::TrackParticleContainer *, const Rec::TrackParticle *)
	Set Track Particle.
void	setTrackParticleElementLink (const ElementLink< Rec::TrackParticleContainer > &link)
	Set Track Particle Link.
void	resetTrackParticle (unsigned int index=0)
	Reset Track Particle.
void	setTrackParticleElementLinkVector (const ElementLinkVector< Rec::TrackParticleContainer > &v)
void	setTrackParticleElementLinkVector (ElementLinkVector< Rec::TrackParticleContainer > &&v)
void	setConversion (const VxContainer *, int)
	Set Conversion.
void	setConversion (const VxContainer *, const Trk::VxCandidate *)
	Set Conversion.
void	setConversionElementLink (const ElementLink< VxContainer > &link)
	Set Conversion.
void	resetConversion (unsigned int index=0)
	Reset Conversion.
void	setConversionElementLinkVector (const ElementLinkVector< VxContainer > &link)
void	setConversionElementLinkVector (ElementLinkVector< VxContainer > &&link)
unsigned int	author () const
	Reconstruction Author.
bool	author (const unsigned int author) const
	Reconstruction Author.
void	addAuthor (unsigned int author)
	Add author.
void	resetAuthor ()
	set_egamma ID
virtual void	fillToken (INavigationToken &thisToken) const
	fill token
virtual void	fillToken (INavigationToken &thisToken, const std::any &) const
	fill token
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.
bool	isPhoton (unsigned int mask=egammaPIDObs::ALL, egammaPIDObs::PID pid=egammaPIDObs::IsEM, bool *found=nullptr) const
bool	passID (egammaPIDObs::egammaIDQuality id) const
	does electron/photon pass the given quality
bool	isSofte (unsigned int mask=egammaPIDObs::ALL, bool *found=nullptr) const
	uses special softe cuts
unsigned int	isem (unsigned int mask=egammaPIDObs::ALL, egammaPIDObs::PID pid=egammaPIDObs::IsEM) const
	ID flag with cuts, 0:e, >1:jet.
unsigned int	isem (unsigned int mask, egammaPIDObs::PID pid, bool *found) const
unsigned int	isemse (unsigned int mask=egammaPIDObs::ALL) const
	ID flag with cuts for softe, 0:e, >1:jet.
unsigned int	isemse (unsigned int mask, bool *found) const
bool	isGoodOQ (unsigned int mask=egammaPIDObs::ALLOQ, bool *found=nullptr) const
	OQ flag.
unsigned int	isgoodoq (unsigned int mask=egammaPIDObs::ALLOQ, bool *found=nullptr) const
virtual const I4MomentumError *	errors () const
	override standard errors to allow lazy loading (lazy loading NOW DISABLED)
void	setErrorMatrix (Amg::MatrixX)
void	setUncombinedErrorMatrix (Amg::MatrixX)
const momentum_type &	get4Mom (egamma::eg4MomType type=egamma::Combined) const
	return the combined or additional uncombined cluster 4mom
const navigable_type &	navigableBase () const
	access to underlying base type (INavigable-like)
navigable_type &	navigableBase ()
	access to underlying base type (INavigable-like)
const momentum_type &	momentumBase () const
	access to underlying base type (I4Momentum-like)
momentum_type &	momentumBase ()
	access to underlying base type (I4Momentum-like)
const particle_type &	particleBase () const
	access to underlying base type (IParticle-like)
particle_type &	particleBase ()
	access to underlying base type (IParticle-like)
virtual void	set_dataType (ParticleDataType::DataType x)
virtual void	set_charge (ChargeType x)
virtual void	set_pdgId (int x)
virtual void	set_origin (const VxContainer *theContainer, int index)
virtual void	set_origin (const VxContainer *theContainer, const Trk::VxCandidate *vertex)
void	set_origin (const ElementLink< VxContainer > &origin)
AthenaBarCode_t	getAthenaBarCode () const
void	setAthenaBarCode (AthenaBarCode_t)
bool	hasSameAthenaBarCode (const IAthenaBarCode &) const
bool	hasSameAthenaBarCodeExceptVersion (const IAthenaBarCode &) const
AthenaBarCodeVersion_t	getVersion () const
void	newVersion ()
void	setVersion (AthenaBarCodeVersion_t newversion)
virtual double	px () const
	x component of momentum
virtual double	py () const
	y component of momentum
virtual double	pz () const
	z component of momentum
virtual double	m () const
	mass
virtual double	m2 () const
	mass squared
virtual double	p () const
	mass momentum magnitude
virtual double	p2 () const
	square of momentum magnitude
virtual double	rapidity () const
	rapidity
virtual double	eta () const
	pseudo rapidity
virtual double	phi () const
	phi in [-pi,pi[
virtual double	e () const
	energy
virtual double	et () const
	transverse energy defined to be e*sin(theta)
virtual double	pt () const
	transverse momentum
virtual double	iPt () const
	inverse of transverse momentum
virtual double	cosPhi () const
	cosinus phi
virtual double	sinPhi () const
	sinus phi
virtual double	tanTh () const
	tan theta
virtual double	cosTh () const
	cosinus theta
virtual double	sinTh () const
	sinus theta
virtual double	cotTh () const
	cottan theta
virtual CLHEP::HepLorentzVector	hlv () const
	CLHEP HepLorentzVector.
virtual I4Momentum::Kind	kind () const
	add Kind which tells what kind (P4XYZ) the underlying implementation has
virtual std::ostream &	dump (std::ostream &out) const
	Print I4Momentum content.
virtual ParticleDataType::DataType	dataType () const
	Return enum indicating real data, fast, or full simulation Return Type has a DataType enum with the following values: {Data = 0, Full = 1, FastShower = 2, Fast = 3, True = 4}.
virtual const Trk::RecVertex *	origin () const
	Return a RecVertex corresponding to particle Origin.
virtual const ElementLink< VxContainer > &	originLink () const
	Return an ElementLink corresponding to particle's Origin.
virtual bool	hasCharge () const
	method to check if charge information is available
virtual ChargeType	charge () const
	returns charge as a typedef ChargeType currently Charge Type is a double for jets this may be changed to an int and ask jets to extend this interface
virtual bool	hasPdgId () const
	method to check if particle id information is available
virtual int	pdgId () const
	Return enum indicating particle id the enum file is available in Event/EventKernel/PdtPdg.h.

Static Public Attributes
static const AthenaBarCode_t	UNDEFINEDBARCODE = (AthenaBarCode_t)(-1)
static const AthenaBarCode_t	UNDEFINEDVERSION = UNDEFINEDBARCODE

Protected Attributes
momentum_type	m_momentumCluster

Private Attributes
ElementLink< CaloClusterContainer >	m_cluster
ElementLinkVector< Rec::TrackParticleContainer >	m_trackParticle
ElementLinkVector< VxContainer >	m_conversion
ElementLinkVector< egDetailContainer >	m_egDetails
ElementLink< CaloRingsContainer >	m_rings
unsigned int	m_author
std::unique_ptr< egPID >	m_egPID
egammaNavigation	m_nav
	The navigable part.
P4ImplEEtaPhiM	m_mom
	The 4-momentum part.
ParticleEvent::Base	m_part
	The particle-id part.

Detailed Description

elec/gamma data class.

It contains the different egDetails. The class is made by egammaBuilder, which is an algorithm

Author

H. Ma, S. Rajagopalan, D. Zerwas, K. Cranmer, S. Laplace, M. Wielers, A. Khodinov, F. Derue, H. Kim

Definition at line 55 of file egamma.h.

Member Typedef Documentation

egammaImpl_t

typedef ParticleImpl< egammaNavigation, P4ImplEEtaPhiM > egamma::egammaImpl_t

Definition at line 69 of file egamma.h.

momentum_type

typedef egammaImpl_t::momentum_type egamma::momentum_type

Definition at line 71 of file egamma.h.

navigable_type

typedef egammaImpl_t::navigable_type egamma::navigable_type

Definition at line 70 of file egamma.h.

particle_type

typedef egammaImpl_t::particle_type egamma::particle_type

Definition at line 72 of file egamma.h.

self_type

typedef ParticleImpl<egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base> ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::self_type

inherited

publish the type of the base class (ie: 'traits-itize' it)

Definition at line 62 of file ParticleImpl.h.

Member Enumeration Documentation

eg4MomType

enum egamma::eg4MomType

Enumerator
Combined
Uncombined

Definition at line 76 of file egamma.h.

                  {
    // standard cluster-track combined 4Mom
    Combined   = 0,
    // uncombined cluster 4Mom
    Uncombined = 1
  };      

Kind

enum I4Momentum::Kind

inherited

Enumerator
P4EETAPHIM
P4IPTCOTTHPHIM
P4PTETAPHIM
P4PXPYPZE
UNKNOWN

Definition at line 33 of file I4Momentum.h.

{ P4EETAPHIM, P4IPTCOTTHPHIM, P4PTETAPHIM, P4PXPYPZE, UNKNOWN };

Constructor & Destructor Documentation

egamma() [1/3]

egamma::egamma

(

)

Default constructor.

Definition at line 24 of file egamma.cxx.

  : IAthenaBarCode()
  , INavigable()
  , I4Momentum()
  , INavigable4Momentum()
  , egammaImpl_t()
  , m_author(egammaParameters::AuthorUnknown)
  , m_egPID(std::make_unique<egPID>())
  , m_momentumCluster()
{
}

egamma() [2/3]

egamma::egamma

(

unsigned int

author

)

Default constructor.

Definition at line 36 of file egamma.cxx.

                                  :
  IAthenaBarCode(),
  INavigable (),
  I4Momentum (),
  INavigable4Momentum (),
  egammaImpl_t(),
  m_author (author),
  m_egPID(std::make_unique<egPID>()),
  m_momentumCluster() 
{ 
  
}

~egamma()

egamma::~egamma ( )

virtualdefault

Destructor.

egamma() [3/3]

egamma::egamma	(	const egamma &	rhs,
		bool	copyDetails = true,
		bool	copyMinimal = false )

Definition at line 57 of file egamma.cxx.

                                                                   :
  IAthenaBarCode      (rhs),
  INavigable          (rhs),
  I4Momentum          (rhs),
  INavigable4Momentum (rhs),
  egammaImpl_t        (rhs),
  m_author            (rhs.m_author),
  m_egPID             (std::make_unique<egPID>(*(rhs.m_egPID))),
  m_momentumCluster   (rhs.m_momentumCluster)
{
  if (!copyMinimal) {
    m_cluster       = rhs.m_cluster;
    m_trackParticle = rhs.m_trackParticle;
    m_conversion    = rhs.m_conversion;
    if (copyDetails) {
      m_egDetails     = rhs.m_egDetails;
    }
    m_rings = rhs.m_rings;
  }
}

Member Function Documentation

addAuthor()

void egamma::addAuthor ( unsigned int author )

inline

Add author.

Definition at line 249 of file egamma.h.

{m_author |= author; }

author() [1/2]

unsigned int egamma::author ( ) const

inline

Reconstruction Author.

Definition at line 245 of file egamma.h.

{return m_author; }

author() [2/2]

bool egamma::author

(

const unsigned int

author

)

const

Reconstruction Author.

Definition at line 348 of file egamma.cxx.

{
  //
  // method to check the author
  //
 
  return (m_author & author) != 0;
}

charge()

virtual ChargeType ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::charge ( ) const

virtualinherited

returns charge as a typedef ChargeType currently Charge Type is a double for jets this may be changed to an int and ask jets to extend this interface

Implements IParticle.

cluster()

const CaloCluster * egamma::cluster

(

)

const

pointer to CaloCluster

Definition at line 358 of file egamma.cxx.

{ 
  //
  // method to acces the cluster object
  //
 
  return (m_cluster.isValid()) ? *m_cluster : nullptr;
} 

clusterElementLink()

const ElementLink< CaloClusterContainer > & egamma::clusterElementLink

(

)

const

element link to cluster

Definition at line 425 of file egamma.cxx.

{ 
  return m_cluster;
}

conversion()

const Trk::VxCandidate * egamma::conversion

(

unsigned int

index = 0

)

const

pointer to Conversion

Definition at line 409 of file egamma.cxx.

{ 
  if(index < m_conversion.size()){
    return ((m_conversion.at(index)).isValid()) ? *(m_conversion.at(index)) : nullptr;
  }
    return nullptr;
  
}   

conversionElementLink()

ElementLink< VxContainer > egamma::conversionElementLink

(

unsigned int

index = 0

)

const

element link to conversion

Definition at line 448 of file egamma.cxx.

{ 
  if(index < m_conversion.size()){
    return m_conversion.at(index);
  }
    return {};
  
}

conversionElementLinkVector()

const ElementLinkVector< VxContainer > & egamma::conversionElementLinkVector

(

)

const

Definition at line 459 of file egamma.cxx.

{ 
  return m_conversion;
}

cosPhi()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::cosPhi ( ) const

virtualinherited

cosinus phi

Implements I4Momentum.

cosTh()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::cosTh ( ) const

virtualinherited

cosinus theta

Implements I4Momentum.

cotTh()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::cotTh ( ) const

virtualinherited

cottan theta

Implements I4Momentum.

dataType()

virtual ParticleDataType::DataType ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::dataType ( ) const

virtualinherited

Return enum indicating real data, fast, or full simulation Return Type has a DataType enum with the following values: {Data = 0, Full = 1, FastShower = 2, Fast = 3, True = 4}.

IParticle interface forwarding

Implements IParticle.

detail() [1/3]

const egDetail * egamma::detail	(	const std::string &	className,
		const std::string &	name = "",
		unsigned int	index = 0 ) const

pointer to detail className of container name

Definition at line 834 of file egamma.cxx.

{
  size_t nsize = m_egDetails.size();
//   const egDetail* ptr = 0;
  for (size_t i = 0; i < nsize; i++) {
    if (m_egDetails[i].isValid() &&
        (*m_egDetails[i])->className() == className)
    {
      if (name.empty()) {
//         if (ptr) //this is potentially highly confusing now with the ElementLinkVectors and the conversion refits, rather return the first match if there are multiple matches
//           return 0;
//         else
    if((*m_egDetails[i])->linkIndex() == (int)index)
      return *m_egDetails[i];
//        ptr = *m_egDetails[i];
      }
      else if (m_egDetails.elementDataID(i) == name && (*m_egDetails[i])->linkIndex() == (int)index)
        return *m_egDetails[i];
    }
  }
//   return ptr;
  return nullptr;
}

detail() [2/3]

template<typename T>

const T * egamma::detail	(	const std::string &	name = "",
		unsigned int	index = 0 ) const

retrieve eg-detail objects:

Definition at line 319 of file egamma.h.

                                                                      {
    std::size_t nsize = m_egDetails.size();
    std::size_t iloop = 0;
//     int nptr = 0;
    const T* ptr = 0;
//     const T* tmp = 0;
 
    for (; iloop != nsize; iloop++) {
      if (key.empty()) {
    if(!m_egDetails[iloop]) continue;
        ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
    if (0 != ptr && ptr->linkIndex() == (int)index) {
//    nptr++; //this is potentially highly confusing now with the ElementLinkVectors and the conversion refits, rather return the first match if there are multiple matches
//    ptr = tmp;
      return ptr;
    }
      }
      else if (m_egDetails[iloop].isValid() &&
               key == m_egDetails.elementDataID(iloop))
      {
    if(!m_egDetails[iloop]) continue;
        ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
    if (0 != ptr && ptr->linkIndex() == (int)index){
      return ptr;
    }
      }
    }
    return ptr;
//     return (nptr==1) ? ptr : 0;
}

detail() [3/3]

const egDetail * egamma::detail

(

int

i

)

const

pointer to detail i

Definition at line 826 of file egamma.cxx.

{
  if (i < 0 || i >= (int)m_egDetails.size())
    return nullptr;
  return *m_egDetails[i];
}

detailElementLink()

ElementLink< egDetailContainer > egamma::detailElementLink

(

int

i

)

const

ElementLink for detail i.

Definition at line 861 of file egamma.cxx.

{
  if (i < 0 || i >= (int)m_egDetails.size())
    return {};
  return m_egDetails[i];
}

detailElementLinkVector()

const ElementLinkVector< egDetailContainer > & egamma::detailElementLinkVector

(

)

const

Definition at line 869 of file egamma.cxx.

{
  return m_egDetails;
}

detailName()

std::string egamma::detailName

(

int

i

)

const

name of detail i

Definition at line 875 of file egamma.cxx.

{
  if (i < 0 || i >= (int)m_egDetails.size())
    return "";
  return m_egDetails.elementDataID(i);
}

detailValue()

double egamma::detailValue	(	egammaParameters::ParamDef	key,
		const std::string &	name = "",
		unsigned int	index = 0 ) const

get the float value of key in the container name

Definition at line 891 of file egamma.cxx.

{
  size_t nsize = m_egDetails.size();
 
  const egDetail* ptr = nullptr;
  for (size_t i = 0; i < nsize; i++) {
    if (m_egDetails[i].isValid()) {
      if (name.empty()) {
    ptr = *m_egDetails[i];
      }
      else if (m_egDetails.elementDataID(i) == name)
    ptr = *m_egDetails[i];
    }
    if ( ptr && ptr->hasParameter(key) && ptr->linkIndex() == (int)index)
      return ptr->parameter(key);
  }
  
  return egammaParameters::EgParamUndefined;
}

dump()

virtual std::ostream & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::dump ( std::ostream & out ) const

virtualinherited

Print I4Momentum content.

Implements I4Momentum.

e()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::e ( ) const

virtualinherited

energy

Implements I4Momentum.

egammaID() [1/2]

double egamma::egammaID

(

egammaPIDObs::PID

idflag

)

const

Definition at line 316 of file egamma.cxx.

{
  //
  // method to retrieve the PID
  // set as double to work for IsEM but also for all weights as likelihood
  //
 
  return m_egPID->egammaID(idflag, nullptr);
}

egammaID() [2/2]

double egamma::egammaID	(	egammaPIDObs::PID	idflag,
		bool *	found ) const

access to PID information, as double to work for IsEM and all possible weights as likelihood

Definition at line 306 of file egamma.cxx.

{
  //
  // method to retrieve the PID
  // set as double to work for IsEM but also for all weights as likelihood
  //
 
  return m_egPID->egammaID(idflag, found);
}

errors()

const I4MomentumError * egamma::errors ( ) const

virtual

override standard errors to allow lazy loading (lazy loading NOW DISABLED)

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 956 of file egamma.cxx.

{
  return momentumBase().errors();
}

et()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::et ( ) const

virtualinherited

transverse energy defined to be e*sin(theta)

Implements I4Momentum.

eta()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::eta ( void ) const

virtualinherited

pseudo rapidity

Implements I4Momentum.

fillToken() [1/2]

void egamma::fillToken ( INavigationToken & thisToken ) const

virtual

fill token

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 116 of file egamma.cxx.

{
 
  bool checkFlag = false;

  // First check on track //
 
  const Rec::TrackParticle* aTrack = this->trackParticle();  
  if ( aTrack != nullptr )
    {
      // check requested object type with token type
      NavigationToken<Rec::TrackParticle>* trackToken =
    dynamic_cast< NavigationToken<Rec::TrackParticle>* >(&theToken);
      if ( trackToken != nullptr )
    {
      // request is honored
      trackToken->setObject(aTrack);
      checkFlag = true;
    }
 
      // alternative token type may phrase the same request
      if ( ! checkFlag ) 
    {
      NavigationToken<Rec::TrackParticle,double>* parTrackToken =
        dynamic_cast< NavigationToken<Rec::TrackParticle,double>* >
        (&theToken);
      if ( parTrackToken != nullptr )
        {
          parTrackToken->setObject(aTrack);
          checkFlag = true;
        }
    }
    }

  // At this point only a request for Rec::TrackParticle could have been
  // honored. This is indicated by checkFlag = true. If checkFlag = false,
  // a test on a request for CaloCluster is performed.
 
  // bail out if request for Rec::TrackParticle is already honored
  if (  checkFlag ) return;

  // Check on cluster //
 
  const CaloCluster* aCluster = this->cluster();
  if ( aCluster != nullptr )
    {
      // check on requested type
      NavigationToken<CaloCluster>* clusToken =
    dynamic_cast< NavigationToken<CaloCluster>* >(&theToken);
      if ( clusToken != nullptr )
        {
          clusToken->setObject(aCluster);
          checkFlag = true;
    }
      // allow for visitor with relational parameter type
      if ( ! checkFlag ) 
    { 
      NavigationToken<CaloCluster,double>* parClusToken =
        dynamic_cast< NavigationToken<CaloCluster,double>* >(&theToken);
      if ( parClusToken != nullptr )
        {
          parClusToken->setObject(aCluster);
          checkFlag = true;
        }
    }
    }
 
  // concrete type request for CaloCluster honored
  if ( checkFlag ) return;

  // Pass on the token to composite constituents: ie. CaloCluster! //
 
  if ( aCluster!= nullptr ) aCluster->fillToken(theToken);

  // At this point no request for concrete egamma constituents has been
  // submitted if checkFlag = false. Now we need to check if a generic
  // type has been requested (i.e. a base type for tracks and clusters).
 
  // try for generic type requests
  if ( aTrack  != nullptr ) theToken.trySetObject(aTrack);
  if ( aCluster!= nullptr ) theToken.trySetObject(aCluster);
}

fillToken() [2/2]

void egamma::fillToken ( INavigationToken & thisToken, const std::any & theWeight ) const

virtual

fill token

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 213 of file egamma.cxx.

{
  bool checkFlag = false;

  // First check on track //
  const Rec::TrackParticle* aTrack = this->trackParticle();  
  if ( aTrack != nullptr )
    {
      // check requested object type with token type
      NavigationToken<Rec::TrackParticle>* trackToken =
    dynamic_cast< NavigationToken<Rec::TrackParticle>* >(&theToken);
      if ( trackToken != nullptr )
    {
      // request is honored
      trackToken->setObject(aTrack);
      checkFlag = true;
    }
 
      // alternative token type may phrase the same request
      if ( ! checkFlag )
    {
      NavigationToken<Rec::TrackParticle,double>* parTrackToken =
        dynamic_cast< NavigationToken<Rec::TrackParticle,double>* >
        (&theToken);
      if ( parTrackToken != nullptr )
        {
          // no weight change in propagation
          parTrackToken->setObject(aTrack,
                       std::any_cast<double>(theWeight));
          checkFlag = true;
        }
    }
    }
 
  // checks on track successful (see above)
  if ( checkFlag ) return;

  // Check on cluster //
 
  const CaloCluster* aCluster = this->cluster();  
  if ( aCluster != nullptr )
    {
      // check on requested type
      NavigationToken<CaloCluster>* clusToken =
    dynamic_cast< NavigationToken<CaloCluster>* >(&theToken);
      if ( clusToken != nullptr )
        {
          clusToken->setObject(aCluster);
      checkFlag = true;
    }
      // allow for visitor with relational parameter type
      if ( ! checkFlag )
    { 
      NavigationToken<CaloCluster,double>* parClusToken =
        dynamic_cast< NavigationToken<CaloCluster,double>* >(&theToken);
      if ( parClusToken != nullptr )
        {
          parClusToken->setObject(aCluster,
                      std::any_cast<double>(theWeight));
          checkFlag = true;
        }
    }
    }
 
  // concrete check for CaloCluster honored
  if ( checkFlag ) return;

  // Pass on the token to composite constituents: ie. CaloCluster! //
 
  if ( aCluster != nullptr )  aCluster->fillToken(theToken,theWeight);
 

  // At this point no request for concrete egamma constituents has been
  // submitted if checkFlag = false. Now we need to check if a generic
  // type has been requested (i.e. a base type for tracks and clusters).
 
  // try for generic type requests
  if ( aTrack   != nullptr ) theToken.trySetObject(aTrack,  theWeight);
  if ( aCluster != nullptr ) theToken.trySetObject(aCluster,theWeight);
}

get4Mom()

const egamma::momentum_type & egamma::get4Mom ( egamma::eg4MomType type = egamma::Combined ) const

inline

return the combined or additional uncombined cluster 4mom

return the combined, or additional uncombined cluster 4mom

Definition at line 396 of file egamma.h.

{ 
  if ( type==egamma::Combined ) return this->momentumBase(); 
  else                          return m_momentumCluster;    
}                                                            

getAthenaBarCode()

AthenaBarCode_t ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::getAthenaBarCode ( ) const

virtualinherited

IAthenaBarCode interface forwarding

Reimplemented from IAthenaBarCode.

getVersion()

AthenaBarCodeVersion_t ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::getVersion ( ) const

virtualinherited

Reimplemented from IAthenaBarCode.

hasCharge()

virtual bool ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::hasCharge ( ) const

virtualinherited

method to check if charge information is available

Implements IParticle.

hasPdgId()

virtual bool ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::hasPdgId ( ) const

virtualinherited

method to check if particle id information is available

Implements IParticle.

hasSameAthenaBarCode()

bool ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::hasSameAthenaBarCode ( const IAthenaBarCode & ) const

virtualinherited

Reimplemented from IAthenaBarCode.

hasSameAthenaBarCodeExceptVersion()

bool ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::hasSameAthenaBarCodeExceptVersion ( const IAthenaBarCode & ) const

virtualinherited

Reimplemented from IAthenaBarCode.

hlv()

virtual CLHEP::HepLorentzVector ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::hlv ( ) const

virtualinherited

CLHEP HepLorentzVector.

Implements I4Momentum.

iPt()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::iPt ( ) const

virtualinherited

inverse of transverse momentum

Implements I4Momentum.

isElectron()

bool egamma::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 at line 647 of file egamma.cxx.

{ 
  //
  // boolean method to define if egamma object is identified 
  // by standard cut-based selection
  //
 
  return (m_egPID->isEM(mask, pid, found)==0);
} 

isem() [1/2]

unsigned int egamma::isem	(	unsigned int	mask,
		egammaPIDObs::PID	pid,
		bool *	found ) const

Definition at line 773 of file egamma.cxx.

{ 
  //
  // method which applies a mask to the isEM variable
  // and returns the corresponding decoded value
  //
 
  return m_egPID->isEM(mask, pid, found); 
} 

isem() [2/2]

unsigned int egamma::isem	(	unsigned int	mask = egammaPIDObs::ALL,
		egammaPIDObs::PID	pid = egammaPIDObs::IsEM ) const

ID flag with cuts, 0:e, >1:jet.

Definition at line 761 of file egamma.cxx.

{ 
  //
  // method which applies a mask to the isEM variable
  // and returns the corresponding decoded value
  //
 
  return m_egPID->isEM(mask, pid, nullptr); 
} 

isemse() [1/2]

unsigned int egamma::isemse	(	unsigned int	mask,
		bool *	found ) const

Definition at line 797 of file egamma.cxx.

{ 
  //
  // method which applies a mask to the isEMsofte variable
  // and returns the corresponding decoded value
  //
 
  return m_egPID->isEMsofte(mask, found); 
} 

isemse() [2/2]

unsigned int egamma::isemse

(

unsigned int

mask = egammaPIDObs::ALL

)

const

ID flag with cuts for softe, 0:e, >1:jet.

Definition at line 786 of file egamma.cxx.

{ 
  //
  // method which applies a mask to the isEMsofte variable
  // and returns the corresponding decoded value
  //
 
  return m_egPID->isEMsofte(mask, nullptr); 
} 

isGoodOQ()

bool egamma::isGoodOQ	(	unsigned int	mask = egammaPIDObs::ALLOQ,
		bool *	found = nullptr ) const

OQ flag.

Definition at line 809 of file egamma.cxx.

{
  return (m_egPID->IsGoodOQ(mask, found) == 0);
}

isgoodoq()

unsigned int egamma::isgoodoq	(	unsigned int	mask = egammaPIDObs::ALLOQ,
		bool *	found = nullptr ) const

Definition at line 815 of file egamma.cxx.

{ 
  //
  // method which applies a mask to theIsGoodOQ  variable
  // and returns the corresponding decoded value
  //
 
  return m_egPID->IsGoodOQ(mask, found); 
} 

isPhoton()

bool egamma::isPhoton	(	unsigned int	mask = egammaPIDObs::ALL,
		egammaPIDObs::PID	pid = egammaPIDObs::IsEM,
		bool *	found = nullptr ) const

Definition at line 660 of file egamma.cxx.

{ 
  //
  // boolean method to define if egamma object is identified 
  // by standard cut-based selection
  //
 
  return (m_egPID->isEM(mask, pid, found)==0);
} 

isSofte()

bool egamma::isSofte	(	unsigned int	mask = egammaPIDObs::ALL,
		bool *	found = nullptr ) const

uses special softe cuts

Definition at line 673 of file egamma.cxx.

{ 
  //
  // boolean method to define if egamma object is identified 
  // by cut-based selection optimized for non-isolated objects
  //
 
  return (m_egPID->isEMsofte(mask, found)==0);
} 

kind()

virtual I4Momentum::Kind ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::kind ( ) const

virtualinherited

add Kind which tells what kind (P4XYZ) the underlying implementation has

Implements I4Momentum.

m()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::m ( void ) const

virtualinherited

mass

Implements I4Momentum.

m2()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::m2 ( ) const

virtualinherited

mass squared

Implements I4Momentum.

momentumBase() [1/2]

momentum_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::momentumBase ( )

inherited

access to underlying base type (I4Momentum-like)

momentumBase() [2/2]

const momentum_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::momentumBase ( ) const

inherited

access to underlying base type (I4Momentum-like)

navigableBase() [1/2]

navigable_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::navigableBase ( )

inherited

access to underlying base type (INavigable-like)

navigableBase() [2/2]

const navigable_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::navigableBase ( ) const

inherited

access to underlying base type (INavigable-like)

nConversions()

unsigned int egamma::nConversions

(

)

const

Definition at line 419 of file egamma.cxx.

{
  return m_conversion.size();
}

nDetails()

int egamma::nDetails

(

)

const

number of details in egamma object

Definition at line 883 of file egamma.cxx.

{
  return m_egDetails.size();
}

newVersion()

void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::newVersion ( )

virtualinherited

Reimplemented from IAthenaBarCode.

nTrackParticles()

unsigned int egamma::nTrackParticles

(

)

const

Definition at line 403 of file egamma.cxx.

{
  return m_trackParticle.size();
}

operator=() [1/2]

egamma & egamma::operator=

(

const egamma &

rhs

)

Definition at line 79 of file egamma.cxx.

{
  if (this != &rhs) {
    IAthenaBarCode::operator=(rhs);
    INavigable::operator=(rhs);
    I4Momentum::operator=(rhs);
    INavigable4Momentum::operator=(rhs);
    egammaImpl_t::operator=(rhs);
    m_author        = rhs.m_author; 
    m_cluster       = rhs.m_cluster;
    m_trackParticle = rhs.m_trackParticle;
    m_conversion    = rhs.m_conversion;
    m_egPID         = std::make_unique<egPID>(*(rhs.m_egPID));
    m_egDetails     = rhs.m_egDetails;
    m_momentumCluster = rhs.m_momentumCluster; // ??? 
    m_rings = rhs.m_rings;
  }
  return *this;
}

operator=() [2/2]

egamma & egamma::operator= ( egamma && rhs )

default

origin()

virtual const Trk::RecVertex * ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::origin ( ) const

virtualinherited

Return a RecVertex corresponding to particle Origin.

Implements IParticle.

originLink()

virtual const ElementLink< VxContainer > & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::originLink ( ) const

virtualinherited

Return an ElementLink corresponding to particle's Origin.

Implements IParticle.

p()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::p ( ) const

virtualinherited

mass momentum magnitude

Implements I4Momentum.

p2()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::p2 ( ) const

virtualinherited

square of momentum magnitude

Implements I4Momentum.

particleBase() [1/2]

particle_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::particleBase ( )

inherited

access to underlying base type (IParticle-like)

particleBase() [2/2]

const particle_type & ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::particleBase ( ) const

inherited

access to underlying base type (IParticle-like)

passID()

bool egamma::passID

(

egammaPIDObs::egammaIDQuality

id

)

const

does electron/photon pass the given quality

Definition at line 684 of file egamma.cxx.

{ 
  //
  // boolean method to define if egamma object is identified 
  // by standard cut-based selection
  //
 
  switch(id) {
  case egammaPIDObs::ElectronIDLoose:
    return isElectron(egammaPIDObs::ElectronLoose, egammaPIDObs::IsEM);
  case egammaPIDObs::ElectronIDMedium:
    return isElectron(egammaPIDObs::ElectronMedium, egammaPIDObs::IsEM);
  case egammaPIDObs::ElectronIDTight:
    return isElectron(egammaPIDObs::ElectronTight, egammaPIDObs::IsEM);
 
  case egammaPIDObs::ElectronIDLoosePP:
    return isElectron(egammaPIDObs::ElectronLoosePP, egammaPIDObs::IsEMLoose);
  case egammaPIDObs::ElectronIDMediumPP:
    return isElectron(egammaPIDObs::ElectronMediumPP, egammaPIDObs::IsEMMedium);
  case egammaPIDObs::ElectronIDTightPP:
    return isElectron(egammaPIDObs::ElectronTightPP, egammaPIDObs::IsEMTight);
 
  case egammaPIDObs::PhotonIDLoose:
    return isPhoton(egammaPIDObs::PhotonLoose, egammaPIDObs::IsEM);
  case egammaPIDObs::PhotonIDMedium:
    return isPhoton(egammaPIDObs::PhotonMedium, egammaPIDObs::IsEMMedium);
  case egammaPIDObs::PhotonIDTight:
    return isPhoton(egammaPIDObs::PhotonTight, egammaPIDObs::IsEM);
 
  case egammaPIDObs::PhotonIDLooseAR:
    return isPhoton(egammaPIDObs::PhotonLooseAR, egammaPIDObs::IsEM);
  case egammaPIDObs::PhotonIDMediumAR:
    return isPhoton(egammaPIDObs::PhotonMediumAR, egammaPIDObs::IsEMMedium);
  case egammaPIDObs::PhotonIDTightAR:
    return isPhoton(egammaPIDObs::PhotonTightAR, egammaPIDObs::IsEM);
 
   case egammaPIDObs::ElectronIDLooseIso:
     return isElectron(egammaPIDObs::ElectronLooseIso, egammaPIDObs::IsEM);
  case egammaPIDObs::ElectronIDMediumIso:
    return isElectron(egammaPIDObs::ElectronMediumIso, egammaPIDObs::IsEM);
  case egammaPIDObs::ElectronIDTightIso:
    return isElectron(egammaPIDObs::ElectronTightIso, egammaPIDObs::IsEM);
 
  case egammaPIDObs::ElectronIDLoosePPIso:
    return isElectron(egammaPIDObs::ElectronLooseIso, egammaPIDObs::IsEMLoose);
  case egammaPIDObs::ElectronIDMediumPPIso:
    return isElectron(egammaPIDObs::ElectronMediumPPIso, egammaPIDObs::IsEMMedium);
  case egammaPIDObs::ElectronIDTightPPIso:
    return isElectron(egammaPIDObs::ElectronTightPPIso, egammaPIDObs::IsEMTight);
 
  case egammaPIDObs::PhotonIDLooseIso:
    return isPhoton(egammaPIDObs::PhotonLooseIso, egammaPIDObs::IsEM);
  case egammaPIDObs::PhotonIDTightIso:
    return isPhoton(egammaPIDObs::PhotonTightIso, egammaPIDObs::IsEM);
  case egammaPIDObs::PhotonIDLooseARIso:
    return isPhoton(egammaPIDObs::PhotonLooseARIso, egammaPIDObs::IsEM);
  case egammaPIDObs::PhotonIDTightARIso:
    return isPhoton(egammaPIDObs::PhotonTightARIso, egammaPIDObs::IsEM);
 
  case egammaPIDObs::frwdElectronIDLoose:
    return isElectron(egammaPIDObs::frwdElectronLoose, egammaPIDObs::IsEM);
  case egammaPIDObs::frwdElectronIDTight:
    return isElectron(egammaPIDObs::frwdElectronTight, egammaPIDObs::IsEM);
 
  case egammaPIDObs::NoIDCut:
    return true;
 
  default:
    return false;
  }
} 

pdgId()

virtual int ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::pdgId ( ) const

virtualinherited

Return enum indicating particle id the enum file is available in Event/EventKernel/PdtPdg.h.

Implements IParticle.

phi()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::phi ( void ) const

virtualinherited

phi in [-pi,pi[

Implements I4Momentum.

pid()

const egPID * egamma::pid

(

)

const

Definition at line 640 of file egamma.cxx.

{ 
  return m_egPID.get(); 
}

print()

void egamma::print

(

)

const

print method

Definition at line 104 of file egamma.cxx.

{
  // loop over egDetails and print later.
}

pt()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::pt ( void ) const

virtualinherited

transverse momentum

Implements I4Momentum.

px()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::px ( ) const

virtualinherited

x component of momentum

I4Momentum interface forwarding

Implements I4Momentum.

py()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::py ( ) const

virtualinherited

y component of momentum

Implements I4Momentum.

pz()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::pz ( ) const

virtualinherited

z component of momentum

Implements I4Momentum.

rapidity()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::rapidity ( ) const

virtualinherited

rapidity

Implements I4Momentum.

resetAuthor()

void egamma::resetAuthor ( )

inline

set_egamma ID

Definition at line 251 of file egamma.h.

{m_author = 0; }

resetCluster()

void egamma::resetCluster

(

)

Reset Cluster.

Definition at line 497 of file egamma.cxx.

{
  m_cluster.reset();
}

resetConversion()

void egamma::resetConversion

(

unsigned int

index = 0

)

Reset Conversion.

Definition at line 561 of file egamma.cxx.

{
  if(index < m_conversion.size()){
    (m_conversion.at(index)).reset();
  }
}

resetRings()

void egamma::resetRings

(

)

Reset Cluster.

Definition at line 477 of file egamma.cxx.

{
  m_rings.reset();
}

resetTrackParticle()

void egamma::resetTrackParticle

(

unsigned int

index = 0

)

Reset Track Particle.

Definition at line 516 of file egamma.cxx.

{
  if(index < m_trackParticle.size()){
    (m_trackParticle.at(index)).reset();
  }
}

rings()

const CaloRings * egamma::rings

(

)

const

pointer to CaloRings

Definition at line 368 of file egamma.cxx.

{ 
  //
  // methods to access RingerRings
  //
 
  return (m_rings.isValid()) ? *m_rings : nullptr;
}

ringsElementLink()

const ElementLink< CaloRingsContainer > & egamma::ringsElementLink

(

)

const

element link to rings

Definition at line 377 of file egamma.cxx.

{ 
  //
  // methods to access RingerRings ElementLink
  //
  return m_rings;
}

set4Mom() [1/3]

void egamma::set4Mom ( const CLHEP::HepLorentzVector & theHlv )

inlinevirtual

set all 4-mom from a CLHEP HepLorentzVector

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 391 of file egamma.h.

{ this->momentumBase().set4Mom (hlv); }

set4Mom() [2/3]

void egamma::set4Mom ( const I4Momentum & theI4Mom )

inlinevirtual

set all 4-mom from another I4Momentum reference

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 379 of file egamma.h.

{ this->momentumBase().set4Mom (mom); }

set4Mom() [3/3]

void egamma::set4Mom ( const I4Momentum *const theI4Mom )

inlinevirtual

set all 4-mom from another I4Momentum pointer

Reimplemented from ParticleImpl< egammaNavigation, P4ImplEEtaPhiM >.

Definition at line 385 of file egamma.h.

{ this->momentumBase().set4Mom (mom); }

set_charge()

virtual void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_charge ( ChargeType x )

virtualinherited

set_dataType()

virtual void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_dataType ( ParticleDataType::DataType x )

virtualinherited

set_egammaID()

bool egamma::set_egammaID	(	egammaPIDObs::PID	id,
		double	result )

set_egamma ID, for doubles and all possible weights as likelihood

Definition at line 327 of file egamma.cxx.

{
  //
  // method to set the PID
  // set as double to work for IsEM but also for all weights as likelihood
  //
 
  return m_egPID->set_egammaID(idflag,result); 
}

set_egammaIDint()

bool egamma::set_egammaIDint	(	egammaPIDObs::PID	id,
		unsigned int	result )

set_egamma ID, for usigned int values

Definition at line 338 of file egamma.cxx.

{
  //
  // method to set the PID for ints directly
  //
 
  return m_egPID->set_egammaIDint(idflag,result); 
}

set_origin() [1/3]

void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_origin ( const ElementLink< VxContainer > & origin )

inherited

set_origin() [2/3]

virtual void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_origin ( const VxContainer * theContainer, const Trk::VxCandidate * vertex )

virtualinherited

set_origin() [3/3]

virtual void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_origin ( const VxContainer * theContainer, int index )

virtualinherited

set_pdgId()

virtual void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::set_pdgId ( int x )

virtualinherited

setAthenaBarCode()

void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::setAthenaBarCode ( AthenaBarCode_t )

virtualinherited

Reimplemented from IAthenaBarCode.

setCluster() [1/2]

void egamma::setCluster	(	const CaloClusterContainer *	pCont,
		const CaloCluster *	cluster )

Set cluster.

Definition at line 503 of file egamma.cxx.

{ 
  m_cluster.toContainedElement(*pCont, cluster); 
}

setCluster() [2/2]

void egamma::setCluster	(	const CaloClusterContainer *	pCont,
		int	index )

Set cluster.

Definition at line 465 of file egamma.cxx.

{ 
  m_cluster.toIndexedElement( *pCont, index);
} 

setClusterElementLink()

void egamma::setClusterElementLink

(

const ElementLink< CaloClusterContainer > &

link

)

Set Cluster Element Link.

Definition at line 510 of file egamma.cxx.

{ 
  m_cluster = link;
}

setConversion() [1/2]

void egamma::setConversion	(	const VxContainer *	pCont,
		const Trk::VxCandidate *	conv )

Set Conversion.

Definition at line 577 of file egamma.cxx.

{ 
  ElementLink<VxContainer> link;
  link.toContainedElement(*pCont, conv);
  m_conversion.push_back(link); 
}

setConversion() [2/2]

void egamma::setConversion	(	const VxContainer *	pCont,
		int	index )

Set Conversion.

Definition at line 569 of file egamma.cxx.

{ 
  ElementLink<VxContainer> link;
  link.toIndexedElement(*pCont, index);
  m_conversion.push_back(link); 
}

setConversionElementLink()

void egamma::setConversionElementLink

(

const ElementLink< VxContainer > &

link

)

Set Conversion.

Definition at line 586 of file egamma.cxx.

{ 
  m_conversion.push_back(link);
}

setConversionElementLinkVector() [1/2]

void egamma::setConversionElementLinkVector

(

const ElementLinkVector< VxContainer > &

link

)

Definition at line 593 of file egamma.cxx.

{ 
  m_conversion = v;
}

setConversionElementLinkVector() [2/2]

void egamma::setConversionElementLinkVector

(

ElementLinkVector< VxContainer > &&

link

)

Definition at line 600 of file egamma.cxx.

{ 
  m_conversion = std::move(v);
}

setDetail()

void egamma::setDetail	(	const egDetailContainer *	cont,
		const egDetail *	ptr )

set detail

Definition at line 607 of file egamma.cxx.

{ 
  ElementLink<egDetailContainer> link;
  link.toContainedElement( *cont, ptr);
  m_egDetails.push_back( link );
} 

setDetailElementLink()

void egamma::setDetailElementLink

(

const ElementLink< egDetailContainer > &

link

)

set detailElementLink

Definition at line 617 of file egamma.cxx.

{ 
  m_egDetails.push_back( link );
} 

setDetailElementLinkVector() [1/2]

void egamma::setDetailElementLinkVector

(

const ElementLinkVector< egDetailContainer > &

v

)

Definition at line 625 of file egamma.cxx.

{ 
  m_egDetails = v;
} 

setDetailElementLinkVector() [2/2]

void egamma::setDetailElementLinkVector

(

ElementLinkVector< egDetailContainer > &&

v

)

Definition at line 633 of file egamma.cxx.

{ 
  m_egDetails = std::move(v);
} 

setE()

void egamma::setE ( double theE )

inline

set energy data member

Definition at line 355 of file egamma.h.

{ this->momentumBase().setE (ene); }

setErrorMatrix()

void egamma::setErrorMatrix

(

Amg::MatrixX

thematrix

)

Definition at line 962 of file egamma.cxx.

{
  const unsigned int Nrows =thematrix.rows();
  CLHEP::HepSymMatrix thematrixCLHEP(Nrows,0);
  
  for (unsigned int i=0; i<Nrows;++i) {
    for (unsigned int j=0; j<Nrows;++j){
      thematrixCLHEP[i][j]= thematrix(i,j);
    }
  }
  this->momentumBase().setErrors(thematrixCLHEP);   
}

setEta()

void egamma::setEta ( double theEta )

inline

set eta data member

Definition at line 361 of file egamma.h.

{ this->momentumBase().setEta (eta); }

setM()

void egamma::setM ( double theM )

inline

set mass data member

Definition at line 373 of file egamma.h.

{ this->momentumBase().setM (m); }

setPhi()

void egamma::setPhi ( double thePhi )

inline

set phi data member

Definition at line 367 of file egamma.h.

{ this->momentumBase().setPhi (phi); }

setRings() [1/2]

void egamma::setRings	(	const CaloRingsContainer *	pCont,
		const CaloRings *	cluster )

Set rings object.

Definition at line 483 of file egamma.cxx.

{ 
  m_rings.toContainedElement(*pCont, cluster); 
}

setRings() [2/2]

void egamma::setRings	(	const CaloRingsContainer *	pCont,
		int	index )

Set rings object.

Definition at line 471 of file egamma.cxx.

{ 
  m_rings.toIndexedElement( *pCont, index);
} 

setRingsElementLink()

void egamma::setRingsElementLink

(

const ElementLink< CaloRingsContainer > &

link

)

Set Rings Element Link.

Definition at line 490 of file egamma.cxx.

{ 
  m_rings = link;
}

setTrackParticle() [1/2]

void egamma::setTrackParticle	(	const Rec::TrackParticleContainer *	pCont,
		const Rec::TrackParticle *	track )

Set Track Particle.

Definition at line 532 of file egamma.cxx.

{ 
  ElementLink<Rec::TrackParticleContainer> link;
  link.toContainedElement(*pCont, track);
  m_trackParticle.push_back(link); 
}

setTrackParticle() [2/2]

void egamma::setTrackParticle	(	const Rec::TrackParticleContainer *	pCont,
		int	index )

Set Track Particle.

Definition at line 524 of file egamma.cxx.

{ 
  ElementLink<Rec::TrackParticleContainer> link;
  link.toIndexedElement(*pCont, index);
  m_trackParticle.push_back(link); 
}

setTrackParticleElementLink()

void egamma::setTrackParticleElementLink

(

const ElementLink< Rec::TrackParticleContainer > &

link

)

Set Track Particle Link.

Definition at line 541 of file egamma.cxx.

{ 
  m_trackParticle.push_back(link);
}

setTrackParticleElementLinkVector() [1/2]

void egamma::setTrackParticleElementLinkVector

(

const ElementLinkVector< Rec::TrackParticleContainer > &

v

)

Definition at line 548 of file egamma.cxx.

{ 
  m_trackParticle = v;
}

setTrackParticleElementLinkVector() [2/2]

void egamma::setTrackParticleElementLinkVector

(

ElementLinkVector< Rec::TrackParticleContainer > &&

v

)

Definition at line 555 of file egamma.cxx.

{ 
  m_trackParticle = std::move(v);
}

setUncombined4Mom() [1/3]

void egamma::setUncombined4Mom

(

const CLHEP::HepLorentzVector &

theHlv

)

set uncombined all 4-mom from a CLHEP HepLorentzVector

set combined all 4-mom from a CLHEP::HepLorentzVector

Definition at line 951 of file egamma.cxx.

{ m_momentumCluster.set4Mom (hlv); }

setUncombined4Mom() [2/3]

void egamma::setUncombined4Mom

(

const I4Momentum &

theI4Mom

)

set uncombined all 4-mom from another I4Momentum reference

set combined all 4-mom from another I4Momentum reference

Definition at line 939 of file egamma.cxx.

{ m_momentumCluster.set4Mom (mom); }

setUncombined4Mom() [3/3]

void egamma::setUncombined4Mom

(

const I4Momentum *const

theI4Mom

)

set uncombined all 4-mom from another I4Momentum pointer

set combined all 4-mom from another I4Momentum pointer

Definition at line 945 of file egamma.cxx.

{ m_momentumCluster.set4Mom (mom); }

setUncombinedE()

void egamma::setUncombinedE

(

double

theE

)

set uncombined energy data member

set combined energy data member

Definition at line 915 of file egamma.cxx.

{ m_momentumCluster.setE (ene); }

setUncombinedErrorMatrix()

void egamma::setUncombinedErrorMatrix

(

Amg::MatrixX

thematrix

)

Definition at line 976 of file egamma.cxx.

{
  //This should be symmetrix in any case
  const unsigned int Nrows =thematrix.rows();
  CLHEP::HepSymMatrix thematrixCLHEP(Nrows,0);
  
for (unsigned int i=0; i<Nrows;++i) {
    for (unsigned int j=0; j<Nrows;++j){
      thematrixCLHEP[i][j]= thematrix(i,j);
    }
  }
  m_momentumCluster.setErrors(thematrixCLHEP);  
}

setUncombinedEta()

void egamma::setUncombinedEta

(

double

theEta

)

set uncombined eta data member

set combined eta data member

Definition at line 921 of file egamma.cxx.

{ m_momentumCluster.setEta (eta); }

setUncombinedM()

void egamma::setUncombinedM

(

double

theM

)

set uncombined mass data member

set combined mass data member

Definition at line 933 of file egamma.cxx.

{ m_momentumCluster.setM (m); }

setUncombinedPhi()

void egamma::setUncombinedPhi

(

double

thePhi

)

set uncombined phi data member

set combined phi data member

Definition at line 927 of file egamma.cxx.

{ m_momentumCluster.setPhi (phi); }

setVersion()

void ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::setVersion ( AthenaBarCodeVersion_t newversion )

virtualinherited

Reimplemented from IAthenaBarCode.

sinPhi()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::sinPhi ( ) const

virtualinherited

sinus phi

Implements I4Momentum.

sinTh()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::sinTh ( ) const

virtualinherited

sinus theta

Implements I4Momentum.

tanTh()

virtual double ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::tanTh ( ) const

virtualinherited

tan theta

Implements I4Momentum.

trackParticle()

const Rec::TrackParticle * egamma::trackParticle

(

unsigned int

index = 0

)

const

pointer to TrackParticle

Definition at line 389 of file egamma.cxx.

{ 
  //
  // method to acces the track object
  //
 
  if(index < m_trackParticle.size()){
    return ((m_trackParticle.at(index)).isValid()) ? *(m_trackParticle.at(index)) : nullptr;
  }
    return nullptr;
  
}   

trackParticleElementLink()

ElementLink< Rec::TrackParticleContainer > egamma::trackParticleElementLink

(

unsigned int

index = 0

)

const

element link to trackParticle

Definition at line 431 of file egamma.cxx.

{ 
  if(index < m_trackParticle.size()){
    return m_trackParticle.at(index);
  }
    return {};
  
}

trackParticleElementLinkVector()

const ElementLinkVector< Rec::TrackParticleContainer > & egamma::trackParticleElementLinkVector

(

)

const

Definition at line 442 of file egamma.cxx.

{ 
  return m_trackParticle;
}

Member Data Documentation

m_author

unsigned int egamma::m_author

private

Definition at line 306 of file egamma.h.

m_cluster

ElementLink<CaloClusterContainer> egamma::m_cluster

private

Definition at line 300 of file egamma.h.

m_conversion

ElementLinkVector<VxContainer> egamma::m_conversion

private

Definition at line 302 of file egamma.h.

m_egDetails

ElementLinkVector<egDetailContainer> egamma::m_egDetails

private

Definition at line 303 of file egamma.h.

m_egPID

std::unique_ptr<egPID> egamma::m_egPID

private

Definition at line 308 of file egamma.h.

m_mom

P4ImplEEtaPhiM ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::m_mom

privateinherited

The 4-momentum part.

Definition at line 310 of file ParticleImpl.h.

m_momentumCluster

momentum_type egamma::m_momentumCluster

protected

Definition at line 314 of file egamma.h.

m_nav

egammaNavigation ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::m_nav

privateinherited

The navigable part.

Definition at line 307 of file ParticleImpl.h.

m_part

ParticleEvent::Base ParticleImpl< egammaNavigation, P4ImplEEtaPhiM, ParticleEvent::Base >::m_part

privateinherited

The particle-id part.

Definition at line 313 of file ParticleImpl.h.

m_rings

ElementLink<CaloRingsContainer> egamma::m_rings

private

Definition at line 304 of file egamma.h.

m_trackParticle

ElementLinkVector<Rec::TrackParticleContainer> egamma::m_trackParticle

private

Definition at line 301 of file egamma.h.

UNDEFINEDBARCODE

const AthenaBarCode_t IAthenaBarCode::UNDEFINEDBARCODE = (AthenaBarCode_t)(-1)

staticinherited

Definition at line 52 of file AthenaKernel/AthenaKernel/IAthenaBarCode.h.

UNDEFINEDVERSION

const AthenaBarCode_t IAthenaBarCode::UNDEFINEDVERSION = UNDEFINEDBARCODE

staticinherited

Definition at line 53 of file AthenaKernel/AthenaKernel/IAthenaBarCode.h.

---

The documentation for this class was generated from the following files:

• egamma.h
• egamma.cxx