HepMC Namespace Reference

Namespaces
	BarcodeBased
	Print
	StatusBased

Classes
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 GenParticle *	GenParticlePtr
typedef const GenParticle *	ConstGenParticlePtr
typedef HepMC::GenVertex *	GenVertexPtr
typedef const HepMC::GenVertex *	ConstGenVertexPtr
typedef HepMC::PdfInfo *	GenPdfInfoPtr
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, int >::value, bool > = true>
int	barcode (const T &p)
template<class T >
int	flow (const T &a, int i)
template<class T >
Flow	flow (const T &a)
bool	set_ll_event_number (HepMC::GenEvent *e, long long int num)
long long int	get_ll_event_number (const HepMC::GenEvent *e)
GenEvent::particle_iterator	begin (HepMC::GenEvent &e)
GenEvent::particle_iterator	end (HepMC::GenEvent &e)
GenEvent::particle_const_iterator	begin (const HepMC::GenEvent &e)
GenEvent::particle_const_iterator	end (const HepMC::GenEvent &e)
GenEvent *	newGenEvent (const int a, const int b)
GenVertex *	signal_process_vertex (const GenEvent *e)
void	fillBarcodesAttribute (GenEvent *)
GenVertex *	barcode_to_vertex (const GenEvent *e, int id)
GenParticle *	barcode_to_particle (const GenEvent *e, int id)
int	mpi (const GenEvent &e)
int	mpi (const GenEvent *e)
int	signal_process_id (const GenEvent &e)
int	signal_process_id (const GenEvent *e)
void	set_signal_process_id (GenEvent *e, const int i)
void	set_mpi (GenEvent *e, const int i)
template<class T >
void	set_random_states (GenEvent *e, std::vector< T > a)
template<class T >
void	set_signal_process_vertex (GenEvent *e, T v)
GenEvent *	copyemptyGenEvent (const GenEvent *inEvt)
template<class T >
bool	suggest_barcode (T &p, int i)
template<class T >
bool	suggest_barcode (T *p, int i)
template<>
bool	suggest_barcode< std::unique_ptr< HepMC::GenParticle > > (std::unique_ptr< HepMC::GenParticle > &p, int i)
bool	valid_beam_particles (const GenEvent *e)
GenParticlePtr	newGenParticlePtr (const HepMC::FourVector &mom=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), int pid=0, int status=0)
int	barcode_or_id (const ConstGenParticlePtr &p)
std::ostream &	operator<< (std::ostream &os, const GenParticle *p)
GenVertex::particles_out_const_iterator	begin (const HepMC::GenVertex &v)
GenVertex::particles_out_const_iterator	end (const HepMC::GenVertex &v)
GenVertexPtr	newGenVertexPtr (const HepMC::FourVector &pos=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), const int i=0)
int	barcode_or_id (const ConstGenVertexPtr &p)
std::ostream &	operator<< (std::ostream &os, const GenVertex *v)
template<class T >
void	set_polarization (T &a, Polarization b)
template<class T >
Polarization	polarization (const T &a)
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. More...
template<typename T >
int	uniqueID (const T &p)
template<typename T >
int	status (const T &p)
template<>
int	status (const ConstGenVertexPtr &v1)
template<>
int	status (const GenVertexPtr &v1)
template<class T >
void	get_particle_history (const T &p, std::deque< int > &out, int direction=0)
	Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle. More...
template<class T >
std::deque< int >	simulation_history (const T &p, int direction)
	Function to calculate all the descendants(direction=1)/ancestors(direction=-1) of the particle. More...
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) 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 (TODO update to be status based) 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 (or barcode) was created during the simulation (TODO update to be status based) More...
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). More...
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). 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_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...
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). More...
int	new_particle_status_from_old (int oldStatus, int barcode)
	Functions for converting between the old and new barcode/status schemes. More...
int	old_particle_status_from_new (int newStatus)
int	new_vertex_status_from_old (int oldStatus, int barcode)
int	old_vertex_status_from_new (int newStatus)
int	maxGeneratedParticleBarcode (const HepMC::GenEvent *genEvent)
int	maxGeneratedVertexBarcode (const HepMC::GenEvent *genEvent)

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. More...
constexpr int	SIM_REGENERATION_INCREMENT = 1000000
	Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction. More...
constexpr int	SIM_STATUS_INCREMENT = 100000
	Constant defining the barcode threshold for regenerated particles, i.e. particles surviving an interaction. More...
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. More...
constexpr int	SPECIALSTATUS = 902
	Constant that the meaning of which is currently lost, to be recovered... More...
constexpr int	EVTGENUNDECAYEDSTATUS = 899
constexpr int	PYTHIA8LHESTATUS = 1003
constexpr int	HERWIG7INTERMEDIATESTATUS = 11
constexpr int	PYTHIA8NOENDVERTEXSTATUS = 201
constexpr int	FORWARDTRANSPORTMODELSTATUS = 212
constexpr int	INVALID_PARTICLE_BARCODE = -1
constexpr int	SINGLE_PARTICLE = 10001
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 const GenParticle * HepMC::ConstGenParticlePtr

Definition at line 38 of file GenParticle.h.

ConstGenVertexPtr

typedef const HepMC::GenVertex * HepMC::ConstGenVertexPtr

Definition at line 60 of file GenVertex.h.

GenParticlePtr

typedef GenParticle * HepMC::GenParticlePtr

Definition at line 37 of file GenParticle.h.

GenPdfInfoPtr

typedef HepMC::PdfInfo* HepMC::GenPdfInfoPtr

Definition at line 17 of file PdfInfo.h.

GenVertexPtr

typedef HepMC::GenVertex * HepMC::GenVertexPtr

Definition at line 59 of file GenVertex.h.

remove_smart_pointer_t

template<class T >

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

Definition at line 74 of file MagicNumbers.h.

Function Documentation

barcode() [1/3]

template<class T , std::enable_if_t<!std::is_pointer< T >::value &&!std::is_same< T, int >::value, bool > = true>

int HepMC::barcode ( const T &  p )

inline

Definition at line 57 of file Barcode.h.

{ return p.barcode();}

barcode() [2/3]

template<class T >

int HepMC::barcode ( const T *  p )

inline

Definition at line 16 of file Barcode.h.

{ return p->barcode(); }

barcode() [3/3]

int HepMC::barcode ( int  p )

inline

Definition at line 17 of file Barcode.h.

{ return p; }

barcode_or_id() [1/2]

int HepMC::barcode_or_id ( const ConstGenParticlePtr &  p )

inline

Definition at line 42 of file GenParticle.h.

{ return p->barcode();}

barcode_or_id() [2/2]

int HepMC::barcode_or_id ( const ConstGenVertexPtr &  p )

inline

Definition at line 71 of file GenVertex.h.

{ return p->barcode();}

barcode_to_particle()

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

inline

Definition at line 506 of file GenEvent.h.

{return  e->barcode_to_particle(id);}

barcode_to_vertex()

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

inline

Definition at line 505 of file GenEvent.h.

{return  e->barcode_to_vertex(id);}

begin() [1/3]

GenEvent::particle_const_iterator HepMC::begin ( const HepMC::GenEvent &  e )

inline

Definition at line 500 of file GenEvent.h.

{ return e.particles_begin(); }

begin() [2/3]

GenVertex::particles_out_const_iterator HepMC::begin ( const HepMC::GenVertex &  v )

inline

Definition at line 61 of file GenVertex.h.

{ return v.particles_out_const_begin(); }

begin() [3/3]

GenEvent::particle_iterator HepMC::begin ( HepMC::GenEvent &  e )

inline

Definition at line 498 of file GenEvent.h.

{ return e.particles_begin(); }

copyemptyGenEvent()

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

inline

Definition at line 531 of file GenEvent.h.

                                                          {
    HepMC::GenEvent* outEvt = new HepMC::GenEvent( inEvt->signal_process_id(),  inEvt->event_number() );
    outEvt->set_mpi  ( inEvt->mpi() );
    outEvt->set_event_scale  ( inEvt->event_scale() );
    outEvt->set_alphaQCD     ( inEvt->alphaQCD() );
    outEvt->set_alphaQED     ( inEvt->alphaQED() );
    outEvt->weights() =        inEvt->weights();
    outEvt->set_random_states( inEvt->random_states() );
    if ( nullptr != inEvt->heavy_ion() ) {
      outEvt->set_heavy_ion    ( *inEvt->heavy_ion() );
    }
    if ( nullptr != inEvt->pdf_info() ) {
      outEvt->set_pdf_info     ( *inEvt->pdf_info() );
    }
    return outEvt;
}

end() [1/3]

GenEvent::particle_const_iterator HepMC::end ( const HepMC::GenEvent &  e )

inline

Definition at line 501 of file GenEvent.h.

{ return e.particles_end(); }

end() [2/3]

GenVertex::particles_out_const_iterator HepMC::end ( const HepMC::GenVertex &  v )

inline

Definition at line 62 of file GenVertex.h.

{ return v.particles_out_const_end(); }

end() [3/3]

GenEvent::particle_iterator HepMC::end ( HepMC::GenEvent &  e )

inline

Definition at line 499 of file GenEvent.h.

{ return e.particles_end(); }

fillBarcodesAttribute()

void HepMC::fillBarcodesAttribute ( GenEvent *  )

inline

Definition at line 504 of file GenEvent.h.

{ }

flow() [1/2]

template<class T >

Flow HepMC::flow

(

const T &

a

)

Definition at line 52 of file Flow.h.

{return a->flow();}

flow() [2/2]

template<class T >

int HepMC::flow	(	const T &	a,
		int	i
	)

Definition at line 51 of file Flow.h.

{return a->flow(i);}

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 302 of file MagicNumbers.h.

{ return BarcodeBased::generations(p);}

get_ll_event_number()

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

inline

Definition at line 495 of file GenEvent.h.

                                                                {
  return e->event_number();
}

get_particle_history()

template<class T >

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

inline

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

Definition at line 156 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->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->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 296 of file MagicNumbers.h.

{ 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 309 of file MagicNumbers.h.

{ return BarcodeBased::is_same_generator_particle(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 313 of file MagicNumbers.h.

{ return BarcodeBased::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 299 of file MagicNumbers.h.

{ return BarcodeBased::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 305 of file MagicNumbers.h.

{ return BarcodeBased::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 290 of file MagicNumbers.h.

{ return BarcodeBased::is_truth_suppressed_pileup(p); }

maxGeneratedParticleBarcode()

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

inline

Definition at line 361 of file MagicNumbers.h.

                                                                       {
  int maxBarcode=0;
#ifdef HEPMC3
  auto allbarcodes = genEvent->attribute<HepMC::GenEventBarcodes>("barcodes");
  for (const auto& bp: allbarcodes->barcode_to_particle_map()) {
    if (!HepMC::BarcodeBased::is_simulation_particle(bp.first)) { maxBarcode=std::max(maxBarcode,bp.first); }
  }
#else
  for (auto currentGenParticle: *genEvent) {
    const int barcode=HepMC::barcode(currentGenParticle);
    if (barcode > maxBarcode &&  !HepMC::BarcodeBased::is_simulation_particle(barcode)) { maxBarcode=barcode; }
  }
#endif
  return maxBarcode;
}

maxGeneratedVertexBarcode()

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

inline

Definition at line 377 of file MagicNumbers.h.

                                                                    {
  int maxBarcode=0;
#ifdef HEPMC3
  auto allbarcodes = genEvent->attribute<HepMC::GenEventBarcodes>("barcodes");
  for (const auto& bp: allbarcodes->barcode_to_vertex_map()) {
    if (!HepMC::BarcodeBased::is_simulation_vertex(bp.first)) { maxBarcode=std::min(maxBarcode,bp.first); }
  }
#else
  HepMC::GenEvent::vertex_const_iterator currentGenVertexIter;
  for (currentGenVertexIter= genEvent->vertices_begin();
       currentGenVertexIter!= genEvent->vertices_end();
       ++currentGenVertexIter) {
    const int barcode((*currentGenVertexIter)->barcode());
    if (barcode < maxBarcode && !HepMC::BarcodeBased::is_simulation_vertex(barcode)) { maxBarcode=barcode; }
  }
#endif
  return maxBarcode;
}

mpi() [1/2]

int HepMC::mpi ( const GenEvent &  e )

inline

Definition at line 507 of file GenEvent.h.

                                  {
    return e.mpi();
}

mpi() [2/2]

int HepMC::mpi ( const GenEvent *  e )

inline

Definition at line 510 of file GenEvent.h.

                                  {
    return e->mpi();
}

new_particle_status_from_old()

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

inline

Functions for converting between the old and new barcode/status schemes.

Definition at line 345 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 ( int  oldStatus, int  barcode  )

inline

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

newGenEvent()

GenEvent* HepMC::newGenEvent ( const int  a, const int  b  )

inline

Definition at line 502 of file GenEvent.h.

{ return new GenEvent(a,b); }

newGenParticlePtr()

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

inline

Definition at line 39 of file GenParticle.h.

                                                                                                                                    {
    return new HepMC::GenParticle(mom,pid,status);
}

newGenVertexPtr()

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

inline

Definition at line 64 of file GenVertex.h.

                                                                                                                  {
    return new HepMC::GenVertex(pos,i);
}

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 (TODO update to be status based)

Definition at line 293 of file MagicNumbers.h.

{ return BarcodeBased::no_truth_link(p);} // TODO potentially this could become id()==0?

old_particle_status_from_new()

int HepMC::old_particle_status_from_new ( int  newStatus )

inline

Definition at line 349 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 316 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;
    };
#ifdef HEPMC3
    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()));
    }
#else
    for (auto p = evt->particles_begin(); p != evt->particles_end(); ++p) {
      (*p)->set_status (particle_status ((*p)->barcode(), (*p)->status()));
    }
    for (auto v = evt->vertices_begin(); v != evt->vertices_end(); ++v)  {
      (*v)->set_id (vertex_status ((*v)->barcode(), (*v)->id()));
    }
#endif
  }

old_vertex_status_from_new()

int HepMC::old_vertex_status_from_new ( int  newStatus )

inline

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

operator<<() [1/2]

std::ostream& HepMC::operator<< ( std::ostream &  os, const GenParticle *  p  )

inline

Definition at line 47 of file GenParticle.h.

{ if (p) return os<<(*p); else return os;}

operator<<() [2/2]

std::ostream& HepMC::operator<< ( std::ostream &  os, const GenVertex *  v  )

inline

Definition at line 72 of file GenVertex.h.

{ if (v) return os<<(*v); else return os;}

polarization()

template<class T >

Polarization HepMC::polarization ( const T &  a )

inline

Definition at line 47 of file Polarization.h.

                                                                {
    return a->polarization();
}

set_ll_event_number()

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

inline

Definition at line 490 of file GenEvent.h.

                                                                    {
  if (num > std::numeric_limits<int>::max()) return false;
  e->set_event_number((int)num);
  return true;
}

set_mpi()

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

inline

Definition at line 522 of file GenEvent.h.

                                              {
    e->set_mpi(i);
}

set_polarization()

template<class T >

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

inline

Definition at line 44 of file Polarization.h.

                                                                        {
    a->set_polarization(b);
}

set_random_states()

template<class T >

void HepMC::set_random_states	(	GenEvent *	e,
		std::vector< T >	a
	)

Definition at line 525 of file GenEvent.h.

                                                                       {
    e->set_random_states(a);
}

set_signal_process_id()

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

inline

Definition at line 519 of file GenEvent.h.

                                                            {
    e->set_signal_process_id(i);
}

set_signal_process_vertex()

template<class T >

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

Definition at line 528 of file GenEvent.h.

                                                                    {
    e->set_signal_process_vertex(v);
}

signal_process_id() [1/2]

int HepMC::signal_process_id ( const GenEvent &  e )

inline

Definition at line 513 of file GenEvent.h.

                                                {
    return e.signal_process_id();
}

signal_process_id() [2/2]

int HepMC::signal_process_id ( const GenEvent *  e )

inline

Definition at line 516 of file GenEvent.h.

                                                {
    return e->signal_process_id();
}

signal_process_vertex()

GenVertex* HepMC::signal_process_vertex ( const GenEvent *  e )

inline

Definition at line 503 of file GenEvent.h.

{ return e->signal_process_vertex(); }

simulation_history()

template<class T >

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

inline

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

Definition at line 185 of file MagicNumbers.h.

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

status() [1/3]

template<>

int HepMC::status ( const ConstGenVertexPtr &  v1 )

inline

Definition at line 151 of file MagicNumbers.h.

{ return v1->id();}

status() [2/3]

template<>

int HepMC::status ( const GenVertexPtr &  v1 )

inline

Definition at line 152 of file MagicNumbers.h.

{ return v1->id();}

status() [3/3]

template<typename T >

int HepMC::status ( const T &  p )

inline

Definition at line 130 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::TruthVertex_v1>) {
      return p.id();
    }
    else if constexpr (std::is_same_v<std::remove_const_t<remove_smart_pointer_t<std::remove_pointer_t<T>>>, xAOD::TruthVertex_v1>) {
      return p->id();
    }
    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() [1/2]

template<class T >

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

Definition at line 548 of file GenEvent.h.

{return p.suggest_barcode(i);}

suggest_barcode() [2/2]

template<class T >

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

Definition at line 549 of file GenEvent.h.

{return p->suggest_barcode(i);}

suggest_barcode< std::unique_ptr< HepMC::GenParticle > >()

template<>

bool HepMC::suggest_barcode< std::unique_ptr< HepMC::GenParticle > > ( std::unique_ptr< HepMC::GenParticle > &  p, int  i  )

inline

Definition at line 551 of file GenEvent.h.

{return p->suggest_barcode(i);}

SUPPRESSED_PILEUP_BARCODE()

constexpr 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 113 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->barcode();
    }
    else {
      return p.barcode();
    }
  }

valid_beam_particles()

bool HepMC::valid_beam_particles ( const GenEvent *  e )

inline

Definition at line 559 of file GenEvent.h.

{return e->valid_beam_particles();}

Variable Documentation

EVTGENUNDECAYEDSTATUS

constexpr int HepMC::EVTGENUNDECAYEDSTATUS = 899

constexpr

Definition at line 42 of file MagicNumbers.h.

FORWARDTRANSPORTMODELSTATUS

constexpr int HepMC::FORWARDTRANSPORTMODELSTATUS = 212

constexpr

Definition at line 46 of file MagicNumbers.h.

HERWIG7INTERMEDIATESTATUS

constexpr int HepMC::HERWIG7INTERMEDIATESTATUS = 11

constexpr

Definition at line 44 of file MagicNumbers.h.

INVALID_PARTICLE_BARCODE

constexpr int HepMC::INVALID_PARTICLE_BARCODE = -1

constexpr

Definition at line 51 of file MagicNumbers.h.

INVALID_PARTICLE_ID

constexpr int HepMC::INVALID_PARTICLE_ID = -1

constexpr

Definition at line 56 of file MagicNumbers.h.

INVALID_VERTEX_ID

constexpr int HepMC::INVALID_VERTEX_ID = 1

constexpr

Definition at line 57 of file MagicNumbers.h.

is_smart_ptr_v

template<class T >

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

inlineconstexpr

Definition at line 67 of file MagicNumbers.h.

PYTHIA8LHESTATUS

constexpr int HepMC::PYTHIA8LHESTATUS = 1003

constexpr

Definition at line 43 of file MagicNumbers.h.

PYTHIA8NOENDVERTEXSTATUS

constexpr int HepMC::PYTHIA8NOENDVERTEXSTATUS = 201

constexpr

Definition at line 45 of file MagicNumbers.h.

SIM_BARCODE_THRESHOLD

constexpr 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 29 of file MagicNumbers.h.

SIM_REGENERATION_INCREMENT

constexpr int HepMC::SIM_REGENERATION_INCREMENT = 1000000

constexpr

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

Definition at line 32 of file MagicNumbers.h.

SIM_STATUS_INCREMENT

constexpr int HepMC::SIM_STATUS_INCREMENT = 100000

constexpr

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

Definition at line 35 of file MagicNumbers.h.

SIM_STATUS_THRESHOLD

constexpr 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 38 of file MagicNumbers.h.

SINGLE_PARTICLE

constexpr int HepMC::SINGLE_PARTICLE = 10001

constexpr

Definition at line 53 of file MagicNumbers.h.

SPECIALSTATUS

constexpr int HepMC::SPECIALSTATUS = 902

constexpr

Constant that the meaning of which is currently lost, to be recovered...

Definition at line 41 of file MagicNumbers.h.

UNDEFINED_ID

constexpr int HepMC::UNDEFINED_ID = 0

constexpr

Definition at line 55 of file MagicNumbers.h.