#include <listmodus.h>

ListModus: Provides a modus for running SMASH on an external particle list, for example as an afterburner calculation.

To use this modus, choose Modus: List

General:

Modus: List

in the configuration file.

Options for ListModus go in the "Modi"→"List" section of the configuration:

Modi:
     List:
             # options here

For configuring see List.

Since SMASH is searching for collisions in computational frame time 't', all particles need to be at the same time. If this is not the case in the list provided, the particles will be propagated backwards on straight lines ("anti-freestreaming"). To avoid unphysical interactions of these particles, the back-propagated particles receive a formation_time and zero cross_section_scaling_factor. The cross-sections are set to zero during the time, where the particle will just propagate on a straight line again to appear at the formation_time into the system.

Definition at line 56 of file listmodus.h.

Inheritance diagram for smash::ListModus:

[legend]

Collaboration diagram for smash::ListModus:

[legend]

Classes
struct	LoadFailure
	Used when external particle list cannot be found. More...

Public Member Functions
	ListModus (Configuration modus_config, const ExperimentParameters &parameters)
	Constructor. More...

	ListModus ()
	Construct an empty list. Useful for convenient JetScape connection. More...

double	initial_conditions (Particles *particles, const ExperimentParameters &parameters)
	Generates initial state of the particles in the system according to a list. More...

void	backpropagate_to_same_time (Particles &particles)
	Judge whether formation times are the same for all the particles; Don't do anti-freestreaming if all particles start already at the same time. More...

void	try_create_particle (Particles &particles, PdgCode pdgcode, double t, double x, double y, double z, double mass, double E, double px, double py, double pz)
	Tries to add a new particle to particles and performs consistency checks: (i) The PDG code is legal and exists in SMASH. More...

Public Member Functions inherited from smash::ModusDefault
int	impose_boundary_conditions (Particles *, const OutputsList &={})
	Enforces sensible positions for the particles. More...

int	total_N_number () const

int	proj_N_number () const

bool	cll_in_nucleus () const

bool	is_collider () const

double	impact_parameter () const

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	length () const

Grid< GridOptions::Normal >	create_grid (const Particles &particles, double min_cell_length, double timestep_duration, CellSizeStrategy strategy=CellSizeStrategy::Optimal) const
	Creates the Grid with normal boundary conditions. More...

Protected Attributes
double	start_time_ = 0.
	Starting time for the List; changed to the earliest formation time. More...

Private Member Functions
bool	file_has_events_ (bf::path filepath, std::streampos last_position)
	Check if the file given by filepath has events left after streampos last_position. More...

bf::path	file_path_ (const int file_id)
	Return the absolute file path based on given integer. More...

std::string	next_event_ ()
	Read the next event. More...

Private Attributes
std::string	particle_list_file_directory_
	File directory of the particle list. More...

std::string	particle_list_file_prefix_
	File prefix of the particle list. More...

std::string	current_particle_list_file_
	File name of current file. More...

const int	shift_id_
	shift_id is the start number of file_id_ More...

int	event_id_
	event_id_ = the unique id of the current event More...

int	file_id_
	file_id_ is the id of the current file More...

int	n_warns_precision_ = 0
	Counter for mass-check warnings to avoid spamming. More...

int	n_warns_mass_consistency_ = 0
	Counter for energy-momentum conservation warnings to avoid spamming. More...

std::streampos	last_read_position_
	last read position in current file More...

Friends
std::ostream &	operator<< (std::ostream &, const ListModus &)
	Writes the initial state for the List to the output stream. More...

Constructor & Destructor Documentation

smash::ListModus::ListModus	(	Configuration	modus_config,
		const ExperimentParameters &	parameters
	)

explicit

Constructor.

Gathers all configuration variables for the List.

Parameters

[in]	modus_config	The configuration object that sets all initial conditions of the experiment.
[in]	parameters	Unused, but necessary because of templated initialization

Definition at line 122 of file listmodus.cc.

     : shift_id_(modus_config.take({"List", "Shift_Id"})) {
   std::string fd = modus_config.take({"List", "File_Directory"});
   particle_list_file_directory_ = fd;
 
   std::string fp = modus_config.take({"List", "File_Prefix"});
   particle_list_file_prefix_ = fp;
 
   event_id_ = 0;
   file_id_ = shift_id_;
 }

smash::ListModus::ListModus ( )

inline

Construct an empty list. Useful for convenient JetScape connection.

Definition at line 72 of file listmodus.h.

72 : shift_id_(0) {}

smash::ListModus::shift_id_

const int shift_id_

shift_id is the start number of file_id_

Definition: listmodus.h:158

Here is the call graph for this function:

Member Function Documentation

double smash::ListModus::initial_conditions	(	Particles *	particles,
		const ExperimentParameters &	parameters
	)

Generates initial state of the particles in the system according to a list.

Parameters

[out]	particles	An empty list that gets filled up by this function
[in]	parameters	Unused, but necessary because of templated use of this function

Returns: The starting time of the simulation

Exceptions

runtime_error	if an input list file could not be found
LoadFailure	if an input list file is not correctly formatted
invalid_argument	if the listed charge of a particle does not correspond to its pdg charge

Definition at line 231 of file listmodus.cc.

                                                                    {
   const auto &log = logger<LogArea::List>();
   std::string particle_list = next_event_();
 
   for (const Line &line : line_parser(particle_list)) {
     std::istringstream lineinput(line.text);
     double t, x, y, z, mass, E, px, py, pz;
     int id, charge;
     std::string pdg_string;
     lineinput >> t >> x >> y >> z >> mass >> E >> px >> py >> pz >>
         pdg_string >> id >> charge;
     if (lineinput.fail()) {
       throw LoadFailure(
           build_error_string("While loading external particle lists data:\n"
                              "Failed to convert the input string to the "
                              "expected data types.",
                              line));
     }
     PdgCode pdgcode(pdg_string);
     log.debug("Particle ", pdgcode, " (x,y,z)= (", x, ", ", y, ", ", z, ")");
 
     // Charge consistency check
     if (pdgcode.charge() != charge) {
       log.error() << "Charge of pdg = " << pdgcode << " != " << charge;
       throw std::invalid_argument("Inconsistent input (charge).");
     }
     try_create_particle(*particles, pdgcode, t, x, y, z, mass, E, px, py, pz);
   }
   backpropagate_to_same_time(*particles);
   event_id_++;
 
   return start_time_;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void smash::ListModus::backpropagate_to_same_time ( Particles & particles )

Judge whether formation times are the same for all the particles; Don't do anti-freestreaming if all particles start already at the same time.

If particles are at different times, calculate earliest formation time as start_time_ and free-stream all particles back to this time.

Parameters

particles particles to be checked and possibly back-streamed

Definition at line 141 of file listmodus.cc.

                                                                {
   /* (1) If particles are already at the same time - don't touch them
          AND start at the start_time_ from the config. */
   double earliest_formation_time = DBL_MAX;
   double formation_time_difference = 0.0;
   double reference_formation_time = 0.0;  // avoid compiler warning
   bool first_particle = true;
   for (const auto &particle : particles) {
     const double t = particle.position().x0();
     if (t < earliest_formation_time) {
       earliest_formation_time = t;
     }
     if (first_particle) {
       reference_formation_time = t;
       first_particle = false;
     } else {
       formation_time_difference += std::abs(t - reference_formation_time);
     }
   }
   /* (2) If particles are NOT at the same time -> anti-stream them to
          the earliest time (Note: not to the start_time_ set by config) */
   bool anti_streaming_needed = (formation_time_difference > really_small);
   start_time_ = earliest_formation_time;
   if (anti_streaming_needed) {
     for (auto &particle : particles) {
       /* for hydro output where formation time is different */
       const double t = particle.position().x0();
       const double delta_t = t - start_time_;
       const ThreeVector r =
           particle.position().threevec() - delta_t * particle.velocity();
       particle.set_4position(FourVector(start_time_, r));
       particle.set_formation_time(t);
       particle.set_cross_section_scaling_factor(0.0);
     }
   }
 }

Here is the caller graph for this function:

void smash::ListModus::try_create_particle	(	Particles &	particles,
		PdgCode	pdgcode,
		double	t,
		double	x,
		double	y,
		double	z,
		double	mass,
		double	E,
		double	px,
		double	py,
		double	pz
	)

Tries to add a new particle to particles and performs consistency checks: (i) The PDG code is legal and exists in SMASH.

If not, a warning is printed and the particle is ignored. (ii) The mass matches the pole mass of pdgcode in SMASH. If it does not, then a warning is printed, the pole mass of the particle is set equal to the corresponding mass from SMASH particle table and it's energy is recomputed as \( E^2 = p^2 + m^2 \). (iii) Any stable particle is on-shell, i.e. \( E^2 - p^2 = m^2 \). If it is not, then a warning is printed and the energy is set to \( E^2 = p^2 + m^2 \). This very tolerant behaviour is justified by the practical usage of SMASH as afterburner. Usually particles unknown to SMASH are rare resonances, which do not play a large role. Mass mismatch is typically less than 1% and comes from rounding and from SMASH enforcing isospin symmetry (for example the mass of neutral pion is artificially forced to be the same as charged pion). On-shellness violation typically comes from the insufficient number of significant digits in the input file + rounding.

Parameters

[in]	pdgcode	pdg code of added particle
[in]	pdgcode	pdg code of added particle
[in]	t	time of added particle
[in]	x	x-coordinate of added particle
[in]	y	y-coordinate of added particle
[in]	z	z-coordinate of added particle
[in]	mass	mass of added particle
[in]	E	energy of added particle
[in]	px	x-component of momentum of added particle
[in]	py	y-component of momentum of added particle
[in]	pz	z-component of momentum of added particle
[out]	particles	structure, to which the particle is added

Definition at line 178 of file listmodus.cc.

                                                {
   constexpr int max_warns_precision = 10, max_warn_mass_consistency = 10;
   const auto &log = logger<LogArea::List>();
   try {
     ParticleData &particle = particles.create(pdgcode);
     // SMASH mass versus input mass consistency check
     if (particle.type().is_stable() &&
         std::abs(mass - particle.pole_mass()) > really_small) {
       if (n_warns_precision_ < max_warns_precision) {
         log.warn() << "Provided mass of " << particle.type().name() << " = "
                    << mass << " [GeV] is inconsistent with SMASH value = "
                    << particle.pole_mass() << ". Forcing E = sqrt(p^2 + m^2)"
                    << ", where m is SMASH mass.";
         n_warns_precision_++;
       } else if (n_warns_precision_ == max_warns_precision) {
         log.warn(
             "Further warnings about SMASH mass versus input mass"
             " inconsistencies will be suppressed.");
         n_warns_precision_++;
       }
       particle.set_4momentum(mass, ThreeVector(px, py, pz));
     }
     particle.set_4momentum(FourVector(E, px, py, pz));
     // On-shell condition consistency check
     if (std::abs(particle.momentum().sqr() - mass * mass) > really_small) {
       if (n_warns_mass_consistency_ < max_warn_mass_consistency) {
         log.warn() << "Provided 4-momentum " << particle.momentum() << " and "
                    << " mass " << mass << " do not satisfy E^2 - p^2 = m^2."
                    << " This may originate from the lack of numerical"
                    << " precision in the input. Setting E to sqrt(p^2 + m^2).";
         n_warns_mass_consistency_++;
       } else if (n_warns_mass_consistency_ == max_warn_mass_consistency) {
         log.warn(
             "Further warnings about E != sqrt(p^2 + m^2) will"
             " be suppressed.");
         n_warns_mass_consistency_++;
       }
       particle.set_4momentum(mass, ThreeVector(px, py, pz));
     }
     // Set spatial coordinates, they will later be backpropagated if needed
     particle.set_4position(FourVector(t, x, y, z));
     particle.set_formation_time(t);
     particle.set_cross_section_scaling_factor(1.0);
   } catch (ParticleType::PdgNotFoundFailure &) {
     log.warn() << "SMASH does not recognize pdg code " << pdgcode
                << " loaded from file. This particle will be ignored.\n";
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool smash::ListModus::file_has_events_	(	bf::path	filepath,
		std::streampos	last_position
	)

private

Check if the file given by filepath has events left after streampos last_position.

Parameters

[in]	filepath	Path to file to be checked.
[in]	last_position	Streamposition in file after which check is performed

Returns: True if there is at least one event left, false otherwise

Exceptions

runtime_error If file could not be read for whatever reason.

Definition at line 333 of file listmodus.cc.

                                                              {
   const auto &log = logger<LogArea::List>();
   bf::ifstream ifs{filepath};
   std::string line;
 
   // last event read read at end of file. we know this because errors are
   // handled in next_event
   if (last_position == -1) {
     return false;
   }
   ifs.seekg(last_position);
   // skip over comment lines, assume that a max. of four consecutive comment
   // lines can occur
   int skipped_lines = 0;
   const int max_comment_lines = 4;
   while (std::getline(ifs, line) && line[0] != '#' &&
          skipped_lines++ < max_comment_lines) {
   }
 
   if (ifs.eof()) {
     return false;
   }
 
   if (!ifs.good()) {
     log.fatal() << "Error while reading " << filepath.filename().native();
     throw std::runtime_error("Error while reading external particle list");
   }
 
   ifs.close();
   return true;
 }

Here is the caller graph for this function:

bf::path smash::ListModus::file_path_ ( const int file_id )

private

Return the absolute file path based on given integer.

The filename is assumed to have the form (particle_list_prefix)_(file_id)

Parameters

[in] file_id integer of wanted file

Returns: Absolute file path to file

Exceptions

runtime_error if file does not exist.

Definition at line 266 of file listmodus.cc.

                                               {
   const auto &log = logger<LogArea::List>();
   std::stringstream fname;
   fname << particle_list_file_prefix_ << file_id;
 
   const bf::path default_path = bf::absolute(particle_list_file_directory_);
 
   const bf::path fpath = default_path / fname.str();
 
   log.debug() << fpath.filename().native() << '\n';
 
   if (!bf::exists(fpath)) {
     log.fatal() << fpath.filename().native() << " does not exist! \n"
                 << "\n Usage of smash with external particle lists:\n"
                 << "1. Put the external particle lists in file \n"
                 << "File_Directory/File_Prefix{id} where {id} "
                 << "traversal [Shift_Id, Nevent-1]\n"
                 << "2. Particles info: t x y z mass p0 px py pz"
                 << " pdg ID charge\n"
                 << "in units of: fm fm fm fm GeV GeV GeV GeV GeV"
                 << " none none none\n";
     throw std::runtime_error("External particle list does not exist!");
   }
 
   return fpath;
 }

Here is the caller graph for this function:

std::string smash::ListModus::next_event_ ( )

private

Read the next event.

Either from the current file if it has more events or from the next file (with file_id += 1)

Returns: One event as string.

Exceptions

runtime_error If file could not be read for whatever reason.

Definition at line 293 of file listmodus.cc.

                                  {
   const auto &log = logger<LogArea::List>();
 
   const bf::path fpath = file_path_(file_id_);
   bf::ifstream ifs{fpath};
   ifs.seekg(last_read_position_);
 
   if (!file_has_events_(fpath, last_read_position_)) {
     // current file out of events. get next file and call this function
     // recursively.
     file_id_++;
     last_read_position_ = 0;
     ifs.close();
     return next_event_();
   }
 
   // read one event. events marked by line # event end i in case of Oscar
   // output. Assume one event per file for all other output formats
   std::string event_string;
   const std::string needle = "end";
   std::string line;
   while (getline(ifs, line)) {
     if (line.find(needle) == std::string::npos) {
       event_string += line + "\n";
     } else {
       break;
     }
   }
 
   if (!ifs.eof() && (ifs.fail() || ifs.bad())) {
     log.fatal() << "Error while reading " << fpath.filename().native();
     throw std::runtime_error("Error while reading external particle list");
   }
   // save position for next event read
   last_read_position_ = ifs.tellg();
   ifs.close();
 
   return event_string;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

double smash::ListModus::start_time_ = 0.

protected

Starting time for the List; changed to the earliest formation time.

Definition at line 145 of file listmodus.h.

std::string smash::ListModus::particle_list_file_directory_

private

File directory of the particle list.

Definition at line 149 of file listmodus.h.

std::string smash::ListModus::particle_list_file_prefix_

private

File prefix of the particle list.

Definition at line 152 of file listmodus.h.

std::string smash::ListModus::current_particle_list_file_

private

File name of current file.

Definition at line 155 of file listmodus.h.

const int smash::ListModus::shift_id_

private

shift_id is the start number of file_id_

Definition at line 158 of file listmodus.h.

int smash::ListModus::event_id_

private

event_id_ = the unique id of the current event

Definition at line 161 of file listmodus.h.

int smash::ListModus::file_id_

private

file_id_ is the id of the current file

Definition at line 164 of file listmodus.h.

int smash::ListModus::n_warns_precision_ = 0

private

Counter for mass-check warnings to avoid spamming.

Definition at line 167 of file listmodus.h.

int smash::ListModus::n_warns_mass_consistency_ = 0

private

Counter for energy-momentum conservation warnings to avoid spamming.

Definition at line 169 of file listmodus.h.

std::streampos smash::ListModus::last_read_position_

private

last read position in current file

Definition at line 183 of file listmodus.h.

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

src/include/smash/listmodus.h
src/listmodus.cc

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation