outputinterface.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2022
 *      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;
};
 
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() = default;
 
  virtual void at_eventstart(const Particles &particles, const int event_number,
                             const EventInfo &info) {
    SMASH_UNUSED(particles);
    SMASH_UNUSED(event_number);
    SMASH_UNUSED(info);
  }
  virtual void at_eventstart(const std::vector<Particles> &ensembles,
                             int event_number) {
    SMASH_UNUSED(ensembles);
    SMASH_UNUSED(event_number);
  }
 
  virtual void at_eventstart(const int event_number,
                             const ThermodynamicQuantity tq,
                             const DensityType dens_type,
                             RectangularLattice<DensityOnLattice> lattice) {
    SMASH_UNUSED(event_number);
    SMASH_UNUSED(tq);
    SMASH_UNUSED(dens_type);
    SMASH_UNUSED(lattice);
  }
 
  virtual void at_eventstart(const int event_number,
                             const ThermodynamicQuantity tq,
                             const DensityType dens_type,
                             RectangularLattice<EnergyMomentumTensor> lattice) {
    SMASH_UNUSED(event_number);
    SMASH_UNUSED(tq);
    SMASH_UNUSED(dens_type);
    SMASH_UNUSED(lattice);
  }
 
  virtual void at_eventend(const int event_number,
                           const ThermodynamicQuantity tq,
                           const DensityType dens_type) {
    SMASH_UNUSED(event_number);
    SMASH_UNUSED(tq);
    SMASH_UNUSED(dens_type);
  }
 
  virtual void at_eventend(const ThermodynamicQuantity tq) { SMASH_UNUSED(tq); }
 
  virtual void at_eventend(const Particles &particles, const int event_number,
                           const EventInfo &info) {
    SMASH_UNUSED(particles);
    SMASH_UNUSED(event_number);
    SMASH_UNUSED(info);
  }
  virtual void at_eventend(const std::vector<Particles> &ensembles,
                           const int event_number) {
    SMASH_UNUSED(ensembles);
    SMASH_UNUSED(event_number);
  }
 
  virtual void at_interaction(const Action &action, const double density) {
    SMASH_UNUSED(action);
    SMASH_UNUSED(density);
  }
 
  virtual void at_intermediate_time(const Particles &particles,
                                    const std::unique_ptr<Clock> &clock,
                                    const DensityParameters &dens_param,
                                    const EventInfo &info) {
    SMASH_UNUSED(particles);
    SMASH_UNUSED(clock);
    SMASH_UNUSED(dens_param);
    SMASH_UNUSED(info);
  }
  virtual void at_intermediate_time(const std::vector<Particles> &ensembles,
                                    const std::unique_ptr<Clock> &clock,
                                    const DensityParameters &dens_param) {
    SMASH_UNUSED(ensembles);
    SMASH_UNUSED(clock);
    SMASH_UNUSED(dens_param);
  }
 
  virtual void thermodynamics_output(
      const ThermodynamicQuantity tq, const DensityType dt,
      RectangularLattice<DensityOnLattice> &lattice) {
    SMASH_UNUSED(tq);
    SMASH_UNUSED(dt);
    SMASH_UNUSED(lattice);
  }
 
  virtual void thermodynamics_output(
      const ThermodynamicQuantity tq, const DensityType dt,
      RectangularLattice<EnergyMomentumTensor> &lattice) {
    SMASH_UNUSED(tq);
    SMASH_UNUSED(dt);
    SMASH_UNUSED(lattice);
  }
 
  virtual void thermodynamics_lattice_output(
      RectangularLattice<DensityOnLattice> &lattice,
      const double current_time) {
    SMASH_UNUSED(lattice);
    SMASH_UNUSED(current_time);
  }
 
  virtual void thermodynamics_lattice_output(
      RectangularLattice<DensityOnLattice> &lattice, const double current_time,
      const std::vector<Particles> &ensembles,
      const DensityParameters &dens_param) {
    SMASH_UNUSED(lattice);
    SMASH_UNUSED(current_time);
    SMASH_UNUSED(ensembles);
    SMASH_UNUSED(dens_param);
  }
 
  virtual void thermodynamics_lattice_output(
      const ThermodynamicQuantity tq,
      RectangularLattice<EnergyMomentumTensor> &lattice,
      const double current_time) {
    SMASH_UNUSED(tq);
    SMASH_UNUSED(lattice);
    SMASH_UNUSED(current_time);
  }
 
  virtual void thermodynamics_output(const GrandCanThermalizer &gct) {
    SMASH_UNUSED(gct);
  }
 
  virtual void fields_output(
      const std::string name1, const std::string name2,
      RectangularLattice<std::pair<ThreeVector, ThreeVector>> &lat) {
    SMASH_UNUSED(name1);
    SMASH_UNUSED(name2);
    SMASH_UNUSED(lat);
  }
 
  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_;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_OUTPUTINTERFACE_H_