EIC code displayed by LXR master/​include/​HepMC/​GenEvent.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:01:09

 //--------------------------------------------------------------------------
 #ifndef HEPMC_GEN_EVENT_H
 #define HEPMC_GEN_EVENT_H
 
 //////////////////////////////////////////////////////////////////////////
 // Matt.Dobbs@Cern.CH, September 1999, refer to:
 // M. Dobbs and J.B. Hansen, "The HepMC C++ Monte Carlo Event Record for
 // High Energy Physics", Computer Physics Communications (to be published).
 //
 // Event record for MC generators (for use at any stage of generation)
 //////////////////////////////////////////////////////////////////////////
 //
 // This class is intended as both a "container class" ( to store a MC
 //  event for interface between MC generators and detector simulation )
 //  and also as a "work in progress class" ( that could be used inside
 //  a generator and modified as the event is built ).
 //
 // Iterators are provided which allow the user to easily obtain a
 //  list of particles or vertices in an event --- this list can be filled
 //  subject to some sort of selection criteria. Examples are given below
 //  ( see HepMC::copy_if and std::copy )
 
 ///
 /// \namespace HepMC
 /// All classes in the HepMC packages are in the HepMC namespace 
 ///
 namespace HepMC {
 
     // To create a list from an iterator, use: (i.e. for a list of particles);
     // #include <algorithm>
     //     list<GenParticle*> thelist;
     //     copy( evt->particles_begin(), evt->particles_end(), 
     //           back_inserter(thelist) );
     // to create a list subject to a condition (predicate) use:
     //     list<GenParticle*> thelist;
     //     HepMC::copy_if( evt->particles_begin(), evt->particles_end(), 
     //                     back_inserter(thelist), is_photon() );
     // where is_photon() is a predicate like:
     //     class is_photon {
     //       public:
     //         bool operator() ( GenParticle const * p ) {
     //             if ( p && p->pdg_id() == 22 ) return true;
     //             return false;
     //         }
     //     };
     // which the user defines herself.
 
     /// define the type of iterator to use
     template <class InputIterator, class OutputIterator, class Predicate>
     void copy_if( InputIterator first, InputIterator last, OutputIterator out,
           Predicate pred ) {
     for ( ; first != last; ++first ) { if ( pred(*first) ) out = *first; }
     }
 } // HepMC
 
 // Since a container of all vertices in the event is maintained, the time
 //  required to loop over all vertices (or particles) is very fast -- and 
 //  the user does not gain much by first making his own list.
 //  (this is not true for the GenVertex:: versions of these iterators, which
 //   allow you to specify the vertex starting point and range)
 
 // Data Members:
 // signal_process_id()   The integer ID that uniquely specifies this signal
 //                       process, i.e. MSUB in Pythia. It is necessary to
 //                       package this with each event rather than with the run
 //                       because many processes may be generated within one
 //                       run.
 // event_number()        Strictly speaking we cannot think of any reason that
 //                       an event would need to know its own event number, it
 //                       is more likely something that would be assigned by
 //                       a database. It is included anyway (tradition?) since
 //                       we expect it may be useful for debugging. It can
 //                       be reset later by a database.
 // mpi()                 The number of multi parton interactions in the event.
 //                       This is NOT beam pileup.  Set to -1 by default.
 // beam_particles()      A pair of pointers to the incoming beam particles.
 // signal_process_vertex() pointer to the vertex containing the signal process
 // weights()             Vector of doubles which specify th weight of the evnt,
 //                       the first entry will be the "event weight" used for
 //                       hit and miss etc., but a general vector is used to
 //                       allow for reweighting etc. We envision a list of
 //                       WeightTags to be included with a run class which
 //                       would specify the meaning of the Weights .
 // random_states()       Vector of integers which specify the random number 
 //                       generator's state for this event. It is left to the
 //                       generator to make use of this. We envision a vector of
 //                       RndmStatesTags to be included with a run class which
 //                       would specify the meaning of the random_states.
 //
 ///////////////////////
 // Memory allocation //
 ///////////////////////
 // -When a vertex (particle) is added to a event (vertex), it is "adopted" 
 //  and becomes the responsibility of the event (vertex) to delete that 
 //  particle. 
 // -objects responsible for deleting memory:
 //    -events delete included vertices
 //    -each vertex deletes its outgoing particles which do not have decay
 //     vertices
 //    -each vertex deletes its incoming particles which do not
 //     have creation vertices 
 //
 ////////////////////////
 // About the Barcodes //
 ////////////////////////
 // - each vertex or particle has a barcode, which is just an integer which
 //   uniquely identifies it inside the event (i.e. there is a one to one
 //   mapping between particle memory addresses and particle barcodes... and 
 //   the same applied for vertices)
 // - The value of a barcode has NO MEANING and NO ORDER!
 //   For the user's convenience, when an event is read in via an IO_method
 //   from an indexed list (like the HEPEVT common block), then the index will
 //   become the barcode for that particle.
 // - particle barcodes are always positive integers
 //   vertex barcodes are always negative integers
 //   The barcodes are chosen and set automatically when a vertex or particle
 //   comes under the ownership of an event (i.e. it is contained in an event).
 // - You can tell when a particle or vertex is owned, because its 
 //   parent_event() return value will return a pointer to the event which owns
 //   it (or null if its an orphan).
 // - Please note that the barcodes are intended for internal use within HepMC 
 //   as a unique identifier for the particles and vertices.
 //   Using the barcode to encode extra information is an abuse of 
 //   the barcode data member and causes confusion among users. 
 // 
 
 #include "HepMC/GenVertex.h"
 #include "HepMC/GenParticle.h"
 #include "HepMC/WeightContainer.h"
 #include "HepMC/GenCrossSection.h"
 #include "HepMC/HeavyIon.h"
 #include "HepMC/PdfInfo.h"
 #include "HepMC/Units.h"
 #include "HepMC/HepMCDefs.h"
 #include <map>
 #include <string>
 #include <vector>
 #include <algorithm>
 #include <iostream>
 
 namespace HepMC {
 
     class GenEventVertexRange;
     class ConstGenEventVertexRange;
     class GenEventParticleRange;
     class ConstGenEventParticleRange;
 
     //! The GenEvent class is the core of HepMC
 
     ///
     /// \class GenEvent 
     /// HepMC::GenEvent contains information about generated particles.
     /// GenEvent is structured as a set of vertices which contain the particles.
     ///
     class GenEvent {
     friend class GenParticle;
     friend class GenVertex;  
     public:
         /// default constructor creates null pointers to HeavyIon, PdfInfo, and GenCrossSection
     GenEvent( int signal_process_id = 0, int event_number = 0,
           GenVertex* signal_vertex = 0,
           const WeightContainer& weights = std::vector<double>(),
           const std::vector<long>& randomstates = std::vector<long>(),
           Units::MomentumUnit = Units::default_momentum_unit(), 
           Units::LengthUnit = Units::default_length_unit() );
         /// explicit constructor that takes HeavyIon and PdfInfo
     GenEvent( int signal_process_id, int event_number,
           GenVertex* signal_vertex, const WeightContainer& weights,
           const std::vector<long>& randomstates,
           const HeavyIon& ion, const PdfInfo& pdf,
           Units::MomentumUnit = Units::default_momentum_unit(), 
           Units::LengthUnit = Units::default_length_unit() );
         /// constructor requiring units - all else is default
     GenEvent( Units::MomentumUnit, Units::LengthUnit,
               int signal_process_id = 0, int event_number = 0,
           GenVertex* signal_vertex = 0,
           const WeightContainer& weights = std::vector<double>(),
           const std::vector<long>& randomstates = std::vector<long>() );
         /// explicit constructor with units first that takes HeavyIon and PdfInfo
     GenEvent( Units::MomentumUnit, Units::LengthUnit,
               int signal_process_id, int event_number,
           GenVertex* signal_vertex, const WeightContainer& weights,
           const std::vector<long>& randomstates,
           const HeavyIon& ion, const PdfInfo& pdf );
     GenEvent( const GenEvent& inevent );          //!< deep copy
     GenEvent& operator=( const GenEvent& inevent ); //!< make a deep copy
     virtual ~GenEvent(); //!<deletes all vertices/particles in this evt
 
         void swap( GenEvent & other );  //!< swap
     
     void print( std::ostream& ostr = std::cout ) const; //!< dumps to ostr
     void print_version( std::ostream& ostr = std::cout ) const; //!< dumps release version to ostr
 
         /// assign a barcode to a particle
     GenParticle* barcode_to_particle( int barCode ) const;
         /// assign a barcode to a vertex
     GenVertex*   barcode_to_vertex(   int barCode ) const;
 
     ////////////////////
     // access methods //
     ////////////////////
 
     int signal_process_id() const; //!<  unique signal process id
     int event_number() const; //!<  event number
     int mpi() const;          //!<  number of multi parton interactions
     double event_scale() const; //!< energy scale, see hep-ph/0109068
     double alphaQCD() const; //!<  QCD coupling, see hep-ph/0109068
     double alphaQED() const; //!<  QED coupling, see hep-ph/0109068
         /// pointer to the vertex containing the signal process
     GenVertex* signal_process_vertex() const;
     /// test to see if we have two valid beam particles
     bool valid_beam_particles() const;
     /// pair of pointers to the two incoming beam particles
     std::pair<HepMC::GenParticle*,HepMC::GenParticle*> beam_particles() const;
     /// check GenEvent for validity
     /// A GenEvent is presumed valid if it has particles and/or vertices.
     bool is_valid() const;
 
     /// direct access to the weights container is allowed. 
     /// Thus you can use myevt.weights()[2];
     /// to access element 2 of the weights.
     /// or use myevt.weights().push_back( mywgt ); to add an element.
     /// and you can set the weights with myevt.weights() = myvector;
     WeightContainer&        weights(); //!< direct access to WeightContainer
     const WeightContainer&  weights() const; //!< direct access to WeightContainer
 
     /// access the GenCrossSection container if it exists
     GenCrossSection const *     cross_section() const;
     GenCrossSection*            cross_section();
     /// access the HeavyIon container if it exists
     HeavyIon const *         heavy_ion() const;
     HeavyIon*                heavy_ion();
     /// access the PdfInfo container if it exists
     PdfInfo const *          pdf_info() const;
     PdfInfo*                 pdf_info();
 
     /// vector of integers containing information about the random state
     const std::vector<long>& random_states() const;
 
         /// how many particle barcodes exist?
     int     particles_size() const;
         /// return true if there are no particle barcodes
     bool    particles_empty() const;
         /// how many vertex barcodes exist?
     int     vertices_size() const;
         /// return true if there are no vertex barcodes
     bool    vertices_empty() const;
 
     /// Write the unit information to an output stream.  
     /// If the output stream is not defined, use std::cout.
         void write_units( std::ostream & os = std::cout ) const; 
     /// If the cross section is defined,
     /// write the cross section information to an output stream.  
     /// If the output stream is not defined, use std::cout.
     void write_cross_section( std::ostream& ostr = std::cout ) const;
 
     /// Units used by the GenParticle momentum FourVector.
     Units::MomentumUnit momentum_unit() const;
     /// Units used by the GenVertex position FourVector.
     Units::LengthUnit   length_unit()   const;
     
     std::ostream& write(std::ostream&);
     std::istream& read(std::istream&);
 
     /////////////////////
     // mutator methods //
     /////////////////////
 
     bool    add_vertex( GenVertex* vtx );    //!< adds to evt and adopts
     bool    remove_vertex( GenVertex* vtx ); //!< erases vtx from evt
     void    clear();                         //!< empties the entire event
     
     void set_signal_process_id( int id ); //!< set unique signal process id
     void set_event_number( int eventno ); //!< set event number
     void set_mpi( int  ); //!< set number of multi parton interactions
     void set_event_scale( double scale ); //!< set energy scale
     void set_alphaQCD( double a ); //!< set QCD coupling
     void set_alphaQED( double a ); //!< set QED coupling
 
         /// set pointer to the vertex containing the signal process
     void set_signal_process_vertex( GenVertex* );
     /// set incoming beam particles
     bool set_beam_particles(GenParticle*, GenParticle*);
         /// use a pair of GenParticle*'s to set incoming beam particles
     bool set_beam_particles(std::pair<HepMC::GenParticle*,HepMC::GenParticle*> const &);
     /// provide random state information
     void set_random_states( const std::vector<long>& randomstates );
 
     /// provide a pointer to the GenCrossSection container
     void set_cross_section( const GenCrossSection& );
     /// provide a pointer to the HeavyIon container
     void set_heavy_ion( const HeavyIon& ion );
     /// provide a pointer to the PdfInfo container
     void set_pdf_info( const PdfInfo& p );
     
     /// set the units using enums
     /// This method will convert momentum and position data if necessary
     void use_units( Units::MomentumUnit, Units::LengthUnit );
     /// set the units using strings
     /// the string must match the enum exactly
     /// This method will convert momentum and position data if necessary
         void use_units( std::string&, std::string& );
     
     /// set the units using enums
     /// This method will NOT convert momentum and position data
     void define_units( Units::MomentumUnit, Units::LengthUnit );
     /// set the units using strings
     /// the string must match the enum exactly
     /// This method will NOT convert momentum and position data
         void define_units( std::string&, std::string& );
     
     /// vertex range
     GenEventVertexRange vertex_range();
     /// vertex range
     ConstGenEventVertexRange vertex_range() const;
     /// particle range
     GenEventParticleRange particle_range();
     /// particle range
     ConstGenEventParticleRange particle_range() const;
 
     public:
     ///////////////////////////////
     // vertex_iterators          //
     ///////////////////////////////
     // Note:  the XXX_iterator is "resolvable" as XXX_const_iterator, but 
     //  not the reverse, which is consistent with STL, 
     //  see Musser, Derge, Saini 2ndEd. p. 69,70.
 
     //!  const vertex iterator
 
     /// \class  vertex_const_iterator
     /// HepMC::GenEvent::vertex_const_iterator
     /// is used to iterate over all vertices in the event.
     class vertex_const_iterator :
       public std::iterator<std::forward_iterator_tag,HepMC::GenVertex*,ptrdiff_t>{
         // Iterates over all vertices in this event
     public:
         /// constructor requiring vertex information
         vertex_const_iterator(
         const 
         std::map<int,HepMC::GenVertex*,std::greater<int> >::const_iterator& i)
         : m_map_iterator(i) {}
         vertex_const_iterator() {}
         /// copy constructor
         vertex_const_iterator( const vertex_const_iterator& i )
         { *this = i; }
         virtual ~vertex_const_iterator() {}
         /// make a copy
         vertex_const_iterator&  operator=( const vertex_const_iterator& i )
         { m_map_iterator = i.m_map_iterator; return *this; }
         /// return a pointer to a GenVertex
         GenVertex* operator*(void) const { return m_map_iterator->second; }
         /// Pre-fix increment
         vertex_const_iterator&  operator++(void)  //Pre-fix increment 
         { ++m_map_iterator; return *this; }
         /// Post-fix increment
         vertex_const_iterator   operator++(int)   //Post-fix increment
         { vertex_const_iterator out(*this); ++(*this); return out; }
         /// equality
         bool  operator==( const vertex_const_iterator& a ) const
         { return m_map_iterator == a.m_map_iterator; }
         /// inequality
         bool  operator!=( const vertex_const_iterator& a ) const
         { return !(m_map_iterator == a.m_map_iterator); }
     protected:
         /// const iterator to a vertex map
         std::map<int,HepMC::GenVertex*,std::greater<int> >::const_iterator 
                                                             m_map_iterator;
     private:
         /// Pre-fix increment -- is not allowed
         vertex_const_iterator&  operator--(void);
         /// Post-fix increment -- is not allowed
         vertex_const_iterator   operator--(int);
     };
     friend class vertex_const_iterator;
     /// begin vertex iteration
     vertex_const_iterator      vertices_begin() const
         { return GenEvent::vertex_const_iterator( 
         m_vertex_barcodes.begin() ); }
     /// end vertex iteration
     vertex_const_iterator      vertices_end() const
         { return GenEvent::vertex_const_iterator(
         m_vertex_barcodes.end() ); }
 
 
     //!  non-const vertex iterator
 
     /// \class  vertex_iterator
     /// HepMC::GenEvent::vertex_iterator
     /// is used to iterate over all vertices in the event.
     class vertex_iterator :
       public std::iterator<std::forward_iterator_tag,HepMC::GenVertex*,ptrdiff_t>{
         // Iterates over all vertices in this event
     public:
         /// constructor requiring vertex information
         vertex_iterator( 
         const 
         std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator& i )
         : m_map_iterator( i ) {}
         vertex_iterator() {}
         /// copy constructor
         vertex_iterator( const vertex_iterator& i ) { *this = i; }
         virtual ~vertex_iterator() {}
         /// make a copy
         vertex_iterator&  operator=( const vertex_iterator& i ) {
         m_map_iterator = i.m_map_iterator;
         return *this;
         }
         /// const vertex iterator
         operator vertex_const_iterator() const
         { return vertex_const_iterator(m_map_iterator); }
         /// return a pointer to a GenVertex
         GenVertex*        operator*(void) const
         { return m_map_iterator->second; }
         /// Pre-fix increment
         vertex_iterator&  operator++(void)  //Pre-fix increment 
         { ++m_map_iterator;     return *this; }
         /// Post-fix increment
         vertex_iterator   operator++(int)   //Post-fix increment
         { vertex_iterator out(*this); ++(*this); return out; }
         /// equality
         bool              operator==( const vertex_iterator& a ) const
         { return m_map_iterator == a.m_map_iterator; }
         /// inequality
         bool              operator!=( const vertex_iterator& a ) const
         { return !(m_map_iterator == a.m_map_iterator); }
     protected:
         /// iterator to the vertex map
         std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator 
                                                            m_map_iterator;
     private:
         /// Pre-fix increment
         vertex_iterator&  operator--(void);
         /// Post-fix increment
         vertex_iterator   operator--(int);
 
     };
     friend class vertex_iterator;
     /// begin vertex iteration
     vertex_iterator            vertices_begin() 
         { return GenEvent::vertex_iterator( 
         m_vertex_barcodes.begin() ); }
     /// end vertex iteration
         vertex_iterator            vertices_end()
         { return GenEvent::vertex_iterator(
         m_vertex_barcodes.end() ); }
 
     public:
     ///////////////////////////////
     // particle_iterator         //
     ///////////////////////////////
     // Example of iterating over all particles in the event:
     //      for ( GenEvent::particle_const_iterator p = particles_begin();
     //            p != particles_end(); ++p ) {
     //         (*p)->print();
     //      }
     //
 
     //!  const particle iterator
 
     /// \class  particle_const_iterator
     /// HepMC::GenEvent::particle_const_iterator 
     /// is used to iterate over all particles in the event.
     class particle_const_iterator :
       public std::iterator<std::forward_iterator_tag,HepMC::GenParticle*,ptrdiff_t>{
         // Iterates over all vertices in this event
     public:
         /// iterate over particles
         particle_const_iterator(
         const std::map<int,HepMC::GenParticle*>::const_iterator& i )
         : m_map_iterator(i) {}
         particle_const_iterator() {}
         /// copy constructor
         particle_const_iterator( const particle_const_iterator& i )
         { *this = i; }
         virtual ~particle_const_iterator() {}
         /// make a copy
         particle_const_iterator& operator=(
         const particle_const_iterator& i )
         { m_map_iterator = i.m_map_iterator; return *this; }
         /// return a pointer to GenParticle
         GenParticle*        operator*(void) const
         { return m_map_iterator->second; }
         /// Pre-fix increment
         particle_const_iterator&  operator++(void)  //Pre-fix increment 
         { ++m_map_iterator; return *this; }
         /// Post-fix increment
         particle_const_iterator   operator++(int)   //Post-fix increment
         { particle_const_iterator out(*this); ++(*this); return out; }
         /// equality
         bool  operator==( const particle_const_iterator& a ) const
         { return m_map_iterator == a.m_map_iterator; }
         /// inequality
         bool  operator!=( const particle_const_iterator& a ) const
         { return !(m_map_iterator == a.m_map_iterator); }
     protected:
         /// const iterator to the GenParticle map
         std::map<int,HepMC::GenParticle*>::const_iterator m_map_iterator;
     private:
         /// Pre-fix increment
         particle_const_iterator&  operator--(void);
         /// Post-fix increment
         particle_const_iterator   operator--(int);
     };  
     friend class particle_const_iterator;
     /// begin particle iteration
     particle_const_iterator      particles_begin() const
         { return GenEvent::particle_const_iterator( 
         m_particle_barcodes.begin() ); }
     /// end particle iteration
     particle_const_iterator      particles_end() const
         { return GenEvent::particle_const_iterator(
         m_particle_barcodes.end() ); }
 
     //!  non-const particle iterator
 
     /// \class  particle_iterator
     /// HepMC::GenEvent::particle_iterator 
     /// is used to iterate over all particles in the event.
     class particle_iterator :
       public std::iterator<std::forward_iterator_tag,HepMC::GenParticle*,ptrdiff_t>{
         // Iterates over all vertices in this event
     public:
         /// iterate over particles
         particle_iterator( const std::map<int,HepMC::GenParticle*>::iterator& i )
         : m_map_iterator( i ) {}
         particle_iterator() {}
         /// copy constructor
         particle_iterator( const particle_iterator& i ) { *this = i; }
         virtual ~particle_iterator() {}
         /// make a copy
         particle_iterator&  operator=( const particle_iterator& i ) {
         m_map_iterator = i.m_map_iterator;
         return *this;
         }
         /// const particle iterator
         operator particle_const_iterator() const
         { return particle_const_iterator(m_map_iterator); }
         /// return pointer to GenParticle
         GenParticle*        operator*(void) const
         { return m_map_iterator->second; }
             /// Pre-fix increment
         particle_iterator&  operator++(void) 
         { ++m_map_iterator;     return *this; }
             /// Post-fix increment
         particle_iterator   operator++(int)   
         { particle_iterator out(*this); ++(*this); return out; }
             /// equality
         bool              operator==( const particle_iterator& a ) const
         { return m_map_iterator == a.m_map_iterator; }
             /// inequality
         bool              operator!=( const particle_iterator& a ) const
         { return !(m_map_iterator == a.m_map_iterator); }
     protected:
         /// iterator for GenParticle map
         std::map<int,HepMC::GenParticle*>::iterator m_map_iterator;
     private:
             /// Pre-fix increment
         particle_iterator&  operator--(void);
             /// Post-fix increment
         particle_iterator   operator--(int);
     };
     friend class particle_iterator;
     /// begin particle iteration
     particle_iterator particles_begin() 
         { return GenEvent::particle_iterator(
         m_particle_barcodes.begin() ); }
     /// end particle iteration
         particle_iterator particles_end()
         { return GenEvent::particle_iterator(
         m_particle_barcodes.end() ); }
 
     ////////////////////////////////////////////////
     protected:
     //
     // Following methods intended for use by GenParticle/Vertex classes:
     // In general there is no reason they should be used elsewhere.
     /// set the barcode - intended for use by GenParticle
     bool         set_barcode( GenParticle* p, int suggested_barcode =false );
     /// set the barcode - intended for use by GenVertex
     bool         set_barcode( GenVertex*   v, int suggested_barcode =false );
     ///  intended for use by GenParticle
     void         remove_barcode( GenParticle* p );
     ///  intended for use by GenVertex
     void         remove_barcode( GenVertex*   v );
 
     void delete_all_vertices(); //!<delete all vertices owned by this event
 
      private: // methods
         /// internal method used when converting momentum units
         bool use_momentum_unit( Units::MomentumUnit );
         bool use_momentum_unit( std::string& );
         /// internal method used when converting length units
     bool use_length_unit( Units::LengthUnit );
     bool use_length_unit( std::string& );
     
     // the following internal methods are used by read() and write()
 
     /// send the beam particles to ASCII output
     std::ostream & write_beam_particles( std::ostream &, 
                          std::pair<HepMC::GenParticle *,HepMC::GenParticle *> );
     /// send a GenVertex to ASCII output
     std::ostream & write_vertex( std::ostream &, GenVertex const * );
     /// send a GenParticle to ASCII output
     std::ostream & write_particle( std::ostream&, GenParticle const * );
     /// find the file type
     std::istream & find_file_type( std::istream & );
     /// find the key at the end of the block
     std::istream & find_end_key( std::istream &, int & );
         /// get unit information from ASCII input
         std::istream & read_units( std::istream & );
     /// get weight names from ASCII input
         std::istream & read_weight_names( std::istream & );
     /// read the event header line
         std::istream & process_event_line( std::istream &, int &, int &, int &, int & );
 
     private: // data members
     int                   m_signal_process_id;
     int                   m_event_number;  
     int                   m_mpi;        // number of multi paricle interactions
     double                m_event_scale;// energy scale, see hep-ph/0109068
     double                m_alphaQCD;   // QCD coupling, see hep-ph/0109068
     double                m_alphaQED;   // QED coupling, see hep-ph/0109068
     GenVertex*            m_signal_process_vertex;
     GenParticle*          m_beam_particle_1;
     GenParticle*          m_beam_particle_2;
     WeightContainer       m_weights; // weights for this event first weight
                                      // is used by default for hit and miss
     std::vector<long> m_random_states; // container of rndm num 
                                            // generator states
 
     std::map< int,HepMC::GenVertex*,std::greater<int> >   m_vertex_barcodes;
     std::map< int,HepMC::GenParticle*,std::less<int> >    m_particle_barcodes;
     GenCrossSection*         m_cross_section;         // undefined by default
     HeavyIon*             m_heavy_ion;        // undefined by default
     PdfInfo*              m_pdf_info;         // undefined by default
     Units::MomentumUnit   m_momentum_unit;    // default value set by configure switch
     Units::LengthUnit     m_position_unit;    // default value set by configure switch
 
     };
 
 
     ///////////////////////////
     // IO Free Functions     //
     ///////////////////////////
   
     /// standard streaming IO output operator
     std::ostream & operator << (std::ostream &, GenEvent &);
     /// standard streaming IO input operator
     std::istream & operator >> (std::istream &, GenEvent &);
     /// set the units for this input stream
     std::istream & set_input_units(std::istream &, 
                                    Units::MomentumUnit, Units::LengthUnit);
     /// Explicitly write the begin block lines that IO_GenEvent uses
     std::ostream & write_HepMC_IO_block_begin(std::ostream & );
     /// Explicitly write the end block line that IO_GenEvent uses
     std::ostream & write_HepMC_IO_block_end(std::ostream & );
 
 
     ///////////////////////////
     // INLINE Free Functions //
     ///////////////////////////
 
     // Implemented in terms of GenEvent::use_...
     inline GenEvent& convert_units(GenEvent & evt, Units::MomentumUnit m, Units::LengthUnit l)
     {
       evt.use_units(m, l);
       return evt;
     }
 
     ///////////////////////////
     // INLINE Access Methods //
     ///////////////////////////
 
     ///  The integer ID that uniquely specifies this signal
     ///  process, i.e. MSUB in Pythia. It is necessary to
     ///  package this with each event rather than with the run
     ///  because many processes may be generated within one run.
     inline int GenEvent::signal_process_id() const 
     { return m_signal_process_id; }
 
     inline int GenEvent::event_number() const { return m_event_number; }
 
     /// Returns the number of multi parton interactions in the event.
     /// This number is -1 if it is not set.
     inline int GenEvent::mpi() const { return m_mpi; }
 
     inline double GenEvent::event_scale() const { return m_event_scale; }
 
     inline double GenEvent::alphaQCD() const { return m_alphaQCD; }
 
     inline double GenEvent::alphaQED() const { return m_alphaQED; }
  
     inline GenVertex* GenEvent::signal_process_vertex() const {
     /// returns a (mutable) pointer to the signal process vertex
     return m_signal_process_vertex;
     }  
 
     inline WeightContainer& GenEvent::weights() { return m_weights; }
 
     inline const WeightContainer& GenEvent::weights() const 
     { return m_weights; }
 
     inline GenCrossSection const * GenEvent::cross_section() const 
     { return m_cross_section; }
 
     inline GenCrossSection*  GenEvent::cross_section()  
     { return m_cross_section; }
 
     inline HeavyIon const * GenEvent::heavy_ion() const 
     { return m_heavy_ion; }
 
     inline HeavyIon*  GenEvent::heavy_ion()  
     { return m_heavy_ion; }
 
     inline PdfInfo const * GenEvent::pdf_info() const 
     { return m_pdf_info; }
 
     inline PdfInfo*  GenEvent::pdf_info()  
     { return m_pdf_info; }
 
     ///  Vector of integers which specify the random number 
     ///  generator's state for this event. It is left to the
     ///  generator to make use of this. We envision a vector of
     ///  RndmStatesTags to be included with a run class which
     ///  would specify the meaning of the random_states.
     inline const std::vector<long>& GenEvent::random_states() const 
     { return m_random_states; }
 
     inline void GenEvent::set_signal_process_id( int id )
     { m_signal_process_id = id; }
 
     inline void GenEvent::set_event_number( int eventno )
     { m_event_number = eventno; }
 
     /// Use this to set the number of multi parton interactions in each event.
     inline void GenEvent::set_mpi( int nmpi )
     { m_mpi = nmpi; }
 
 
     inline void GenEvent::set_event_scale( double sc ) { m_event_scale = sc; }
 
     inline void GenEvent::set_alphaQCD( double a ) { m_alphaQCD = a; }
 
     inline void GenEvent::set_alphaQED( double a ) { m_alphaQED = a; }
 
     inline void GenEvent::set_signal_process_vertex( GenVertex* vtx ) {
     m_signal_process_vertex = vtx;
     if ( m_signal_process_vertex ) add_vertex( m_signal_process_vertex );
     }
 
     inline void GenEvent::set_cross_section( const GenCrossSection& xs )
     { 
         delete m_cross_section;
         m_cross_section = new GenCrossSection(xs); 
     }
 
     inline void GenEvent::set_heavy_ion( const HeavyIon& ion )
     { 
         delete m_heavy_ion;
         m_heavy_ion = new HeavyIon(ion); 
     }
 
     inline void GenEvent::set_pdf_info( const PdfInfo& p )
     { 
         delete m_pdf_info;
         m_pdf_info = new PdfInfo(p); 
     }
 
     inline void GenEvent::set_random_states( const std::vector<long>&
                          randomstates )
     { m_random_states = randomstates; }
 
     inline void GenEvent::remove_barcode( GenParticle* p )
     { m_particle_barcodes.erase( p->barcode() ); }
 
     inline void GenEvent::remove_barcode( GenVertex* v )
     { m_vertex_barcodes.erase( v->barcode() ); }
 
     /// Each vertex or particle has a barcode, which is just an integer which
     /// uniquely identifies it inside the event (i.e. there is a one to one
     /// mapping between particle memory addresses and particle barcodes... and 
     /// the same applied for vertices).
     ///
     /// The value of a barcode has NO MEANING and NO ORDER!
     /// For the user's convenience, when an event is read in via an IO_method
     /// from an indexed list (like the HEPEVT common block), then the index will
     /// become the barcode for that particle.
     ///
     /// Particle barcodes are always positive integers.
     /// The barcodes are chosen and set automatically when a vertex or particle
     /// comes under the ownership of an event (i.e. it is contained in an event).
     /// 
     /// Please note that the barcodes are intended for internal use within 
     /// HepMC as a unique identifier for the particles and vertices.
     /// Using the barcode to encode extra information is an abuse of 
     /// the barcode data member and causes confusion among users. 
     inline GenParticle* GenEvent::barcode_to_particle( int barCode ) const
     { 
     std::map<int,HepMC::GenParticle*>::const_iterator i 
         = m_particle_barcodes.find(barCode);
     return ( i != m_particle_barcodes.end() ) ? (*i).second : 0;
     }
 
     /// Each vertex or particle has a barcode, which is just an integer which
     /// uniquely identifies it inside the event (i.e. there is a one to one
     /// mapping between particle memory addresses and particle barcodes... and 
     /// the same applied for vertices).
     ///
     /// The value of a barcode has NO MEANING and NO ORDER!
     /// For the user's convenience, when an event is read in via an IO_method
     /// from an indexed list (like the HEPEVT common block), then the index will
     /// become the barcode for that particle.
     ///
     /// Vertex barcodes are always negative integers.
     /// The barcodes are chosen and set automatically when a vertex or particle
     /// comes under the ownership of an event (i.e. it is contained in an event).
     /// 
     /// Please note that the barcodes are intended for internal use within 
     /// HepMC as a unique identifier for the particles and vertices.
     /// Using the barcode to encode extra information is an abuse of 
     /// the barcode data member and causes confusion among users. 
     inline GenVertex* GenEvent::barcode_to_vertex( int barCode ) const
     {
     std::map<int,GenVertex*,std::greater<int> >::const_iterator i 
         = m_vertex_barcodes.find(barCode);
     return ( i != m_vertex_barcodes.end() ) ? (*i).second : 0;
     }
 
     inline int GenEvent::particles_size() const {
     return (int)m_particle_barcodes.size();
     }
     inline bool GenEvent::particles_empty() const {
     return (bool)m_particle_barcodes.empty();
     }
     inline int GenEvent::vertices_size() const {
     return (int)m_vertex_barcodes.size();
     }
     inline bool GenEvent::vertices_empty() const {
     return (bool)m_vertex_barcodes.empty();
     }
     
     // beam particles
     inline std::pair<HepMC::GenParticle *,HepMC::GenParticle *> GenEvent::beam_particles() const {
         return std::pair<GenParticle *,GenParticle *> (m_beam_particle_1, m_beam_particle_2);
     }
 
     // units
     inline Units::MomentumUnit GenEvent::momentum_unit() const {
         return m_momentum_unit; 
     }
     inline Units::LengthUnit   GenEvent::length_unit()   const {
         return m_position_unit; 
     }
     
     inline void GenEvent::use_units( Units::MomentumUnit new_m, Units::LengthUnit new_l ) { 
        use_momentum_unit( new_m );
        use_length_unit( new_l );
     }
     
     inline void GenEvent::use_units( std::string& new_m, std::string& new_l ) { 
        use_momentum_unit( new_m );
        use_length_unit( new_l );
     }
     
     inline void GenEvent::define_units( Units::MomentumUnit new_m, Units::LengthUnit new_l ) { 
     m_momentum_unit = new_m; 
     m_position_unit = new_l; 
     }
 
 } // HepMC
 
 #endif  // HEPMC_GEN_EVENT_H
 
 //--------------------------------------------------------------------------
 
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team