In This Package:

IO_GenEvent.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
#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 "HepMC/IO_BaseClass.h"
#include "HepMC/TempParticleMap.h"
#include "HepMC/CommonIO.h"

namespace HepMC {

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


    class IO_GenEvent : public IO_BaseClass {
    public:
        IO_GenEvent( const char* filename="IO_GenEvent.dat", 
                  std::ios::openmode mode=std::ios::out );
        IO_GenEvent( std::istream & );
        IO_GenEvent( std::ostream & );
        virtual       ~IO_GenEvent();

        void          write_event( const GenEvent* evt );
        bool          fill_next_event( GenEvent* evt );
        void          write_particle_data_table(const ParticleDataTable*);
        bool          fill_particle_data_table( ParticleDataTable* );
        void          write_comment( const std::string comment );

        int           rdstate() const;  
        void          clear();  

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

    protected: // for internal use only
        void          write_vertex( GenVertex* );
        void          write_beam_particles( std::pair<HepMC::GenParticle *,HepMC::GenParticle *> );
        void          write_heavy_ion( HeavyIon const * );
        void          write_pdf_info( PdfInfo const * );
        void          write_particle( GenParticle* p );
        void          write_particle_data( const ParticleData* d );
        GenVertex*    read_vertex( TempParticleMap& particle_to_end_vertex );
        GenParticle*  read_particle( TempParticleMap& particle_to_end_vertex );
        ParticleData* read_particle_data( ParticleDataTable* );
        HeavyIon*     read_heavy_ion(  );
        PdfInfo*      read_pdf_info(  );
        bool          write_end_listing();

        void          output( const double& );  
        void          output( const float& );  
        void          output( const int& ); 
        void          output( const long& ); 
        void          output( const char& );  
    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
//--------------------------------------------------------------------------

---