IO_GenEvent.cc

//--------------------------------------------------------------------------

// garren@fnal.gov, July 2006
// event input/output in ascii format for machine reading
// IO_GenEvent format contains HeavyIon and PdfInfo classes

#include "HepMC/IO_GenEvent.h"
#include "HepMC/IO_Exception.h"
#include "HepMC/GenEvent.h"
#include "HepMC/StreamHelpers.h"

namespace HepMC {

    IO_GenEvent::IO_GenEvent( const std::string& filename, std::ios::openmode mode ) 
    : m_mode(mode), 
      m_file(filename.c_str(), mode), 
      m_ostr(0),
      m_istr(0),
      m_iostr(0),
      m_have_file(false),
      m_error_type(IO_Exception::OK),
      m_error_message()
    {
        if ( (m_mode&std::ios::out && m_mode&std::ios::in) ||
             (m_mode&std::ios::app && m_mode&std::ios::in) ) {
            m_error_type = IO_Exception::InputAndOutput;
            m_error_message ="IO_GenEvent::IO_GenEvent Error, open of file requested of input AND output type. Not allowed. Closing file.";
            std::cerr << m_error_message << std::endl;
            m_file.close();
            return;
        }
        // now we set the streams
        m_iostr = &m_file;
        if ( m_mode&std::ios::in ) {
            m_istr = &m_file;
            m_ostr = NULL;
            detail::establish_input_stream_info(m_file);
        }
        if ( m_mode&std::ios::out ) {
            m_ostr = &m_file;
            m_istr = NULL;
            detail::establish_output_stream_info(m_file);
        }
        m_have_file = true;
    }


    IO_GenEvent::IO_GenEvent( std::istream & istr ) 
    : m_ostr(0),
      m_istr(&istr),
      m_iostr(&istr),
      m_have_file(false),
      m_error_type(IO_Exception::OK),
      m_error_message()
    { 
        detail::establish_input_stream_info( istr );
    }

    IO_GenEvent::IO_GenEvent( std::ostream & ostr )
    : m_ostr(&ostr),
      m_istr(0),
      m_iostr(&ostr),
      m_have_file(false),
      m_error_type(IO_Exception::OK),
      m_error_message()
   {
        detail::establish_output_stream_info( ostr );
   }

    IO_GenEvent::~IO_GenEvent() {
        if ( m_ostr != NULL ) {
            write_HepMC_IO_block_end(*m_ostr);
        }
        if(m_have_file) m_file.close();
    }

    void IO_GenEvent::use_input_units( Units::MomentumUnit mom, 
                                       Units::LengthUnit len ) {
        if( m_istr != NULL ) {
            set_input_units( *m_istr, mom, len );
        }
    }

    void IO_GenEvent::print( std::ostream& ostr ) const { 
        ostr << "IO_GenEvent: unformated ascii file IO for machine reading.\n"; 
        if(m_have_file)    ostr  << "\tFile openmode: " << m_mode ;
        ostr << " stream state: " << m_ostr->rdstate()
             << " bad:" << (m_ostr->rdstate()&std::ios::badbit)
             << " eof:" << (m_ostr->rdstate()&std::ios::eofbit)
             << " fail:" << (m_ostr->rdstate()&std::ios::failbit)
             << " good:" << (m_ostr->rdstate()&std::ios::goodbit) << std::endl;
    }

    void IO_GenEvent::precision( int size )  { 
        if( size > 16 ) { 
            std::cerr << "IO_GenEvent::precision Error, "
                      << "precision is greater than 16. "
                      << "Not allowed. Using default precision of 16."
                      << std::endl;
            size = 16;
        }
        if(m_ostr) {
            m_ostr->precision(size);
        }
    }
        
    bool IO_GenEvent::fill_next_event( GenEvent* evt ){
        //
        // reset error type
        m_error_type = IO_Exception::OK;
        //
        // test that evt pointer is not null
        if ( !evt ) {
            m_error_type = IO_Exception::NullEvent;
            m_error_message = "IO_GenEvent::fill_next_event error - passed null event.";
            std::cerr << m_error_message << std::endl;
            return false;
        }
        // make sure the stream is good, and that it is in input mode
        if ( !(*m_istr) ) return false;
        if ( !m_istr ) {
            m_error_type = IO_Exception::WrongFileType;
            m_error_message = "HepMC::IO_GenEvent::fill_next_event attempt to read from output file.";
            std::cerr << m_error_message << std::endl;
            return false;
        }
        // use streaming input
        try {
            *m_istr >> *evt;
        }
        catch (IO_Exception& e) {
            m_error_type = IO_Exception::InvalidData;
            m_error_message = e.what();
            evt->clear();
            return false;
        }
        if( evt->is_valid() ) return true;
        return false;
    }

    void IO_GenEvent::write_event( const GenEvent* evt ) {
        //
        // make sure the state is good, and that it is in output mode
        if ( !evt  ) return;
        if ( m_ostr == NULL ) {
            m_error_type = IO_Exception::WrongFileType;
            m_error_message = "HepMC::IO_GenEvent::write_event attempt to write to input file.";
            std::cerr << m_error_message << std::endl;
            return;
        }
        //
        // write event listing key before first event only.
        write_HepMC_IO_block_begin(*m_ostr);
        // explicit cast is necessary
        GenEvent e = *evt;
        *m_ostr << e ;
    }

    void IO_GenEvent::write_comment( const std::string comment ) {
        // make sure the stream is good, and that it is in output mode
        if ( !(*m_ostr) ) return;
        if ( m_ostr == NULL ) {
            m_error_type = IO_Exception::WrongFileType;
            m_error_message = "HepMC::IO_GenEvent::write_event attempt to write to input file.";
            std::cerr << m_error_message << std::endl;
            return;
        }
        // write end of event listing key if events have already been written
        write_HepMC_IO_block_end(*m_ostr);
        // insert the comment key before the comment
        *m_ostr << "\n" << "HepMC::IO_GenEvent-COMMENT\n";
        *m_ostr << comment << std::endl;
    }
        
} // HepMC