MC Namespace Reference

Functions
template<class T >
bool	isInteracting (const T &p)
	Identify if the particle with given PDG ID would not interact with the detector, i.e. not a neutrino or WIMP. More...
template<class T >
bool	isChargedNonShowering (const T &p)
	Identify if the particle with given PDG ID would produce ID tracks but not shower in the detector if stable. More...
template<class T >
bool	isBeam (const T &p)
template<class T >
bool	isDecayed (const T &p)
template<class T >
bool	isStable (const T &p)
template<class T >
bool	isFinalState (const T &p)
template<class T >
bool	isPhysical (const T &p)
template<class T >
bool	isPhysicalHadron (const T &p)
template<class T >
bool	isGenStable (const T &p)
	Determine if the particle is stable at the generator (not det-sim) level,. More...
template<class T >
bool	isSimStable (const T &p)
	Identify if the particle is considered stable at the post-detector-sim stage. More...
template<class T >
bool	isSimInteracting (const T &p)
	Identify if the particle could interact with the detector during the simulation, e.g. not a neutrino or WIMP. More...
template<class T >
bool	isStableOrSimDecayed (const T &p)
	Identify if particle is satble or decayed in simulation. More...
template<class T >
bool	isZeroEnergyPhoton (const T &p)
	Identify a photon with zero energy. Probably a workaround for a generator bug. More...
template<class T >
bool	isSingleParticle (const T &p)
template<class T >
bool	isSpecialNonInteracting (const T &p)
template<class T >
T	getMother (T thePart)
	Function to get a mother of particle. MCTruthClassifier legacy. More...
template<class C , class T >
T	find_matching (C TruthTES, T bcin)
	Function to find a particle in container. More...
template<class T >
void	findAllJetMothers (T thePart, std::set< T > &allJetMothers)
	Function to find all ancestors of the particle. More...
template<class T >
void	findParticleDaughters (T thePart, std::set< T > &daughters)
	Function to get the particle stable MC daughters. More...
template<class T >
T	isHadronFromB (T p)
	Function to get the parent B hadron. More...
template<class T >
bool	isHardScatVrtx (T pVert)
	Function to classify the vertex as hard scattering vertex. More...
template<class T >
bool	fromHadron (T p, T hadptr, bool &fromTau, bool &fromBSM)
	Function to classify the particle. More...
template<class T >
auto	findEndVert (T thePart) -> decltype(thePart->end_vertex())
	Function to find the end vertex of a particle. More...
template<class V >
auto	findFinalStatePart (V EndVert) -> decltype(EndVert->particles_out())
	Function to find the stable particle descendants of the gived vertex.. More...

Function Documentation

find_matching()

template<class C , class T >

T MC::find_matching	(	C	TruthTES,
		T	bcin
	)

Function to find a particle in container.

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 103 of file HepMCHelpers.h.

                                                                   {
    T ptrPart = nullptr;
    if (!bcin) return ptrPart;
    for (T truthParticle : *TruthTES) {
      if (HepMC::is_sim_descendant(bcin,truthParticle)) {
        ptrPart = truthParticle;
        break;
      }
    }
    return ptrPart;
  }

findAllJetMothers()

template<class T >

void MC::findAllJetMothers	(	T	thePart,
		std::set< T > &	allJetMothers
	)

Function to find all ancestors of the particle.

This can be used for HepMC3::GenParticlePtr, HepMC3::ConstGenParticlePtr or xAOD::TruthParticle*

Definition at line 116 of file HepMCHelpers.h.

                                                                                 {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return;
    auto incoming = partOriVert->particles_in();
    for (auto theMoth: incoming) {
      if (!theMoth) continue;
      allJetMothers.insert(theMoth);
      findAllJetMothers(theMoth, allJetMothers);
    }
  }

findEndVert()

template<class T >

auto MC::findEndVert

(

T

thePart

)

-> decltype(thePart->end_vertex())

Function to find the end vertex of a particle.

This algorithm allows for 1->1 decays.
This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex* and particle counterparts

Definition at line 212 of file HepMCHelpers.h.

                                                                                    {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if (((itrDaug && HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }

findFinalStatePart()

template<class V >

auto MC::findFinalStatePart

(

V

EndVert

)

-> decltype(EndVert->particles_out())

Function to find the stable particle descendants of the gived vertex..

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex* and particle counterparts

Definition at line 240 of file HepMCHelpers.h.

                                                                                              {
    if (!EndVert) return {};
    decltype(EndVert->particles_out()) finalStatePart;
    auto outgoing = EndVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findEndVert(thePart);
      if (pVert == EndVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStatePart<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }

findParticleDaughters()

template<class T >

void MC::findParticleDaughters	(	T	thePart,
		std::set< T > &	daughters
	)

Function to get the particle stable MC daughters.

This can be used for HepMC3::GenParticlePtr, HepMC3::ConstGenParticlePtr or xAOD::TruthParticle*

Definition at line 129 of file HepMCHelpers.h.

                                                                                 {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (auto theDaughter: endVtx->particles_out()) {
      if (theDaughter && isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         daughters.insert(theDaughter);
      }
      findParticleDaughters(theDaughter, daughters);
    }
  }

fromHadron()

template<class T >

bool MC::fromHadron	(	T	p,
		T	hadptr,
		bool &	fromTau,
		bool &	fromBSM
	)

Function to classify the particle.

AV: This is MCtruthClassifier legacy. The function should be improved in the future. This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 184 of file HepMCHelpers.h.

                                                                                  {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    auto incoming = vtx->particles_in();
    for (auto parent: incoming) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      // sometimes Athena replaces status 2 with HepMC::SPECIALSTATUS, see e.g.
      // PhysicsAnalysis/TruthParticleID/McParticleTools/src/EtaPtFilterTool.cxx#L374
      // not at all clear why and unfortunately there's no documentation in the code
      if (!isPhysical(parent) && parent->status() != HepMC::SPECIALSTATUS)  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadptr)  hadptr = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= fromHadron(parent, hadptr, fromTau, fromBSM);
    }
    return fromHad;
  }

getMother()

template<class T >

T MC::getMother

(

T

thePart

)

Function to get a mother of particle. MCTruthClassifier legacy.

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 68 of file HepMCHelpers.h.

                                            {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      auto incoming = partOriVert->particles_in();
      for ( auto p: incoming) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }

isBeam()

template<class T >

bool MC::isBeam ( const T &  p )

inline

Definition at line 28 of file HepMCHelpers.h.

{ return p->status()%HepMC::SIM_STATUS_THRESHOLD == 4;}

isChargedNonShowering()

template<class T >

bool MC::isChargedNonShowering ( const T &  p )

inline

Identify if the particle with given PDG ID would produce ID tracks but not shower in the detector if stable.

Definition at line 26 of file HepMCHelpers.h.

{ return (isMuon<T>(p) || isSUSY<T>(p)); }

isDecayed()

template<class T >

bool MC::isDecayed ( const T &  p )

inline

Definition at line 29 of file HepMCHelpers.h.

{ return p->status()%HepMC::SIM_STATUS_THRESHOLD == 2;}

isFinalState()

template<class T >

bool MC::isFinalState ( const T &  p )

inline

Definition at line 31 of file HepMCHelpers.h.

{ return p->status()%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

isGenStable()

template<class T >

bool MC::isGenStable ( const T &  p )

inline

Determine if the particle is stable at the generator (not det-sim) level,.

Definition at line 36 of file HepMCHelpers.h.

{ return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

isHadronFromB()

template<class T >

T MC::isHadronFromB

(

T

p

)

Function to get the parent B hadron.

This can be used for HepMC3::GenParticlePtr, HepMC3::ConstGenParticlePtr or xAOD::TruthParticle*

AV: Strictly speaking, this is wrong and one has to check all the incoming particles. However that is MCTruthCalssifier legacy that should be fixed later at some point.

Definition at line 142 of file HepMCHelpers.h.

                                           {
    if (!p) return nullptr;
    int pid = abs(p->pdg_id());
    if (isBottomHadron(pid) || pid == BQUARK) return p;
    if (pid == CQUARK || isNucleus(pid) || isBSM(pid) || !p->production_vertex()) return nullptr;
    auto incoming = p->production_vertex()->particles_in();
    if (incoming.size() == 0) return nullptr;
    return isHadronFromB(incoming.front());
  }

isHardScatVrtx()

template<class T >

bool MC::isHardScatVrtx

(

T

pVert

)

Function to classify the vertex as hard scattering vertex.

AV: This is MCtruthClassifier legacy. Note that this function willnot capture some cases of the HardScattering vertices. The function should be improved in the future. This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 158 of file HepMCHelpers.h.

                                                   {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}

isInteracting()

template<class T >

bool MC::isInteracting ( const T &  p )

inline

Identify if the particle with given PDG ID would not interact with the detector, i.e. not a neutrino or WIMP.

Definition at line 23 of file HepMCHelpers.h.

{ return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

isPhysical()

template<class T >

bool MC::isPhysical ( const T &  p )

inline

Definition at line 32 of file HepMCHelpers.h.

{ return isStable<T>(p) || isDecayed<T>(p); }

isPhysicalHadron()

template<class T >

bool MC::isPhysicalHadron ( const T &  p )

inline

Definition at line 33 of file HepMCHelpers.h.

{ return isHadron<T>(p) && isPhysical<T>(p);}

isSimInteracting()

template<class T >

bool MC::isSimInteracting ( const T &  p )

inline

Identify if the particle could interact with the detector during the simulation, e.g. not a neutrino or WIMP.

Definition at line 42 of file HepMCHelpers.h.

{ return isGenStable<T>(p) && isInteracting<T>(p);}

isSimStable()

template<class T >

bool MC::isSimStable ( const T &  p )

inline

Identify if the particle is considered stable at the post-detector-sim stage.

Definition at line 39 of file HepMCHelpers.h.

{ return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

isSingleParticle()

template<class T >

bool MC::isSingleParticle ( const T &  p )

inline

Definition at line 55 of file HepMCHelpers.h.

{ return p->barcode() == HepMC::SINGLE_PARTICLE;}

isSpecialNonInteracting()

template<class T >

bool MC::isSpecialNonInteracting ( const T &  p )

inline

Definition at line 57 of file HepMCHelpers.h.

                                                                     {
    const int apid = std::abs(p->pdg_id());
    if (apid == 12 || apid == 14 || apid == 16) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == 39 || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }

isStable()

template<class T >

bool MC::isStable ( const T &  p )

inline

Definition at line 30 of file HepMCHelpers.h.

{ return p->status()%HepMC::SIM_STATUS_THRESHOLD == 1;}

isStableOrSimDecayed()

template<class T >

bool MC::isStableOrSimDecayed ( const T &  p )

inline

Identify if particle is satble or decayed in simulation.

• a pathological case of decayed particle w/o end vertex. The decayed particles w/o end vertex might occur in case of simulation of long lived particles in Geant stripped off the decay products. I.e. those particles should be re-decayed later.

Definition at line 47 of file HepMCHelpers.h.

                                                                  {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

isZeroEnergyPhoton()

template<class T >

bool MC::isZeroEnergyPhoton ( const T &  p )

inline

Identify a photon with zero energy. Probably a workaround for a generator bug.

Definition at line 53 of file HepMCHelpers.h.

{ return isPhoton<T>(p) && p->e() == 0;}