binaryoutput.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2020,2022
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_BINARYOUTPUT_H_
#define SRC_INCLUDE_SMASH_BINARYOUTPUT_H_
 
#include <memory>
#include <string>
 
#include "file.h"
#include "forwarddeclarations.h"
#include "numeric_cast.h"
#include "outputinterface.h"
#include "outputparameters.h"
 
namespace smash {
 
class BinaryOutputBase : public OutputInterface {
 protected:
  explicit BinaryOutputBase(const std::filesystem::path &path,
                            const std::string &mode, const std::string &name,
                            bool extended_format);
 
  void write(const char c);
 
  void write(const std::string &s);
 
  void write(const double x);
 
  void write(const FourVector &v);
 
  void write(const std::int32_t x) {
    std::fwrite(&x, sizeof(x), 1, file_.get());
  }
 
  void write(const std::uint32_t x) {
    std::fwrite(&x, sizeof(x), 1, file_.get());
  }
 
  void write(const std::uint16_t x) {
    std::fwrite(&x, sizeof(x), 1, file_.get());
  }
 
  void write(const size_t x) { write(smash::numeric_cast<uint32_t>(x)); }
 
  void write(const Particles &particles);
 
  void write(const ParticleList &particles);
 
  void write_particledata(const ParticleData &p);
 
  RenamingFilePtr file_;
 
 private:
  const uint16_t format_version_ = 8;
  bool extended_;
};
 
class BinaryOutputCollisions : public BinaryOutputBase {
 public:
  BinaryOutputCollisions(const std::filesystem::path &path, std::string name,
                         const OutputParameters &out_par);
 
  void at_eventstart(const Particles &particles, const int event_number,
                     const EventInfo &event) override;
 
  void at_eventend(const Particles &particles, const int32_t event_number,
                   const EventInfo &event) override;
 
  void at_interaction(const Action &action, const double density) override;
 
 private:
  bool print_start_end_;
};
 
class BinaryOutputParticles : public BinaryOutputBase {
 public:
  BinaryOutputParticles(const std::filesystem::path &path, std::string name,
                        const OutputParameters &out_par);
 
  void at_eventstart(const Particles &particles, const int event_number,
                     const EventInfo &event) override;
 
  void at_eventend(const Particles &particles, const int event_number,
                   const EventInfo &event) override;
 
  void at_intermediate_time(const Particles &particles,
                            const std::unique_ptr<Clock> &clock,
                            const DensityParameters &dens_param,
                            const EventInfo &event) override;
 
 private:
  OutputOnlyFinal only_final_;
};
 
class BinaryOutputInitialConditions : public BinaryOutputBase {
 public:
  BinaryOutputInitialConditions(const std::filesystem::path &path,
                                std::string name,
                                const OutputParameters &out_par);
 
  void at_eventstart(const Particles &, const int, const EventInfo &) override;
 
  void at_eventend(const Particles &particles, const int event_number,
                   const EventInfo &event) override;
 
  void at_interaction(const Action &action, const double) override;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_BINARYOUTPUT_H_