OutputFile.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
 
// standard library includes
#include <fstream>
#include <string>
 
namespace marley {
 
  class Generator;
 
  class OutputFile {
 
    public:
 
      // Arguments to the constructor correspond to fields in
      // the JSON objects that appear under the "output" key
      // in the "executable_settings" section of a MARLEY job
      // configuration file
      OutputFile(const std::string& name, const std::string& format,
        const std::string& mode, bool force = false);
 
      virtual ~OutputFile() = default;
 
      const std::string& name() const { return name_; }
 
      virtual bool resume(std::unique_ptr<marley::Generator>& gen,
        long& num_previous_events) = 0;
 
      virtual void close(const marley::JSON& json_config,
        const marley::Generator& gen, const long num_events) = 0;
 
      virtual int_fast64_t bytes_written() = 0;
 
      virtual void write_event(const marley::Event* event) = 0;
 
      bool mode_is_resume() const { return mode_ == Mode::RESUME; }
 
      virtual void write_flux_avg_tot_xsec(double avg_tot_xsec) = 0;
 
      // Add more formats to the enum class as needed. This should include
      // every event format that MARLEY knows how to write. The "ASCII" format
      // is MARLEY's native format for textual input and output of
      // marley::Event objects (via the << and >> operators on std::ostream and
      // std::istream objects).
      enum class Format { ROOT, HEPEVT, JSON, ASCII };
 
    protected:
 
      std::unique_ptr<marley::Generator> restore_generator(
        const marley::JSON& config);
 
      inline bool check_if_file_exists(const std::string& filename) {
        std::ifstream test_stream( filename );
        return test_stream.good();
      }
 
      virtual void open() = 0;
 
      virtual void write_generator_state(const marley::JSON& json_config,
        const marley::Generator& gen, const long num_events) = 0;
 
      // Modes to use when writing output to files that are not initially empty
      // OVERWRITE = removes any previous contents of the file, then writes new
      //   events in the requested format. This mode is allowed for all output
      //   formats.
      // APPEND = adds new events to the end of the file without altering any
      //   previous contents. This mode is only allowed for formats that don't
      //   save metadata (random number generator state, etc.) to the file,
      //   i.e., the HEPEVT and ASCII formats.
      // RESUME = uses saved metadata in a file to restore a previous MARLEY
      //   configuration (including the random number generator state), then
      //   appends new events after those currently saved in the file. This
      //   mode is only allowed for output formats that include such metadata,
      //   i.e., the ROOT and JSON formats.
      enum class Mode { OVERWRITE, APPEND, RESUME };
 
      std::string name_; 
      Format format_; 
      Mode mode_;
 
      // Whether to force the current output mode without prompting the user.
      // Currently only used when setting the OVERWRITE output mode.
      bool force_;
  };
 
  class TextOutputFile : public OutputFile {
    private:
 
      // Formats the beginning of a JSON output file properly based on the
      // current indent level. Writes the result to a std::ostream.
      void start_json_output(bool start_array);
 
      // Stream used to read and write from the output file as needed
      std::fstream stream_;
 
      // Flag used to see if we need a comma in front of the current
      // JSON event or not. Unused by the other formats.
      bool needs_comma_ = false;
 
      int indent_ = -1; // -1 gives the most compact JSON file possible
 
      int_fast64_t byte_count_ = 0;
 
      double flux_avg_tot_xsec_ = 0.;
 
    public:
 
      TextOutputFile(const std::string& name, const std::string& format,
        const std::string& mode, bool force = false, int indent = -1);
 
      virtual ~TextOutputFile() = default;
 
      inline void set_indent(int indent) { indent_ = indent; }
 
      virtual void open() override;
 
      // TODO: consider a better way of doing this
      // Returns true if the generator was successfully restored from the
      // saved metadata, or false otherwise.
      virtual bool resume(std::unique_ptr<marley::Generator>& gen,
        long& num_previous_events) override;
 
      int_fast64_t bytes_written() override;
 
      // Write a new marley::Event to this output file
      virtual void write_event(const marley::Event* event) override;
 
      void write_generator_state(const marley::JSON& json_config,
        const marley::Generator& gen, const long num_events) override;
 
      virtual void close(const marley::JSON& json_config,
        const marley::Generator& gen, const long num_events) override;
 
      // This function is a no-op for the JSON format (we will write the
      // flux-averaged cross section to the output file when saving the
      // generator state)
      virtual void write_flux_avg_tot_xsec(double avg_tot_xsec) override;
  };
 
}