In This Package:

HepMC::IO_AsciiParticles

HepMC::IO_AsciiParticles Class Reference

Strategy for reading or writing events/particleData as machine readable ascii to a file. More...

#include <IO_AsciiParticles.h>

Inheritance diagram for HepMC::IO_AsciiParticles:

[legend]Collaboration diagram for HepMC::IO_AsciiParticles:[legend]List of all members.


Public Member Functions
	IO_AsciiParticles (const char *filename="IO_AsciiParticles.dat", std::ios::openmode mode=std::ios::out)
	constructor requiring a file name and std::ios mode
virtual	~IO_AsciiParticles ()
void	write_event (const GenEvent *evt)
	write this event
bool	fill_next_event (GenEvent *evt)
	get the next event
void	write_particle_data_table (const ParticleDataTable *)
	write this ParticleDataTable
bool	fill_particle_data_table (ParticleDataTable *)
	fill this ParticleDataTable
void	write_comment (const std::string comment)
	insert a comment directly into the output file --- normally you only want to do this at the beginning or end of the file.
void	setPrecision (int iprec)
	set output precision
int	rdstate () const
	check the state of the IO stream
void	clear ()
	clear the IO stream
void	print (std::ostream &ostr=std::cout) const
	write to ostr
GenEvent *	read_next_event ()
	do not over-ride
ParticleDataTable *	read_particle_data_table ()
	do not over-ride
virtual GenEvent *&	operator>> (GenEvent *&)
	the same as read_next_event
virtual ParticleDataTable *&	operator>> (ParticleDataTable *&)
	the same as read_particle_data_table
virtual const GenEvent *&	operator<< (const GenEvent *&)
	the same as write_event
virtual GenEvent *&	operator<< (GenEvent *&)
	the same as write_event
virtual const ParticleDataTable *&	operator<< (const ParticleDataTable *&)
	the same as write_particle_data_table
virtual ParticleDataTable *&	operator<< (ParticleDataTable *&)
	the same as write_particle_data_table
Protected Member Functions
bool	write_end_listing ()
	write end tag
Private Member Functions
	IO_AsciiParticles (const IO_AsciiParticles &)
Private Attributes
int	m_precision
std::ios::openmode	m_mode
std::fstream *	m_file
std::ostream *	m_outstream
bool	m_finished_first_event_io

Detailed Description

Strategy for reading or writing events/particleData as machine readable ascii to a file.

When instantiating, the mode of file to be created must be specified.

Definition at line 54 of file IO_AsciiParticles.h.

Constructor & Destructor Documentation

HepMC::IO_AsciiParticles::IO_AsciiParticles	(	const char *	filename = `"IO_AsciiParticles.dat"`,
		std::ios::openmode	mode = `std::ios::out`
	)

constructor requiring a file name and std::ios mode

virtual HepMC::IO_AsciiParticles::~IO_AsciiParticles ( ) [virtual]

HepMC::IO_AsciiParticles::IO_AsciiParticles ( const IO_AsciiParticles & ) [inline, private]

Definition at line 85 of file IO_AsciiParticles.h.

00085 : IO_BaseClass() {}

Member Function Documentation

void HepMC::IO_AsciiParticles::write_event ( const GenEvent * evt ) [virtual]

write this event

Implements HepMC::IO_BaseClass.

bool HepMC::IO_AsciiParticles::fill_next_event ( GenEvent * evt ) [virtual]

get the next event

Implements HepMC::IO_BaseClass.

void HepMC::IO_AsciiParticles::write_particle_data_table ( const ParticleDataTable * ) [inline, virtual]

write this ParticleDataTable

Implements HepMC::IO_BaseClass.

Definition at line 106 of file IO_AsciiParticles.h.

00106 {;}

bool HepMC::IO_AsciiParticles::fill_particle_data_table ( ParticleDataTable * ) [inline, virtual]

fill this ParticleDataTable

Implements HepMC::IO_BaseClass.

Definition at line 107 of file IO_AsciiParticles.h.

00107 {return false;}

void HepMC::IO_AsciiParticles::write_comment ( const std::string comment )

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_AsciiParticles-COMMENT\n"

void HepMC::IO_AsciiParticles::setPrecision ( int iprec ) [inline]

set output precision

Definition at line 100 of file IO_AsciiParticles.h.

00100 { m_precision=iprec; }

int HepMC::IO_AsciiParticles::rdstate ( ) const [inline]

check the state of the IO stream

Definition at line 98 of file IO_AsciiParticles.h.

00098 { return (int)m_file->rdstate(); }

void HepMC::IO_AsciiParticles::clear ( ) [inline]

clear the IO stream

Definition at line 99 of file IO_AsciiParticles.h.

00099 { m_file->clear(); }

void HepMC::IO_AsciiParticles::print ( std::ostream & ostr = std::cout ) const [virtual]

write to ostr

Reimplemented from HepMC::IO_BaseClass.

bool HepMC::IO_AsciiParticles::write_end_listing ( ) [protected]

write end tag

GenEvent * HepMC::IO_BaseClass::read_next_event ( ) [inline, inherited]

do not over-ride

creates a new event and fills it by calling the sister method read_next_event( GenEvent* )

Definition at line 87 of file IO_BaseClass.h.

00087                                                    {
00090         // 
00091         // 1. create an empty event container
00092         GenEvent* evt = new GenEvent();
00093         // 2. fill the evt container - if the read is successful, return the
00094         //    pointer, otherwise return null and delete the evt
00095         if ( fill_next_event( evt ) ) return evt;
00096         // note: the below delete is only reached if read fails
00097         //       ... thus there is not much overhead in new then delete 
00098         //       since this statement is rarely reached
00099         delete evt;
00100         return 0;
00101     }

ParticleDataTable * HepMC::IO_BaseClass::read_particle_data_table ( ) [inline, inherited]

do not over-ride

creates a new particle data table and fills it by calling the sister method read_particle_data_table( ParticleDataTable* )

Definition at line 103 of file IO_BaseClass.h.

00103                                                                      {
00106         //
00107         // 1. create an empty pdt
00108         ParticleDataTable* pdt = new ParticleDataTable();
00109         // 2. fill the pdt container - if the read is successful, return the
00110         //    pointer, otherwise return null and delete the evt
00111         if ( fill_particle_data_table( pdt ) ) return pdt;
00112         // next statement is only reached if read fails
00113         delete pdt;
00114         return 0;
00115     }

GenEvent *& HepMC::IO_BaseClass::operator>> ( GenEvent *& ) [inline, virtual, inherited]

the same as read_next_event

Definition at line 121 of file IO_BaseClass.h.

00121                                                               {
00122         evt = read_next_event();
00123         return evt;
00124     }

ParticleDataTable *& HepMC::IO_BaseClass::operator>> ( ParticleDataTable *& ) [inline, virtual, inherited]

the same as read_particle_data_table

Definition at line 137 of file IO_BaseClass.h.

00138                                                                     {
00139         pdt = read_particle_data_table();
00140         return pdt;
00141     }

const GenEvent *& HepMC::IO_BaseClass::operator<< ( const GenEvent *& ) [inline, virtual, inherited]

the same as write_event

Definition at line 126 of file IO_BaseClass.h.

00127                                                                      {
00128         write_event( evt );
00129         return evt;
00130     }

GenEvent *& HepMC::IO_BaseClass::operator<< ( GenEvent *& ) [inline, virtual, inherited]

the same as write_event

Definition at line 132 of file IO_BaseClass.h.

00132                                                                {
00133         write_event( evt );
00134         return evt;
00135     }

const ParticleDataTable *& HepMC::IO_BaseClass::operator<< ( const ParticleDataTable *& ) [inline, virtual, inherited]

the same as write_particle_data_table

Definition at line 143 of file IO_BaseClass.h.

00144                                                                              {
00145         write_particle_data_table( pdt );
00146         return pdt;
00147     }

ParticleDataTable *& HepMC::IO_BaseClass::operator<< ( ParticleDataTable *& ) [inline, virtual, inherited]

the same as write_particle_data_table

Definition at line 149 of file IO_BaseClass.h.

00150                                                                               {
00151         write_particle_data_table( pdt );
00152         return pdt;
00153     }