PYTHIA  8.312
LHEH5.h
1 // The LHEH5 code below has been modified from the original
2 // https://bitbucket.org/iamholger/lheh5/src/master/ authored by
3 // Holger Schulz, and developed under the Scientific Discovery
4 // through Advanced Computing (SciDAC) program funded by
5 // the U.S. Department of Energy, Office of Science, Advanced Scientific
6 // Computing Research.
7 //
8 // Note, this header can be used in conjuction with LHAHF5.h.
9 //
10 // Fermilab Software Legal Information (BSD License)
11 // Copyright (c) 2009, FERMI NATIONAL ACCELERATOR LABORATORY
12 // All rights reserved.
13 //
14 // Redistribution and use in source and binary forms, with or without
15 // modification, are permitted provided that the following conditions
16 // are met:
17 //
18 // Redistributions of source code must retain the above copyright
19 // notice, this list of conditions and the following disclaimer.
20 //
21 // Redistributions in binary form must reproduce the above copyright
22 // notice, this list of conditions and the following disclaimer in the
23 // documentation and/or other materials provided with the
24 // distribution.
25 //
26 // Neither the name of the FERMI NATIONAL ACCELERATOR LABORATORY, nor
27 // the names of its contributors may be used to endorse or promote
28 // products derived from this software without specific prior written
29 // permission.
30 //
31 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
34 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
35 // COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
36 // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
38 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
41 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
42 // OF THE POSSIBILITY OF SUCH DAMAGE.
43 
44 #ifndef Pythia8_LHEH5_H
45 #define Pythia8_LHEH5_H
46 
47 // Standard includes.
48 #include <iostream>
49 #include <string>
50 #include <vector>
51 #include <unistd.h>
52 
53 // HighFive includes.
54 #include "highfive/H5File.hpp"
55 #include "highfive/H5DataSet.hpp"
56 
57 using namespace HighFive;
58 
59 namespace LHEH5 {
60 
61 //==========================================================================
62 
63 // Particle struct.
64 
65 struct Particle {
66  int id, status, mother1, mother2, color1, color2;
67  double px, py, pz, e, m, lifetime, spin;
68  // id .. IDUP
69  // color1/2 .. ICOLUP firt/second
70  // mother1/2 .. MOTHUP first/second
71  // status .. ISTUP
72  // px ... m .. PUP[..]
73  // lifetime .. VTIMUP
74  // spin .. SPINUP
75  // (UP ... user process)
76 };
77 
78 //--------------------------------------------------------------------------
79 
80 // Print a particle.
81 
82 std::ostream& operator << (std::ostream& os, Particle const & p) {
83  os << "\tpx: " << p.px << " py: " << p.py << " pz: " << p.pz
84  << " e: " << p.e << "\n";
85  return os;
86 }
87 
88 //==========================================================================
89 
90 // Event header struct.
91 
92 struct EventHeader {
93  // Event info
94  int nparticles; // corr to NUP
95  int pid; // this is all LHAu-::setProcess
96  std::vector<double> weights;
97  //double weight;
98  size_t trials;
99  double scale;
100  double rscale;
101  double fscale;
102  double aqed;
103  double aqcd;
104  int npLO;
105  int npNLO;
106 };
107 
108 //--------------------------------------------------------------------------
109 
110 // Print an event header.
111 
112 std::ostream& operator << (std::ostream& os, EventHeader const & eh) {
113  os << "\tnparticles: " << eh.nparticles << " procid: " << eh.pid
114  << " weights: { ";
115  for (const auto& w : eh.weights) os << w << " ";
116  os << "} trials: " << eh.trials << "\n";
117  os << "\tscale: " << eh.scale << " rscale: " << eh.rscale << " fscale: "
118  << eh.fscale << " aqed: " << eh.aqed << " aqcd: " << eh.aqcd << "\n";
119  os << "\tnpLO: " << eh.npLO << " npNLO: " << eh.npNLO << "\n";
120  return os;
121 }
122 
123 //==========================================================================
124 
125 // Old event struct.
126 
127 struct Events {
128  // Lookup.
129  std::vector<size_t> _vstart;
130  std::vector<size_t> _vend;
131  // Particles.
132  std::vector<int> _vid;
133  std::vector<int> _vstatus;
134  std::vector<int> _vmother1;
135  std::vector<int> _vmother2;
136  std::vector<int> _vcolor1;
137  std::vector<int> _vcolor2;
138  std::vector<double> _vpx;
139  std::vector<double> _vpy;
140  std::vector<double> _vpz;
141  std::vector<double> _ve;
142  std::vector<double> _vm;
143  std::vector<double> _vlifetime;
144  std::vector<double> _vspin;
145  // Event info.
146  std::vector<int> _vnparticles;
147  std::vector<int> _vpid;
148  std::vector<double> _vweight;
149  std::vector<size_t> _vtrials;
150  std::vector<double> _vscale;
151  std::vector<double> _vrscale;
152  std::vector<double> _vfscale;
153  std::vector<double> _vaqed;
154  std::vector<double> _vaqcd;
155  std::vector<int> _vnpLO;
156  std::vector<int> _vnpNLO;
157  size_t _particle_offset;
158  Particle mkParticle(size_t idx) const;
159  std::vector<Particle> mkEvent(size_t ievent) const;
160  EventHeader mkEventHeader(int ievent) const;
161 };
162 
163 //--------------------------------------------------------------------------
164 
165 // Make a particle, given an index.
166 
167 Particle Events::mkParticle(size_t idx) const {
168  return {std::move(_vid[idx]), std::move(_vstatus[idx]),
169  std::move(_vmother1[idx]), std::move(_vmother2[idx]),
170  std::move(_vcolor1[idx]), std::move(_vcolor2[idx]),
171  std::move(_vpx[idx]), std::move(_vpy[idx]), std::move(_vpz[idx]),
172  std::move(_ve[idx]), std::move(_vm[idx]),
173  std::move(_vlifetime[idx]),std::move(_vspin[idx])};
174 }
175 
176 //--------------------------------------------------------------------------
177 
178 // Make an event, given an index.
179 
180 std::vector<Particle> Events::mkEvent(size_t ievent) const {
181  std::vector<Particle> _E;
182  // NOTE we need to subtract the particle offset here as the
183  // particle properties run from 0 and not the global index
184  // when using batches.
185  size_t id = _vstart[ievent] - _particle_offset;
186  for ( ; id <(_vend[ievent] - _particle_offset); ++id)
187  _E.push_back(mkParticle( id));
188 
189  // Make sure beam particles are ordered according to convention
190  // i.e. first particle has positive z-momentum
191  if (_E[0].pz <0) std::swap<Particle>(_E[0], _E[1]);
192 
193  return _E;
194 }
195 
196 //--------------------------------------------------------------------------
197 
198 // Make an event header, given an index.
199 
200 EventHeader Events::mkEventHeader(int iev) const {
201  return {std::move(_vnparticles[iev]), std::move(_vpid[iev]),
202  std::vector<double>(1,_vweight[iev]), std::move(_vtrials[iev]),
203  std::move(_vscale[iev]), std::move(_vrscale[iev]),
204  std::move(_vfscale[iev]),
205  std::move(_vaqed[iev]), std::move(_vaqcd[iev]),
206  std::move(_vnpLO[iev]), std::move(_vnpNLO[iev])};
207 }
208 
209 //--------------------------------------------------------------------------
210 
211 // Read function, returns an Events struct.
212 
213 Events readEvents(Group& g_index, Group& g_particle, Group& g_event,
214  size_t first_event, size_t n_events) {
215  // Lookup
216  std::vector<size_t> _vstart, _vend;
217  // Particles
218  std::vector<int> _vid, _vstatus, _vmother1, _vmother2, _vcolor1, _vcolor2;
219  std::vector<double> _vpx, _vpy, _vpz, _ve, _vm, _vlifetime, _vspin;
220  // Event info
221  std::vector<int> _vnparticles, _vpid, _vnpLO, _vnpNLO;
222  std::vector<size_t> _vtrials ;
223  std::vector<double> _vweight, _vscale, _vrscale, _vfscale, _vaqed, _vaqcd;
224 
225  // Lookup.
226  DataSet _start = g_index.getDataSet("start");
227  DataSet _end = g_index.getDataSet("end");
228  // Particles.
229  DataSet _id = g_particle.getDataSet("id");
230  DataSet _status = g_particle.getDataSet("status");
231  DataSet _mother1 = g_particle.getDataSet("mother1");
232  DataSet _mother2 = g_particle.getDataSet("mother2");
233  DataSet _color1 = g_particle.getDataSet("color1");
234  DataSet _color2 = g_particle.getDataSet("color2");
235  DataSet _px = g_particle.getDataSet("px");
236  DataSet _py = g_particle.getDataSet("py");
237  DataSet _pz = g_particle.getDataSet("pz");
238  DataSet _e = g_particle.getDataSet("e");
239  DataSet _m = g_particle.getDataSet("m");
240  DataSet _lifetime = g_particle.getDataSet("lifetime");
241  DataSet _spin = g_particle.getDataSet("spin");
242  // Event info.
243  DataSet _nparticles = g_event.getDataSet("nparticles");
244  DataSet _pid = g_event.getDataSet("pid");
245  DataSet _weight = g_event.getDataSet("weight");
246  DataSet _trials = g_event.getDataSet("trials");
247  DataSet _scale = g_event.getDataSet("scale");
248  DataSet _rscale = g_event.getDataSet("rscale");
249  DataSet _fscale = g_event.getDataSet("fscale");
250  DataSet _aqed = g_event.getDataSet("aqed");
251  DataSet _aqcd = g_event.getDataSet("aqcd");
252  DataSet _npLO = g_event.getDataSet("npLO");
253  DataSet _npNLO = g_event.getDataSet("npNLO");
254 
255  std::vector<size_t> offset_e = {first_event};
256  std::vector<size_t> readsize_e = {n_events};
257 
258  _start.select(offset_e, readsize_e).read(_vstart);
259  _end.select( offset_e, readsize_e).read(_vend );
260  std::vector<size_t> offset_p = {_vstart.front()};
261  std::vector<size_t> readsize_p = {_vend.back()-_vstart.front()};
262 
263  int RESP = _vend.back()-_vstart.front();
264  _vid.reserve(RESP);
265  _vstatus .reserve(RESP);
266  _vmother1 .reserve(RESP);
267  _vmother2 .reserve(RESP);
268  _vcolor1 .reserve(RESP);
269  _vcolor2 .reserve(RESP);
270  _vpx .reserve(RESP);
271  _vpy .reserve(RESP);
272  _vpz .reserve(RESP);
273  _ve .reserve(RESP);
274  _vm .reserve(RESP);
275  _vlifetime.reserve(RESP);
276  _vspin .reserve(RESP);
277 
278  _vnparticles.reserve(n_events);
279  _vpid .reserve(n_events);
280  _vweight .reserve(n_events);
281  _vtrials .reserve(n_events);
282  _vscale .reserve(n_events);
283  _vrscale .reserve(n_events);
284  _vfscale .reserve(n_events);
285  _vaqed .reserve(n_events);
286  _vaqcd .reserve(n_events);
287  _vnpLO .reserve(n_events);
288  _vnpNLO .reserve(n_events);
289 
290  // This is using HighFive's read.
291  _id .select(offset_p, readsize_p).read(_vid );
292  _status .select(offset_p, readsize_p).read(_vstatus );
293  _mother1 .select(offset_p, readsize_p).read(_vmother1 );
294  _mother2 .select(offset_p, readsize_p).read(_vmother2 );
295  _color1 .select(offset_p, readsize_p).read(_vcolor1 );
296  _color2 .select(offset_p, readsize_p).read(_vcolor2 );
297  _px .select(offset_p, readsize_p).read(_vpx );
298  _py .select(offset_p, readsize_p).read(_vpy );
299  _pz .select(offset_p, readsize_p).read(_vpz );
300  _e .select(offset_p, readsize_p).read(_ve );
301  _m .select(offset_p, readsize_p).read(_vm );
302  _lifetime.select(offset_p, readsize_p).read(_vlifetime);
303  _spin .select(offset_p, readsize_p).read(_vspin );
304 
305  _nparticles.select(offset_e, readsize_e).read(_vnparticles);
306  _pid .select(offset_e, readsize_e).read(_vpid );
307  _weight .select(offset_e, readsize_e).read(_vweight );
308  _trials .select(offset_e, readsize_e).read(_vtrials );
309  _scale .select(offset_e, readsize_e).read(_vscale );
310  _rscale .select(offset_e, readsize_e).read(_vrscale );
311  _fscale .select(offset_e, readsize_e).read(_vfscale );
312  _aqed .select(offset_e, readsize_e).read(_vaqed );
313  _aqcd .select(offset_e, readsize_e).read(_vaqcd );
314  _npLO .select(offset_e, readsize_e).read(_vnpLO );
315  _npNLO .select(offset_e, readsize_e).read(_vnpNLO );
316 
317  return {
318  std::move(_vstart),
319  std::move(_vend),
320  std::move(_vid),
321  std::move(_vstatus),
322  std::move(_vmother1),
323  std::move(_vmother2),
324  std::move(_vcolor1),
325  std::move(_vcolor2),
326  std::move(_vpx),
327  std::move(_vpy),
328  std::move(_vpz),
329  std::move(_ve),
330  std::move(_vm),
331  std::move(_vlifetime),
332  std::move(_vspin),
333  std::move(_vnparticles),
334  std::move(_vpid),
335  std::move(_vweight),
336  std::move(_vtrials),
337  std::move(_vscale),
338  std::move(_vrscale),
339  std::move(_vfscale),
340  std::move(_vaqed),
341  std::move(_vaqcd),
342  std::move(_vnpLO),
343  std::move(_vnpNLO),
344  offset_p[0]};
345 }
346 
347 //==========================================================================
348 
349 // New events struct.
350 
351 struct Events2 {
352  // Lookup.
353  std::vector<size_t> _vstart;
354  // Particles.
355  std::vector<int> _vid;
356  std::vector<int> _vstatus;
357  std::vector<int> _vmother1;
358  std::vector<int> _vmother2;
359  std::vector<int> _vcolor1;
360  std::vector<int> _vcolor2;
361  std::vector<double> _vpx;
362  std::vector<double> _vpy;
363  std::vector<double> _vpz;
364  std::vector<double> _ve;
365  std::vector<double> _vm;
366  std::vector<double> _vlifetime;
367  std::vector<double> _vspin;
368  // Event info.
369  std::vector<int> _vnparticles;
370  std::vector<int> _vpid;
371  std::vector<std::vector<double>> _vweightvec;
372  std::vector<size_t> _vtrials;
373  std::vector<double> _vscale;
374  std::vector<double> _vrscale;
375  std::vector<double> _vfscale;
376  std::vector<double> _vaqed;
377  std::vector<double> _vaqcd;
378  int npLO;
379  int npNLO;
380  size_t _particle_offset;
381 
382  Particle mkParticle(size_t idx) const;
383  std::vector<Particle> mkEvent(size_t ievent) const;
384  EventHeader mkEventHeader(int ievent) const;
385 };
386 
387 //--------------------------------------------------------------------------
388 
389 // Make a particle, given an index.
390 
391 Particle Events2::mkParticle(size_t idx) const {
392  return {std::move(_vid[idx]), std::move(_vstatus[idx]),
393  std::move(_vmother1[idx]), std::move(_vmother2[idx]),
394  std::move(_vcolor1[idx]), std::move(_vcolor2[idx]),
395  std::move(_vpx[idx]), std::move(_vpy[idx]), std::move(_vpz[idx]),
396  std::move(_ve[idx]), std::move(_vm[idx]),
397  std::move(_vlifetime[idx]),std::move(_vspin[idx])};
398 }
399 
400 //--------------------------------------------------------------------------
401 
402 // Make an event, given an index.
403 
404 std::vector<Particle> Events2::mkEvent(size_t ievent) const {
405  std::vector<Particle> _E;
406  // NOTE we need to subtract the particle offset here as the particle
407  // properties run from 0 and not the global index when using batches.
408  size_t partno = _vstart[ievent] - _particle_offset;
409  for (int id=0; id <_vnparticles[ievent];++id){
410  _E.push_back(mkParticle(partno));
411  partno++;
412  }
413  // Make sure beam particles are ordered according to convention
414  // i.e. first particle has positive z-momentum
415  if (_E[0].pz < 0.) std::swap<Particle>(_E[0], _E[1]);
416  return _E;
417 }
418 
419 //--------------------------------------------------------------------------
420 
421 // Make an event header, given an index.
422 
423 EventHeader Events2::mkEventHeader(int iev) const {
424  return {std::move(_vnparticles[iev]), std::move(_vpid[iev]),
425  std::move(_vweightvec[iev]), std::move(_vtrials[iev]),
426  std::move(_vscale[iev]), std::move(_vrscale[iev]),
427  std::move(_vfscale[iev]),
428  std::move(_vaqed[iev]), std::move(_vaqcd[iev]),
429  npLO, npNLO,
430  };
431 }
432 
433 //--------------------------------------------------------------------------
434 
435 // Read function, returns an Events struct --- this is for the new structure.
436 
437 Events2 readEvents2(Group& g_particle, Group& g_event, size_t first_event,
438  size_t n_events, int npLO, int npNLO, bool hasMultiWts) {
439  // Lookup.
440  std::vector<size_t> _vstart;
441  // Particles.
442  std::vector<int> _vid, _vstatus, _vmother1, _vmother2, _vcolor1, _vcolor2;
443  std::vector<double> _vpx, _vpy, _vpz, _ve, _vm, _vlifetime, _vspin;
444  // Event info.
445  std::vector<int> _vnparticles, _vpid;
446  std::vector<size_t> _vtrials ;
447  std::vector<double> _vscale, _vrscale, _vfscale, _vaqed, _vaqcd;
448 
449  // Lookup.
450  DataSet _start = g_event.getDataSet("start");
451  // Particles.
452  DataSet _id = g_particle.getDataSet("id");
453  DataSet _status = g_particle.getDataSet("status");
454  DataSet _mother1 = g_particle.getDataSet("mother1");
455  DataSet _mother2 = g_particle.getDataSet("mother2");
456  DataSet _color1 = g_particle.getDataSet("color1");
457  DataSet _color2 = g_particle.getDataSet("color2");
458  DataSet _px = g_particle.getDataSet("px");
459  DataSet _py = g_particle.getDataSet("py");
460  DataSet _pz = g_particle.getDataSet("pz");
461  DataSet _e = g_particle.getDataSet("e");
462  DataSet _m = g_particle.getDataSet("m");
463  DataSet _lifetime = g_particle.getDataSet("lifetime");
464  DataSet _spin = g_particle.getDataSet("spin");
465  // Event info.
466  DataSet _nparticles = g_event.getDataSet("nparticles");
467  DataSet _pid = g_event.getDataSet("pid");
468  DataSet _weight = g_event.getDataSet("weight");
469  DataSet _trials = g_event.getDataSet("trials");
470  DataSet _scale = g_event.getDataSet("scale");
471  DataSet _rscale = g_event.getDataSet("rscale");
472  DataSet _fscale = g_event.getDataSet("fscale");
473  DataSet _aqed = g_event.getDataSet("aqed");
474  DataSet _aqcd = g_event.getDataSet("aqcd");
475 
476  std::vector<size_t> offset_e = {first_event};
477  std::vector<size_t> readsize_e = {n_events};
478 
479  // We now know the first event to read.
480  _start.select(offset_e, readsize_e).read(_vstart);
481 
482  // That's the first particle.
483  std::vector<size_t> offset_p = {_vstart.front()};
484  // The last particle is last entry in start + nparticles of that event.
485  _vnparticles.reserve(n_events);
486  _nparticles.select(offset_e, readsize_e).read(_vnparticles);
487 
488  size_t RESP = _vstart.back() - _vstart.front() + _vnparticles.back();
489  std::vector<size_t> readsize_p = {RESP};
490  _vid.reserve(RESP);
491  _vstatus .reserve(RESP);
492  _vmother1 .reserve(RESP);
493  _vmother2 .reserve(RESP);
494  _vcolor1 .reserve(RESP);
495  _vcolor2 .reserve(RESP);
496  _vpx .reserve(RESP);
497  _vpy .reserve(RESP);
498  _vpz .reserve(RESP);
499  _ve .reserve(RESP);
500  _vm .reserve(RESP);
501  _vlifetime.reserve(RESP);
502  _vspin .reserve(RESP);
503  _vpid .reserve(n_events);
504  _vtrials .reserve(n_events);
505  _vscale .reserve(n_events);
506  _vrscale .reserve(n_events);
507  _vfscale .reserve(n_events);
508  _vaqed .reserve(n_events);
509  _vaqcd .reserve(n_events);
510 
511  // This is using HighFive's read.
512  _id .select(offset_p, readsize_p).read(_vid );
513  _status .select(offset_p, readsize_p).read(_vstatus );
514  _mother1 .select(offset_p, readsize_p).read(_vmother1 );
515  _mother2 .select(offset_p, readsize_p).read(_vmother2 );
516  _color1 .select(offset_p, readsize_p).read(_vcolor1 );
517  _color2 .select(offset_p, readsize_p).read(_vcolor2 );
518  _px .select(offset_p, readsize_p).read(_vpx );
519  _py .select(offset_p, readsize_p).read(_vpy );
520  _pz .select(offset_p, readsize_p).read(_vpz );
521  _e .select(offset_p, readsize_p).read(_ve );
522  _m .select(offset_p, readsize_p).read(_vm );
523  _lifetime.select(offset_p, readsize_p).read(_vlifetime);
524  _spin .select(offset_p, readsize_p).read(_vspin );
525  _pid .select(offset_e, readsize_e).read(_vpid );
526  // Read event weights depending on format.
527  std::vector<size_t> wtdim = _weight.getSpace().getDimensions();
528  size_t n_weights = wtdim.size() > 1 ? wtdim[1] : 1;
529  std::vector< std::vector<double> > _vweightvec(n_events,
530  std::vector<double>(n_weights));
531  if (hasMultiWts) {
532  // The weights are stored in a (possibly one-dimensional) vector.
533  std::vector<size_t> offsets = {first_event,first_event};
534  std::vector<size_t> counts = {n_events, n_weights};
535  _weight .select(offsets, counts).read(_vweightvec );
536  } else {
537  // The weights are stored as a single floating point value.
538  std::vector<double> _vweight;
539  _weight .select(offset_e, readsize_e).read(_vweight);
540  _vweightvec.resize(1);
541  _vweightvec[0] = _vweight;
542  }
543  _trials .select(offset_e, readsize_e).read(_vtrials);
544  _scale .select(offset_e, readsize_e).read(_vscale );
545  _rscale .select(offset_e, readsize_e).read(_vrscale);
546  _fscale .select(offset_e, readsize_e).read(_vfscale);
547  _aqed .select(offset_e, readsize_e).read(_vaqed );
548  _aqcd .select(offset_e, readsize_e).read(_vaqcd );
549 
550  return {
551  std::move(_vstart ),
552  std::move(_vid ),
553  std::move(_vstatus ),
554  std::move(_vmother1 ),
555  std::move(_vmother2 ),
556  std::move(_vcolor1 ),
557  std::move(_vcolor2 ),
558  std::move(_vpx ),
559  std::move(_vpy ),
560  std::move(_vpz ),
561  std::move(_ve ),
562  std::move(_vm ),
563  std::move(_vlifetime ),
564  std::move(_vspin ),
565  std::move(_vnparticles),
566  std::move(_vpid ),
567  std::move(_vweightvec ),
568  std::move(_vtrials ),
569  std::move(_vscale ),
570  std::move(_vrscale ),
571  std::move(_vfscale ),
572  std::move(_vaqed ),
573  std::move(_vaqcd ),
574  npLO,
575  npNLO,
576  offset_p[0],
577  };
578 }
579 
580 //==========================================================================
581 
582 } // end namespace LHEH5
583 
584 #endif // Pythia8_LHEH5_H
Old event struct.
Definition: LHEH5.h:127
Definition: LHEH5.h:59
std::vector< int > _vnparticles
Event info.
Definition: LHEH5.h:369
std::vector< int > _vid
Particles.
Definition: LHEH5.h:132
std::vector< double > weights
this is all LHAu-::setProcess
Definition: LHEH5.h:96
New events struct.
Definition: LHEH5.h:351
std::vector< int > _vid
Particles.
Definition: LHEH5.h:355
Standard includes.
int nparticles
Event info.
Definition: LHEH5.h:94
std::vector< size_t > _vstart
Lookup.
Definition: LHEH5.h:353
std::vector< int > _vnparticles
Event info.
Definition: LHEH5.h:146
size_t trials
double weight;
Definition: LHEH5.h:98
int pid
corr to NUP
Definition: LHEH5.h:95
Event header struct.
Definition: LHEH5.h:92
std::vector< size_t > _vstart
Lookup.
Definition: LHEH5.h:129
Particle struct.
Definition: LHEH5.h:65