marley::OutputFileRoot Class Reference

Class that represents an output file in a ROOT-based binary format for HepMC3 events. More...

#include <OutputFileRoot.hh>

Inheritance diagram for marley::OutputFileRoot:

Public Member Functions
	OutputFileRoot (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
void	clear_event_data ()
	Clears the temporary storage for event data.
virtual void	open ()
	Opens the owned ROOT file 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
std::unique_ptr< TFile >	out_tfile_
	TFile object used to manage input/output.
TTree *	out_tree_ = nullptr
	TTree object used to store the events.
std::shared_ptr< HepMC3::GenRunInfo >	run_info_
	Copy of the run information to check for a mismatch.
std::unique_ptr< HepMC3::GenEventData >	temp_event_data_
	Temporary storage for the events.
HepMC3::GenEventData *	temp_event_data_ptr_ = nullptr
std::unique_ptr< HepMC3::GenRunInfoData >	temp_run_info_data_
	Temporary storage for the run information.
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 a ROOT-based binary format for HepMC3 events.

Definition at line 38 of file OutputFileRoot.hh.

Constructor & Destructor Documentation

OutputFileRoot()

marley::OutputFileRoot::OutputFileRoot

(

const JSON &

output_config

)

Definition at line 34 of file OutputFileRoot.cc.

  : marley::OutputFile( output_config )
{
  this->open();
}

~OutputFileRoot()

marley::OutputFileRoot::~OutputFileRoot ( )

virtual

Definition at line 40 of file OutputFileRoot.cc.

                                      {
  out_tfile_->cd();
  out_tree_->Write();
}

Member Function Documentation

bytes_written()

virtual int_fast64_t marley::OutputFileRoot::bytes_written ( )

inlineoverridevirtual

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

Implements marley::OutputFile.

Definition at line 49 of file OutputFileRoot.hh.

        { return out_tfile_->GetBytesWritten(); }

References out_tfile_.

clear_event_data()

void marley::OutputFileRoot::clear_event_data ( )

protected

Clears the temporary storage for event data.

Definition at line 180 of file OutputFileRoot.cc.

                                            {
  temp_event_data_->particles.clear();
  temp_event_data_->vertices.clear();
  temp_event_data_->links1.clear();
  temp_event_data_->links2.clear();
  temp_event_data_->attribute_id.clear();
  temp_event_data_->attribute_name.clear();
  temp_event_data_->attribute_string.clear();
}

References temp_event_data_.

Referenced by resume(), and write_event().

open()

void marley::OutputFileRoot::open ( )

protectedvirtual

Opens the owned ROOT file with the correct settings.

Definition at line 45 of file OutputFileRoot.cc.

                                {
 
  this->prompt_before_overwrite();
 
  if ( mode_ == Mode::RESUME && !check_if_file_exists( name_ ) )
    throw marley::Error( "Cannot resume run. Could"
      " not open the file \"" + name_ + '\"' );
 
  std::string open_mode_str( "update" );
  if ( mode_ == Mode::OVERWRITE ) open_mode_str = "recreate";
 
  // Open the ROOT file with the appropriate mode
  out_tfile_ = std::make_unique< TFile >( name_.c_str(),
    open_mode_str.c_str() );
 
  // Set up storage for event data to be written to the output
  temp_event_data_ptr_ = new HepMC3::GenEventData;
  temp_event_data_.reset( temp_event_data_ptr_ );
 
  // Check if the event TTree already exists in the file. If it does,
  // use it. Otherwise, create a new one and set up the "event" branch.
  out_tfile_->GetObject( "MARLEY_event_tree", out_tree_ );
  if ( !out_tree_ ) {
    out_tfile_->cd();
    out_tree_ = new TTree( "MARLEY_event_tree",
      "HepMC3-format MARLEY events" );
    out_tree_->Branch( "event", temp_event_data_ptr_ );
  }
 
  // Set the "event" branch address for the event data
  out_tree_->SetBranchAddress( "event", &temp_event_data_ptr_ );
}

References marley::OutputFile::check_if_file_exists(), marley::OutputFile::name_, out_tfile_, out_tree_, marley::OutputFile::prompt_before_overwrite(), temp_event_data_, and temp_event_data_ptr_.

resume()

bool marley::OutputFileRoot::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 78 of file OutputFileRoot.cc.

{
  if ( mode_ != Mode::RESUME ) {
    throw marley::Error( "Cannot call OutputFileRoot::resume() for an output"
      " mode other than \"resume\"" );
    return false;
  }
 
  // Retrieve the run information from the file
  HepMC3::GenRunInfoData* temp_run_info_data_ptr = nullptr;
  out_tfile_->GetObject( "MARLEY_run_info", temp_run_info_data_ptr );
  temp_run_info_data_.reset( temp_run_info_data_ptr );
 
  if ( !temp_run_info_data_ ) {
    throw marley::Error( "Failed to retrieve run information from the ROOT"
      " file \"" + name_ + "\"" );
    return false;
  }
 
  run_info_ = std::make_shared< HepMC3::GenRunInfo >();
  run_info_->read_data( *temp_run_info_data_ );
 
  // Get the generator JSON configuration
  auto config_attr = run_info_->attribute< HepMC3::StringAttribute >(
    "MARLEY.JSONconfig" );
 
  if ( !config_attr ) {
    throw marley::Error( "Failed to retrieve generator configuration from the"
      " ROOT file \"" + name_ + "\"" );
    return false;
  }
 
  std::string config_str = config_attr->value();
 
  // Initialize the generator using the JSON configuration
  marley::JSON config = marley::JSON::load( config_str );
  gen = this->restore_generator( config );
 
  // Retrieve the last event from the TTree
  num_previous_events = out_tree_->GetEntries();
 
  this->clear_event_data();
  out_tree_->GetEntry( num_previous_events - 1 );
 
  auto ev = std::make_shared< HepMC3::GenEvent >();
  ev->read_data( *temp_event_data_ );
 
  // Retrieve the generator state string from this event
  auto state_attr = ev->attribute< HepMC3::StringAttribute >(
    "MARLEY.GeneratorState" );
 
  if ( !state_attr ) {
    throw marley::Error( "Failed to retrieve generator state from the ROOT"
      " file \"" + name_ + "\"" );
    return false;
  }
 
  std::string state_str = state_attr->value();
 
  // Restore the random number generator state of the generator
  gen->seed_using_state_string( state_str );
 
  // If the file has reweight provenance, merge the accumulated weight
  // calculator configurations into the Generator's Weighter before
  // assigning the 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 );
 
  // Use the retrieved run information for making new events
  gen->set_run_info( run_info_ );
 
  return true;
}

References clear_event_data(), marley::OutputFile::merge_reweight_provenance_weights(), marley::OutputFile::name_, out_tfile_, out_tree_, marley::OutputFile::restore_generator(), run_info_, temp_event_data_, temp_run_info_data_, and HepMC3::StringAttribute::value().

write_event()

void marley::OutputFileRoot::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 153 of file OutputFileRoot.cc.

                                                              {
 
  if ( !event ) throw marley::Error( "Null pointer passed to"
    " OutputFileRoot::write_event()" );
 
  // If the run information hasn't been set, then initialize it and save it
  auto ev_run_info = event->run_info();
  if ( !run_info_ && ev_run_info ) {
    run_info_ = ev_run_info;
 
    temp_run_info_data_ = std::make_unique< HepMC3::GenRunInfoData >();
    run_info_->write_data( *temp_run_info_data_ );
 
    out_tfile_->cd();
    out_tfile_->WriteObject( temp_run_info_data_.get(),
      "MARLEY_run_info", "WriteDelete" );
  }
  else if ( run_info_ != ev_run_info ) {
    throw marley::Error( "Unexpected change in MARLEY run information" );
  }
 
  // Clear out any pre-existing contents from the temporary event storage
  this->clear_event_data();
  event->write_data( *temp_event_data_ );
  out_tree_->Fill();
}

References clear_event_data(), out_tfile_, out_tree_, run_info_, temp_event_data_, and temp_run_info_data_.

Member Data Documentation

out_tfile_

std::unique_ptr< TFile > marley::OutputFileRoot::out_tfile_

protected

TFile object used to manage input/output.

Definition at line 63 of file OutputFileRoot.hh.

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

out_tree_

TTree* marley::OutputFileRoot::out_tree_ = nullptr

protected

TTree object used to store the events.

Definition at line 68 of file OutputFileRoot.hh.

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

run_info_

std::shared_ptr< HepMC3::GenRunInfo > marley::OutputFileRoot::run_info_

protected

Copy of the run information to check for a mismatch.

Definition at line 81 of file OutputFileRoot.hh.

Referenced by resume(), and write_event().

temp_event_data_

std::unique_ptr< HepMC3::GenEventData > marley::OutputFileRoot::temp_event_data_

protected

Temporary storage for the events.

Definition at line 71 of file OutputFileRoot.hh.

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

temp_event_data_ptr_

HepMC3::GenEventData* marley::OutputFileRoot::temp_event_data_ptr_ = nullptr

protected

Bare pointer to the event data storage (needed for some ROOT manipulations)

Definition at line 75 of file OutputFileRoot.hh.

Referenced by open().

temp_run_info_data_

std::unique_ptr< HepMC3::GenRunInfoData > marley::OutputFileRoot::temp_run_info_data_

protected

Temporary storage for the run information.

Definition at line 78 of file OutputFileRoot.hh.

Referenced by resume(), and write_event().

---

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

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