Changeset 571 in svn for trunk/Utilities/HepMC/src

Timestamp:

Nov 2, 2011, 5:06:22 PM (13 years ago)

Author:

cp3-support

Message:

upgrade HepMC to version 2.06.05

Location:

trunk/Utilities/HepMC/src

Files:

• CompareGenEvent.cc (modified) (1 diff)
• GenCrossSection.cc (added)
• GenEvent.cc (modified) (17 diffs)
• GenEventStreamIO.cc (added)
• GenParticle.cc (modified) (4 diffs)
• GenRanges.cc (added)
• GenVertex.cc (modified) (4 diffs)
• HeavyIon.cc (added)
• IO_AsciiParticles.cc (modified) (1 diff)
• IO_GenEvent.cc (modified) (8 diffs)
• PdfInfo.cc (added)
• Polarization.cc (modified) (4 diffs)
• StreamHelpers.cc (added)
• StreamInfo.cc (added)
• Units.cc (modified) (2 diffs)
• WeightContainer.cc (added)
• filterEvent.cc (added)

trunk/Utilities/HepMC/src/CompareGenEvent.cc

@@ -91 +91 @@
 
 bool compareWeights( GenEvent* e1, GenEvent* e2 ) {
-   WeightContainer w1 = e1->weights();
-   WeightContainer w2 = e2->weights();
-   if( w1.size() != w2.size() ) { 
-       std::cerr << "compareWeights: size of weight container differs " << std::endl;
-       return false; 
-   }
-   for( int i=0; i<w1.size(); ++i ) {
-       if( w1[i] != w2[i] ) {
-           std::cerr << "compareWeights: weight container entry " 
-                     << i << " differs" << std::endl;
-           return false; 
-       }
-   }
-   return true;
+   if( e1->weights() == e2->weights() ) return true;
+   std::cerr << "compareWeights: weight containers differ " << std::endl;
+   return false;
 }
 

trunk/Utilities/HepMC/src/GenEvent.cc

@@ -14 +14 @@
 
 #include "GenEvent.h"
+#include "GenCrossSection.h"
 #include "Version.h"
+#include "StreamHelpers.h"
 
 namespace HepMC {
@@ -38 +40 @@
         m_vertex_barcodes(),
         m_particle_barcodes(),
+        m_cross_section(0), 
         m_heavy_ion(0), 
         m_pdf_info(0),
@@ -71 +74 @@
         m_vertex_barcodes(),
         m_particle_barcodes(),
+        m_cross_section(0), 
         m_heavy_ion( new HeavyIon(ion) ), 
         m_pdf_info( new PdfInfo(pdf) ),
@@ -102 +106 @@
         m_vertex_barcodes(),
         m_particle_barcodes(),
+        m_cross_section(0), 
         m_heavy_ion(0), 
         m_pdf_info(0),
@@ -136 +141 @@
         m_vertex_barcodes(),
         m_particle_barcodes(),
+        m_cross_section(0), 
         m_heavy_ion( new HeavyIon(ion) ), 
         m_pdf_info( new PdfInfo(pdf) ),
@@ -162 +168 @@
         m_vertex_barcodes      ( /* inevent.m_vertex_barcodes */ ),
         m_particle_barcodes    ( /* inevent.m_particle_barcodes */ ),
+        m_cross_section        ( inevent.cross_section() ? new GenCrossSection(*inevent.cross_section()) : 0 ),
         m_heavy_ion            ( inevent.heavy_ion() ? new HeavyIon(*inevent.heavy_ion()) : 0 ),
         m_pdf_info             ( inevent.pdf_info() ? new PdfInfo(*inevent.pdf_info()) : 0 ),
@@ -168 +175 @@
     {
         /// deep copy - makes a copy of all vertices!
-        //++s_counter;
         //
 
@@ -234 +240 @@
         m_vertex_barcodes.swap(   other.m_vertex_barcodes );
         m_particle_barcodes.swap( other.m_particle_barcodes );
+        std::swap(m_cross_section        , other.m_cross_section        );
         std::swap(m_heavy_ion            , other.m_heavy_ion            );
         std::swap(m_pdf_info             , other.m_pdf_info             );
@@ -252 +259 @@
     {
         /// Deep destructor.
-        /// deletes all vertices/particles in this evt
-        ///
+        /// deletes all vertices/particles in this GenEvent
+        /// deletes the associated HeavyIon and PdfInfo
         delete_all_vertices();
+        delete m_cross_section;
         delete m_heavy_ion;
         delete m_pdf_info;
-        //--s_counter;
     }
 
@@ -281 +288 @@
                   : 0 )
              << "\n";
-        //ostr << " Current Memory Usage: " 
-        //     << GenEvent::counter() << " events, "
-        //     << GenVertex::counter() << " vertices, "
-        //     << GenParticle::counter() << " particles.\n"; 
         write_units( ostr );
+        write_cross_section(ostr);
         ostr << " Entries this event: " << vertices_size() << " vertices, "
              << particles_size() << " particles.\n"; 
@@ -302 +306 @@
         // Weights
         ostr << " Wgts(" << weights().size() << ")=";
-        for ( WeightContainer::const_iterator wgt = weights().begin();
-              wgt != weights().end(); ++wgt ) { ostr << *wgt << " "; }
-        ostr << "\n";
+        weights().print(ostr);
         ostr << " EventScale " << event_scale() 
              << " [energy] \t alphaQCD=" << alphaQCD() 
@@ -367 +369 @@
         ///
         delete_all_vertices();
+        // remove existing objects and set pointers to null
+        delete m_cross_section;
+        m_cross_section = 0;
         delete m_heavy_ion;
+        m_heavy_ion = 0;
         delete m_pdf_info;
+        m_pdf_info = 0;
         m_signal_process_id = 0;
         m_beam_particle_1 = 0;
         m_beam_particle_2 = 0;
         m_event_number = 0;
+        m_mpi = -1;
         m_event_scale = -1;
         m_alphaQCD = -1;
@@ -378 +386 @@
         m_weights = std::vector<double>();
         m_random_states = std::vector<long>();
-        //m_momentum_unit = ;
-        //m_position_unit = ;
+        // resetting unit information
+        m_momentum_unit = Units::default_momentum_unit();
+        m_position_unit = Units::default_length_unit();
         // error check just to be safe
         if ( m_vertex_barcodes.size() != 0 
@@ -388 +397 @@
                       << m_vertex_barcodes.size() << "  " 
                       << m_particle_barcodes.size() << std::endl;
-            //std::cerr << "Total Number vtx,particle in memory "
-             //         << "after method called = "
-             //         << GenVertex::counter() << "\t"
-                //      << GenParticle::counter() << std::endl;
         }
         return;
@@ -420 +425 @@
                       << m_vertex_barcodes.size() << "  " 
                       << m_particle_barcodes.size() << std::endl;
-            //std::cerr << "Total Number vtx,particle in memory "
-            //          << "after method called = "
-            //          << GenVertex::counter() << "\t"
-                //      << GenParticle::counter() << std::endl;
         }
     }
@@ -602 +603 @@
     }
 
+    void GenEvent::write_cross_section( std::ostream& os ) const
+    {
+        // write the GenCrossSection information if the cross section was set
+        if( !cross_section() ) return;
+        if( cross_section()->is_set() ) {
+            os << " Cross Section: " << cross_section()->cross_section() ;
+            os << " +/- " << cross_section()->cross_section_error() ;
+            os << std::endl;
+        }
+    }
+
    bool GenEvent::use_momentum_unit( Units::MomentumUnit newunit ) { 
         // currently not exception-safe. 
@@ -651 +663 @@
     }  
 
+    bool GenEvent::is_valid() const {
+        /// A GenEvent is presumed valid if it has both associated
+        /// particles and vertices.   No other information is checked.
+        if ( vertices_empty() ) return false;
+        if ( particles_empty() ) return false;
+        return true;
+    }
+
+    std::ostream & GenEvent::write_beam_particles(std::ostream & os, 
+                         std::pair<HepMC::GenParticle *,HepMC::GenParticle *> pr )
+    {
+        GenParticle* p = pr.first;
+        if(!p) {
+           detail::output( os, 0 );
+        } else {
+           detail::output( os, p->barcode() );
+        }
+        p = pr.second;
+        if(!p) {
+           detail::output( os, 0 );
+        } else {
+           detail::output( os, p->barcode() );
+        }
+
+        return os;
+    }
+
+    std::ostream & GenEvent::write_vertex(std::ostream & os, GenVertex const * v)
+    {
+        if ( !v || !os ) {
+            std::cerr << "GenEvent::write_vertex !v||!os, "
+                      << "v="<< v << " setting badbit" << std::endl;
+            os.clear(std::ios::badbit); 
+            return os;
+        }
+        // First collect info we need
+        // count the number of orphan particles going into v
+        int num_orphans_in = 0;
+        for ( GenVertex::particles_in_const_iterator p1
+                  = v->particles_in_const_begin();
+              p1 != v->particles_in_const_end(); ++p1 ) {
+            if ( !(*p1)->production_vertex() ) ++num_orphans_in;
+        }
+        //
+        os << 'V';
+        detail::output( os, v->barcode() ); // v's unique identifier
+        detail::output( os, v->id() );
+        detail::output( os, v->position().x() );
+        detail::output( os, v->position().y() );
+        detail::output( os, v->position().z() );
+        detail::output( os, v->position().t() );
+        detail::output( os, num_orphans_in );
+        detail::output( os, (int)v->particles_out_size() );
+        detail::output( os, (int)v->weights().size() );
+        for ( WeightContainer::const_iterator w = v->weights().begin(); 
+              w != v->weights().end(); ++w ) {
+            detail::output( os, *w );
+        }
+        detail::output( os,'\n');
+        // incoming particles
+        for ( GenVertex::particles_in_const_iterator p2 
+                  = v->particles_in_const_begin();
+              p2 != v->particles_in_const_end(); ++p2 ) {
+            if ( !(*p2)->production_vertex() ) {
+                write_particle( os, *p2 );
+            }
+        }
+        // outgoing particles
+        for ( GenVertex::particles_out_const_iterator p3 
+                  = v->particles_out_const_begin();
+              p3 != v->particles_out_const_end(); ++p3 ) {
+            write_particle( os, *p3 );
+        }
+        return os;
+    }
+
+    std::ostream & GenEvent::write_particle( std::ostream & os, GenParticle const * p )
+    {
+        if ( !p || !os ) {
+            std::cerr << "GenEvent::write_particle !p||!os, "
+                      << "p="<< p << " setting badbit" << std::endl;
+            os.clear(std::ios::badbit); 
+            return os;
+        }
+        os << 'P';
+        detail::output( os, p->barcode() );
+        detail::output( os, p->pdg_id() );
+        detail::output( os, p->momentum().px() );
+        detail::output( os, p->momentum().py() );
+        detail::output( os, p->momentum().pz() );
+        detail::output( os, p->momentum().e() );
+        detail::output( os, p->generated_mass() );
+        detail::output( os, p->status() );
+        detail::output( os, p->polarization().theta() );
+        detail::output( os, p->polarization().phi() );
+        // since end_vertex is oftentimes null, this CREATES a null vertex
+        // in the map
+        detail::output( os,   ( p->end_vertex() ? p->end_vertex()->barcode() : 0 )  );
+        os << ' ' << p->flow() << "\n";
+
+        return os;
+    }
+
 } // HepMC

trunk/Utilities/HepMC/src/GenParticle.cc

@@ -39 +39 @@
         m_pdg_id( inparticle.pdg_id() ), 
         m_status( inparticle.status() ), 
-        m_flow(this),
+        m_flow(inparticle.flow()),
         m_polarization( inparticle.polarization() ),
         m_production_vertex(0), 
@@ -188 +188 @@
     /// Dump this particle's full info to ostr
     std::ostream& operator<<( std::ostream& ostr, const GenParticle& part ) {
+        // find the current stream state
+        std::ios_base::fmtflags orig = ostr.flags();
+        std::streamsize prec = ostr.precision();
         ostr << " ";
         ostr.width(9);
@@ -199 +202 @@
         ostr << part.momentum().px() << ",";
         ostr.width(9);
-        ostr.precision(2);
         ostr << part.momentum().py() << ",";
         ostr.width(9);
-        ostr.precision(2);
         ostr << part.momentum().pz() << ",";
         ostr.width(9);
-        ostr.precision(2);
         ostr << part.momentum().e() << " ";
         ostr.setf(std::ios::fmtflags(0), std::ios::floatfield);
@@ -227 +227 @@
             ostr << (void*)part.end_vertex();
         }
+        // restore the stream state
+        ostr.flags(orig);
+        ostr.precision(prec);
         return ostr;
     }

trunk/Utilities/HepMC/src/GenVertex.cc

@@ -144 +144 @@
 
     void GenVertex::print( std::ostream& ostr ) const {
+        // find the current stream state
+        std::ios_base::fmtflags orig = ostr.flags();
+        std::streamsize prec = ostr.precision();
         if ( barcode()!=0 ) {
             if ( position() != FourVector(0,0,0,0) ) {
@@ -159 +162 @@
                 ostr << position().x() << ",";
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().y() << ",";
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().z() << ",";
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().t();
                 ostr.setf(std::ios::fmtflags(0), std::ios::floatfield);
@@ -198 +198 @@
                 ostr << position().x();
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().y();
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().z();
                 ostr.width(9);
-                ostr.precision(2);
                 ostr << position().t();
                 ostr.setf(std::ios::fmtflags(0), std::ios::floatfield);
@@ -249 +246 @@
             ostr << **part2 << std::endl;
         }
+        // restore the stream state
+        ostr.flags(orig);
+        ostr.precision(prec);
     }
 

trunk/Utilities/HepMC/src/IO_AsciiParticles.cc

@@ -11 +11 @@
 #include "IO_AsciiParticles.h"
 #include "GenEvent.h"
-#include "ParticleDataTable.h"
 #include "Version.h"
 

trunk/Utilities/HepMC/src/IO_GenEvent.cc

@@ -8 +8 @@
 
 #include "IO_GenEvent.h"
+#include "IO_Exception.h"
 #include "GenEvent.h"
-#include "ParticleDataTable.h"
-#include "HeavyIon.h"
-#include "PdfInfo.h"
-#include "CommonIO.h"
-#include "Version.h"
+#include "StreamHelpers.h"
 
 namespace HepMC {
@@ -23 +20 @@
       m_istr(0),
       m_iostr(0),
-      m_finished_first_event_io(false),
       m_have_file(false),
-      m_common_io()
+      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) ) {
-            std::cerr << "IO_GenEvent::IO_GenEvent Error, open of file requested "
-                      << "of input AND output type. Not allowed. Closing file."
-                      << std::endl;
+            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;
         }
-        // precision 16 (# digits following decimal point) is the minimum that
-        //  will capture the full information stored in a double
-        m_file.precision(16);
-        // we use decimal to store integers, because it is smaller than hex!
-        m_file.setf(std::ios::dec,std::ios::basefield);
-        m_file.setf(std::ios::scientific,std::ios::floatfield);
         // now we set the streams
         m_iostr = &m_file;
@@ -46 +37 @@
             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;
@@ -59 +52 @@
       m_istr(&istr),
       m_iostr(&istr),
-      m_finished_first_event_io(false),
       m_have_file(false),
-      m_common_io()
-    { }
+      m_error_type(IO_Exception::OK),
+      m_error_message()
+    { 
+        detail::establish_input_stream_info( istr );
+    }
 
     IO_GenEvent::IO_GenEvent( std::ostream & ostr )
@@ -68 +63 @@
       m_istr(0),
       m_iostr(&ostr),
-      m_finished_first_event_io(false),
       m_have_file(false),
-      m_common_io()
-    {
-        // precision 16 (# digits following decimal point) is the minimum that
-        //  will capture the full information stored in a double
-        m_ostr->precision(16);
-        // we use decimal to store integers, because it is smaller than hex!
-        m_ostr->setf(std::ios::dec,std::ios::basefield);
-        m_ostr->setf(std::ios::scientific,std::ios::floatfield);
-    }
+      m_error_type(IO_Exception::OK),
+      m_error_message()
+   {
+        detail::establish_output_stream_info( ostr );
+   }
 
     IO_GenEvent::~IO_GenEvent() {
-        write_end_listing();
+        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 ) {
-        m_common_io.use_input_units(mom,len);
+    void IO_GenEvent::use_input_units( Units::MomentumUnit mom, 
+                                       Units::LengthUnit len ) {
+        if( m_istr != NULL ) {
+            set_input_units( *m_istr, mom, len );
+        }
     }
 
@@ -99 +94 @@
     }
 
+    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 ) {
         /// Writes evt to output stream. It does NOT delete the event after writing.
@@ -105 +147 @@
         if ( !evt  ) return;
         if ( m_ostr == NULL ) {
-            std::cerr << "HepMC::IO_GenEvent::write_event "
-                      << " attempt to write to input file." << std::endl;
+            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.
-        if ( !m_finished_first_event_io ) {
-            m_finished_first_event_io = 1;
-            *m_ostr << "\n" << "HepMC::Version " << versionName();
-            *m_ostr << "\n";
-            m_common_io.write_IO_GenEvent_Key(*m_ostr);
-        }
-        //
-        // output the event data including the number of primary vertices
-        //  and the total number of vertices
-        std::vector<long> random_states = evt->random_states();
-        *m_ostr << 'E';
-        output( evt->event_number() );
-        output( evt->mpi() );
-        output( 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.
-        write_beam_particles( evt->beam_particles() );
-        output( (int)random_states.size() );
-        for ( std::vector<long>::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');
-        write_unit_info( evt );
-        write_heavy_ion( evt->heavy_ion() );
-        write_pdf_info( evt->pdf_info() );
-        //
-        // Output all of the vertices - note there is no real order.
-        for ( GenEvent::vertex_const_iterator v = evt->vertices_begin();
-              v != evt->vertices_end(); ++v ) {
-            write_vertex( *v );
-        }
-    }
-
-    bool IO_GenEvent::fill_next_event( GenEvent* evt ){
-        //
-        //
-        // test that evt pointer is not null
-        if ( !evt ) {
-            std::cerr 
-                << "IO_GenEvent::fill_next_event error - passed null event." 
-                << 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 ) {
-            std::cerr << "HepMC::IO_GenEvent::fill_next_event "
-                      << " attempt to read from output file." << std::endl;
-            return false;
-        }
-        //
-        // search for event listing key before first event only.
-        //
-        // skip through the file just after first occurence of the start_key
-        int iotype = 0;
-        if ( !m_finished_first_event_io ) {
-            iotype = m_common_io.find_file_type(*m_istr);
-            if( iotype <= 0 ) {
-                std::cerr << "IO_GenEvent::fill_next_event start key not found "
-                          << "setting badbit." << std::endl;
-                m_istr->clear(std::ios::badbit); 
-                return false;
-            }
-            m_finished_first_event_io = 1;
-        }
-        //
-        // test to be sure the next entry is of type "E" then ignore it
-        if ( !(*m_istr) ) { 
-                std::cerr << "IO_GenEvent::fill_next_event end of stream found "
-                          << "setting badbit." << std::endl;
-                m_istr->clear(std::ios::badbit); 
-                return false;
-        }
-        if ( !(*m_istr) || m_istr->peek()!='E' ) { 
-            // if the E is not the next entry, then check to see if it is
-            // the end event listing key - if yes, search for another start key
-            int ioendtype = m_common_io.find_end_key(*m_istr);
-            if ( ioendtype == iotype ) {
-                iotype = m_common_io.find_file_type(*m_istr);
-                if( iotype <= 0 ) {
-                    // this is the only case where we set an EOF state
-                    m_istr->clear(std::ios::eofbit);
-                    return false;
-                }
-            } else if ( ioendtype > 0 ) {
-                std::cerr << "IO_GenEvent::fill_next_event end key does not match start key "
-                          << "setting badbit." << std::endl;
-                m_istr->clear(std::ios::badbit); 
-                return false;
-            } else {
-                std::cerr << "IO_GenEvent::fill_next_event end key not found "
-                          << "setting badbit." << std::endl;
-                m_istr->clear(std::ios::badbit); 
-                return false;
-            }
-        }
-        m_istr->ignore();
-        // call the appropriate read method
-        if( m_common_io.io_type() == gen ) {
-            return m_common_io.read_io_genevent(m_istr, evt);
-        } else if( m_common_io.io_type() == ascii ) { 
-            return m_common_io.read_io_ascii(m_istr, evt);
-        } else if( m_common_io.io_type() == extascii ) { 
-            return m_common_io.read_io_extendedascii(m_istr, evt);
-        } else if( m_common_io.io_type() == ascii_pdt ) { 
-        } else if( m_common_io.io_type() == extascii_pdt ) { 
-        }
-        // should not get to this statement
-        return false;
+        write_HepMC_IO_block_begin(*m_ostr);
+        // explicit cast is necessary
+        GenEvent e = *evt;
+        *m_ostr << e ;
     }
 
@@ -236 +164 @@
         if ( !(*m_ostr) ) return;
         if ( m_ostr == NULL ) {
-            std::cerr << "HepMC::IO_GenEvent::write_comment "
-                      << " attempt to write to input file." << std::endl;
+            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_end_listing();
+        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;
     }
-
-    void IO_GenEvent::write_vertex( GenVertex* v ) {
-        // assumes mode has already been checked
-        if ( !v || !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_vertex !v||!(*m_ostr), "
-                      << "v="<< v << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        // First collect info we need
-        // count the number of orphan particles going into v
-        int num_orphans_in = 0;
-        for ( GenVertex::particles_in_const_iterator p1
-                  = v->particles_in_const_begin();
-              p1 != v->particles_in_const_end(); ++p1 ) {
-            if ( !(*p1)->production_vertex() ) ++num_orphans_in;
-        }
-        //
-        *m_ostr << 'V';
-        output( v->barcode() ); // v's unique identifier
-        output( v->id() );
-        output( v->position().x() );
-        output( v->position().y() );
-        output( v->position().z() );
-        output( v->position().t() );
-        output( num_orphans_in );
-        output( (int)v->particles_out_size() );
-        output( (int)v->weights().size() );
-        for ( WeightContainer::iterator w = v->weights().begin(); 
-              w != v->weights().end(); ++w ) {
-            output( *w );
-        }
-        output('\n');
-        for ( GenVertex::particles_in_const_iterator p2 
-                  = v->particles_in_const_begin();
-              p2 != v->particles_in_const_end(); ++p2 ) {
-            if ( !(*p2)->production_vertex() ) {
-                write_particle( *p2 );
-            }
-        }
-        for ( GenVertex::particles_out_const_iterator p3 
-                  = v->particles_out_const_begin();
-              p3 != v->particles_out_const_end(); ++p3 ) {
-            write_particle( *p3 );
-        }
-    }
-
-    void IO_GenEvent::write_beam_particles( 
-        std::pair<HepMC::GenParticle *,HepMC::GenParticle *> pr ) {
-        GenParticle* p = pr.first;
-        //m_file << 'B';
-        if(!p) {
-           output( 0 );
-        } else {
-           output( p->barcode() );
-        }
-        p = pr.second;
-        if(!p) {
-           output( 0 );
-        } else {
-           output( p->barcode() );
-        }
-    }
-
-    void IO_GenEvent::write_heavy_ion( HeavyIon const * ion ) {
-        // assumes mode has already been checked
-        if ( !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_heavy_ion !(*m_ostr), "
-                      << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        *m_ostr << 'H';
-        // HeavyIon* is set to 0 by default
-        if ( !ion  ) {
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0 );
-            output( 0. );
-            output( 0. );
-            output( 0. );
-            output( 0. );
-            output('\n');
-            return;
-        }
-        //
-        output( ion->Ncoll_hard() );
-        output( ion->Npart_proj() );
-        output( ion->Npart_targ() );
-        output( ion->Ncoll() );
-        output( ion->spectator_neutrons() );
-        output( ion->spectator_protons() );
-        output( ion->N_Nwounded_collisions() );
-        output( ion->Nwounded_N_collisions() );
-        output( ion->Nwounded_Nwounded_collisions() );
-        output( ion->impact_parameter() );
-        output( ion->event_plane_angle() );
-        output( ion->eccentricity() );
-        output( ion->sigma_inel_NN() );
-        output('\n');
-    }
-
-    void IO_GenEvent::write_pdf_info( PdfInfo const * pdf ) {
-        // assumes mode has already been checked
-        if ( !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_pdf_info !(*m_ostr), "
-                      << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        *m_ostr << 'F';
-        // PdfInfo* is set to 0 by default
-        if ( !pdf ) {
-            output( 0 );
-            output( 0 );
-            output( 0. );
-            output( 0. );
-            output( 0. );
-            output( 0. );
-            output( 0. );
-            output( 0 );
-            output( 0 );
-            output('\n');
-            return;
-        }
-        //
-        output( pdf->id1() );
-        output( pdf->id2() );
-        output( pdf->x1() );
-        output( pdf->x2() );
-        output( pdf->scalePDF() );
-        output( pdf->pdf1() );
-        output( pdf->pdf2() );
-        output( pdf->pdf_id1() );
-        output( pdf->pdf_id2() );
-        output('\n');
-    }
-
-    void IO_GenEvent::write_unit_info( const GenEvent* evt ) {
-        if ( !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_unit_info !(*m_ostr), "
-                      << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        // could write enums here, but strings are more readable
-        *m_ostr << "U " << name(evt->momentum_unit());
-        *m_ostr << " " << name(evt->length_unit());
-        output('\n');
-    }
-
-    void IO_GenEvent::write_particle( GenParticle* p ) {
-        // assumes mode has already been checked
-        if ( !p || !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_particle !p||!(*m_ostr), "
-                      << "p="<< p << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        *m_ostr << 'P';
-        output( p->barcode() );
-        output( p->pdg_id() );
-        output( p->momentum().px() );
-        output( p->momentum().py() );
-        output( p->momentum().pz() );
-        output( p->momentum().e() );
-        output( p->generated_mass() );
-        output( p->status() );
-        output( p->polarization().theta() );
-        output( p->polarization().phi() );
-        // since end_vertex is oftentimes null, this CREATES a null vertex
-        // in the map
-        output(   ( p->end_vertex() ? p->end_vertex()->barcode() : 0 )  );
-        *m_ostr << ' ' << p->flow() << "\n";
-    }
-
-    void IO_GenEvent::write_particle_data( const ParticleData* pdata ) {
-        // assumes mode has already been checked
-        if ( !pdata || !(*m_ostr) ) {
-            std::cerr << "IO_GenEvent::write_particle_data !pdata||!(*m_ostr), "
-                      << "pdata="<< pdata << " setting badbit" << std::endl;
-            m_ostr->clear(std::ios::badbit); 
-            return;
-        }
-        *m_ostr << 'D';
-        output( pdata->pdg_id() );
-        output( pdata->charge() );
-        output( pdata->mass() );
-        output( pdata->clifetime() );
-        output( (int)(pdata->spin()*2.+.1) );
-        // writes the first 21 characters starting with 0
-        *m_ostr << " " << pdata->name().substr(0,21) << "\n";
-    }
-
-    HeavyIon* IO_GenEvent::read_heavy_ion()
-    {
-        // assumes mode has already been checked
-        //
-        // test to be sure the next entry is of type "H" then ignore it
-        if ( !(*m_istr) || m_istr->peek()!='H' ) {
-            std::cerr << "IO_GenEvent::read_heavy_ion setting badbit." << std::endl;
-            m_istr->clear(std::ios::badbit); 
-            return false;
-        } 
-        m_istr->ignore();
-        // read values into temp variables, then create a new HeavyIon object
-        int nh =0, np =0, nt =0, nc =0, 
-            neut = 0, prot = 0, nw =0, nwn =0, nwnw =0;
-        float impact = 0., plane = 0., xcen = 0., inel = 0.; 
-        *m_istr >> nh >> np >> nt >> nc >> neut >> prot
-               >> nw >> nwn >> nwnw >> impact >> plane >> xcen >> inel;
-        m_istr->ignore(2,'\n');
-        if( nh == 0 ) return false;
-        HeavyIon* ion = new HeavyIon(nh, np, nt, nc, neut, prot,
-                                     nw, nwn, nwnw, 
-                                     impact, plane, xcen, inel );
-        //
-        return ion;
-    }
-
-    GenParticle* IO_GenEvent::read_particle(
-        TempParticleMap& particle_to_end_vertex ){
-        // assumes mode has already been checked
-        //
-        // test to be sure the next entry is of type "P" then ignore it
-        if ( !(*m_istr) || m_istr->peek()!='P' ) { 
-            std::cerr << "IO_GenEvent::read_particle setting badbit." 
-                      << std::endl;
-            m_istr->clear(std::ios::badbit); 
-            return false;
-        } 
-        m_istr->ignore();
-        //
-        // declare variables to be read in to, and read everything except flow
-        double px = 0., py = 0., pz = 0., e = 0., m = 0., theta = 0., phi = 0.;
-        int bar_code = 0, id = 0, status = 0, end_vtx_code = 0, flow_size = 0;
-        *m_istr >> bar_code >> id >> px >> py >> pz >> e >> m >> status 
-               >> theta >> phi >> end_vtx_code >> flow_size;
-        //
-        // read flow patterns if any exist
-        Flow flow;
-        int code_index, code;
-        for ( int i = 1; i <= flow_size; ++i ) {
-            *m_istr >> code_index >> code;
-            flow.set_icode( code_index,code);
-        }
-        m_istr->ignore(2,'\n'); // '\n' at end of entry
-        GenParticle* p = new GenParticle( FourVector(px,py,pz,e), 
-                                    id, status, flow, 
-                                    Polarization(theta,phi) );
-        p->set_generated_mass( m );
-        p->suggest_barcode( bar_code );
-        //
-        // all particles are connected to their end vertex separately 
-        // after all particles and vertices have been created - so we keep
-        // a map of all particles that have end vertices
-        if ( end_vtx_code != 0 ) {
-            particle_to_end_vertex.addEndParticle(p,end_vtx_code);
-        }
-        return p;
-    }
-
-    ParticleData* IO_GenEvent::read_particle_data( ParticleDataTable* pdt ) {
-        // assumes mode has already been checked
-        //
-        // test to be sure the next entry is of type "D" then ignore it
-        if ( !(*m_istr) || m_istr->peek()!='D' ) return false;
-        m_istr->ignore();
-        //
-        // read values into temp variables then create new ParticleData object
-        char its_name[22];
-        int its_id = 0, its_spin = 0;  
-        double its_charge = 0, its_mass = 0, its_clifetime = 0;
-        *m_istr >> its_id >> its_charge >> its_mass 
-               >> its_clifetime >> its_spin;
-        m_istr->ignore(1); // eat the " "
-        m_istr->getline( its_name, 22, '\n' );
-        ParticleData* pdata = new ParticleData( its_name, its_id, its_charge, 
-                                                its_mass, its_clifetime, 
-                                                double(its_spin)/2.);
-        pdt->insert(pdata);
-        return pdata;
-    }
-
-    bool IO_GenEvent::write_end_listing() {
-        if ( m_finished_first_event_io && (m_ostr != NULL) ) {
-            m_common_io.write_IO_GenEvent_End(*m_ostr);
-            *m_ostr << std::flush;
-            m_finished_first_event_io = 0;
-            return true;
-        }
-        return false;
-    }
         
 } // HepMC

trunk/Utilities/HepMC/src/Polarization.cc

@@ -9 +9 @@
 namespace HepMC {
 
+    Polarization::Polarization( )
+    : m_theta( 0. ),
+      m_phi( 0. ),
+      m_defined( false )
+    { }
+
     Polarization::Polarization( double theta, double phi )
     : m_theta( valid_theta(theta) ),
-      m_phi  ( valid_phi(phi) )
+      m_phi  ( valid_phi(phi) ),
+      m_defined( true )
     { }
 
     Polarization::Polarization( const Polarization& inpolar )
     : m_theta( valid_theta( inpolar.theta() ) ),
-      m_phi  ( valid_phi(   inpolar.phi()   ) )
+      m_phi  ( valid_phi(   inpolar.phi()   ) ),
+      m_defined( inpolar.is_defined() )
     { }
 
     Polarization::Polarization( const ThreeVector& vec3in ) 
     : m_theta( valid_theta( vec3in.theta() ) ),
-      m_phi  ( valid_phi(   vec3in.phi()   ) )
+      m_phi  ( valid_phi(   vec3in.phi()   ) ),
+      m_defined( true )
     { }
 
@@ -28 +37 @@
         std::swap( m_theta, other.m_theta );
         std::swap( m_phi,   other.m_phi   );
+        std::swap( m_defined, other.m_defined );
     }
 
@@ -64 +74 @@
         return m_phi = valid_phi( phi );
     }
+    
+    bool Polarization::is_defined( ) const {
+        return m_defined;
+    }
+    
+    void Polarization::set_undefined() {
+        m_defined = false;
+        m_theta = 0.;
+        m_phi = 0.;
+    }
 
     void Polarization::set_theta_phi( double theta, double phi ) {
         set_theta( theta );
         set_phi( phi ) ;
+        m_defined = true;
     }
 
@@ -73 +94 @@
         set_theta( vec3in.theta() );
         set_phi( vec3in.phi() );
+        m_defined = true;
         return vec3in;
     }

trunk/Utilities/HepMC/src/Units.cc

@@ -52 +52 @@
     // if this function fails to compile, rerun configure using --with-length_units
     LengthUnit default_length_unit() {
-      //return @HEPMC_DEFAULT_LEN_UNIT@ ;
       return MM ;
     }
@@ -58 +57 @@
     // if this function fails to compile, rerun configure using --with-momentum_units
     MomentumUnit default_momentum_unit() {
-      //return @HEPMC_DEFAULT_MOM_UNIT@ ;
-      return GEV;
+      return GEV ;
     }