source: svn/trunk/Utilities/HepMC/interface/IO_GenEvent.h@ 554

//--------------------------------------------------------------------------
#ifndef HEPMC_IO_GENEVENT_H
#define HEPMC_IO_GENEVENT_H

//////////////////////////////////////////////////////////////////////////
// garren@fnal.gov, July 2007
// with input from Gavin Salam, salam@lpthe.jussieu.fr
//
// event input/output in ascii format for machine reading
// This class persists all information found in a GenEvent
//////////////////////////////////////////////////////////////////////////

#include <fstream>
#include <string>
#include <map>
#include <vector>
#include "IO_BaseClass.h"
#include "TempParticleMap.h"
#include "CommonIO.h"
#include "Units.h"

namespace HepMC {

    class GenEvent;
    class GenVertex;
    class GenParticle;
    class ParticleData;
    class HeavyIon;
    class PdfInfo;

    //! IO_GenEvent also deals with HeavyIon and PdfInfo 

    ///
    /// \class  IO_GenEvent
    /// event input/output in ascii format for machine reading
    /// extended format contains HeavyIon and PdfInfo classes
    ///
    /// Strategy for reading or writing events using iostreams
    /// When instantiating with a file name, the mode of file to be created 
    ///  must be specified. Options are:
    ///      std::ios::in     open file for input 
    ///      std::ios::out    open file for output
    ///      std::ios::trunc  erase old file when opening (i.e. ios::out|ios::trunc
    ///                    removes oldfile, and creates a new one for output )
    ///      std::ios::app    append output to end of file
    ///  for the purposes of this class, simultaneous input and output mode 
    ///  ( std::ios::in | std::ios::out ) is not allowed.
    /// 
    /// Event listings are preceded by the key:
    ///  "HepMC::IO_GenEvent-START_EVENT_LISTING\n"
    ///  and terminated by the key:
    ///  "HepMC::IO_GenEvent-END_EVENT_LISTING\n"
    /// GenParticle Data tables are preceded by the key:
    ///  "HepMC::IO_GenEvent-START_PARTICLE_DATA\n"
    ///  and terminated by the key:
    ///  "HepMC::IO_GenEvent-END_PARTICLE_DATA\n"
    /// Comments are allowed. They need not be preceded by anything, though if
    ///  a comment is written using write_comment( const string ) then it will be
    ///  preceded by "HepMC::IO_GenEvent-COMMENT\n"
    /// Each event, vertex, particle, particle data, heavy ion, or pdf info line
    ///  is preceded by   "E ","V ","P ","D ","H ","F "    respectively.
    /// Comments may appear anywhere in the file -- so long as they do not contain
    ///  any of the start/stop keys.
    ///
    class IO_GenEvent : public IO_BaseClass {
    public:
        /// constructor requiring a file name and std::ios mode
        IO_GenEvent( const std::string& filename="IO_GenEvent.dat", 
                  std::ios::openmode mode=std::ios::out );
        /// constructor requiring an input stream
        IO_GenEvent( std::istream & );
        /// constructor requiring an output stream
        IO_GenEvent( std::ostream & );
        virtual       ~IO_GenEvent();

        /// write this event
        void          write_event( const GenEvent* evt );
        /// get the next event
        bool          fill_next_event( GenEvent* evt );
        void          write_particle_data_table(const ParticleDataTable*);
        bool          fill_particle_data_table( ParticleDataTable* );
        /// insert a comment directly into the output file --- normally you
        ///  only want to do this at the beginning or end of the file. All
        ///  comments are preceded with "HepMC::IO_GenEvent-COMMENT\n"
        void          write_comment( const std::string comment );

        int           rdstate() const;  //!< check the state of the IO stream
        void          clear();  //!< clear the IO stream

        /// write to ostr
        void          print( std::ostream& ostr = std::cout ) const;

        /// needed when reading a file without units if those units are 
        /// different than the declared default units 
        /// (e.g., the default units are MeV, but the file was written with GeV)
        /// This method is not necessary if the units are written in the file
        void use_input_units( Units::MomentumUnit, Units::LengthUnit );

    protected: // for internal use only
        /// write vertex information
        void          write_vertex( GenVertex* );
        /// write beam particle information
        void          write_beam_particles( std::pair<HepMC::GenParticle *,HepMC::GenParticle *> );
        /// write heavy ion information
        void          write_heavy_ion( HeavyIon const * );
        /// write PDF information
        void          write_pdf_info( PdfInfo const * );
        /// write units
        void          write_unit_info( const GenEvent* evt );
        /// write particle information
        void          write_particle( GenParticle* p );
        /// write particle data information
        void          write_particle_data( const ParticleData* d );
        /// read vertex information
        GenVertex*    read_vertex( TempParticleMap& particle_to_end_vertex );
        /// read GenParticle information
        GenParticle*  read_particle( TempParticleMap& particle_to_end_vertex );
        /// read particle data table information
        ParticleData* read_particle_data( ParticleDataTable* );
        /// read heavy ion information
        HeavyIon*     read_heavy_ion(  );
        /// read units
        void          read_unit_info( GenEvent* evt );
        /// write end tag
        bool          write_end_listing();

        void          output( const double& );  //!< write double
        void          output( const float& );  //!< write float
        void          output( const int& ); //!< write int
        void          output( const long& ); //!< write long
        void          output( const char& );  //!< write a single character
    private: // use of copy constructor is not allowed
        IO_GenEvent( const IO_GenEvent& ) : IO_BaseClass() {}
    private: // data members
        std::ios::openmode  m_mode;
        std::fstream        m_file;
        std::ostream *      m_ostr;
        std::istream *      m_istr;
        std::ios *          m_iostr;
        bool                m_finished_first_event_io;
        bool                m_have_file;
        CommonIO            m_common_io;
        
    };

    //////////////
    // Inlines  //
    //////////////

    inline void IO_GenEvent::output( const double& d ) {
        if( m_ostr  ) {
            if ( d == 0. ) {
                *m_ostr << ' ' << (int)0;
            } else {
                *m_ostr << ' ' << d;
            }
        }
    }
    inline void IO_GenEvent::output( const float& d ) {
        if( m_ostr  ) {
            if ( d == 0. ) {
                *m_ostr << ' ' << (int)0;
            } else {
                *m_ostr << ' ' << d;
            }
        }
    }
    inline void IO_GenEvent::output( const int& i ) { 
        if( m_ostr  ) {
            if ( i == 0. ) {
                *m_ostr << ' ' << (int)0;
            } else {
                *m_ostr << ' ' << i; 
            }
        }
    }
    inline void IO_GenEvent::output( const long& i ) {
        if( m_ostr  ) {
            if ( i == 0. ) {
                *m_ostr << ' ' << (int)0;
            } else {
                *m_ostr << ' ' << i; 
            }
        }
    }
    inline void IO_GenEvent::output( const char& c ) {
        if( m_ostr  ) {
            if ( c ) {
                *m_ostr << c; 
            } else {
                *m_ostr << ' ' ;
            }
        }
    }
    inline int  IO_GenEvent::rdstate() const { 
        int state;
        if( m_istr ) {
            state =  (int)m_istr->rdstate();
        } else {
            state =  (int)m_ostr->rdstate();
        }
        return state; 
    }
    inline void IO_GenEvent::clear() { 
        if( m_istr ) {
            m_istr->clear();
        } else {
            m_ostr->clear();
        }
    }
    // these are required by IO_BaseClass, but not used here
    inline void IO_GenEvent::write_particle_data_table(const ParticleDataTable*) {;}
    inline bool IO_GenEvent::fill_particle_data_table( ParticleDataTable* ) 
    { return false;}

} // HepMC

#endif  // HEPMC_IO_GENEVENT_H
//--------------------------------------------------------------------------