marley::EventFileReader Class Reference

Object that parses MARLEY output files. More...

#include <EventFileReader.hh>

Public Member Functions
	EventFileReader (const std::string &file_name)
double	flux_averaged_xsec (bool natural_units=false)
	Returns the flux-averaged total cross section used to produce the events in the file.
virtual bool	next_event (HepMC3::GenEvent &ev)
	Read the next MARLEY event record from the file.
virtual	operator bool () const
	Implicit boolean conversion allows the state of the input stream (or ROOT file) to be tested for readiness to read in another event.
EventFileReader &	operator>> (HepMC3::GenEvent &ev)
	Stream operator for reading in the next event.

Protected Member Functions
virtual bool	deduce_file_format ()
	Helper function that auto-detects which of the available output formats is appropriate for the requested file.
void	ensure_initialized ()
	This function should be called at the beginning of all public member functions of EventFileReader that interact with data in the file.
void	get_flux_averaged_xsec (const HepMC3::GenRunInfo &run_info)
virtual void	initialize ()
	Prepares the file for reading the events.

Protected Attributes
std::string	file_name_
	Name of the file (with any needed path specification) to be read.
double	flux_avg_tot_xs_ = 0.
	Flux-averaged total cross section (MeV -2) used to produce the events in the file, or zero if that information is not included in a particular format.
OutputFile::Format	format_
	Format of the output file being read.
std::ifstream	in_
	Input stream used to read from textual output formats.
bool	initialized_ = false
	Flag that indicates whether initialize() has been called or not.
std::shared_ptr< HepMC3::ReaderAscii >	reader_
	Helper object used to interpret ASCII-format HepMC3 files.

Detailed Description

Object that parses MARLEY output files.

Definition at line 48 of file EventFileReader.hh.

Constructor & Destructor Documentation

EventFileReader()

marley::EventFileReader::EventFileReader

(

const std::string &

file_name

)

Definition at line 39 of file EventFileReader.cc.

  : file_name_( file_name )
{
}

Member Function Documentation

deduce_file_format()

bool marley::EventFileReader::deduce_file_format ( )

protectedvirtual

Helper function that auto-detects which of the available output formats is appropriate for the requested file.

Definition at line 47 of file EventFileReader.cc.

                                               {
 
  // Before we bother to check anything else, see if the file exists and is
  // readable. Skip the MARLEY search path in this case (the event file should
  // have been passed to the constructor with any needed path specification).
  // Complain if the file cannot be read.
  const auto& fm = marley::FileManager::Instance();
  if ( fm.find_file(file_name_, "").empty() ) throw marley::Error( "Could"
    " not read from the file \"" + file_name_ + '\"' );
 
  // Create a temporary event object to use for the following format checks
  HepMC3::GenEvent temp_event;
 
  #ifdef USE_ROOT
  // Before checking if the file is in ROOT format, completely suppress any
  // error messages from ROOT.
  auto temp_error_level = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kFatal;
 
  // Try to read in a HepMC3::GenEvent from the file assuming that the ROOT
  // output format was used
  tfile_ = std::unique_ptr<TFile>( TFile::Open(file_name_.c_str(), "read") );
 
  // We've completed the ROOT format check, so restore the old error messaging
  // behavior
  gErrorIgnoreLevel = temp_error_level;
 
  if ( tfile_ ) {
    format_ = marley::OutputFile::Format::ROOT;
    return true;
  }
  #endif
 
  // Try to read in a HepMC3::GenEvent from the file assuming that the ASCII
  // output format was used
  HepMC3::ReaderAscii temp_reader( file_name_ );
  bool read_ok = temp_reader.read_event( temp_event );
  if ( read_ok ) {
 
    // Save the flux-averaged total xsec from the run information for easy
    // retrieval
    auto run_info = temp_event.run_info();
    if ( !run_info ) {
      throw marley::Error( "Missing run information while parsing an"
        " ASCII-format HepMC3 file" );
    }
 
    this->get_flux_averaged_xsec( *run_info );
 
    format_ = marley::OutputFile::Format::ASCII;
    return true;
  }
 
  // TODO: add other formats here as needed
 
  // If everything else failed, then complain that events could not be read
  return false;
}

References file_name_, format_, get_flux_averaged_xsec(), marley::FileManager::Instance(), HepMC3::ReaderAscii::read_event(), and HepMC3::GenEvent::run_info().

Referenced by ensure_initialized().

ensure_initialized()

void marley::EventFileReader::ensure_initialized ( )

protected

This function should be called at the beginning of all public member functions of EventFileReader that interact with data in the file.

It provides necessary initialization as a workaround to calling virtual functions in the constructor

Definition at line 220 of file EventFileReader.cc.

                                               {
  if ( !initialized_ ) {
 
    if ( !this->deduce_file_format() ) throw marley::Error( "Could not"
      " read MARLEY events from the file \"" + file_name_ + '\"' );
 
    this->initialize();
    initialized_ = true;
  }
}

References deduce_file_format(), file_name_, initialize(), and initialized_.

Referenced by flux_averaged_xsec(), and next_event().

flux_averaged_xsec()

double marley::EventFileReader::flux_averaged_xsec

(

bool

natural_units = false

)

Returns the flux-averaged total cross section used to produce the events in the file.

For file formats which do not include this information, this function will return zero

Parameters

[in]

natural_units

If true, then this function will return the flux-averaged total cross section in natural units (MeV -2). If false (default), then 10-42 cm2 will be used.

Definition at line 231 of file EventFileReader.cc.

                                                                     {
  this->ensure_initialized();
  if ( natural_units ) return flux_avg_tot_xs_;
  double result = flux_avg_tot_xs_ * marley_utils::hbar_c2
    * marley_utils::fm2_to_minus40_cm2 * 1e2; // 10^{-42} cm^2
  return result;
}

References ensure_initialized(), and flux_avg_tot_xs_.

get_flux_averaged_xsec()

void marley::EventFileReader::get_flux_averaged_xsec ( const HepMC3::GenRunInfo & run_info )

protected

Helper function for loading the flux-averaged total cross section information from the HepMC3 run information

Definition at line 239 of file EventFileReader.cc.

{
  auto avg_xsec_attr = run_info.attribute< HepMC3::DoubleAttribute >(
    "NuHepMC.FluxAveragedTotalCrossSection" );
  if ( !avg_xsec_attr ) {
    throw marley::Error( "Missing flux-averaged total cross section while"
      " parsing a HepMC3 file" );
  }
 
  // Retrieve the flux-averaged total cross section and convert it back to
  // natural units (MeV^{-2}) from picobarn
  flux_avg_tot_xs_ = avg_xsec_attr->value()
    / ( marley_utils::hbar_c2 * marley_utils::fm2_to_picobarn );
}

References HepMC3::GenRunInfo::attribute(), and flux_avg_tot_xs_.

Referenced by deduce_file_format(), and initialize().

initialize()

void marley::EventFileReader::initialize ( )

protectedvirtual

Prepares the file for reading the events.

Definition at line 106 of file EventFileReader.cc.

                                       {
  switch ( format_ ) {
 
    case marley::OutputFile::Format::ASCII:
    {
      in_.open( file_name_ );
      reader_ = std::make_shared< HepMC3::ReaderAscii >( in_ );
      break;
    }
 
    #ifdef USE_ROOT
    case marley::OutputFile::Format::ROOT:
    {
      tfile_->GetObject( "MARLEY_event_tree", ttree_ );
      if ( !ttree_ ) throw marley::Error( "Failed to load MARLEY event TTree"
        " from the ROOT file \"" + file_name_ + '\"' );
 
      temp_event_data_ = std::make_unique< HepMC3::GenEventData >();
      temp_event_data_ptr_ = temp_event_data_.get();
      ttree_->SetBranchAddress( "event", &temp_event_data_ptr_ );
 
      tfile_->GetObject( "MARLEY_run_info", temp_run_info_data_ );
      if ( !temp_run_info_data_ ) throw marley::Error( "Failed to load"
        " MARLEY run information from the ROOT file \"" + file_name_ + '\"' );
 
      run_info_ = std::make_shared< HepMC3::GenRunInfo >();
      run_info_->read_data( *temp_run_info_data_ );
 
      this->get_flux_averaged_xsec( *run_info_ );
 
      break;
    }
    #endif
 
    default:
      throw marley::Error( "Unrecognized file format encountered in"
        " marley::EventFileReader::initialize()" );
  }
}

References file_name_, format_, get_flux_averaged_xsec(), in_, and reader_.

Referenced by ensure_initialized().

next_event()

bool marley::EventFileReader::next_event ( HepMC3::GenEvent & ev )

virtual

Read the next MARLEY event record from the file.

Parameters

[out]

ev

Reference to the object that will be filled with the next event record

Returns

True if reading the next event was successful, or false otherwise. This behavior is designed to be used as a while loop condition for iterating over events in the output file

Definition at line 146 of file EventFileReader.cc.

{
  this->ensure_initialized();
  switch ( format_ ) {
 
    case marley::OutputFile::Format::ASCII:
    {
      bool read_ok = reader_->read_event( ev );
      return read_ok && in_;
      break;
    }
 
    #ifdef USE_ROOT
    case marley::OutputFile::Format::ROOT:
    {
      ++event_num_;
      if ( event_num_ < ttree_->GetEntries() ) {
 
        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();
 
        ttree_->GetEntry( event_num_ );
        ev.read_data( *temp_event_data_ );
        ev.set_run_info( run_info_ );
        return true;
      }
 
      ev = HepMC3::GenEvent();
      return false;
 
      break;
    }
    #endif
 
    default:
      throw marley::Error( "Unrecognized file format encountered in"
        " marley::EventFileReader::next_event()" );
  }
 
  ev = HepMC3::GenEvent();
  return false;
}

References ensure_initialized(), format_, in_, HepMC3::GenEvent::read_data(), reader_, and HepMC3::GenEvent::set_run_info().

Referenced by operator>>().

operator bool()

marley::EventFileReader::operator bool ( ) const

virtual

Implicit boolean conversion allows the state of the input stream (or ROOT file) to be tested for readiness to read in another event.

Definition at line 194 of file EventFileReader.cc.

                                           {
 
  switch ( format_ ) {
 
    case marley::OutputFile::Format::ASCII:
    {
      return static_cast< bool >( in_ );
      break;
    }
 
    #ifdef USE_ROOT
    case marley::OutputFile::Format::ROOT:
    {
      return ( tfile_ && ttree_ && event_num_ < ttree_->GetEntries() );
      break;
    }
    #endif
 
    default:
      throw marley::Error( "Unrecognized file format encountered in"
        " marley::EventFileReader::operator bool()" );
  }
 
  return false;
}

References format_, and in_.

operator>>()

EventFileReader & marley::EventFileReader::operator>> ( HepMC3::GenEvent & ev )

inline

Stream operator for reading in the next event.

Definition at line 75 of file EventFileReader.hh.

                                                               {
        next_event( ev );
        return *this;
      }

References next_event().

Member Data Documentation

file_name_

std::string marley::EventFileReader::file_name_

protected

Name of the file (with any needed path specification) to be read.

Definition at line 89 of file EventFileReader.hh.

Referenced by deduce_file_format(), ensure_initialized(), and initialize().

flux_avg_tot_xs_

double marley::EventFileReader::flux_avg_tot_xs_ = 0.

protected

Flux-averaged total cross section (MeV ^-2) used to produce the events in the file, or zero if that information is not included in a particular format.

Definition at line 133 of file EventFileReader.hh.

Referenced by flux_averaged_xsec(), and get_flux_averaged_xsec().

format_

OutputFile::Format marley::EventFileReader::format_

protected

Format of the output file being read.

This format will be determined automatically by deduce_file_format() and does not need to be specified by the user

Definition at line 94 of file EventFileReader.hh.

Referenced by deduce_file_format(), initialize(), next_event(), and operator bool().

in_

std::ifstream marley::EventFileReader::in_

protected

Input stream used to read from textual output formats.

Definition at line 97 of file EventFileReader.hh.

Referenced by initialize(), next_event(), and operator bool().

initialized_

bool marley::EventFileReader::initialized_ = false

protected

Flag that indicates whether initialize() has been called or not.

To avoid problems with using virtual functions in the constructor, we defer nearly all of the initialization to the first call to one of the other public member functions.

Definition at line 139 of file EventFileReader.hh.

Referenced by ensure_initialized().

reader_

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

protected

Helper object used to interpret ASCII-format HepMC3 files.

Definition at line 100 of file EventFileReader.hh.

Referenced by initialize(), and next_event().

---

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

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