smash::OutputFormatter< Converter, > Class Template Reference

#include <outputformatter.h>

template<typename Converter, std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>
class smash::OutputFormatter< Converter, >

A general-purpose formatter for output, supporting both ASCII and binary formats.

This class allows the output of particle data in a flexible and configurable manner, either in human-readable ASCII format or compact binary format. It uses a template parameter Converter to determine the desired output format, which must conform to the interface of either ToASCII or ToBinary.

New quantities can be added for output by:

1. Adding their corresponding getter to the constructor, which extracts the value from a ParticleData instance.
2. Adding the proper key-value pair to the units_ map, specifying the unit of the quantity.

Template Parameters

Converter

The desired output format. At the moment it must be either ToASCII or ToBinary.

Definition at line 194 of file outputformatter.h.

Classes
struct	AliasesQuantity
	Thrown when the synonym quantities are used. More...
struct	RepeatedQuantity
	Thrown when the same quantity is repeated. More...
struct	UnknownQuantity
	Thrown when a not existing quantity is used. More...

Public Member Functions
	OutputFormatter (const std::vector< std::string > &in_quantities)
	Creates the formatter. More...
std::size_t	compute_single_size (const ParticleData &sample) const
	Computes and returns the total size of the formatted representation of a single particle using all registered getters. More...
Converter::type	single_particle_data (const ParticleData &p) const
	Produces a line of data representing a single particle suitable for writing to an output file. More...
template<class Range , std::enable_if_t< std::is_same_v< Range, Particles >||std::is_same_v< Range, ParticleList >, bool > = true>
Converter::type	particles_data_chunk (const Range &particles) const
	Builds multiple particle lines for a range of particles by appending the Converter::type representation of each particle into a single buffer. More...
Converter::type	quantities_line () const
	Produces the line with quantities for the header of the output file. More...
Converter::type	unit_line () const
	Produces the line with units for the header of the output file. More...

Private Member Functions
void	validate_quantities ()
	Checks whether the quantities requested are known and unique. More...
void	append_to_buffer (const ParticleData &particle, typename Converter::type &buffer) const
	Appends the Converter::type representation of a single particle to the provided buffer. More...

Private Attributes
Converter	converter_ {}
	Member to convert data into the correct output format. More...
std::vector< std::string >	quantities_ {}
	List of quantities to be written. More...
std::vector< std::function< typename Converter::type(const ParticleData &)> >	getters_ {}
	List of getters to extract output data from the ParticleData object. More...
const std::map< std::string, std::string >	units_
	Map with known quantities and corresponding units. More...
const std::vector< std::pair< std::string, std::string > >	aliases_
	Map with known quantities and corresponding units. More...

Constructor & Destructor Documentation

OutputFormatter()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

smash::OutputFormatter< Converter, >::OutputFormatter ( const std::vector< std::string > &  in_quantities )

inlineexplicit

Creates the formatter.

This reduces the number of literal strings flying around in the codebase, and since this is called only once per output file, in the beginning of the run, there is almost no efficiency lost compared to having fixed strings.

Parameters

[in]

in_quantities

list of quantities to be output.

Exceptions

std::invalid_argument	if the list of quantities is empty
std::invalid_argument	if unknown quantities exist in the list
std::invalid_argument	if incompatible quantities exist in the list
std::invalid_argument	if there are repeated quantities

Definition at line 209 of file outputformatter.h.

      : quantities_(in_quantities) {
    validate_quantities();
    for (const std::string& quantity : quantities_) {
      if (quantity == "t") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.position()[0]);
        });
      } else if (quantity == "x") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.position()[1]);
        });
      } else if (quantity == "y") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.position()[2]);
        });
      } else if (quantity == "z") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.position()[3]);
        });
      } else if (quantity == "mass") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.effective_mass());
        });
      } else if (quantity == "p0") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_precise_double(in.momentum()[0]);
        });
      } else if (quantity == "px") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_precise_double(in.momentum()[1]);
        });
      } else if (quantity == "py") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_precise_double(in.momentum()[2]);
        });
      } else if (quantity == "pz") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_precise_double(in.momentum()[3]);
        });
      } else if (quantity == "pdg") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.pdgcode().get_decimal());
        });
      } else if (quantity == "ID" || quantity == "id") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.id());
        });
      } else if (quantity == "charge") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.type().charge());
        });
      } else if (quantity == "ncoll") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(
              in.get_history().collisions_per_particle);
        });
      } else if (quantity == "form_time") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.formation_time());
        });
      } else if (quantity == "xsecfac") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.xsec_scaling_factor());
        });
      } else if (quantity == "proc_id_origin") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.get_history().id_process);
        });
      } else if (quantity == "proc_type_origin") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(
              static_cast<int>(in.get_history().process_type));
        });
      } else if (quantity == "time_last_coll") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(
              in.get_history().time_last_collision);
        });
      } else if (quantity == "pdg_mother1") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.get_history().p1.get_decimal());
        });
      } else if (quantity == "pdg_mother2") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.get_history().p2.get_decimal());
        });
      } else if (quantity == "baryon_number") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.pdgcode().baryon_number());
        });
      } else if (quantity == "strangeness") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_integer(in.pdgcode().strangeness());
        });
      } else if (quantity == "spin0") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.spin_vector()[0]);
        });
      } else if (quantity == "spinx") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.spin_vector()[1]);
        });
      } else if (quantity == "spiny") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.spin_vector()[2]);
        });
      } else if (quantity == "spinz") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.spin_vector()[3]);
        });
      } else if (quantity == "0") {  // for OSCAR1999
        getters_.push_back([this]([[maybe_unused]] const ParticleData& in) {
          return this->converter_.as_integer(0);
        });
      } else if (quantity == "tau") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.hyperbolic_time());
        });
      } else if (quantity == "eta" || quantity == "eta_s") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.spatial_rapidity());
        });
      } else if (quantity == "mt") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.transverse_mass());
        });
      } else if (quantity == "Rap" || quantity == "y_rap") {
        // "Rap" is used for compatibility with vHLLE
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.rapidity());
        });
      } else if (quantity == "perturbative_weight") {
        getters_.push_back([this](const ParticleData& in) {
          return this->converter_.as_double(in.perturbative_weight());
        });
      }
    }
  }

Member Function Documentation

compute_single_size()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

std::size_t smash::OutputFormatter< Converter, >::compute_single_size ( const ParticleData &  sample ) const

inline

Computes and returns the total size of the formatted representation of a single particle using all registered getters.

The total size consists of:

• the sum of the sizes of all field strings (from each getter),
• (n - 1) separator characters if a separator is defined, since separators appear only between fields, not after the last one,
• one end-of-line character if an end-of-line marker is defined.

Parameters

[in]

sample

A representative particle used to compute the size.

Returns

Total size of the formatted representation of one particle.

Definition at line 362 of file outputformatter.h.

                                                                  {
    const std::size_t n = getters_.size();
    if (n == 0) {
      return 0;
    }
    std::size_t size = 0;
    for (const auto& getter : getters_) {
      const typename Converter::type tmp = getter(sample);
      size += tmp.size();
    }
 
    if (Converter::separator.has_value()) {
      size += (n - 1);
    }
 
    if (Converter::end_of_line.has_value()) {
      size += 1;
    }
 
    return size;
  }

single_particle_data()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

Converter::type smash::OutputFormatter< Converter, >::single_particle_data ( const ParticleData &  p ) const

inline

Produces a line of data representing a single particle suitable for writing to an output file.

Parameters

[in]

p

Particle whose information is to be written.

Returns

A buffer containing the formatted data.

See also

append_to_buffer

Definition at line 392 of file outputformatter.h.

                                                                           {
    typename Converter::type chunk{};
    append_to_buffer(p, chunk);
    return chunk;
  }

particles_data_chunk()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

template<class Range , std::enable_if_t< std::is_same_v< Range, Particles >||std::is_same_v< Range, ParticleList >, bool > = true>

Converter::type smash::OutputFormatter< Converter, >::particles_data_chunk ( const Range &  particles ) const

inline

Builds multiple particle lines for a range of particles by appending the Converter::type representation of each particle into a single buffer.

The resulting buffer reflects exactly what the Converter defines( per-record separators and end-of-line markers, if any). No additional formatting is applied beyond what the Converter specifies.

Template Parameters

Range

Container type — constrained to Particles or ParticleList.

Parameters

[in]

particles

Container of particles whose data should be formatted and added to the buffer

Returns

Converter::type A buffer containing the concatenated representation of all particles in the block.

Note

Capacity is reserved using a size estimate based on the first element.

See also

append_to_buffer

Returns

Converter::type

Definition at line 424 of file outputformatter.h.

                                                                            {
    typename Converter::type chunk{};
    if (particles.size() == 0)
      return chunk;
 
    chunk.reserve(particles.size() * compute_single_size(particles.front()));
 
    for (const ParticleData& p : particles) {
      append_to_buffer(p, chunk);
    }
    return chunk;
  }

quantities_line()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

Converter::type smash::OutputFormatter< Converter, >::quantities_line ( ) const

inline

Produces the line with quantities for the header of the output file.

Appends each quantity name to the output buffer, separating them by the separator character if it is defined in the Converter. End of line character is added last if defined.

Returns

Converter::type

Definition at line 446 of file outputformatter.h.

                                                 {
    typename Converter::type out{};
 
    // Educated size guess to reduce the number of reallocations in push_backs:
    out.reserve(quantities_.size() * 5);
 
    for (const auto& string_name : quantities_) {
      if constexpr (Converter::separator) {
        if (!out.empty()) {
          out.push_back(*Converter::separator);
        }
      }
      typename Converter::type name = converter_.as_string(string_name);
      out.insert(out.end(), name.begin(), name.end());
    }
    if constexpr (Converter::end_of_line) {
      out.push_back(*Converter::end_of_line);
    }
    return out;
  }

unit_line()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

Converter::type smash::OutputFormatter< Converter, >::unit_line ( ) const

inline

Produces the line with units for the header of the output file.

Looks up each quantity’s unit in the units_ map and appends it to the output buffer. Each unit is separated by the separator character if defined. End of line character is added last if defined.

Returns

Converter::type

Definition at line 476 of file outputformatter.h.

                                           {
    typename Converter::type out{};
 
    // Educated size guess to reduce the number of reallocations in push_backs:
    out.reserve(quantities_.size() * 5);
 
    for (const auto& key : quantities_) {
      if constexpr (Converter::separator) {
        if (!out.empty()) {
          out.push_back(*Converter::separator);
        }
      }
      const auto& unit = converter_.as_string(units_.at(key));
      out.insert(out.end(), unit.begin(), unit.end());
    }
    if constexpr (Converter::end_of_line) {
      out.push_back(*Converter::end_of_line);
    }
    return out;
  }

validate_quantities()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

void smash::OutputFormatter< Converter, >::validate_quantities ( )

inlineprivate

Checks whether the quantities requested are known and unique.

Definition at line 575 of file outputformatter.h.

                             {
    if (quantities_.empty()) {
      throw std::invalid_argument(
          "OutputFormatter: Empty quantities handed over to the class.");
    }
    std::string repeated{};
    for (const std::string& quantity : quantities_) {
      if (std::count(quantities_.begin(), quantities_.end(), quantity) > 1) {
        repeated += "'" + quantity + "',";
      }
    }
    if (!repeated.empty()) {
      throw RepeatedQuantity("Repeated \"Quantities\": " + repeated +
                             " please fix the configuration file.\n");
    }
    std::string unknown{};
    for (const std::string& quantity : quantities_) {
      if (units_.count(quantity) == 0) {
        unknown += "'" + quantity + "',";
      }
    }
    if (!unknown.empty()) {
      throw UnknownQuantity("Unknown \"Quantities\": " + unknown +
                            " please fix the configuration file.\n");
    }
    for (const auto& alias : aliases_) {
      const bool first_quantity_is_given =
          std::find(quantities_.begin(), quantities_.end(), alias.first) !=
          quantities_.end();
      const bool second_quantity_is_given =
          std::find(quantities_.begin(), quantities_.end(), alias.second) !=
          quantities_.end();
      if (first_quantity_is_given && second_quantity_is_given) {
        throw AliasesQuantity(
            "Both '" + alias.first + "' and '" + alias.second +
            "' cannot be provided in the \"Quantities\" key together. Please, "
            "fix the configuration file.");
      }
    }
  }

append_to_buffer()

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

void smash::OutputFormatter< Converter, >::append_to_buffer ( const ParticleData &  particle, typename Converter::type &  buffer  ) const

inlineprivate

Appends the Converter::type representation of a single particle to the provided buffer.

The buffer is used exactly as provided by the caller; no assumptions or modifications are made to its initial state or capacity.

Parameters

[in]	particle	Particle whose information is to be appended.
[out]	buffer	Destination buffer to which the converted data is appended.

Definition at line 628 of file outputformatter.h.

                                                              {
    for (std::size_t i = 0; i < getters_.size(); ++i) {
      if constexpr (Converter::separator) {
        if (i > 0)
          buffer.push_back(*Converter::separator);
      }
      auto data = getters_[i](particle);
      buffer.insert(buffer.end(), std::make_move_iterator(data.begin()),
                    std::make_move_iterator(data.end()));
    }
    if constexpr (Converter::end_of_line) {
      buffer.push_back(*Converter::end_of_line);
    }
  }

Member Data Documentation

converter_

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

Converter smash::OutputFormatter< Converter, >::converter_ {}

private

Member to convert data into the correct output format.

Definition at line 523 of file outputformatter.h.

quantities_

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

std::vector<std::string> smash::OutputFormatter< Converter, >::quantities_ {}

private

List of quantities to be written.

Definition at line 526 of file outputformatter.h.

getters_

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

std::vector<std::function<typename Converter::type(const ParticleData&)> > smash::OutputFormatter< Converter, >::getters_ {}

private

List of getters to extract output data from the ParticleData object.

Definition at line 530 of file outputformatter.h.

units_

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

const std::map<std::string, std::string> smash::OutputFormatter< Converter, >::units_

private

Map with known quantities and corresponding units.

Definition at line 533 of file outputformatter.h.

aliases_

template<typename Converter , std::enable_if_t< std::is_same_v< Converter, ToASCII >||std::is_same_v< Converter, ToBinary >, bool > = true>

const std::vector<std::pair<std::string, std::string> > smash::OutputFormatter< Converter, >::aliases_

private

Initial value:

= {
      {"ID", "id"}, {"eta_s", "eta"}, {"y_rap", "Rap"}}

Map with known quantities and corresponding units.

Definition at line 571 of file outputformatter.h.

---

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

• src/include/smash/outputformatter.h