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.

Namespaces
	smash::LogArea
	The namespace where log areas are declared.

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::Sampling
	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::HadronGasEos
	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::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	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, Sampling, Pythia, GrandcanThermalizer, CrossSections, Output, HadronGasEos, HyperSurfaceCrossing, InitialConditions >
	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
std::ostream &	smash::operator<< (std::ostream &out, const ActionPtr &action)
std::ostream &	smash::operator<< (std::ostream &out, const ActionList &actions)
std::ostream &	smash::operator<< (std::ostream &out, const Angles &a)
void	smash::DecayAction::format_debug_output (std::ostream &out) const override
std::ostream &	smash::operator<< (std::ostream &, const EnergyMomentumTensor &)
std::ostream &	smash::operator<< (std::ostream &os, const FourVector &vec)
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)
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...
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)
std::ostream &	smash::operator<< (std::ostream &out, const ParticleList &particle_list)
PrintParticleListDetailed	smash::detailed (const ParticleList &list)
std::ostream &	smash::operator<< (std::ostream &out, const PrintParticleListDetailed &particle_list)
std::ostream &	smash::operator<< (std::ostream &is, const PdgCode &code)
std::ostream &	smash::operator<< (std::ostream &os, ProcessType process_type)
std::ostream &	smash::operator<< (std::ostream &os, const CollisionBranch &cbranch)
void	smash::ScatterAction::format_debug_output (std::ostream &out) const override
std::ostream &	smash::operator<< (std::ostream &, const ThreeVector &)

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
	An array that stores all pre-configured Logger objects. More...

Friends
std::ostream &	smash::Action::operator<< (std::ostream &out, const Action &action)
std::ostream &	smash::BoxModus::operator<< (std::ostream &out, const BoxModus &m)
std::ostream &	smash::ColliderModus::operator<< (std::ostream &, const ColliderModus &)
std::ostream &	smash::Experiment< Modus >::operator<< (std::ostream &out, const Experiment &e)
	Creates a verbose textual description of the setup of the Experiment. More...
std::ostream &	smash::ListModus::operator<< (std::ostream &, const ListModus &)
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 &)
std::ostream &	smash::Particles::operator<< (std::ostream &out, const Particles &particles)
std::ostream &	smash::ParticleType::operator<< (std::ostream &out, const ParticleType &type)
std::ostream &	smash::SphereModus::operator<< (std::ostream &, const SphereModus &)

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 166 of file logging.h.

source_location

#define 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 240 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, Sampling, Pythia, GrandcanThermalizer, CrossSections, Output, HadronGasEos, HyperSurfaceCrossing, InitialConditions>

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

Definition at line 223 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::ScatterAction, smash::DecayAction, smash::HypersurfacecrossingAction, smash::WallcrossingAction, and smash::ThermalizationAction.

operator<<() [1/12]

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

inline

Convenience: dereferences the ActionPtr to Action.

Definition at line 463 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 276 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 184 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 113 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 144 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 36 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 118 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 22 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 24 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 304 of file logging.h.

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

Here is the caller graph for this function:

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 330 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 342 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 110 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 121 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 476 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 136 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 88 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 85 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::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
      os << "Soft String Excitation";
      break;
    case ProcessType::StringHard:
      os << "Hard String via Pythia";
      break;
    case ProcessType::Decay:
      os << "Decay";
      break;
    case ProcessType::Wall:
      os << "Wall";
      break;
    case ProcessType::HyperSurfaceCrossing:
      os << "Hypersurface crossing";
      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 55 of file processbranch.cc.

                                                                       {
  ProcessType ptype = cbranch.get_type();
  if (ptype == ProcessType::StringSoftSingleDiffractiveAX ||
      ptype == ProcessType::StringSoftSingleDiffractiveXB) {
    os << "1-diff";
  } else if (ptype == ProcessType::StringSoftDoubleDiffractive) {
    os << "2-diff";
  } else if (ptype == ProcessType::StringSoftAnnihilation) {
    os << "BBbar";
  } else if (ptype == ProcessType::StringSoftNonDiffractive) {
    os << "non-diff";
  } else if (ptype == ProcessType::StringHard) {
    os << "hard";
  } else if (ptype == ProcessType::TwoToOne || ptype == ProcessType::TwoToTwo ||
             ptype == ProcessType::Elastic || ptype == ProcessType::Decay) {
    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 560 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 264 of file logging.h.

width

template<typename T >

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

Output width.

Definition at line 266 of file logging.h.

precision

template<typename T >

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

Precision that value is being formatted with.

Definition at line 268 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 270 of file logging.h.

logg

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

An array that stores all pre-configured Logger objects.

The objects can be accessed via the logger function.

To access its elements use logg[LAreaName] where AreaName is the respective areas name declared in loggin.h. 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;

For further documentation see logging.h.

Definition at line 39 of file logging.cc.

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 413 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 38 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)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  if (m.initial_condition_ == BoxInitialCondition::PeakedMomenta) {
    out << "All initial momenta = 3T = " << 3 * m.temperature_ << " GeV\n";
  } else {
    out << "Boltzmann momentum distribution with T = " << m.temperature_
        << " GeV.\n";
  }
  if (m.insert_jet_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_);
    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 441 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

Creates a verbose textual description of the setup of the Experiment.

Writes the initial state for the Experiment to the output stream. It automatically appends the output of the current Modus.

Definition at line 569 of file experiment.h.

                                                                    {
  out << "End time: " << e.end_time_ << " fm/c\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 135 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 276 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 513 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 768 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 189 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)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  out << "Boltzmann momentum distribution with T = " << m.sphere_temperature_
      << " GeV.\n";
  if (m.insert_jet_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_);
    out << "Adding a " << ptype->name() << " as a jet in the middle "
        << "of the sphere with " << m.jet_mom_ << " GeV initial momentum.\n";
  }
  return out;
}