xAOD::EgammaHelpers Namespace Reference

Functions
template<class T >
const T *	getLink (const xAOD::IParticle *particle, std::string name)
	Access to element link to object of type T stored in auxdata. More...
const xAOD::Electron *	getRecoElectron (const xAOD::TruthParticle *)
	return the reco electron associated to the given TruthParticle (if any) More...
const xAOD::Photon *	getRecoPhoton (const xAOD::TruthParticle *particle)
	return the reco photon associated to the given TruthParticle (if any) More...
bool	isTrueConvertedPhoton (const xAOD::Photon *ph, float maxRadius=800.)
	is the object matched to a true converted photon with R < maxRadius More...
bool	isTrueConvertedPhoton (const xAOD::TruthParticle *truePh, float maxRadius=800.)
	is the true object a converted photon with R < maxRadius More...
const xAOD::TruthParticle *	getBkgElectronMother (const xAOD::Electron *el, const bool allTheWayBack=true)
	Helper wrapper function for calling the function below that accepts truth input. More...
const xAOD::TruthParticle *	getBkgElectronMother (const xAOD::TruthParticle *truthel, const bool allTheWayBack=true)
	Helper function for getting the True "Mother" electron for an existing electron. More...
std::vector< const xAOD::TruthParticle * >	getBkgElectronLineage (const xAOD::Electron *el, const bool allTheWayBack=true)
	Helper wrapper function for calling the function below that accepts truth input. More...
std::vector< const xAOD::TruthParticle * >	getBkgElectronLineage (const xAOD::TruthParticle *truthel, const bool allTheWayBack=true)
	Helper function for getting the True Lineage of an electron for an existing electron. More...
bool	isElectron (const xAOD::Egamma *eg)
	is the object an electron (not Fwd) More...
bool	isFwdElectron (const xAOD::Egamma *eg)
	is the object a Fwd electron More...
bool	isPhoton (const xAOD::Egamma *eg)
	is the object a photon More...
bool	isConvertedPhoton (const xAOD::Egamma *eg)
	is the object a converted photon More...
bool	isBarrel (const xAOD::Egamma *eg)
	return true if the cluster is in the barrel More...
bool	isBarrel (const xAOD::CaloCluster *cluster)
	return true if the cluster (or the majority of its energy) is in the barrel More...
bool	isFCAL (const xAOD::CaloCluster *cluster)
	return true if the cluster (or the majority of its energy) is in the FCAL0 More...
std::vector< ElementLink< xAOD::CaloClusterContainer > >	getAssociatedTopoClustersLinks (const xAOD::CaloCluster *cluster)
	Return a vector of all the elementlinks to the topo clusters associated with the egamma cluster. More...
std::vector< const xAOD::CaloCluster * >	getAssociatedTopoClusters (const xAOD::CaloCluster *cluster)
	Return a vector of all the topo clusters associated with the egamma cluster. More...
std::vector< ElementLink< xAOD::FlowElementContainer > >	getAssociatedFlowElementsLinks (const xAOD::Egamma *eg, bool neutral=true)
	Return a vector of the elementlinks to the flow elements associated with the egamma cluster (neutral for default) More...
std::vector< const xAOD::FlowElement * >	getAssociatedFlowElements (const xAOD::Egamma *eg, bool neutral=true, bool charged=false)
	Return a vector of the flow elements associated with the egamma cluster (only neutral for default) More...
std::set< const xAOD::TrackParticle * >	getTrackParticles (const xAOD::Egamma *eg, bool useBremAssoc=true, bool allParticles=true)
	Return a list of all or only the best TrackParticle associated to the object. More...
std::vector< const xAOD::TrackParticle * >	getTrackParticlesVec (const xAOD::Egamma *eg, bool useBremAssoc=true, bool allParticles=true)
	Return a list of all or only the best TrackParticle associated to the object. More...
int	summaryValueInt (const xAOD::TrackParticle &tp, const xAOD::SummaryType &info, int deflt=-999)
	return the summary value for a TrackParticle or default value (-999) (to be used mostly in python where uint8_t is converted to char and the Tracking does not provide unprotected methods) More...
float	summaryValueFloat (const xAOD::TrackParticle &tp, const xAOD::SummaryType &info, float deflt=-999.)
	return the summary value for a TrackParticle or default value (-999) More...
const xAOD::TrackParticle *	getOriginalTrackParticle (const xAOD::Electron *el)
	Helper function for getting the "Original" Track Particle (i.e before GSF) via the electron. More...
const xAOD::TrackParticle *	getOriginalTrackParticleFromGSF (const xAOD::TrackParticle *trkPar)
	Helper function for getting the "Original" Track Particle (i.e before GSF) via the GSF Track Particle. More...
float	getLastMeasurementQoverP (const xAOD::TrackParticle *tp)
	return parameters for the last measurement for a GSF track particle More...
std::set< const xAOD::TrackParticle * >	getTrackParticles (const xAOD::Electron *el, bool useBremAssoc=true, bool allParticles=true)
	Return a list of all or only the best TrackParticle associated to the object. More...
std::vector< const xAOD::TrackParticle * >	getTrackParticlesVec (const xAOD::Electron *el, bool useBremAssoc=true, bool allParticles=true)
	Return a list of all or only the best TrackParticle associated to the object. More...
std::size_t	numberOfSiHits (const xAOD::TrackParticle *tp)
	return the number of Si hits in the track particle More...
bool	isConvertedPhoton (const xAOD::Photon *ph)
	is the object a converted photon More...
xAOD::EgammaParameters::ConversionType	conversionType (const xAOD::Photon *ph)
	return the photon conversion type (see EgammaEnums) More...
xAOD::EgammaParameters::ConversionType	conversionType (const xAOD::Vertex *vx)
	return the photon conversion type (see EgammaEnums) More...
std::size_t	numberOfSiTracks (const xAOD::Photon *eg)
	return the number of Si tracks in the conversion More...
std::size_t	numberOfSiTracks (const xAOD::Vertex *vx)
	return the number of Si tracks in the conversion More...
std::size_t	numberOfSiTracks (const xAOD::EgammaParameters::ConversionType convType)
	return the number of Si tracks in the conversion More...
float	conversionRadius (const xAOD::Vertex *vx)
	return the conversion radius or 9999. More...
float	conversionRadius (const xAOD::Photon *ph)
	return the conversion radius or 9999. More...
Amg::Vector3D	momentumAtVertex (const xAOD::Photon *, bool debug=false)
	return the momentum at the vertex (which can be 0) More...
Amg::Vector3D	momentumAtVertex (const xAOD::Vertex &, bool debug=false)
	return the momentum at the vertex (which can be 0) More...
std::set< const xAOD::TrackParticle * >	getTrackParticles (const xAOD::Photon *ph, bool useBremAssoc=true)
	Return a list of all or only the best TrackParticle associated to the object. More...
std::vector< const xAOD::TrackParticle * >	getTrackParticlesVec (const xAOD::Photon *ph, bool useBremAssoc=true)
	Return a list of all or only the best TrackParticle associated to the object. More...

Function Documentation

conversionRadius() [1/2]

float xAOD::EgammaHelpers::conversionRadius

(

const xAOD::Photon *

ph

)

return the conversion radius or 9999.

Definition at line 74 of file PhotonxAODHelpers.cxx.

                                                             {
  if (!ph || !ph->vertex()) return 9999.;
  return conversionRadius(ph->vertex());
}

conversionRadius() [2/2]

float xAOD::EgammaHelpers::conversionRadius

(

const xAOD::Vertex *

vx

)

return the conversion radius or 9999.

Definition at line 69 of file PhotonxAODHelpers.cxx.

                                                             {
  if (!vx) return 9999.;
  return sqrt( vx->x()*vx->x() + vx->y()*vx->y() );
}

conversionType() [1/2]

xAOD::EgammaParameters::ConversionType xAOD::EgammaHelpers::conversionType

(

const xAOD::Photon *

ph

)

return the photon conversion type (see EgammaEnums)

Definition at line 19 of file PhotonxAODHelpers.cxx.

                                                                                        {
  if (!ph) return xAOD::EgammaParameters::NumberOfVertexConversionTypes;
  return conversionType(ph->vertex());
}

conversionType() [2/2]

xAOD::EgammaParameters::ConversionType xAOD::EgammaHelpers::conversionType

(

const xAOD::Vertex *

vx

)

return the photon conversion type (see EgammaEnums)

Definition at line 24 of file PhotonxAODHelpers.cxx.

                                                                                        {
  if (!vx) return xAOD::EgammaParameters::unconverted;
 
  const TrackParticle *trk1 = ( vx->nTrackParticles() ? vx->trackParticle(0) : nullptr );
  const TrackParticle *trk2 = ( vx->nTrackParticles() > 1 ? vx->trackParticle(1) : nullptr );
  uint8_t nSiHits1 = numberOfSiHits(trk1);
  uint8_t nSiHits2 = numberOfSiHits(trk2);
 
  if (!trk1) {return xAOD::EgammaParameters::unconverted;}
 
  if (!trk2)
    {return nSiHits1 ? xAOD::EgammaParameters::singleSi : xAOD::EgammaParameters::singleTRT;}
  
  if (nSiHits1 && nSiHits2){
    return xAOD::EgammaParameters::doubleSi;
  }
  if (nSiHits1 || nSiHits2){
    return xAOD::EgammaParameters::doubleSiTRT;
  }  
  else{
    return xAOD::EgammaParameters::doubleTRT;
  }
}

getAssociatedFlowElements()

std::vector< const xAOD::FlowElement * > xAOD::EgammaHelpers::getAssociatedFlowElements	(	const xAOD::Egamma *	eg,
		bool	neutral = true,
		bool	charged = false
	)

Return a vector of the flow elements associated with the egamma cluster (only neutral for default)

Definition at line 93 of file EgammaxAODHelpers.cxx.

                                                                        {
  std::vector< const xAOD::FlowElement* > flowelements;
  if (!neutral && !charged)
    return flowelements;
  std::vector< ElementLink< xAOD::FlowElementContainer > > veclinks = xAOD::EgammaHelpers::getAssociatedFlowElementsLinks(eg,neutral);
  for (const auto& i : veclinks){
    if(i.isValid()){
      flowelements.push_back(*i);
    }
    else{
      flowelements.push_back(nullptr);
    }
  }
  if (neutral && charged) {
    std::vector< ElementLink< xAOD::FlowElementContainer > > oveclinks = xAOD::EgammaHelpers::getAssociatedFlowElementsLinks(eg,false);
    for (const auto& i : oveclinks){
      if(i.isValid()){
    flowelements.push_back(*i);
      }
      else{
    flowelements.push_back(nullptr);
      }
    }
  }
  return flowelements;
}

getAssociatedFlowElementsLinks()

std::vector< ElementLink< xAOD::FlowElementContainer > > xAOD::EgammaHelpers::getAssociatedFlowElementsLinks	(	const xAOD::Egamma *	eg,
		bool	neutral = true
	)

Return a vector of the elementlinks to the flow elements associated with the egamma cluster (neutral for default)

Definition at line 80 of file EgammaxAODHelpers.cxx.

                                                                      {
  static const SG::AuxElement::Accessor < std::vector< ElementLink< xAOD::FlowElementContainer > > > nflowElementLinks("neutralFELinks");
  static const SG::AuxElement::Accessor < std::vector< ElementLink< xAOD::FlowElementContainer > > > cflowElementLinks("chargedFELinks");
  std::vector< ElementLink< xAOD::FlowElementContainer > > veclinks;
  if(neutral && nflowElementLinks.isAvailable(*eg)){
    veclinks=nflowElementLinks(*eg);
  } else if(!neutral && cflowElementLinks.isAvailable(*eg)){
    veclinks=cflowElementLinks(*eg);
  }
  return veclinks;
}

getAssociatedTopoClusters()

std::vector< const xAOD::CaloCluster * > xAOD::EgammaHelpers::getAssociatedTopoClusters

(

const xAOD::CaloCluster *

cluster

)

Return a vector of all the topo clusters associated with the egamma cluster.

Definition at line 66 of file EgammaxAODHelpers.cxx.

                                                                                                            {
  std::vector< const xAOD::CaloCluster* > topoclusters;
  std::vector< ElementLink< xAOD::CaloClusterContainer > > veclinks = xAOD::EgammaHelpers::getAssociatedTopoClustersLinks(cluster);
  for (const auto& i : veclinks){
    if(i.isValid()){
      topoclusters.push_back(*i);
    }
    else{
      topoclusters.push_back(nullptr);
    }
  }
  return topoclusters;
}

getAssociatedTopoClustersLinks()

std::vector< ElementLink< xAOD::CaloClusterContainer > > xAOD::EgammaHelpers::getAssociatedTopoClustersLinks

(

const xAOD::CaloCluster *

cluster

)

Return a vector of all the elementlinks to the topo clusters associated with the egamma cluster.

Definition at line 56 of file EgammaxAODHelpers.cxx.

                                                                                                                                    {
 
  static const SG::AuxElement::Accessor < std::vector< ElementLink< xAOD::CaloClusterContainer > > > caloClusterLinks("constituentClusterLinks");
  std::vector< ElementLink< xAOD::CaloClusterContainer > > veclinks;
  if(caloClusterLinks.isAvailable(*cluster)){
    veclinks=caloClusterLinks(*cluster);
  }
  return veclinks;
}

getBkgElectronLineage() [1/2]

std::vector< const xAOD::TruthParticle * > xAOD::EgammaHelpers::getBkgElectronLineage	(	const xAOD::Electron *	el,
		const bool	allTheWayBack = true
	)

Helper wrapper function for calling the function below that accepts truth input.

Definition at line 110 of file EgammaTruthxAODHelpers.cxx.

                                                  {
  const xAOD::TruthParticle *truthel = xAOD::TruthHelpers::getTruthParticle(*el);
  return getBkgElectronLineage(truthel,allTheWayBack);
}

getBkgElectronLineage() [2/2]

std::vector< const xAOD::TruthParticle * > xAOD::EgammaHelpers::getBkgElectronLineage	(	const xAOD::TruthParticle *	truthel,
		const bool	allTheWayBack = true
	)

Helper function for getting the True Lineage of an electron for an existing electron.

There are cases when an electron has a photon (or electron) mother, that in turn comes from another particle (possible leading to a Z or W etc). This method will navigate back and will return all true electron and photons in the lineage. in case of complex topologies will return just the 1st electron or photon mother

The user can apply also a barcode cut. This is handy in cases when we want to find the first non geant particle occuring when going back the lineage. The method will stop after the 1st particle failing this cut

Definition at line 118 of file EgammaTruthxAODHelpers.cxx.

                                                  {
  std::vector<const xAOD::TruthParticle*> vec;
  //Truth must exist and be an electron
  if (!truthel || !MC::isElectron(truthel)){
    return vec;
  }
  vec.push_back(truthel); //push its self back as first entry
 
  // The first parent has to exist
  if (!truthel->nParents()) {
    return vec;
  }
 
  if (!HepMC::is_simulation_particle(truthel) && !allTheWayBack)  {
    return vec;
  }
  
  //And has to be a photon or electron
  const xAOD::TruthParticle* parent = truthel->parent();
  if ( !MC::isPhoton(parent) && !MC::isElectron(parent) ) {
    return vec;
  }
 
  vec.push_back(parent); //push in the parent as the second entry
 
  //Loop over the generations
  while (parent->nParents() &&
     (HepMC::is_simulation_particle(parent) || allTheWayBack)) {
    //Find the next parent
    const xAOD::TruthParticle* tmp = parent->parent();
    //You want to see an electron or a photon 
    if (MC::isPhoton(tmp) || MC::isElectron(tmp)) {
      parent=tmp;
    } else { // if we do not see any more electron and photons we stop
      break; 
    }
    vec.push_back(parent); //push in the parent
  }
  return vec;
}

getBkgElectronMother() [1/2]

const xAOD::TruthParticle * xAOD::EgammaHelpers::getBkgElectronMother	(	const xAOD::Electron *	el,
		const bool	allTheWayBack = true
	)

Helper wrapper function for calling the function below that accepts truth input.

It extract the truth from the reco electron and uses the function below

Definition at line 91 of file EgammaTruthxAODHelpers.cxx.

                                                { 
  const xAOD::TruthParticle *truthel =
    xAOD::TruthHelpers::getTruthParticle(*el);
  return getBkgElectronMother(truthel,allTheWayBack);
}

getBkgElectronMother() [2/2]

const xAOD::TruthParticle * xAOD::EgammaHelpers::getBkgElectronMother	(	const xAOD::TruthParticle *	truthel,
		const bool	allTheWayBack = true
	)

Helper function for getting the True "Mother" electron for an existing electron.

There are cases when an electron has a photon (or electron) mother, that in turn comes from another particle (possible leading to a Z or W etc). This method will navigate back up to the last electron or photon it can find in the lineage of the original true electron. Then the user just needs to check this electron/photon. If it fails returns null pointer.

The user can also get the first Geant4 particle cut. This is handy in cases when we want to find the first non geant particle occuring when going back the lineage. The method will stop after the 1st particle failing this cut

Definition at line 99 of file EgammaTruthxAODHelpers.cxx.

                                                 {
  std::vector<const xAOD::TruthParticle*>  vec =
    xAOD::EgammaHelpers::getBkgElectronLineage(truthel,allTheWayBack);
  if (!vec.empty()) { 
    return vec.back();
  }
  return nullptr;
}

getLastMeasurementQoverP()

float xAOD::EgammaHelpers::getLastMeasurementQoverP

(

const xAOD::TrackParticle *

tp

)

return parameters for the last measurement for a GSF track particle

Definition at line 31 of file ElectronxAODHelpers.cxx.

                                                                            {
  static const SG::AuxElement::Accessor<float > QoverPLM  ("QoverPLM");
  if(tp && QoverPLM.isAvailable(*tp)){
    return QoverPLM(*tp);
  }
  return -999 ; 
}

getLink()

template<class T >

const T* xAOD::EgammaHelpers::getLink	(	const xAOD::IParticle *	particle,
		std::string	name
	)

Access to element link to object of type T stored in auxdata.

Definition at line 27 of file EgammaTruthxAODHelpers.h.

                                                                   {
      if (!particle) return nullptr;
      typedef ElementLink< DataVector<T> > Link_t;
      
      if (!particle->isAvailable< Link_t >(name) ) { 
      return nullptr; 
    }  
      const Link_t link = particle->auxdata<Link_t>(name);
      if (!link.isValid()) { 
      return nullptr; 
    }
      return *link;
    }

getOriginalTrackParticle()

const xAOD::TrackParticle * xAOD::EgammaHelpers::getOriginalTrackParticle

(

const xAOD::Electron *

el

)

Helper function for getting the "Original" Track Particle (i.e before GSF) via the electron.

Definition at line 11 of file ElectronxAODHelpers.cxx.

                                                                                          {
  
  if(el){
    const xAOD::TrackParticle* trkPar= el->trackParticle();
    if(trkPar){
      return getOriginalTrackParticleFromGSF(trkPar);
    }
  }
  return nullptr;
}

getOriginalTrackParticleFromGSF()

const xAOD::TrackParticle * xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF

(

const xAOD::TrackParticle *

trkPar

)

Helper function for getting the "Original" Track Particle (i.e before GSF) via the GSF Track Particle.

Definition at line 22 of file ElectronxAODHelpers.cxx.

                                                                                                          {
  
  if(! trkPar) {return nullptr;}
  static const SG::AuxElement::Accessor<ElementLink<xAOD::TrackParticleContainer> > orig ("originalTrackParticle");
  if (!orig.isAvailable(*trkPar) || !orig(*trkPar).isValid()) {return nullptr;}
 
  return (*orig(*trkPar));
}

getRecoElectron()

const xAOD::Electron * xAOD::EgammaHelpers::getRecoElectron

(

const xAOD::TruthParticle *

particle

)

return the reco electron associated to the given TruthParticle (if any)

Definition at line 31 of file EgammaTruthxAODHelpers.cxx.

                                                                      {
 
   if( ! recoElectronLinkAcc.isAvailable( *particle ) ) {
      return nullptr;
   }
   const ElementLink< xAOD::ElectronContainer >& link =
      recoElectronLinkAcc( *particle );
   if( ! link.isValid() ) {
      return nullptr;
   }
   return *link;
}

getRecoPhoton()

const xAOD::Photon * xAOD::EgammaHelpers::getRecoPhoton

(

const xAOD::TruthParticle *

particle

)

return the reco photon associated to the given TruthParticle (if any)

Definition at line 54 of file EgammaTruthxAODHelpers.cxx.

                                                                    {
 
   if( ! recoPhotonLinkAcc.isAvailable( *particle ) ) {
      return nullptr;
   }
   const ElementLink< xAOD::PhotonContainer >& link =
      recoPhotonLinkAcc( *particle );
   if( ! link.isValid() ) {
      return nullptr;
   }
   return *link;
}

getTrackParticles() [1/3]

std::set< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticles	(	const xAOD::Egamma *	eg,
		bool	useBremAssoc = true,
		bool	allParticles = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This is useful when a std::set of the original track Particles is required, which is mainly the case for the as it will re-order the elements in pointer order and not best match.

Definition at line 121 of file EgammaxAODHelpers.cxx.

                                                              {
 
  if (eg) {
    if (eg->type()==xAOD::Type::Electron) {
      const xAOD::Electron* el = static_cast<const xAOD::Electron*> (eg);
      if (el) {
        return getTrackParticles(el, useBremAssoc, allParticles);
      }
    }
    else if (eg->type()==xAOD::Type::Photon) {
      const xAOD::Photon* ph = static_cast<const xAOD::Photon*> (eg);
      if (ph) {
        return getTrackParticles(ph, useBremAssoc);
      }
    }
  }
  return std::set<const xAOD::TrackParticle*>{};
}

getTrackParticles() [2/3]

std::set< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticles	(	const xAOD::Electron *	el,
		bool	useBremAssoc = true,
		bool	allParticles = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This is useful when a std::set of the original track Particles is required, which is mainly the case for the
as it will re-order the elements in pointer order and not best match.

Definition at line 39 of file ElectronxAODHelpers.cxx.

                                                              {
  std::set<const xAOD::TrackParticle*> tps;
  for (unsigned int i = 0; i < el->nTrackParticles(); ++i){
    const xAOD::TrackParticle* tp = el->trackParticle(i);
    if (useBremAssoc) tp = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp);
    if (tp) tps.insert( tp );
    if (!allParticles) break; // break after first particle
  }
  return tps;
}

getTrackParticles() [3/3]

std::set< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticles	(	const xAOD::Photon *	ph,
		bool	useBremAssoc = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This is useful when a std::set of the original track Particles is required, which is mainly the case for the
as it will re-order the elements in pointer order and not best match.

Definition at line 108 of file PhotonxAODHelpers.cxx.

                                                              {
 
  std::set<const xAOD::TrackParticle*> tps;
  if (!ph) return tps;
  for (unsigned int ivx = 0; ivx < ph->nVertices(); ++ivx)
  {
    const xAOD::Vertex* vx = ph->vertex(ivx);
    for (unsigned int i=0; vx && i < vx->nTrackParticles(); ++i){
      const xAOD::TrackParticle *tp = vx->trackParticle(i);
      tps.insert( useBremAssoc ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp) : tp );
    }
  }
  return tps;
}

getTrackParticlesVec() [1/3]

std::vector< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticlesVec	(	const xAOD::Egamma *	eg,
		bool	useBremAssoc = true,
		bool	allParticles = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This one returns a vector so as to be more "user friendly", as it retains the original best match ordering

Definition at line 142 of file EgammaxAODHelpers.cxx.

                                                                {
  if (eg) {
    if (eg->type()==xAOD::Type::Electron) {
      const xAOD::Electron* el = static_cast<const xAOD::Electron*> (eg);
      if (el) {
        return getTrackParticlesVec(el, useBremAssoc, allParticles);
      }
    }
    else if (eg->type()==xAOD::Type::Photon) {
      const xAOD::Photon* ph = static_cast<const xAOD::Photon*> (eg);
      if (ph) {
        return getTrackParticlesVec(ph, useBremAssoc);
      }
    }
  }
  return std::vector<const xAOD::TrackParticle*>{};
}

getTrackParticlesVec() [2/3]

std::vector< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticlesVec	(	const xAOD::Electron *	el,
		bool	useBremAssoc = true,
		bool	allParticles = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This one returns a vector so as to be more "user friendly",as it retains the original best match ordering

Definition at line 52 of file ElectronxAODHelpers.cxx.

                                                                {
 
  std::vector<const xAOD::TrackParticle*> tps;
  for (unsigned int i = 0; i < el->nTrackParticles(); ++i){
    const xAOD::TrackParticle* tp = el->trackParticle(i);
    if (useBremAssoc) {tp = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp);}
    if (tp) {tps.push_back( tp );}
    if (!allParticles) {break;} // break after first particle
  }
  return tps;
}

getTrackParticlesVec() [3/3]

std::vector< const xAOD::TrackParticle * > xAOD::EgammaHelpers::getTrackParticlesVec	(	const xAOD::Photon *	ph,
		bool	useBremAssoc = true
	)

Return a list of all or only the best TrackParticle associated to the object.

If useBremAssoc is set, get the original TrackParticle This one returns a vector so as to be more "user friendly",as it retains the original best match ordering

Definition at line 124 of file PhotonxAODHelpers.cxx.

                                                                {
  std::vector<const xAOD::TrackParticle*> tps;
  if (!ph) return tps;
  for (unsigned int ivx = 0; ivx < ph->nVertices(); ++ivx)
  {
    const xAOD::Vertex* vx = ph->vertex(ivx);
    for (unsigned int i=0; vx && i < vx->nTrackParticles(); ++i){
      const xAOD::TrackParticle *tp = vx->trackParticle(i);
      tps.push_back( useBremAssoc ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(tp) : tp );
    }
  }
  return tps;
}

isBarrel() [1/2]

bool xAOD::EgammaHelpers::isBarrel

(

const xAOD::CaloCluster *

cluster

)

return true if the cluster (or the majority of its energy) is in the barrel

Definition at line 38 of file EgammaxAODHelpers.cxx.

                                                              {
  const bool isBarrel = cluster->inBarrel();
  const bool isEndcap = cluster->inEndcap();
  if (isBarrel && isEndcap){
    return  cluster->eSample(CaloSampling::EMB2) >= cluster->eSample(CaloSampling::EME2);
  }
  return isBarrel;
}

isBarrel() [2/2]

bool xAOD::EgammaHelpers::isBarrel

(

const xAOD::Egamma *

eg

)

return true if the cluster is in the barrel

Definition at line 34 of file EgammaxAODHelpers.cxx.

                                                    {
  return (eg ? isBarrel(eg->caloCluster()) : false);
}

isConvertedPhoton() [1/2]

bool xAOD::EgammaHelpers::isConvertedPhoton

(

const xAOD::Egamma *

eg

)

is the object a converted photon

Definition at line 26 of file EgammaxAODHelpers.cxx.

                                                             {
  if (!eg || eg->type()!=xAOD::Type::Photon){
    return false;
  }
  const xAOD::Photon *ph = static_cast<const xAOD::Photon*>(eg);
  return (ph->nVertices()>0);
}

isConvertedPhoton() [2/2]

bool xAOD::EgammaHelpers::isConvertedPhoton

(

const xAOD::Photon *

ph

)

is the object a converted photon

Definition at line 15 of file PhotonxAODHelpers.cxx.

                                                             {
  return (ph && (ph->nVertices()>0) );
}

isElectron()

bool xAOD::EgammaHelpers::isElectron

(

const xAOD::Egamma *

eg

)

is the object an electron (not Fwd)

Definition at line 13 of file EgammaxAODHelpers.cxx.

                                                      {
  return ( (eg->type()==xAOD::Type::Electron) &&
       (!eg->author(xAOD::EgammaParameters::AuthorFwdElectron)));
}

isFCAL()

bool xAOD::EgammaHelpers::isFCAL

(

const xAOD::CaloCluster *

cluster

)

return true if the cluster (or the majority of its energy) is in the FCAL0

Definition at line 47 of file EgammaxAODHelpers.cxx.

                                                            {
  const bool hasEME2 = cluster->hasSampling(CaloSampling::EME2);
  const bool hasFCAL0 = cluster->hasSampling(CaloSampling::FCAL0);
  if (hasEME2 && hasFCAL0){
    return  cluster->eSample(CaloSampling::FCAL0) >= cluster->eSample(CaloSampling::EME2);
  }
  return hasFCAL0;
}

isFwdElectron()

bool xAOD::EgammaHelpers::isFwdElectron

(

const xAOD::Egamma *

eg

)

is the object a Fwd electron

Definition at line 18 of file EgammaxAODHelpers.cxx.

                                                         {
  return eg->author(xAOD::EgammaParameters::AuthorFwdElectron);
}

isPhoton()

bool xAOD::EgammaHelpers::isPhoton

(

const xAOD::Egamma *

eg

)

is the object a photon

Definition at line 22 of file EgammaxAODHelpers.cxx.

                                                    {
  return (eg->type()==xAOD::Type::Photon);
}

isTrueConvertedPhoton() [1/2]

bool xAOD::EgammaHelpers::isTrueConvertedPhoton	(	const xAOD::Photon *	ph,
		float	maxRadius = 800.
	)

is the object matched to a true converted photon with R < maxRadius

Definition at line 69 of file EgammaTruthxAODHelpers.cxx.

                                                                                    {
  const xAOD::TruthParticle *truthPh = xAOD::TruthHelpers::getTruthParticle(*ph);
  if (!truthPh) {return false;}
  // In older versions egammaTruthParticles did not have a decay vertex associated
  // so we look for the original truth particle
  if (truthPh->hasDecayVtx()){ 
    return isTrueConvertedPhoton(truthPh, maxRadius);
  }
  const xAOD::TruthParticle *orgTruthPh = xAOD::TruthHelpers::getTruthParticle(*truthPh);
  if (!orgTruthPh){ return false;}
  return xAOD::EgammaHelpers::isTrueConvertedPhoton(orgTruthPh, maxRadius);
}

isTrueConvertedPhoton() [2/2]

bool xAOD::EgammaHelpers::isTrueConvertedPhoton	(	const xAOD::TruthParticle *	truePh,
		float	maxRadius = 800.
	)

is the true object a converted photon with R < maxRadius

Definition at line 83 of file EgammaTruthxAODHelpers.cxx.

                                                                                                {
  return (MC::isPhoton(truthPh) && truthPh->hasDecayVtx()
      && truthPh->decayVtx()->perp() < maxRadius); 
}

momentumAtVertex() [1/2]

Amg::Vector3D xAOD::EgammaHelpers::momentumAtVertex	(	const xAOD::Photon *	photon,
		bool	debug = false
	)

return the momentum at the vertex (which can be 0)

Definition at line 81 of file PhotonxAODHelpers.cxx.

                                                                                   {
  if (!photon || !photon->vertex()) return Amg::Vector3D(0., 0., 0.);
  return momentumAtVertex(*photon->vertex(), debug);
}

momentumAtVertex() [2/2]

Amg::Vector3D xAOD::EgammaHelpers::momentumAtVertex	(	const xAOD::Vertex &	vertex,
		bool	debug = false
	)

return the momentum at the vertex (which can be 0)

Definition at line 87 of file PhotonxAODHelpers.cxx.

                                                                                   {  
 
  static const SG::AuxElement::Accessor<float> accPx("px");
  static const SG::AuxElement::Accessor<float> accPy("py");
  static const SG::AuxElement::Accessor<float> accPz("pz");
  
  if (accPx.isAvailable(vertex) && 
      accPy.isAvailable(vertex) && 
      accPz.isAvailable(vertex)) 
    {
      return Amg::Vector3D(accPx(vertex), 
               accPy(vertex),  
               accPz(vertex)); 
    }
  if (debug){
    std::cout << "Vertex not decorated with momentum" << std::endl;
  }
  return Amg::Vector3D(0., 0., 0.);
}

numberOfSiHits()

std::size_t xAOD::EgammaHelpers::numberOfSiHits

(

const xAOD::TrackParticle *

tp

)

return the number of Si hits in the track particle

Definition at line 66 of file ElectronxAODHelpers.cxx.

                                                                      {
  if (!tp) return 0;
  uint8_t dummy(0);
  uint8_t nSiHits(0);
  if (tp->summaryValue(dummy, xAOD::numberOfPixelHits)){
    nSiHits += dummy;
  }
  if (tp->summaryValue(dummy, xAOD::numberOfSCTHits)){
    nSiHits += dummy;
  }
  return nSiHits;
}  

numberOfSiTracks() [1/3]

std::size_t xAOD::EgammaHelpers::numberOfSiTracks

(

const xAOD::EgammaParameters::ConversionType

convType

)

return the number of Si tracks in the conversion

Definition at line 60 of file PhotonxAODHelpers.cxx.

                                                                                              {
  if (convType == xAOD::EgammaParameters::doubleSi) {return 2;}
  if (convType == xAOD::EgammaParameters::singleSi ||
      convType == xAOD::EgammaParameters::doubleSiTRT) {return 1;}
  return 0;
}

numberOfSiTracks() [2/3]

std::size_t xAOD::EgammaHelpers::numberOfSiTracks

(

const xAOD::Photon *

eg

)

return the number of Si tracks in the conversion

Definition at line 50 of file PhotonxAODHelpers.cxx.

                                                                 {
  if (!ph || !ph->vertex()) {return 0;}
  return numberOfSiTracks(ph->vertex());
}

numberOfSiTracks() [3/3]

std::size_t xAOD::EgammaHelpers::numberOfSiTracks

(

const xAOD::Vertex *

vx

)

return the number of Si tracks in the conversion

Definition at line 55 of file PhotonxAODHelpers.cxx.

                                                                 {
  if (!vx) return 0;
  return numberOfSiTracks(conversionType(vx));
}

summaryValueFloat()

float xAOD::EgammaHelpers::summaryValueFloat	(	const xAOD::TrackParticle &	tp,
		const xAOD::SummaryType &	info,
		float	deflt = -999.
	)

return the summary value for a TrackParticle or default value (-999)

Definition at line 169 of file EgammaxAODHelpers.cxx.

                                       {
  float dummy(0);
  return (tp.summaryValue(dummy, info) ? dummy : deflt);
}

summaryValueInt()

int xAOD::EgammaHelpers::summaryValueInt	(	const xAOD::TrackParticle &	tp,
		const xAOD::SummaryType &	info,
		int	deflt = -999
	)

return the summary value for a TrackParticle or default value (-999) (to be used mostly in python where uint8_t is converted to char and the Tracking does not provide unprotected methods)

Definition at line 162 of file EgammaxAODHelpers.cxx.

                                 {
  uint8_t dummy(0);
  return (tp.summaryValue(dummy, info) ? dummy : deflt);
}