icoutput.cc

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2019-2020,2022-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#include "smash/icoutput.h"
 
#include <filesystem>
#include <fstream>
 
#include "smash/action.h"
 
namespace smash {
 
ICOutput::ICOutput(const std::filesystem::path &path, const std::string &name,
                   const OutputParameters &out_par)
    : OutputInterface(name),
      file_{path / "SMASH_IC_For_vHLLE.dat", "w"},
      out_par_(out_par),
      formatter_{OutputDefaultQuantities::ic_For_vHLLE} {
  std::fprintf(
      file_.get(),
      "# %s initial conditions: hypersurface of constant proper time\n",
      SMASH_VERSION);
  std::fprintf(file_.get(), "# %s", formatter_.quantities_line().c_str());
  std::fprintf(file_.get(), "# %s", formatter_.unit_line().c_str());
}
 
ICOutput::~ICOutput() {}
 
void ICOutput::at_eventstart(const Particles &, const EventLabel &event_label,
                             const EventInfo &event) {
  if (event.n_ensembles != 1) {
    throw std::logic_error(
        "ICOutput shouldn't be used with multiple parallel ensembles.");
  }
  std::fprintf(file_.get(), "# event %i ensemble %i start\n",
               event_label.event_number, event_label.ensemble_number);
}
 
void ICOutput::at_eventend([[maybe_unused]] const Particles &particles,
                           const EventLabel &event_label,
                           const EventInfo &event) {
  if (event.n_ensembles != 1) {
    throw std::logic_error(
        "ICOutput shouldn't be used with multiple parallel ensembles.");
  }
  std::fprintf(file_.get(), "# event %i ensemble %i end\n",
               event_label.event_number, event_label.ensemble_number);
}
 
void ICOutput::at_intermediate_time(const Particles &,
                                    const std::unique_ptr<Clock> &,
                                    const DensityParameters &,
                                    const EventLabel &, const EventInfo &) {
  // Dummy, but virtual function needs to be declared.
}
 
void ICOutput::at_interaction(const Action &action, const double) {
  assert(action.get_type() == ProcessType::Fluidization ||
         action.get_type() == ProcessType::FluidizationNoRemoval);
  assert(action.incoming_particles().size() == 1);
 
  const ParticleData &particle = action.incoming_particles()[0];
 
  // Determine if particle is spectator:
  // Fulfilled if particle is initial nucleon, aka has no prior interactions
  bool is_spectator = particle.get_history().collisions_per_particle == 0;
 
  // write particle data excluding spectators
  if (!is_spectator) {
    std::fprintf(file_.get(), "%s",
                 formatter_.single_particle_data(particle).c_str());
  }
 
  if (IC_proper_time_ < 0.0) {
    // First particle that is removed, overwrite negative default
    IC_proper_time_ = particle.hyperbolic_time();
  } else {
    // Verify that all other particles have the same proper time
    const double next_proper_time = particle.hyperbolic_time();
    if (!((next_proper_time - IC_proper_time_) < really_small))
      throw std::runtime_error(
          "Hypersurface proper time changed during evolution.");
  }
}
 
}  // namespace smash