marley::OutputFileAscii Class Reference

Class that represents an output file in the standard ASCII format for HepMC3 events. More...

#include <OutputFileAscii.hh>

Inheritance diagram for marley::OutputFileAscii:

Public Member Functions
	OutputFileAscii (const JSON &output_config)
virtual int_fast64_t	bytes_written () override
	The number of bytes that have been written during the current MARLEY session to this file.
virtual bool	resume (std::unique_ptr< marley::Generator > &gen, long &num_previous_events) override
	Load a marley::Generator object whose configuration and state were saved to the metadata in the output file.
virtual void	write_event (HepMC3::GenEvent *event) override
	Write a new HepMC3::GenEvent to this output file.
Public Member Functions inherited from marley::OutputFile
bool	mode_is_resume () const
const std::string &	name () const

Protected Member Functions
virtual void	open ()
	Opens the owned std::fstream with the correct settings.
Protected Member Functions inherited from marley::OutputFile
	OutputFile (const JSON &output_config)
bool	check_if_file_exists (const std::string &filename)
	Checks that a given file exists (and is readable)
void	prompt_before_overwrite ()
	If mode_ is OVERWRITE and the output file already exists and force_ is false, prompt the user before overwriting. If the user declines, throw a marley::Error with a diagnostic message suggesting the "force" and "mode" configuration keys.
std::unique_ptr< marley::Generator >	restore_generator (const marley::JSON &config)
	Helper function for resume() that instantiates a marley::Generator object given the previous JSON configuration object.

Protected Attributes
int_fast64_t	byte_count_ = 0
	Storage for the number of bytes written to disk.
std::shared_ptr< HepMC3::GenEvent >	pending_flush_event_
std::streampos	pending_truncate_pos_ = std::streampos( -1 )
std::shared_ptr< HepMC3::ReaderAscii >	reader_
std::fstream	stream_
	Stream used to read and write from the output file as needed.
std::shared_ptr< HepMC3::WriterAscii >	writer_
	Helper object used to produce standard ASCII HepMC3 output.
Protected Attributes inherited from marley::OutputFile
bool	force_
Format	format_
	Format to use when writing events to the file.
Mode	mode_
std::string	name_
	Name of the file to receive output.

Additional Inherited Members
Public Types inherited from marley::OutputFile
enum class	Format { ASCII , ROOT }
Static Public Member Functions inherited from marley::OutputFile
static std::shared_ptr< OutputFile >	make_OutputFile (const JSON &output_config)
Protected Types inherited from marley::OutputFile
enum class	Mode { OVERWRITE , RESUME }
Static Protected Member Functions inherited from marley::OutputFile
static void	merge_reweight_provenance_weights (HepMC3::GenRunInfo &run_info, marley::Generator &gen)
	When resuming from a file that has been through one or more reweight passes, merge the reweight provenance weight calculator configurations with the original generate-time weights. Builds a combined Weighter and gives the Generator ownership. If no reweight provenance is found, this function is a no-op.

Detailed Description

Class that represents an output file in the standard ASCII format for HepMC3 events.

Definition at line 35 of file OutputFileAscii.hh.

Constructor & Destructor Documentation

OutputFileAscii()

marley::OutputFileAscii::OutputFileAscii

(

const JSON &

output_config

)

Definition at line 65 of file OutputFileAscii.cc.

  : marley::OutputFile( output_config )
{
  format_ = Format::ASCII;
 
  this->open();
  reader_ = std::make_shared< HepMC3::ReaderAscii >( stream_ );
  writer_ = std::make_shared< HepMC3::WriterAscii >( stream_ );
 
  // Ensure that all floating-point values are output with full precision
  writer_->set_precision( std::numeric_limits<double>::max_digits10 );
}

Member Function Documentation

bytes_written()

int_fast64_t marley::OutputFileAscii::bytes_written ( )

overridevirtual

The number of bytes that have been written during the current MARLEY session to this file.

Implements marley::OutputFile.

Definition at line 211 of file OutputFileAscii.cc.

                                                  {
  // If the stream is open, then update the byte count. Otherwise, just
  // use the saved value.
  if ( stream_.is_open() ) {
    stream_.flush();
    byte_count_ = static_cast<int_fast64_t>( stream_.tellp() );
  }
  return byte_count_;
}

References byte_count_, and stream_.

open()

void marley::OutputFileAscii::open ( )

protectedvirtual

Opens the owned std::fstream with the correct settings.

Definition at line 78 of file OutputFileAscii.cc.

                                 {
 
  this->prompt_before_overwrite();
 
  auto open_mode_flag = std::ios::in | std::ios::out | std::ios::trunc;
 
  if ( mode_ == Mode::RESUME ) {
    if ( !check_if_file_exists( name_ ) )
      throw marley::Error( "Cannot resume run. Could"
        " not open the file \"" + name_ + '\"' );
    else open_mode_flag = std::ios::in | std::ios::out;
  }
  else if ( mode_ != Mode::OVERWRITE ) {
    throw marley::Error( "Unrecognized file mode encountered in"
      " OutputFileAscii::open()" );
  }
 
  stream_.open( name_, open_mode_flag );
 
}

References marley::OutputFile::check_if_file_exists(), marley::OutputFile::name_, marley::OutputFile::prompt_before_overwrite(), and stream_.

resume()

bool marley::OutputFileAscii::resume ( std::unique_ptr< marley::Generator > & gen, long & num_previous_events )

overridevirtual

Load a marley::Generator object whose configuration and state were saved to the metadata in the output file.

Parameters

[out]	gen	A std::unique_ptr that will be filled with a restored Generator object constructed using the saved metadata
[out]	num_previous_events	The number of events previously saved to the output file

Returns

true if the Generator is successfully restored using the file's saved metadata, or false otherwise.

Implements marley::OutputFile.

Definition at line 99 of file OutputFileAscii.cc.

{
  if ( mode_ != Mode::RESUME ) {
    throw marley::Error( "Cannot call OutputFileAscii::resume() for an output"
      " mode other than \"resume\"" );
    return false;
  }
 
  MARLEY_LOG( INFO, "io" ) << "Continuing previous run from the file " << name_;
 
  // Create a temporary event to use for storage while parsing the file
  auto evt = std::make_shared< HepMC3::GenEvent >();
 
  // Read back the first event from the file so that we can retrieve the run
  // information
  stream_.seekg( 0, std::ios::beg );
  bool read_ok = reader_->read_event( *evt );
 
  auto run_info = evt->run_info();
 
  if ( !read_ok || !run_info ) {
    throw marley::Error( "Failed to retrieve run information from the file "
      + name_ );
    return false;
  }
 
  // Extract the prior generator JSON configuration from the RunInfo
  auto config_str = run_info->attribute< HepMC3::StringAttribute >(
    "MARLEY.JSONconfig" );
 
  if ( !config_str ) {
    throw marley::Error( "Failed to retrieve generator configuration from the"
      " file " + name_ );
    return false;
  }
 
  auto seed_str = run_info->attribute< HepMC3::StringAttribute >(
    "MARLEY.RNGseed" );
 
  if ( !seed_str ) {
    throw marley::Error( "Failed to load previous random number"
      " generator seed from the file " + name_ );
    return false;
  }
 
  // Parse the prior generator configuration into a JSON object
  auto json_config = marley::JSON::load( config_str->value() );
 
  // Move to the beginning of the last HepMC3 event in the file and
  // save its stream position for truncation
  std::streampos last_event_pos = seek_to_last_genevent( stream_ );
 
  if ( last_event_pos == std::streampos( -1 ) ) {
    throw marley::Error( "Failed to find the last event in the file "
      + name_ );
    return false;
  }
 
  // Parse the last HepMC3 event so that we can retrieve the generator state
  read_ok = reader_->read_event( *evt );
 
  auto state_str = evt->attribute< HepMC3::StringAttribute >(
    "MARLEY.GeneratorState" );
 
  if ( !read_ok || !state_str ) {
    throw marley::Error( "Failed to retrieve generator state from the file "
      + name_ );
    return false;
  }
 
  // We assume that the events in the file were originally written out using
  // the convention in the marley executable: the event number of the last
  // event in the file is equal to the total number of events.
  num_previous_events = evt->event_number();
 
  MARLEY_LOG( INFO, "io" ) << "Resuming run from \"" << name_ << "\":"
    << " found " << num_previous_events << " previous event(s)";
 
  // We're done retrieving the information. Restore the Generator to its
  // previous state
  gen = this->restore_generator( json_config );
  gen->seed_using_state_string( state_str->value() );
 
  MARLEY_LOG( INFO, "io" ) << "The previous run was initialized using"
    << " the random number generator seed " << seed_str->value();
 
  // If the file has reweight provenance, merge the accumulated weight
  // calculator configurations into the Generator's Weighter before
  // setting up run info. This ensures new events have the correct
  // number of weight slots to match the existing events in the file.
  merge_reweight_provenance_weights( *run_info, *gen );
 
  // Initialize the Generator's run info now so that it is available for
  // use below (it is normally initialized lazily inside create_event()).
  gen->set_up_run_info();
 
  // Defer truncation: save the event and truncation position so that
  // the stale GeneratorState and HepMC3 footer are removed only on the
  // first write_event() call. This ensures the GeneratorState remains in
  // the file should an exception occur before any new event is written.
  // Also reassign the event's run_info to the Generator's so that the
  // pointer-identity comparison in WriterAscii::write_event() does not
  // produce spurious "different GenRunInfo" warnings.
  evt->set_run_info( gen->run_info() );
  evt->remove_attribute( "MARLEY.GeneratorState" );
  pending_truncate_pos_ = last_event_pos;
  pending_flush_event_ = evt;
 
  return true;
}

References marley::OutputFile::merge_reweight_provenance_weights(), marley::OutputFile::name_, pending_flush_event_, pending_truncate_pos_, reader_, marley::OutputFile::restore_generator(), and stream_.

write_event()

void marley::OutputFileAscii::write_event ( HepMC3::GenEvent * event )

overridevirtual

Write a new HepMC3::GenEvent to this output file.

If a nullptr is passed to this function, then a marley::Error will be thrown

Implements marley::OutputFile.

Definition at line 221 of file OutputFileAscii.cc.

                                                               {
 
  if ( !event ) throw marley::Error( "Null pointer passed to"
    " OutputFileAscii::write_event()" );
 
  if ( pending_flush_event_ ) {
    stream_.flush();
    std::filesystem::resize_file( name_,
      static_cast<std::uintmax_t>( pending_truncate_pos_ ) );
    stream_.clear();
    stream_.seekg( pending_truncate_pos_ );
    stream_.seekp( pending_truncate_pos_ );
    writer_->set_run_info( pending_flush_event_->run_info() );
    writer_->write_event( *pending_flush_event_ );
    stream_.flush();
    pending_flush_event_.reset();
    pending_truncate_pos_ = std::streampos( -1 );
  }
 
  writer_->write_event( *event );
}

References marley::OutputFile::name_, pending_flush_event_, pending_truncate_pos_, stream_, and writer_.

Member Data Documentation

byte_count_

int_fast64_t marley::OutputFileAscii::byte_count_ = 0

protected

Storage for the number of bytes written to disk.

Definition at line 66 of file OutputFileAscii.hh.

Referenced by bytes_written().

pending_flush_event_

std::shared_ptr< HepMC3::GenEvent > marley::OutputFileAscii::pending_flush_event_

protected

Last event without its GeneratorState, to be flushed on the first write() call after resume

Definition at line 74 of file OutputFileAscii.hh.

Referenced by resume(), and write_event().

pending_truncate_pos_

std::streampos marley::OutputFileAscii::pending_truncate_pos_ = std::streampos( -1 )

protected

Stream position at which to truncate on the first write after resume, removing the stale GeneratorState and HepMC3 footer

Definition at line 70 of file OutputFileAscii.hh.

Referenced by resume(), and write_event().

reader_

std::shared_ptr< HepMC3::ReaderAscii > marley::OutputFileAscii::reader_

protected

Helper object used to read back HepMC3 events for restoring the generator state, etc.

Definition at line 60 of file OutputFileAscii.hh.

Referenced by resume().

stream_

std::fstream marley::OutputFileAscii::stream_

protected

Stream used to read and write from the output file as needed.

Definition at line 56 of file OutputFileAscii.hh.

Referenced by bytes_written(), open(), resume(), and write_event().

writer_

std::shared_ptr< HepMC3::WriterAscii > marley::OutputFileAscii::writer_

protected

Helper object used to produce standard ASCII HepMC3 output.

Definition at line 63 of file OutputFileAscii.hh.

Referenced by write_event().

---

The documentation for this class was generated from the following files:

• /home/sjg/Desktop/marley/include/marley/OutputFileAscii.hh
• /home/sjg/Desktop/marley/src/OutputFileAscii.cc