HepMC::StatusBased Namespace Reference

Functions
template<class T >
bool	is_truth_suppressed_pileup (const T &p)
	Method to establish if a particle corresponds to truth-suppressed pile-up. More...
template<class T >
bool	no_truth_link (const T &p)
	Method to establish if a if the object is linked to something which was never saved to the HepMC Truth - for example particle was too low energy to be recorded. More...
template<class T >
bool	ignoreTruthLink (const T &p, bool vetoPileUp)
	Helper function for SDO creation in PileUpTools. More...
template<class T >
bool	is_simulation_particle (const T &p)
	Method to establish if a particle was created during the simulation based on the status value. More...
template<class T >
bool	is_sim_secondary (const T &p)
	Method to establish if a particle is a new seondary created during the simulation based on the status value. More...
template<class T >
int	generations (const T &p)
	Method to return how many interactions a particle has undergone during simulation based on the status value. More...
template<class T >
bool	is_simulation_vertex (const T &v)
	Method to establish if the vertex was created during simulation from the status. More...
template<class T1 , class T2 >
bool	is_same_generator_particle (const T1 &p1, const T2 &p2)
	Method to establish if two particles in the GenEvent actually represent the same generated particle. More...
template<class T1 , class T2 >
bool	is_same_object (const T1 &p1, const T2 &p2)
	Method to establish if two particles/vertices in the GenEvent actually represent the same particle. More...
template<class T1 , class T2 >
bool	is_sim_descendant (const T1 &p1, const T2 &p2)
	Method to check if the first particle is a descendant of the second in the simulation, i.e. particle p1 was produced simulations particle p2. More...

Function Documentation

generations()

template<class T >

int HepMC::StatusBased::generations ( const T &  p )

inline

Method to return how many interactions a particle has undergone during simulation based on the status value.

Definition at line 271 of file MagicNumbers.h.

{ return (status(p)/SIM_STATUS_INCREMENT);}

ignoreTruthLink()

template<class T >

bool HepMC::StatusBased::ignoreTruthLink ( const T &  p, bool  vetoPileUp  )

inline

Helper function for SDO creation in PileUpTools.

Definition at line 255 of file MagicNumbers.h.

                                                                                {
      if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, HepMcParticleLink>) {
        return no_truth_link(p) || (vetoPileUp && is_truth_suppressed_pileup(p));
      }
      else {
        const int u = uniqueID(p);  return no_truth_link(u) || (vetoPileUp && is_truth_suppressed_pileup(u));
      }
    }

is_same_generator_particle()

template<class T1 , class T2 >

bool HepMC::StatusBased::is_same_generator_particle ( const T1 &  p1, const T2 &  p2  )

inline

Method to establish if two particles in the GenEvent actually represent the same generated particle.

Definition at line 277 of file MagicNumbers.h.

                                                                                                    {
      const int id1 = uniqueID(p1);
      const int id2 = uniqueID(p2);
      if (id1 == id2) { return true;} // simplest case
      const int generations1 = generations(p1);
      const int generations2 = generations(p2);
      if (generations1 == generations2) { return false; } // if the id values don't match and the particles have the same generation number then they cannot be the same particle.
      if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T1>>>, TrackRecord>) {
        // No choice, but to get the history of one of the particles:
        const int direction = (generations2 > generations1) ? -1 : 1;
        std::deque<int> history2 = simulation_history( p2, direction );
        if (std::find(history2.begin(),history2.end(), id1) == history2.end()) { return false; }
      }
      else {
        // No choice, but to get the history of one of the particles:
        const int direction = (generations1 > generations2) ? -1 : 1;
        std::deque<int> history1 = simulation_history( p1, direction );
        if (std::find(history1.begin(),history1.end(), id2) == history1.end()) { return false; }
      }
      return true;
    }

is_same_object()

template<class T1 , class T2 >

bool HepMC::StatusBased::is_same_object ( const T1 &  p1, const T2 &  p2  )

inline

Method to establish if two particles/vertices in the GenEvent actually represent the same particle.

Definition at line 300 of file MagicNumbers.h.

                                                                                        {
      const int id1 = uniqueID(p1);
      const int id2 = uniqueID(p2);
      return (id1 == id2);
    }

is_sim_descendant()

template<class T1 , class T2 >

bool HepMC::StatusBased::is_sim_descendant ( const T1 &  p1, const T2 &  p2  )

inline

Method to check if the first particle is a descendant of the second in the simulation, i.e. particle p1 was produced simulations particle p2.

Definition at line 308 of file MagicNumbers.h.

                                                                                           {
      const int id1 = uniqueID(p1);
      const int id2 = uniqueID(p2);
      if (id1 == id2) { return true;} // simplest case
      const int generations1 = generations(p1);
      const int generations2 = generations(p2);
      if (generations1 == generations2) { return false; } // if the id values don't match and the particles have the same generation number then they cannot be the same particle.
      if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T1>>>, TrackRecord>) {
        // No choice, but to get the descendents of p2
        constexpr int descendents = 1;
        std::deque<int> history2 = simulation_history( p2, descendents );
        if (std::find(history2.begin(),history2.end(), id1) == history2.end()) { return false; }
       }
      else {
        // No choice, but to get the history of p1
        constexpr int ancestors = -1;
        std::deque<int> history1 = simulation_history( p1, ancestors );
        if (std::find(history1.begin(),history1.end(), id2) == history1.end()) { return false; }
      }
      return true;
    }

is_sim_secondary()

template<class T >

bool HepMC::StatusBased::is_sim_secondary ( const T &  p )

inline

Method to establish if a particle is a new seondary created during the simulation based on the status value.

Definition at line 268 of file MagicNumbers.h.

{ return (status(p)%SIM_STATUS_INCREMENT > SIM_STATUS_THRESHOLD); }

is_simulation_particle()

template<class T >

bool HepMC::StatusBased::is_simulation_particle ( const T &  p )

inline

Method to establish if a particle was created during the simulation based on the status value.

Definition at line 265 of file MagicNumbers.h.

{ return (status(p)>SIM_STATUS_THRESHOLD);}

is_simulation_vertex()

template<class T >

bool HepMC::StatusBased::is_simulation_vertex ( const T &  v )

inline

Method to establish if the vertex was created during simulation from the status.

Definition at line 274 of file MagicNumbers.h.

{ return (status(v)>SIM_STATUS_THRESHOLD);}

is_truth_suppressed_pileup()

template<class T >

bool HepMC::StatusBased::is_truth_suppressed_pileup ( const T &  p )

inline

Method to establish if a particle corresponds to truth-suppressed pile-up.

Definition at line 229 of file MagicNumbers.h.

                                                                          {
      if constexpr (std::is_same_v<std::remove_const_t<T>, HepMcParticleLink>) {
        return p.getTruthSuppressionType() == EBC_PU_SUPPRESSED;
      }
      else if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, HepMcParticleLink>) {
        return p->getTruthSuppressionType() == EBC_PU_SUPPRESSED;
      }
      else {
        return p == EBC_PU_SUPPRESSED;
      }
    }

no_truth_link()

template<class T >

bool HepMC::StatusBased::no_truth_link ( const T &  p )

inline

Method to establish if a if the object is linked to something which was never saved to the HepMC Truth - for example particle was too low energy to be recorded.

Definition at line 242 of file MagicNumbers.h.

                                                             {
      if constexpr (std::is_same_v<std::remove_const_t<T>, HepMcParticleLink>) {
        return p.linkIsNull();
      }
      else if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, HepMcParticleLink>) {
        return p->linkIsNull();
      }
      else {
        return (uniqueID(p) == UNDEFINED_ID);
      }
    }