[u/mrichter/AliRoot.git] / TEvtGen / HepMC / IO_AsciiParticles.cc

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

//////////////////////////////////////////////////////////////////////////////
// Mikhail.Kirsanov@Cern.CH, 2006
// event input/output in ascii format for eye and machine reading
//
// for arguments mostly similar to IO_Ascii. Special value of
// argument filename in constructor: if it is "cout" the output is to std::cout
//////////////////////////////////////////////////////////////////////////////

#include "HepMC/IO_AsciiParticles.h"
#include "HepMC/GenEvent.h"
#include "HepMC/Version.h"

namespace HepMC {

  IO_AsciiParticles::IO_AsciiParticles( const char* filename, std::ios::openmode mode ) 
  : m_precision(2),
    m_mode(mode), m_finished_first_event_io(0)
  {
    if(std::string(filename) == std::string("cout")) {
      m_outstream = &(std::cout);
      m_file = 0;
    } else {
      m_file = new std::fstream(filename, mode);
      m_outstream = m_file;
      if ( (m_mode&std::ios::out && m_mode&std::ios::in) ||
           (m_mode&std::ios::app && m_mode&std::ios::in) ) {
	    std::cerr << "IO_AsciiParticles::IO_AsciiParticles Error, open of file requested "
                  << "of input AND output type. Not allowed. Closing file."
                  << std::endl;
        m_file->close();
        delete m_file;
	return;
      }
    }
    // precision 16 (# digits following decimal point) is the minimum that
    // will capture the full information stored in a double
    // with precision <= 2 the width of output will be < 80 characters
    m_outstream->precision(m_precision);
    // we use decimal to store integers, because it is smaller than hex!
    m_outstream->setf(std::ios::dec,std::ios::basefield);
    m_outstream->setf(std::ios::scientific,std::ios::floatfield);
  }

  IO_AsciiParticles::~IO_AsciiParticles() {
    if(m_file) {
       m_file->close();
       delete m_file;
    }
  }

  void IO_AsciiParticles::print( std::ostream& ostr ) const { 
    ostr << "IO_AsciiParticles: formated ascii file IO for eye and machine reading.\n" 
         << "\tFile openmode: " << m_mode 
         << " file state: " << m_outstream->rdstate()
         << " bad:" << (m_outstream->rdstate()&std::ios::badbit)
         << " eof:" << (m_outstream->rdstate()&std::ios::eofbit)
         << " fail:" << (m_outstream->rdstate()&std::ios::failbit)
         << " good:" << (m_outstream->rdstate()&std::ios::goodbit) << std::endl;
  }

  void IO_AsciiParticles::write_event( const GenEvent* evt ) {
  // Writes evt to m_outstream. It does NOT delete the event after writing.
    //
	// check the state of m_outstream is good, and that it is in output mode
	if ( !evt || !m_outstream ) return;
	if ( !(m_mode&std::ios::out) ) {
	    std::cerr << "HepMC::IO_AsciiParticles::write_event "
		      << " attempt to write to input file." << std::endl;
	    return;
	}
	//
	// write event listing key before first event only.
	if ( !m_finished_first_event_io ) {
	    m_finished_first_event_io = 1;
        *m_outstream << "0 Run  HepMC::IO_AsciiParticles eye-readable events output"
                     << std::endl;
        *m_outstream << "#      HepMC::Version " << versionName() << std::endl;
        *m_outstream <<
    "  #  stat pdg  moth1   px        py         pz     energy    mass      eta"
                     << std::endl;
	}
	//
	// output the event data
	std::vector<long int> random_states = evt->random_states();
	*m_outstream << evt->event_number() << " Event" << std::endl;
#if 0
	*m_outstream << " " << evt->event_scale();
	output( evt->alphaQCD() );
	output( evt->alphaQED() );
	output( evt->signal_process_id() );
	output(   ( evt->signal_process_vertex() ?
		    evt->signal_process_vertex()->barcode() : 0 )   );
	output( evt->vertices_size() ); // total number of vertices.
	output( (int)random_states.size() );
	for ( std::vector<long int>::iterator rs = random_states.begin(); 
	      rs != random_states.end(); ++rs ) {
	    output( *rs );
	}
	output( (int)evt->weights().size() );
	for ( WeightContainer::const_iterator w = evt->weights().begin(); 
	      w != evt->weights().end(); ++w ) {
	    output( *w );
	}
	output('\n');
#endif
	//
    int nparticles=0, imoth=0, ip=0, istati;
    double xmassi, etai;
    *m_outstream << evt->particles_size() << " particles" << std::endl;
    GenVertex* orig;
    for(HepMC::GenEvent::particle_const_iterator part = evt->particles_begin();
        part != evt->particles_end(); ++part ) {
      //if( (*part)->status() != 1 ) continue;
      nparticles++;
      ip++;
      istati = (*part)->status();
      if( (*part)->end_vertex() && istati == 1) {
        std::cout << "final particle with end vertex!" << std::endl;
        istati = -100;
      }
      imoth=0;
      orig = (*part)->production_vertex();
      if(orig) {
        imoth = 0;
        bool ifound=false;
        for(HepMC::GenEvent::particle_const_iterator part1 =
                                                     evt->particles_begin();
                                                     part1 != part; part1++ ) {
          imoth++;
          if( (*part1)->end_vertex() == orig ) { ifound = true; break; }
        }
        if(!ifound) imoth = 0;
      }

      m_outstream->width(4);
      *m_outstream << ip << " ";

      m_outstream->width(3);
      *m_outstream << istati << " ";

      m_outstream->width(5);
      *m_outstream << (*part)->pdg_id() << " ";

      m_outstream->width(3);
      *m_outstream << imoth << "  ";

      if((*part)->momentum().px() >= 0.) *m_outstream << " ";
      *m_outstream << (*part)->momentum().px() << " ";
      if((*part)->momentum().py() >= 0.) *m_outstream << " ";
      *m_outstream << (*part)->momentum().py() << " ";
      if((*part)->momentum().pz() >= 0.) *m_outstream << " ";
      *m_outstream << (*part)->momentum().pz() << " "
             << (*part)->momentum().e() << " ";

      xmassi = (*part)->generatedMass();
      if(fabs(xmassi) < 0.0001) xmassi =0.;
      m_outstream->setf(std::ios::fixed);
      m_outstream->precision(3);
      m_outstream->width(8);
      *m_outstream << xmassi << " ";
      m_outstream->setf(std::ios::scientific,std::ios::floatfield);
      m_outstream->precision(m_precision);

      m_outstream->setf(std::ios::fixed);
      m_outstream->precision(3);
      m_outstream->width(6);
      etai = (*part)->momentum().eta();
      if(etai > 999.)etai = 999.;
      if(etai < -999.)etai = -999.;
      *m_outstream << etai << std::endl;
      m_outstream->setf(std::ios::scientific,std::ios::floatfield);
      m_outstream->precision(m_precision);

    }
  }

  bool IO_AsciiParticles::fill_next_event( GenEvent* evt ){
	//
	//
	// test that evt pointer is not null
	if ( !evt ) {
	    std::cerr 
		<< "IO_AsciiParticles::fill_next_event error - passed null event." 
		<< std::endl;
	    return false;
	}
	// check the state of m_outstream is good, and that it is in input mode
	if ( !m_file )
      std::cerr << "HepMC::IO_AsciiParticles::fill_next_event "
                << " no file for input" << std::endl;
	if ( !(m_mode&std::ios::in) ) {
	    std::cerr << "HepMC::IO_AsciiParticles::fill_next_event "
		      << " attempt to read from output file" << std::endl;
	    return false;
	}
    std::cerr << "IO_AsciiParticles input is not yet implemented" << std::endl;
    return false;
  }

  void IO_AsciiParticles::write_comment( const std::string comment ) {
	// check the state of *m_outstream is good, and that it is in output mode
	if ( !m_outstream ) return;
	if ( !(m_mode&std::ios::out) ) {
	    std::cerr << "HepMC::IO_AsciiParticles::write_particle_data_table "
		      << " attempt to write to input file." << std::endl;
	    return;
	}
	// write end of event listing key if events have already been written
	write_end_listing();
	// insert the comment key before the comment
	*m_outstream << "\n" << "HepMC::IO_AsciiParticles-COMMENT\n";
	*m_outstream << comment << std::endl;
  }

  bool IO_AsciiParticles::write_end_listing() {
	return false;
  }

} // HepMC
Commit	Line	Data
0ca57c2f	1	//--------------------------------------------------------------------------
	2
	3	//////////////////////////////////////////////////////////////////////////////
	4	// Mikhail.Kirsanov@Cern.CH, 2006
	5	// event input/output in ascii format for eye and machine reading
	6	//
	7	// for arguments mostly similar to IO_Ascii. Special value of
	8	// argument filename in constructor: if it is "cout" the output is to std::cout
	9	//////////////////////////////////////////////////////////////////////////////
	10
	11	#include "HepMC/IO_AsciiParticles.h"
	12	#include "HepMC/GenEvent.h"
	13	#include "HepMC/Version.h"
	14
	15	namespace HepMC {
	16
	17	IO_AsciiParticles::IO_AsciiParticles( const char* filename, std::ios::openmode mode )
	18	: m_precision(2),
	19	m_mode(mode), m_finished_first_event_io(0)
	20	{
	21	if(std::string(filename) == std::string("cout")) {
	22	m_outstream = &(std::cout);
	23	m_file = 0;
	24	} else {
	25	m_file = new std::fstream(filename, mode);
	26	m_outstream = m_file;
	27	if ( (m_mode&std::ios::out && m_mode&std::ios::in) \|\|
	28	(m_mode&std::ios::app && m_mode&std::ios::in) ) {
	29	std::cerr << "IO_AsciiParticles::IO_AsciiParticles Error, open of file requested "
	30	<< "of input AND output type. Not allowed. Closing file."
	31	<< std::endl;
	32	m_file->close();
	33	delete m_file;
	34	return;
	35	}
	36	}
	37	// precision 16 (# digits following decimal point) is the minimum that
	38	// will capture the full information stored in a double
	39	// with precision <= 2 the width of output will be < 80 characters
	40	m_outstream->precision(m_precision);
	41	// we use decimal to store integers, because it is smaller than hex!
	42	m_outstream->setf(std::ios::dec,std::ios::basefield);
	43	m_outstream->setf(std::ios::scientific,std::ios::floatfield);
	44	}
	45
	46	IO_AsciiParticles::~IO_AsciiParticles() {
	47	if(m_file) {
	48	m_file->close();
	49	delete m_file;
	50	}
	51	}
	52
	53	void IO_AsciiParticles::print( std::ostream& ostr ) const {
	54	ostr << "IO_AsciiParticles: formated ascii file IO for eye and machine reading.\n"
	55	<< "\tFile openmode: " << m_mode
	56	<< " file state: " << m_outstream->rdstate()
	57	<< " bad:" << (m_outstream->rdstate()&std::ios::badbit)
	58	<< " eof:" << (m_outstream->rdstate()&std::ios::eofbit)
	59	<< " fail:" << (m_outstream->rdstate()&std::ios::failbit)
	60	<< " good:" << (m_outstream->rdstate()&std::ios::goodbit) << std::endl;
	61	}
	62
	63	void IO_AsciiParticles::write_event( const GenEvent* evt ) {
	64	// Writes evt to m_outstream. It does NOT delete the event after writing.
65	//
66	// check the state of m_outstream is good, and that it is in output mode
67	if ( !evt \|\| !m_outstream ) return;
68	if ( !(m_mode&std::ios::out) ) {
69	std::cerr << "HepMC::IO_AsciiParticles::write_event "
70	<< " attempt to write to input file." << std::endl;
71	return;
72	}
73	//
74	// write event listing key before first event only.
75	if ( !m_finished_first_event_io ) {
76	m_finished_first_event_io = 1;
77	*m_outstream << "0 Run HepMC::IO_AsciiParticles eye-readable events output"
78	<< std::endl;
79	*m_outstream << "# HepMC::Version " << versionName() << std::endl;
80	*m_outstream <<
81	" # stat pdg moth1 px py pz energy mass eta"
82	<< std::endl;
83	}
84	//
85	// output the event data
86	std::vector<long int> random_states = evt->random_states();
87	*m_outstream << evt->event_number() << " Event" << std::endl;
88	#if 0
89	*m_outstream << " " << evt->event_scale();
90	output( evt->alphaQCD() );
91	output( evt->alphaQED() );
92	output( evt->signal_process_id() );
93	output( ( evt->signal_process_vertex() ?
94	evt->signal_process_vertex()->barcode() : 0 ) );
95	output( evt->vertices_size() ); // total number of vertices.
96	output( (int)random_states.size() );
97	for ( std::vector<long int>::iterator rs = random_states.begin();
98	rs != random_states.end(); ++rs ) {
99	output( *rs );
100	}
101	output( (int)evt->weights().size() );
102	for ( WeightContainer::const_iterator w = evt->weights().begin();
103	w != evt->weights().end(); ++w ) {
104	output( *w );
105	}
106	output('\n');
107	#endif
108	//
109	int nparticles=0, imoth=0, ip=0, istati;
110	double xmassi, etai;
111	*m_outstream << evt->particles_size() << " particles" << std::endl;
112	GenVertex* orig;
113	for(HepMC::GenEvent::particle_const_iterator part = evt->particles_begin();
114	part != evt->particles_end(); ++part ) {
115	//if( (*part)->status() != 1 ) continue;
116	nparticles++;
117	ip++;
118	istati = (*part)->status();
119	if( (*part)->end_vertex() && istati == 1) {
120	std::cout << "final particle with end vertex!" << std::endl;
121	istati = -100;
122	}
123	imoth=0;
124	orig = (*part)->production_vertex();
125	if(orig) {
126	imoth = 0;
127	bool ifound=false;
128	for(HepMC::GenEvent::particle_const_iterator part1 =
129	evt->particles_begin();
130	part1 != part; part1++ ) {
131	imoth++;
132	if( (*part1)->end_vertex() == orig ) { ifound = true; break; }
133	}
134	if(!ifound) imoth = 0;
135	}
136
137	m_outstream->width(4);
138	*m_outstream << ip << " ";
139
140	m_outstream->width(3);
141	*m_outstream << istati << " ";
142
143	m_outstream->width(5);
144	m_outstream << (part)->pdg_id() << " ";
145
146	m_outstream->width(3);
147	*m_outstream << imoth << " ";
148
149	if((part)->momentum().px() >= 0.) m_outstream << " ";
150	m_outstream << (part)->momentum().px() << " ";
151	if((part)->momentum().py() >= 0.) m_outstream << " ";
152	m_outstream << (part)->momentum().py() << " ";
153	if((part)->momentum().pz() >= 0.) m_outstream << " ";
154	m_outstream << (part)->momentum().pz() << " "
155	<< (*part)->momentum().e() << " ";
156
157	xmassi = (*part)->generatedMass();
158	if(fabs(xmassi) < 0.0001) xmassi =0.;
159	m_outstream->setf(std::ios::fixed);
160	m_outstream->precision(3);
161	m_outstream->width(8);
162	*m_outstream << xmassi << " ";
163	m_outstream->setf(std::ios::scientific,std::ios::floatfield);
164	m_outstream->precision(m_precision);
165
166	m_outstream->setf(std::ios::fixed);
167	m_outstream->precision(3);
168	m_outstream->width(6);
169	etai = (*part)->momentum().eta();
170	if(etai > 999.)etai = 999.;
171	if(etai < -999.)etai = -999.;
172	*m_outstream << etai << std::endl;
173	m_outstream->setf(std::ios::scientific,std::ios::floatfield);
174	m_outstream->precision(m_precision);
175
176	}
177	}
178
179	bool IO_AsciiParticles::fill_next_event( GenEvent* evt ){
180	//
181	//
182	// test that evt pointer is not null
183	if ( !evt ) {
184	std::cerr
185	<< "IO_AsciiParticles::fill_next_event error - passed null event."
186	<< std::endl;
187	return false;
188	}
189	// check the state of m_outstream is good, and that it is in input mode
190	if ( !m_file )
191	std::cerr << "HepMC::IO_AsciiParticles::fill_next_event "
192	<< " no file for input" << std::endl;
193	if ( !(m_mode&std::ios::in) ) {
194	std::cerr << "HepMC::IO_AsciiParticles::fill_next_event "
195	<< " attempt to read from output file" << std::endl;
196	return false;
197	}
198	std::cerr << "IO_AsciiParticles input is not yet implemented" << std::endl;
199	return false;
200	}
201
202	void IO_AsciiParticles::write_comment( const std::string comment ) {
203	// check the state of *m_outstream is good, and that it is in output mode
204	if ( !m_outstream ) return;
205	if ( !(m_mode&std::ios::out) ) {
206	std::cerr << "HepMC::IO_AsciiParticles::write_particle_data_table "
207	<< " attempt to write to input file." << std::endl;
208	return;
209	}
210	// write end of event listing key if events have already been written
211	write_end_listing();
212	// insert the comment key before the comment
213	*m_outstream << "\n" << "HepMC::IO_AsciiParticles-COMMENT\n";
214	*m_outstream << comment << std::endl;
215	}
216
217	bool IO_AsciiParticles::write_end_listing() {
218	return false;
219	}
220
221	} // HepMC
222