TEvtGen/HepMC/GenRanges.h

   1 #ifndef HEPMC_GEN_EVENT_ITERATORS_H
   2 #define HEPMC_GEN_EVENT_ITERATORS_H
   3
   4 //--------------------------------------------------------------------------
   5 //////////////////////////////////////////////////////////////////////////
   6 // garren@fnal.gov, May 2009
   7 //
   8 //////////////////////////////////////////////////////////////////////////
   9 //--------------------------------------------------------------------------
  10
  11 #include <stdexcept>
  12
  13 #include "HepMC/GenEvent.h"
  14 #include "HepMC/GenVertex.h"
  15
  16 namespace HepMC {
  17
  18 //! GenEventVertexRange acts like a collection of vertices
  19
  20 ///
  21 /// \class  GenEventVertexRange
  22 /// HepMC::GenEventVertexRange is used to mimic a collection of
  23 /// vertices for ease of use - especially with utilities such as
  24 /// the Boost foreach funtion
  25 ///
  26 class GenEventVertexRange {
  27
  28 public:
  29
  30   /// the constructor requires a GenEvent
  31   GenEventVertexRange( GenEvent & e ) : m_event(e) {}
  32   ///
  33   GenEvent::vertex_iterator begin() { return m_event.vertices_begin(); }
  34   GenEvent::vertex_iterator end()   { return m_event.vertices_end(); }
  35
  36 private:
  37   /// Because the class contains a reference, assignments are not allowed.
  38   /// However, we need the copy constructor for GenEvent::vertex_range().
  39   GenEventVertexRange& operator=( GenEventVertexRange & );
  40
  41 private:
  42   GenEvent & m_event;
  43
  44 };
  45
  46 //! ConstGenEventVertexRange acts like a collection of vertices
  47
  48 ///
  49 /// \class  ConstGenEventVertexRange
  50 /// HepMC::ConstGenEventVertexRange is used to mimic a collection of
  51 /// vertices for ease of use - especially with utilities such as
  52 /// the Boost foreach funtion
  53 /// This is the const partner of GenEventVertexRange
  54 ///
  55 class ConstGenEventVertexRange {
  56
  57 public:
  58
  59   /// the constructor requires a const GenEvent
  60   ConstGenEventVertexRange( GenEvent const & e ) : m_event(e) {}
  61   ///
  62   GenEvent::vertex_const_iterator begin() const { return m_event.vertices_begin(); }
  63   GenEvent::vertex_const_iterator end()   const { return m_event.vertices_end(); }
  64
  65 private:
  66   /// Because the class contains a reference, assignments are not allowed.
  67   /// However, we need the copy constructor for GenEvent::vertex_range().
  68   ConstGenEventVertexRange& operator=( ConstGenEventVertexRange & );
  69
  70 private:
  71   GenEvent const & m_event;
  72
  73 };
  74
  75 //! GenEventParticleRange acts like a collection of particles
  76
  77 ///
  78 /// \class  GenEventParticleRange
  79 /// HepMC::GenEventParticleRange is used to mimic a collection of
  80 /// particles for ease of use - especially with utilities such as
  81 /// the Boost foreach funtion
  82 ///
  83 class GenEventParticleRange {
  84
  85 public:
  86
  87   /// the constructor requires a GenEvent
  88   GenEventParticleRange( GenEvent & e ) : m_event(e) {}
  89   ///
  90   GenEvent::particle_iterator begin() { return m_event.particles_begin(); }
  91   GenEvent::particle_iterator end()   { return m_event.particles_end(); }
  92
  93 private:
  94   /// Because the class contains a reference, assignments are not allowed.
  95   /// However, we need the copy constructor for GenEvent::particle_range().
  96   GenEventParticleRange& operator=( GenEventParticleRange & );
  97
  98 private:
  99   GenEvent & m_event;
 100
 101 };
 102
 103 //! ConstGenEventParticleRange acts like a collection of particles
 104
 105 ///
 106 /// \class  ConstGenEventParticleRange
 107 /// HepMC::ConstGenEventParticleRange is used to mimic a collection of
 108 /// particles for ease of use - especially with utilities such as
 109 /// the Boost foreach funtion
 110 /// This is the const partner of GenEventParticleRange
 111 ///
 112 class ConstGenEventParticleRange {
 113
 114 public:
 115
 116   /// the constructor requires a const GenEvent
 117   ConstGenEventParticleRange( GenEvent const & e ) : m_event(e) {}
 118   ///
 119   GenEvent::particle_const_iterator begin() const { return m_event.particles_begin(); }
 120   GenEvent::particle_const_iterator end()   const { return m_event.particles_end(); }
 121
 122 private:
 123   /// Because the class contains a reference, assignments are not allowed.
 124   /// However, we need the copy constructor for GenEvent::particle_range().
 125   ConstGenEventParticleRange& operator=( ConstGenEventParticleRange & );
 126
 127 private:
 128   GenEvent const & m_event;
 129
 130 };
 131
 132 //! GenVertexParticleRange acts like a collection of particles
 133
 134 ///
 135 /// \class  GenVertexParticleRange
 136 /// HepMC::GenVertexParticleRange is used to mimic a collection of
 137 /// particles for ease of use - especially with utilities such as
 138 /// the Boost foreach funtion
 139 ///
 140 class GenVertexParticleRange {
 141
 142 public:
 143
 144   /// the constructor requires a GenVertex
 145   GenVertexParticleRange( GenVertex & v, IteratorRange range = relatives )
 146   : m_vertex(v),m_range(range) {}
 147   ///
 148   GenVertex::particle_iterator begin() { return m_vertex.particles_begin(m_range); }
 149   GenVertex::particle_iterator end()   { return m_vertex.particles_end(m_range); }
 150
 151 private:
 152   /// Because the class contains a reference, assignments are not allowed.
 153   /// However, we need the copy constructor for GenVertex::particles().
 154   GenVertexParticleRange& operator=( GenVertexParticleRange & );
 155
 156 private:
 157   GenVertex     & m_vertex;
 158   IteratorRange   m_range;
 159
 160 };
 161
 162 //! GenParticleProductionRange acts like a collection of particles
 163
 164 ///
 165 /// \class  GenParticleProductionRange
 166 /// HepMC::GenParticleProductionRange is used to mimic a collection of
 167 /// particles associated with the particle's production vertex for ease of use
 168 /// Utilities such as the Boost foreach funtion will want to use this class.
 169 ///
 170 class GenParticleProductionRange {
 171
 172 public:
 173
 174   /// the constructor requires a GenParticle
 175   GenParticleProductionRange( GenParticle const & p, IteratorRange range = relatives )
 176   : m_particle(p),m_range(range) {}
 177   /// begin iterator throws an error if the particle production_vertex is undefined
 178   GenVertex::particle_iterator begin();
 179   /// end iterator throws an error if the particle production_vertex is undefined
 180   GenVertex::particle_iterator end();
 181
 182 private:
 183   /// Because the class contains a reference, assignments are not allowed.
 184   /// However, we need the copy constructor for GenVertex::particles_in().
 185   GenParticleProductionRange& operator=( GenParticleProductionRange & );
 186
 187 private:
 188   GenParticle const & m_particle;
 189   IteratorRange       m_range;
 190
 191 };
 192
 193 class ConstGenParticleProductionRange {
 194
 195 public:
 196
 197   /// the constructor requires a GenParticle
 198   ConstGenParticleProductionRange( GenParticle const & p, IteratorRange range = relatives )
 199   : m_particle(p),m_range(range) {}
 200   /// begin iterator throws an error if the particle production_vertex is undefined
 201   GenVertex::particle_iterator begin();
 202   /// end iterator throws an error if the particle production_vertex is undefined
 203   GenVertex::particle_iterator end();
 204
 205 private:
 206   /// Because the class contains a reference, assignments are not allowed.
 207   /// However, we need the copy constructor for GenVertex::particles_in().
 208   ConstGenParticleProductionRange& operator=( ConstGenParticleProductionRange & );
 209
 210 private:
 211   GenParticle const & m_particle;
 212   IteratorRange       m_range;
 213
 214 };
 215
 216 //! GenParticleEndRange acts like a collection of particles
 217
 218 ///
 219 /// \class  GenParticleEndRange
 220 /// HepMC::GenParticleEndRange is used to mimic a collection of
 221 /// particles associated with the particle's end vertex for ease of use
 222 /// Utilities such as the Boost foreach funtion will want to use this class.
 223 ///
 224 class GenParticleEndRange {
 225
 226 public:
 227
 228   /// the constructor requires a GenParticle
 229   GenParticleEndRange( GenParticle const & p, IteratorRange range = relatives )
 230   : m_particle(p),m_range(range) {}
 231   /// begin iterator throws an error if the particle end_vertex is undefined
 232   GenVertex::particle_iterator begin();
 233   /// end iterator throws an error if the particle end_vertex is undefined
 234   GenVertex::particle_iterator end();
 235
 236 private:
 237   /// Because the class contains a reference, assignments are not allowed.
 238   /// However, we need the copy constructor for GenVertex::particles_out().
 239   GenParticleEndRange& operator=( GenParticleEndRange & );
 240
 241 private:
 242   GenParticle const & m_particle;
 243   IteratorRange       m_range;
 244
 245 };
 246
 247 class ConstGenParticleEndRange {
 248
 249 public:
 250
 251   /// the constructor requires a GenParticle
 252   ConstGenParticleEndRange( GenParticle const & p, IteratorRange range = relatives )
 253   : m_particle(p),m_range(range) {}
 254   /// begin iterator throws an error if the particle end_vertex is undefined
 255   GenVertex::particle_iterator begin();
 256   /// end iterator throws an error if the particle end_vertex is undefined
 257   GenVertex::particle_iterator end();
 258
 259 private:
 260   /// Because the class contains a reference, assignments are not allowed.
 261   /// However, we need the copy constructor for GenVertex::particles_out().
 262   ConstGenParticleEndRange& operator=( ConstGenParticleEndRange & );
 263
 264 private:
 265   GenParticle const & m_particle;
 266   IteratorRange       m_range;
 267
 268 };
 269
 270
 271 inline GenVertex::particle_iterator GenParticleProductionRange::begin()
 272 {
 273     if ( ! m_particle.production_vertex() )
 274         throw(std::range_error("GenParticleProductionRange: GenParticle has no production_vertex"));
 275     return m_particle.production_vertex()->particles_begin(m_range);
 276 }
 277
 278 inline GenVertex::particle_iterator GenParticleProductionRange::end()
 279 {
 280     if ( ! m_particle.production_vertex() )
 281         throw(std::range_error("GenParticleProductionRange: GenParticle has no production_vertex"));
 282     return m_particle.production_vertex()->particles_end(m_range);
 283 }
 284
 285
 286 inline GenVertex::particle_iterator ConstGenParticleProductionRange::begin()
 287 {
 288     if ( ! m_particle.production_vertex() )
 289         throw(std::range_error("ConstGenParticleProductionRange: GenParticle has no production_vertex"));
 290     return m_particle.production_vertex()->particles_begin(m_range);
 291 }
 292
 293 inline GenVertex::particle_iterator ConstGenParticleProductionRange::end()
 294 {
 295     if ( ! m_particle.production_vertex() )
 296         throw(std::range_error("ConstGenParticleProductionRange: GenParticle has no production_vertex"));
 297     return m_particle.production_vertex()->particles_end(m_range);
 298 }
 299
 300 inline GenVertex::particle_iterator GenParticleEndRange::begin()
 301 {
 302     if ( ! m_particle.end_vertex() )
 303         throw(std::range_error("GenParticleEndRange: GenParticle has no end_vertex"));
 304     return m_particle.end_vertex()->particles_begin(m_range);
 305 }
 306 inline GenVertex::particle_iterator GenParticleEndRange::end()
 307 {
 308     if ( ! m_particle.end_vertex() )
 309         throw(std::range_error("GenParticleEndRange: GenParticle has no end_vertex"));
 310     return m_particle.end_vertex()->particles_end(m_range);
 311 }
 312
 313 inline GenVertex::particle_iterator ConstGenParticleEndRange::begin()
 314 {
 315     if ( ! m_particle.end_vertex() )
 316         throw(std::range_error("ConstGenParticleEndRange: GenParticle has no end_vertex"));
 317     return m_particle.end_vertex()->particles_begin(m_range);
 318 }
 319 inline GenVertex::particle_iterator ConstGenParticleEndRange::end()
 320 {
 321     if ( ! m_particle.end_vertex() )
 322         throw(std::range_error("ConstGenParticleEndRange: GenParticle has no end_vertex"));
 323     return m_particle.end_vertex()->particles_end(m_range);
 324 }
 325
 326 } // HepMC
 327
 328 #endif  // HEPMC_GEN_EVENT_ITERATORS_H