HepMC3::ReaderAscii Class Reference

GenEvent I/O parsing for structured text files. More...

#include <ReaderAscii.h>

Inheritance diagram for HepMC3::ReaderAscii:

Public Member Functions
	ReaderAscii (const std::string &filename)
	Constructor.
	ReaderAscii (std::istream &)
	The ctor to read from stream.
	ReaderAscii (std::shared_ptr< std::istream > s_stream)
	The ctor to read from stream. Useful for temp. streams.
	~ReaderAscii ()
	Destructor.
void	close () override
	Close file stream.
bool	failed () override
	Return status of the stream.
bool	read_event (GenEvent &evt) override
	Load event from file.
bool	skip (const int) override
	skip events
Public Member Functions inherited from HepMC3::Reader
	Reader ()
	Constructor.
	Reader (const Reader &)=delete
	deleted copy constructor
virtual	~Reader ()
	Virtual destructor.
virtual std::map< std::string, std::string >	get_options () const
	Get options.
Reader &	operator= (const Reader &)=delete
	deleted copy assignment operator
virtual std::shared_ptr< GenRunInfo >	run_info () const
	Get the global GenRunInfo object.
virtual void	set_options (const std::map< std::string, std::string > &options)
	Set options.
virtual void	set_run_info (std::shared_ptr< GenRunInfo > run)
	Set the global GenRunInfo object.

Additional Inherited Members
Protected Attributes inherited from HepMC3::Reader
std::map< std::string, std::string >	m_options
	Options.

Detailed Description

GenEvent I/O parsing for structured text files.

Definition at line 31 of file ReaderAscii.h.

Constructor & Destructor Documentation

ReaderAscii() [1/3]

HepMC3::ReaderAscii::ReaderAscii

(

const std::string &

filename

)

Constructor.

Definition at line 2142 of file marley_hepmc3.cc.

    : m_file(filename), m_isstream(false)
{
    if ( !m_file.is_open() ) {
        HEPMC3_ERROR_LEVEL(100,"ReaderAscii: could not open input file: " << filename)
    }
    set_run_info(std::make_shared<GenRunInfo>());
}

References HepMC3::Reader::set_run_info().

ReaderAscii() [2/3]

HepMC3::ReaderAscii::ReaderAscii

(

std::istream &

stream

)

The ctor to read from stream.

Definition at line 2151 of file marley_hepmc3.cc.

    : m_stream(&stream), m_isstream(true)
{
    if ( !m_stream->good() ) {
        HEPMC3_ERROR_LEVEL(100,"ReaderAscii: could not open input stream ")
    }
    set_run_info(std::make_shared<GenRunInfo>());
}

References HepMC3::Reader::set_run_info().

ReaderAscii() [3/3]

HepMC3::ReaderAscii::ReaderAscii

(

std::shared_ptr< std::istream >

s_stream

)

The ctor to read from stream. Useful for temp. streams.

Definition at line 2161 of file marley_hepmc3.cc.

    : m_shared_stream(s_stream), m_stream(s_stream.get()), m_isstream(true)
{
    if ( !m_stream->good() ) {
        HEPMC3_ERROR_LEVEL(100,"ReaderAscii: could not open input stream ")
    }
    set_run_info(std::make_shared<GenRunInfo>());
}

References HepMC3::Reader::set_run_info().

~ReaderAscii()

HepMC3::ReaderAscii::~ReaderAscii

(

)

Destructor.

Definition at line 2170 of file marley_hepmc3.cc.

{ if (!m_isstream) close(); }

References close().

Member Function Documentation

close()

void HepMC3::ReaderAscii::close ( )

overridevirtual

Close file stream.

Implements HepMC3::Reader.

Definition at line 2716 of file marley_hepmc3.cc.

                        {
    if ( !m_file.is_open()) return;
    m_file.close();
}

Referenced by ~ReaderAscii().

failed()

bool HepMC3::ReaderAscii::failed ( )

overridevirtual

Return status of the stream.

Implements HepMC3::Reader.

Definition at line 2714 of file marley_hepmc3.cc.

{ return m_isstream ? (bool)m_stream->rdstate() :(bool)m_file.rdstate(); }

Referenced by read_event(), and skip().

read_event()

bool HepMC3::ReaderAscii::read_event ( GenEvent & evt )

overridevirtual

Load event from file.

Parameters

[out]

evt

Event to be filled

Insert the implicit vertices in the gaps of explicit vertices: Find the gaps looping over the explicit vertices

Found a gap in ids, insert an implicit vertex into a list of gaps.

Implements HepMC3::Reader.

Definition at line 2208 of file marley_hepmc3.cc.

                                          {
    if ( (!m_file.is_open()) && (!m_isstream) ) return false;
 
    char               peek(0);
    std::array<char, 262144> buf{};
    bool               event_context    = false;
    bool               parsed_weights    = false;
    bool               parsed_particles_or_vertices    = false;
    bool               run_info_context    = false;
    bool               is_parsing_successful  = true;
    std::pair<int, int> vertices_and_particles(0, 0);
 
    evt.clear();
    evt.set_run_info(run_info());
    m_io_explicit.clear();
    m_io_implicit.clear();
    m_io_implicit_ids.clear();
    m_io_explicit_ids.clear();
    m_data.particles.clear();
    m_data.vertices.clear();
    m_data.links1.clear();
    m_data.links2.clear();
    m_data.attribute_id.clear();
    m_data.attribute_name.clear();
    m_data.attribute_string.clear();
    //
    // Parse event, vertex and particle information
    //
    while (!failed()) {
        m_isstream ? m_stream->getline(buf.data(), buf.size()) : m_file.getline(buf.data(), buf.size());
 
        if ( strlen(buf.data()) == 0 ) continue;
 
        // Check for ReaderAscii header/footer
        if ( strncmp(buf.data(), "HepMC", 5) == 0 ) {
            if ( strncmp(buf.data(), "HepMC::Version", 14) != 0 && strncmp(buf.data(), "HepMC::Asciiv3", 14) != 0 )
            {
                HEPMC3_WARNING_LEVEL(500,"ReaderAscii: found unsupported expression in header. Will close the input.")
                std::cout << buf.data() << std::endl;
                m_isstream ? m_stream->clear(std::ios::eofbit) : m_file.clear(std::ios::eofbit);
            }
            if (event_context) {
                is_parsing_successful = true;
                break;
            }
            continue;
        }
 
        switch (buf[0]) {
        case 'E':
            vertices_and_particles = parse_event_information( buf.data());
            if (vertices_and_particles.second < 0) {
                is_parsing_successful = false;
            } else {
                is_parsing_successful = true;
                event_context   = true;
                parsed_weights = false;
                parsed_particles_or_vertices = false;
            }
 
 
            run_info_context   = false;
            break;
        case 'V':
            is_parsing_successful = parse_vertex_information( buf.data());
            parsed_particles_or_vertices =  true;
            break;
        case 'P':
            is_parsing_successful = parse_particle_information( buf.data());
            parsed_particles_or_vertices =  true;
            break;
        case 'W':
            if ( event_context ) {
                is_parsing_successful = parse_weight_values( buf.data());
                parsed_weights=true;
            } else {
                if ( !run_info_context ) {
                    set_run_info(std::make_shared<GenRunInfo>());
                    evt.set_run_info(run_info());
                }
                run_info_context = true;
                is_parsing_successful = parse_weight_names(buf.data());
            }
            break;
        case 'U':
            is_parsing_successful = parse_units( buf.data());
            break;
        case 'T':
            if ( event_context ) {
                //We ignore T in the event context
            } else {
                if ( !run_info_context ) {
                    set_run_info(std::make_shared<GenRunInfo>());
                    evt.set_run_info(run_info());
                }
                run_info_context = true;
                is_parsing_successful = parse_tool(buf.data());
            }
            break;
        case 'A':
            if ( event_context ) {
                is_parsing_successful = parse_attribute( buf.data());
            } else {
                if ( !run_info_context ) {
                    set_run_info(std::make_shared<GenRunInfo>());
                    evt.set_run_info(run_info());
                }
                run_info_context = true;
                is_parsing_successful = parse_run_attribute(buf.data());
            }
            break;
        default:
            HEPMC3_WARNING_LEVEL(500,"ReaderAscii: skipping unrecognised prefix: " << buf[0])
            is_parsing_successful = true;
            break;
        }
 
        if ( !is_parsing_successful ) break;
 
        // Check for next event or run info
        m_isstream ? peek = m_stream->peek() : peek = m_file.peek();
        //End of event. The next entry is event.
        if ( event_context &&  peek == 'E' ) break;
 
        //End of event. The next entry is run info which starts from weight name.
        if ( event_context &&  peek == 'W' && parsed_weights  ) break;
 
        //End of event. The next entry is run info which starts from attribute.
        if ( event_context &&  peek == 'A' && parsed_particles_or_vertices  ) break;
 
        //End of event. The next entry is run info which starts from tool.
        if ( event_context &&  peek == 'T' ) break;
 
    }

    int currid = -static_cast<int>(m_data.vertices.size());
    auto fir = m_io_implicit_ids.rbegin();
    for (const auto& iofirst: m_io_explicit_ids) {
        for (; currid < iofirst; ++currid, ++fir) {
            if (fir == m_io_implicit_ids.rend()) {
                HEPMC3_ERROR_LEVEL(600,"ReaderAscii: not enough implicit vertices")
            }
            m_io_explicit[currid] = std::move(m_io_implicit[*fir]);
        }
        ++currid;
    }
 
    for (const auto& io: m_io_explicit) {
        for (const auto& i: io.second.first) { m_data.links1.push_back(i); m_data.links2.push_back(io.first); }
        for (const auto& o: io.second.second) { m_data.links1.push_back(io.first); m_data.links2.push_back(o); }
    }
    evt.read_data(m_data);
 
    // Check if all particles and vertices were parsed
    if ((int)evt.particles().size() > vertices_and_particles.second) {
        HEPMC3_ERROR_LEVEL(600,"ReaderAscii: too many particles were parsed")
        printf("%zu  vs  %i expected\n", evt.particles().size(), vertices_and_particles.second);
        is_parsing_successful = false;
    }
    if ((int)evt.particles().size() < vertices_and_particles.second) {
        HEPMC3_ERROR_LEVEL(600,"ReaderAscii: too few  particles were parsed")
        printf("%zu  vs  %i expected\n", evt.particles().size(), vertices_and_particles.second);
        is_parsing_successful = false;
    }
 
    if ((int)evt.vertices().size()  > vertices_and_particles.first) {
        HEPMC3_ERROR_LEVEL(600,"ReaderAscii: too many vertices were parsed")
        printf("%zu  vs  %i expected\n", evt.vertices().size(), vertices_and_particles.first);
        is_parsing_successful =  false;
    }
 
    if ((int)evt.vertices().size()  < vertices_and_particles.first) {
        HEPMC3_ERROR_LEVEL(600,"ReaderAscii: too few vertices were parsed")
        printf("%zu  vs  %i expected\n", evt.vertices().size(), vertices_and_particles.first);
        is_parsing_successful =  false;
    }
    // Check if there were HEPMC3_ERRORs during parsing
    if ( !is_parsing_successful ) {
        HEPMC3_ERROR_LEVEL(600,"ReaderAscii: event parsing failed. Returning empty event")
        HEPMC3_DEBUG(1, "Parsing failed at line:" << std::endl << buf.data())
 
        evt.clear();
        m_isstream ? m_stream->clear(std::ios::badbit) : m_file.clear(std::ios::badbit);
 
        return false;
    }
 
 
    return true;
}

References HepMC3::GenEvent::clear(), failed(), HepMC3::GenEvent::particles(), HepMC3::GenEvent::read_data(), HepMC3::Reader::run_info(), HepMC3::GenEvent::set_run_info(), HepMC3::Reader::set_run_info(), and HepMC3::GenEvent::vertices().

Referenced by marley::EventFileReader::deduce_file_format().

skip()

bool HepMC3::ReaderAscii::skip ( const int n )

overridevirtual

skip events

Reimplemented from HepMC3::Reader.

Definition at line 2172 of file marley_hepmc3.cc.

{
    std::array<char, 262144> buf{};
    bool               event_context    = false;
    bool               run_info_context    = false;
    int nn = n;
    while (!failed()) {
        char  peek(0);
        if ( (!m_file.is_open()) && (!m_isstream) ) return false;
        m_isstream ? peek = m_stream->peek() : peek = m_file.peek();
        if ( peek == 'E' ) { event_context = true; nn--; }
        //We have to read each run info.
        if ( !event_context && ( peek == 'W' || peek == 'A' || peek == 'T' ) ) {
            m_isstream ? m_stream->getline(buf.data(), buf.size()) : m_file.getline(buf.data(), buf.size());
            if (!run_info_context) {
                set_run_info(std::make_shared<GenRunInfo>());
                run_info_context = true;
            }
            if ( peek == 'W' ) {
                parse_weight_names(buf.data());
            }
            if ( peek == 'T' ) {
                parse_tool(buf.data());
            }
            if ( peek == 'A' ) {
                parse_run_attribute(buf.data());
            }
        }
        if ( event_context && ( peek == 'V' || peek == 'P' ) ) event_context=false;
        if (nn < 0) return true;
        m_isstream ? m_stream->getline(buf.data(), buf.size()) : m_file.getline(buf.data(), buf.size());
    }
    return true;
}

References failed(), and HepMC3::Reader::set_run_info().

---

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

• /home/sjg/Desktop/marley/include/builtin/HepMC3/ReaderAscii.h
• /home/sjg/Desktop/marley/src/marley_hepmc3.cc