#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 57 of file listmodus.h.

Inheritance diagram for smash::ListModus:

Classes
struct	InvalidEvents
	Used when external particle list is invalid. More...

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

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

	ListModus ()=default
	Construct an empty list. More...

double	initial_conditions (Particles *particles, const ExperimentParameters &parameters)
	Generates initial state of the particles in the system according to a list. 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, const std::vector< std::string > &optional_quantities={})
	Tries to add a new particle to particles and performs consistency checks: (i) The PDG code is legal and exists in SMASH. More...

bool	is_list () const

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

bool	is_collider () const

bool	is_box () const

bool	is_list () const

bool	is_sphere () const

double	sqrt_s_NN () const

double	impact_parameter () const

void	sample_impact () const
	sample impact parameter for collider modus More...

double	velocity_projectile () const

double	velocity_target () const

FermiMotion	fermi_motion () const

double	max_timestep (double) const

double	equilibration_time () const

double	length () const

double	radius () const

bool	calculation_frame_is_fixed_target () const

double	nuclei_passing_time () const
	Get the passing time of the two nuclei in a collision. More...

bool	is_IC_for_hybrid () const

const InitialConditionParameters &	IC_parameters () const

const std::map< int32_t, double > &	fluid_background ()

const RectangularLattice< EnergyMomentumTensor > &	fluid_lattice ()

void	build_fluidization_lattice ([[maybe_unused]] const double t, [[maybe_unused]] const std::vector< Particles > &ensembles, [[maybe_unused]] const DensityParameters &dens_par)
	Build lattice of energy momentum tensor. More...

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

std::unique_ptr< GrandCanThermalizer >	create_grandcan_thermalizer (Configuration &conf) const
	Creates GrandCanThermalizer. More...

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

Private Member Functions
void	read_particles_from_next_event_ (Particles &particles)
	Read the next event from file. More...

bool	file_has_events_ (std::filesystem::path filepath, std::streampos last_position)
	Check if the given file has events left after the given position. More...

std::filesystem::path	file_path_ (std::optional< int > file_id)
	Return the absolute path of the data file. More...

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

void	validate_list_of_particles_of_all_events_ () const
	Read and validate all events particles. More...

void	validate_optional_fields_ () const
	Validate the optional fields. More...

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

void	insert_optional_quantities_to_ (ParticleData &p, const std::vector< std::string > &optional_quantities) const
	Sets the optional fields given in the input list into a particle. More...

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

std::string	particle_list_filename_or_prefix_
	Prefix of the file(s) containing the particle list. More...

std::optional< int >	file_id_
	The id of the current file. More...

std::vector< std::string >	optional_fields_ {}
	Fields with optional quantities to be read. More...

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

std::streampos	last_read_position_ = 0
	Last read position in current file. More...

bool	warn_about_mass_discrepancy_ = true
	Auxiliary flag to warn about mass-discrepancies only once per instance. More...

bool	warn_about_off_shell_particles_ = true
	Auxiliary flag to warn about off-shell particles only once per instance. More...

SpinInteractionType	spin_interaction_type_ = SpinInteractionType::Off
	Auxiliary flag to indicate the type of spin interaction used. More...

bool	verbose_ = true
	Flag to suppress some error messages. More...

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

Constructor & Destructor Documentation

◆ ListModus() [1/2]

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	Necessary because of templated usage in Experiment

Exceptions

InvalidEvents If more than 2 particles are at the same position in any of the events.

Definition at line 42 of file listmodus.cc.

     : file_id_{std::nullopt}, event_id_{0} {
   /*
    * Make some logic on config to understand whether to extract parent or
    * children keys. These have all the same keys but have a different section
    * name (like for instance 'ListBox' instead of 'List'). At the moment there
    * is only one child and this approach is fine enough, although ugly.
    */
   const bool is_list =
       modus_config.has_value(InputKeys::modi_list_fileDirectory);
   const bool is_list_box =
       modus_config.has_value(InputKeys::modi_listBox_fileDirectory);
   if (is_list == is_list_box) {
     throw std::logic_error(
         "Unexpected error in ListModus constructor. Either List or ListBox "
         "sections must be present in configuration.");
   }
   Key<std::string> file_prefix_key = InputKeys::modi_list_filePrefix,
                    file_directory_key = InputKeys::modi_list_fileDirectory,
                    filename_key = InputKeys::modi_list_filename;
   Key<int> shift_id_key = InputKeys::modi_list_shiftId;
   Key<std::vector<std::string>> optional_quantities_key =
       InputKeys::modi_list_optionalQuantities;
   if (is_list_box) {
     file_prefix_key = InputKeys::modi_listBox_filePrefix;
     file_directory_key = InputKeys::modi_listBox_fileDirectory;
     filename_key = InputKeys::modi_listBox_filename;
     shift_id_key = InputKeys::modi_listBox_shiftId;
     optional_quantities_key = InputKeys::modi_listBox_optionalQuantities;
   }
  
   // Set the default values for the spin interaction type
   spin_interaction_type_ = param.spin_interaction_type;
  
   // Impose strict requirement on possible keys present in configuration file
   const bool file_prefix_used = modus_config.has_value(file_prefix_key);
   const bool filename_used = modus_config.has_value(filename_key);
   if (file_prefix_used == filename_used) {
     throw std::invalid_argument(
         "Either 'Filename' or 'File_Prefix' key must be used in 'Modi' section "
         "in configuration file. Please, adjust your configuration file.");
   }
   if (file_prefix_used) {
     particle_list_filename_or_prefix_ = modus_config.take(file_prefix_key);
     file_id_ = modus_config.take(shift_id_key);
   } else {
     particle_list_filename_or_prefix_ = modus_config.take(filename_key);
   }
   particle_list_file_directory_ = modus_config.take(file_directory_key);
   if (param.n_ensembles > 1) {
     throw std::runtime_error("ListModus only makes sense with one ensemble");
   }
   optional_fields_ = modus_config.take(optional_quantities_key);
   validate_list_of_particles_of_all_events_();
   validate_optional_fields_();
 }

◆ ListModus() [2/2]

smash::ListModus::ListModus ( )

default

Construct an empty list.

This is needed for children construction but it is offered as public instead of protected as it is also useful for JetScape.

Member Function Documentation

◆ initial_conditions()

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

See also: read_particles_from_next_event_ for possible exceptions thrown.

Definition at line 266 of file listmodus.cc.

                                                                    {
   read_particles_from_next_event_(*particles);
   if (particles->size() > 0) {
     backpropagate_to_same_time_if_needed_(*particles);
   } else {
     start_time_ = 0.0;
   }
   event_id_++;
  
   return start_time_;
 }

◆ try_create_particle()

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,
		const std::vector< std::string > &	optional_quantities = `{}`
	)

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 \). (iv) If there are nan values in the position or momentum of the particle an exception is thrown.

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]	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
[in]	optional_quantities	Extra values present in the input list
[out]	particles	Object to which the particle is added

Definition at line 135 of file listmodus.cc.

                                                      {
   try {
     ParticleData new_particle =
         create_valid_smash_particle_matching_provided_quantities(
             pdgcode, mass, {t, x, y, z}, {E, px, py, pz}, LList,
             warn_about_mass_discrepancy_, warn_about_off_shell_particles_);
     insert_optional_quantities_to_(new_particle, optional_quantities);
     particles.insert(new_particle);
   } catch (ParticleType::PdgNotFoundFailure &) {
     logg[LList].warn() << "SMASH does not recognize pdg code " << pdgcode
                        << " loaded from file. This particle will be ignored.\n";
   }
 }

◆ is_list()

bool smash::ListModus::is_list ( ) const

inline

Returns: whether the modus is list modus (which is, yes, trivially true)

Definition at line 148 of file listmodus.h.

148 { return true; }

◆ read_particles_from_next_event_()

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

private

Read the next event from file.

Parameters

particles The list of particles where the read information is stored

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 279 of file listmodus.cc.

                                                                     {
   std::string particle_list = next_event_();
   const std::vector<Line> event_content = line_parser(particle_list);
   if (event_content.empty()) {
     if (verbose_) {
       logg[LList].warn(
           "Encountered empty event while reading input particle lists data, "
           "which will result in empty events in the output file!");
     }
     return;
   }
   for (const Line &line : event_content) {
     std::istringstream lineinput(line.text);
     double t, x, y, z, mass, E, px, py, pz;
     std::string pdg_string;
     lineinput >> t >> x >> y >> z >> mass >> E >> px >> py >> pz >> pdg_string;
     std::vector<std::string> optional_quantities(optional_fields_.size());
     for (size_t i = 0; i < optional_fields_.size(); ++i) {
       std::string opt{};
       lineinput >> opt;
       optional_quantities[i] = std::move(opt);
     }
     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);
     logg[LList].debug("Particle ", pdgcode, " (x,y,z)= (", x, ", ", y, ", ", z,
                       ")");
  
     try_create_particle(particles, pdgcode, t, x, y, z, mass, E, px, py, pz,
                         optional_quantities);
   }
 }

◆ file_has_events_()

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

private

Check if the given file has events left after the given position.

Parameters

[in]	filepath	Path to file to be checked
[in]	last_position	Stream position 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 390 of file listmodus.cc.

                                                              {
   std::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()) {
     if (verbose_) {
       logg[LList].fatal() << "Error while reading "
                           << filepath.filename().native();
     }
     throw std::runtime_error("Error while reading external particle list");
   }
  
   ifs.close();
   return true;
 }

◆ file_path_()

std::filesystem::path smash::ListModus::file_path_ ( std::optional< int > file_id )

private

Return the absolute path of the data file.

If an integer is passed, the filename is constructed using particle_list_filename_or_prefix_ concatenated with the given number, otherwise the file prefix is understood to be the full filename. The file is expected to be in particle_list_file_directory_ folder.

Parameters

[in] file_id An std::optional integer

Returns: The absolute file path to file

Exceptions

runtime_error If file does not exist.

Definition at line 317 of file listmodus.cc.

                                                                 {
   std::string fname = particle_list_filename_or_prefix_ +
                       ((file_id) ? std::to_string(*file_id) : "");
  
   const std::filesystem::path default_path =
       std::filesystem::absolute(particle_list_file_directory_);
  
   const std::filesystem::path fpath = default_path / fname;
  
   logg[LList].debug() << "File: " << std::filesystem::absolute(fpath) << '\n';
  
   if (!std::filesystem::exists(fpath)) {
     if (verbose_) {
       logg[LList].fatal()
           << fpath.filename().native() << " does not exist! \n\n"
           << "Usage of smash with external particle lists:\n"
           << "  1. Put the external particle lists in one or more files\n"
           << "     according to the user guide instructions.\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 e\n";
     }
     throw std::runtime_error("External particle list does not exist!");
   }
  
   return fpath;
 }

◆ next_event_()

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 344 of file listmodus.cc.

                                  {
   const std::filesystem::path fpath = file_path_(file_id_);
   std::ifstream ifs{fpath};
   ifs.seekg(last_read_position_);
  
   if (!file_has_events_(fpath, last_read_position_)) {
     if (file_id_) {
       // Get next file and call this function recursively
       (*file_id_)++;
       last_read_position_ = 0;
       ifs.close();
       return next_event_();
     } else {
       throw std::runtime_error(
           "Attempt to read in next event in ListModus object but no further "
           "data found in single provided file. Please, check your setup.");
     }
   }
  
   // 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())) {
     if (verbose_) {
       logg[LList].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;
 }

◆ validate_list_of_particles_of_all_events_()

void smash::ListModus::validate_list_of_particles_of_all_events_ ( ) const

private

Read and validate all events particles.

At the moment this is done w.r.t. their positions and errors are reported if more than 2 particles have the same identical position.

Exceptions

InvalidEvents If more than 2 particles with the same identical position are found.

Definition at line 431 of file listmodus.cc.

                                                                 {
   ListModus utility_copy{*this};
   utility_copy.verbose_ = false;
   utility_copy.warn_about_mass_discrepancy_ = false;
   utility_copy.warn_about_off_shell_particles_ = false;
   bool are_there_faulty_events = false;
   while (true) {
     try {
       Particles particles{};
       utility_copy.read_particles_from_next_event_(particles);
       if (is_list_of_particles_invalid(particles, utility_copy.event_id_)) {
         are_there_faulty_events = true;
       }
       utility_copy.event_id_++;
     } catch (const std::exception &) {
       break;
     }
   }
   if (are_there_faulty_events) {
     throw InvalidEvents(
         "More than 2 particles with the same 4-position have been found in the "
         "same event.\nPlease, check your particles list file.");
   }
 }

◆ validate_optional_fields_()

void smash::ListModus::validate_optional_fields_ ( ) const

private

Validate the optional fields.

At the moment, it ensures that if at least one spin component is given, all four are given.

Exceptions

std::invalid_argument if not all spin components are given.

Definition at line 456 of file listmodus.cc.

                                                 {
   // If spin interactions are enabled, require all four spin components.
   if (spin_interaction_type_ != SpinInteractionType::Off) {
     std::array<bool, 4> has_spin{{false, false, false, false}};
     for (const auto &field : optional_fields_) {
       if (field == "spin0") {
         has_spin[0] = true;
       } else if (field == "spinx") {
         has_spin[1] = true;
       } else if (field == "spiny") {
         has_spin[2] = true;
       } else if (field == "spinz") {
         has_spin[3] = true;
       }
     }
     for (int c = 0; c < 4; ++c) {
       if (!has_spin[c]) {
         throw std::invalid_argument(
             "When spin interactions are enabled, all four spin components "
             "(spin0, spinx, spiny, spinz) must be provided in the config "
             "file.");
       }
     }
   }
 }

◆ backpropagate_to_same_time_if_needed_()

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

private

Judge whether 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 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 107 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) {
     backpropagate_straight_line(&particles, start_time_);
   }
 }

◆ insert_optional_quantities_to_()

void smash::ListModus::insert_optional_quantities_to_	(	ParticleData &	p,
		const std::vector< std::string > &	optional_quantities
	)		const

private

Sets the optional fields given in the input list into a particle.

A warning is issued if the file is not read exactly as given, which happens if, for example, a float is present in an integer-related field.

Parameters

[in]	p	particle to be modified
[in]	optional_quantities	list of values to be set

Exceptions

std::invalid_argument if the quantities in the input file do not obey the appropriate bounds.

Definition at line 152 of file listmodus.cc.

                                                            {
   if (optional_quantities.empty()) {
     return;
   } else if (optional_quantities.size() != optional_fields_.size()) {
     using namespace std::string_literals;  // NOLINT(build/namespaces)
     throw std::out_of_range("Unexpected size mismatch in "s + __func__ +
                             " between the list of optional quantities values "
                             "passed in and the class member optional_fields_");
   }
   HistoryData hist = p.get_history();
   std::ostringstream error_message{"", std::ios_base::ate};
  
   for (size_t i = 0; i < optional_fields_.size(); ++i) {
     size_t len{};
     auto field = optional_fields_[i];
     auto quantity = optional_quantities[i];
     if (field == "ID") {
       // ID information is not relevant
       continue;
     } else if (field == "charge") {
       const PdgCode pdgcode = p.pdgcode();
       const int charge = std::stoi(optional_quantities[i], &len);
       // Charge consistency check
       if (pdgcode.charge() != charge) {
         error_message << "Charge of pdg = " << pdgcode << " != " << charge
                       << ".\n";
         throw std::invalid_argument("Inconsistent input (charge).");
       }
     } else if (field == "ncoll") {
       const int ncoll = std::stoi(optional_quantities[i], &len);
       if (ncoll < 0) {
         error_message << "ncoll < 0.\n";
       }
       hist.collisions_per_particle = ncoll;
     } else if (field == "form_time") {
       p.set_formation_time(std::stod(quantity, &len));
     } else if (field == "xsecfac") {
       const double xsecfac = std::stod(quantity, &len);
       if (xsecfac < 0 || xsecfac > 1) {
         error_message << "xsecfac < 0 or xsecfac > 1.\n";
       }
       p.set_cross_section_scaling_factor(xsecfac);
     } else if (field == "proc_type") {
       const int proc_type = std::stoi(quantity, &len);
       if (!is_valid_process_type(proc_type)) {
         error_message << "Invalid proc_type.\n";
       }
       hist.process_type = static_cast<ProcessType>(proc_type);
     } else if (field == "time_last_coll") {
       const double t_last_coll = std::stod(quantity, &len);
       if (t_last_coll > p.position().x0()) {
         error_message << "time_last_coll > particle time.\n";
       }
       hist.time_last_collision = t_last_coll;
     } else if (field == "pdg_mother1") {
       if (quantity != "0") {
         if (!ParticleType::exists(PdgCode(quantity))) {
           error_message << "pdg_mother1 cannot be " << quantity << ".\n";
         }
         hist.p1 = PdgCode(quantity);
         len = quantity.size();
       }
     } else if (field == "pdg_mother2") {
       if (quantity != "0") {
         if (!ParticleType::exists(PdgCode(quantity))) {
           error_message << "pdg_mother2 cannot be " << quantity << ".\n";
         }
         hist.p2 = PdgCode(quantity);
         len = quantity.size();
       }
     } else if (field == "spin0") {
       const double s0 = std::stod(quantity, &len);
       p.set_spin_vector_component(0, s0);
     } else if (field == "spinx") {
       const double s1 = std::stod(quantity, &len);
       p.set_spin_vector_component(1, s1);
     } else if (field == "spiny") {
       const double s2 = std::stod(quantity, &len);
       p.set_spin_vector_component(2, s2);
     } else if (field == "spinz") {
       const double s3 = std::stod(quantity, &len);
       p.set_spin_vector_component(3, s3);
     } else if (field == "perturbative_weight") {
       const double weight = std::stod(quantity, &len);
       if (0 > weight || weight > 1) {
         error_message << "Perturbative weight must be between 0 and 1.\n";
       }
       p.set_perturbative_weight(weight);
     } else {
       error_message << " Unknown quantities given in the configuration.\n";
     }
     /* This is to assist the user, in case of a mistype in the inputfile.
      * We do not throw here because it may be intentional. */
     if (len != quantity.size()) {
       logg[LList].warn()
           << field << "=" << quantity
           << " not read exactly as written in the input particle list.\n";
     }
   }
  
   if (error_message.str().size() > 0) {
     logg[LList].error()
         << "The reading-in of optional quantities had the following problems:"
         << std::endl
         << error_message.str();
     throw std::invalid_argument(
         "Please fix the list of input particles and/or configuration.");
   }
   p.set_history(std::move(hist));
 }

Member Data Documentation

◆ start_time_

double smash::ListModus::start_time_ = 0.

protected

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

Definition at line 152 of file listmodus.h.

◆ particle_list_file_directory_

std::string smash::ListModus::particle_list_file_directory_

private

File directory of the particle list.

Definition at line 250 of file listmodus.h.

◆ particle_list_filename_or_prefix_

std::string smash::ListModus::particle_list_filename_or_prefix_

private

Prefix of the file(s) containing the particle list.

If the user want to use a single file without numbering, this will contain the full filename.

Definition at line 256 of file listmodus.h.

◆ file_id_

std::optional<int> smash::ListModus::file_id_

private

The id of the current file.

Definition at line 259 of file listmodus.h.

◆ optional_fields_

std::vector<std::string> smash::ListModus::optional_fields_ {}

private

Fields with optional quantities to be read.

Definition at line 262 of file listmodus.h.

◆ event_id_

int smash::ListModus::event_id_

private

The unique id of the current event.

Definition at line 264 of file listmodus.h.

◆ last_read_position_

std::streampos smash::ListModus::last_read_position_ = 0

private

Last read position in current file.

Definition at line 267 of file listmodus.h.

◆ warn_about_mass_discrepancy_

bool smash::ListModus::warn_about_mass_discrepancy_ = true

private

Auxiliary flag to warn about mass-discrepancies only once per instance.

Definition at line 270 of file listmodus.h.

◆ warn_about_off_shell_particles_

bool smash::ListModus::warn_about_off_shell_particles_ = true

private

Auxiliary flag to warn about off-shell particles only once per instance.

Definition at line 272 of file listmodus.h.

◆ spin_interaction_type_

SpinInteractionType smash::ListModus::spin_interaction_type_ = SpinInteractionType::Off

private

Auxiliary flag to indicate the type of spin interaction used.

Definition at line 275 of file listmodus.h.

◆ verbose_

bool smash::ListModus::verbose_ = true

private

Flag to suppress some error messages.

This is used during the validation of particles in all events, because there we do not know how many events exist and we simply try to read the next one till an error occurs. This triggers an error message which should not be printed to the user.

Definition at line 283 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

◆ ListModus() [1/2]

◆ ListModus() [2/2]

Member Function Documentation

◆ initial_conditions()

◆ try_create_particle()

◆ is_list()

◆ read_particles_from_next_event_()

◆ file_has_events_()

◆ file_path_()

◆ next_event_()

◆ validate_list_of_particles_of_all_events_()

◆ validate_optional_fields_()

◆ backpropagate_to_same_time_if_needed_()

◆ insert_optional_quantities_to_()

Member Data Documentation

◆ start_time_

◆ particle_list_file_directory_

◆ particle_list_filename_or_prefix_

◆ file_id_

◆ optional_fields_

◆ event_id_

◆ last_read_position_

◆ warn_about_mass_discrepancy_

◆ warn_about_off_shell_particles_

◆ spin_interaction_type_

◆ verbose_