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

Adding their corresponding getter to the constructor, which extracts the value from a ParticleData instance.
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 179 of file outputformatter.h.

Public Member Functions
	OutputFormatter (const std::vector< std::string > &in_quantities)
	Creates the formatter. More...

Converter::type	binary_chunk (const ParticleData &p)
	Produces a chunk of binary representing a particle line for the output file. More...

Converter::type	data_line (const ParticleData &p) const
	Produces the line with formatted data for the body of the output file. 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...

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...

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 194 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 == "0") {  // for OSCAR1999
         getters_.push_back([this]([[maybe_unused]] const ParticleData& in) {
           return this->converter_.as_integer(0);
         });
       }
     }
   }

Member Function Documentation

◆ binary_chunk()

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, >::binary_chunk ( const ParticleData & p )

inline

Produces a chunk of binary representing a particle line for the output file.

Parameters

[in] p Particle whose information is to be written.

Returns: vector of char of the formatted data.

Definition at line 303 of file outputformatter.h.

                                                              {
     return std::accumulate(
         std::begin(getters_), std::end(getters_), std::vector<char>{},
         [&p](std::vector<char> ss, const auto& getter) {
           auto binary_data = getter(p);
           ss.insert(ss.end(), binary_data.begin(), binary_data.end());
           return ss;
         });
   }

◆ data_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, >::data_line ( const ParticleData & p ) const

inline

Produces the line with formatted data for the body of the output file.

Parameters

[in] p particle whose information is to be written.

Returns: string with formatted data separated by a space.

Definition at line 319 of file outputformatter.h.

                                                                 {
     return std::accumulate(
         std::begin(getters_), std::end(getters_), std::string{},
         [&p](const std::string& ss, const auto& getter) {
           return ss.empty() ? getter(p) : ss + " " + getter(p);
         });
   }

◆ 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.

Returns: string with name of quantities separated by a space.

Definition at line 331 of file outputformatter.h.

                                                  {
     return std::accumulate(
         std::begin(quantities_), std::end(quantities_), std::string{},
         [this](const std::string& ss, const std::string& s) {
           return ss.empty() ? this->converter_.as_string(s)
                             : ss + " " + this->converter_.as_string(s);
         });
   }

◆ 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.

Returns: string with units separated by a space.

Definition at line 344 of file outputformatter.h.

                                            {
     return std::accumulate(
         std::begin(quantities_), std::end(quantities_), std::string{},
         [this](const std::string& ss, const std::string& s) {
           return ss.empty()
                      ? this->converter_.as_string(units_.at(s))
                      : ss + " " + this->converter_.as_string(units_.at(s));
         });
   }

◆ 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 393 of file outputformatter.h.

                              {
     if (quantities_.empty()) {
       throw std::invalid_argument(
           "OutputFormatter: Empty quantities handed over to the class.");
     }
     std::string error_message{};
     std::string repeated{};
     for (const std::string& quantity : quantities_) {
       if (std::count(quantities_.begin(), quantities_.end(), quantity) > 1) {
         repeated += "'" + quantity + "',";
       }
     }
     if (!repeated.empty()) {
       error_message += "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()) {
       error_message += "Unknown \"Quantities\": " + unknown +
                        " please fix the configuration file.\n";
     }
     if (!repeated.empty() || !unknown.empty())
       throw std::invalid_argument(error_message);
  
     const bool oscar1999_id_is_given =
         std::find(quantities_.begin(), quantities_.end(), "id") !=
         quantities_.end();
     const bool oscar2013_id_is_given =
         std::find(quantities_.begin(), quantities_.end(), "ID") !=
         quantities_.end();
     if (oscar1999_id_is_given && oscar2013_id_is_given) {
       throw std::invalid_argument(
           "Both 'id' and 'ID' cannot be provided in the \"Quantities\" key "
           "together. Please, fix the configuration file.");
     }
   }

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 356 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 359 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 363 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

Initial value:

= {
      {"t", "fm"},
      {"x", "fm"},
      {"y", "fm"},
      {"z", "fm"},
      {"mass", "GeV"},
      {"p0", "GeV"},
      {"px", "GeV"},
      {"py", "GeV"},
      {"pz", "GeV"},
      {"pdg", "none"},
      {"ID", "none"},
      {"id", "none"},  
      {"charge", "e"},
      {"ncoll", "none"},
      {"form_time", "fm"},
      {"xsecfac", "none"},
      {"proc_id_origin", "none"},
      {"proc_type_origin", "none"},
      {"time_last_coll", "fm"},
      {"pdg_mother1", "none"},
      {"pdg_mother2", "none"},
      {"baryon_number", "none"},
      {"strangeness", "none"},
      {"0", "0"}}

Map with known quantities and corresponding units.

Definition at line 366 of file outputformatter.h.

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

src/include/smash/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, >

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ OutputFormatter()

Member Function Documentation

◆ binary_chunk()

◆ data_line()

◆ quantities_line()

◆ unit_line()

◆ validate_quantities()

Member Data Documentation

◆ converter_

◆ quantities_

◆ getters_

◆ units_

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, >