MC Namespace Reference

Namespaces
	Pythia8

Classes
class	Loops

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)
	Identify if the particle is beam particle. More...
template<class T >
bool	isDecayed (const T &p)
	Identify if the particle decayed. More...
template<class T >
bool	isStable (const T &p)
	Identify if the particle is stable, i.e. has not decayed. More...
template<class T >
bool	isFinalState (const T &p)
	Identify if the particle is final state particle. More...
template<class T >
bool	isPhysical (const T &p)
	Identify if the particle is physical, i.e. is stable or decayed. More...
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)
	Identify a particlegun particle. More...
template<class T >
bool	isSpecialNonInteracting (const T &p)
	Identify a special non-interacting particles. More...
template<class T >
T	findMother (T thePart)
	Function to get a mother of particle. MCTruthClassifier legacy. More...
template<class C , class T >
T	findMatching (C TruthContainer, T p)
	Function to find a particle in container. More...
template<class T >
void	findParticleAncestors (T thePart, std::set< T > &allancestors)
	Function to find all ancestors of the particle. More...
template<class T >
void	findParticleStableDescendants (T thePart, std::set< T > &allstabledescendants)
	Function to get the particle stable MC daughters. More...
template<class T >
bool	isHardScatteringVertex (T pVert)
	Function to classify the vertex as hard scattering vertex. More...
template<class T >
bool	isFromHadron (T p, T hadron, bool &fromTau, bool &fromBSM)
	Function to classify the particle. More...
template<class T >
auto	findSimulatedEndVertex (T thePart) -> decltype(thePart->end_vertex())
	Function to find the end vertex of a particle. More...
template<class V >
auto	findFinalStateParticles (V theVert) -> decltype(theVert->particles_out())
	Function to find the stable particle descendants of the given vertex.. More...

Function Documentation

findFinalStateParticles()

template<class V >

auto MC::findFinalStateParticles

(

V

theVert

)

-> decltype(theVert->particles_out())

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

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

Definition at line 263 of file HepMCHelpers.h.

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

findMatching()

template<class C , class T >

T MC::findMatching	(	C	TruthContainer,
		T	p
	)

Function to find a particle in container.

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

Definition at line 133 of file HepMCHelpers.h.

                                                                     {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

findMother()

template<class T >

T MC::findMother

(

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 100 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;
  }

findParticleAncestors()

template<class T >

void MC::findParticleAncestors	(	T	thePart,
		std::set< T > &	allancestors
	)

Function to find all ancestors of the particle.

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

Definition at line 156 of file HepMCHelpers.h.

                                                                                    {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (auto theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }

findParticleStableDescendants()

template<class T >

void MC::findParticleStableDescendants	(	T	thePart,
		std::set< T > &	allstabledescendants
	)

Function to get the particle stable MC daughters.

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

Definition at line 168 of file HepMCHelpers.h.

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

findSimulatedEndVertex()

template<class T >

auto MC::findSimulatedEndVertex

(

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 235 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 ((( 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;
  }

isBeam()

template<class T >

bool MC::isBeam ( const T &  p )

inline

Identify if the particle is beam particle.

Definition at line 39 of file HepMCHelpers.h.

{ return HepMC::status(p)%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 36 of file HepMCHelpers.h.

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

isDecayed()

template<class T >

bool MC::isDecayed ( const T &  p )

inline

Identify if the particle decayed.

Definition at line 42 of file HepMCHelpers.h.

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

isFinalState()

template<class T >

bool MC::isFinalState ( const T &  p )

inline

Identify if the particle is final state particle.

Definition at line 48 of file HepMCHelpers.h.

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

isFromHadron()

template<class T >

bool MC::isFromHadron	(	T	p,
		T	hadron,
		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 210 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);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }

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 54 of file HepMCHelpers.h.

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

isHardScatteringVertex()

template<class T >

bool MC::isHardScatteringVertex

(

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 184 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 33 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

Identify if the particle is physical, i.e. is stable or decayed.

Definition at line 51 of file HepMCHelpers.h.

{ return isStable<T>(p) || isDecayed<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 60 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 57 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

Identify a particlegun particle.

Definition at line 74 of file HepMCHelpers.h.

                                                               {
    if constexpr (std::is_same_v<std::remove_const_t<HepMC::remove_smart_pointer_t<std::remove_pointer_t<T>>>, xAOD::TruthParticle_v1>) {
      return HepMC::uniqueID(p)  == 3 // Post migration format
        || HepMC::uniqueID(p) == 10001; // pre-migration file read in so barcode copied to id for xAOD::Truth
    }
    else {
#if defined(HEPMC3)
      return HepMC::uniqueID(p)  == 3 ||  HepMC::barcode(p)  == 10001;
#else
      return HepMC::barcode(p)  == 10001;
#endif
    }
  }

isSpecialNonInteracting()

template<class T >

bool MC::isSpecialNonInteracting ( const T &  p )

inline

Identify a special non-interacting particles.

Definition at line 89 of file HepMCHelpers.h.

                                                                     {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || 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

Identify if the particle is stable, i.e. has not decayed.

Definition at line 45 of file HepMCHelpers.h.

{ return HepMC::status(p)%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 65 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 71 of file HepMCHelpers.h.

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