HepMC Reference Documentation HepMC

GenParticle.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
#ifndef HEPMC_GEN_PARTICLE_H
#define HEPMC_GEN_PARTICLE_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).
//
// particle within an event coming in/out of a vertex
// particle is the basic building block or unit of the event record
//
// example:
//      GenParticle* p = new GenParticle( FourVector(1,1,1,3), 11, 1 );
// creates a particle with 4-vector (p,E)=1,1,1,3 - with pdg id 11 (electron)
// and give this particle status =1.
//
// the pointers to end/production vertices can only be set by the
//  vertices themselves - thus to set the production vertex for a particle,
//  you add the particle to that vertex with GenVertex::add_particle_out()
//
// We decide not to have a separate 4 vector for the momentum 
//  at decay time (which MC++ includes to allow dE/dX losses etc). 
//  If you want that, just add a decay vertex with the
//  same particle (modified momentum) going out
//

#include "HepMC/Flow.h"
#include "HepMC/Polarization.h"
#include "HepMC/SimpleVector.h"
#include <iostream>
#ifdef _WIN32
#define hepmc_uint64_t  __int64
#else
#include <stdint.h>     // for uint64_t
#define hepmc_uint64_t   uint64_t
#endif

namespace HepMC {

    class GenVertex;
    class GenEvent; 



    class GenParticle {

        friend class GenVertex; // so vertex can set decay/production vertexes
        friend class GenEvent;  // so event can set the barCodes
        friend std::ostream& operator<<( std::ostream&, const GenParticle& );

    public:
        GenParticle(void);
        GenParticle( const FourVector& momentum, int pdg_id,
                     int status = 0, const Flow& itsflow = Flow(),
                     const Polarization& polar = Polarization(0,0) );
        GenParticle( const GenParticle& inparticle ); 
        virtual ~GenParticle();

        void swap( GenParticle & other); 
        GenParticle& operator=( const GenParticle& inparticle ); 

        bool         operator==( const GenParticle& ) const;
        bool         operator!=( const GenParticle& ) const;

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

        operator HepMC::FourVector() const; 

        // access methods //

        const FourVector &          momentum() const;
        int                  pdg_id() const;
        int                  status() const;
        const Flow &         flow() const;
        int                  flow( int code_index ) const;
        const Polarization & polarization() const;
        GenVertex*           production_vertex() const;
        GenVertex*           end_vertex() const;
        GenEvent*            parent_event() const;

        double               generated_mass() const; 

        double               generatedMass() const { return generated_mass(); }


        int                  barcode() const; 

        // mutator methods //

        bool                 suggest_barcode( int the_bar_code );

        void   set_momentum( const FourVector& vec4 ); 
        void   set_pdg_id( int id ); 
        void   set_status( int status = 0 ); 
        void   set_flow( const Flow& f ); 
        void   set_flow( int code_index, int code = 0 ); 

        void   set_polarization( const Polarization& pol = Polarization(0,0) );
        void   set_generated_mass( const double & m ); 

        void   setGeneratedMass( const double & m )  
                         { return set_generated_mass(m); }

    protected: // for internal use only by friend GenVertex class

        //static unsigned int counter(); //!< temporary for debugging

        void   set_production_vertex_( GenVertex* productionvertex = 0);
        void   set_end_vertex_( GenVertex* decayvertex = 0 );
        void   set_barcode_( int the_bar_code ); 

        void convert_momentum( const double& );

    private:
        FourVector       m_momentum;          // momentum vector
        int              m_pdg_id;            // id according to PDG convention
        int              m_status;            // As defined for HEPEVT
        Flow             m_flow;
        Polarization     m_polarization;
        GenVertex*       m_production_vertex; // null if vacuum or beam
        GenVertex*       m_end_vertex;        // null if not-decayed
        int              m_barcode;           // unique identifier in the event
        double           m_generated_mass;    // mass of this particle when it was generated

        //static unsigned int       s_counter;
    };  

    // INLINES  //

    inline GenParticle::operator HepMC::FourVector() const 
    { return m_momentum; }

    inline const FourVector & GenParticle::momentum() const 
    { return m_momentum; }

    inline int GenParticle::pdg_id() const { return m_pdg_id; }

    inline int GenParticle::status() const { return m_status; }

    inline GenVertex* GenParticle::production_vertex() const 
    { return m_production_vertex; }

    inline GenVertex* GenParticle::end_vertex() const { return m_end_vertex; }

    inline const Flow & GenParticle::flow() const { return m_flow; }

    inline int GenParticle::flow( int code_index ) const
    { return m_flow.icode( code_index ); }

    inline const Polarization & GenParticle::polarization() const 
    { return m_polarization; }

    inline void GenParticle::set_momentum( const FourVector& vec4 )
    { m_momentum = vec4; }

    inline void GenParticle::set_pdg_id( int id ) { m_pdg_id = id; }

    inline void GenParticle::set_status( int status ) { m_status = status; }

    inline void GenParticle::set_flow( const Flow& f ) { m_flow = f; }

    inline void GenParticle::set_flow( int code_index, int code ) 
    {
        if ( code == 0 ) { 
            m_flow.set_unique_icode( code_index );
        } else { 
            m_flow.set_icode( code_index, code );
        }
    }

    inline void GenParticle::set_polarization( const Polarization& polar )
    { m_polarization = polar; }

    inline int  GenParticle::barcode() const { return m_barcode; }

    inline void GenParticle::set_barcode_( int bc ) { m_barcode = bc; }

} // HepMC

#endif  // HEPMC_GEN_PARTICLE_H
//--------------------------------------------------------------------------

---