Logging Classes and Functions

The interfaces in this group are used for debug and informational console output.

SMASH uses the einhard logging library for debug and info/warn/error output to stdout. This library builds upon the C++ ostream classes and thus uses stream operators for converting objects into a text representation.

The einhard library supports named output streams (which simply means they automatically add the name to the prefix string). We use this feature to define log areas in SMASH that can be configured independently. The einhard::Logger class supports two options: colorization and verbosity. For colorization we stay with the default of auto-detecting a color-terminal. For verbosity we use a Configuration object to set the verbosity of each area independently. This way we have control over the amount of debug output at runtime and without the need to touch the code/recompile.

To output something from your code do the following:

logg[LAreaName].trace(source_location);
logg[LAreaName].debug("particle", p);
logg[LAreaName].warn("Something happened.");

Note that LAreaName needs to be declared within the smash namespace of the respective file in a form of (using PauliBlocking as an example area):

static constexpr int LPauliBlocking = LogArea::PauliBlocking::id;

The einhard::Logger class supports two ways of writing to an output stream: Use stream operators or pass the list of objects for output as parameters. Thus

log.debug("particle: ", p);

and

log.debug() << "particle: " << p;

are equivalent (except for a small optimization opportunity in the former variant, that could make it slightly more efficient). You can see, though, that the former variant is more concise and often much easier to type than the stream operators.

Classes
struct	smash::LogArea::Main
	Log area tag type. More...
struct	smash::LogArea::Experiment
	Log area tag type. More...
struct	smash::LogArea::Box
	Log area tag type. More...
struct	smash::LogArea::Collider
	Log area tag type. More...
struct	smash::LogArea::Sphere
	Log area tag type. More...
struct	smash::LogArea::Action
	Log area tag type. More...
struct	smash::LogArea::InputParser
	Log area tag type. More...
struct	smash::LogArea::ParticleType
	Log area tag type. More...
struct	smash::LogArea::FindScatter
	Log area tag type. More...
struct	smash::LogArea::Clock
	Log area tag type. More...
struct	smash::LogArea::DecayModes
	Log area tag type. More...
struct	smash::LogArea::Resonances
	Log area tag type. More...
struct	smash::LogArea::ScatterAction
	Log area tag type. More...
struct	smash::LogArea::Distributions
	Log area tag type. More...
struct	smash::LogArea::Propagation
	Log area tag type. More...
struct	smash::LogArea::Grid
	Log area tag type. More...
struct	smash::LogArea::List
	Log area tag type. More...
struct	smash::LogArea::Nucleus
	Log area tag type. More...
struct	smash::LogArea::Density
	Log area tag type. More...
struct	smash::LogArea::PauliBlocking
	Log area tag type. More...
struct	smash::LogArea::Tmn
	Log area tag type. More...
struct	smash::LogArea::Fpe
	Log area tag type. More...
struct	smash::LogArea::Lattice
	Log area tag type. More...
struct	smash::LogArea::Pythia
	Log area tag type. More...
struct	smash::LogArea::GrandcanThermalizer
	Log area tag type. More...
struct	smash::LogArea::CrossSections
	Log area tag type. More...
struct	smash::LogArea::Output
	Log area tag type. More...
struct	smash::LogArea::HyperSurfaceCrossing
	Log area tag type. More...
struct	smash::LogArea::InitialConditions
	Log area tag type. More...
struct	smash::LogArea::ScatterActionMulti
	Log area tag type. More...
struct	smash::LogArea::Configuration
	Log area tag type. More...
struct	smash::LogArea::Potentials
	Log area tag type. More...
struct	smash::LogArea::RootSolver
	Log area tag type. More...
struct	smash::FormattingHelper< T >
struct	YAML::convert< einhard::LogLevel >
struct	smash::PrintParticleListDetailed

Macros
#define	DECLARE_LOGAREA(id__, name__)
	Declares the necessary interface to identify a new log area. More...
#define	SMASH_SOURCE_LOCATION    __FILE__ ":" + std::to_string(__LINE__) + " (" + __func__ + ')'
	Hackery that is required to output the location in the source code where the log statement occurs. More...

Typedefs
using	smash::LogArea::AreaTuple = std::tuple< Main, Experiment, Box, Collider, Sphere, Action, InputParser, ParticleType, FindScatter, Clock, DecayModes, Resonances, ScatterAction, Distributions, Propagation, Grid, List, Nucleus, Density, PauliBlocking, Tmn, Fpe, Lattice, Pythia, GrandcanThermalizer, CrossSections, Output, HyperSurfaceCrossing, InitialConditions, ScatterActionMulti, Configuration, Potentials, RootSolver >
	This type collects all existing log areas so they will be created with the correct log level automatically. More...

Functions
virtual void	smash::Action::format_debug_output (std::ostream &out) const =0
	Writes information about this action to the out stream. More...
std::ostream &	smash::operator<< (std::ostream &out, const ActionPtr &action)
	Convenience: dereferences the ActionPtr to Action. More...
std::ostream &	smash::operator<< (std::ostream &out, const ActionList &actions)
	Writes multiple actions to the out stream. More...
std::ostream &	smash::operator<< (std::ostream &out, const Angles &a)
	Creates output for an Angles object in the form "φ: 0.1294, cos ϑ: 0.423". More...
void	smash::DecayAction::format_debug_output (std::ostream &out) const override
	Writes information about this decay action to the out stream. More...
std::ostream &	smash::operator<< (std::ostream &out, const EnergyMomentumTensor &Tmn)
	Prints out 4x4 tensor to the output stream. More...
std::ostream &	smash::operator<< (std::ostream &os, const FourVector &vec)
	Writes the four components of the vector to the output stream. More...
template<int w = 9, int p = w - 3, typename CharT , typename Traits >
std::basic_ostream< CharT, Traits > &	smash::field (std::basic_ostream< CharT, Traits > &s)
	Stream modifier to align the next object to a specific width w. More...
void	smash::create_all_loggers (Configuration config)
	Called from main() right after the Configuration object is fully set up to create all logger objects (as defined by LogArea::AreaTuple) with the correct area names and log levels. More...
einhard::LogLevel	smash::default_loglevel ()
void	smash::set_default_loglevel (einhard::LogLevel level)
	Set the default log level (what will be returned from subsequent default_loglevel calls). More...
template<typename T >
FormattingHelper< T >	smash::format (const T &value, const char *unit, int width=-1, int precision=-1)
	Acts as a stream modifier for std::ostream to output an object with an optional suffix string and with a given field width and precision. More...
std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > &	smash::get_loggers ()
	Return the globally shared logger array. More...
static Node	YAML::convert< einhard::LogLevel >::encode (const einhard::LogLevel &x)
	Convert from einhard::LogLevel to YAML::Node. More...
static bool	YAML::convert< einhard::LogLevel >::decode (const Node &node, einhard::LogLevel &x)
	Convert from YAML::Node to einhard::LogLevel. More...
std::ostream &	smash::operator<< (std::ostream &s, const ParticleData &p)
	Writes the state of the particle to the output stream. More...
std::ostream &	smash::operator<< (std::ostream &out, const ParticleList &particle_list)
	Writes a compact overview over the particles in the particle_list argument to the stream. More...
PrintParticleListDetailed	smash::detailed (const ParticleList &list)
	Request the ParticleList to be printed in full detail (i.e. More...
std::ostream &	smash::operator<< (std::ostream &out, const PrintParticleListDetailed &particle_list)
	Writes a detailed overview over the particles in the particle_list argument to the stream. More...
std::ostream &	smash::operator<< (std::ostream &is, const PdgCode &code)
	Writes the textual representation of the PDG code to the output stream. More...
std::ostream &	smash::operator<< (std::ostream &os, ProcessType process_type)
	Writes the textual representation of the process_type to the output stream os. More...
std::ostream &	smash::operator<< (std::ostream &os, const CollisionBranch &cbranch)
	Writes the textual representation of the Collision Branch cbranch to the output stream os. More...
void	smash::ScatterAction::format_debug_output (std::ostream &out) const override
	Writes information about this scatter action to the out stream. More...
std::ostream &	smash::operator<< (std::ostream &, const ThreeVector &)
	Writes the three components of the vector to the output stream. More...

Variables
const T &	smash::FormattingHelper< T >::value
	Value that is being formatted. More...
const int	smash::FormattingHelper< T >::width
	Output width. More...
const int	smash::FormattingHelper< T >::precision
	Precision that value is being formatted with. More...
const char *const	smash::FormattingHelper< T >::unit
	Unit that is attached at the end of value. More...
std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > &	smash::logg = get_loggers()
	An array that stores all pre-configured Logger objects. More...

Friends
std::ostream &	smash::Action::operator<< (std::ostream &out, const Action &action)
	Dispatches formatting to the virtual Action::format_debug_output function. More...
std::ostream &	smash::BoxModus::operator<< (std::ostream &out, const BoxModus &m)
	Console output on startup of box specific parameters; writes the initial state for the box to the output stream. More...
std::ostream &	smash::ColliderModus::operator<< (std::ostream &, const ColliderModus &)
	Writes the initial state for the ColliderModus to the output stream. More...
std::ostream &	smash::Experiment< Modus >::operator<< (std::ostream &out, const Experiment &e)
	Writes the initial state for the Experiment to the output stream. More...
std::ostream &	smash::ListModus::operator<< (std::ostream &out, const ListModus &m)
	Writes the initial state for the List to the output stream. More...
std::ostream &	smash::FormattingHelper< T >::operator<< (std::ostream &out, const FormattingHelper &h)
	Nicely formatted output. More...
std::ostream &	smash::Nucleus::operator<< (std::ostream &, const Nucleus &)
	Writes the state of the Nucleus object to the output stream. More...
std::ostream &	smash::Particles::operator<< (std::ostream &out, const Particles &particles)
	Print effective mass and type name for all particles to the stream. More...
std::ostream &	smash::ParticleType::operator<< (std::ostream &out, const ParticleType &type)
	Writes all information about the particle type to the output stream. More...
std::ostream &	smash::SphereModus::operator<< (std::ostream &out, const SphereModus &m)
	Writes the initial state for the Sphere to the output stream. More...

Macro Definition Documentation

DECLARE_LOGAREA

#define DECLARE_LOGAREA	(		id__,
			name__
	)

Value:

  struct name__ {                                                         \
    static constexpr int id = id__;                                       \
    static constexpr const char *textual() { return #name__; }            \
    static constexpr int textual_length() { return sizeof(#name__) - 1; } \
  }

Declares the necessary interface to identify a new log area.

Definition at line 75 of file logging.h.

SMASH_SOURCE_LOCATION

#define SMASH_SOURCE_LOCATION    __FILE__ ":" + std::to_string(__LINE__) + " (" + __func__ + ')'

Hackery that is required to output the location in the source code where the log statement occurs.

Definition at line 153 of file logging.h.

Typedef Documentation

AreaTuple

using smash::LogArea::AreaTuple = typedef std::tuple<Main, Experiment, Box, Collider, Sphere, Action, InputParser, ParticleType, FindScatter, Clock, DecayModes, Resonances, ScatterAction, Distributions, Propagation, Grid, List, Nucleus, Density, PauliBlocking, Tmn, Fpe, Lattice, Pythia, GrandcanThermalizer, CrossSections, Output, HyperSurfaceCrossing, InitialConditions, ScatterActionMulti, Configuration, Potentials, RootSolver>

This type collects all existing log areas so they will be created with the correct log level automatically.

Definition at line 129 of file logging.h.

Function Documentation

format_debug_output() [1/3]

virtual void smash::Action::format_debug_output ( std::ostream &  out ) const

protectedpure virtual

Writes information about this action to the out stream.

Parameters

[out]

out

out stream to be written to

Implemented in smash::WallcrossingAction, smash::ThermalizationAction, smash::ScatterActionMulti, smash::ScatterAction, smash::FreeforallAction, smash::FluidizationAction, and smash::DecayAction.

operator<<() [1/12]

std::ostream& smash::operator<< ( std::ostream &  out, const ActionPtr &  action  )

inline

Convenience: dereferences the ActionPtr to Action.

Definition at line 546 of file action.h.

                                                                        {
  return out << *action;
}

operator<<() [2/12]

std::ostream & smash::operator<<	(	std::ostream &	out,
		const ActionList &	actions
	)

Writes multiple actions to the out stream.

Definition at line 400 of file action.cc.

                                                                   {
  out << "ActionList {\n";
  for (const auto &a : actions) {
    out << "- " << a << '\n';
  }
  return out << '}';
}

operator<<() [3/12]

std::ostream& smash::operator<< ( std::ostream &  out, const Angles &  a  )

inline

Creates output for an Angles object in the form "φ: 0.1294, cos ϑ: 0.423".

Definition at line 195 of file angles.h.

                                                                {
  return out << "φ:" << field << a.phi() << ", cos ϑ:" << field << a.costheta();
}

Here is the call graph for this function:

format_debug_output() [2/3]

void smash::DecayAction::format_debug_output ( std::ostream &  out ) const

overrideprotectedvirtual

Writes information about this decay action to the out stream.

Implements smash::Action.

Definition at line 202 of file decayaction.cc.

                                                           {
  out << "Decay of " << incoming_particles_ << " to " << outgoing_particles_
      << ", sqrt(s)=" << format(sqrt_s(), "GeV", 11, 9);
}

Here is the call graph for this function:

operator<<() [4/12]

std::ostream & smash::operator<<	(	std::ostream &	out,
		const EnergyMomentumTensor &	Tmn
	)

Prints out 4x4 tensor to the output stream.

Parameters

[in]	out	Location of output
[in]	Tmn	Energy-momentum tensor

Definition at line 162 of file energymomentumtensor.cc.

                                                                         {
  out.width(12);
  for (size_t mu = 0; mu < 4; mu++) {
    for (size_t nu = 0; nu < 4; nu++) {
      out << std::setprecision(3) << std::setw(12) << std::fixed
          << Tmn[EnergyMomentumTensor::tmn_index(mu, nu)];
    }
    out << std::endl;
  }
  return out;
}

Here is the call graph for this function:

operator<<() [5/12]

std::ostream & smash::operator<<	(	std::ostream &	os,
		const FourVector &	vec
	)

Writes the four components of the vector to the output stream.

Parameters

[in]	os	The ostream into which to output
[in]	vec	The FourVector to write into os

Definition at line 37 of file fourvector.cc.

                                                               {
  out.put('(');
  out.fill(' ');
  for (auto x : vec) {
    out << field<8> << x;
  }
  return out << ')';
}

field()

template<int w = 9, int p = w - 3, typename CharT , typename Traits >

std::basic_ostream<CharT, Traits>& smash::field ( std::basic_ostream< CharT, Traits > &  s )

inline

Stream modifier to align the next object to a specific width w.

Template Parameters

w	The number of characters the field should have in the output.
p	The floating precision.
CharT	Character type of the output stream.
Traits	Traits of the output stream.

Parameters

[in,out]

s

The output stream.

Returns

The output stream.

Definition at line 30 of file iomanipulators.h.

                                        {
  s.put(s.widen(' '));
  s.setf(std::ios_base::fixed, std::ios_base::floatfield);
  s.width(w);
  s.precision(p);
  return s;
}

Here is the caller graph for this function:

create_all_loggers()

void smash::create_all_loggers

(

Configuration

config

)

Called from main() right after the Configuration object is fully set up to create all logger objects (as defined by LogArea::AreaTuple) with the correct area names and log levels.

Parameters

config

A configuration object with the log area names as toplevel keys.

Definition at line 115 of file logging.cc.

                                              {
  create_all_loggers_impl<std::tuple_size<LogArea::AreaTuple>::value>(config);
}

Here is the caller graph for this function:

default_loglevel()

einhard::LogLevel smash::default_loglevel

(

)

Returns

The default log level to use if no specific level is configured.

Definition at line 23 of file logging.cc.

{ return global_default_loglevel; }

set_default_loglevel()

void smash::set_default_loglevel

(

einhard::LogLevel

level

)

Set the default log level (what will be returned from subsequent default_loglevel calls).

Parameters

level

The new log level. See einhard::LogLevel.

Definition at line 25 of file logging.cc.

                                                 {
  global_default_loglevel = level;
}

Here is the caller graph for this function:

format()

template<typename T >

FormattingHelper<T> smash::format	(	const T &	value,
		const char *	unit,
		int	width = -1,
		int	precision = -1
	)

Acts as a stream modifier for std::ostream to output an object with an optional suffix string and with a given field width and precision.

Template Parameters

T	Value that is being formatted.

Parameters

value	The object to be written to the stream.
unit	An optional suffix string, typically used for a unit. May be nullptr.
width	The field width to use for value.
precision	The precision to use for value.

Definition at line 217 of file logging.h.

                                               {
  return {value, width, precision, unit};
}

Here is the caller graph for this function:

get_loggers()

std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > & smash::get_loggers

(

)

Return the globally shared logger array.

The array is initialized on first use to avoid static initialization order issues across translation units.

Definition at line 30 of file logging.cc.

                   {
  static std::array<einhard::Logger<>,
                    std::tuple_size<LogArea::AreaTuple>::value>
      logg_instance;
  return logg_instance;
}

encode()

static Node YAML::convert< einhard::LogLevel >::encode ( const einhard::LogLevel &  x )

inlinestatic

Convert from einhard::LogLevel to YAML::Node.

Parameters

x	Log level.

Returns

Corresponding YAML node.

Definition at line 262 of file logging.h.

                                               {
    return Node{einhard::getLogLevelString(x)};
  }

Here is the call graph for this function:

decode()

static bool YAML::convert< einhard::LogLevel >::decode ( const Node &  node, einhard::LogLevel &  x  )

inlinestatic

Convert from YAML::Node to einhard::LogLevel.

Parameters

[in]	node	YAML node.
[out]	x	Where the corresponding log level will be stored if the conversion was successful.

Returns

Whether the conversion was successful.

Definition at line 274 of file logging.h.

                                                           {
    if (!node.IsScalar()) {
      return false;
    } else {
      x = einhard::getLogLevel(node.Scalar());
      return true;
    }
  }

Here is the call graph for this function:

operator<<() [6/12]

std::ostream & smash::operator<<	(	std::ostream &	s,
		const ParticleData &	p
	)

Writes the state of the particle to the output stream.

Definition at line 171 of file particledata.cc.

                                                               {
  out.fill(' ');
  return out << p.type().name() << " (" << std::setw(5) << p.type().pdgcode()
             << ")" << std::right << "{id:" << field<6> << p.id()
             << ", process:" << field<4> << p.id_process()
             << ", pos [fm]:" << p.position() << ", mom [GeV]:" << p.momentum()
             << ", formation time [fm]:" << p.formation_time()
             << ", cross section scaling factor:" << p.xsec_scaling_factor()
             << "}";
}

operator<<() [7/12]

std::ostream & smash::operator<<	(	std::ostream &	out,
		const ParticleList &	particle_list
	)

Writes a compact overview over the particles in the particle_list argument to the stream.

Definition at line 182 of file particledata.cc.

                                                                           {
  auto column = out.tellp();
  out << '[';
  for (const auto &p : particle_list) {
    if (out.tellp() - column >= 201) {
      out << '\n';
      column = out.tellp();
      out << ' ';
    }
    out << std::setw(5) << std::setprecision(3) << p.momentum().abs3()
        << p.type().name();
  }
  return out << ']';
}

detailed()

PrintParticleListDetailed smash::detailed ( const ParticleList &  list )

inline

Request the ParticleList to be printed in full detail (i.e.

one full ParticleData printout per line).

Definition at line 599 of file particledata.h.

                                                                    {
  return {list};
}

operator<<() [8/12]

std::ostream & smash::operator<<	(	std::ostream &	out,
		const PrintParticleListDetailed &	particle_list
	)

Writes a detailed overview over the particles in the particle_list argument to the stream.

This overload is selected via the function detailed.

Definition at line 197 of file particledata.cc.

                                                                         {
  bool first = true;
  out << '[';
  for (const auto &p : particle_list.list) {
    if (first) {
      first = false;
    } else {
      out << "\n ";
    }
    out << p;
  }
  return out << ']';
}

operator<<() [9/12]

std::ostream & smash::operator<<	(	std::ostream &	is,
		const PdgCode &	code
	)

Writes the textual representation of the PDG code to the output stream.

Definition at line 119 of file pdgcode.cc.

                                                           {
  return s << code.string();
}

Here is the call graph for this function:

operator<<() [10/12]

std::ostream & smash::operator<<	(	std::ostream &	os,
		ProcessType	process_type
	)

Writes the textual representation of the process_type to the output stream os.

Definition at line 106 of file processbranch.cc.

                                                                 {
  switch (process_type) {
    case ProcessType::None:
      os << "None";
      break;
    case ProcessType::Elastic:
      os << "Elastic";
      break;
    case ProcessType::TwoToOne:
      os << "TwoToOne";
      break;
    case ProcessType::TwoToTwo:
      os << "TwoToTwo";
      break;
    case ProcessType::TwoToThree:
      os << "TwoToThree";
      break;
    case ProcessType::TwoToFour:
      os << "TwoToFour";
      break;
    case ProcessType::TwoToFive:
      os << "TwoToFive";
      break;
    case ProcessType::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
      os << "SoftStringExcitation";
      break;
    case ProcessType::StringHardNonDiffractive:
    case ProcessType::StringHardSingleDiffractiveAX:
    case ProcessType::StringHardSingleDiffractiveXB:
    case ProcessType::StringHardDoubleDiffractive:
      os << "HardStringExcitation";
      break;
    case ProcessType::Decay:
      os << "Decay";
      break;
    case ProcessType::Wall:
      os << "Wall";
      break;
    case ProcessType::Thermalization:
      os << "Thermalization";
      break;
    case ProcessType::Fluidization:
    case ProcessType::FluidizationNoRemoval:
      os << "Fluidization";
      break;
    case ProcessType::MultiParticleThreeMesonsToOne:
      os << "ThreeMesonsToOne";
      break;
    case ProcessType::MultiParticleThreeToTwo:
      os << "ThreeToTwo";
      break;
    case ProcessType::MultiParticleFourToTwo:
      os << "FourToTwo";
      break;
    case ProcessType::MultiParticleFiveToTwo:
      os << "FiveToTwo";
      break;
    case ProcessType::Freeforall:
      os << "Freeforall";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}

operator<<() [11/12]

std::ostream & smash::operator<<	(	std::ostream &	os,
		const CollisionBranch &	cbranch
	)

Writes the textual representation of the Collision Branch cbranch to the output stream os.

Definition at line 64 of file processbranch.cc.

                                                                       {
  ProcessType ptype = cbranch.get_type();
  if (ptype == ProcessType::StringSoftSingleDiffractiveAX ||
      ptype == ProcessType::StringSoftSingleDiffractiveXB) {
    os << "soft-1-diff";
  } else if (ptype == ProcessType::StringSoftDoubleDiffractive) {
    os << "soft-2-diff";
  } else if (ptype == ProcessType::StringSoftAnnihilation) {
    os << "soft-BBbar";
  } else if (ptype == ProcessType::StringSoftNonDiffractive) {
    os << "soft-non-diff";
  } else if (ptype == ProcessType::StringHardNonDiffractive) {
    os << "hard-non-diff";
  } else if (ptype == ProcessType::StringHardSingleDiffractiveXB ||
             ptype == ProcessType::StringHardSingleDiffractiveAX) {
    os << "hard-1-diff";
  } else if (ptype == ProcessType::StringHardDoubleDiffractive) {
    os << "hard-2-diff";
  } else if (ptype == ProcessType::TwoToOne || ptype == ProcessType::TwoToTwo ||
             ptype == ProcessType::TwoToThree ||
             ptype == ProcessType::TwoToFour ||
             ptype == ProcessType::TwoToFive || ptype == ProcessType::Elastic ||
             ptype == ProcessType::Decay ||
             ptype == ProcessType::MultiParticleThreeMesonsToOne ||
             ptype == ProcessType::MultiParticleThreeToTwo ||
             ptype == ProcessType::MultiParticleFourToTwo ||
             ptype == ProcessType::MultiParticleFiveToTwo) {
    ParticleTypePtrList ptype_list = cbranch.particle_types();
    /* Sorting ensures unique name for every channel
     * It avoids duplicates, such as Δ⁰Δ⁺⁺ and Δ⁺⁺Δ⁰,
     * which actually occur in SMASH, because of the way channels are added:
     * for example one channel can be added twice with halved cross-section. */
    std::sort(ptype_list.begin(), ptype_list.end());
    for (const auto& type : ptype_list) {
      os << type->name();
    }
  } else {
    os << ptype;
  }
  return os;
}

Here is the call graph for this function:

format_debug_output() [3/3]

void smash::ScatterAction::format_debug_output ( std::ostream &  out ) const

overrideprotectedvirtual

Writes information about this scatter action to the out stream.

Implements smash::Action.

Definition at line 897 of file scatteraction.cc.

                                                             {
  out << "Scatter of " << incoming_particles_;
  if (outgoing_particles_.empty()) {
    out << " (not performed)";
  } else {
    out << " to " << outgoing_particles_;
  }
}

operator<<() [12/12]

std::ostream & smash::operator<<	(	std::ostream &	out,
		const ThreeVector &	v
	)

Writes the three components of the vector to the output stream.

Definition at line 16 of file threevector.cc.

                                                              {
  out.put('(');
  out.fill(' ');
  for (auto x : v) {
    out << field<8> << x;
  }
  return out << ')';
}

Variable Documentation

value

template<typename T >

const T& smash::FormattingHelper< T >::value

Value that is being formatted.

Definition at line 177 of file logging.h.

width

template<typename T >

const int smash::FormattingHelper< T >::width

Output width.

Definition at line 179 of file logging.h.

precision

template<typename T >

const int smash::FormattingHelper< T >::precision

Precision that value is being formatted with.

Definition at line 181 of file logging.h.

unit

template<typename T >

const char* const smash::FormattingHelper< T >::unit

Unit that is attached at the end of value.

Definition at line 183 of file logging.h.

logg

std::array<einhard::Logger<>, std::tuple_size<LogArea::AreaTuple>::value>& smash::logg = get_loggers()

inline

An array that stores all pre-configured Logger objects.

To access its elements use logg[LAreaName] where LAreaName is the respective area identifier declared in the smash namespace of the file containing the log statement.

Note that LAreaName needs to be declared within the smash namespace of the respective file in a form of (using PauliBlocking as an example area):

static constexpr int LPauliBlocking = LogArea::PauliBlocking::id;

Definition at line 245 of file logging.h.

Friends

operator<< [1/10]

std::ostream& operator<< ( std::ostream &  out, const Action &  action  )

friend

Dispatches formatting to the virtual Action::format_debug_output function.

Definition at line 496 of file action.h.

                                                                       {
    action.format_debug_output(out);
    return out;
  }

operator<< [2/10]

std::ostream& operator<< ( std::ostream &  out, const BoxModus &  m  )

friend

Console output on startup of box specific parameters; writes the initial state for the box to the output stream.

Parameters

[in]	out	The ostream into which to output
[in]	m	The BoxModus object to write into out

Definition at line 33 of file boxmodus.cc.

                                                           {
  out << "-- Box Modus:\nSize of the box: (" << m.length_ << " fm)³\n";
  if (m.use_thermal_) {
    out << "Thermal multiplicities "
        << "(T = " << m.temperature_ << " GeV, muB = " << m.mub_
        << " GeV, muS = " << m.mus_ << " GeV, muQ = " << m.muq_ << " GeV)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  switch (m.initial_condition_) {
    case BoxInitialCondition::PeakedMomenta:
      out << "All initial momenta = 3T = " << 3 * m.temperature_ << " GeV\n";
      break;
    case BoxInitialCondition::ThermalMomentaBoltzmann:
      out << "Boltzmann momentum distribution with T = " << m.temperature_
          << " GeV.\n";
      break;
    case BoxInitialCondition::ThermalMomentaQuantum:
      out << "Fermi/Bose momentum distribution with T = " << m.temperature_
          << " GeV.\n";
      break;
  }
  if (m.jet_pdg_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_.value());
    out << "Adding a " << ptype->name() << " as a jet in the middle "
        << "of the box with " << m.jet_mom_ << " GeV initial momentum.\n";
  }
  return out;
}

operator<< [3/10]

std::ostream& operator<< ( std::ostream &  out, const ColliderModus &  m  )

friend

Writes the initial state for the ColliderModus to the output stream.

Parameters

[in]	out	The ostream into which to output
[in]	m	The ColliderModus object to write into out

Definition at line 352 of file collidermodus.cc.

                                                                {
  return out << "-- Collider Modus:\n"
             << "sqrt(S) (nucleus-nucleus) = "
             << format(std::sqrt(m.total_s_), "GeV\n")
             << "sqrt(S) (nucleon-nucleon) = " << format(m.sqrt_s_NN_, "GeV\n")
             << "Projectile:\n"
             << *m.projectile_ << "\nTarget:\n"
             << *m.target_;
}

operator<< [4/10]

template<typename Modus >

std::ostream& operator<< ( std::ostream &  out, const Experiment< Modus > &  e  )

friend

Writes the initial state for the Experiment to the output stream.

It automatically appends the output of the current Modus.

Definition at line 727 of file experiment.h.

                                                                    {
  out << "End time: " << e.end_time_ << " fm\n";
  out << e.modus_;
  return out;
}

operator<< [5/10]

std::ostream& operator<< ( std::ostream &  out, const ListModus &  m  )

friend

Writes the initial state for the List to the output stream.

Parameters

[in]	out	The ostream into which to output
[in]	m	The ListModus object to write into out

Definition at line 101 of file listmodus.cc.

                                                            {
  out << "-- List Modus\nInput directory for external particle lists:\n"
      << m.particle_list_file_directory_ << "\n";
  return out;
}

operator<< [6/10]

template<typename T >

std::ostream& operator<< ( std::ostream &  out, const FormattingHelper< T > &  h  )

friend

Nicely formatted output.

Parameters

out	Output stream
h	FormattingHelper with given output parameters.

Definition at line 189 of file logging.h.

                                                             {
    if (h.width > 0) {
      out << std::setfill(' ') << std::setw(h.width);
    }
    if (h.precision >= 0) {
      out << std::setprecision(h.precision);
    }
    out << h.value;
    if (h.unit) {
      out << ' ' << h.unit;
    }
    return out;
  }

operator<< [7/10]

std::ostream& operator<< ( std::ostream &  out, const Nucleus &  n  )

friend

Writes the state of the Nucleus object to the output stream.

Definition at line 579 of file nucleus.cc.

                                                          {
  return out << "  #particles   #testparticles   mass [GeV]   "
                "radius [fm]  diffusiveness [fm]\n"
             << format(n.number_of_particles(), nullptr, 12)
             << format(n.size(), nullptr, 17) << format(n.mass(), nullptr, 13)
             << format(n.get_nuclear_radius(), nullptr, 14)
             << format(n.get_diffusiveness(), nullptr, 20);
}

operator<< [8/10]

std::ostream& operator<< ( std::ostream &  out, const Particles &  particles  )

friend

Print effective mass and type name for all particles to the stream.

Parameters

[in]	out	The ostream into which to output
[in]	particles	The Particles object to write into out

Definition at line 148 of file particles.cc.

                                                                    {
  out << particles.size() << " Particles:\n";
  for (unsigned i = 0; i < particles.data_size_; ++i) {
    const auto &p = particles.data_[i];
    if (p.id() < 0) {
      out << "------  ";
    } else {
      out << std::setw(5) << std::setprecision(3) << p.momentum().abs3()
          << p.type().name();
    }
    if ((i & 15) == 0) {
      out << '\n';
    }
  }
  return out;
}

operator<< [9/10]

std::ostream& operator<< ( std::ostream &  out, const ParticleType &  type  )

friend

Writes all information about the particle type to the output stream.

Parameters

[out]	out	The ostream into which to output
[in]	type	The ParticleType object to write into out

Definition at line 827 of file particletype.cc.

                                                                  {
  const PdgCode &pdg = type.pdgcode();
  return out << type.name() << std::setfill(' ') << std::right
             << "[ mass:" << field<6> << type.mass()
             << ", width:" << field<6> << type.width_at_pole()
             << ", PDG:" << field<6> << pdg
             << ", charge:" << field<3> << pdg.charge()
             << ", spin:" << field<2> << pdg.spin() << "/2 ]";
}

operator<< [10/10]

std::ostream& operator<< ( std::ostream &  out, const SphereModus &  m  )

friend

Writes the initial state for the Sphere to the output stream.

Parameters

[in]	out	The ostream into which to output
[in]	m	The SphereModus object to write into out

Definition at line 89 of file spheremodus.cc.

                                                              {
  out << "-- Sphere Modus:\nRadius of the sphere: " << m.radius_ << " fm\n";
  if (m.use_thermal_) {
    out << "Thermal multiplicities (T = " << m.sphere_temperature_
        << " GeV, muB = " << m.mub_ << " GeV, muS = " << m.mus_
        << " GeV, muQ = " << m.muq_ << " GeV)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  switch (m.init_distr_) {
    case SphereInitialCondition::ThermalMomentaBoltzmann:
      out << "Boltzmann momentum distribution with T = "
          << m.sphere_temperature_ << " GeV.\n";
      break;
    case SphereInitialCondition::ThermalMomentaQuantum:
      out << "Fermi/Bose momentum distribution with T = "
          << m.sphere_temperature_ << " GeV.\n";
      break;
    case SphereInitialCondition::IC_ES:
      out << "Sphere Initial Condition is IC_ES";
      break;
    case SphereInitialCondition::IC_1M:
      out << "Sphere Initial Condition is IC_1M";
      break;
    case SphereInitialCondition::IC_2M:
      out << "Sphere Initial Condition is IC_2M";
      break;
    case SphereInitialCondition::IC_Massive:
      out << "Sphere Initial Condition is IC_Massive";
      break;
  }
  if (m.jet_pdg_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_.value());
    const auto pos = m.jet_pos_;
    if (m.jet_back_) {
      ParticleTypePtr anti =
          ptype->has_antiparticle() ? ptype->get_antiparticle() : ptype;
      out << "Adding a dijet " << ptype->name() << anti->name()
          << " centered at (" << pos.x1() << ", " << pos.x2() << ", "
          << pos.x3() << ") separated by " << m.jet_back_separation_
          << " fm,\neach with " << m.jet_mom_ << " GeV of initial momentum.\n";
    } else {
      out << "Adding a " << ptype->name() << " as a jet at (" << pos.x1()
          << ", " << pos.x2() << ", " << pos.x3() << ") fm with " << m.jet_mom_
          << " GeV of initial momentum.\n";
    }
  }
  return out;
}