outputinterface.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_OUTPUTINTERFACE_H_
#define SRC_INCLUDE_SMASH_OUTPUTINTERFACE_H_
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "density.h"
#include "energymomentumtensor.h"
#include "forwarddeclarations.h"
#include "grandcan_thermalizer.h"
#include "lattice.h"
#include "macros.h"
 
namespace smash {
static constexpr int LOutput = LogArea::Output::id;
 
struct EventInfo {
  double impact_parameter;
  double modus_length;
  double current_time;
  double total_kinetic_energy;
  double total_mean_field_energy;
  double total_energy;
  int test_particles;
  int n_ensembles;
  bool empty_event;
  bool impose_kinematic_cut_for_SMASH_IC;
};
 
struct EventLabel {
  int32_t event_number;
  int32_t ensemble_number;
};
 
class OutputInterface {
 public:
  explicit OutputInterface(std::string name)
      : is_dilepton_output_(name == "Dileptons"),
        is_photon_output_(name == "Photons"),
        is_IC_output_(name == "SMASH_IC") {}
  virtual ~OutputInterface() = 0;
 
  virtual void at_eventstart(const Particles &, const EventLabel &,
                             const EventInfo &) {}
 
  virtual void at_eventstart(const std::vector<Particles> &, int) {}
 
  virtual void at_eventstart(const int, const ThermodynamicQuantity,
                             const DensityType,
                             RectangularLattice<DensityOnLattice>) {}
 
  virtual void at_eventstart(const int, const ThermodynamicQuantity,
                             const DensityType,
                             RectangularLattice<EnergyMomentumTensor>) {}
 
  virtual void at_eventend(const ThermodynamicQuantity) {}
 
  virtual void at_eventend(const Particles &, const EventLabel &,
                           const EventInfo &) {}
  virtual void at_eventend(const std::vector<Particles> &, const int) {}
 
  virtual void at_interaction(const Action &, const double) {}
 
  virtual void at_intermediate_time(const Particles &,
                                    const std::unique_ptr<Clock> &,
                                    const DensityParameters &,
                                    const EventLabel &, const EventInfo &) {}
  virtual void at_intermediate_time(const std::vector<Particles> &,
                                    const std::unique_ptr<Clock> &,
                                    const DensityParameters &) {}
 
  virtual void thermodynamics_output(const ThermodynamicQuantity,
                                     const DensityType,
                                     RectangularLattice<DensityOnLattice> &) {}
 
  virtual void thermodynamics_output(
      const ThermodynamicQuantity, const DensityType,
      RectangularLattice<EnergyMomentumTensor> &) {}
 
  virtual void thermodynamics_lattice_output(
      RectangularLattice<DensityOnLattice> &, const double) {}
 
  virtual void thermodynamics_lattice_output(
      RectangularLattice<DensityOnLattice> &, const double,
      const std::vector<Particles> &, const DensityParameters &) {}
 
  virtual void thermodynamics_lattice_output(
      const ThermodynamicQuantity, RectangularLattice<EnergyMomentumTensor> &,
      const double) {}
 
  virtual void thermodynamics_output(const GrandCanThermalizer &) {}
 
  virtual void fields_output(
      const std::string, const std::string,
      RectangularLattice<std::pair<ThreeVector, ThreeVector>> &) {}
 
  bool is_dilepton_output() const { return is_dilepton_output_; }
 
  bool is_photon_output() const { return is_photon_output_; }
 
  bool is_IC_output() const { return is_IC_output_; }
 
  const char *to_string(const ThermodynamicQuantity tq) {
    switch (tq) {
      case ThermodynamicQuantity::EckartDensity:
        return "rho_eckart";
      case ThermodynamicQuantity::Tmn:
        return "tmn";
      case ThermodynamicQuantity::TmnLandau:
        return "tmn_landau";
      case ThermodynamicQuantity::LandauVelocity:
        return "v_landau";
      case ThermodynamicQuantity::j_QBS:
        return "j_QBS";
    }
    throw std::invalid_argument("Unknown thermodynamic quantity.");
  }
 
  const char *to_string(const DensityType dens_type) {
    switch (dens_type) {
      case DensityType::Hadron:
        return "hadron";
      case DensityType::Baryon:
        return "net_baryon";
      case DensityType::BaryonicIsospin:
        return "net_baryonI3";
      case DensityType::Pion:
        return "pion";
      case DensityType::Isospin3_tot:
        return "tot_isospin3";
      case DensityType::Charge:
        return "charge";
      case DensityType::Strangeness:
        return "strangeness";
      case DensityType::None:
        return "none";
    }
    throw std::invalid_argument("Unknown density type.");
  }
 
 protected:
  const bool is_dilepton_output_;
 
  const bool is_photon_output_;
 
  const bool is_IC_output_;
};
 
inline OutputInterface::~OutputInterface() = default;
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_OUTPUTINTERFACE_H_