]>
Commit | Line | Data |
---|---|---|
c6b60c38 | 1 | // SigmaProcess.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 hard-process differential cross sections. | |
7 | // SigmaProcess: base class for cross sections. | |
8 | // Sigma0Process: base class for unresolved processes, derived from above. | |
9 | // Sigma1Process: base class for 2 -> 1 processes, derived from above. | |
10 | // Sigma2Process: base class for 2 -> 2 processes, derived from above. | |
11 | // Sigma3Process: base class for 2 -> 3 processes, derived from above. | |
12 | // SigmaLHAProcess: wrapper class for Les Houches Accord external input. | |
13 | // Actual physics processes are found in separate files: | |
14 | // SigmaQCD for QCD processes; | |
15 | // SigmaEW for electroweak processes (including photon production); | |
16 | // SigmaOnia for charmonium and bottomonium processes; | |
17 | // SigmaHiggs for Higgs processes; | |
18 | // SigmaSUSY for supersymmetric production; | |
19 | // SigmaLeftRightSym for processes in left-right-symmetric scenarios; | |
20 | // SigmaLeptoquark for leptoquark production. | |
21 | // SigmaExtraDim for processes in scenarios for extra dimensions; | |
22 | // SigmaGeneric for generic scalar/fermion/vector pair production. | |
23 | ||
24 | #ifndef Pythia8_SigmaProcess_H | |
25 | #define Pythia8_SigmaProcess_H | |
26 | ||
27 | #include "Basics.h" | |
28 | #include "BeamParticle.h" | |
29 | #include "Event.h" | |
30 | #include "Info.h" | |
31 | #include "LesHouches.h" | |
32 | #include "ParticleData.h" | |
33 | #include "PartonDistributions.h" | |
34 | #include "PythiaComplex.h" | |
35 | #include "PythiaStdlib.h" | |
36 | #include "ResonanceWidths.h" | |
37 | #include "Settings.h" | |
38 | #include "SigmaTotal.h" | |
39 | #include "StandardModel.h" | |
40 | #include "SusyLesHouches.h" | |
41 | ||
42 | namespace Pythia8 { | |
43 | ||
44 | //========================================================================== | |
45 | ||
46 | // InBeam is a simple helper class for partons and their flux in a beam. | |
47 | ||
48 | class InBeam { | |
49 | ||
50 | public: | |
51 | ||
52 | // Constructor. | |
53 | InBeam( int idIn = 0) : id(idIn), pdf(0.) {} | |
54 | ||
55 | // Values. | |
56 | int id; | |
57 | double pdf; | |
58 | ||
59 | }; | |
60 | ||
61 | //========================================================================== | |
62 | ||
63 | // InPair is a simple helper class for colliding parton pairs and their flux. | |
64 | ||
65 | class InPair { | |
66 | ||
67 | public: | |
68 | ||
69 | // Constructor. | |
70 | InPair( int idAIn = 0, int idBIn = 0) : idA(idAIn), idB(idBIn), | |
71 | pdfA(0.), pdfB(0.), pdfSigma(0.) {} | |
72 | ||
73 | // Values. | |
74 | int idA, idB; | |
75 | double pdfA, pdfB, pdfSigma; | |
76 | ||
77 | }; | |
78 | ||
79 | //========================================================================== | |
80 | ||
81 | // SigmaProcess is the base class for cross section calculations. | |
82 | ||
83 | class SigmaProcess { | |
84 | ||
85 | public: | |
86 | ||
87 | // Destructor. | |
88 | virtual ~SigmaProcess() {} | |
89 | ||
90 | // Perform simple initialization and store pointers. | |
91 | void init(Info* infoPtrIn, Settings* settingsPtrIn, | |
92 | ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, | |
93 | BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, Couplings* couplings, | |
94 | SigmaTotal* sigmaTotPtrIn = 0, SusyLesHouches* slhaPtr = 0); | |
95 | ||
96 | // Store or replace Les Houches pointer. | |
97 | void setLHAPtr( LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;} | |
98 | ||
99 | // Initialize process. Only used for some processes. | |
100 | virtual void initProc() {} | |
101 | ||
102 | // Set up allowed flux of incoming partons. Default is no flux. | |
103 | virtual bool initFlux(); | |
104 | ||
105 | // Input and complement kinematics for resolved 2 -> 1 process. | |
106 | // Usage: set1Kin( x1in, x2in, sHin). | |
107 | virtual void set1Kin( double , double , double ) {} | |
108 | ||
109 | // Input and complement kinematics for resolved 2 -> 2 process. | |
110 | // Usage: set2Kin( x1in, x2in, sHin, tHin, m3in, m4in, runBW3in, runBW4in). | |
111 | virtual void set2Kin( double , double , double , double , double , | |
112 | double, double, double ) {} | |
113 | ||
114 | // Ditto, but for Multiparton Interactions applications, so different input. | |
115 | // Usage: set2KinMPI( x1in, x2in, sHin, tHin, uHin, | |
116 | // alpSin, alpEMin, needMasses, m3in, m4in) | |
117 | virtual void set2KinMPI( double , double , double , double , | |
118 | double , double , double , bool , double , double ) {} | |
119 | ||
120 | // Input and complement kinematics for resolved 2 -> 3 process. | |
121 | // Usage: set3Kin( x1in, x2in, sHin, p3prel, p4prel, p5prel, | |
122 | // m3in, m4in, m5in, runBW3in, runBW4in, runBW5in); | |
123 | virtual void set3Kin( double , double , double , Vec4 , Vec4 , Vec4 , | |
124 | double , double , double , double , double , double ) {} | |
125 | ||
126 | // Calculate flavour-independent parts of cross section. | |
127 | virtual void sigmaKin() {} | |
128 | ||
129 | // Evaluate sigma for unresolved, sigmaHat(sHat) for 2 -> 1 processes, | |
130 | // d(sigmaHat)/d(tHat) for (resolved) 2 -> 2 processes, and |M|^2 for | |
131 | // 2 -> 3 processes. Answer in "native" units, either mb or GeV^-2. | |
132 | virtual double sigmaHat() {return 0.;} | |
133 | ||
134 | // Wrapper to sigmaHat, to (a) store current incoming flavours and | |
135 | // (b) convert from GeV^-2 to mb where required. | |
136 | // For 2 -> 1/2 also (c) convert from from |M|^2 to d(sigmaHat)/d(tHat). | |
137 | virtual double sigmaHatWrap(int id1in = 0, int id2in = 0) { | |
138 | id1 = id1in; id2 = id2in; | |
139 | return ( convert2mb() ? CONVERT2MB * sigmaHat() : sigmaHat() ); } | |
140 | ||
141 | // Convolute above with parton flux and K factor. Sum over open channels. | |
142 | virtual double sigmaPDF(); | |
143 | ||
144 | // Select incoming parton channel and extract parton densities (resolved). | |
145 | void pickInState(int id1in = 0, int id2in = 0); | |
146 | ||
147 | // Select flavour, colour and anticolour. | |
148 | virtual void setIdColAcol() {} | |
149 | ||
150 | // Perform kinematics for a Multiparton Interaction, in its rest frame. | |
151 | virtual bool final2KinMPI( int = 0, int = 0, Vec4 = 0., Vec4 = 0., | |
152 | double = 0., double = 0.) {return true;} | |
153 | ||
154 | // Evaluate weight for simultaneous flavours (only gamma*/Z0 gamma*/Z0). | |
155 | // Usage: weightDecayFlav( process). | |
156 | virtual double weightDecayFlav( Event&) {return 1.;} | |
157 | ||
158 | // Evaluate weight for decay angular configuration. | |
159 | // Usage: weightDecay( process, iResBeg, iResEnd), where | |
160 | // iResBeg <= i < iResEnd is range of sister partons to test decays of. | |
161 | virtual double weightDecay( Event&, int, int) {return 1.;} | |
162 | ||
163 | // Set scale, when that is missing for an external LHA process. | |
164 | virtual void setScale() {} | |
165 | ||
166 | // Process name and code, and the number of final-state particles. | |
167 | virtual string name() const {return "unnamed process";} | |
168 | virtual int code() const {return 0;} | |
169 | virtual int nFinal() const {return 2;} | |
170 | ||
171 | // Need to know which incoming partons to set up interaction for. | |
172 | virtual string inFlux() const {return "unknown";} | |
173 | ||
174 | // Need to know whether to convert cross section answer from GeV^-2 to mb. | |
175 | virtual bool convert2mb() const {return true;} | |
176 | ||
177 | // For 2 -> 2 process optional conversion from |M|^2 to d(sigmaHat)/d(tHat). | |
178 | virtual bool convertM2() const {return false;} | |
179 | ||
180 | // Special treatment needed for Les Houches processes. | |
181 | virtual bool isLHA() const {return false;} | |
182 | ||
183 | // Special treatment needed for elastic and diffractive processes. | |
184 | virtual bool isMinBias() const {return false;} | |
185 | virtual bool isResolved() const {return true;} | |
186 | virtual bool isDiffA() const {return false;} | |
187 | virtual bool isDiffB() const {return false;} | |
188 | virtual bool isDiffC() const {return false;} | |
189 | ||
190 | // Special treatment needed for SUSY processes. | |
191 | virtual bool isSUSY() const {return false;} | |
192 | ||
193 | // Special treatment needed if negative cross sections allowed. | |
194 | virtual bool allowNegativeSigma() const {return false;} | |
195 | ||
196 | // Flavours in 2 -> 2/3 processes where masses needed from beginning. | |
197 | // (For a light quark masses will be used in the final kinematics, | |
198 | // but not at the matrix-element level. For a gluon no masses at all.) | |
199 | virtual int id3Mass() const {return 0;} | |
200 | virtual int id4Mass() const {return 0;} | |
201 | virtual int id5Mass() const {return 0;} | |
202 | ||
203 | // Special treatment needed if process contains an s-channel resonance. | |
204 | virtual int resonanceA() const {return 0;} | |
205 | virtual int resonanceB() const {return 0;} | |
206 | ||
207 | // 2 -> 2 and 2 -> 3 processes only through s-channel exchange. | |
208 | virtual bool isSChannel() const {return false;} | |
209 | ||
210 | // NOAM: Insert an intermediate resonance in 2 -> 1 -> 2 (or 3) listings. | |
211 | virtual int idSChannel() const {return 0;} | |
212 | ||
213 | // QCD 2 -> 3 processes need special phase space selection machinery. | |
214 | virtual bool isQCD3body() const {return false;} | |
215 | ||
216 | // Special treatment in 2 -> 3 with two massive propagators. | |
217 | virtual int idTchan1() const {return 0;} | |
218 | virtual int idTchan2() const {return 0;} | |
219 | virtual double tChanFracPow1() const {return 0.3;} | |
220 | virtual double tChanFracPow2() const {return 0.3;} | |
221 | virtual bool useMirrorWeight() const {return false;} | |
222 | ||
223 | // Special process-specific gamma*/Z0 choice if >=0 (e.g. f fbar -> H0 Z0). | |
224 | virtual int gmZmode() const {return -1;} | |
225 | ||
226 | // Tell whether tHat and uHat are swapped (= same as swap 3 and 4). | |
227 | bool swappedTU() const {return swapTU;} | |
228 | ||
229 | // Give back particle properties: flavours, colours, masses, or all. | |
230 | int id(int i) const {return idSave[i];} | |
231 | int col(int i) const {return colSave[i];} | |
232 | int acol(int i) const {return acolSave[i];} | |
233 | double m(int i) const {return mSave[i];} | |
234 | Particle getParton(int i) const {return parton[i];} | |
235 | ||
236 | // Give back couplings and parton densities. Not all known for minbias. | |
237 | double Q2Ren() const {return Q2RenSave;} | |
238 | double alphaEMRen() const {return alpEM;} | |
239 | double alphaSRen() const {return alpS;} | |
240 | double Q2Fac() const {return Q2FacSave;} | |
241 | double pdf1() const {return pdf1Save;} | |
242 | double pdf2() const {return pdf2Save;} | |
243 | ||
244 | // Give back angles; relevant only for multipe-interactions processes. | |
245 | double thetaMPI() const {return atan2( sinTheta, cosTheta);} | |
246 | double phiMPI() const {return phi;} | |
247 | double sHBetaMPI() const {return sHBeta;} | |
248 | double pT2MPI() const {return pT2Mass;} | |
249 | double pTMPIFin() const {return pTFin;} | |
250 | ||
251 | // Save and load kinematics for trial interactions | |
252 | void saveKin() { | |
253 | for (int i = 0; i < 6; i++) { partonT[i] = parton[i]; | |
254 | mSaveT[i] = mSave[i]; } | |
255 | pTFinT = pTFin; phiT = phi; cosThetaT = cosTheta; sinThetaT = sinTheta; } | |
256 | void loadKin() { | |
257 | for (int i = 0; i < 6; i++) { parton[i] = partonT[i]; | |
258 | mSave[i] = mSaveT[i]; } | |
259 | pTFin = pTFinT; cosTheta = cosThetaT; sinTheta = sinThetaT; phi = phiT; | |
260 | } | |
261 | void swapKin() { | |
262 | for (int i = 0; i < 6; i++) { swap(parton[i], partonT[i]); | |
263 | swap(mSave[i], mSaveT[i]); } | |
264 | swap(pTFin, pTFinT); swap(cosTheta, cosThetaT); | |
265 | swap(sinTheta, sinThetaT); swap(phi, phiT); } | |
266 | ||
267 | protected: | |
268 | ||
269 | // Constructor. | |
270 | SigmaProcess() : infoPtr(0), settingsPtr(0), particleDataPtr(0), | |
271 | rndmPtr(0), beamAPtr(0), beamBPtr(0), couplingsPtr(0), sigmaTotPtr(0), | |
272 | slhaPtr(0), lhaUpPtr(0) {for (int i = 0; i < 6; ++i) mSave[i] = 0.;} | |
273 | ||
274 | // Constants: could only be changed in the code itself. | |
275 | static const double CONVERT2MB, MASSMARGIN, COMPRELERR; | |
276 | static const int NCOMPSTEP; | |
277 | ||
278 | // Pointer to various information on the generation. | |
279 | Info* infoPtr; | |
280 | ||
281 | // Pointer to the settings database. | |
282 | Settings* settingsPtr; | |
283 | ||
284 | // Pointer to the particle data table. | |
285 | ParticleData* particleDataPtr; | |
286 | ||
287 | // Pointer to the random number generator. | |
288 | Rndm* rndmPtr; | |
289 | ||
290 | // Pointers to incoming beams. | |
291 | BeamParticle* beamAPtr; | |
292 | BeamParticle* beamBPtr; | |
293 | ||
294 | // Pointer to Standard Model couplings, including alphaS and alphaEM. | |
295 | Couplings* couplingsPtr; | |
296 | ||
297 | // Pointer to the total/elastic/diffractive cross section object. | |
298 | SigmaTotal* sigmaTotPtr; | |
299 | ||
300 | // Pointer to the SLHA object. | |
301 | SusyLesHouches* slhaPtr; | |
302 | ||
303 | // Pointer to LHAup for generating external events. | |
304 | LHAup* lhaUpPtr; | |
305 | ||
306 | // Initialization data, normally only set once. | |
307 | int nQuarkIn, renormScale1, renormScale2, renormScale3, renormScale3VV, | |
308 | factorScale1, factorScale2, factorScale3, factorScale3VV; | |
309 | double Kfactor, mcME, mbME, mmuME, mtauME, renormMultFac, renormFixScale, | |
310 | factorMultFac, factorFixScale; | |
311 | ||
312 | // CP violation parameters for Higgs sector, normally only set once. | |
313 | int higgsH1parity, higgsH2parity, higgsA3parity; | |
314 | double higgsH1eta, higgsH2eta, higgsA3eta; | |
315 | ||
316 | // Information on incoming beams. | |
317 | int idA, idB; | |
318 | double mA, mB; | |
319 | bool isLeptonA, isLeptonB, hasLeptonBeams; | |
320 | ||
321 | // Partons in beams, with PDF's. | |
322 | vector<InBeam> inBeamA; | |
323 | vector<InBeam> inBeamB; | |
324 | void addBeamA(int idIn) {inBeamA.push_back(InBeam(idIn));} | |
325 | void addBeamB(int idIn) {inBeamB.push_back(InBeam(idIn));} | |
326 | int sizeBeamA() const {return inBeamA.size();} | |
327 | int sizeBeamB() const {return inBeamB.size();} | |
328 | ||
329 | // Allowed colliding parton pairs, with pdf's. | |
330 | vector<InPair> inPair; | |
331 | void addPair(int idAIn, int idBIn) { | |
332 | inPair.push_back(InPair(idAIn, idBIn));} | |
333 | int sizePair() const {return inPair.size();} | |
334 | ||
335 | // Store common subprocess kinematics quantities. | |
336 | double mH, sH, sH2; | |
337 | ||
338 | // Store Q2 renormalization and factorization scales, and related values. | |
339 | double Q2RenSave, alpEM, alpS, Q2FacSave, x1Save, x2Save, pdf1Save, | |
340 | pdf2Save, sigmaSumSave; | |
341 | ||
342 | // Store flavour, colour, anticolour, mass, angles and the whole particle. | |
343 | int id1, id2, id3, id4, id5; | |
344 | int idSave[6], colSave[6], acolSave[6]; | |
345 | double mSave[6], cosTheta, sinTheta, phi, sHMass, sHBeta, pT2Mass, pTFin; | |
346 | Particle parton[6]; | |
347 | ||
348 | // Minimal set of saved kinematics for trial interactions when | |
349 | // using the x-dependent matter profile of multiparton interactions. | |
350 | Particle partonT[6]; | |
351 | double mSaveT[6], pTFinT, cosThetaT, sinThetaT, phiT; | |
352 | ||
353 | // Calculate and store all modified masses and four-vectors | |
354 | // intended for matrix elements. Return false if failed. | |
355 | virtual bool setupForME() {return true;} | |
356 | bool setupForMEin(); | |
357 | double mME[5]; | |
358 | Vec4 pME[5]; | |
359 | ||
360 | // Store whether tHat and uHat are swapped (= same as swap 3 and 4). | |
361 | bool swapTU; | |
362 | ||
363 | // Set flavour, colour and anticolour. | |
364 | void setId( int id1in = 0, int id2in = 0, int id3in = 0, int id4in = 0, | |
365 | int id5in = 0) {idSave[1] = id1in; idSave[2] = id2in; idSave[3] = id3in; | |
366 | idSave[4] = id4in; idSave[5] = id5in;} | |
367 | void setColAcol( int col1 = 0, int acol1 = 0, | |
368 | int col2 = 0, int acol2 = 0, int col3 = 0, int acol3 = 0, | |
369 | int col4 = 0, int acol4 = 0, int col5 = 0, int acol5 = 0) { | |
370 | colSave[1] = col1; acolSave[1] = acol1; colSave[2] = col2; | |
371 | acolSave[2] = acol2; colSave[3] = col3; acolSave[3] = acol3; | |
372 | colSave[4] = col4; acolSave[4] = acol4; colSave[5] = col5; | |
373 | acolSave[5] = acol5; } | |
374 | void swapColAcol() { swap(colSave[1], acolSave[1]); | |
375 | swap(colSave[2], acolSave[2]); swap(colSave[3], acolSave[3]); | |
376 | swap(colSave[4], acolSave[4]); swap(colSave[5], acolSave[5]);} | |
377 | void swapCol1234() { swap(colSave[1], colSave[2]); | |
378 | swap(colSave[3], colSave[4]); swap(acolSave[1], acolSave[2]); | |
379 | swap(acolSave[3], acolSave[4]);} | |
380 | void swapCol12() { swap(colSave[1], colSave[2]); | |
381 | swap(acolSave[1], acolSave[2]);} | |
382 | void swapCol34() { swap(colSave[3], colSave[4]); | |
383 | swap(acolSave[3], acolSave[4]);} | |
384 | ||
385 | // Common code for top and Higgs secondary decay angular weights. | |
386 | double weightTopDecay( Event& process, int iResBeg, int iResEnd); | |
387 | double weightHiggsDecay( Event& process, int iResBeg, int iResEnd); | |
388 | ||
389 | }; | |
390 | ||
391 | //========================================================================== | |
392 | ||
393 | // Sigma0Process is the base class for unresolved and minimum-bias processes. | |
394 | // It is derived from SigmaProcess. | |
395 | ||
396 | class Sigma0Process : public SigmaProcess { | |
397 | ||
398 | public: | |
399 | ||
400 | // Destructor. | |
401 | virtual ~Sigma0Process() {} | |
402 | ||
403 | // Number of final-state particles. | |
404 | virtual int nFinal() const {return 2;}; | |
405 | ||
406 | // No partonic flux to be set up. | |
407 | virtual bool initFlux() {return true;} | |
408 | ||
409 | // Evaluate sigma for unresolved processes. | |
410 | virtual double sigmaHat() {return 0.;} | |
411 | ||
412 | // Since no PDF's there is no difference from above. | |
413 | virtual double sigmaPDF() {return sigmaHat();} | |
414 | ||
415 | // Answer for these processes already in mb, so do not convert. | |
416 | virtual bool convert2mb() const {return false;} | |
417 | ||
418 | protected: | |
419 | ||
420 | // Constructor. | |
421 | Sigma0Process() {} | |
422 | ||
423 | }; | |
424 | ||
425 | //========================================================================== | |
426 | ||
427 | // Sigma1Process is the base class for 2 -> 1 processes. | |
428 | // It is derived from SigmaProcess. | |
429 | ||
430 | class Sigma1Process : public SigmaProcess { | |
431 | ||
432 | public: | |
433 | ||
434 | // Destructor. | |
435 | virtual ~Sigma1Process() {} | |
436 | ||
437 | // Number of final-state particles. | |
438 | virtual int nFinal() const {return 1;}; | |
439 | ||
440 | // Input and complement kinematics for resolved 2 -> 1 process. | |
441 | virtual void set1Kin( double x1in, double x2in, double sHin) { | |
442 | store1Kin( x1in, x2in, sHin); sigmaKin();} | |
443 | ||
444 | // Evaluate sigmaHat(sHat) for resolved 2 -> 1 processes. | |
445 | virtual double sigmaHat() {return 0.;} | |
446 | ||
447 | // Wrapper to sigmaHat, to (a) store current incoming flavours, | |
448 | // (b) convert from GeV^-2 to mb where required, and | |
449 | // (c) convert from |M|^2 to d(sigmaHat)/d(tHat) where required. | |
450 | virtual double sigmaHatWrap(int id1in = 0, int id2in = 0); | |
451 | ||
452 | protected: | |
453 | ||
454 | // Constructor. | |
455 | Sigma1Process() {} | |
456 | ||
457 | // Store kinematics and set scales for resolved 2 -> 1 process. | |
458 | virtual void store1Kin( double x1in, double x2in, double sHin); | |
459 | ||
460 | // Calculate modified masses and four-vectors for matrix elements. | |
461 | virtual bool setupForME(); | |
462 | ||
463 | }; | |
464 | ||
465 | //========================================================================== | |
466 | ||
467 | // Sigma2Process is the base class for 2 -> 2 processes. | |
468 | // It is derived from SigmaProcess. | |
469 | ||
470 | class Sigma2Process : public SigmaProcess { | |
471 | ||
472 | public: | |
473 | ||
474 | // Destructor. | |
475 | virtual ~Sigma2Process() {} | |
476 | ||
477 | // Number of final-state particles. | |
478 | virtual int nFinal() const {return 2;}; | |
479 | ||
480 | // Input and complement kinematics for resolved 2 -> 2 process. | |
481 | virtual void set2Kin( double x1in, double x2in, double sHin, | |
482 | double tHin, double m3in, double m4in, double runBW3in, | |
483 | double runBW4in) { store2Kin( x1in, x2in, sHin, tHin, m3in, m4in, | |
484 | runBW3in, runBW4in); sigmaKin();} | |
485 | ||
486 | // Ditto, but for Multiparton Interactions applications, so different input. | |
487 | virtual void set2KinMPI( double x1in, double x2in, double sHin, | |
488 | double tHin, double uHin, double alpSin, double alpEMin, | |
489 | bool needMasses, double m3in, double m4in) { | |
490 | store2KinMPI( x1in, x2in, sHin, tHin, uHin, alpSin, alpEMin, | |
491 | needMasses, m3in, m4in); sigmaKin();} | |
492 | ||
493 | // Evaluate d(sigmaHat)/d(tHat) for resolved 2 -> 2 processes. | |
494 | virtual double sigmaHat() {return 0.;} | |
495 | ||
496 | // Wrapper to sigmaHat, to (a) store current incoming flavours, | |
497 | // (b) convert from GeV^-2 to mb where required, and | |
498 | // (c) convert from |M|^2 to d(sigmaHat)/d(tHat) where required. | |
499 | virtual double sigmaHatWrap(int id1in = 0, int id2in = 0) { | |
500 | id1 = id1in; id2 = id2in; double sigmaTmp = sigmaHat(); | |
501 | if (convertM2()) sigmaTmp /= 16. * M_PI * sH2; | |
502 | if (convert2mb()) sigmaTmp *= CONVERT2MB; return sigmaTmp;} | |
503 | ||
504 | // Perform kinematics for a Multiparton Interaction, in its rest frame. | |
505 | virtual bool final2KinMPI( int i1Res = 0, int i2Res = 0, Vec4 p1Res = 0., | |
506 | Vec4 p2Res = 0., double m1Res = 0., double m2Res = 0.); | |
507 | ||
508 | protected: | |
509 | ||
510 | // Constructor. | |
511 | Sigma2Process() : tH(0.), uH(0.), tH2(0.), uH2(0.), m3(0.), s3(0.), | |
512 | m4(0.), s4(0.), pT2(0.), runBW3(0.), runBW4(0.) {} | |
513 | ||
514 | // Store kinematics and set scales for resolved 2 -> 2 process. | |
515 | virtual void store2Kin( double x1in, double x2in, double sHin, | |
516 | double tHin, double m3in, double m4in, double runBW3in, | |
517 | double runBW4in); | |
518 | virtual void store2KinMPI( double x1in, double x2in, double sHin, | |
519 | double tHin, double uHin, double alpSin, double alpEMin, | |
520 | bool needMasses, double m3in, double m4in); | |
521 | ||
522 | // Calculate modified masses and four-vectors for matrix elements. | |
523 | virtual bool setupForME(); | |
524 | ||
525 | // Store subprocess kinematics quantities. | |
526 | double tH, uH, tH2, uH2, m3, s3, m4, s4, pT2, runBW3, runBW4; | |
527 | ||
528 | }; | |
529 | ||
530 | //========================================================================== | |
531 | ||
532 | // Sigma3Process is the base class for 2 -> 3 processes. | |
533 | // It is derived from SigmaProcess. | |
534 | ||
535 | class Sigma3Process : public SigmaProcess { | |
536 | ||
537 | public: | |
538 | ||
539 | // Destructor. | |
540 | virtual ~Sigma3Process() {} | |
541 | ||
542 | // Number of final-state particles. | |
543 | virtual int nFinal() const {return 3;}; | |
544 | ||
545 | // Input and complement kinematics for resolved 2 -> 3 process. | |
546 | virtual void set3Kin( double x1in, double x2in, double sHin, | |
547 | Vec4 p3cmIn, Vec4 p4cmIn, Vec4 p5cmIn, double m3in, double m4in, | |
548 | double m5in, double runBW3in, double runBW4in, double runBW5in) { | |
549 | store3Kin( x1in, x2in, sHin, p3cmIn, p4cmIn, p5cmIn, m3in, m4in, m5in, | |
550 | runBW3in, runBW4in, runBW5in); sigmaKin();} | |
551 | ||
552 | // Evaluate d(sigmaHat)/d(tHat) for resolved 2 -> 3 processes. | |
553 | virtual double sigmaHat() {return 0.;} | |
554 | ||
555 | protected: | |
556 | ||
557 | // Constructor. | |
558 | Sigma3Process() {} | |
559 | ||
560 | // Store kinematics and set scales for resolved 2 -> 3 process. | |
561 | virtual void store3Kin( double x1in, double x2in, double sHin, | |
562 | Vec4 p3cmIn, Vec4 p4cmIn, Vec4 p5cmIn, double m3in, double m4in, | |
563 | double m5in, double runBW3in, double runBW4in, double runBW5in); | |
564 | ||
565 | // Calculate modified masses and four-vectors for matrix elements. | |
566 | virtual bool setupForME(); | |
567 | ||
568 | // Store subprocess kinematics quantities. | |
569 | double m3, s3, m4, s4, m5, s5, runBW3, runBW4, runBW5; | |
570 | Vec4 p3cm, p4cm, p5cm; | |
571 | ||
572 | }; | |
573 | ||
574 | //========================================================================== | |
575 | ||
576 | // SigmaLHAProcess is a wrapper class for Les Houches Accord external input. | |
577 | // It is derived from SigmaProcess. | |
578 | ||
579 | class SigmaLHAProcess : public SigmaProcess { | |
580 | ||
581 | public: | |
582 | ||
583 | // Constructor. | |
584 | SigmaLHAProcess() {} | |
585 | ||
586 | // Destructor. | |
587 | virtual ~SigmaLHAProcess() {} | |
588 | ||
589 | // No partonic flux to be set up. | |
590 | virtual bool initFlux() {return true;} | |
591 | ||
592 | // Dummy function: action is put in PhaseSpaceLHA. | |
593 | virtual double sigmaPDF() {return 1.;} | |
594 | ||
595 | // Evaluate weight for decay angular configuration, where relevant. | |
596 | virtual double weightDecay( Event& process, int iResBeg, int iResEnd); | |
597 | ||
598 | // Set scale, when that is missing for an external LHA process. | |
599 | virtual void setScale(); | |
600 | ||
601 | // Info on the subprocess. | |
602 | virtual string name() const {return "Les Houches User Process(es)";} | |
603 | virtual int code() const {return 9999;} | |
604 | ||
605 | // Number of final-state particles depends on current process choice. | |
606 | virtual int nFinal() const; | |
607 | ||
608 | // Answer for these processes not in GeV^-2, so do not do this conversion. | |
609 | virtual bool convert2mb() const {return false;} | |
610 | ||
611 | // Ensure special treatment of Les Houches processes. | |
612 | virtual bool isLHA() const {return true;} | |
613 | ||
614 | // Special treatment needed if negative cross sections allowed. | |
615 | virtual bool allowNegativeSigma() const { | |
616 | return (lhaUpPtr->strategy() < 0);} | |
617 | ||
618 | private: | |
619 | ||
620 | }; | |
621 | ||
622 | //========================================================================== | |
623 | ||
624 | } // end namespace Pythia8 | |
625 | ||
626 | #endif // Pythia8_SigmaProcess_H | |
627 |