xAOD::EgammaHelpers Namespace Reference

Functions
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...
std::vector< const xAOD::TruthParticle * >	getBkgElectronLineage (const xAOD::TruthParticle *truthel, const bool allTheWayBack=true)
	Helper function for getting the truth lineage of an electron that is arising from material interactions in simulation (so called Bkg Electron) There are cases when an electron has a photon (or electron) mother, that in turn comes from another electron of photon. More...
const xAOD::TruthParticle *	getBkgElectronMother (const xAOD::Electron *el, const bool allTheWayBack=true)
	Helper wrapper function for calling the function above extracting the truth from a reco electron. More...
const xAOD::TruthParticle *	getBkgElectronMother (const xAOD::TruthParticle *truthel, const bool allTheWayBack=true)
	Helper function for getting the "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...
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, bool excludeTRT=false)
	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...
unsigned short	energyInMissingCells (const xAOD::Egamma &eg, double &e2, double &e3)
	Get the energies in sampling 2 and 3 that are in cells rejected by the topo-cluster timing cut but that would have been expected in a egamma cluster. 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, bool excludeTRT=false)
	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 82 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 77 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 27 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 32 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;
  }
}

energyInMissingCells()

unsigned short xAOD::EgammaHelpers::energyInMissingCells	(	const xAOD::Egamma &	eg,
		double &	e2,
		double &	e3
	)

Get the energies in sampling 2 and 3 that are in cells rejected by the topo-cluster timing cut but that would have been expected in a egamma cluster.

Definition at line 176 of file EgammaxAODHelpers.cxx.

                                                                                {
 
  const static SG::AuxElement::ConstAccessor<float> acc_Eadded_s2("Eadded_Lr2");
  const static SG::AuxElement::ConstAccessor<float> acc_Eadded_s3("Eadded_Lr3");
 
  unsigned short status = 0;
  if (acc_Eadded_s2.isAvailable(eg))
    { e2 = acc_Eadded_s2(eg); }
  else
    { status += 1; }
  if (acc_Eadded_s3.isAvailable(eg))
    { e3 = acc_Eadded_s3(eg); }
  else
    { status += 2; }
  return status;
}

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 92 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 79 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 65 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 55 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 157 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 truth lineage of an electron that is arising from material interactions in simulation (so called Bkg Electron) There are cases when an electron has a photon (or electron) mother, that in turn comes from another electron of photon.

The allTheWayBack (default true) will return the full lineage of the electron going back to the earliest generator e/gamma truth particle available. When this is set to false we stop at the generator e/gamma particle that interacted with material in simulation (meaning we will not go at the beginning of the generator record). The 0th entry of the returned vector is the passed e/gamma particle, while the last is the last e/gamma particle we have seen in the lineage.

Definition at line 90 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 = nullptr;
  for (size_t p = 0; p < truthel->nParents(); ++p) {
    if ( !MC::isPhoton(truthel->parent(p)) && !MC::isElectron(truthel->parent(p)) )  return vec;
    parent = truthel->parent(p); //AV: note, here is an ambiguity for the case of multiple parents.
  }
 
  if (!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 = nullptr; 
    //You want to see an electron or a photon
    for (size_t p = 0; p < parent->nParents(); ++p) {
      if (MC::isPhoton(parent->parent(p)) || MC::isElectron(parent->parent(p))) tmp = parent->parent(p); //AV: note some ambiguity for multiple parents passing the selection
    }
    if (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 above extracting the truth from a reco electron.

Definition at line 137 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 "Mother" electron for an existing electron.

return the last entry in the lineage vector

Definition at line 145 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 ; 
}

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 120 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 116 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 141 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 132 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 37 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 33 of file EgammaxAODHelpers.cxx.

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

isConvertedPhoton() [1/2]

bool xAOD::EgammaHelpers::isConvertedPhoton	(	const xAOD::Egamma *	eg,
		bool	excludeTRT = false
	)

is the object a converted photon

Definition at line 25 of file EgammaxAODHelpers.cxx.

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

isConvertedPhoton() [2/2]

bool xAOD::EgammaHelpers::isConvertedPhoton	(	const xAOD::Photon *	ph,
		bool	excludeTRT = false
	)

is the object a converted photon

Definition at line 15 of file PhotonxAODHelpers.cxx.

                                                                               {
  const bool hasVertices = ph && (ph->nVertices() > 0);
  if (excludeTRT) {
    // special case for Run3: consider unconv if TRT Conv in the barrel
    using enum xAOD::EgammaParameters::ConversionType;
    const xAOD::EgammaParameters::ConversionType conversionType = xAOD::EgammaHelpers::conversionType(ph);
    const bool isTRTConv = (conversionType == singleTRT) || (conversionType == doubleTRT);
    return hasVertices && (std::abs(ph->eta()) > 0.8 || !isTRTConv); 
  }
  return hasVertices;
}

isElectron()

bool xAOD::EgammaHelpers::isElectron

(

const xAOD::Egamma *

eg

)

is the object an electron (not Fwd)

Definition at line 12 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 46 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 17 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 21 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 89 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 95 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 68 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 58 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 63 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 168 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 161 of file EgammaxAODHelpers.cxx.

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