HepMC Namespace Reference

Namespaces
namespace	BarcodeBased
namespace	StatusBased

Classes
class	ShortEventAttribute
class	GenEventBarcodes
class	ShadowParticle
	Attribute for linking GenParticles between GenEvents. More...
class	Polarization
struct	DataPool
struct	is_smart_ptr
struct	is_smart_ptr< std::shared_ptr< T > >
struct	is_smart_ptr< std::unique_ptr< T > >
struct	is_smart_ptr< std::weak_ptr< T > >
struct	remove_smart_pointer
struct	remove_smart_pointer< std::shared_ptr< T > >
struct	remove_smart_pointer< std::unique_ptr< T > >
struct	remove_smart_pointer< std::weak_ptr< T > >

Typedefs
typedef std::shared_ptr< HepMC3::VectorIntAttribute >	Flow
using	Print = HepMC3::Print
using	GenHeavyIon = HepMC3::GenHeavyIon
using	GenEvent = HepMC3::GenEvent
typedef HepMC3::GenParticlePtr	GenParticlePtr
typedef HepMC3::ConstGenParticlePtr	ConstGenParticlePtr
typedef HepMC3::GenVertexPtr	GenVertexPtr
typedef HepMC3::ConstGenVertexPtr	ConstGenVertexPtr
typedef HepMC3::GenHeavyIonPtr	GenHeavyIonPtr
typedef HepMC3::HEPEVT_Wrapper	HEPEVT_Wrapper
typedef std::shared_ptr< HepMC3::GenPdfInfo >	GenPdfInfoPtr
typedef HepMC3::Relatives	Relatives
typedef HepMC3::FourVector	FourVector
typedef HepMC3::Pythia8ToHepMC3	Pythia8ToHepMC
template<class T>
using	remove_smart_pointer_t = typename remove_smart_pointer<T>::type

Functions
template<class T>
int	barcode (const T *p)
int	barcode (int p)
template<class T, std::enable_if_t< !std::is_pointer< T >::value &&!std::is_same< T, HepMC3::GenParticlePtr >::value &&!std::is_same< T, HepMC3::ConstGenParticlePtr >::value &&!std::is_same< T, HepMC3::GenVertexPtr >::value &&!std::is_same< T, HepMC3::ConstGenVertexPtr >::value &&!std::is_same< T, HepMC3::GenVertex >::value &&!std::is_same< T, HepMC3::GenParticle >::value &&!std::is_same< T, int >::value, bool > = true>
int	barcode (const T &p)
template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticlePtr >::value||std::is_same< T, HepMC3::ConstGenParticlePtr >::value||std::is_same< T, HepMC3::GenVertexPtr >::value||std::is_same< T, HepMC3::ConstGenVertexPtr >::value, bool > = true>
int	barcode (const T &p)
template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticle >::value||std::is_same< T, HepMC3::GenVertex >::value, bool > = true>
int	barcode (const T &p)
int	flow (const HepMC3::GenParticlePtr &p, int i)
int	flow (const HepMC3::ConstGenParticlePtr &p, int i)
Flow	flow (const HepMC3::GenParticlePtr &p)
Flow	flow (const HepMC3::ConstGenParticlePtr &p)
template<class T>
void	set_flow (T &a, Flow fl)
bool	set_ll_event_number (HepMC3::GenEvent *e, long long int num)
long long int	get_ll_event_number (const HepMC3::GenEvent *e)
std::map< std::string, std::size_t >	weights_map (const HepMC3::GenEvent *e)
std::vector< HepMC3::GenParticlePtr >::const_iterator	begin (HepMC3::GenEvent &e)
std::vector< HepMC3::GenParticlePtr >::const_iterator	end (HepMC3::GenEvent &e)
std::vector< HepMC3::ConstGenParticlePtr >::const_iterator	begin (const HepMC3::GenEvent &e)
std::vector< HepMC3::ConstGenParticlePtr >::const_iterator	end (const HepMC3::GenEvent &e)
GenEvent *	newGenEvent (const int signal_process_id, const int event_number)
GenEvent *	copyemptyGenEvent (const GenEvent *inEvt)
void	fillBarcodesAttribute (GenEvent *e)
ConstGenVertexPtr	barcode_to_vertex (const GenEvent *e, int id)
ConstGenParticlePtr	barcode_to_particle (const GenEvent *e, int id)
GenVertexPtr	barcode_to_vertex (GenEvent *e, int id)
GenParticlePtr	barcode_to_particle (GenEvent *e, int id)
int	mpi (const GenEvent &evt)
int	mpi (const GenEvent *evt)
int	signal_process_id (const GenEvent &evt)
int	signal_process_id (const GenEvent *evt)
void	set_signal_process_id (GenEvent *e, const int i=0)
void	set_mpi (GenEvent *e, const int i=0)
void	set_random_states (GenEvent *e, std::vector< long int > &a)
template<class T>
void	set_signal_process_vertex (GenEvent *e, T &v)
ConstGenVertexPtr	signal_process_vertex (const GenEvent *e)
GenVertexPtr	signal_process_vertex (GenEvent *e)
bool	valid_beam_particles (const GenEvent *e)
template<class T>
bool	suggest_barcode (T &p, int i)
GenParticlePtr	newGenParticlePtr (const HepMC3::FourVector &mom=HepMC3::FourVector::ZERO_VECTOR(), int pid=0, int status=0)
ConstGenParticlePtr	newConstGenParticlePtr (const HepMC3::FourVector &mom=HepMC3::FourVector::ZERO_VECTOR(), int pid=0, int status=0)
int	barcode_or_id (const ConstGenParticlePtr &p)
GenVertexPtr	newGenVertexPtr (const HepMC3::FourVector &pos=HepMC3::FourVector::ZERO_VECTOR(), const int i=0)
int	barcode_or_id (const ConstGenVertexPtr &p)
template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticlePtr >::value||std::is_same< T, HepMC3::ConstGenParticlePtr >::value, bool > = true>
Polarization	polarization (const T &a)
template<class T>
void	set_polarization (T &a, const Polarization &b)
constexpr int	SUPPRESSED_PILEUP_BARCODE (std::numeric_limits< int32_t >::max())
	This barcode is used by objects matched to particles from pile-up interactions in standard MC Production.
template<typename T>
int	uniqueID (const T &p)
template<typename T>
int	status (const T &p)
template<class T>
void	get_particle_history (const T &p, std::deque< int > &out, const int direction=0)
	Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle.
template<class T>
std::deque< int >	simulation_history (const T &p, const int direction)
	Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle.
template<class T>
bool	is_truth_suppressed_pileup (const T &p)
	Method to establish if a particle (or barcode) corresponds to truth-suppressed pile-up (TODO update to be status based).
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.
template<class T>
bool	ignoreTruthLink (const T &p, bool vetoPileUp)
	Helper function for SDO creation in PileUpTools.
template<class T>
bool	is_simulation_particle (const T &p)
	Method to establish if a particle (or barcode) was created during the simulation (TODO update to be status based).
template<class T>
int	generations (const T &p)
	Method to return how many interactions a particle has undergone during simulation (TODO migrate to be based on status).
template<class T>
bool	is_simulation_vertex (const T &v)
	Method to establish if the vertex was created during simulation (TODO migrate to be based on status).
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.
template<class T1, class T2>
bool	is_same_particle (const T1 &p1, const T2 &p2)
	Method to establish if two particles in the GenEvent actually represent the same particle.
template<class T1, class T2>
bool	is_same_vertex (const T1 &p1, const T2 &p2)
	Method to establish if two particles in the GenEvent actually represent the same vertex.
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.
template<class T>
void	old_to_new_simulation_scheme (T &evt)
	Function that converts the old scheme of labeling the simulation particles (barcodes) into the new scheme (statuses).
int	new_particle_status_from_old (const int oldStatus, const int barcode)
	Get particle status in the new scheme from the barcode and status in the old scheme.
int	old_particle_status_from_new (const int newStatus)
	Get particle status in the old scheme from the status in the new scheme.
int	new_vertex_status_from_old (const int oldStatus, const int barcode)
	Get vertex status in the new scheme from the barcode and status in the old scheme.
int	old_vertex_status_from_new (const int newStatus)
	Get vertex status in the old scheme from the status in the new scheme.
int	maxGeneratedParticleBarcode (const HepMC::GenEvent *genEvent)
	Get the maximal value of barcode of particle present in the event.
int	maxGeneratedVertexBarcode (const HepMC::GenEvent *genEvent)
	Get the maximal absolute value of barcode of vertex present in the event. Returns a negative number.

Variables
constexpr int	SIM_BARCODE_THRESHOLD = 200000
	Constant defining the barcode threshold for simulated particles, eg. can be used to separate generator event record entries from simulated particles.
constexpr int	SIM_REGENERATION_INCREMENT = 1000000
	Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction.
constexpr int	SIM_STATUS_INCREMENT = 100000
	Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction.
constexpr int	SIM_STATUS_THRESHOLD = 20000
	Constant definiting the status threshold for simulated particles, eg. can be used to separate generator event record entries from simulated particles.
constexpr int	FORWARD_TRANSPORT_MODEL_PROCESS = 212
	Special Forward transport Geant process for vertices.
constexpr int	INVALID_PARTICLE_BARCODE = -1
constexpr int	UNDEFINED_ID = 0
constexpr int	INVALID_PARTICLE_ID = -1
constexpr int	INVALID_VERTEX_ID = 1
template<class T>
constexpr bool	is_smart_ptr_v = is_smart_ptr<T>::value

Typedef Documentation

ConstGenParticlePtr

typedef HepMC3::ConstGenParticlePtr HepMC::ConstGenParticlePtr

Definition at line 20 of file GenParticle.h.

ConstGenVertexPtr

typedef HepMC3::ConstGenVertexPtr HepMC::ConstGenVertexPtr

Definition at line 24 of file GenVertex.h.

Flow

typedef std::shared_ptr<HepMC3::VectorIntAttribute> HepMC::Flow

Definition at line 12 of file Flow.h.

FourVector

typedef HepMC3::FourVector HepMC::FourVector

Definition at line 11 of file SimpleVector.h.

GenEvent

using HepMC::GenEvent = HepMC3::GenEvent

Definition at line 39 of file GenEvent.h.

GenHeavyIon

using HepMC::GenHeavyIon = HepMC3::GenHeavyIon

Definition at line 38 of file GenEvent.h.

GenHeavyIonPtr

typedef HepMC3::GenHeavyIonPtr HepMC::GenHeavyIonPtr

Definition at line 11 of file HeavyIon.h.

GenParticlePtr

typedef HepMC3::GenParticlePtr HepMC::GenParticlePtr

Definition at line 19 of file GenParticle.h.

GenPdfInfoPtr

typedef std::shared_ptr<HepMC3::GenPdfInfo> HepMC::GenPdfInfoPtr

Definition at line 11 of file PdfInfo.h.

GenVertexPtr

typedef HepMC3::GenVertexPtr HepMC::GenVertexPtr

Definition at line 23 of file GenVertex.h.

HEPEVT_Wrapper

typedef HepMC3::HEPEVT_Wrapper HepMC::HEPEVT_Wrapper

Definition at line 14 of file HEPEVT_Wrapper.h.

Print

using HepMC::Print = HepMC3::Print

Definition at line 37 of file GenEvent.h.

Pythia8ToHepMC

typedef HepMC3::Pythia8ToHepMC3 HepMC::Pythia8ToHepMC

Definition at line 20 of file Pythia8_i.h.

Relatives

typedef HepMC3::Relatives HepMC::Relatives

Definition at line 10 of file Relatives.h.

remove_smart_pointer_t

template<class T>

using HepMC::remove_smart_pointer_t = typename remove_smart_pointer<T>::type

Definition at line 74 of file MagicNumbers.h.

Function Documentation

barcode() [1/5]

template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticle >::value||std::is_same< T, HepMC3::GenVertex >::value, bool > = true>

int HepMC::barcode ( const T & p )

inline

Definition at line 46 of file Barcode.h.

                               {
    const HepMC3::GenEvent* e = p.parent_event();
    if (!e) return 0;
    std::shared_ptr<HepMC3::IntAttribute> barcode = e->attribute<HepMC3::IntAttribute>(HepMCStr::barcode, p.id());
    return barcode ? (barcode->value()) : p.id();
}

barcode() [2/5]

template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticlePtr >::value||std::is_same< T, HepMC3::ConstGenParticlePtr >::value||std::is_same< T, HepMC3::GenVertexPtr >::value||std::is_same< T, HepMC3::ConstGenVertexPtr >::value, bool > = true>

int HepMC::barcode ( const T & p )

inline

Definition at line 34 of file Barcode.h.

                               {
    if (!p) return 0;
    const HepMC3::GenEvent* e = p->parent_event();
    if (!e) return 0;
    std::shared_ptr<HepMC3::IntAttribute> barcode = e->attribute<HepMC3::IntAttribute>(HepMCStr::barcode, p->id());
    return barcode ? (barcode->value()) : p->id();
}

barcode() [3/5]

template<class T, std::enable_if_t< !std::is_pointer< T >::value &&!std::is_same< T, HepMC3::GenParticlePtr >::value &&!std::is_same< T, HepMC3::ConstGenParticlePtr >::value &&!std::is_same< T, HepMC3::GenVertexPtr >::value &&!std::is_same< T, HepMC3::ConstGenVertexPtr >::value &&!std::is_same< T, HepMC3::GenVertex >::value &&!std::is_same< T, HepMC3::GenParticle >::value &&!std::is_same< T, int >::value, bool > = true>

int HepMC::barcode ( const T & p )

inline

Definition at line 26 of file Barcode.h.

{ return p.barcode();}

barcode() [4/5]

template<class T>

int HepMC::barcode ( const T * p )

inline

Definition at line 15 of file Barcode.h.

{ return p->barcode(); }

barcode() [5/5]

int HepMC::barcode ( int p )

inline

Definition at line 16 of file Barcode.h.

{ return p; }

barcode_or_id() [1/2]

int HepMC::barcode_or_id ( const ConstGenParticlePtr & p )

inline

Definition at line 27 of file GenParticle.h.

{ return p->id(); }

barcode_or_id() [2/2]

int HepMC::barcode_or_id ( const ConstGenVertexPtr & p )

inline

Definition at line 30 of file GenVertex.h.

{ return p->id();}

barcode_to_particle() [1/2]

ConstGenParticlePtr HepMC::barcode_to_particle ( const GenEvent * e, int id )

inline

Definition at line 443 of file GenEvent.h.

                                                                           {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    ConstGenParticlePtr ptr = barcodes->barcode_to_particle (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenParticle barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &particles = e->particles();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= particles.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->particle();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->particle();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (id > 0 && id <= static_cast<int>(particles.size())) {
    if (!particles[id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return particles[id-1];
    }
  }
  return  HepMC3::ConstGenParticlePtr();
}

barcode_to_particle() [2/2]

GenParticlePtr HepMC::barcode_to_particle ( GenEvent * e, int id )

inline

Definition at line 523 of file GenEvent.h.

                                                                {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    GenParticlePtr ptr = barcodes->barcode_to_particle (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenParticle barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &particles = e->particles();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= particles.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->particle();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->particle();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (id > 0 && id <= static_cast<int>(particles.size())) {
    if (!particles[id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return particles[id-1];
    }
  }
  return  HepMC3::GenParticlePtr();
}

barcode_to_vertex() [1/2]

ConstGenVertexPtr HepMC::barcode_to_vertex ( const GenEvent * e, int id )

inline

Definition at line 403 of file GenEvent.h.

                                                                       {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    ConstGenVertexPtr ptr = barcodes->barcode_to_vertex (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenVertex barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &vertices = e->vertices();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= vertices.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(-i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->vertex();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->vertex();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (-id > 0 && -id <= static_cast<int>(vertices.size())) {
    if (!vertices[-id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return vertices[-id-1];
    }
  }
  return  HepMC3::ConstGenVertexPtr();
}

barcode_to_vertex() [2/2]

GenVertexPtr HepMC::barcode_to_vertex ( GenEvent * e, int id )

inline

Definition at line 483 of file GenEvent.h.

                                                            {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    GenVertexPtr ptr = barcodes->barcode_to_vertex (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenVertex barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &vertices = e->vertices();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= vertices.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(-i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->vertex();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->vertex();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (-id > 0 && -id <= static_cast<int>(vertices.size())) {
    if (!vertices[-id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return vertices[-id-1];
    }
  }
  return  HepMC3::GenVertexPtr();
}

begin() [1/2]

std::vector< HepMC3::ConstGenParticlePtr >::const_iterator HepMC::begin ( const HepMC3::GenEvent & e )

inline

Definition at line 357 of file GenEvent.h.

{ return e.particles().begin(); }

begin() [2/2]

std::vector< HepMC3::GenParticlePtr >::const_iterator HepMC::begin ( HepMC3::GenEvent & e )

inline

Definition at line 355 of file GenEvent.h.

{ return e.particles().begin(); }

copyemptyGenEvent()

GenEvent * HepMC::copyemptyGenEvent ( const GenEvent * inEvt )

inline

Definition at line 369 of file GenEvent.h.

                                                          {
  GenEvent* e = new GenEvent();
  e->set_event_number(inEvt->event_number());
  e->weights() = inEvt->weights();
  auto a_mpi = inEvt->attribute<HepMC3::IntAttribute>(HepMCStr::mpi); 
  if (a_mpi) e->add_attribute(HepMCStr::mpi, std::make_shared<HepMC3::IntAttribute>(*a_mpi));
  auto a_signal_process_id = inEvt->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
  if (a_signal_process_id) e->add_attribute(HepMCStr::signal_process_id, std::make_shared<HepMC3::IntAttribute>(*a_signal_process_id));
  auto a_event_scale = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::event_scale);
  if (a_event_scale) e->add_attribute(HepMCStr::event_scale, std::make_shared<HepMC3::DoubleAttribute>(*a_event_scale));
  auto a_alphaQCD = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQCD);
  if (a_alphaQCD) e->add_attribute(HepMCStr::alphaQCD, std::make_shared<HepMC3::DoubleAttribute>(*a_alphaQCD));
  auto a_alphaQED = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQED);
  if (a_alphaQED) e->add_attribute(HepMCStr::alphaQED, std::make_shared<HepMC3::DoubleAttribute>(*a_alphaQED));
  auto a_pi = inEvt->pdf_info(); 
  if (a_pi) e->set_pdf_info(std::make_shared<HepMC3::GenPdfInfo>(*a_pi));
  auto a_hi = inEvt->heavy_ion(); 
  if (a_hi) e->set_heavy_ion(std::make_shared<HepMC3::GenHeavyIon>(*a_hi));
  auto a_random_states = inEvt->attribute<HepMC3::VectorLongIntAttribute>(HepMCStr::random_states);
  if (a_random_states) e->add_attribute(HepMCStr::random_states, std::make_shared<HepMC3::VectorLongIntAttribute>(*a_random_states));
  e->add_attribute(HepMCStr::barcodes, std::make_shared<GenEventBarcodes>());
  return e;
}

end() [1/2]

std::vector< HepMC3::ConstGenParticlePtr >::const_iterator HepMC::end ( const HepMC3::GenEvent & e )

inline

Definition at line 358 of file GenEvent.h.

{ return e.particles().end(); }

end() [2/2]

std::vector< HepMC3::GenParticlePtr >::const_iterator HepMC::end ( HepMC3::GenEvent & e )

inline

Definition at line 356 of file GenEvent.h.

{ return e.particles().end(); }

fillBarcodesAttribute()

void HepMC::fillBarcodesAttribute ( GenEvent * e )

inline

Definition at line 393 of file GenEvent.h.

                                               {
  auto barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (!barcodes) {
    barcodes = std::make_shared<GenEventBarcodes>();
    e->add_attribute(HepMCStr::barcodes, barcodes);
  }
  // force re-parsing as calling barcodes->is_parsed() returns true here
  barcodes->fillAttribute(e);
}

flow() [1/4]

Flow HepMC::flow ( const HepMC3::ConstGenParticlePtr & p )

inline

Definition at line 33 of file Flow.h.

                                                     {
    std::shared_ptr<HepMC3::VectorIntAttribute> vf = p->attribute<HepMC3::VectorIntAttribute>(HepMCStr::flow);
    if (vf) return vf;
 
    std::vector<int> fl;
    for (int i = 1; i <= 10; i++) {
        std::shared_ptr<HepMC3::IntAttribute> f = p->attribute<HepMC3::IntAttribute>("flow" + std::to_string(i));  if (f) fl.push_back(i); else break;
    }
    return std::make_shared<HepMC3::VectorIntAttribute>(fl);
}

flow() [2/4]

int HepMC::flow ( const HepMC3::ConstGenParticlePtr & p, int i )

inline

Definition at line 18 of file Flow.h.

                                                           {
    std::shared_ptr<HepMC3::IntAttribute> f = p->attribute<HepMC3::IntAttribute>("flow" + std::to_string(i));  if (f) return f->value();
    std::shared_ptr<HepMC3::VectorIntAttribute> vf = p->attribute<HepMC3::VectorIntAttribute>(HepMCStr::flow);  if (vf) if (0 < i && i < (int)(vf->value().size())) return vf->value().at(i);
    return 0;
}

flow() [3/4]

Flow HepMC::flow ( const HepMC3::GenParticlePtr & p )

inline

Definition at line 23 of file Flow.h.

                                                {
    std::shared_ptr<HepMC3::VectorIntAttribute> vf = p->attribute<HepMC3::VectorIntAttribute>(HepMCStr::flow);
    if (vf)  return vf;
 
    std::vector<int> fl;
    for (int i = 1; i <= 10; i++) {
        std::shared_ptr<HepMC3::IntAttribute> f = p->attribute<HepMC3::IntAttribute>("flow" + std::to_string(i));  if (f) fl.push_back(i); else break;
    }
    return std::make_shared<HepMC3::VectorIntAttribute>(fl);
}

flow() [4/4]

int HepMC::flow ( const HepMC3::GenParticlePtr & p, int i )

inline

Definition at line 13 of file Flow.h.

                                                      {
    std::shared_ptr<HepMC3::IntAttribute> f = p->attribute<HepMC3::IntAttribute>("flow" + std::to_string(i));  if (f) return f->value();
    std::shared_ptr<HepMC3::VectorIntAttribute> vf = p->attribute<HepMC3::VectorIntAttribute>(HepMCStr::flow);  if (vf) if (0 < i && i < (int)(vf->value().size())) return vf->value().at(i);
    return 0;
}

generations()

template<class T>

int HepMC::generations ( const T & p )

inline

Method to return how many interactions a particle has undergone during simulation (TODO migrate to be based on status).

Definition at line 325 of file MagicNumbers.h.

{ return StatusBased::generations(p);}

get_ll_event_number()

long long int HepMC::get_ll_event_number ( const HepMC3::GenEvent * e )

inline

Definition at line 341 of file GenEvent.h.

                                                                 {
  auto at = e->attribute<HepMC3::LongLongAttribute>(HepMCStr::long_long_event_number);
  return at ? at->value() : e->event_number();
}

get_particle_history()

template<class T>

void HepMC::get_particle_history ( const T & p, std::deque< int > & out, const int direction = 0 )

inline

Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle.

Definition at line 131 of file MagicNumbers.h.

                                                                                                             {
    if (direction < 0) {
      if (p->status()>SIM_STATUS_INCREMENT) {
        auto pv = p->production_vertex();
        if (pv) {
          for (auto pa: pv->particles_in()) {
            if (!pa || pa->pdg_id() != p->pdg_id()) continue;
            out.push_front(uniqueID(p));
            get_particle_history(pa, out, -1);
            break;
          }
        }
      }
    }
    if (direction > 0) {
      if (p->status()>SIM_STATUS_INCREMENT) {
        auto pv = p->end_vertex();
        if (pv) {
          for (auto pa: pv->particles_out()) {
            if (!pa || pa->pdg_id() != p->pdg_id()) continue;
            out.push_back(uniqueID(p));
            get_particle_history(pa, out, 1);
            break;
          }
        }
      }
    }
  }

ignoreTruthLink()

template<class T>

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

inline

Helper function for SDO creation in PileUpTools.

Definition at line 312 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 StatusBased::ignoreTruthLink(p, vetoPileUp);
    }
    else {
      return BarcodeBased::ignoreTruthLink(p, vetoPileUp);
    }
  }

is_same_generator_particle()

template<class T1, class T2>

bool HepMC::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 331 of file MagicNumbers.h.

{ return StatusBased::is_same_generator_particle(p1, p2); }

is_same_particle()

template<class T1, class T2>

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

inline

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

Definition at line 334 of file MagicNumbers.h.

{ return StatusBased::is_same_object(p1, p2); }

is_same_vertex()

template<class T1, class T2>

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

inline

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

Definition at line 337 of file MagicNumbers.h.

{ return StatusBased::is_same_object(p1, p2); }

is_sim_descendant()

template<class T1, class T2>

bool HepMC::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 340 of file MagicNumbers.h.

{ return StatusBased::is_sim_descendant(p1, p2);}

is_simulation_particle()

template<class T>

bool HepMC::is_simulation_particle ( const T & p )

inline

Method to establish if a particle (or barcode) was created during the simulation (TODO update to be status based).

Definition at line 322 of file MagicNumbers.h.

{ return StatusBased::is_simulation_particle(p);}

is_simulation_vertex()

template<class T>

bool HepMC::is_simulation_vertex ( const T & v )

inline

Method to establish if the vertex was created during simulation (TODO migrate to be based on status).

Definition at line 328 of file MagicNumbers.h.

{ return StatusBased::is_simulation_vertex(v);}

is_truth_suppressed_pileup()

template<class T>

bool HepMC::is_truth_suppressed_pileup ( const T & p )

inline

Method to establish if a particle (or barcode) corresponds to truth-suppressed pile-up (TODO update to be status based).

Definition at line 299 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 StatusBased::is_truth_suppressed_pileup(p);
    }
    else {
      return BarcodeBased::is_truth_suppressed_pileup(p);
    }
  }

maxGeneratedParticleBarcode()

int HepMC::maxGeneratedParticleBarcode ( const HepMC::GenEvent * genEvent )

inline

Get the maximal value of barcode of particle present in the event.

Definition at line 386 of file MagicNumbers.h.

                                                                       {
  int maxBarcode = 0;
  auto allbarcodes = genEvent->attribute<HepMC::GenEventBarcodes>(HepMCStr::barcodes);
  for (const auto& bp: allbarcodes->barcode_to_particle_map()) {
    if (!HepMC::BarcodeBased::is_simulation_particle(bp.first)) { maxBarcode=std::max(maxBarcode,bp.first); }
  }
  return maxBarcode;
}

maxGeneratedVertexBarcode()

int HepMC::maxGeneratedVertexBarcode ( const HepMC::GenEvent * genEvent )

inline

Get the maximal absolute value of barcode of vertex present in the event. Returns a negative number.

Definition at line 396 of file MagicNumbers.h.

                                                                    {
  int maxBarcode=0;
  auto allbarcodes = genEvent->attribute<HepMC::GenEventBarcodes>(HepMCStr::barcodes);
  for (const auto& bp: allbarcodes->barcode_to_vertex_map()) {
    if (!HepMC::BarcodeBased::is_simulation_vertex(bp.first)) { maxBarcode=std::min(maxBarcode,bp.first); }
  }
  return maxBarcode;
}

mpi() [1/2]

int HepMC::mpi ( const GenEvent & evt )

inline

Definition at line 563 of file GenEvent.h.

                                    {
    std::shared_ptr<HepMC3::IntAttribute> A_mpi = evt.attribute<HepMC3::IntAttribute>(HepMCStr::mpi);
    return A_mpi ? (A_mpi->value()) : 0;
}

mpi() [2/2]

int HepMC::mpi ( const GenEvent * evt )

inline

Definition at line 567 of file GenEvent.h.

                                    {
    std::shared_ptr<HepMC3::IntAttribute> A_mpi = evt->attribute<HepMC3::IntAttribute>(HepMCStr::mpi);
    return A_mpi ? (A_mpi->value()) : 0;
}

new_particle_status_from_old()

int HepMC::new_particle_status_from_old ( const int oldStatus, const int barcode )

inline

Get particle status in the new scheme from the barcode and status in the old scheme.

Definition at line 363 of file MagicNumbers.h.

                                                                                  {
    int generations_barcode_based = (barcode/SIM_REGENERATION_INCREMENT);
    bool is_sim_secondary_barcode_based = (barcode%SIM_REGENERATION_INCREMENT > SIM_BARCODE_THRESHOLD);
    return oldStatus + SIM_STATUS_INCREMENT*generations_barcode_based + (is_sim_secondary_barcode_based? SIM_STATUS_THRESHOLD : 0); 
  }

new_vertex_status_from_old()

int HepMC::new_vertex_status_from_old ( const int oldStatus, const int barcode )

inline

Get vertex status in the new scheme from the barcode and status in the old scheme.

Definition at line 373 of file MagicNumbers.h.

                                                                                {
    bool is_simulation_vertex_barcode_based =  (barcode<-SIM_BARCODE_THRESHOLD);
    return (is_simulation_vertex_barcode_based? SIM_STATUS_THRESHOLD : 0) + oldStatus;
  }

newConstGenParticlePtr()

ConstGenParticlePtr HepMC::newConstGenParticlePtr ( const HepMC3::FourVector & mom = HepMC3::FourVector::ZERO_VECTOR(), int pid = 0, int status = 0 )

inline

Definition at line 24 of file GenParticle.h.

                                                                                                                                      {
    return std::make_shared<const HepMC3::GenParticle>(mom, pid, status);
}

newGenEvent()

GenEvent * HepMC::newGenEvent ( const int signal_process_id, const int event_number )

inline

Definition at line 360 of file GenEvent.h.

                                                                                  { // TODO Update event_number to long long int?
    GenEvent* e = new GenEvent();
    std::shared_ptr<HepMC3::IntAttribute> signal_process_id_A = std::make_shared<HepMC3::IntAttribute>(signal_process_id);
    e->add_attribute(HepMCStr::signal_process_id, signal_process_id_A);
    e->add_attribute(HepMCStr::barcodes, std::make_shared<GenEventBarcodes>());
    e->set_event_number(event_number);
    return e;
}

newGenParticlePtr()

GenParticlePtr HepMC::newGenParticlePtr ( const HepMC3::FourVector & mom = HepMC3::FourVector::ZERO_VECTOR(), int pid = 0, int status = 0 )

inline

Definition at line 21 of file GenParticle.h.

                                                                                                                            {
    return std::make_shared<HepMC3::GenParticle>(mom, pid, status);
}

newGenVertexPtr()

GenVertexPtr HepMC::newGenVertexPtr ( const HepMC3::FourVector & pos = HepMC3::FourVector::ZERO_VECTOR(), const int i = 0 )

inline

Definition at line 25 of file GenVertex.h.

                                                                                                            {
    GenVertexPtr v = std::make_shared<HepMC3::GenVertex>(pos);
    v->set_status(i);
    return v;
}

no_truth_link()

template<class T>

bool HepMC::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 309 of file MagicNumbers.h.

{ return StatusBased::no_truth_link(p);}

old_particle_status_from_new()

int HepMC::old_particle_status_from_new ( const int newStatus )

inline

Get particle status in the old scheme from the status in the new scheme.

Definition at line 370 of file MagicNumbers.h.

{ return newStatus%SIM_STATUS_THRESHOLD; }

old_to_new_simulation_scheme()

template<class T>

void HepMC::old_to_new_simulation_scheme

(

T &

evt

)

Function that converts the old scheme of labeling the simulation particles (barcodes) into the new scheme (statuses).

Definition at line 343 of file MagicNumbers.h.

                                                               {
    auto particle_status = [] (int barcode, int status) {
      if ((barcode % SIM_REGENERATION_INCREMENT) > SIM_BARCODE_THRESHOLD)
        status += SIM_STATUS_THRESHOLD;
      status += SIM_STATUS_INCREMENT * (barcode / SIM_REGENERATION_INCREMENT);
      return status;
    };
    auto vertex_status = [] (int barcode, int status) {
      if (-barcode > SIM_BARCODE_THRESHOLD) status += SIM_STATUS_THRESHOLD;
      return status;
    };
    for (auto p: evt->particles())  {
      p->set_status (particle_status (HepMC::barcode(p), p->status()));
    }
    for (auto v: evt->vertices()) {
      v->set_status (vertex_status (HepMC::barcode(v), v->status()));
    }
  }

old_vertex_status_from_new()

int HepMC::old_vertex_status_from_new ( const int newStatus )

inline

Get vertex status in the old scheme from the status in the new scheme.

Definition at line 379 of file MagicNumbers.h.

                                                             {
    bool is_simulation_vertex_status_based = (newStatus>SIM_STATUS_THRESHOLD);
    return ( is_simulation_vertex_status_based ? -SIM_STATUS_THRESHOLD : 0) + newStatus; }

polarization()

template<class T, std::enable_if_t< std::is_same< T, HepMC3::GenParticlePtr >::value||std::is_same< T, HepMC3::ConstGenParticlePtr >::value, bool > = true>

Polarization HepMC::polarization ( const T & a )

inline

Definition at line 28 of file Polarization.h.

                                             {
    std::shared_ptr<HepMC3::DoubleAttribute> phi_A = a->template attribute<HepMC3::DoubleAttribute>(HepMCStr::phi);
    std::shared_ptr<HepMC3::DoubleAttribute> theta_A = a->template attribute<HepMC3::DoubleAttribute>(HepMCStr::theta);
    const double phi = (phi_A ? phi_A->value() : 0.0);
    const double theta = (theta_A ? theta_A->value() : 0.0);
    const bool is_defined = phi_A && theta_A;
    return Polarization(theta, phi, is_defined);
}

set_flow()

template<class T>

void HepMC::set_flow	(	T &	a,
		Flow	fl )

Definition at line 43 of file Flow.h.

                                                 {
    if (fl) a->add_attribute(HepMCStr::flow, std::make_shared<HepMC3::VectorIntAttribute>(*fl));
}

set_ll_event_number()

bool HepMC::set_ll_event_number ( HepMC3::GenEvent * e, long long int num )

inline

Definition at line 337 of file GenEvent.h.

                                                                     {
  e->add_attribute(HepMCStr::long_long_event_number, std::make_shared<HepMC3::LongLongAttribute>(num));
  return true;
}

set_mpi()

void HepMC::set_mpi ( GenEvent * e, const int i = 0 )

inline

Definition at line 584 of file GenEvent.h.

                                                {
    std::shared_ptr<HepMC3::IntAttribute> mpi = std::make_shared<HepMC3::IntAttribute>(i);
    e->add_attribute(HepMCStr::mpi, std::move(mpi));
}

set_polarization()

template<class T>

void HepMC::set_polarization ( T & a, const Polarization & b )

inline

Definition at line 36 of file Polarization.h.

                                                                             {
    a->add_attribute(HepMCStr::phi, std::make_shared<HepMC3::DoubleAttribute>(b.phi()));
    a->add_attribute(HepMCStr::theta, std::make_shared<HepMC3::DoubleAttribute>(b.theta()));
}

set_random_states()

void HepMC::set_random_states ( GenEvent * e, std::vector< long int > & a )

inline

Definition at line 588 of file GenEvent.h.

                                                                   {
    e->add_attribute(HepMCStr::random_states, std::make_shared<HepMC3::VectorLongIntAttribute>(a));
}

set_signal_process_id()

void HepMC::set_signal_process_id ( GenEvent * e, const int i = 0 )

inline

Definition at line 580 of file GenEvent.h.

                                                              {
    std::shared_ptr<HepMC3::IntAttribute> signal_process_id = std::make_shared<HepMC3::IntAttribute>(i);
    e->add_attribute(HepMCStr::signal_process_id, std::move(signal_process_id));
}

set_signal_process_vertex()

template<class T>

void HepMC::set_signal_process_vertex	(	GenEvent *	e,
		T &	v )

Definition at line 591 of file GenEvent.h.

                                                                     {
    if (!v || !e) return;
/* AV: HepMC2 adds the vertex to event */
    e->add_vertex(v);
    v->add_attribute(HepMCStr::signal_process_vertex, std::make_shared<HepMC3::IntAttribute>(1));
}

signal_process_id() [1/2]

int HepMC::signal_process_id ( const GenEvent & evt )

inline

Definition at line 572 of file GenEvent.h.

                                                  {
    std::shared_ptr<HepMC3::IntAttribute> A_signal_process_id = evt.attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
    return A_signal_process_id ? (A_signal_process_id->value()) : 0;
}

signal_process_id() [2/2]

int HepMC::signal_process_id ( const GenEvent * evt )

inline

Definition at line 576 of file GenEvent.h.

                                                  {
    std::shared_ptr<HepMC3::IntAttribute> A_signal_process_id = evt->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
    return A_signal_process_id ? (A_signal_process_id->value()) : 0;
}

signal_process_vertex() [1/2]

ConstGenVertexPtr HepMC::signal_process_vertex ( const GenEvent * e )

inline

Definition at line 597 of file GenEvent.h.

{ for (auto& v: e->vertices()) if (v->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_vertex)) return v; return nullptr; }

signal_process_vertex() [2/2]

GenVertexPtr HepMC::signal_process_vertex ( GenEvent * e )

inline

Definition at line 598 of file GenEvent.h.

{ for (auto& v: e->vertices()) if (v->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_vertex)) return v; return nullptr; }

simulation_history()

template<class T>

std::deque< int > HepMC::simulation_history ( const T & p, const int direction )

inline

Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle.

Definition at line 160 of file MagicNumbers.h.

{ std::deque<int> res; res.push_back(uniqueID(p)); get_particle_history(p, res, direction); return res;}

status()

template<typename T>

int HepMC::status ( const T & p )

inline

Definition at line 115 of file MagicNumbers.h.

                                                       {
    if constexpr (std::is_integral_v<T>) {
      return p;
    }
    else if constexpr (std::is_integral_v<std::remove_pointer_t<T>>) {
      return *p;
    }
    else if constexpr (std::is_pointer_v<T> || is_smart_ptr_v<T>){ //T is ptr
      return p->status();
    }
    else {
      return p.status();
    }
  }

suggest_barcode()

template<class T>

bool HepMC::suggest_barcode	(	T &	p,
		int	i )

Definition at line 607 of file GenEvent.h.

                                                     {
  if (!p->parent_event()) return false;
  auto barcodes = p->parent_event()->template attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (!barcodes) {
    barcodes = std::make_shared<GenEventBarcodes>();
    p->parent_event()->add_attribute(HepMCStr::barcodes, barcodes);
  }
  barcodes->remove(p);
  const bool ret = p->add_attribute(HepMCStr::barcode, std::make_shared<HepMC3::IntAttribute>(i));
  if (ret) barcodes->add(p);
  return ret;
}

SUPPRESSED_PILEUP_BARCODE()

int HepMC::SUPPRESSED_PILEUP_BARCODE ( std::numeric_limits< int32_t > ::max() )

constexpr

This barcode is used by objects matched to particles from pile-up interactions in standard MC Production.

uniqueID()

template<typename T>

int HepMC::uniqueID ( const T & p )

inline

Definition at line 89 of file MagicNumbers.h.

                                                         {
    if constexpr (std::is_integral_v<T>) {
      return p;
    }
    else if constexpr (std::is_integral_v<std::remove_pointer_t<T>>) {
      return *p;
    }
    else if constexpr (std::is_same_v<T, xAOD::TruthParticle_v1> || std::is_same_v<T, xAOD::TruthVertex_v1>) {
      return p.uid();
    }
    else if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, xAOD::TruthParticle_v1> || std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, xAOD::TruthVertex_v1>) {
      return p->uid();
    }
    else if constexpr (std::is_same_v<T, CaloCalibrationHit>) {
      return p.particleUID();
    }
    else if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, CaloCalibrationHit>) {
      return p->particleUID();
    }
    else if constexpr (std::is_pointer_v<T> || is_smart_ptr_v<T>){ //T is ptr
      return p->id();
    }
    else {
      return p.id();
    }
  }

valid_beam_particles()

bool HepMC::valid_beam_particles ( const GenEvent * e )

inline

Definition at line 599 of file GenEvent.h.

                                                    { 
  if (!e) return false; 
  size_t nBeams = 0;
  for (const auto& p : e->beams()) { if (p->status() == 4)  ++nBeams; }
  if  (nBeams != 2) return false; 
  return true;
}

weights_map()

std::map< std::string, std::size_t > HepMC::weights_map ( const HepMC3::GenEvent * e )

inline

Definition at line 346 of file GenEvent.h.

                                                                         {
  std::map<std::string, std::size_t>  ret;
  auto run = e->run_info();
  if (!run) return ret;
  const std::vector<std::string> names = run->weight_names();
  for (const auto& name: names) ret[name] = run->weight_index(name);
  return ret;
}

Variable Documentation

FORWARD_TRANSPORT_MODEL_PROCESS

int HepMC::FORWARD_TRANSPORT_MODEL_PROCESS = 212

constexpr

Special Forward transport Geant process for vertices.

Definition at line 50 of file MagicNumbers.h.

INVALID_PARTICLE_BARCODE

int HepMC::INVALID_PARTICLE_BARCODE = -1

constexpr

Definition at line 55 of file MagicNumbers.h.

INVALID_PARTICLE_ID

int HepMC::INVALID_PARTICLE_ID = -1

constexpr

Definition at line 58 of file MagicNumbers.h.

INVALID_VERTEX_ID

int HepMC::INVALID_VERTEX_ID = 1

constexpr

Definition at line 59 of file MagicNumbers.h.

is_smart_ptr_v

template<class T>

bool HepMC::is_smart_ptr_v = is_smart_ptr<T>::value

inlineconstexpr

Definition at line 68 of file MagicNumbers.h.

SIM_BARCODE_THRESHOLD

int HepMC::SIM_BARCODE_THRESHOLD = 200000

constexpr

Constant defining the barcode threshold for simulated particles, eg. can be used to separate generator event record entries from simulated particles.

Definition at line 38 of file MagicNumbers.h.

SIM_REGENERATION_INCREMENT

int HepMC::SIM_REGENERATION_INCREMENT = 1000000

constexpr

Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction.

Definition at line 41 of file MagicNumbers.h.

SIM_STATUS_INCREMENT

int HepMC::SIM_STATUS_INCREMENT = 100000

constexpr

Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction.

Definition at line 44 of file MagicNumbers.h.

SIM_STATUS_THRESHOLD

int HepMC::SIM_STATUS_THRESHOLD = 20000

constexpr

Constant definiting the status threshold for simulated particles, eg. can be used to separate generator event record entries from simulated particles.

Definition at line 47 of file MagicNumbers.h.

UNDEFINED_ID

int HepMC::UNDEFINED_ID = 0

constexpr

Definition at line 57 of file MagicNumbers.h.