Line data Source code
1 : //--------------------------------------------------------------------------
2 : #ifndef HEPMC_GEN_EVENT_H
3 : #define HEPMC_GEN_EVENT_H
4 :
5 : //////////////////////////////////////////////////////////////////////////
6 : // Matt.Dobbs@Cern.CH, September 1999, refer to:
7 : // M. Dobbs and J.B. Hansen, "The HepMC C++ Monte Carlo Event Record for
8 : // High Energy Physics", Computer Physics Communications (to be published).
9 : //
10 : // Event record for MC generators (for use at any stage of generation)
11 : //////////////////////////////////////////////////////////////////////////
12 : //
13 : // This class is intended as both a "container class" ( to store a MC
14 : // event for interface between MC generators and detector simulation )
15 : // and also as a "work in progress class" ( that could be used inside
16 : // a generator and modified as the event is built ).
17 : //
18 : // Iterators are provided which allow the user to easily obtain a
19 : // list of particles or vertices in an event --- this list can be filled
20 : // subject to some sort of selection criteria. Examples are given below
21 : // ( see HepMC::copy_if and std::copy )
22 :
23 : ///
24 : /// \namespace HepMC
25 : /// All classes in the HepMC packages are in the HepMC namespace
26 : ///
27 : namespace HepMC {
28 :
29 : // To create a list from an iterator, use: (i.e. for a list of particles);
30 : // #include <algorithm>
31 : // list<GenParticle*> thelist;
32 : // copy( evt->particles_begin(), evt->particles_end(),
33 : // back_inserter(thelist) );
34 : // to create a list subject to a condition (predicate) use:
35 : // list<GenParticle*> thelist;
36 : // HepMC::copy_if( evt->particles_begin(), evt->particles_end(),
37 : // back_inserter(thelist), is_photon() );
38 : // where is_photon() is a predicate like:
39 : // class is_photon {
40 : // public:
41 : // bool operator() ( GenParticle const * p ) {
42 : // if ( p && p->pdg_id() == 22 ) return true;
43 : // return false;
44 : // }
45 : // };
46 : // which the user defines herself.
47 :
48 : /// define the type of iterator to use
49 : template <class InputIterator, class OutputIterator, class Predicate>
50 : void copy_if( InputIterator first, InputIterator last, OutputIterator out,
51 : Predicate pred ) {
52 : for ( ; first != last; ++first ) { if ( pred(*first) ) out = *first; }
53 : }
54 : } // HepMC
55 :
56 : // Since a container of all vertices in the event is maintained, the time
57 : // required to loop over all vertices (or particles) is very fast -- and
58 : // the user does not gain much by first making his own list.
59 : // (this is not true for the GenVertex:: versions of these iterators, which
60 : // allow you to specify the vertex starting point and range)
61 :
62 : // Data Members:
63 : // signal_process_id() The integer ID that uniquely specifies this signal
64 : // process, i.e. MSUB in Pythia. It is necessary to
65 : // package this with each event rather than with the run
66 : // because many processes may be generated within one
67 : // run.
68 : // event_number() Strictly speaking we cannot think of any reason that
69 : // an event would need to know its own event number, it
70 : // is more likely something that would be assigned by
71 : // a database. It is included anyway (tradition?) since
72 : // we expect it may be useful for debugging. It can
73 : // be reset later by a database.
74 : // mpi() The number of multi parton interactions in the event.
75 : // This is NOT beam pileup. Set to -1 by default.
76 : // beam_particles() A pair of pointers to the incoming beam particles.
77 : // signal_process_vertex() pointer to the vertex containing the signal process
78 : // weights() Vector of doubles which specify th weight of the evnt,
79 : // the first entry will be the "event weight" used for
80 : // hit and miss etc., but a general vector is used to
81 : // allow for reweighting etc. We envision a list of
82 : // WeightTags to be included with a run class which
83 : // would specify the meaning of the Weights .
84 : // random_states() Vector of integers which specify the random number
85 : // generator's state for this event. It is left to the
86 : // generator to make use of this. We envision a vector of
87 : // RndmStatesTags to be included with a run class which
88 : // would specify the meaning of the random_states.
89 : //
90 : ///////////////////////
91 : // Memory allocation //
92 : ///////////////////////
93 : // -When a vertex (particle) is added to a event (vertex), it is "adopted"
94 : // and becomes the responsibility of the event (vertex) to delete that
95 : // particle.
96 : // -objects responsible for deleting memory:
97 : // -events delete included vertices
98 : // -each vertex deletes its outgoing particles which do not have decay
99 : // vertices
100 : // -each vertex deletes its incoming particles which do not
101 : // have creation vertices
102 : //
103 : ////////////////////////
104 : // About the Barcodes //
105 : ////////////////////////
106 : // - each vertex or particle has a barcode, which is just an integer which
107 : // uniquely identifies it inside the event (i.e. there is a one to one
108 : // mapping between particle memory addresses and particle barcodes... and
109 : // the same applied for vertices)
110 : // - The value of a barcode has NO MEANING and NO ORDER!
111 : // For the user's convenience, when an event is read in via an IO_method
112 : // from an indexed list (like the HEPEVT common block), then the index will
113 : // become the barcode for that particle.
114 : // - particle barcodes are always positive integers
115 : // vertex barcodes are always negative integers
116 : // The barcodes are chosen and set automatically when a vertex or particle
117 : // comes under the ownership of an event (i.e. it is contained in an event).
118 : // - You can tell when a particle or vertex is owned, because its
119 : // parent_event() return value will return a pointer to the event which owns
120 : // it (or null if its an orphan).
121 : // - Please note that the barcodes are intended for internal use within HepMC
122 : // as a unique identifier for the particles and vertices.
123 : // Using the barcode to encode extra information is an abuse of
124 : // the barcode data member and causes confusion among users.
125 : //
126 :
127 : #include "HepMC/GenVertex.h"
128 : #include "HepMC/GenParticle.h"
129 : #include "HepMC/WeightContainer.h"
130 : #include "HepMC/GenCrossSection.h"
131 : #include "HepMC/HeavyIon.h"
132 : #include "HepMC/PdfInfo.h"
133 : #include "HepMC/Units.h"
134 : #include "HepMC/HepMCDefs.h"
135 : #include <map>
136 : #include <string>
137 : #include <vector>
138 : #include <algorithm>
139 : #include <iostream>
140 :
141 : namespace HepMC {
142 :
143 : class GenEventVertexRange;
144 : class ConstGenEventVertexRange;
145 : class GenEventParticleRange;
146 : class ConstGenEventParticleRange;
147 :
148 : //! The GenEvent class is the core of HepMC
149 :
150 : ///
151 : /// \class GenEvent
152 : /// HepMC::GenEvent contains information about generated particles.
153 : /// GenEvent is structured as a set of vertices which contain the particles.
154 : ///
155 : class GenEvent {
156 : friend class GenParticle;
157 : friend class GenVertex;
158 : public:
159 : /// default constructor creates null pointers to HeavyIon, PdfInfo, and GenCrossSection
160 : GenEvent( int signal_process_id = 0, int event_number = 0,
161 : GenVertex* signal_vertex = 0,
162 : const WeightContainer& weights = std::vector<double>(),
163 : const std::vector<long>& randomstates = std::vector<long>(),
164 : Units::MomentumUnit = Units::default_momentum_unit(),
165 : Units::LengthUnit = Units::default_length_unit() );
166 : /// explicit constructor that takes HeavyIon and PdfInfo
167 : GenEvent( int signal_process_id, int event_number,
168 : GenVertex* signal_vertex, const WeightContainer& weights,
169 : const std::vector<long>& randomstates,
170 : const HeavyIon& ion, const PdfInfo& pdf,
171 : Units::MomentumUnit = Units::default_momentum_unit(),
172 : Units::LengthUnit = Units::default_length_unit() );
173 : /// constructor requiring units - all else is default
174 : GenEvent( Units::MomentumUnit, Units::LengthUnit,
175 : int signal_process_id = 0, int event_number = 0,
176 : GenVertex* signal_vertex = 0,
177 : const WeightContainer& weights = std::vector<double>(),
178 : const std::vector<long>& randomstates = std::vector<long>() );
179 : /// explicit constructor with units first that takes HeavyIon and PdfInfo
180 : GenEvent( Units::MomentumUnit, Units::LengthUnit,
181 : int signal_process_id, int event_number,
182 : GenVertex* signal_vertex, const WeightContainer& weights,
183 : const std::vector<long>& randomstates,
184 : const HeavyIon& ion, const PdfInfo& pdf );
185 : GenEvent( const GenEvent& inevent ); //!< deep copy
186 : GenEvent& operator=( const GenEvent& inevent ); //!< make a deep copy
187 : virtual ~GenEvent(); //!<deletes all vertices/particles in this evt
188 :
189 : void swap( GenEvent & other ); //!< swap
190 :
191 : void print( std::ostream& ostr = std::cout ) const; //!< dumps to ostr
192 : void print_version( std::ostream& ostr = std::cout ) const; //!< dumps release version to ostr
193 :
194 : /// assign a barcode to a particle
195 : GenParticle* barcode_to_particle( int barCode ) const;
196 : /// assign a barcode to a vertex
197 : GenVertex* barcode_to_vertex( int barCode ) const;
198 :
199 : ////////////////////
200 : // access methods //
201 : ////////////////////
202 :
203 : int signal_process_id() const; //!< unique signal process id
204 : int event_number() const; //!< event number
205 : int mpi() const; //!< number of multi parton interactions
206 : double event_scale() const; //!< energy scale, see hep-ph/0109068
207 : double alphaQCD() const; //!< QCD coupling, see hep-ph/0109068
208 : double alphaQED() const; //!< QED coupling, see hep-ph/0109068
209 : /// pointer to the vertex containing the signal process
210 : GenVertex* signal_process_vertex() const;
211 : /// test to see if we have two valid beam particles
212 : bool valid_beam_particles() const;
213 : /// pair of pointers to the two incoming beam particles
214 : std::pair<HepMC::GenParticle*,HepMC::GenParticle*> beam_particles() const;
215 : /// check GenEvent for validity
216 : /// A GenEvent is presumed valid if it has particles and/or vertices.
217 : bool is_valid() const;
218 :
219 : /// direct access to the weights container is allowed.
220 : /// Thus you can use myevt.weights()[2];
221 : /// to access element 2 of the weights.
222 : /// or use myevt.weights().push_back( mywgt ); to add an element.
223 : /// and you can set the weights with myevt.weights() = myvector;
224 : WeightContainer& weights(); //!< direct access to WeightContainer
225 : const WeightContainer& weights() const; //!< direct access to WeightContainer
226 :
227 : /// access the GenCrossSection container if it exists
228 : GenCrossSection const * cross_section() const;
229 : GenCrossSection* cross_section();
230 : /// access the HeavyIon container if it exists
231 : HeavyIon const * heavy_ion() const;
232 : HeavyIon* heavy_ion();
233 : /// access the PdfInfo container if it exists
234 : PdfInfo const * pdf_info() const;
235 : PdfInfo* pdf_info();
236 :
237 : /// vector of integers containing information about the random state
238 : const std::vector<long>& random_states() const;
239 :
240 : /// how many particle barcodes exist?
241 : int particles_size() const;
242 : /// return true if there are no particle barcodes
243 : bool particles_empty() const;
244 : /// how many vertex barcodes exist?
245 : int vertices_size() const;
246 : /// return true if there are no vertex barcodes
247 : bool vertices_empty() const;
248 :
249 : /// Write the unit information to an output stream.
250 : /// If the output stream is not defined, use std::cout.
251 : void write_units( std::ostream & os = std::cout ) const;
252 : /// If the cross section is defined,
253 : /// write the cross section information to an output stream.
254 : /// If the output stream is not defined, use std::cout.
255 : void write_cross_section( std::ostream& ostr = std::cout ) const;
256 :
257 : /// Units used by the GenParticle momentum FourVector.
258 : Units::MomentumUnit momentum_unit() const;
259 : /// Units used by the GenVertex position FourVector.
260 : Units::LengthUnit length_unit() const;
261 :
262 : std::ostream& write(std::ostream&);
263 : std::istream& read(std::istream&);
264 :
265 : /////////////////////
266 : // mutator methods //
267 : /////////////////////
268 :
269 : bool add_vertex( GenVertex* vtx ); //!< adds to evt and adopts
270 : bool remove_vertex( GenVertex* vtx ); //!< erases vtx from evt
271 : void clear(); //!< empties the entire event
272 :
273 : void set_signal_process_id( int id ); //!< set unique signal process id
274 : void set_event_number( int eventno ); //!< set event number
275 : void set_mpi( int ); //!< set number of multi parton interactions
276 : void set_event_scale( double scale ); //!< set energy scale
277 : void set_alphaQCD( double a ); //!< set QCD coupling
278 : void set_alphaQED( double a ); //!< set QED coupling
279 :
280 : /// set pointer to the vertex containing the signal process
281 : void set_signal_process_vertex( GenVertex* );
282 : /// set incoming beam particles
283 : bool set_beam_particles(GenParticle*, GenParticle*);
284 : /// use a pair of GenParticle*'s to set incoming beam particles
285 : bool set_beam_particles(std::pair<HepMC::GenParticle*,HepMC::GenParticle*> const &);
286 : /// provide random state information
287 : void set_random_states( const std::vector<long>& randomstates );
288 :
289 : /// provide a pointer to the GenCrossSection container
290 : void set_cross_section( const GenCrossSection& );
291 : /// provide a pointer to the HeavyIon container
292 : void set_heavy_ion( const HeavyIon& ion );
293 : /// provide a pointer to the PdfInfo container
294 : void set_pdf_info( const PdfInfo& p );
295 :
296 : /// set the units using enums
297 : /// This method will convert momentum and position data if necessary
298 : void use_units( Units::MomentumUnit, Units::LengthUnit );
299 : /// set the units using strings
300 : /// the string must match the enum exactly
301 : /// This method will convert momentum and position data if necessary
302 : void use_units( std::string&, std::string& );
303 :
304 : /// set the units using enums
305 : /// This method will NOT convert momentum and position data
306 : void define_units( Units::MomentumUnit, Units::LengthUnit );
307 : /// set the units using strings
308 : /// the string must match the enum exactly
309 : /// This method will NOT convert momentum and position data
310 : void define_units( std::string&, std::string& );
311 :
312 : /// vertex range
313 : GenEventVertexRange vertex_range();
314 : /// vertex range
315 : ConstGenEventVertexRange vertex_range() const;
316 : /// particle range
317 : GenEventParticleRange particle_range();
318 : /// particle range
319 : ConstGenEventParticleRange particle_range() const;
320 :
321 : public:
322 : ///////////////////////////////
323 : // vertex_iterators //
324 : ///////////////////////////////
325 : // Note: the XXX_iterator is "resolvable" as XXX_const_iterator, but
326 : // not the reverse, which is consistent with STL,
327 : // see Musser, Derge, Saini 2ndEd. p. 69,70.
328 :
329 : //! const vertex iterator
330 :
331 : /// \class vertex_const_iterator
332 : /// HepMC::GenEvent::vertex_const_iterator
333 : /// is used to iterate over all vertices in the event.
334 : class vertex_const_iterator :
335 : public std::iterator<std::forward_iterator_tag,HepMC::GenVertex*,ptrdiff_t>{
336 : // Iterates over all vertices in this event
337 : public:
338 : /// constructor requiring vertex information
339 : vertex_const_iterator(
340 : const
341 : std::map<int,HepMC::GenVertex*,std::greater<int> >::const_iterator& i)
342 0 : : m_map_iterator(i) {}
343 : vertex_const_iterator() {}
344 : /// copy constructor
345 : vertex_const_iterator( const vertex_const_iterator& i )
346 : { *this = i; }
347 0 : virtual ~vertex_const_iterator() {}
348 : /// make a copy
349 : vertex_const_iterator& operator=( const vertex_const_iterator& i )
350 : { m_map_iterator = i.m_map_iterator; return *this; }
351 : /// return a pointer to a GenVertex
352 0 : GenVertex* operator*(void) const { return m_map_iterator->second; }
353 : /// Pre-fix increment
354 : vertex_const_iterator& operator++(void) //Pre-fix increment
355 0 : { ++m_map_iterator; return *this; }
356 : /// Post-fix increment
357 : vertex_const_iterator operator++(int) //Post-fix increment
358 : { vertex_const_iterator out(*this); ++(*this); return out; }
359 : /// equality
360 : bool operator==( const vertex_const_iterator& a ) const
361 : { return m_map_iterator == a.m_map_iterator; }
362 : /// inequality
363 : bool operator!=( const vertex_const_iterator& a ) const
364 0 : { return !(m_map_iterator == a.m_map_iterator); }
365 : protected:
366 : /// const iterator to a vertex map
367 : std::map<int,HepMC::GenVertex*,std::greater<int> >::const_iterator
368 : m_map_iterator;
369 : private:
370 : /// Pre-fix increment -- is not allowed
371 : vertex_const_iterator& operator--(void);
372 : /// Post-fix increment -- is not allowed
373 : vertex_const_iterator operator--(int);
374 : };
375 : friend class vertex_const_iterator;
376 : /// begin vertex iteration
377 : vertex_const_iterator vertices_begin() const
378 0 : { return GenEvent::vertex_const_iterator(
379 0 : m_vertex_barcodes.begin() ); }
380 : /// end vertex iteration
381 : vertex_const_iterator vertices_end() const
382 0 : { return GenEvent::vertex_const_iterator(
383 0 : m_vertex_barcodes.end() ); }
384 :
385 :
386 : //! non-const vertex iterator
387 :
388 : /// \class vertex_iterator
389 : /// HepMC::GenEvent::vertex_iterator
390 : /// is used to iterate over all vertices in the event.
391 : class vertex_iterator :
392 : public std::iterator<std::forward_iterator_tag,HepMC::GenVertex*,ptrdiff_t>{
393 : // Iterates over all vertices in this event
394 : public:
395 : /// constructor requiring vertex information
396 : vertex_iterator(
397 : const
398 : std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator& i )
399 0 : : m_map_iterator( i ) {}
400 : vertex_iterator() {}
401 : /// copy constructor
402 : vertex_iterator( const vertex_iterator& i ) { *this = i; }
403 0 : virtual ~vertex_iterator() {}
404 : /// make a copy
405 : vertex_iterator& operator=( const vertex_iterator& i ) {
406 : m_map_iterator = i.m_map_iterator;
407 : return *this;
408 : }
409 : /// const vertex iterator
410 : operator vertex_const_iterator() const
411 0 : { return vertex_const_iterator(m_map_iterator); }
412 : /// return a pointer to a GenVertex
413 : GenVertex* operator*(void) const
414 0 : { return m_map_iterator->second; }
415 : /// Pre-fix increment
416 : vertex_iterator& operator++(void) //Pre-fix increment
417 0 : { ++m_map_iterator; return *this; }
418 : /// Post-fix increment
419 : vertex_iterator operator++(int) //Post-fix increment
420 : { vertex_iterator out(*this); ++(*this); return out; }
421 : /// equality
422 : bool operator==( const vertex_iterator& a ) const
423 : { return m_map_iterator == a.m_map_iterator; }
424 : /// inequality
425 : bool operator!=( const vertex_iterator& a ) const
426 0 : { return !(m_map_iterator == a.m_map_iterator); }
427 : protected:
428 : /// iterator to the vertex map
429 : std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator
430 : m_map_iterator;
431 : private:
432 : /// Pre-fix increment
433 : vertex_iterator& operator--(void);
434 : /// Post-fix increment
435 : vertex_iterator operator--(int);
436 :
437 : };
438 : friend class vertex_iterator;
439 : /// begin vertex iteration
440 : vertex_iterator vertices_begin()
441 0 : { return GenEvent::vertex_iterator(
442 0 : m_vertex_barcodes.begin() ); }
443 : /// end vertex iteration
444 : vertex_iterator vertices_end()
445 0 : { return GenEvent::vertex_iterator(
446 0 : m_vertex_barcodes.end() ); }
447 :
448 : public:
449 : ///////////////////////////////
450 : // particle_iterator //
451 : ///////////////////////////////
452 : // Example of iterating over all particles in the event:
453 : // for ( GenEvent::particle_const_iterator p = particles_begin();
454 : // p != particles_end(); ++p ) {
455 : // (*p)->print();
456 : // }
457 : //
458 :
459 : //! const particle iterator
460 :
461 : /// \class particle_const_iterator
462 : /// HepMC::GenEvent::particle_const_iterator
463 : /// is used to iterate over all particles in the event.
464 : class particle_const_iterator :
465 : public std::iterator<std::forward_iterator_tag,HepMC::GenParticle*,ptrdiff_t>{
466 : // Iterates over all vertices in this event
467 : public:
468 : /// iterate over particles
469 : particle_const_iterator(
470 : const std::map<int,HepMC::GenParticle*>::const_iterator& i )
471 0 : : m_map_iterator(i) {}
472 : particle_const_iterator() {}
473 : /// copy constructor
474 0 : particle_const_iterator( const particle_const_iterator& i )
475 0 : { *this = i; }
476 0 : virtual ~particle_const_iterator() {}
477 : /// make a copy
478 : particle_const_iterator& operator=(
479 : const particle_const_iterator& i )
480 0 : { m_map_iterator = i.m_map_iterator; return *this; }
481 : /// return a pointer to GenParticle
482 : GenParticle* operator*(void) const
483 0 : { return m_map_iterator->second; }
484 : /// Pre-fix increment
485 : particle_const_iterator& operator++(void) //Pre-fix increment
486 0 : { ++m_map_iterator; return *this; }
487 : /// Post-fix increment
488 : particle_const_iterator operator++(int) //Post-fix increment
489 0 : { particle_const_iterator out(*this); ++(*this); return out; }
490 : /// equality
491 : bool operator==( const particle_const_iterator& a ) const
492 : { return m_map_iterator == a.m_map_iterator; }
493 : /// inequality
494 : bool operator!=( const particle_const_iterator& a ) const
495 0 : { return !(m_map_iterator == a.m_map_iterator); }
496 : protected:
497 : /// const iterator to the GenParticle map
498 : std::map<int,HepMC::GenParticle*>::const_iterator m_map_iterator;
499 : private:
500 : /// Pre-fix increment
501 : particle_const_iterator& operator--(void);
502 : /// Post-fix increment
503 : particle_const_iterator operator--(int);
504 : };
505 : friend class particle_const_iterator;
506 : /// begin particle iteration
507 : particle_const_iterator particles_begin() const
508 0 : { return GenEvent::particle_const_iterator(
509 0 : m_particle_barcodes.begin() ); }
510 : /// end particle iteration
511 : particle_const_iterator particles_end() const
512 0 : { return GenEvent::particle_const_iterator(
513 0 : m_particle_barcodes.end() ); }
514 :
515 : //! non-const particle iterator
516 :
517 : /// \class particle_iterator
518 : /// HepMC::GenEvent::particle_iterator
519 : /// is used to iterate over all particles in the event.
520 : class particle_iterator :
521 : public std::iterator<std::forward_iterator_tag,HepMC::GenParticle*,ptrdiff_t>{
522 : // Iterates over all vertices in this event
523 : public:
524 : /// iterate over particles
525 : particle_iterator( const std::map<int,HepMC::GenParticle*>::iterator& i )
526 0 : : m_map_iterator( i ) {}
527 0 : particle_iterator() {}
528 : /// copy constructor
529 : particle_iterator( const particle_iterator& i ) { *this = i; }
530 0 : virtual ~particle_iterator() {}
531 : /// make a copy
532 : particle_iterator& operator=( const particle_iterator& i ) {
533 0 : m_map_iterator = i.m_map_iterator;
534 0 : return *this;
535 : }
536 : /// const particle iterator
537 : operator particle_const_iterator() const
538 0 : { return particle_const_iterator(m_map_iterator); }
539 : /// return pointer to GenParticle
540 : GenParticle* operator*(void) const
541 0 : { return m_map_iterator->second; }
542 : /// Pre-fix increment
543 : particle_iterator& operator++(void)
544 0 : { ++m_map_iterator; return *this; }
545 : /// Post-fix increment
546 : particle_iterator operator++(int)
547 : { particle_iterator out(*this); ++(*this); return out; }
548 : /// equality
549 : bool operator==( const particle_iterator& a ) const
550 : { return m_map_iterator == a.m_map_iterator; }
551 : /// inequality
552 : bool operator!=( const particle_iterator& a ) const
553 0 : { return !(m_map_iterator == a.m_map_iterator); }
554 : protected:
555 : /// iterator for GenParticle map
556 : std::map<int,HepMC::GenParticle*>::iterator m_map_iterator;
557 : private:
558 : /// Pre-fix increment
559 : particle_iterator& operator--(void);
560 : /// Post-fix increment
561 : particle_iterator operator--(int);
562 : };
563 : friend class particle_iterator;
564 : /// begin particle iteration
565 : particle_iterator particles_begin()
566 0 : { return GenEvent::particle_iterator(
567 0 : m_particle_barcodes.begin() ); }
568 : /// end particle iteration
569 : particle_iterator particles_end()
570 0 : { return GenEvent::particle_iterator(
571 0 : m_particle_barcodes.end() ); }
572 :
573 : ////////////////////////////////////////////////
574 : protected:
575 : //
576 : // Following methods intended for use by GenParticle/Vertex classes:
577 : // In general there is no reason they should be used elsewhere.
578 : /// set the barcode - intended for use by GenParticle
579 : bool set_barcode( GenParticle* p, int suggested_barcode =false );
580 : /// set the barcode - intended for use by GenVertex
581 : bool set_barcode( GenVertex* v, int suggested_barcode =false );
582 : /// intended for use by GenParticle
583 : void remove_barcode( GenParticle* p );
584 : /// intended for use by GenVertex
585 : void remove_barcode( GenVertex* v );
586 :
587 : void delete_all_vertices(); //!<delete all vertices owned by this event
588 :
589 : private: // methods
590 : /// internal method used when converting momentum units
591 : bool use_momentum_unit( Units::MomentumUnit );
592 : bool use_momentum_unit( std::string& );
593 : /// internal method used when converting length units
594 : bool use_length_unit( Units::LengthUnit );
595 : bool use_length_unit( std::string& );
596 :
597 : // the following internal methods are used by read() and write()
598 :
599 : /// send the beam particles to ASCII output
600 : std::ostream & write_beam_particles( std::ostream &,
601 : std::pair<HepMC::GenParticle *,HepMC::GenParticle *> );
602 : /// send a GenVertex to ASCII output
603 : std::ostream & write_vertex( std::ostream &, GenVertex const * );
604 : /// send a GenParticle to ASCII output
605 : std::ostream & write_particle( std::ostream&, GenParticle const * );
606 : /// find the file type
607 : std::istream & find_file_type( std::istream & );
608 : /// find the key at the end of the block
609 : std::istream & find_end_key( std::istream &, int & );
610 : /// get unit information from ASCII input
611 : std::istream & read_units( std::istream & );
612 : /// get weight names from ASCII input
613 : std::istream & read_weight_names( std::istream & );
614 : /// read the event header line
615 : std::istream & process_event_line( std::istream &, int &, int &, int &, int & );
616 :
617 : private: // data members
618 : int m_signal_process_id;
619 : int m_event_number;
620 : int m_mpi; // number of multi paricle interactions
621 : double m_event_scale;// energy scale, see hep-ph/0109068
622 : double m_alphaQCD; // QCD coupling, see hep-ph/0109068
623 : double m_alphaQED; // QED coupling, see hep-ph/0109068
624 : GenVertex* m_signal_process_vertex;
625 : GenParticle* m_beam_particle_1;
626 : GenParticle* m_beam_particle_2;
627 : WeightContainer m_weights; // weights for this event first weight
628 : // is used by default for hit and miss
629 : std::vector<long> m_random_states; // container of rndm num
630 : // generator states
631 :
632 : std::map< int,HepMC::GenVertex*,std::greater<int> > m_vertex_barcodes;
633 : std::map< int,HepMC::GenParticle*,std::less<int> > m_particle_barcodes;
634 : GenCrossSection* m_cross_section; // undefined by default
635 : HeavyIon* m_heavy_ion; // undefined by default
636 : PdfInfo* m_pdf_info; // undefined by default
637 : Units::MomentumUnit m_momentum_unit; // default value set by configure switch
638 : Units::LengthUnit m_position_unit; // default value set by configure switch
639 :
640 : };
641 :
642 :
643 : ///////////////////////////
644 : // IO Free Functions //
645 : ///////////////////////////
646 :
647 : /// standard streaming IO output operator
648 : std::ostream & operator << (std::ostream &, GenEvent &);
649 : /// standard streaming IO input operator
650 : std::istream & operator >> (std::istream &, GenEvent &);
651 : /// set the units for this input stream
652 : std::istream & set_input_units(std::istream &,
653 : Units::MomentumUnit, Units::LengthUnit);
654 : /// Explicitly write the begin block lines that IO_GenEvent uses
655 : std::ostream & write_HepMC_IO_block_begin(std::ostream & );
656 : /// Explicitly write the end block line that IO_GenEvent uses
657 : std::ostream & write_HepMC_IO_block_end(std::ostream & );
658 :
659 :
660 : ///////////////////////////
661 : // INLINE Free Functions //
662 : ///////////////////////////
663 :
664 : // Implemented in terms of GenEvent::use_...
665 : inline GenEvent& convert_units(GenEvent & evt, Units::MomentumUnit m, Units::LengthUnit l)
666 : {
667 : evt.use_units(m, l);
668 : return evt;
669 : }
670 :
671 : ///////////////////////////
672 : // INLINE Access Methods //
673 : ///////////////////////////
674 :
675 : /// The integer ID that uniquely specifies this signal
676 : /// process, i.e. MSUB in Pythia. It is necessary to
677 : /// package this with each event rather than with the run
678 : /// because many processes may be generated within one run.
679 : inline int GenEvent::signal_process_id() const
680 0 : { return m_signal_process_id; }
681 :
682 0 : inline int GenEvent::event_number() const { return m_event_number; }
683 :
684 : /// Returns the number of multi parton interactions in the event.
685 : /// This number is -1 if it is not set.
686 0 : inline int GenEvent::mpi() const { return m_mpi; }
687 :
688 0 : inline double GenEvent::event_scale() const { return m_event_scale; }
689 :
690 0 : inline double GenEvent::alphaQCD() const { return m_alphaQCD; }
691 :
692 0 : inline double GenEvent::alphaQED() const { return m_alphaQED; }
693 :
694 : inline GenVertex* GenEvent::signal_process_vertex() const {
695 : /// returns a (mutable) pointer to the signal process vertex
696 0 : return m_signal_process_vertex;
697 : }
698 :
699 0 : inline WeightContainer& GenEvent::weights() { return m_weights; }
700 :
701 : inline const WeightContainer& GenEvent::weights() const
702 0 : { return m_weights; }
703 :
704 : inline GenCrossSection const * GenEvent::cross_section() const
705 0 : { return m_cross_section; }
706 :
707 : inline GenCrossSection* GenEvent::cross_section()
708 : { return m_cross_section; }
709 :
710 : inline HeavyIon const * GenEvent::heavy_ion() const
711 0 : { return m_heavy_ion; }
712 :
713 : inline HeavyIon* GenEvent::heavy_ion()
714 0 : { return m_heavy_ion; }
715 :
716 : inline PdfInfo const * GenEvent::pdf_info() const
717 0 : { return m_pdf_info; }
718 :
719 : inline PdfInfo* GenEvent::pdf_info()
720 0 : { return m_pdf_info; }
721 :
722 : /// Vector of integers which specify the random number
723 : /// generator's state for this event. It is left to the
724 : /// generator to make use of this. We envision a vector of
725 : /// RndmStatesTags to be included with a run class which
726 : /// would specify the meaning of the random_states.
727 : inline const std::vector<long>& GenEvent::random_states() const
728 0 : { return m_random_states; }
729 :
730 : inline void GenEvent::set_signal_process_id( int id )
731 0 : { m_signal_process_id = id; }
732 :
733 : inline void GenEvent::set_event_number( int eventno )
734 0 : { m_event_number = eventno; }
735 :
736 : /// Use this to set the number of multi parton interactions in each event.
737 : inline void GenEvent::set_mpi( int nmpi )
738 0 : { m_mpi = nmpi; }
739 :
740 :
741 0 : inline void GenEvent::set_event_scale( double sc ) { m_event_scale = sc; }
742 :
743 0 : inline void GenEvent::set_alphaQCD( double a ) { m_alphaQCD = a; }
744 :
745 0 : inline void GenEvent::set_alphaQED( double a ) { m_alphaQED = a; }
746 :
747 : inline void GenEvent::set_signal_process_vertex( GenVertex* vtx ) {
748 0 : m_signal_process_vertex = vtx;
749 0 : if ( m_signal_process_vertex ) add_vertex( m_signal_process_vertex );
750 0 : }
751 :
752 : inline void GenEvent::set_cross_section( const GenCrossSection& xs )
753 : {
754 0 : delete m_cross_section;
755 0 : m_cross_section = new GenCrossSection(xs);
756 0 : }
757 :
758 : inline void GenEvent::set_heavy_ion( const HeavyIon& ion )
759 : {
760 0 : delete m_heavy_ion;
761 0 : m_heavy_ion = new HeavyIon(ion);
762 0 : }
763 :
764 : inline void GenEvent::set_pdf_info( const PdfInfo& p )
765 : {
766 0 : delete m_pdf_info;
767 0 : m_pdf_info = new PdfInfo(p);
768 0 : }
769 :
770 : inline void GenEvent::set_random_states( const std::vector<long>&
771 : randomstates )
772 0 : { m_random_states = randomstates; }
773 :
774 : inline void GenEvent::remove_barcode( GenParticle* p )
775 0 : { m_particle_barcodes.erase( p->barcode() ); }
776 :
777 : inline void GenEvent::remove_barcode( GenVertex* v )
778 0 : { m_vertex_barcodes.erase( v->barcode() ); }
779 :
780 : /// Each vertex or particle has a barcode, which is just an integer which
781 : /// uniquely identifies it inside the event (i.e. there is a one to one
782 : /// mapping between particle memory addresses and particle barcodes... and
783 : /// the same applied for vertices).
784 : ///
785 : /// The value of a barcode has NO MEANING and NO ORDER!
786 : /// For the user's convenience, when an event is read in via an IO_method
787 : /// from an indexed list (like the HEPEVT common block), then the index will
788 : /// become the barcode for that particle.
789 : ///
790 : /// Particle barcodes are always positive integers.
791 : /// The barcodes are chosen and set automatically when a vertex or particle
792 : /// comes under the ownership of an event (i.e. it is contained in an event).
793 : ///
794 : /// Please note that the barcodes are intended for internal use within
795 : /// HepMC as a unique identifier for the particles and vertices.
796 : /// Using the barcode to encode extra information is an abuse of
797 : /// the barcode data member and causes confusion among users.
798 : inline GenParticle* GenEvent::barcode_to_particle( int barCode ) const
799 : {
800 : std::map<int,HepMC::GenParticle*>::const_iterator i
801 : = m_particle_barcodes.find(barCode);
802 : return ( i != m_particle_barcodes.end() ) ? (*i).second : 0;
803 : }
804 :
805 : /// Each vertex or particle has a barcode, which is just an integer which
806 : /// uniquely identifies it inside the event (i.e. there is a one to one
807 : /// mapping between particle memory addresses and particle barcodes... and
808 : /// the same applied for vertices).
809 : ///
810 : /// The value of a barcode has NO MEANING and NO ORDER!
811 : /// For the user's convenience, when an event is read in via an IO_method
812 : /// from an indexed list (like the HEPEVT common block), then the index will
813 : /// become the barcode for that particle.
814 : ///
815 : /// Vertex barcodes are always negative integers.
816 : /// The barcodes are chosen and set automatically when a vertex or particle
817 : /// comes under the ownership of an event (i.e. it is contained in an event).
818 : ///
819 : /// Please note that the barcodes are intended for internal use within
820 : /// HepMC as a unique identifier for the particles and vertices.
821 : /// Using the barcode to encode extra information is an abuse of
822 : /// the barcode data member and causes confusion among users.
823 : inline GenVertex* GenEvent::barcode_to_vertex( int barCode ) const
824 : {
825 0 : std::map<int,GenVertex*,std::greater<int> >::const_iterator i
826 0 : = m_vertex_barcodes.find(barCode);
827 0 : return ( i != m_vertex_barcodes.end() ) ? (*i).second : 0;
828 0 : }
829 :
830 : inline int GenEvent::particles_size() const {
831 0 : return (int)m_particle_barcodes.size();
832 : }
833 : inline bool GenEvent::particles_empty() const {
834 0 : return (bool)m_particle_barcodes.empty();
835 : }
836 : inline int GenEvent::vertices_size() const {
837 0 : return (int)m_vertex_barcodes.size();
838 : }
839 : inline bool GenEvent::vertices_empty() const {
840 0 : return (bool)m_vertex_barcodes.empty();
841 : }
842 :
843 : // beam particles
844 : inline std::pair<HepMC::GenParticle *,HepMC::GenParticle *> GenEvent::beam_particles() const {
845 0 : return std::pair<GenParticle *,GenParticle *> (m_beam_particle_1, m_beam_particle_2);
846 : }
847 :
848 : // units
849 : inline Units::MomentumUnit GenEvent::momentum_unit() const {
850 0 : return m_momentum_unit;
851 : }
852 : inline Units::LengthUnit GenEvent::length_unit() const {
853 0 : return m_position_unit;
854 : }
855 :
856 : inline void GenEvent::use_units( Units::MomentumUnit new_m, Units::LengthUnit new_l ) {
857 0 : use_momentum_unit( new_m );
858 0 : use_length_unit( new_l );
859 0 : }
860 :
861 : inline void GenEvent::use_units( std::string& new_m, std::string& new_l ) {
862 0 : use_momentum_unit( new_m );
863 0 : use_length_unit( new_l );
864 0 : }
865 :
866 : inline void GenEvent::define_units( Units::MomentumUnit new_m, Units::LengthUnit new_l ) {
867 : m_momentum_unit = new_m;
868 : m_position_unit = new_l;
869 : }
870 :
871 : } // HepMC
872 :
873 : #endif // HEPMC_GEN_EVENT_H
874 :
875 : //--------------------------------------------------------------------------
876 :
877 :
|
