GenVertex.h

//--------------------------------------------------------------------------
#ifndef HEPMC_GEN_VERTEX_H
#define HEPMC_GEN_VERTEX_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).
//
// GenVertex within an event
// A vertex is indirectly (via particle "edges") linked to other 
//   vertices ("nodes") to form a composite "graph"

// --> HANDLE COMPILER INCONSISTENCIES
// This pre-compiler directive is included (2002-01-16) to allow compatibility
// with several compilers.
// Mar 27, 2004: HepMC is now standard compliant only. 
//   I've removed forward_iterator, and it will no longer compile on gcc < 3. 
#ifdef __SUNPRO_CC    // Solaris CC 5.2
#define NEED_SOLARIS_FRIEND_FEATURE
#endif // Platform

#include "HepMC/WeightContainer.h"
#include "HepMC/SimpleVector.h"
#include "HepMC/IteratorRange.h"
#include <iostream>
#include <iterator>
#include <vector>
#include <set>
#include <algorithm>
#include <cstddef>

namespace HepMC {

    class GenVertexParticleRange;
    class GenParticleProductionRange;
    class ConstGenParticleProductionRange;
    class GenParticleEndRange;
    class ConstGenParticleEndRange;

    class GenParticle;
    class GenEvent;


    class GenVertex {

        friend std::ostream& operator<<( std::ostream&, const GenVertex& );
        friend class GenEvent;

#ifdef NEED_SOLARIS_FRIEND_FEATURE
        // This bit of ugly code is only for CC-5.2 compiler. 
        // M.Dobbs 2002/02/19 
        // It is not needed by linux gcc, nor Windows Visual C++.
    public: 
        class vertex_iterator;
        friend class vertex_iterator;
        class particle_iterator;
        friend class particle_iterator;
#endif // NEED_SOLARIS_FRIEND_FEATURE

    public:
        GenVertex( const FourVector& position =FourVector(0,0,0,0),
                   int id = 0, 
                   const WeightContainer& weights = std::vector<double>() );
        GenVertex( const GenVertex& invertex );            
        virtual    ~GenVertex();

        void swap( GenVertex & other); 
        GenVertex& operator= ( const GenVertex& invertex ); 
        bool       operator==( const GenVertex& a ) const; 
        bool       operator!=( const GenVertex& a ) const; 
        void       print( std::ostream& ostr = std::cout ) const; 

        double     check_momentum_conservation() const;

        void       add_particle_in( GenParticle* inparticle );
        void       add_particle_out( GenParticle* outparticle );
        GenParticle* remove_particle( GenParticle* particle ); 

        operator    HepMC::FourVector() const; 
        operator   HepMC::ThreeVector() const; 

        // access methods //

        GenEvent*               parent_event() const;
        ThreeVector             point3d() const;
        const FourVector &      position() const;
        void                    set_position( const FourVector& position = FourVector(0,0,0,0) );
        int                     id() const;  
        void                    set_id( int id );  

        int                     barcode() const; 

        bool                    suggest_barcode( int the_bar_code );
        
        WeightContainer&        weights();
        const WeightContainer&  weights() const;

        GenVertexParticleRange particles( IteratorRange range = relatives );
        GenParticleProductionRange particles_in( GenParticle&, IteratorRange range = relatives );
        ConstGenParticleProductionRange particles_in( GenParticle const &, IteratorRange range = relatives ) const;
        GenParticleEndRange particles_out( GenParticle&, IteratorRange range = relatives );
        ConstGenParticleEndRange particles_out( GenParticle const &, IteratorRange range = relatives ) const;

        // Iterators      // users should use prefer to use particle_iterator

        typedef std::vector<HepMC::GenParticle*>::const_iterator 
        particles_in_const_iterator;
        typedef std::vector<HepMC::GenParticle*>::const_iterator 
        particles_out_const_iterator;
        particles_in_const_iterator         particles_in_const_begin() const;
        particles_in_const_iterator         particles_in_const_end() const;
        particles_out_const_iterator        particles_out_const_begin() const;
        particles_out_const_iterator        particles_out_const_end() const;
        int                                 particles_in_size() const;
        int                                 particles_out_size() const;

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

        void                    set_parent_event_( GenEvent* evt ); 
        void                    set_barcode_( int the_bar_code ); 
        void                    change_parent_event_( GenEvent* evt ); 

        // edge_iterator           // (protected - for internal use only)
        // If the user wants the functionality of the edge_iterator, he should
        // use particle_iterator with IteratorRange = family, parents, children
        //


        class edge_iterator :
          public std::iterator<std::forward_iterator_tag,HepMC::GenParticle*,ptrdiff_t>{
        public:
            edge_iterator();
            edge_iterator( const GenVertex& vtx, IteratorRange range =family );
            edge_iterator( const edge_iterator& p );
            virtual        ~edge_iterator();
            edge_iterator& operator=( const edge_iterator& p );
            GenParticle*      operator*(void) const;
            edge_iterator& operator++(void); // Pre-fix increment 
            edge_iterator  operator++(int);   // Post-fix increment
            bool           operator==( const edge_iterator& a ) const;
            bool           operator!=( const edge_iterator& a ) const;
            bool           is_parent() const;
            bool           is_child() const;
            const GenVertex*  vertex_root() const;
        private:
            edge_iterator& operator--(void);
            edge_iterator  operator--(int);
        private:
            const GenVertex*  m_vertex;
            IteratorRange  m_range;
            std::vector<HepMC::GenParticle*>::const_iterator m_set_iter;
            bool           m_is_inparticle_iter;
            bool           m_is_past_end;
        };
        friend class edge_iterator;
        int              edges_size( IteratorRange range = family ) const;
        edge_iterator    edges_begin( IteratorRange range = family) const;
        edge_iterator    edges_end( IteratorRange /* dummy_range */ ) const;

    public:
        // vertex_iterator           //


        class vertex_iterator :
          public std::iterator<std::forward_iterator_tag,HepMC::GenVertex*,ptrdiff_t>{
        public:
            vertex_iterator();
            vertex_iterator( GenVertex& vtx_root, IteratorRange range );
            vertex_iterator( GenVertex& vtx_root, IteratorRange range,
                             std::set<const HepMC::GenVertex*>& visited_vertices );
            vertex_iterator( const vertex_iterator& v_iter );
            virtual             ~vertex_iterator();
            vertex_iterator&    operator=( const vertex_iterator& );
            GenVertex*          operator*(void) const;
            vertex_iterator&    operator++(void);  //Pre-fix increment 
            vertex_iterator     operator++(int);   //Post-fix increment
            bool                operator==( const vertex_iterator& ) const;
            bool                operator!=( const vertex_iterator& ) const;
            GenVertex*          vertex_root() const;
            IteratorRange       range() const;
            void                copy_with_own_set( const vertex_iterator& 
                                                   v_iter,
                                                   std::set<const HepMC::GenVertex*>& 
                                                   visited_vertices );

        protected:                  // intended for internal use only
            GenVertex* follow_edge_(); 
            void    copy_recursive_iterator_( const vertex_iterator* 
                                              recursive_v_iter );
        private:
            vertex_iterator&    operator--(void);
            vertex_iterator     operator--(int);

        private:
            GenVertex*       m_vertex;   // the vertex associated to this iter
            IteratorRange    m_range;
            std::set<const HepMC::GenVertex*>* m_visited_vertices;
            bool             m_it_owns_set;  // true if it is responsible for 
                                             // deleting the visited vertex set
            edge_iterator    m_edge; // particle edge pointing to return vtx
            vertex_iterator* m_recursive_iterator;
        };      
        friend class vertex_iterator;
        vertex_iterator     vertices_begin( IteratorRange range = relatives );
        vertex_iterator     vertices_end( IteratorRange /* dummy_range */ );
 
    public:
        // particle_iterator         //


        class particle_iterator :
          public std::iterator<std::forward_iterator_tag,GenParticle*,ptrdiff_t>{
        public:
            particle_iterator();
            particle_iterator( GenVertex& vertex_root, IteratorRange range );
            particle_iterator( const particle_iterator& );
            virtual             ~particle_iterator();
            particle_iterator&  operator=( const particle_iterator& );
            GenParticle*        operator*(void) const;
            particle_iterator&  operator++(void); 
            particle_iterator   operator++(int); 
            bool                operator==( const particle_iterator& ) const;
            bool                operator!=( const particle_iterator& ) const;
        protected:
            GenParticle*        advance_to_first_(); 
        private:
            vertex_iterator     m_vertex_iterator;
            edge_iterator       m_edge;     // points to the return
        };
        friend class particle_iterator;
        particle_iterator       particles_begin( IteratorRange range 
                                                 = relatives );
        particle_iterator       particles_end( IteratorRange 
                                               /* dummy_range */ );

    protected: 
        void delete_adopted_particles();
        void remove_particle_in( GenParticle* );
        void remove_particle_out( GenParticle* );
        void convert_position( const double& );

    private: // GenVertex data members
        FourVector              m_position;      //4-vec of vertex [mm]
        std::vector<HepMC::GenParticle*>  m_particles_in;  //all incoming particles
        std::vector<HepMC::GenParticle*>  m_particles_out; //all outgoing particles
        int                  m_id;
        WeightContainer      m_weights;       // weights for this vtx
        GenEvent*            m_event;
        int                  m_barcode;   // unique identifier in the event

        //static unsigned int  s_counter;
    };  

    // INLINES access methods //

    inline GenVertex::operator HepMC::FourVector() const { return position(); }

    inline GenVertex::operator HepMC::ThreeVector() const { return point3d(); }

    inline const FourVector & GenVertex::position() const { return m_position; }

    inline GenEvent* GenVertex::parent_event() const { return m_event; }

    inline ThreeVector GenVertex::point3d() const { 
        return ThreeVector(m_position.x(),m_position.y(),m_position.z()); 
    }

    inline int GenVertex::id() const { return m_id; }

    inline int  GenVertex::barcode() const { return m_barcode; }
    inline void GenVertex::set_barcode_( int bc ) { m_barcode = bc; }

    inline WeightContainer& GenVertex::weights() { return m_weights; }

    inline const WeightContainer& GenVertex::weights() const 
    { return m_weights; }

    inline void GenVertex::set_position( const FourVector& pos ) {
        m_position = pos;
    }

    inline void GenVertex::set_id( int pid ) { m_id = pid; }

    // INLINES  //

    inline GenVertex::particles_in_const_iterator 
    GenVertex::particles_in_const_begin() const { 
        return m_particles_in.begin(); 
    }

    inline GenVertex::particles_in_const_iterator 
    GenVertex::particles_in_const_end() const { 
        return m_particles_in.end(); 
    }

    inline GenVertex::particles_out_const_iterator 
    GenVertex::particles_out_const_begin() const { 
        return m_particles_out.begin();
    }

    inline GenVertex::particles_out_const_iterator 
    GenVertex::particles_out_const_end() const {        
        return m_particles_out.end(); 
    }

    inline int GenVertex::particles_in_size() const {
        return m_particles_in.size(); 
    }

    inline int GenVertex::particles_out_size() const {
        return m_particles_out.size(); 
    }   

    inline bool GenVertex::edge_iterator::operator==( 
        const edge_iterator& a ) const { 
        return **this == *a; 
    }

    inline bool GenVertex::edge_iterator::operator!=(
        const edge_iterator& a ) const { 
        return !(**this == *a); 
    }

    inline const GenVertex* GenVertex::edge_iterator::vertex_root() const {
        return m_vertex;
    }

    inline GenVertex::edge_iterator GenVertex::edges_begin( IteratorRange 
                                                      range ) const {
        return GenVertex::edge_iterator(*this, range);
    }

    inline GenVertex::edge_iterator GenVertex::edges_end( IteratorRange 
                                                    /* dummy_range */ ) const {
        return GenVertex::edge_iterator();
    }

    inline bool GenVertex::vertex_iterator::operator==( 
        const vertex_iterator& a ) const {
        return **this == *a; 
    }

    inline bool GenVertex::vertex_iterator::operator!=( 
        const vertex_iterator& a ) const {
        return !(**this == *a); 
    }

    inline GenVertex* GenVertex::vertex_iterator::vertex_root() const {
        return m_vertex; 
    }

    inline IteratorRange GenVertex::vertex_iterator::range() const {
        return m_range; 
    }

    inline GenVertex::vertex_iterator GenVertex::vertices_begin( 
        IteratorRange range ){
        // this is not const because the it could return itself
        return vertex_iterator( *this, range );
    }

    inline GenVertex::vertex_iterator GenVertex::vertices_end( 
        IteratorRange /* dummy_range */ ) {
        return vertex_iterator();
    }

    inline bool GenVertex::particle_iterator::operator==( 
        const particle_iterator& a ) const {
        return **this == *a; 
    }

    inline bool GenVertex::particle_iterator::operator!=( 
        const particle_iterator& a ) const {
        return !(**this == *a); 
    }

    inline GenVertex::particle_iterator GenVertex::particles_begin( 
        IteratorRange range ) {
        return particle_iterator( *this, range );
    }

    inline GenVertex::particle_iterator GenVertex::particles_end(
        IteratorRange /* dummy_range */ ){
        return particle_iterator();
    }

} // HepMC

#endif  // HEPMC_GEN_VERTEX_H
//--------------------------------------------------------------------------