smash::ListModus Class Reference

#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:

Collaboration diagram for smash::ListModus:

Classes
struct	LoadFailure

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...
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...
int	total_N_number () const
int	proj_N_number () const
bool	cll_in_nucleus () const
bool	is_collider () const
bool	is_box () const
bool	is_list () const
double	sqrt_s_NN () const
double	impact_parameter () const
double	velocity_projectile () const
double	velocity_target () const
FermiMotion	fermi_motion () const
double	max_timestep (double) const
double	equilibration_time () const
double	nuclei_passing_time () const
	Get the passing time of the two nuclei in a collision. More...
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 &)

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	Unused, but necessary because of templated initialization

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

ListModus() [2/2]

smash::ListModus::ListModus ( )

inline

Construct an empty list. Useful for convenient JetScape connection.

Definition at line 72 of file listmodus.h.

: shift_id_(0) {}

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

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

                                                                   {
  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);
    logg[LList].debug("Particle ", pdgcode, " (x,y,z)= (", x, ", ", y, ", ", z,
                      ")");
 
    // Charge consistency check
    if (pdgcode.charge() != charge) {
      logg[LList].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);
  }
  if (particles->size() > 0) {
    backpropagate_to_same_time(*particles);
  } else {
    start_time_ = 0.0;
  }
  event_id_++;
 
  return start_time_;
}

Here is the call graph for this function:

backpropagate_to_same_time()

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 135 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:

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
	)

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

                                               {
  constexpr int max_warns_precision = 10, max_warn_mass_consistency = 10;
  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) {
        logg[LList].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) {
        logg[LList].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) {
        logg[LList].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) {
        logg[LList].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 &) {
    logg[LList].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:

is_list()

bool smash::ListModus::is_list ( ) const

inline

Returns

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

Definition at line 143 of file listmodus.h.

{ return true; }

file_has_events_()

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

                                                             {
  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()) {
    logg[LList].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:

file_path_()

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.

                                              {
  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();
 
  logg[LList].debug() << fpath.filename().native() << '\n';
 
  if (!bf::exists(fpath)) {
    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 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 e\n";
    throw std::runtime_error("External particle list does not exist!");
  }
 
  return fpath;
}

Here is the caller graph for this function:

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

                                 {
  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())) {
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 147 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 151 of file listmodus.h.

particle_list_file_prefix_

std::string smash::ListModus::particle_list_file_prefix_

private

File prefix of the particle list.

Definition at line 154 of file listmodus.h.

current_particle_list_file_

std::string smash::ListModus::current_particle_list_file_

private

File name of current file.

Definition at line 157 of file listmodus.h.

shift_id_

const int smash::ListModus::shift_id_

private

shift_id is the start number of file_id_

Definition at line 160 of file listmodus.h.

event_id_

int smash::ListModus::event_id_

private

event_id_ = the unique id of the current event

Definition at line 163 of file listmodus.h.

file_id_

int smash::ListModus::file_id_

private

file_id_ is the id of the current file

Definition at line 166 of file listmodus.h.

n_warns_precision_

int smash::ListModus::n_warns_precision_ = 0

private

Counter for mass-check warnings to avoid spamming.

Definition at line 169 of file listmodus.h.

n_warns_mass_consistency_

int smash::ListModus::n_warns_mass_consistency_ = 0

private

Counter for energy-momentum conservation warnings to avoid spamming.

Definition at line 171 of file listmodus.h.

last_read_position_

std::streampos smash::ListModus::last_read_position_

private

last read position in current file

Definition at line 185 of file listmodus.h.

---

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

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