#include <hepmcinterface.h>

Base class for output handlers that need the HepMC3 structure.

This class can write the full event info or just the initial state (i.e., beam particles) and final state (i.e., final state particle).

The class serves as a base class for output routines that utilizes the HepMC event format (currently HepMcOutput and RivetOutput).

A techincal point: We need to generate HepMC::GenParticle objects, and we need to keep track of which HepMC::GenParticle corresponds to which smash::ParticleData. We therefor set up a map from the smash::ParticleData identifier (integer) to HepMC::GenParticlePtr. We use that map to keep track of the particles and interaction points.

In case full event history:

At each interaction we create a new vertex, and add the incoming particles as "in" particles to that vertex. We also set the appropriate "state" of the incoming particles. That is, if the interaction corresponded to a decay, then the HepMC state is set to two (2). All other interactions are set to one hundred (100) plus the SMASH interaction code (since there is no standard for these codes other than 1: final state, 2: particle has decayed, 4: particle is beam particle).

For outgoing particles this is a bit different. In case of elastic scatterings, SMASH will keep the incoming particle around as an outgoing particle. This is not how the HepMC event record is invisioned. Indeed, the particle has changed momentum and that should be recorded in the event record. In that case, we therefore generate a new particle which we add as outgoing particle.

All outgoing particles of a vertex have their initial status set to one (1 - final state), but it can be changed later due to other interactions.

If the outgoing particle corresponds to an incoming particle, and in particular if the incoming particle is a beam particle (or later fragment thereof), we need to fragment the ion so that the outgoing particle is dissociated from the incoming particle. To that end, we check if the outgoing particle was part of the beam particles. If so, we remove the outgoing particle from the register of identifiers that make up the beam particle, and create a new beam particle. This ensures that the HepMC event record is sound (in most cases).

Definition at line 81 of file hepmcinterface.h.

Inheritance diagram for smash::HepMcInterface:

[legend]

Collaboration diagram for smash::HepMcInterface:

[legend]

Public Types
using	AZ = std::pair< int, int >
	Pair of Atomic weight and number. More...

Public Member Functions
	HepMcInterface (const std::string &name, const bool full_event, const int total_N, const int proj_N)
	Create HepMC particle event in memory. More...

void	at_eventstart (const Particles &particles, const int event_number, const EventInfo &event) override
	Add the initial particles information of an event to the central vertex. More...

void	at_interaction (const Action &action, const double density) override
	Writes collisions to event. More...

void	at_eventend (const Particles &particles, const int32_t event_number, const EventInfo &event) override
	Add the final particles information of an event to the central vertex. More...

Public Member Functions inherited from smash::OutputInterface
	OutputInterface (std::string name)
	Construct output interface. More...

virtual	~OutputInterface ()=default

virtual void	at_eventend (const Particles &particles, const int event_number, const EventInfo &info)=0
	Output launched at event end. More...

virtual void	at_intermediate_time (const Particles &particles, const std::unique_ptr< Clock > &clock, const DensityParameters &dens_param, const EventInfo &info)
	Output launched after every N'th timestep. More...

virtual void	thermodynamics_output (const ThermodynamicQuantity tq, const DensityType dt, RectangularLattice< DensityOnLattice > &lattice)
	Output to write thermodynamics from the lattice. More...

virtual void	thermodynamics_output (const ThermodynamicQuantity tq, const DensityType dt, RectangularLattice< EnergyMomentumTensor > &lattice)
	Output to write energy-momentum tensor and related quantities from the lattice. More...

virtual void	thermodynamics_output (const GrandCanThermalizer &gct)
	Output to write energy-momentum tensor and related quantities from the thermalizer class. More...

bool	is_dilepton_output () const
	Get, whether this is the dilepton output? More...

bool	is_photon_output () const
	Get, whether this is the photon output? More...

bool	is_IC_output () const
	Get, whether this is the IC output? More...

const char *	to_string (const ThermodynamicQuantity tq)
	Convert thermodynamic quantities to strings. More...

const char *	to_string (const DensityType dens_type)
	Convert density types to strings. More...

Protected Types
enum	Status { beam = 4, fnal = 1, dcy = 2, off = 100 }
	HepMC status codes. More...

using	IdMap = std::map< int, HepMC3::GenParticlePtr >
	Type of mapping from SMASH ID to HepMC ID. More...

using	CollCounter = std::valarray< int >
	Counter of collitions per incoming particle. More...

Protected Member Functions
void	clear ()
	Clear before an event. More...

int	get_status (const ProcessType &t) const
	Convert SMASH process type to HepMC status. More...

HepMC3::GenParticlePtr	make_gen (int pid, int status, const smash::FourVector &mom, double mass=-1)
	Make an HepMC particle. More...

HepMC3::GenParticlePtr	make_register (const ParticleData &p, int status=Status::fnal)
	Find particle in mapping or generate it. More...

HepMC3::GenParticlePtr	find_or_make (const ParticleData &p, int status=Status::fnal, bool force_new=false)
	Find particle in mapping or generate it. More...

int	ion_pdg (const AZ &az) const
	Encode ion PDG. More...

Protected Attributes
HepMC3::GenEvent	event_
	The event. More...

HepMC3::GenHeavyIonPtr	ion_
	The heavy-ion structure. More...

HepMC3::GenCrossSectionPtr	xs_
	Dummy cross-section. More...

HepMC3::GenVertexPtr	ip_
	The interaction point. More...

IdMap	map_
	Mapping from ID to particle. More...

CollCounter	coll_
	Collision counter. More...

int	ncoll_
	counter of binary collisions (e.g., where both incoming particles are from the beams. More...

int	ncoll_hard_
	counter of hard binary collisions (e.g., where both incoming particles are from the beams. More...

const int	total_N_
	Total number of nucleons in projectile and target, needed for converting nuclei to single particles. More...

const int	proj_N_
	Total number of nucleons in projectile, needed for converting nuclei to single particles. More...

bool	full_event_
	Whether the full event or only final-state particles are in the output. More...

Protected Attributes inherited from smash::OutputInterface
const bool	is_dilepton_output_
	Is this the dilepton output? More...

const bool	is_photon_output_
	Is this the photon output? More...

const bool	is_IC_output_
	Is this the IC output? More...

Member Typedef Documentation

◆ AZ

using smash::HepMcInterface::AZ = std::pair<int, int>

Pair of Atomic weight and number.

Definition at line 84 of file hepmcinterface.h.

◆ IdMap

using smash::HepMcInterface::IdMap = std::map<int, HepMC3::GenParticlePtr>

protected

Type of mapping from SMASH ID to HepMC ID.

Definition at line 137 of file hepmcinterface.h.

◆ CollCounter

using smash::HepMcInterface::CollCounter = std::valarray<int>

protected

Counter of collitions per incoming particle.

Definition at line 139 of file hepmcinterface.h.

Member Enumeration Documentation

◆ Status

enum smash::HepMcInterface::Status

protected

HepMC status codes.

Enumerator
beam
fnal
dcy
off

Definition at line 130 of file hepmcinterface.h.

               {
     beam = 4,  // Beam particle
     fnal = 1,  // final state `final` is a reserved word
     dcy = 2,   // Decay
     off = 100
   };

Constructor & Destructor Documentation

◆ HepMcInterface()

smash::HepMcInterface::HepMcInterface	(	const std::string &	name,
		const bool	full_event,
		const int	total_N,
		const int	proj_N
	)

Create HepMC particle event in memory.

Parameters

[in]	name	Name of output
[in]	full_event	Whether the full event or only final-state particles are printed in the output
[in]	total_N	Total number of particles in both nuclei.
[in]	proj_N	Number of particles in projectile.

Definition at line 18 of file hepmcinterface.cc.

     : OutputInterface(name),
       event_(HepMC3::Units::GEV, HepMC3::Units::MM),
       ion_(),
       xs_(),
       ip_(),
       total_N_(total_N),
       proj_N_(proj_N),
       full_event_(full_event) {
   logg[LOutput].debug() << "Name of output: " << name << " "
                         << (full_event_ ? "full event" : "final state only")
                         << " output" << std::endl;
   ion_ = std::make_shared<HepMC3::GenHeavyIon>();
   xs_ = std::make_shared<HepMC3::GenCrossSection>();
  
   HepMC3::Setup::set_debug_level(logg[LOutput].isEnabled<einhard::DEBUG>() ? 5
                                                                            : 0);
 }

Member Function Documentation

◆ at_eventstart()

void smash::HepMcInterface::at_eventstart	(	const Particles &	particles,
		const int	event_number,
		const EventInfo &	event
	)

overridevirtual

Add the initial particles information of an event to the central vertex.

Construct projectile and target particles with nuclear pdg code if collider.

Parameters

[in]	particles	Current list of all particles.
[in]	event_number	Current event number
[in]	event	Event information

Exceptions

std::runtime_error if nuclei with non-nucleon particle (like hypernuclei) are tried to be constructed

Implements smash::OutputInterface.

Definition at line 38 of file hepmcinterface.cc.

                                                            {
   // Clear event and mapping and set event number
   clear();
  
   // Set header stuff on event
   ion_->impact_parameter = event.impact_parameter;
   xs_->set_cross_section(1, 1);  // Dummy values
   event_.set_event_number(event_number);
   event_.set_heavy_ion(ion_);
   coll_.resize(total_N_);
  
   // Create IP only if final state
   ip_ = std::make_shared<HepMC3::GenVertex>();
   event_.add_vertex(ip_);
  
   // Count up projectile and target
   smash::FourVector p_proj;
   smash::FourVector p_targ;
   AZ az_proj;
   AZ az_targ;
   bool is_coll = proj_N_ > 0 && total_N_ > 0;
  
   for (auto& data : particles) {
     if (is_coll) {
       if (!data.is_neutron() && !data.is_proton()) {
         throw std::runtime_error(
             "Particle of PID=" + std::to_string(data.pdgcode().get_decimal()) +
             " is not a valid HepMC beam particle!");
       }
  
       bool isproj = data.id() < proj_N_;
       smash::FourVector& p = (isproj ? p_proj : p_targ);
       AZ& az = (isproj ? az_proj : az_targ);
       p += data.momentum();
       az.second += data.is_proton();
       az.first++;
     }
  
     if (!full_event_ && is_coll) {
       continue;
     }
  
     // If we are not only adding final state particles, but all
     // interactions, or not in collider modus, then we add all the
     // incoming particles as outgoing (incoming for non-collider
     // modus) of the vertex.  In that way, we will keep track of
     // participants and spectators as well as make the event
     // structure consistent.
     auto op = make_register(data, Status::fnal);
     if (is_coll) {
       ip_->add_particle_out(op);
     } else {
       ip_->add_particle_in(op);
     }
   }
   // Make beam particles
   if (is_coll) {
     auto proj = make_gen(ion_pdg(az_proj), Status::beam, p_proj);
     auto targ = make_gen(ion_pdg(az_targ), Status::beam, p_targ);
  
     // Add to interaction point if we need to
     ip_->add_particle_in(proj);
     ip_->add_particle_in(targ);
   }
 }

Here is the call graph for this function:

◆ at_interaction()

void smash::HepMcInterface::at_interaction	(	const Action &	action,
		const double	density
	)

overridevirtual

Writes collisions to event.

Parameters

[in]	action	an Action object containing incoming, outgoing particles and type of interactions.
[in]	density	Unused, needed since inherited.

Reimplemented from smash::OutputInterface.

Definition at line 106 of file hepmcinterface.cc.

                                                     {
   HepMC3::GenVertexPtr vp;
   auto type = action.get_type();
   int status = get_status(type);
  
   if (full_event_) {
     FourVector v = action.get_interaction_point();
     vp = std::make_shared<HepMC3::GenVertex>(
         HepMC3::FourVector(v.x1(), v.x2(), v.x3(), v.x0()));
     vp->add_attribute("weight", std::make_shared<HepMC3::FloatAttribute>(
                                     action.get_total_weight()));
     vp->add_attribute(
         "partial_weight",
         std::make_shared<HepMC3::FloatAttribute>(action.get_partial_weight()));
     event_.add_vertex(vp);
   }
  
   // Now mark participants
   if (full_event_) {
     for (auto& i : action.incoming_particles()) {
       // Create tree
       HepMC3::GenParticlePtr ip = find_or_make(i, status);
       ip->set_status(status);
       vp->add_particle_in(ip);
     }
   } else {
     return;
   }
  
   // Add outgoing particles
   for (auto& o : action.outgoing_particles()) {
     vp->add_particle_out(make_register(o, Status::fnal));
   }
 }

Here is the call graph for this function:

◆ at_eventend()

void smash::HepMcInterface::at_eventend	(	const Particles &	particles,
		const int32_t	event_number,
		const EventInfo &	event
	)

override

Add the final particles information of an event to the central vertex.

Store impact paramter and write event.

Parameters

[in]	particles	Current list of particles.
[in]	event_number	Number of event.
[in]	event	Event info, see event_info

Definition at line 142 of file hepmcinterface.cc.

                                                          {
   // In case this was an empty event
   if (event.empty_event) {
     clear();
     return;
   }
   /* since the number of collisions is not an experimental obervable, we set it
    * to -1.
    */
   ion_->Ncoll_hard = -1;
   ion_->Ncoll = -1;
   /* This should be the number of participants in the projectile nucleus.
    * However, to avoid confusion with the Glauber model, we prefer to set it -1.
    */
   ion_->Npart_proj = -1;
   /* his should be the number of participants in the target nucleus.
    * However, to avoid confusion with the Glauber model, we prefer to set it -1.
    */
   ion_->Npart_targ = -1;
   // If we only do final state events, then take particle
   // Note, we should already have the particles if not only final
   // state
   // Take all passed particles and add as outgoing particles to event
   for (auto& p : particles) {
     if (!full_event_) {
       auto h = make_register(p, Status::fnal);
       ip_->add_particle_out(h);
     } else if (map_.find(p.id()) == map_.end()) {
       throw std::runtime_error("Dangling particle " + std::to_string(p.id()));
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void smash::HepMcInterface::clear ( )

protected

Clear before an event.

Definition at line 177 of file hepmcinterface.cc.

                            {
   event_.clear();
   map_.clear();
   ip_ = 0;
   coll_ = 0;
   ncoll_ = 0;
   ncoll_hard_ = 0;
 }

Here is the caller graph for this function:

◆ get_status()

int smash::HepMcInterface::get_status ( const ProcessType & t ) const

protected

Convert SMASH process type to HepMC status.

Definition at line 186 of file hepmcinterface.cc.

                                                          {
   if (t == ProcessType::Decay)
     return Status::dcy;
  
   // Make all other codes SMASH specific
   return static_cast<int>(t) + static_cast<int>(Status::off);
 }

Here is the caller graph for this function:

◆ make_gen()

HepMC3::GenParticlePtr smash::HepMcInterface::make_gen	(	int	pid,
		int	status,
		const smash::FourVector &	mom,
		double	mass = `-1`
	)

protected

Make an HepMC particle.

Parameters

[in]	pid	Particle type identifier
[in]	status	Status code of particle
[in]	mom	Four momentum of particle
[in]	mass	Generator mass of particle

Returns: A shared pointer to a HepMC::GenParticle object

Definition at line 194 of file hepmcinterface.cc.

                                                              {
   auto p = std::make_shared<HepMC3::GenParticle>(
       HepMC3::FourVector(mom.x1(), mom.x2(), mom.x3(), mom.x0()), pid, status);
   if (mass > 0)
     p->set_generated_mass(mass);
   return p;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_register()

HepMC3::GenParticlePtr smash::HepMcInterface::make_register	(	const ParticleData &	p,
		int	status = `Status::fnal`
	)

protected

Find particle in mapping or generate it.

Parameters

[in]	p	ParticleData object
[in]	status	HepMC status code

Returns: r The existing or generated particle

Definition at line 204 of file hepmcinterface.cc.

                                                                  {
   int id = p.id();
   auto h = make_gen(p.pdgcode().get_decimal(), status, p.momentum(),
                     p.type().mass());
   map_[id] = h;
  
   return h;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_or_make()

HepMC3::GenParticlePtr smash::HepMcInterface::find_or_make	(	const ParticleData &	p,
		int	status = `Status::fnal`,
		bool	force_new = `false`
	)

protected

Find particle in mapping or generate it.

Parameters

[in]	p	ParticleData object
[in]	status	HepMC status code
[in]	force_new	Create new particle even if could found

Returns: r The existing or generated particle

Definition at line 214 of file hepmcinterface.cc.

                                                                     {
   int id = p.id();
   if (!force_new) {
     auto it = map_.find(id);
     if (it != map_.end()) {
       return it->second;
     }
   }
  
   return make_register(p, status);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ion_pdg()

int smash::HepMcInterface::ion_pdg ( const AZ & az ) const

protected

Encode ion PDG.

Parameters

[in] az Pair of Atomic weight and number

Returns: PDG code of ion

Definition at line 228 of file hepmcinterface.cc.

                                               {
   if (az.second == 1 && az.first == 1)
     return 2212;  // Proton
   if (az.second == 1 && az.first == 0)
     return 2112;  // Neutron
  
   return 1'000'000'000 + az.second * 10'000 + az.first * 10;
 }

Here is the caller graph for this function:

Member Data Documentation

◆ event_

HepMC3::GenEvent smash::HepMcInterface::event_

protected

The event.

Definition at line 188 of file hepmcinterface.h.

◆ ion_

HepMC3::GenHeavyIonPtr smash::HepMcInterface::ion_

protected

The heavy-ion structure.

Definition at line 190 of file hepmcinterface.h.

◆ xs_

HepMC3::GenCrossSectionPtr smash::HepMcInterface::xs_

protected

Dummy cross-section.

Definition at line 192 of file hepmcinterface.h.

◆ ip_

HepMC3::GenVertexPtr smash::HepMcInterface::ip_

protected

The interaction point.

Definition at line 194 of file hepmcinterface.h.

◆ map_

IdMap smash::HepMcInterface::map_

protected

Mapping from ID to particle.

Definition at line 196 of file hepmcinterface.h.

◆ coll_

CollCounter smash::HepMcInterface::coll_

protected

Collision counter.

For each \(i_{th}\) incoming nucleon we keep track of how many collisions that particle took in \( c_i\), classifying it as a participant if it had at least one collision. So, the total number of participants is:

\[ N_{\mathrm{part}} = \sum_i \begin{cases} 1 & c_i>0\\ 0 &c_i=0\end{cases} \]

The total number of collisions is given by the sum of the collisions of the nucleons of the incoming ion, the so called "projectile". Since we are considering the collisions between the nucleons of both ions, those of the "target" are already included in the sum.

\[ N_{\mathrm{coll}} = \sum_i^{N_{\mathrm{projectile}}} c_i\\ \]

Definition at line 217 of file hepmcinterface.h.

◆ ncoll_

int smash::HepMcInterface::ncoll_

protected

counter of binary collisions (e.g., where both incoming particles are from the beams.

Definition at line 220 of file hepmcinterface.h.

◆ ncoll_hard_

int smash::HepMcInterface::ncoll_hard_

protected

counter of hard binary collisions (e.g., where both incoming particles are from the beams.

Definition at line 223 of file hepmcinterface.h.

◆ total_N_

const int smash::HepMcInterface::total_N_

protected

Total number of nucleons in projectile and target, needed for converting nuclei to single particles.

Definition at line 228 of file hepmcinterface.h.

◆ proj_N_

const int smash::HepMcInterface::proj_N_

protected

Total number of nucleons in projectile, needed for converting nuclei to single particles.

Definition at line 233 of file hepmcinterface.h.

◆ full_event_

bool smash::HepMcInterface::full_event_

protected

Whether the full event or only final-state particles are in the output.

Definition at line 235 of file hepmcinterface.h.

The documentation for this class was generated from the following files:

src/include/smash/hepmcinterface.h
src/hepmcinterface.cc

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ AZ

◆ IdMap

◆ CollCounter

Member Enumeration Documentation

◆ Status

Constructor & Destructor Documentation

◆ HepMcInterface()

Member Function Documentation

◆ at_eventstart()

◆ at_interaction()

◆ at_eventend()

◆ clear()

◆ get_status()

◆ make_gen()

◆ make_register()

◆ find_or_make()

◆ ion_pdg()

Member Data Documentation

◆ event_

◆ ion_

◆ xs_

◆ ip_

◆ map_

◆ coll_

◆ ncoll_

◆ ncoll_hard_

◆ total_N_

◆ proj_N_

◆ full_event_