binaryoutput.cc

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2020,2022-2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#include "smash/binaryoutput.h"
 
#include <cstdint>
#include <filesystem>
#include <string>
 
#include "smash/action.h"
#include "smash/clock.h"
#include "smash/config.h"
 
namespace smash {
 
static constexpr int LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id;
 
static auto get_list_of_binary_quantities(const std::string &content,
                                          const std::string &format,
                                          const OutputParameters &parameters);
 
static auto get_binary_filename(const std::string &content,
                                const std::vector<std::string> &quantities) {
  std::string filename = content;
  if (content == "Particles" || content == "Collisions") {
    std::transform(filename.begin(), filename.end(), filename.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    if (quantities == OutputDefaultQuantities::oscar2013) {
      filename += "_oscar2013";
    } else if (quantities == OutputDefaultQuantities::oscar2013extended) {
      filename += "_oscar2013_extended";
    } else {
      filename += "_binary";
    }
  } else if (content == "Photons" || content == "Dileptons") {
    // Nothing to be done here
  } else if (content == "Initial_Conditions") {
    filename = "SMASH_IC";
  } else {
    throw std::invalid_argument(
        "Unknown content to get the binary output filename.");
  }
  return filename + ".bin";
}
 
BinaryOutputBase::BinaryOutputBase(const std::filesystem::path &path,
                                   const std::string &mode,
                                   const std::string &name,
                                   const std::vector<std::string> &quantities)
    : OutputInterface(name), file_{path, mode}, formatter_(quantities) {
  if (quantities.empty()) {
    throw std::invalid_argument(
        "Empty quantities list passed to 'BinaryOutputBase' cconstructor.");
  }
  std::fwrite("SMSH", 4, 1, file_.get());  // magic number
  write(format_version_);                  // file format version number
  std::uint16_t format_variant{};
  if (quantities == OutputDefaultQuantities::oscar2013) {
    format_variant = 0;
  } else if (quantities == OutputDefaultQuantities::oscar2013extended) {
    format_variant = 1;
  } else {
    format_variant = format_custom_;
  }
  write(format_variant);
  write(SMASH_VERSION);
}
 
// write functions:
void BinaryOutputBase::write(const char c) {
  std::fwrite(&c, sizeof(char), 1, file_.get());
}
void BinaryOutputBase::write(const ToBinary::type &chunk) {
  std::fwrite(chunk.data(), sizeof(char), chunk.size(), file_.get());
}
 
void BinaryOutputBase::write(const std::string &s) {
  const auto size = smash::numeric_cast<uint32_t>(s.size());
  std::fwrite(&size, sizeof(std::uint32_t), 1, file_.get());
  std::fwrite(s.c_str(), s.size(), 1, file_.get());
}
 
void BinaryOutputBase::write(const double x) {
  std::fwrite(&x, sizeof(x), 1, file_.get());
}
 
void BinaryOutputBase::write(const FourVector &v) {
  std::fwrite(v.begin(), sizeof(*v.begin()), 4, file_.get());
}
 
void BinaryOutputBase::write(const Particles &particles) {
  for (const auto &p : particles) {
    write_particledata(p);
  }
}
 
void BinaryOutputBase::write(const ParticleList &particles) {
  for (const auto &p : particles) {
    write_particledata(p);
  }
}
 
void BinaryOutputBase::write_particledata(const ParticleData &p) {
  write(formatter_.binary_chunk(p));
}
 
BinaryOutputCollisions::BinaryOutputCollisions(
    const std::filesystem::path &path, std::string name,
    const OutputParameters &out_par, const std::vector<std::string> &quantities)
    : BinaryOutputBase(path / get_binary_filename(name, quantities), "wb", name,
                       quantities),
      print_start_end_(out_par.coll_printstartend) {}
 
void BinaryOutputCollisions::at_eventstart(const Particles &particles,
                                           const EventLabel &event_label,
                                           const EventInfo &) {
  const char pchar = 'p';
  if (print_start_end_) {
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(event_label.event_number);
    write(event_label.ensemble_number);
    write(particles.size());
    write(particles);
  }
}
 
void BinaryOutputCollisions::at_eventend(const Particles &particles,
                                         const EventLabel &event_label,
                                         const EventInfo &event) {
  const char pchar = 'p';
  if (print_start_end_) {
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(event_label.event_number);
    write(event_label.ensemble_number);
    write(particles.size());
    write(particles);
  }
 
  // Event end line
  const char fchar = 'f';
  std::fwrite(&fchar, sizeof(char), 1, file_.get());
  write(event_label.event_number);
  write(event_label.ensemble_number);
  write(event.impact_parameter);
  const char empty = event.empty_event;
  write(empty);
 
  // Flush to disk
  std::fflush(file_.get());
}
 
void BinaryOutputCollisions::at_interaction(const Action &action,
                                            const double density) {
  const char ichar = 'i';
  std::fwrite(&ichar, sizeof(char), 1, file_.get());
  write(action.incoming_particles().size());
  write(action.outgoing_particles().size());
  std::fwrite(&density, sizeof(double), 1, file_.get());
  const double weight = action.get_total_weight();
  std::fwrite(&weight, sizeof(double), 1, file_.get());
  const double partial_weight = action.get_partial_weight();
  std::fwrite(&partial_weight, sizeof(double), 1, file_.get());
  const auto type = static_cast<uint32_t>(action.get_type());
  std::fwrite(&type, sizeof(uint32_t), 1, file_.get());
  write(action.incoming_particles());
  write(action.outgoing_particles());
}
 
BinaryOutputParticles::BinaryOutputParticles(
    const std::filesystem::path &path, std::string name,
    const OutputParameters &out_par, const std::vector<std::string> &quantities)
    : BinaryOutputBase(path / get_binary_filename(name, quantities), "wb", name,
                       quantities),
      only_final_(out_par.part_only_final) {}
 
void BinaryOutputParticles::at_eventstart(const Particles &particles,
                                          const EventLabel &event_label,
                                          const EventInfo &) {
  const char pchar = 'p';
  if (only_final_ == OutputOnlyFinal::No) {
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(event_label.event_number);
    write(event_label.ensemble_number);
    write(particles.size());
    write(particles);
  }
}
 
void BinaryOutputParticles::at_eventend(const Particles &particles,
                                        const EventLabel &event_label,
                                        const EventInfo &event) {
  const char pchar = 'p';
  if (!(event.empty_event && only_final_ == OutputOnlyFinal::IfNotEmpty)) {
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(event_label.event_number);
    write(event_label.ensemble_number);
    write(particles.size());
    write(particles);
  }
 
  // Event end line
  const char fchar = 'f';
  std::fwrite(&fchar, sizeof(char), 1, file_.get());
  write(event_label.event_number);
  write(event_label.ensemble_number);
  write(event.impact_parameter);
  const char empty = event.empty_event;
  write(empty);
 
  // Flush to disk
  std::fflush(file_.get());
}
 
void BinaryOutputParticles::at_intermediate_time(const Particles &particles,
                                                 const std::unique_ptr<Clock> &,
                                                 const DensityParameters &,
                                                 const EventLabel &event_label,
                                                 const EventInfo &) {
  const char pchar = 'p';
  if (only_final_ == OutputOnlyFinal::No) {
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(event_label.event_number);
    write(event_label.ensemble_number);
    write(particles.size());
    write(particles);
  }
}
 
BinaryOutputInitialConditions::BinaryOutputInitialConditions(
    const std::filesystem::path &path, std::string name,
    const std::vector<std::string> &quantities)
    : BinaryOutputBase(path / get_binary_filename(name, quantities), "wb", name,
                       quantities) {}
 
void BinaryOutputInitialConditions::at_eventstart(const Particles &,
                                                  const EventLabel &,
                                                  const EventInfo &) {}
 
void BinaryOutputInitialConditions::at_eventend(const Particles &particles,
                                                const EventLabel &event_label,
                                                const EventInfo &event) {
  // Event end line
  const char fchar = 'f';
  std::fwrite(&fchar, sizeof(char), 1, file_.get());
  write(event_label.event_number);
  write(event_label.ensemble_number);
  write(event.impact_parameter);
  const char empty = event.empty_event;
  write(empty);
 
  // Flush to disk
  std::fflush(file_.get());
 
  // If the runtime is too short some particles might not yet have
  // reached the hypersurface. Warning is printed.
  if (particles.size() != 0 && !event.impose_kinematic_cut_for_SMASH_IC) {
    logg[LHyperSurfaceCrossing].warn(
        "End time might be too small for initial conditions output. "
        "Hypersurface has not yet been crossed by ",
        particles.size(), " particle(s).");
  }
}
 
void BinaryOutputInitialConditions::at_interaction(const Action &action,
                                                   const double) {
  if (action.get_type() == ProcessType::HyperSurfaceCrossing) {
    const char pchar = 'p';
    std::fwrite(&pchar, sizeof(char), 1, file_.get());
    write(action.incoming_particles().size());
    write(action.incoming_particles());
  }
}
 
static auto get_list_of_binary_quantities(const std::string &content,
                                          const std::string &format,
                                          const OutputParameters &parameters) {
  const bool is_extended = std::invoke([&content, &parameters]() {
    if (content == "Particles")
      return parameters.part_extended;
    else if (content == "Collisions")
      return parameters.coll_extended;
    else if (content == "Dileptons")
      return parameters.dil_extended;
    else if (content == "Photons")
      return parameters.photons_extended;
    else if (content == "Initial_Conditions")
      return parameters.ic_extended;
    else
      return false;
  });
  const auto default_quantities =
      (is_extended) ? OutputDefaultQuantities::oscar2013extended
                    : OutputDefaultQuantities::oscar2013;
  if (format == "Oscar2013_bin" || content == "Dileptons" ||
      content == "Photons" || content == "Initial_Conditions") {
    return default_quantities;
  } else if (format == "Binary") {
    if (content == "Particles" || content == "Collisions") {
      auto list_of_quantities = parameters.quantities.at(content);
      if (list_of_quantities.empty()) {
        return default_quantities;
      } else {
        return list_of_quantities;
      }
    } else {
      /* Note that this function should not be called with "Binary" format for
       * output contents which do not support custom binary quantities. Hence we
       * throw here to prevent such a case.*/
      throw std::invalid_argument(
          "Unknown content to get the list of quantities for binary output.");
    }
  } else {
    throw std::invalid_argument(
        "Unknown format to get the list of quantities for binary output.");
  }
}
 
std::unique_ptr<OutputInterface> create_binary_output(
    const std::string &format, const std::string &content,
    const std::filesystem::path &path, const OutputParameters &out_par) {
  if (content == "Particles") {
    return std::make_unique<BinaryOutputParticles>(
        path, content, out_par,
        get_list_of_binary_quantities(content, format, out_par));
  } else if (content == "Collisions" || content == "Dileptons" ||
             content == "Photons") {
    return std::make_unique<BinaryOutputCollisions>(
        path, content, out_par,
        get_list_of_binary_quantities(content, format, out_par));
  } else if (content == "Initial_Conditions") {
    return std::make_unique<BinaryOutputInitialConditions>(
        path, content, get_list_of_binary_quantities(content, format, out_par));
  } else {
    throw std::invalid_argument("Binary output not available for '" + content +
                                "' content.");
  }
}
 
}  // namespace smash