Coverity 21240
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8175 / include / PhaseSpace.h
1 // PhaseSpace.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2013 Torbjorn Sjostrand.
3 // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
5
6 // Header file for phase space generators in kinematics selection.
7 // PhaseSpace: base class for phase space generators.
8 // Base class for derived classes> 2 ->1 , 2 -> 2, 2 -> 2 elastic/diffractive,
9 // 2 -> 2 minbias, 2 -> 3, Les Houches. 
10
11 #ifndef Pythia8_PhaseSpace_H
12 #define Pythia8_PhaseSpace_H
13
14 #include "Basics.h"
15 #include "BeamParticle.h"
16 #include "Info.h"
17 #include "LesHouches.h"
18 #include "MultipartonInteractions.h"
19 #include "ParticleData.h"
20 #include "PartonDistributions.h"
21 #include "PythiaStdlib.h"
22 #include "SigmaProcess.h"
23 #include "SigmaTotal.h"
24 #include "Settings.h"
25 #include "StandardModel.h"
26 #include "UserHooks.h"
27
28 namespace Pythia8 {
29
30 //==========================================================================
31
32 // Forward reference to the UserHooks class.
33 class UserHooks;
34  
35 //==========================================================================
36
37 // PhaseSpace is a base class for  phase space generators 
38 // used in the selection of hard-process kinematics.
39
40 class PhaseSpace {
41
42 public:
43
44   // Destructor.
45   virtual ~PhaseSpace() {}
46
47   // Perform simple initialization and store pointers.
48   void init(bool isFirst, SigmaProcess* sigmaProcessPtrIn, 
49     Info* infoPtrIn, Settings* settingsPtrIn, ParticleData* particleDataPtrIn,
50     Rndm* rndmPtrIn, BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, 
51     Couplings* couplingsPtrIn, SigmaTotal* sigmaTotPtrIn, 
52     UserHooks* userHooksPtrIn);
53
54   // Update the CM energy of the event.
55   void newECM(double eCMin) {eCM = eCMin; s = eCM * eCM;}
56
57   // Store or replace Les Houches pointer.
58   void setLHAPtr(LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;}  
59
60   // A pure virtual method, wherein an optimization procedure
61   // is used to determine how phase space should be sampled.
62   virtual bool setupSampling() = 0; 
63
64   // A pure virtual method, wherein a trial event kinematics 
65   // is to be selected in the derived class.
66   virtual bool trialKin(bool inEvent = true, bool repeatSame = false) = 0; 
67
68   // A pure virtual method, wherein the accepted event kinematics 
69   // is to be constructed in the derived class.
70   virtual bool finalKin() = 0; 
71
72   // Allow for nonisotropic decays when ME's available.
73   void   decayKinematics( Event& process);
74
75   // Give back current or maximum cross section, or set latter.
76   double sigmaNow() const {return sigmaNw;}
77   double sigmaMax() const {return sigmaMx;}
78   double biasSelectionWeight()  const {return biasWt;}
79   bool   newSigmaMax() const {return newSigmaMx;}
80   void   setSigmaMax(double sigmaMaxIn) {sigmaMx = sigmaMaxIn;}
81
82   // For Les Houches with negative event weight needs 
83   virtual double sigmaSumSigned() const {return sigmaMx;}
84   
85   // Give back constructed four-vectors and known masses.
86   Vec4   p(int i)   const {return pH[i];} 
87   double m(int i)   const {return mH[i];}
88
89   // Give back other event properties.
90   double ecm()      const {return eCM;}
91   double x1()       const {return x1H;}
92   double x2()       const {return x2H;}
93   double sHat()     const {return sH;}
94   double tHat()     const {return tH;}
95   double uHat()     const {return uH;}
96   double pTHat()    const {return pTH;}
97   double thetaHat() const {return theta;}
98   double phiHat()   const {return phi;}
99   double runBW3()   const {return runBW3H;}
100   double runBW4()   const {return runBW4H;}
101   double runBW5()   const {return runBW5H;}
102
103   // Inform whether beam particles are resolved in partons or scatter directly.
104   virtual bool isResolved() const {return true;}
105
106 protected:
107
108   // Constructor.
109  PhaseSpace() :
110     sigmaProcessPtr(0x0), 
111     infoPtr(0x0),
112     settingsPtr(0x0),
113     particleDataPtr(0x0),
114     rndmPtr(0x0),
115     beamAPtr(0x0),
116     beamBPtr(0x0),
117     couplingsPtr(0x0),
118     sigmaTotPtr(0x0),
119     userHooksPtr(0x0),
120     lhaUpPtr(0x0),
121     useBreitWigners(false), doEnergySpread(false), showSearch(false), showViolation(false),
122     increaseMaximum(false),
123     gmZmodeGlobal(0),
124     mHatGlobalMin(0), mHatGlobalMax(0), pTHatGlobalMin(0), pTHatGlobalMax(0), 
125     pTHatMinDiverge(0), minWidthBreitWigners(0),
126     idA(0), idB(0),
127     mA(0), mB(0), eCM(0), s(0), 
128     hasLeptonBeams(false), hasPointLeptons(false),
129     newSigmaMx(false), canModifySigma(false), canBiasSelection(false), canBias2Sel(false),
130     gmZmode(0),
131     bias2SelPow(0), bias2SelRef(0), wtBW(0), sigmaNw(0), sigmaMx(0), sigmaPos(0), 
132     sigmaNeg(0), biasWt(0),
133     mHatMin(0), mHatMax(0), sHatMin(0), sHatMax(0), pTHatMin(0), pTHatMax(0), 
134     pT2HatMin(0), pT2HatMax(0), 
135     x1H(0), x2H(0), m3(0), m4(0), m5(0), s3(0), s4(0), s5(0), mHat(0), sH(0), tH(0), uH(0), pAbs(0), p2Abs(0), 
136     pTH(0), theta(0), phi(0), betaZ(0),
137     idResA(0), idResB(0),
138     mResA(0), mResB(0), GammaResA(0), GammaResB(0), tauResA(0), tauResB(0), widResA(0), 
139     widResB(0),
140     sameResMass(false),
141     useMirrorWeight(false), 
142     tau(0), y(0), z(0), tauMin(0), tauMax(0), yMax(0), zMin(0), zMax(0), ratio34(0), unity34(0), 
143     zNeg(0), zPos(0), wtTau(0), wtY(0), wtZ(0), wt3Body(0), runBW3H(0), runBW4H(0), runBW5H(0), 
144     intTau0(0), intTau1(0), intTau2(0), intTau3(0), intTau4(0), intTau5(0), intTau6(0), 
145     intY0(0), intY12(0), intY34(0), intY56(0), mTchan1(0), sTchan1(0), mTchan2(0), sTchan2(0), 
146     frac3Flat(0), frac3Pow1(0), frac3Pow2(0), 
147     p3cm(), p4cm(), p5cm(),
148     nTau(0), nY(0), nZ(0) {
149       for (int i=0; i<6; i++) {
150         mH[i] = 0;
151         useBW[i] = 0; 
152         idMass[i] = 0;
153         mPeak[i] = 0; sPeak[i] = 0; mWidth[i] = 0; mMin[i] = 0; mMax[i] = 0; mw[i] = 0; wmRat[i] = 0; 
154         mLower[i] = 0; mUpper[i] = 0; sLower[i] = 0; sUpper[i] = 0; fracFlat[i] = 0; fracInv[i] = 0; 
155         fracInv2[i] = 0; atanLower[i] = 0; atanUpper[i] = 0; intBW[i] = 0; intFlat[i] = 0; 
156         intInv[i] = 0; intInv2[i] = 0; 
157       }
158
159       for (int i=0; i<8; i++) {
160         tauCoef[8] = 0; yCoef[8] = 0; zCoef[8] = 0; tauCoefSum[8] = 0; yCoefSum[8] = 0; 
161         zCoefSum[8] = 0;
162       }
163     }
164
165   // Constants: could only be changed in the code itself.
166   static const int    NMAXTRY, NTRY3BODY;
167   static const double SAFETYMARGIN, TINY, EVENFRAC, SAMESIGMA, WIDTHMARGIN, 
168                       SAMEMASS, MASSMARGIN, EXTRABWWTMAX, THRESHOLDSIZE, 
169                       THRESHOLDSTEP, YRANGEMARGIN, LEPTONXMIN, LEPTONXMAX, 
170                       LEPTONXLOGMIN, LEPTONXLOGMAX, LEPTONTAUMIN,
171                       SHATMINZ, PT2RATMINZ, WTCORRECTION[11];
172
173   // MBR constants: form factor appoximation with two exponents.
174   static const double FFA1, FFA2,FFB1, FFB2; 
175
176   // Pointer to cross section. 
177   SigmaProcess* sigmaProcessPtr; 
178
179   // Pointer to various information on the generation.
180   Info*         infoPtr;
181
182   // Pointer to the settings database.
183   Settings*     settingsPtr;
184
185   // Pointer to the particle data table.
186   ParticleData* particleDataPtr;
187
188   // Pointer to the random number generator.
189   Rndm*         rndmPtr;
190
191   // Pointers to incoming beams.
192   BeamParticle* beamAPtr;
193   BeamParticle* beamBPtr;
194
195   // Pointer to Standard Model couplings.
196   Couplings*         couplingsPtr;
197   
198   // Pointer to the total/elastic/diffractive cross section object.
199   SigmaTotal*   sigmaTotPtr;
200
201   // Pointer to userHooks object for user interaction with program.
202   UserHooks*    userHooksPtr;
203
204   // Pointer to LHAup for generating external events.
205   LHAup*        lhaUpPtr;
206
207   // Initialization data, normally only set once.
208   bool   useBreitWigners, doEnergySpread, showSearch, showViolation,
209          increaseMaximum;
210   int    gmZmodeGlobal;
211   double mHatGlobalMin, mHatGlobalMax, pTHatGlobalMin, pTHatGlobalMax, 
212          pTHatMinDiverge, minWidthBreitWigners;
213  
214   // Information on incoming beams.
215   int    idA, idB;
216   double mA, mB, eCM, s; 
217   bool   hasLeptonBeams, hasPointLeptons;
218
219  // Cross section information.
220   bool   newSigmaMx, canModifySigma, canBiasSelection, canBias2Sel;
221   int    gmZmode;
222   double bias2SelPow, bias2SelRef, wtBW, sigmaNw, sigmaMx, sigmaPos, 
223          sigmaNeg, biasWt;
224
225   // Process-specific kinematics properties, almost always available.
226   double mHatMin, mHatMax, sHatMin, sHatMax, pTHatMin, pTHatMax, 
227          pT2HatMin, pT2HatMax; 
228
229   // Event-specific kinematics properties, almost always available.
230   double x1H, x2H, m3, m4, m5, s3, s4, s5, mHat, sH, tH, uH, pAbs, p2Abs, 
231          pTH, theta, phi, betaZ;
232   Vec4   pH[6];
233   double mH[6];
234
235   // Reselect decay products momenta isotropically in phase space.
236   void decayKinematicsStep( Event& process, int iRes);
237
238   // Much common code for normal 2 -> 1, 2 -> 2 and 2 -> 3 cases:
239
240   // Determine how phase space should be sampled.
241   void setup3Body();
242   bool setupSampling123(bool is2, bool is3, ostream& os = cout); 
243
244   // Select a trial kinematics phase space point.
245   bool trialKin123(bool is2, bool is3, bool inEvent = true, 
246     ostream& os = cout); 
247
248   // Presence and properties of any s-channel resonances.
249   int    idResA, idResB;
250   double mResA, mResB, GammaResA, GammaResB, tauResA, tauResB, widResA, 
251          widResB;
252   bool   sameResMass;
253
254   // Kinematics properties specific to 2 -> 1/2/3.
255   bool   useMirrorWeight; 
256   double tau, y, z, tauMin, tauMax, yMax, zMin, zMax, ratio34, unity34, 
257          zNeg, zPos, wtTau, wtY, wtZ, wt3Body, runBW3H, runBW4H, runBW5H, 
258          intTau0, intTau1, intTau2, intTau3, intTau4, intTau5, intTau6, 
259          intY0, intY12, intY34, intY56, mTchan1, sTchan1, mTchan2, sTchan2, 
260          frac3Flat, frac3Pow1, frac3Pow2; 
261   Vec4   p3cm, p4cm, p5cm;
262
263   // Coefficients for optimized selection in 2 -> 1/2/3.
264   int    nTau, nY, nZ;
265   double tauCoef[8], yCoef[8], zCoef[8], tauCoefSum[8], yCoefSum[8], 
266          zCoefSum[8];
267
268   // Calculate kinematical limits for 2 -> 1/2/3.
269   bool limitTau(bool is2, bool is3);
270   bool limitY();
271   bool limitZ();
272
273   // Select kinematical variable between defined limits for 2 -> 1/2/3.
274   void selectTau(int iTau, double tauVal, bool is2);
275   void selectY(int iY, double yVal);
276   void selectZ(int iZ, double zVal);
277   bool select3Body();
278
279   // Solve equation system for better phase space coefficients in 2 -> 1/2/3.
280   void solveSys( int n, int bin[8], double vec[8], double mat[8][8],
281     double coef[8], ostream& os = cout); 
282
283   // Properties specific to resonance mass selection in 2 -> 2 and 2 -> 3.
284   bool   useBW[6]; 
285   int    idMass[6];
286   double mPeak[6], sPeak[6], mWidth[6], mMin[6], mMax[6], mw[6], wmRat[6], 
287          mLower[6], mUpper[6], sLower[6], sUpper[6], fracFlat[6], fracInv[6], 
288          fracInv2[6], atanLower[6], atanUpper[6], intBW[6], intFlat[6], 
289          intInv[6], intInv2[6]; 
290
291   // Setup mass selection for one resonance at a time. Split in two parts.
292   void   setupMass1(int iM);
293   void   setupMass2(int iM, double distToThresh);
294
295   // Do mass selection and find the associated weight.
296   void   trialMass(int iM);
297   double weightMass(int iM);
298
299   // The error function erf(x) should normally be in your math library,
300   // but if not uncomment this simple parametrization by Sergei Winitzki.
301   //double erf(double x) { double x2 = x * x; double kx2 = 0.147 * x2; 
302   //  double tmp = sqrt(1. - exp(-x2 * (4./M_PI + kx2) / (1. + kx2)));
303   //  return ((x >= 0.) ? tmp : -tmp); } 
304
305 };
306  
307 //==========================================================================
308
309 // A derived class with 2 -> 1 kinematics set up in tau, y.
310
311 class PhaseSpace2to1tauy : public PhaseSpace {
312
313 public:
314
315   // Constructor.
316   PhaseSpace2to1tauy() {}
317
318   // Optimize subsequent kinematics selection.
319   virtual bool setupSampling() {if (!setupMass()) return false;
320     return setupSampling123(false, false);} 
321
322   // Construct the trial kinematics.
323   virtual bool trialKin(bool inEvent = true, bool = false) {wtBW = 1.; 
324     return trialKin123(false, false, inEvent);}
325
326   // Construct the final event kinematics.
327   virtual bool finalKin();
328
329 private:
330
331   // Set up allowed mass range.
332   bool setupMass();
333
334 };
335  
336 //==========================================================================
337
338 // A derived class with 2 -> 2 kinematics set up in tau, y, z = cos(theta).
339
340 class PhaseSpace2to2tauyz : public PhaseSpace {
341
342 public:
343
344   // Constructor.
345   PhaseSpace2to2tauyz() {}
346
347   // Optimize subsequent kinematics selection.
348   virtual bool setupSampling() {if (!setupMasses()) return false; 
349     return setupSampling123(true, false);} 
350
351   // Construct the trial kinematics.
352   virtual bool trialKin(bool inEvent = true, bool = false) {
353     if (!trialMasses()) return false; 
354     return trialKin123(true, false, inEvent);}
355
356   // Construct the final event kinematics.
357   virtual bool finalKin();
358
359 private:
360
361   // Set up for fixed or Breit-Wigner mass selection.
362   bool setupMasses();
363
364   // Select fixed or Breit-Wigner-distributed masses.
365   bool trialMasses();
366
367   // Pick off-shell initialization masses when on-shell not allowed.
368   bool constrainedM3M4();
369   bool constrainedM3();
370   bool constrainedM4();
371
372 };
373  
374 //==========================================================================
375
376 // A derived class with 2 -> 2 kinematics set up for elastic scattering.
377
378 class PhaseSpace2to2elastic : public PhaseSpace {
379
380 public:
381
382   // Constructor.
383   PhaseSpace2to2elastic() {}
384
385   // Construct the trial or final event kinematics.
386   virtual bool setupSampling(); 
387   virtual bool trialKin(bool inEvent = true, bool = false); 
388   virtual bool finalKin(); 
389
390   // Are beam particles resolved in partons or scatter directly?
391   virtual bool isResolved() const {return false;}
392
393 private:
394
395   // Constants: could only be changed in the code itself.
396   static const double EXPMAX, CONVERTEL;
397
398   // Kinematics properties specific to 2 -> 2 elastic.
399   bool   useCoulomb;
400   double s1, s2, bSlope, lambda12S, tLow, tUpp, tAux, sigmaTot, rho,
401          lambda, tAbsMin, phaseCst, alphaEM0, sigmaNuc, sigmaCou, signCou;
402
403  // Calculation of alphaElectromagnetic.
404  AlphaEM alphaEM;
405
406 };
407  
408 //==========================================================================
409
410 // A derived class with 2 -> 2 kinematics set up for diffractive scattering.
411
412 class PhaseSpace2to2diffractive : public PhaseSpace {
413
414 public:
415
416   // Constructor.
417   PhaseSpace2to2diffractive(bool isDiffAin = false, bool isDiffBin = false)
418     : isDiffA(isDiffAin), isDiffB(isDiffBin) {}
419
420   // Construct the trial or final event kinematics.
421   virtual bool setupSampling(); 
422   virtual bool trialKin(bool inEvent = true, bool = false); 
423   virtual bool finalKin(); 
424
425   // Are beam particles resolved in partons or scatter directly?
426   virtual bool isResolved() const {return false;}
427
428 private:
429
430   // Constants: could only be changed in the code itself.
431   static const int    NTRY;
432   static const double EXPMAX, DIFFMASSMARGIN;
433
434   // Initialization data, in constructor or read from Settings.
435   bool   isDiffA, isDiffB;
436   int    PomFlux;
437   double epsilonPF, alphaPrimePF;
438
439   // Initialization: kinematics properties specific to 2 -> 2 diffractive.
440   double m3ElDiff, m4ElDiff, s1, s2, lambda12, lambda34, tLow, tUpp,
441          cRes, sResXB, sResAX, sProton, bMin, bSlope, bSlope1, bSlope2, 
442          probSlope1, xIntPF, xtCorPF, mp24DL, coefDL, tAux, tAux1, tAux2;
443     
444   // Parameters for MBR model.
445   double sdpmax, ddpmax, dymin0, dymax, amx, am1, am2, t;
446   double eps, alph, alph2, m2min, dyminSD, dyminDD, dyminSigSD, dyminSigDD;
447   
448 };
449
450 //==========================================================================
451
452 // A derived class with 2 -> 3 kinematics set up for central diffractive 
453 // scattering.
454
455 class PhaseSpace2to3diffractive : public PhaseSpace {
456
457 public:
458
459   // Constructor.
460   PhaseSpace2to3diffractive() {}
461
462   // Construct the trial or final event kinematics.
463   virtual bool setupSampling(); 
464   virtual bool trialKin(bool inEvent = true, bool = false); 
465   virtual bool finalKin(); 
466
467   // Are beam particles resolved in partons or scatter directly?
468   virtual bool isResolved() const {return false;}
469
470  private:
471   
472   // Constants: could only be changed in the code itself.
473   static const int    NTRY, NINTEG2;
474   static const double EXPMAX, DIFFMASSMIN, DIFFMASSMARGIN;
475     
476   // Local variables to calculate DPE kinematics.
477   int    PomFlux;
478   double epsilonPF, alphaPrimePF, s1, s2, m5min, s5min, tLow[2], tUpp[2], 
479          bMin[2], tAux[2], bSlope1, bSlope2, probSlope1[2], tAux1[2], 
480          tAux2[2], bSlope, xIntPF, xIntInvPF, xtCorPF, mp24DL, coefDL, 
481          epsMBR, alphMBR, m2minMBR, dyminMBR, dyminSigMBR, dyminInvMBR, 
482          dpepmax, t1, t2;
483   Vec4   p1, p2, p3, p4, p5;
484
485 };
486  
487 //==========================================================================
488
489 // A derived class for minumum bias events. Hardly does anything, since
490 // the real action is taken care of by the MultipartonInteractions class.
491
492 class PhaseSpace2to2minbias : public PhaseSpace {
493
494 public:
495
496   // Constructor.
497   PhaseSpace2to2minbias() {}
498
499   // Construct the trial or final event kinematics.
500   virtual bool setupSampling() {sigmaNw = sigmaProcessPtr->sigmaHat();
501     sigmaMx = sigmaNw; return true;}
502   virtual bool trialKin( bool , bool = false) {return true;}  
503   virtual bool finalKin() {return true;}
504
505 private:
506
507 };
508  
509 //==========================================================================
510
511 // A derived class with 2 -> 3 kinematics 1 + 2 -> 3 + 4 + 5 set up in 
512 // tau, y, pT2_4, pT2_5, phi_4, phi_5 and y_3 (partial cylindrical symmetry).
513
514 class PhaseSpace2to3tauycyl : public PhaseSpace {
515
516 public:
517
518   // Constructor.
519   PhaseSpace2to3tauycyl() {}
520
521   // Optimize subsequent kinematics selection.
522   virtual bool setupSampling() {if (!setupMasses()) return false; 
523     setup3Body(); return setupSampling123(false, true);} 
524
525   // Construct the trial kinematics.
526   virtual bool trialKin(bool inEvent = true, bool = false) {
527     if (!trialMasses()) return false; 
528     return trialKin123(false, true, inEvent);}
529
530   // Construct the final event kinematics.
531   virtual bool finalKin();
532
533 private:
534
535   // Constants: could only be changed in the code itself.
536   static const int    NITERNR;
537
538   // Set up for fixed or Breit-Wigner mass selection.
539   bool setupMasses();
540
541   // Select fixed or Breit-Wigner-distributed masses.
542   bool trialMasses();
543
544 };
545  
546 //==========================================================================
547
548 // A derived class with 2 -> 3 kinematics 1 + 2 -> 3 + 4 + 5 set up in 
549 // y3, y4, y5, pT2_3, pT2_5, phi_3 and phi_5, and with R separation cut.
550 // Intended specifically for (essentially massless) 2 -> 3 QCD processes.
551
552 class PhaseSpace2to3yyycyl : public PhaseSpace {
553
554 public:
555
556   // Constructor.
557   PhaseSpace2to3yyycyl() {}
558
559   // Optimize subsequent kinematics selection.
560   virtual bool setupSampling(); 
561
562   // Construct the trial kinematics.
563   virtual bool trialKin(bool inEvent = true, bool = false); 
564
565   // Construct the final event kinematics.
566   virtual bool finalKin();
567
568 private:
569
570   // Phase space cuts specifically for 2 -> 3 QCD processes.
571   double pTHat3Min, pTHat3Max, pTHat5Min, pTHat5Max, RsepMin, R2sepMin;
572   bool   hasBaryonBeams;
573
574   // Event kinematics choices.
575   double pT3Min, pT3Max, pT5Min, pT5Max, y3Max, y4Max, y5Max,
576          pT3, pT4, pT5, phi3, phi4, phi5, y3, y4, y5, dphi;
577   Vec4   pInSum;
578
579 };
580
581 //==========================================================================
582
583 // A derived class for Les Houches events. 
584
585 class PhaseSpaceLHA : public PhaseSpace {
586
587 public:
588
589   // Constructor.
590   PhaseSpaceLHA() {idProcSave = 0;}
591
592   // Find maximal cross section for comparison with internal processes.
593   virtual bool setupSampling();
594
595   // Construct the next process, by interface to Les Houches class.
596   virtual bool trialKin( bool , bool repeatSame = false); 
597
598   // Set scale, alpha_s and alpha_em if not done.
599   virtual bool finalKin() {sigmaProcessPtr->setScale(); return true;}
600
601   // For Les Houches with negative event weight needs 
602   virtual double sigmaSumSigned() const {return sigmaSgn;}
603
604 private:
605
606   // Constants.
607   static const double CONVERTPB2MB;
608
609   // Local properties.
610   int    strategy, stratAbs, nProc, idProcSave;
611   double xMaxAbsSum, xSecSgnSum, sigmaSgn;
612   vector<int>    idProc;
613   vector<double> xMaxAbsProc;
614
615 };
616
617 //==========================================================================
618
619 } // end namespace Pythia8
620
621 #endif // Pythia8_PhaseSpace_H
622