EIC code displayed by LXR master/​include/​HepMC/​GenRanges.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_ITERATORS_H
 #define HEPMC_GEN_EVENT_ITERATORS_H
 
 //--------------------------------------------------------------------------
 //////////////////////////////////////////////////////////////////////////
 // garren@fnal.gov, May 2009
 // 
 //////////////////////////////////////////////////////////////////////////
 //--------------------------------------------------------------------------
 
 #include <stdexcept>
 
 #include "HepMC/GenEvent.h"
 #include "HepMC/GenVertex.h"
 
 namespace HepMC {
 
 //! GenEventVertexRange acts like a collection of vertices
 
 ///
 /// \class  GenEventVertexRange
 /// HepMC::GenEventVertexRange is used to mimic a collection of
 /// vertices for ease of use - especially with utilities such as 
 /// the Boost foreach funtion
 ///
 class GenEventVertexRange {
 
 public:
 
   /// the constructor requires a GenEvent
   GenEventVertexRange( GenEvent & e ) : m_event(e) {}
   /// 
   GenEvent::vertex_iterator begin() { return m_event.vertices_begin(); }
   GenEvent::vertex_iterator end()   { return m_event.vertices_end(); }
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenEvent::vertex_range().
   GenEventVertexRange& operator=( GenEventVertexRange & );
 
 private:
   GenEvent & m_event;
 
 };
 
 //! ConstGenEventVertexRange acts like a collection of vertices
 
 ///
 /// \class  ConstGenEventVertexRange
 /// HepMC::ConstGenEventVertexRange is used to mimic a collection of
 /// vertices for ease of use - especially with utilities such as 
 /// the Boost foreach funtion
 /// This is the const partner of GenEventVertexRange
 ///
 class ConstGenEventVertexRange {
 
 public:
 
   /// the constructor requires a const GenEvent
   ConstGenEventVertexRange( GenEvent const & e ) : m_event(e) {}
   /// 
   GenEvent::vertex_const_iterator begin() const { return m_event.vertices_begin(); }
   GenEvent::vertex_const_iterator end()   const { return m_event.vertices_end(); }
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenEvent::vertex_range().
   ConstGenEventVertexRange& operator=( ConstGenEventVertexRange & );
 
 private:
   GenEvent const & m_event;
 
 };
 
 //! GenEventParticleRange acts like a collection of particles
 
 ///
 /// \class  GenEventParticleRange
 /// HepMC::GenEventParticleRange is used to mimic a collection of
 /// particles for ease of use - especially with utilities such as 
 /// the Boost foreach funtion
 ///
 class GenEventParticleRange {
 
 public:
 
   /// the constructor requires a GenEvent
   GenEventParticleRange( GenEvent & e ) : m_event(e) {}
   /// 
   GenEvent::particle_iterator begin() { return m_event.particles_begin(); }
   GenEvent::particle_iterator end()   { return m_event.particles_end(); }
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenEvent::particle_range().
   GenEventParticleRange& operator=( GenEventParticleRange & );
 
 private:
   GenEvent & m_event;
 
 };
 
 //! ConstGenEventParticleRange acts like a collection of particles
 
 ///
 /// \class  ConstGenEventParticleRange
 /// HepMC::ConstGenEventParticleRange is used to mimic a collection of
 /// particles for ease of use - especially with utilities such as 
 /// the Boost foreach funtion
 /// This is the const partner of GenEventParticleRange
 ///
 class ConstGenEventParticleRange {
 
 public:
 
   /// the constructor requires a const GenEvent
   ConstGenEventParticleRange( GenEvent const & e ) : m_event(e) {}
   /// 
   GenEvent::particle_const_iterator begin() const { return m_event.particles_begin(); }
   GenEvent::particle_const_iterator end()   const { return m_event.particles_end(); }
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenEvent::particle_range().
   ConstGenEventParticleRange& operator=( ConstGenEventParticleRange & );
 
 private:
   GenEvent const & m_event;
 
 };
 
 //! GenVertexParticleRange acts like a collection of particles
 
 ///
 /// \class  GenVertexParticleRange
 /// HepMC::GenVertexParticleRange is used to mimic a collection of
 /// particles for ease of use - especially with utilities such as 
 /// the Boost foreach funtion
 ///
 class GenVertexParticleRange {
 
 public:
 
   /// the constructor requires a GenVertex
   GenVertexParticleRange( GenVertex & v, IteratorRange range = relatives ) 
   : m_vertex(v),m_range(range) {}
   /// 
   GenVertex::particle_iterator begin() { return m_vertex.particles_begin(m_range); }
   GenVertex::particle_iterator end()   { return m_vertex.particles_end(m_range); }
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenVertex::particles().
   GenVertexParticleRange& operator=( GenVertexParticleRange & );
 
 private:
   GenVertex     & m_vertex;
   IteratorRange   m_range;
 
 };
 
 //! GenParticleProductionRange acts like a collection of particles
 
 ///
 /// \class  GenParticleProductionRange
 /// HepMC::GenParticleProductionRange is used to mimic a collection of
 /// particles associated with the particle's production vertex for ease of use 
 /// Utilities such as the Boost foreach funtion will want to use this class.
 ///
 class GenParticleProductionRange {
 
 public:
 
   /// the constructor requires a GenParticle
   GenParticleProductionRange( GenParticle const & p, IteratorRange range = relatives ) 
   : m_particle(p),m_range(range) {}
   /// begin iterator throws an error if the particle production_vertex is undefined
   GenVertex::particle_iterator begin();
   /// end iterator throws an error if the particle production_vertex is undefined
   GenVertex::particle_iterator end(); 
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenVertex::particles_in().
   GenParticleProductionRange& operator=( GenParticleProductionRange & );
 
 private:
   GenParticle const & m_particle;
   IteratorRange       m_range;
 
 };
 
 class ConstGenParticleProductionRange {
 
 public:
 
   /// the constructor requires a GenParticle
   ConstGenParticleProductionRange( GenParticle const & p, IteratorRange range = relatives ) 
   : m_particle(p),m_range(range) {}
   /// begin iterator throws an error if the particle production_vertex is undefined
   GenVertex::particle_iterator begin();
   /// end iterator throws an error if the particle production_vertex is undefined
   GenVertex::particle_iterator end(); 
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenVertex::particles_in().
   ConstGenParticleProductionRange& operator=( ConstGenParticleProductionRange & );
 
 private:
   GenParticle const & m_particle;
   IteratorRange       m_range;
 
 };
 
 //! GenParticleEndRange acts like a collection of particles
 
 ///
 /// \class  GenParticleEndRange
 /// HepMC::GenParticleEndRange is used to mimic a collection of
 /// particles associated with the particle's end vertex for ease of use 
 /// Utilities such as the Boost foreach funtion will want to use this class.
 ///
 class GenParticleEndRange {
 
 public:
 
   /// the constructor requires a GenParticle
   GenParticleEndRange( GenParticle const & p, IteratorRange range = relatives ) 
   : m_particle(p),m_range(range) {}
   /// begin iterator throws an error if the particle end_vertex is undefined
   GenVertex::particle_iterator begin();
   /// end iterator throws an error if the particle end_vertex is undefined
   GenVertex::particle_iterator end(); 
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenVertex::particles_out().
   GenParticleEndRange& operator=( GenParticleEndRange & );
 
 private:
   GenParticle const & m_particle;
   IteratorRange       m_range;
 
 };
 
 class ConstGenParticleEndRange {
 
 public:
 
   /// the constructor requires a GenParticle
   ConstGenParticleEndRange( GenParticle const & p, IteratorRange range = relatives ) 
   : m_particle(p),m_range(range) {}
   /// begin iterator throws an error if the particle end_vertex is undefined
   GenVertex::particle_iterator begin();
   /// end iterator throws an error if the particle end_vertex is undefined
   GenVertex::particle_iterator end(); 
 
 private:
   /// Because the class contains a reference, assignments are not allowed.
   /// However, we need the copy constructor for GenVertex::particles_out().
   ConstGenParticleEndRange& operator=( ConstGenParticleEndRange & );
 
 private:
   GenParticle const & m_particle;
   IteratorRange       m_range;
 
 };
 
 
 inline GenVertex::particle_iterator GenParticleProductionRange::begin() 
 { 
     if ( ! m_particle.production_vertex() ) 
         throw(std::range_error("GenParticleProductionRange: GenParticle has no production_vertex"));
     return m_particle.production_vertex()->particles_begin(m_range); 
 }
 
 inline GenVertex::particle_iterator GenParticleProductionRange::end()
 { 
     if ( ! m_particle.production_vertex() ) 
         throw(std::range_error("GenParticleProductionRange: GenParticle has no production_vertex"));
     return m_particle.production_vertex()->particles_end(m_range); 
 }
 
 
 inline GenVertex::particle_iterator ConstGenParticleProductionRange::begin() 
 { 
     if ( ! m_particle.production_vertex() ) 
         throw(std::range_error("ConstGenParticleProductionRange: GenParticle has no production_vertex"));
     return m_particle.production_vertex()->particles_begin(m_range); 
 }
 
 inline GenVertex::particle_iterator ConstGenParticleProductionRange::end()
 { 
     if ( ! m_particle.production_vertex() ) 
         throw(std::range_error("ConstGenParticleProductionRange: GenParticle has no production_vertex"));
     return m_particle.production_vertex()->particles_end(m_range); 
 }
 
 inline GenVertex::particle_iterator GenParticleEndRange::begin() 
 { 
     if ( ! m_particle.end_vertex() ) 
         throw(std::range_error("GenParticleEndRange: GenParticle has no end_vertex"));
     return m_particle.end_vertex()->particles_begin(m_range); 
 }
 inline GenVertex::particle_iterator GenParticleEndRange::end()
 { 
     if ( ! m_particle.end_vertex() ) 
         throw(std::range_error("GenParticleEndRange: GenParticle has no end_vertex"));
     return m_particle.end_vertex()->particles_end(m_range); 
 }
 
 inline GenVertex::particle_iterator ConstGenParticleEndRange::begin() 
 { 
     if ( ! m_particle.end_vertex() ) 
         throw(std::range_error("ConstGenParticleEndRange: GenParticle has no end_vertex"));
     return m_particle.end_vertex()->particles_begin(m_range); 
 }
 inline GenVertex::particle_iterator ConstGenParticleEndRange::end()
 { 
     if ( ! m_particle.end_vertex() ) 
         throw(std::range_error("ConstGenParticleEndRange: GenParticle has no end_vertex"));
     return m_particle.end_vertex()->particles_end(m_range); 
 }
 
 } // HepMC
 
 #endif  // HEPMC_GEN_EVENT_ITERATORS_H

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