Line data Source code
1 : // ProcessContainer.cc is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 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 : // Function definitions (not found in the header) for the
7 : // ProcessContainer and SetupContainers classes.
8 :
9 : #include "Pythia8/ProcessContainer.h"
10 :
11 : // Internal headers for special processes.
12 : #include "Pythia8/SigmaCompositeness.h"
13 : #include "Pythia8/SigmaEW.h"
14 : #include "Pythia8/SigmaExtraDim.h"
15 : #include "Pythia8/SigmaGeneric.h"
16 : #include "Pythia8/SigmaHiggs.h"
17 : #include "Pythia8/SigmaLeftRightSym.h"
18 : #include "Pythia8/SigmaLeptoquark.h"
19 : #include "Pythia8/SigmaNewGaugeBosons.h"
20 : #include "Pythia8/SigmaQCD.h"
21 : #include "Pythia8/SigmaSUSY.h"
22 :
23 : namespace Pythia8 {
24 :
25 : //==========================================================================
26 :
27 : // ProcessContainer class.
28 : // Information allowing the generation of a specific process.
29 :
30 : //--------------------------------------------------------------------------
31 :
32 : // Constants: could be changed here if desired, but normally should not.
33 : // These are of technical nature, as described for each.
34 :
35 : // Number of event tries to check maximization finding reliability.
36 : const int ProcessContainer::N12SAMPLE = 100;
37 :
38 : // Ditto, but increased for 2 -> 3 processes.
39 : const int ProcessContainer::N3SAMPLE = 1000;
40 :
41 : //--------------------------------------------------------------------------
42 :
43 : // Initialize phase space and counters.
44 : // Argument isFirst distinguishes two hard processes in same event.
45 :
46 : bool ProcessContainer::init(bool isFirst, Info* infoPtrIn,
47 : Settings& settings, ParticleData* particleDataPtrIn, Rndm* rndmPtrIn,
48 : BeamParticle* beamAPtr, BeamParticle* beamBPtr, Couplings* couplingsPtr,
49 : SigmaTotal* sigmaTotPtr, ResonanceDecays* resDecaysPtrIn,
50 : SLHAinterface* slhaInterfacePtr, UserHooks* userHooksPtrIn) {
51 :
52 : // Extract info about current process from SigmaProcess object.
53 0 : isLHA = sigmaProcessPtr->isLHA();
54 0 : isNonDiff = sigmaProcessPtr->isNonDiff();
55 0 : isResolved = sigmaProcessPtr->isResolved();
56 0 : isDiffA = sigmaProcessPtr->isDiffA();
57 0 : isDiffB = sigmaProcessPtr->isDiffB();
58 0 : isDiffC = sigmaProcessPtr->isDiffC();
59 0 : isQCD3body = sigmaProcessPtr->isQCD3body();
60 0 : int nFin = sigmaProcessPtr->nFinal();
61 0 : lhaStrat = (isLHA) ? lhaUpPtr->strategy() : 0;
62 0 : lhaStratAbs = abs(lhaStrat);
63 0 : allowNegSig = sigmaProcessPtr->allowNegativeSigma();
64 :
65 0 : useStrictLHEFscales = settings.flag("Beams:strictLHEFscale");
66 :
67 : // Flag for maximum violation handling.
68 0 : increaseMaximum = settings.flag("PhaseSpace:increaseMaximum");
69 :
70 : // Pick and create phase space generator. Send pointers where required.
71 0 : if (phaseSpacePtr != 0) ;
72 0 : else if (isLHA) phaseSpacePtr = new PhaseSpaceLHA();
73 0 : else if (isNonDiff) phaseSpacePtr = new PhaseSpace2to2nondiffractive();
74 0 : else if (!isResolved && !isDiffA && !isDiffB && !isDiffC )
75 0 : phaseSpacePtr = new PhaseSpace2to2elastic();
76 0 : else if (!isResolved && !isDiffA && !isDiffB && isDiffC)
77 0 : phaseSpacePtr = new PhaseSpace2to3diffractive();
78 0 : else if (!isResolved) phaseSpacePtr = new PhaseSpace2to2diffractive(
79 0 : isDiffA, isDiffB);
80 0 : else if (nFin == 1) phaseSpacePtr = new PhaseSpace2to1tauy();
81 0 : else if (nFin == 2) phaseSpacePtr = new PhaseSpace2to2tauyz();
82 0 : else if (isQCD3body) phaseSpacePtr = new PhaseSpace2to3yyycyl();
83 0 : else phaseSpacePtr = new PhaseSpace2to3tauycyl();
84 :
85 : // Store pointers and perform simple initialization.
86 0 : infoPtr = infoPtrIn;
87 0 : particleDataPtr = particleDataPtrIn;
88 0 : rndmPtr = rndmPtrIn;
89 0 : resDecaysPtr = resDecaysPtrIn;
90 0 : userHooksPtr = userHooksPtrIn;
91 0 : canVetoResDecay = (userHooksPtr != 0)
92 0 : ? userHooksPtr->canVetoResonanceDecays() : false;
93 0 : if (isLHA) {
94 0 : sigmaProcessPtr->setLHAPtr(lhaUpPtr);
95 0 : phaseSpacePtr->setLHAPtr(lhaUpPtr);
96 0 : }
97 0 : sigmaProcessPtr->init(infoPtr, &settings, particleDataPtr, rndmPtr,
98 : beamAPtr, beamBPtr, couplingsPtr, sigmaTotPtr, slhaInterfacePtr);
99 0 : phaseSpacePtr->init( isFirst, sigmaProcessPtr, infoPtr, &settings,
100 0 : particleDataPtr, rndmPtr, beamAPtr, beamBPtr, couplingsPtr, sigmaTotPtr,
101 0 : userHooksPtr);
102 :
103 : // Reset cross section statistics.
104 0 : nTry = 0;
105 0 : nSel = 0;
106 0 : nAcc = 0;
107 0 : nTryStat = 0;
108 0 : sigmaMx = 0.;
109 0 : sigmaSum = 0.;
110 0 : sigma2Sum = 0.;
111 0 : sigmaNeg = 0.;
112 0 : sigmaAvg = 0.;
113 0 : sigmaFin = 0.;
114 0 : deltaFin = 0.;
115 0 : wtAccSum = 0.;
116 :
117 : // Initialize process and allowed incoming partons.
118 0 : sigmaProcessPtr->initProc();
119 0 : if (!sigmaProcessPtr->initFlux()) return false;
120 :
121 : // Find maximum of differential cross section * phasespace.
122 0 : bool physical = phaseSpacePtr->setupSampling();
123 0 : sigmaMx = phaseSpacePtr->sigmaMax();
124 : double sigmaHalfWay = sigmaMx;
125 :
126 : // Separate signed maximum needed for LHA with negative weight.
127 0 : sigmaSgn = phaseSpacePtr->sigmaSumSigned();
128 :
129 : // Check maximum by a few events, and extrapolate a further increase.
130 0 : if (physical & !isLHA) {
131 0 : int nSample = (nFin < 3) ? N12SAMPLE : N3SAMPLE;
132 0 : for (int iSample = 0; iSample < nSample; ++iSample) {
133 : bool test = false;
134 0 : while (!test) test = phaseSpacePtr->trialKin(false);
135 0 : if (iSample == nSample/2) sigmaHalfWay = phaseSpacePtr->sigmaMax();
136 : }
137 0 : double sigmaFullWay = phaseSpacePtr->sigmaMax();
138 0 : sigmaMx = (sigmaHalfWay > 0.) ? pow2(sigmaFullWay) / sigmaHalfWay
139 : : sigmaFullWay;
140 0 : phaseSpacePtr->setSigmaMax(sigmaMx);
141 0 : }
142 :
143 : // Allow Pythia to overwrite incoming beams or parts of Les Houches input.
144 0 : idRenameBeams = settings.mode("LesHouches:idRenameBeams");
145 0 : setLifetime = settings.mode("LesHouches:setLifetime");
146 0 : setLeptonMass = settings.mode("LesHouches:setLeptonMass");
147 0 : mRecalculate = settings.parm("LesHouches:mRecalculate");
148 0 : matchInOut = settings.flag("LesHouches:matchInOut");
149 0 : idLep[0] = 11; mLep[0] = particleDataPtr->m0(11);
150 0 : idLep[1] = 13; mLep[1] = particleDataPtr->m0(13);
151 0 : idLep[2] = 15; mLep[2] = particleDataPtr->m0(15);
152 :
153 : // Done.
154 : return physical;
155 0 : }
156 :
157 : //--------------------------------------------------------------------------
158 :
159 : // Generate a trial event; selected or not.
160 :
161 : bool ProcessContainer::trialProcess() {
162 :
163 : // Loop over tries only occurs for Les Houches strategy = +-2.
164 0 : for (int iTry = 0; ; ++iTry) {
165 :
166 : // Generate a trial phase space point, if meaningful.
167 0 : if (sigmaMx == 0.) return false;
168 0 : infoPtr->setEndOfFile(false);
169 0 : bool repeatSame = (iTry > 0);
170 0 : bool physical = phaseSpacePtr->trialKin(true, repeatSame);
171 :
172 : // Note if at end of Les Houches file, else do statistics.
173 0 : if (isLHA && !physical) infoPtr->setEndOfFile(true);
174 : else {
175 0 : ++nTry;
176 : // Statistics for separate Les Houches process codes. Insert new codes.
177 0 : if (isLHA) {
178 0 : int codeLHANow = lhaUpPtr->idProcess();
179 : int iFill = -1;
180 0 : for (int i = 0; i < int(codeLHA.size()); ++i)
181 0 : if (codeLHANow == codeLHA[i]) iFill = i;
182 0 : if (iFill >= 0) {
183 0 : ++nTryLHA[iFill];
184 0 : } else {
185 0 : codeLHA.push_back(codeLHANow);
186 0 : nTryLHA.push_back(1);
187 0 : nSelLHA.push_back(0);
188 0 : nAccLHA.push_back(0);
189 0 : for (int i = int(codeLHA.size()) - 1; i > 0; --i) {
190 0 : if (codeLHA[i] < codeLHA[i - 1]) {
191 0 : swap(codeLHA[i], codeLHA[i - 1]);
192 0 : swap(nTryLHA[i], nTryLHA[i - 1]);
193 0 : swap(nSelLHA[i], nSelLHA[i - 1]);
194 0 : swap(nAccLHA[i], nAccLHA[i - 1]);
195 : }
196 0 : else break;
197 : }
198 : }
199 0 : }
200 : }
201 :
202 : // Possibly fail, else cross section.
203 0 : if (!physical) return false;
204 0 : double sigmaNow = phaseSpacePtr->sigmaNow();
205 :
206 : // Tell if this event comes with weight from cross section.
207 : double sigmaWeight = 1.;
208 0 : if (!isLHA && !increaseMaximum && sigmaNow > sigmaMx)
209 0 : sigmaWeight = sigmaNow / sigmaMx;
210 0 : if ( lhaStrat < 0 && sigmaNow < 0.) sigmaWeight = -1.;
211 0 : if ( lhaStratAbs == 4) sigmaWeight = sigmaNow;
212 :
213 : // Also compensating weight from biased phase-space selection.
214 0 : double biasWeight = phaseSpacePtr->biasSelectionWeight();
215 0 : weightNow = sigmaWeight * biasWeight;
216 0 : infoPtr->setWeight( weightNow, lhaStrat);
217 :
218 : // Check that not negative cross section when not allowed.
219 0 : if (!allowNegSig) {
220 0 : if (sigmaNow < sigmaNeg) {
221 0 : infoPtr->errorMsg("Warning in ProcessContainer::trialProcess: neg"
222 0 : "ative cross section set 0", "for " + sigmaProcessPtr->name() );
223 0 : sigmaNeg = sigmaNow;
224 0 : }
225 0 : if (sigmaNow < 0.) sigmaNow = 0.;
226 : }
227 :
228 : // Cross section of process may come with a weight. Update sum.
229 0 : double sigmaAdd = sigmaNow * biasWeight;
230 0 : if (lhaStratAbs == 2 || lhaStratAbs == 3) sigmaAdd = sigmaSgn;
231 0 : sigmaSum += sigmaAdd;
232 0 : sigma2Sum += pow2(sigmaAdd);
233 :
234 : // Check if maximum violated.
235 0 : newSigmaMx = phaseSpacePtr->newSigmaMax();
236 0 : if (newSigmaMx) sigmaMx = phaseSpacePtr->sigmaMax();
237 :
238 : // Select or reject trial point. Statistics.
239 : bool select = true;
240 0 : if (lhaStratAbs < 3) select
241 0 : = (newSigmaMx || rndmPtr->flat() * abs(sigmaMx) < abs(sigmaNow));
242 0 : if (select) {
243 0 : ++nSel;
244 0 : if (isLHA) {
245 0 : int codeLHANow = lhaUpPtr->idProcess();
246 : int iFill = -1;
247 0 : for (int i = 0; i < int(codeLHA.size()); ++i)
248 0 : if (codeLHANow == codeLHA[i]) iFill = i;
249 0 : if (iFill >= 0) ++nSelLHA[iFill];
250 0 : }
251 : }
252 0 : if (select || lhaStratAbs != 2) return select;
253 :
254 0 : }
255 :
256 0 : }
257 :
258 : //--------------------------------------------------------------------------
259 :
260 : // Accumulate statistics after user veto, including LHA code.
261 :
262 : void ProcessContainer::accumulate() {
263 :
264 0 : ++nAcc;
265 0 : wtAccSum += weightNow;
266 0 : if (isLHA) {
267 0 : int codeLHANow = lhaUpPtr->idProcess();
268 : int iFill = -1;
269 0 : for (int i = 0; i < int(codeLHA.size()); ++i)
270 0 : if (codeLHANow == codeLHA[i]) iFill = i;
271 0 : if (iFill >= 0) ++nAccLHA[iFill];
272 0 : }
273 :
274 0 : }
275 :
276 : //--------------------------------------------------------------------------
277 :
278 : // Pick flavours and colour flow of process.
279 :
280 : bool ProcessContainer::constructState() {
281 :
282 : // Construct flavour and colours for selected event.
283 0 : if (isResolved && !isNonDiff) sigmaProcessPtr->pickInState();
284 0 : sigmaProcessPtr->setIdColAcol();
285 :
286 : // Done.
287 0 : return true;
288 :
289 : }
290 :
291 : //--------------------------------------------------------------------------
292 :
293 : // Give the hard subprocess with kinematics.
294 :
295 : bool ProcessContainer::constructProcess( Event& process, bool isHardest) {
296 :
297 : // Construct kinematics from selected phase space point.
298 0 : if (!phaseSpacePtr->finalKin()) return false;
299 0 : int nFin = sigmaProcessPtr->nFinal();
300 :
301 : // Basic info on process.
302 0 : if (isHardest) infoPtr->setType( name(), code(), nFin, isNonDiff,
303 0 : isResolved, isDiffA, isDiffB, isDiffC, isLHA);
304 :
305 : // Let hard process record begin with the event as a whole and
306 : // the two incoming beam particles.
307 0 : int idA = infoPtr->idA();
308 0 : if (abs(idA) == idRenameBeams) idA = 16;
309 0 : int idB = infoPtr->idB();
310 0 : if (abs(idB) == idRenameBeams) idB = -16;
311 0 : process.append( 90, -11, 0, 0, 0, 0, 0, 0,
312 0 : Vec4(0., 0., 0., infoPtr->eCM()), infoPtr->eCM(), 0. );
313 0 : process.append( idA, -12, 0, 0, 0, 0, 0, 0,
314 0 : Vec4(0., 0., infoPtr->pzA(), infoPtr->eA()), infoPtr->mA(), 0. );
315 0 : process.append( idB, -12, 0, 0, 0, 0, 0, 0,
316 0 : Vec4(0., 0., infoPtr->pzB(), infoPtr->eB()), infoPtr->mB(), 0. );
317 :
318 : // For nondiffractive process no interaction selected so far, so done.
319 0 : if (isNonDiff) return true;
320 :
321 : // Entries 3 and 4, now to be added, come from 1 and 2.
322 0 : process[1].daughter1(3);
323 0 : process[2].daughter1(4);
324 0 : double scale = 0.;
325 : double scalup = 0.;
326 :
327 : // For DiffC entries 3 - 5 come jointly from 1 and 2 (to keep HepMC happy).
328 0 : if (isDiffC) {
329 0 : process[1].daughters(3, 5);
330 0 : process[2].daughters(3, 5);
331 0 : }
332 :
333 : // Insert the subprocess partons - resolved processes.
334 0 : int idRes = sigmaProcessPtr->idSChannel();
335 0 : if (isResolved && !isLHA) {
336 :
337 : // NOAM: Mothers and daughters without/with intermediate state.
338 : int m_M1 = 3;
339 : int m_M2 = 4;
340 : int m_D1 = 5;
341 0 : int m_D2 = (nFin == 1) ? 0 : 4 + nFin;
342 0 : if (idRes != 0) {
343 : m_M1 = 5;
344 : m_M2 = 0;
345 : m_D1 = 5;
346 : m_D2 = 0;
347 0 : }
348 :
349 : // Find scale from which to begin MPI/ISR/FSR evolution.
350 0 : scale = sqrt(Q2Fac());
351 0 : process.scale( scale );
352 :
353 : // Loop over incoming and outgoing partons.
354 0 : int colOffset = process.lastColTag();
355 0 : for (int i = 1; i <= 2 + nFin; ++i) {
356 :
357 : // Read out particle info from SigmaProcess object.
358 0 : int id = sigmaProcessPtr->id(i);
359 0 : int status = (i <= 2) ? -21 : 23;
360 0 : int mother1 = (i <= 2) ? i : m_M1 ;
361 0 : int mother2 = (i <= 2) ? 0 : m_M2 ;
362 0 : int daughter1 = (i <= 2) ? m_D1 : 0;
363 0 : int daughter2 = (i <= 2) ? m_D2 : 0;
364 0 : int col = sigmaProcessPtr->col(i);
365 0 : if (col > 0) col += colOffset;
366 0 : else if (col < 0) col -= colOffset;
367 0 : int acol = sigmaProcessPtr->acol(i);
368 0 : if (acol > 0) acol += colOffset;
369 0 : else if (acol < 0) acol -= colOffset;
370 :
371 : // Append to process record.
372 0 : int iNow = process.append( id, status, mother1, mother2,
373 0 : daughter1, daughter2, col, acol, phaseSpacePtr->p(i),
374 0 : phaseSpacePtr->m(i), scale);
375 :
376 : // NOAM: If there is an intermediate state, insert the it in
377 : // the process record after the two incoming particles.
378 0 : if (i == 2 && idRes != 0) {
379 :
380 : // Sign of intermediate state: go by charge.
381 0 : if (particleDataPtr->hasAnti(idRes)
382 0 : && process[3].chargeType() + process[4].chargeType() < 0)
383 0 : idRes *= -1;
384 :
385 : // The colour configuration of the intermediate state has to be
386 : // resolved separately.
387 : col = 0;
388 : acol = 0;
389 0 : int m_col1 = sigmaProcessPtr->col(1);
390 0 : int m_acol1 = sigmaProcessPtr->acol(1);
391 0 : int m_col2 = sigmaProcessPtr->col(2);
392 0 : int m_acol2 = sigmaProcessPtr->acol(2);
393 0 : if (m_col1 == m_acol2 && m_col2 != m_acol1) {
394 : col = m_col2;
395 : acol = m_acol1;
396 0 : } else if (m_col2 == m_acol1 && m_col1 != m_acol2) {
397 : col = m_col1;
398 : acol = m_acol2;
399 0 : }
400 0 : if ( col > 0) col += colOffset;
401 0 : else if ( col < 0) col -= colOffset;
402 0 : if (acol > 0) acol += colOffset;
403 0 : else if (acol < 0) acol -= colOffset;
404 :
405 : // Insert the intermediate state into the event record.
406 0 : Vec4 pIntMed = phaseSpacePtr->p(1) + phaseSpacePtr->p(2);
407 0 : process.append( idRes, -22, 3, 4, 6, 5 + nFin, col, acol,
408 0 : pIntMed, pIntMed.mCalc(), scale);
409 0 : }
410 :
411 : // Pick lifetime where relevant, else not.
412 0 : if (process[iNow].tau0() > 0.) process[iNow].tau(
413 0 : process[iNow].tau0() * rndmPtr->exp() );
414 : }
415 0 : }
416 :
417 : // Insert the outgoing particles - unresolved processes.
418 0 : else if (!isLHA) {
419 0 : int id3 = sigmaProcessPtr->id(3);
420 0 : int status3 = (id3 == process[1].id()) ? 14 : 15;
421 0 : process.append( id3, status3, 1, 0, 0, 0, 0, 0,
422 0 : phaseSpacePtr->p(3), phaseSpacePtr->m(3));
423 0 : int id4 = sigmaProcessPtr->id(4);
424 0 : int status4 = (id4 == process[2].id()) ? 14 : 15;
425 0 : process.append( id4, status4, 2, 0, 0, 0, 0, 0,
426 0 : phaseSpacePtr->p(4), phaseSpacePtr->m(4));
427 :
428 : // For central diffraction: two scattered protons inserted so far,
429 : // but modify mothers, add also centrally-produced hadronic system.
430 0 : if (isDiffC) {
431 0 : process[3].mothers( 1, 2);
432 0 : process[4].mothers( 1, 2);
433 0 : int id5 = sigmaProcessPtr->id(5);
434 : int status5 = 15;
435 0 : process.append( id5, status5, 1, 2, 0, 0, 0, 0,
436 0 : phaseSpacePtr->p(5), phaseSpacePtr->m(5));
437 0 : }
438 0 : }
439 :
440 : // Insert the outgoing particles - Les Houches Accord processes.
441 : else {
442 :
443 : // Since LHA partons may be out of order, determine correct one.
444 : // (Recall that zeroth particle is empty.)
445 0 : vector<int> newPos;
446 0 : newPos.reserve(lhaUpPtr->sizePart());
447 0 : newPos.push_back(0);
448 0 : for (int iNew = 0; iNew < lhaUpPtr->sizePart(); ++iNew) {
449 : // For iNew == 0 look for the two incoming partons, then for
450 : // partons having them as mothers, and so on layer by layer.
451 0 : for (int i = 1; i < lhaUpPtr->sizePart(); ++i)
452 0 : if (lhaUpPtr->mother1(i) == newPos[iNew]) newPos.push_back(i);
453 0 : if (int(newPos.size()) <= iNew) break;
454 : }
455 :
456 : // Find scale from which to begin MPI/ISR/FSR evolution.
457 0 : scalup = lhaUpPtr->scale();
458 0 : scale = scalup;
459 0 : double scalePr = (scale < 0.) ? sqrt(Q2Fac()) : scale;
460 0 : process.scale( scalePr);
461 :
462 : // Copy over info from LHA event to process, in proper order.
463 0 : Vec4 pSumOut;
464 0 : for (int i = 1; i < lhaUpPtr->sizePart(); ++i) {
465 0 : int iOld = newPos[i];
466 0 : int id = lhaUpPtr->id(iOld);
467 0 : if (i == 1 && abs(id) == idRenameBeams) id = 16;
468 0 : if (i == 2 && abs(id) == idRenameBeams) id = -16;
469 0 : int idAbs = abs(id);
470 :
471 : // Translate from LHA status codes.
472 0 : int lhaStatus = lhaUpPtr->status(iOld);
473 : int status = -21;
474 0 : if (lhaStatus == 2 || lhaStatus == 3) status = -22;
475 0 : if (lhaStatus == 1) status = 23;
476 :
477 : // Find where mothers have been moved by reordering.
478 0 : int mother1Old = lhaUpPtr->mother1(iOld);
479 0 : int mother2Old = lhaUpPtr->mother2(iOld);
480 : int mother1 = 0;
481 : int mother2 = 0;
482 0 : for (int im = 1; im < i; ++im) {
483 0 : if (mother1Old == newPos[im]) mother1 = im + 2;
484 0 : if (mother2Old == newPos[im]) mother2 = im + 2;
485 : }
486 0 : if (i <= 2) mother1 = i;
487 :
488 : // Ensure that second mother = 0 except for bona fide carbon copies.
489 0 : if (mother1 > 0 && mother2 == mother1) {
490 0 : int sister1 = process[mother1].daughter1();
491 0 : int sister2 = process[mother1].daughter2();
492 0 : if (sister2 != sister1 && sister2 != 0) mother2 = 0;
493 0 : }
494 :
495 : // Find daughters and where they have been moved by reordering.
496 : // (Values shifted two steps to account for inserted beams.)
497 : int daughter1 = 0;
498 : int daughter2 = 0;
499 0 : for (int im = i + 1; im < lhaUpPtr->sizePart(); ++im) {
500 0 : if (lhaUpPtr->mother1(newPos[im]) == iOld
501 0 : || lhaUpPtr->mother2(newPos[im]) == iOld) {
502 0 : if (daughter1 == 0 || im + 2 < daughter1) daughter1 = im + 2;
503 0 : if (daughter2 == 0 || im + 2 > daughter2) daughter2 = im + 2;
504 : }
505 : }
506 : // For 2 -> 1 hard scatterings reset second daughter to 0.
507 0 : if (daughter2 == daughter1) daughter2 = 0;
508 :
509 : // Colour trivial, except reset irrelevant colour indices.
510 0 : int colType = particleDataPtr->colType(id);
511 0 : int col1 = (colType == 1 || colType == 2 || abs(colType) == 3)
512 0 : ? lhaUpPtr->col1(iOld) : 0;
513 0 : int col2 = (colType == -1 || colType == 2 || abs(colType) == 3)
514 0 : ? lhaUpPtr->col2(iOld) : 0;
515 :
516 : // Copy momentum, ensure lepton masses and consistent (E, p m) set.
517 0 : double px = lhaUpPtr->px(iOld);
518 0 : double py = lhaUpPtr->py(iOld);
519 0 : double pz = lhaUpPtr->pz(iOld);
520 0 : double e = lhaUpPtr->e(iOld);
521 0 : double m = lhaUpPtr->m(iOld);
522 0 : for (int idL = 0; idL < 3; ++idL)
523 0 : if (idAbs == idLep[idL] && setLeptonMass > 0 && (setLeptonMass == 2
524 0 : || m < 0.9 * mLep[idL] || m > 1.1 * mLep[idL])) m = mLep[idL];
525 0 : if (mRecalculate > 0. && m > mRecalculate)
526 0 : m = sqrtpos( e*e - px*px - py*py - pz*pz);
527 0 : else e = sqrt( m*m + px*px + py*py + pz*pz);
528 :
529 : // Momentum sum for outgoing particles.
530 0 : if (matchInOut && i > 2 && lhaStatus == 1)
531 0 : pSumOut += Vec4( px, py, pz, e);
532 :
533 : // Polarization.
534 0 : double pol = lhaUpPtr->spin(iOld);
535 :
536 : // Allow scale setting for generic partons.
537 0 : double scaleShow = lhaUpPtr->scale(iOld);
538 :
539 : // For resonance decay products use resonance mass as scale.
540 : double scaleNow = scalePr;
541 0 : if (mother1 > 4 && !useStrictLHEFscales) scaleNow = process[mother1].m();
542 0 : if (scaleShow >= 0.0) scaleNow = scaleShow;
543 :
544 : // Store Les Houches Accord partons.
545 0 : int iNow = process.append( id, status, mother1, mother2, daughter1,
546 0 : daughter2, col1, col2, Vec4(px, py, pz, e), m, scaleNow, pol);
547 :
548 : // Check if need to store lifetime.
549 0 : double tau = lhaUpPtr->tau(iOld);
550 0 : if ( (setLifetime == 1 && idAbs == 15) || setLifetime == 2)
551 0 : tau = process[iNow].tau0() * rndmPtr->exp();
552 0 : if (tau > 0.) process[iNow].tau(tau);
553 : }
554 :
555 : // Reassign momenta and masses for incoming partons.
556 0 : if (matchInOut) {
557 0 : double e1 = 0.5 * (pSumOut.e() + pSumOut.pz());
558 0 : double e2 = 0.5 * (pSumOut.e() - pSumOut.pz());
559 0 : process[3].pz( e1);
560 0 : process[3].e( e1);
561 0 : process[3].m( 0.);
562 0 : process[4].pz(-e2);
563 0 : process[4].e( e2);
564 0 : process[4].m( 0.);
565 0 : }
566 0 : }
567 :
568 : // Loop through decay chains and set secondary vertices when needed.
569 0 : for (int i = 3; i < process.size(); ++i) {
570 0 : int iMother = process[i].mother1();
571 :
572 : // If sister to already assigned vertex then assign same.
573 0 : if ( process[i - 1].mother1() == iMother && process[i - 1].hasVertex() )
574 0 : process[i].vProd( process[i - 1].vProd() );
575 :
576 : // Else if mother already has vertex and/or lifetime then assign.
577 0 : else if ( process[iMother].hasVertex() || process[iMother].tau() > 0.)
578 0 : process[i].vProd( process[iMother].vDec() );
579 : }
580 :
581 : // Further info on process. Reset quantities that may or may not be known.
582 0 : int id1Now = process[3].id();
583 0 : int id2Now = process[4].id();
584 : int id1pdf = 0;
585 : int id2pdf = 0;
586 : double x1pdf = 0.;
587 : double x2pdf = 0.;
588 : double pdf1 = 0.;
589 : double pdf2 = 0.;
590 : double tHat = 0.;
591 : double uHat = 0.;
592 : double pTHatL = 0.;
593 : double m3 = 0.;
594 : double m4 = 0.;
595 : double theta = 0.;
596 : double phi = 0.;
597 : double x1Now, x2Now, Q2FacNow, alphaEM, alphaS, Q2Ren, sHat;
598 :
599 : // Internally generated and stored information.
600 0 : if (!isLHA) {
601 : id1pdf = id1Now;
602 : id2pdf = id2Now;
603 0 : x1Now = phaseSpacePtr->x1();
604 0 : x2Now = phaseSpacePtr->x2();
605 : x1pdf = x1Now;
606 : x2pdf = x2Now;
607 0 : pdf1 = sigmaProcessPtr->pdf1();
608 0 : pdf2 = sigmaProcessPtr->pdf2();
609 0 : Q2FacNow = sigmaProcessPtr->Q2Fac();
610 0 : alphaEM = sigmaProcessPtr->alphaEMRen();
611 0 : alphaS = sigmaProcessPtr->alphaSRen();
612 0 : Q2Ren = sigmaProcessPtr->Q2Ren();
613 0 : sHat = phaseSpacePtr->sHat();
614 0 : tHat = phaseSpacePtr->tHat();
615 0 : uHat = phaseSpacePtr->uHat();
616 0 : pTHatL = phaseSpacePtr->pTHat();
617 0 : m3 = phaseSpacePtr->m(3);
618 0 : m4 = phaseSpacePtr->m(4);
619 0 : theta = phaseSpacePtr->thetaHat();
620 0 : phi = phaseSpacePtr->phiHat();
621 0 : }
622 :
623 : // Les Houches Accord process partly available, partly to be constructed.
624 : else {
625 0 : x1Now = 2. * process[3].e() / infoPtr->eCM();
626 0 : x2Now = 2. * process[4].e() / infoPtr->eCM();
627 0 : Q2FacNow = (scale < 0.) ? sigmaProcessPtr->Q2Fac() : pow2(scale);
628 0 : alphaEM = lhaUpPtr->alphaQED();
629 0 : if (alphaEM < 0.001) alphaEM = sigmaProcessPtr->alphaEMRen();
630 0 : alphaS = lhaUpPtr->alphaQCD();
631 0 : if (alphaS < 0.001) alphaS = sigmaProcessPtr->alphaSRen();
632 0 : Q2Ren = (scale < 0.) ? sigmaProcessPtr->Q2Ren() : pow2(scale);
633 0 : Vec4 pSum = process[3].p() + process[4].p();
634 0 : sHat = pSum * pSum;
635 : int nFinLH = 0;
636 : double pTLH = 0.;
637 0 : for (int i = 5; i < process.size(); ++i)
638 0 : if (process[i].mother1() == 3 && process[i].mother2() == 4) {
639 0 : ++nFinLH;
640 0 : pTLH += process[i].pT();
641 0 : }
642 0 : if (nFinLH > 0) pTHatL = pTLH / nFinLH;
643 :
644 : // Read info on parton densities if provided.
645 0 : id1pdf = lhaUpPtr->id1pdf();
646 0 : id2pdf = lhaUpPtr->id2pdf();
647 0 : x1pdf = lhaUpPtr->x1pdf();
648 0 : x2pdf = lhaUpPtr->x2pdf();
649 0 : if (lhaUpPtr->pdfIsSet()) {
650 0 : pdf1 = lhaUpPtr->pdf1();
651 0 : pdf2 = lhaUpPtr->pdf2();
652 0 : Q2FacNow = pow2(lhaUpPtr->scalePDF());
653 0 : }
654 :
655 : // Reconstruct kinematics of 2 -> 2 processes from momenta.
656 0 : if (nFin == 2) {
657 0 : Vec4 pDifT = process[3].p() - process[5].p();
658 0 : tHat = pDifT * pDifT;
659 0 : Vec4 pDifU = process[3].p() - process[6].p();
660 0 : uHat = pDifU * pDifU;
661 0 : pTHatL = process[5].pT();
662 0 : m3 = process[5].m();
663 0 : m4 = process[6].m();
664 0 : Vec4 p5 = process[5].p();
665 0 : p5.bstback(pSum);
666 0 : theta = p5.theta();
667 0 : phi = process[5].phi();
668 0 : }
669 0 : }
670 :
671 : // Store information.
672 0 : if (isHardest) {
673 0 : infoPtr->setPDFalpha( 0, id1pdf, id2pdf, x1pdf, x2pdf, pdf1, pdf2,
674 : Q2FacNow, alphaEM, alphaS, Q2Ren, scalup);
675 0 : infoPtr->setKin( 0, id1Now, id2Now, x1Now, x2Now, sHat, tHat, uHat,
676 : pTHatL, m3, m4, theta, phi);
677 0 : }
678 0 : infoPtr->setTypeMPI( code(), pTHatL);
679 :
680 : // For Les Houches event store subprocess classification.
681 0 : if (isLHA) {
682 0 : int codeSub = lhaUpPtr->idProcess();
683 0 : ostringstream nameSub;
684 0 : nameSub << "user process " << codeSub;
685 0 : infoPtr->setSubType( 0, nameSub.str(), codeSub, nFin);
686 0 : }
687 :
688 : // Done.
689 : return true;
690 :
691 0 : }
692 :
693 : //--------------------------------------------------------------------------
694 :
695 : // Give the hard resonance decay chain from Les Houches input.
696 : // Note: mildly modified copy of some constructProcess code; to streamline.
697 :
698 : bool ProcessContainer::constructDecays( Event& process) {
699 :
700 : // Let hard process record begin with the event as a whole.
701 0 : process.clear();
702 0 : process.append( 90, -11, 0, 0, 0, 0, 0, 0, Vec4(0., 0., 0., 0.), 0., 0. );
703 :
704 : // Since LHA partons may be out of order, determine correct one.
705 : // (Recall that zeroth particle is empty.)
706 0 : vector<int> newPos;
707 0 : newPos.reserve(lhaUpPtr->sizePart());
708 0 : newPos.push_back(0);
709 0 : for (int iNew = 0; iNew < lhaUpPtr->sizePart(); ++iNew) {
710 : // For iNew == 0 look for the two incoming partons, then for
711 : // partons having them as mothers, and so on layer by layer.
712 0 : for (int i = 1; i < lhaUpPtr->sizePart(); ++i)
713 0 : if (lhaUpPtr->mother1(i) == newPos[iNew]) newPos.push_back(i);
714 0 : if (int(newPos.size()) <= iNew) break;
715 : }
716 :
717 : // Find scale from which to begin MPI/ISR/FSR evolution.
718 0 : double scale = lhaUpPtr->scale();
719 0 : process.scale( scale);
720 0 : Vec4 pSum;
721 :
722 : // Copy over info from LHA event to process, in proper order.
723 0 : for (int i = 1; i < lhaUpPtr->sizePart(); ++i) {
724 0 : int iOld = newPos[i];
725 0 : int id = lhaUpPtr->id(iOld);
726 :
727 : // Translate from LHA status codes.
728 0 : int lhaStatus = lhaUpPtr->status(iOld);
729 : int status = -21;
730 0 : if (lhaStatus == 2 || lhaStatus == 3) status = -22;
731 0 : if (lhaStatus == 1) status = 23;
732 :
733 : // Find where mothers have been moved by reordering.
734 0 : int mother1Old = lhaUpPtr->mother1(iOld);
735 0 : int mother2Old = lhaUpPtr->mother2(iOld);
736 : int mother1 = 0;
737 : int mother2 = 0;
738 0 : for (int im = 1; im < i; ++im) {
739 0 : if (mother1Old == newPos[im]) mother1 = im;
740 0 : if (mother2Old == newPos[im]) mother2 = im;
741 : }
742 :
743 : // Ensure that second mother = 0 except for bona fide carbon copies.
744 0 : if (mother1 > 0 && mother2 == mother1) {
745 0 : int sister1 = process[mother1].daughter1();
746 0 : int sister2 = process[mother1].daughter2();
747 0 : if (sister2 != sister1 && sister2 != 0) mother2 = 0;
748 0 : }
749 :
750 : // Find daughters and where they have been moved by reordering.
751 : int daughter1 = 0;
752 : int daughter2 = 0;
753 0 : for (int im = i + 1; im < lhaUpPtr->sizePart(); ++im) {
754 0 : if (lhaUpPtr->mother1(newPos[im]) == iOld
755 0 : || lhaUpPtr->mother2(newPos[im]) == iOld) {
756 0 : if (daughter1 == 0 || im < daughter1) daughter1 = im;
757 0 : if (daughter2 == 0 || im > daughter2) daughter2 = im;
758 : }
759 : }
760 : // For 2 -> 1 hard scatterings reset second daughter to 0.
761 0 : if (daughter2 == daughter1) daughter2 = 0;
762 :
763 : // Colour trivial, except reset irrelevant colour indices.
764 0 : int colType = particleDataPtr->colType(id);
765 0 : int col1 = (colType == 1 || colType == 2 || abs(colType) == 3)
766 0 : ? lhaUpPtr->col1(iOld) : 0;
767 0 : int col2 = (colType == -1 || colType == 2 || abs(colType) == 3)
768 0 : ? lhaUpPtr->col2(iOld) : 0;
769 :
770 : // Momentum trivial.
771 0 : double px = lhaUpPtr->px(iOld);
772 0 : double py = lhaUpPtr->py(iOld);
773 0 : double pz = lhaUpPtr->pz(iOld);
774 0 : double e = lhaUpPtr->e(iOld);
775 0 : double m = lhaUpPtr->m(iOld);
776 0 : if (status > 0) pSum += Vec4( px, py, pz, e);
777 :
778 : // Polarization.
779 0 : double pol = lhaUpPtr->spin(iOld);
780 :
781 : // For resonance decay products use resonance mass as scale.
782 : double scaleNow = scale;
783 0 : if (mother1 > 0) scaleNow = process[mother1].m();
784 :
785 : // Store Les Houches Accord partons.
786 0 : int iNow = process.append( id, status, mother1, mother2, daughter1,
787 0 : daughter2, col1, col2, Vec4(px, py, pz, e), m, scaleNow, pol);
788 :
789 : // Check if need to store lifetime.
790 0 : double tau = lhaUpPtr->tau(iOld);
791 0 : if ( (setLifetime == 1 && abs(id) == 15) || setLifetime == 2)
792 0 : tau = process[iNow].tau0() * rndmPtr->exp();
793 0 : if (tau > 0.) process[iNow].tau(tau);
794 : }
795 :
796 : // Update four-momentum of system as a whole.
797 0 : process[0].p( pSum);
798 0 : process[0].m( pSum.mCalc());
799 :
800 : // Loop through decay chains and set secondary vertices when needed.
801 0 : for (int i = 1; i < process.size(); ++i) {
802 0 : int iMother = process[i].mother1();
803 :
804 : // If sister to already assigned vertex then assign same.
805 0 : if ( process[i - 1].mother1() == iMother && process[i - 1].hasVertex()
806 0 : && i > 1) process[i].vProd( process[i - 1].vProd() );
807 :
808 : // Else if mother already has vertex and/or lifetime then assign.
809 0 : else if ( process[iMother].hasVertex() || process[iMother].tau() > 0.)
810 0 : process[i].vProd( process[iMother].vDec() );
811 : }
812 :
813 : // Done.
814 : return true;
815 :
816 0 : }
817 :
818 : //--------------------------------------------------------------------------
819 :
820 : // Handle resonance decays.
821 :
822 : bool ProcessContainer::decayResonances( Event& process) {
823 :
824 : // Save current event-record size and status codes.
825 0 : process.saveSize();
826 0 : vector<int> statusSave( process.size());
827 0 : for (int i = 0; i < process.size(); ++i)
828 0 : statusSave[i] = process[i].status();
829 : bool physical = true;
830 : bool newChain = false;
831 : bool newFlavours = false;
832 :
833 : // Do loop over user veto.
834 0 : do {
835 :
836 : // Do sequential chain of uncorrelated isotropic decays.
837 : do {
838 0 : physical = resDecaysPtr->next( process);
839 0 : if (!physical) return false;
840 :
841 : // Check whether flavours should be correlated.
842 : // (Currently only relevant for f fbar -> gamma*/Z0 gamma*/Z0.)
843 0 : newFlavours = ( sigmaProcessPtr->weightDecayFlav( process)
844 0 : < rndmPtr->flat() );
845 :
846 : // Reset the decay chains if have to redo.
847 0 : if (newFlavours) {
848 0 : process.restoreSize();
849 0 : for (int i = 0; i < process.size(); ++i)
850 0 : process[i].status( statusSave[i]);
851 0 : }
852 :
853 : // Loop back where required to generate new decays with new flavours.
854 0 : } while (newFlavours);
855 :
856 : // Correct to nonisotropic decays.
857 0 : phaseSpacePtr->decayKinematics( process);
858 :
859 : // Optionally user hooks check/veto on decay chain.
860 0 : if (canVetoResDecay)
861 0 : newChain = userHooksPtr->doVetoResonanceDecays( process);
862 :
863 : // Reset the decay chains if have to redo.
864 0 : if (newChain) {
865 0 : process.restoreSize();
866 0 : for (int i = 0; i < process.size(); ++i)
867 0 : process[i].status( statusSave[i]);
868 0 : }
869 :
870 : // Loop back where required to generate new decay chain.
871 0 : } while(newChain);
872 :
873 : // Done.
874 0 : return true;
875 :
876 0 : }
877 :
878 : //--------------------------------------------------------------------------
879 :
880 : // Reset event generation statistics; but NOT maximum of cross section.
881 :
882 : void ProcessContainer::reset() {
883 :
884 0 : nTry = 0;
885 0 : nSel = 0;
886 0 : nAcc = 0;
887 0 : nTryStat = 0;
888 0 : sigmaSum = 0.;
889 0 : sigma2Sum = 0.;
890 0 : sigmaNeg = 0.;
891 0 : sigmaAvg = 0.;
892 0 : sigmaFin = 0.;
893 0 : deltaFin = 0.;
894 0 : wtAccSum = 0.;
895 :
896 0 : }
897 :
898 : //--------------------------------------------------------------------------
899 :
900 : // Estimate integrated cross section and its uncertainty.
901 :
902 : void ProcessContainer::sigmaDelta() {
903 :
904 : // Initial values. No analysis meaningful unless accepted events.
905 0 : nTryStat = nTry;
906 0 : sigmaAvg = 0.;
907 0 : sigmaFin = 0.;
908 0 : deltaFin = 0.;
909 0 : if (nAcc == 0) return;
910 :
911 : // Average value. No error analysis unless at least two events.
912 0 : double nTryInv = 1. / nTry;
913 0 : double nSelInv = 1. / nSel;
914 0 : double nAccInv = 1. / nAcc;
915 0 : sigmaAvg = sigmaSum * nTryInv;
916 0 : double fracAcc = nAcc * nSelInv;
917 0 : sigmaFin = sigmaAvg * fracAcc;
918 0 : deltaFin = sigmaFin;
919 0 : if (nAcc == 1) return;
920 :
921 : // Estimated error. Quadratic sum of cross section term and
922 : // binomial from accept/reject step.
923 0 : double delta2Sig = (lhaStratAbs != 3)
924 0 : ? (sigma2Sum * nTryInv - pow2(sigmaAvg)) * nTryInv / pow2(sigmaAvg)
925 0 : : pow2( lhaUpPtr->xErrSum() / lhaUpPtr->xSecSum());
926 0 : double delta2Veto = (nSel - nAcc) * nAccInv * nSelInv;
927 0 : double delta2Sum = delta2Sig + delta2Veto;
928 0 : deltaFin = sqrtpos(delta2Sum) * sigmaFin;
929 :
930 0 : }
931 :
932 : //==========================================================================
933 :
934 : // SetupContainer class.
935 : // Turns list of user-desired processes into a vector of containers.
936 :
937 : //--------------------------------------------------------------------------
938 :
939 : // Main routine to initialize list of processes.
940 :
941 : bool SetupContainers::init(vector<ProcessContainer*>& containerPtrs,
942 : Info *infoPtr, Settings& settings, ParticleData* particleDataPtr,
943 : Couplings* couplings) {
944 :
945 : // Reset process list, if filled in previous subrun.
946 0 : if (containerPtrs.size() > 0) {
947 0 : for (int i = 0; i < int(containerPtrs.size()); ++i)
948 0 : delete containerPtrs[i];
949 0 : containerPtrs.clear();
950 0 : }
951 : SigmaProcess* sigmaPtr;
952 :
953 : // Set up requested objects for soft QCD processes.
954 0 : bool softQCD = settings.flag("SoftQCD:all");
955 0 : bool inelastic = settings.flag("SoftQCD:inelastic");
956 0 : if (softQCD || inelastic || settings.flag("SoftQCD:nonDiffractive")) {
957 0 : sigmaPtr = new Sigma0nonDiffractive;
958 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
959 0 : }
960 0 : if (softQCD || settings.flag("SoftQCD:elastic")) {
961 0 : sigmaPtr = new Sigma0AB2AB;
962 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
963 0 : }
964 0 : if (softQCD || inelastic || settings.flag("SoftQCD:singleDiffractive")) {
965 0 : sigmaPtr = new Sigma0AB2XB;
966 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
967 0 : sigmaPtr = new Sigma0AB2AX;
968 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
969 0 : }
970 0 : if (softQCD || inelastic || settings.flag("SoftQCD:doubleDiffractive")) {
971 0 : sigmaPtr = new Sigma0AB2XX;
972 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
973 0 : }
974 0 : if (softQCD || inelastic || settings.flag("SoftQCD:centralDiffractive")) {
975 0 : sigmaPtr = new Sigma0AB2AXB;
976 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
977 0 : }
978 :
979 : // Set up requested objects for hard QCD processes.
980 0 : bool hardQCD = settings.flag("HardQCD:all");
981 0 : if (hardQCD || settings.flag("HardQCD:gg2gg")) {
982 0 : sigmaPtr = new Sigma2gg2gg;
983 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
984 0 : }
985 0 : if (hardQCD || settings.flag("HardQCD:gg2qqbar")) {
986 0 : sigmaPtr = new Sigma2gg2qqbar;
987 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
988 0 : }
989 0 : if (hardQCD || settings.flag("HardQCD:qg2qg")) {
990 0 : sigmaPtr = new Sigma2qg2qg;
991 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
992 0 : }
993 0 : if (hardQCD || settings.flag("HardQCD:qq2qq")) {
994 0 : sigmaPtr = new Sigma2qq2qq;
995 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
996 0 : }
997 0 : if (hardQCD || settings.flag("HardQCD:qqbar2gg")) {
998 0 : sigmaPtr = new Sigma2qqbar2gg;
999 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1000 0 : }
1001 0 : if (hardQCD || settings.flag("HardQCD:qqbar2qqbarNew")) {
1002 0 : sigmaPtr = new Sigma2qqbar2qqbarNew;
1003 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1004 0 : }
1005 :
1006 : // Set up requested objects for c cbar and b bbar, also hard QCD.
1007 0 : bool hardccbar = settings.flag("HardQCD:hardccbar");
1008 0 : if (hardQCD || hardccbar || settings.flag("HardQCD:gg2ccbar")) {
1009 0 : sigmaPtr = new Sigma2gg2QQbar(4, 121);
1010 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1011 0 : }
1012 0 : if (hardQCD || hardccbar || settings.flag("HardQCD:qqbar2ccbar")) {
1013 0 : sigmaPtr = new Sigma2qqbar2QQbar(4, 122);
1014 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1015 0 : }
1016 0 : bool hardbbbar = settings.flag("HardQCD:hardbbbar");
1017 0 : if (hardQCD || hardbbbar || settings.flag("HardQCD:gg2bbbar")) {
1018 0 : sigmaPtr = new Sigma2gg2QQbar(5, 123);
1019 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1020 0 : }
1021 0 : if (hardQCD || hardbbbar || settings.flag("HardQCD:qqbar2bbbar")) {
1022 0 : sigmaPtr = new Sigma2qqbar2QQbar(5, 124);
1023 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1024 0 : }
1025 :
1026 : // Set up requested objects for hard QCD 2 -> 3 processes.
1027 0 : bool hardQCD3parton = settings.flag("HardQCD:3parton");
1028 0 : if (hardQCD3parton || settings.flag("HardQCD:gg2ggg")) {
1029 0 : sigmaPtr = new Sigma3gg2ggg;
1030 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1031 0 : }
1032 0 : if (hardQCD3parton || settings.flag("HardQCD:qqbar2ggg")) {
1033 0 : sigmaPtr = new Sigma3qqbar2ggg;
1034 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1035 0 : }
1036 0 : if (hardQCD3parton || settings.flag("HardQCD:qg2qgg")) {
1037 0 : sigmaPtr = new Sigma3qg2qgg;
1038 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1039 0 : }
1040 0 : if (hardQCD3parton || settings.flag("HardQCD:qq2qqgDiff")) {
1041 0 : sigmaPtr = new Sigma3qq2qqgDiff;
1042 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1043 0 : }
1044 0 : if (hardQCD3parton || settings.flag("HardQCD:qq2qqgSame")) {
1045 0 : sigmaPtr = new Sigma3qq2qqgSame;
1046 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1047 0 : }
1048 0 : if (hardQCD3parton || settings.flag("HardQCD:qqbar2qqbargDiff")) {
1049 0 : sigmaPtr = new Sigma3qqbar2qqbargDiff;
1050 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1051 0 : }
1052 0 : if (hardQCD3parton || settings.flag("HardQCD:qqbar2qqbargSame")) {
1053 0 : sigmaPtr = new Sigma3qqbar2qqbargSame;
1054 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1055 0 : }
1056 0 : if (hardQCD3parton || settings.flag("HardQCD:gg2qqbarg")) {
1057 0 : sigmaPtr = new Sigma3gg2qqbarg;
1058 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1059 0 : }
1060 0 : if (hardQCD3parton || settings.flag("HardQCD:qg2qqqbarDiff")) {
1061 0 : sigmaPtr = new Sigma3qg2qqqbarDiff;
1062 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1063 0 : }
1064 0 : if (hardQCD3parton || settings.flag("HardQCD:qg2qqqbarSame")) {
1065 0 : sigmaPtr = new Sigma3qg2qqqbarSame;
1066 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1067 0 : }
1068 :
1069 : // Set up requested objects for prompt photon processes.
1070 0 : bool promptPhotons = settings.flag("PromptPhoton:all");
1071 0 : if (promptPhotons
1072 0 : || settings.flag("PromptPhoton:qg2qgamma")) {
1073 0 : sigmaPtr = new Sigma2qg2qgamma;
1074 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1075 0 : }
1076 0 : if (promptPhotons
1077 0 : || settings.flag("PromptPhoton:qqbar2ggamma")) {
1078 0 : sigmaPtr = new Sigma2qqbar2ggamma;
1079 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1080 0 : }
1081 0 : if (promptPhotons
1082 0 : || settings.flag("PromptPhoton:gg2ggamma")) {
1083 0 : sigmaPtr = new Sigma2gg2ggamma;
1084 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1085 0 : }
1086 0 : if (promptPhotons
1087 0 : || settings.flag("PromptPhoton:ffbar2gammagamma")) {
1088 0 : sigmaPtr = new Sigma2ffbar2gammagamma;
1089 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1090 0 : }
1091 0 : if (promptPhotons
1092 0 : || settings.flag("PromptPhoton:gg2gammagamma")) {
1093 0 : sigmaPtr = new Sigma2gg2gammagamma;
1094 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1095 0 : }
1096 :
1097 : // Set up requested objects for weak gauge boson t-channel exchange.
1098 0 : bool weakBosonExchanges = settings.flag("WeakBosonExchange:all");
1099 0 : if (weakBosonExchanges
1100 0 : || settings.flag("WeakBosonExchange:ff2ff(t:gmZ)")) {
1101 0 : sigmaPtr = new Sigma2ff2fftgmZ;
1102 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1103 0 : }
1104 0 : if (weakBosonExchanges
1105 0 : || settings.flag("WeakBosonExchange:ff2ff(t:W)")) {
1106 0 : sigmaPtr = new Sigma2ff2fftW;
1107 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1108 0 : }
1109 :
1110 : // Set up requested objects for weak gauge boson processes.
1111 0 : bool weakSingleBosons = settings.flag("WeakSingleBoson:all");
1112 0 : if (weakSingleBosons
1113 0 : || settings.flag("WeakSingleBoson:ffbar2gmZ")) {
1114 0 : sigmaPtr = new Sigma1ffbar2gmZ;
1115 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1116 0 : }
1117 0 : if (weakSingleBosons
1118 0 : || settings.flag("WeakSingleBoson:ffbar2W")) {
1119 0 : sigmaPtr = new Sigma1ffbar2W;
1120 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1121 0 : }
1122 :
1123 : // Set up requested object for s-channel gamma exchange.
1124 : // Subset of gamma*/Z0 above, intended for multiparton interactions.
1125 0 : if (settings.flag("WeakSingleBoson:ffbar2ffbar(s:gm)")) {
1126 0 : sigmaPtr = new Sigma2ffbar2ffbarsgm;
1127 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1128 0 : }
1129 :
1130 : // Set up requested object for s-channel gamma*/Z0 or W+- exchange.
1131 0 : if (settings.flag("WeakSingleBoson:ffbar2ffbar(s:gmZ)")) {
1132 0 : sigmaPtr = new Sigma2ffbar2ffbarsgmZ;
1133 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1134 0 : }
1135 0 : if (settings.flag("WeakSingleBoson:ffbar2ffbar(s:W)")) {
1136 0 : sigmaPtr = new Sigma2ffbar2ffbarsW;
1137 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1138 0 : }
1139 :
1140 : // Set up requested objects for weak gauge boson pair processes.
1141 0 : bool weakDoubleBosons = settings.flag("WeakDoubleBoson:all");
1142 0 : if (weakDoubleBosons
1143 0 : || settings.flag("WeakDoubleBoson:ffbar2gmZgmZ")) {
1144 0 : sigmaPtr = new Sigma2ffbar2gmZgmZ;
1145 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1146 0 : }
1147 0 : if (weakDoubleBosons
1148 0 : || settings.flag("WeakDoubleBoson:ffbar2ZW")) {
1149 0 : sigmaPtr = new Sigma2ffbar2ZW;
1150 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1151 0 : }
1152 0 : if (weakDoubleBosons
1153 0 : || settings.flag("WeakDoubleBoson:ffbar2WW")) {
1154 0 : sigmaPtr = new Sigma2ffbar2WW;
1155 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1156 0 : }
1157 :
1158 : // Set up requested objects for weak gauge boson + parton processes.
1159 0 : bool weakBosonAndPartons = settings.flag("WeakBosonAndParton:all");
1160 0 : if (weakBosonAndPartons
1161 0 : || settings.flag("WeakBosonAndParton:qqbar2gmZg")) {
1162 0 : sigmaPtr = new Sigma2qqbar2gmZg;
1163 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1164 0 : }
1165 0 : if (weakBosonAndPartons
1166 0 : || settings.flag("WeakBosonAndParton:qg2gmZq")) {
1167 0 : sigmaPtr = new Sigma2qg2gmZq;
1168 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1169 0 : }
1170 0 : if (weakBosonAndPartons
1171 0 : || settings.flag("WeakBosonAndParton:ffbar2gmZgm")) {
1172 0 : sigmaPtr = new Sigma2ffbar2gmZgm;
1173 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1174 0 : }
1175 0 : if (weakBosonAndPartons
1176 0 : || settings.flag("WeakBosonAndParton:fgm2gmZf")) {
1177 0 : sigmaPtr = new Sigma2fgm2gmZf;
1178 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1179 0 : }
1180 0 : if (weakBosonAndPartons
1181 0 : || settings.flag("WeakBosonAndParton:qqbar2Wg")) {
1182 0 : sigmaPtr = new Sigma2qqbar2Wg;
1183 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1184 0 : }
1185 0 : if (weakBosonAndPartons
1186 0 : || settings.flag("WeakBosonAndParton:qg2Wq")) {
1187 0 : sigmaPtr = new Sigma2qg2Wq;
1188 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1189 0 : }
1190 0 : if (weakBosonAndPartons
1191 0 : || settings.flag("WeakBosonAndParton:ffbar2Wgm")) {
1192 0 : sigmaPtr = new Sigma2ffbar2Wgm;
1193 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1194 0 : }
1195 0 : if (weakBosonAndPartons
1196 0 : || settings.flag("WeakBosonAndParton:fgm2Wf")) {
1197 0 : sigmaPtr = new Sigma2fgm2Wf;
1198 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1199 0 : }
1200 :
1201 : // Set up requested objects for photon collision processes.
1202 0 : bool photonCollisions = settings.flag("PhotonCollision:all");
1203 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2qqbar")) {
1204 0 : sigmaPtr = new Sigma2gmgm2ffbar(1, 261);
1205 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1206 0 : }
1207 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2ccbar")) {
1208 0 : sigmaPtr = new Sigma2gmgm2ffbar(4, 262);
1209 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1210 0 : }
1211 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2bbbar")) {
1212 0 : sigmaPtr = new Sigma2gmgm2ffbar(5, 263);
1213 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1214 0 : }
1215 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2ee")) {
1216 0 : sigmaPtr = new Sigma2gmgm2ffbar(11, 264);
1217 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1218 0 : }
1219 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2mumu")) {
1220 0 : sigmaPtr = new Sigma2gmgm2ffbar(13, 265);
1221 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1222 0 : }
1223 0 : if (photonCollisions || settings.flag("PhotonCollision:gmgm2tautau")) {
1224 0 : sigmaPtr = new Sigma2gmgm2ffbar(15, 266);
1225 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1226 0 : }
1227 :
1228 : // Set up requested objects for onia production.
1229 0 : charmonium = SigmaOniaSetup(infoPtr, &settings, particleDataPtr, 4);
1230 0 : bottomonium = SigmaOniaSetup(infoPtr, &settings, particleDataPtr, 5);
1231 0 : vector<SigmaProcess*> charmoniumSigmaPtrs, bottomoniumSigmaPtrs;
1232 0 : charmonium.setupSigma2gg(charmoniumSigmaPtrs);
1233 0 : charmonium.setupSigma2qg(charmoniumSigmaPtrs);
1234 0 : charmonium.setupSigma2qq(charmoniumSigmaPtrs);
1235 0 : bottomonium.setupSigma2gg(bottomoniumSigmaPtrs);
1236 0 : bottomonium.setupSigma2qg(bottomoniumSigmaPtrs);
1237 0 : bottomonium.setupSigma2qq(bottomoniumSigmaPtrs);
1238 0 : for (unsigned int i = 0; i < charmoniumSigmaPtrs.size(); ++i)
1239 0 : containerPtrs.push_back( new ProcessContainer(charmoniumSigmaPtrs[i]) );
1240 0 : for (unsigned int i = 0; i < bottomoniumSigmaPtrs.size(); ++i)
1241 0 : containerPtrs.push_back( new ProcessContainer(bottomoniumSigmaPtrs[i]) );
1242 :
1243 : // Set up requested objects for top production.
1244 0 : bool tops = settings.flag("Top:all");
1245 0 : if (tops || settings.flag("Top:gg2ttbar")) {
1246 0 : sigmaPtr = new Sigma2gg2QQbar(6, 601);
1247 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1248 : }
1249 0 : if (tops || settings.flag("Top:qqbar2ttbar")) {
1250 0 : sigmaPtr = new Sigma2qqbar2QQbar(6, 602);
1251 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1252 : }
1253 0 : if (tops || settings.flag("Top:qq2tq(t:W)")) {
1254 0 : sigmaPtr = new Sigma2qq2QqtW(6, 603);
1255 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1256 : }
1257 0 : if (tops || settings.flag("Top:ffbar2ttbar(s:gmZ)")) {
1258 0 : sigmaPtr = new Sigma2ffbar2FFbarsgmZ(6, 604);
1259 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1260 : }
1261 0 : if (tops || settings.flag("Top:ffbar2tqbar(s:W)")) {
1262 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(6, 0, 605);
1263 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1264 : }
1265 0 : if (tops || settings.flag("Top:gmgm2ttbar")) {
1266 0 : sigmaPtr = new Sigma2gmgm2ffbar(6, 606);
1267 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1268 : }
1269 :
1270 : // Set up requested objects for fourth-generation b' production
1271 0 : bool bPrimes = settings.flag("FourthBottom:all");
1272 0 : if (bPrimes || settings.flag("FourthBottom:gg2bPrimebPrimebar")) {
1273 0 : sigmaPtr = new Sigma2gg2QQbar(7, 801);
1274 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1275 : }
1276 0 : if (bPrimes || settings.flag("FourthBottom:qqbar2bPrimebPrimebar")) {
1277 0 : sigmaPtr = new Sigma2qqbar2QQbar(7, 802);
1278 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1279 : }
1280 0 : if (bPrimes || settings.flag("FourthBottom:qq2bPrimeq(t:W)")) {
1281 0 : sigmaPtr = new Sigma2qq2QqtW(7, 803);
1282 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1283 : }
1284 0 : if (bPrimes || settings.flag("FourthBottom:ffbar2bPrimebPrimebar(s:gmZ)")) {
1285 0 : sigmaPtr = new Sigma2ffbar2FFbarsgmZ(7, 804);
1286 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1287 : }
1288 0 : if (bPrimes || settings.flag("FourthBottom:ffbar2bPrimeqbar(s:W)")) {
1289 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(7, 0, 805);
1290 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1291 : }
1292 0 : if (bPrimes || settings.flag("FourthBottom:ffbar2bPrimetbar(s:W)")) {
1293 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(7, 6, 806);
1294 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1295 : }
1296 :
1297 : // Set up requested objects for fourth-generation t' production
1298 0 : bool tPrimes = settings.flag("FourthTop:all");
1299 0 : if (tPrimes || settings.flag("FourthTop:gg2tPrimetPrimebar")) {
1300 0 : sigmaPtr = new Sigma2gg2QQbar(8, 821);
1301 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1302 : }
1303 0 : if (tPrimes || settings.flag("FourthTop:qqbar2tPrimetPrimebar")) {
1304 0 : sigmaPtr = new Sigma2qqbar2QQbar(8, 822);
1305 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1306 : }
1307 0 : if (tPrimes || settings.flag("FourthTop:qq2tPrimeq(t:W)")) {
1308 0 : sigmaPtr = new Sigma2qq2QqtW(8, 823);
1309 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1310 : }
1311 0 : if (tPrimes || settings.flag("FourthTop:ffbar2tPrimetPrimebar(s:gmZ)")) {
1312 0 : sigmaPtr = new Sigma2ffbar2FFbarsgmZ(8, 824);
1313 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1314 : }
1315 0 : if (tPrimes || settings.flag("FourthTop:ffbar2tPrimeqbar(s:W)")) {
1316 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(8, 0, 825);
1317 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1318 : }
1319 :
1320 : // Set up requested objects for two different fourth-generation fermions.
1321 0 : if (bPrimes || tPrimes
1322 0 : || settings.flag("FourthPair:ffbar2tPrimebPrimebar(s:W)")) {
1323 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(8, 7, 841);
1324 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1325 : }
1326 0 : if (settings.flag("FourthPair:ffbar2tauPrimenuPrimebar(s:W)")) {
1327 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(17, 18, 842);
1328 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1329 : }
1330 :
1331 : // Flag for global choice between SM and BSM Higgses.
1332 0 : bool useBSMHiggses = settings.flag("Higgs:useBSM");
1333 :
1334 : // Set up requested objects for Standard-Model Higgs production.
1335 0 : if (!useBSMHiggses) {
1336 0 : bool HiggsesSM = settings.flag("HiggsSM:all");
1337 0 : if (HiggsesSM || settings.flag("HiggsSM:ffbar2H")) {
1338 0 : sigmaPtr = new Sigma1ffbar2H(0);
1339 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1340 : }
1341 0 : if (HiggsesSM || settings.flag("HiggsSM:gg2H")) {
1342 0 : sigmaPtr = new Sigma1gg2H(0);
1343 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1344 : }
1345 0 : if (HiggsesSM || settings.flag("HiggsSM:gmgm2H")) {
1346 0 : sigmaPtr = new Sigma1gmgm2H(0);
1347 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1348 : }
1349 0 : if (HiggsesSM || settings.flag("HiggsSM:ffbar2HZ")) {
1350 0 : sigmaPtr = new Sigma2ffbar2HZ(0);
1351 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1352 : }
1353 0 : if (HiggsesSM || settings.flag("HiggsSM:ffbar2HW")) {
1354 0 : sigmaPtr = new Sigma2ffbar2HW(0);
1355 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1356 : }
1357 0 : if (HiggsesSM || settings.flag("HiggsSM:ff2Hff(t:ZZ)")) {
1358 0 : sigmaPtr = new Sigma3ff2HfftZZ(0);
1359 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1360 : }
1361 0 : if (HiggsesSM || settings.flag("HiggsSM:ff2Hff(t:WW)")) {
1362 0 : sigmaPtr = new Sigma3ff2HfftWW(0);
1363 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1364 : }
1365 0 : if (HiggsesSM || settings.flag("HiggsSM:gg2Httbar")) {
1366 0 : sigmaPtr = new Sigma3gg2HQQbar(6,0);
1367 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1368 : }
1369 0 : if (HiggsesSM || settings.flag("HiggsSM:qqbar2Httbar")) {
1370 0 : sigmaPtr = new Sigma3qqbar2HQQbar(6,0);
1371 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1372 : }
1373 :
1374 : // Further Standard-Model Higgs processes, not included in "all".
1375 0 : if (settings.flag("HiggsSM:qg2Hq")) {
1376 0 : sigmaPtr = new Sigma2qg2Hq(4,0);
1377 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1378 0 : sigmaPtr = new Sigma2qg2Hq(5,0);
1379 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1380 : }
1381 0 : if (settings.flag("HiggsSM:gg2Hbbbar")) {
1382 0 : sigmaPtr = new Sigma3gg2HQQbar(5,0);
1383 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1384 : }
1385 0 : if (settings.flag("HiggsSM:qqbar2Hbbbar")) {
1386 0 : sigmaPtr = new Sigma3qqbar2HQQbar(5,0);
1387 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1388 : }
1389 0 : if (settings.flag("HiggsSM:gg2Hg(l:t)")) {
1390 0 : sigmaPtr = new Sigma2gg2Hglt(0);
1391 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1392 : }
1393 0 : if (settings.flag("HiggsSM:qg2Hq(l:t)")) {
1394 0 : sigmaPtr = new Sigma2qg2Hqlt(0);
1395 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1396 : }
1397 0 : if (settings.flag("HiggsSM:qqbar2Hg(l:t)")) {
1398 0 : sigmaPtr = new Sigma2qqbar2Hglt(0);
1399 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1400 : }
1401 0 : }
1402 :
1403 : // Common switch for the group of Higgs production BSM.
1404 0 : if (useBSMHiggses) {
1405 0 : bool HiggsesBSM = settings.flag("HiggsBSM:all");
1406 :
1407 : // Set up requested objects for BSM H1 production.
1408 0 : bool HiggsesH1 = settings.flag("HiggsBSM:allH1");
1409 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:ffbar2H1")) {
1410 0 : sigmaPtr = new Sigma1ffbar2H(1);
1411 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1412 : }
1413 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:gg2H1")) {
1414 0 : sigmaPtr = new Sigma1gg2H(1);
1415 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1416 : }
1417 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:gmgm2H1")) {
1418 0 : sigmaPtr = new Sigma1gmgm2H(1);
1419 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1420 : }
1421 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:ffbar2H1Z")) {
1422 0 : sigmaPtr = new Sigma2ffbar2HZ(1);
1423 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1424 : }
1425 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:ffbar2H1W")) {
1426 0 : sigmaPtr = new Sigma2ffbar2HW(1);
1427 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1428 : }
1429 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:ff2H1ff(t:ZZ)")) {
1430 0 : sigmaPtr = new Sigma3ff2HfftZZ(1);
1431 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1432 : }
1433 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:ff2H1ff(t:WW)")) {
1434 0 : sigmaPtr = new Sigma3ff2HfftWW(1);
1435 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1436 : }
1437 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:gg2H1ttbar")) {
1438 0 : sigmaPtr = new Sigma3gg2HQQbar(6,1);
1439 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1440 : }
1441 0 : if (HiggsesBSM || HiggsesH1 || settings.flag("HiggsBSM:qqbar2H1ttbar")) {
1442 0 : sigmaPtr = new Sigma3qqbar2HQQbar(6,1);
1443 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1444 : }
1445 :
1446 : // Further BSM H1 processes, not included in "all".
1447 0 : if (settings.flag("HiggsBSM:qg2H1q")) {
1448 0 : sigmaPtr = new Sigma2qg2Hq(4,1);
1449 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1450 0 : sigmaPtr = new Sigma2qg2Hq(5,1);
1451 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1452 : }
1453 0 : if (settings.flag("HiggsBSM:gg2H1bbbar")) {
1454 0 : sigmaPtr = new Sigma3gg2HQQbar(5,1);
1455 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1456 : }
1457 0 : if (settings.flag("HiggsBSM:qqbar2H1bbbar")) {
1458 0 : sigmaPtr = new Sigma3qqbar2HQQbar(5,1);
1459 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1460 : }
1461 0 : if (settings.flag("HiggsBSM:gg2H1g(l:t)")) {
1462 0 : sigmaPtr = new Sigma2gg2Hglt(1);
1463 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1464 : }
1465 0 : if (settings.flag("HiggsBSM:qg2H1q(l:t)")) {
1466 0 : sigmaPtr = new Sigma2qg2Hqlt(1);
1467 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1468 : }
1469 0 : if (settings.flag("HiggsBSM:qqbar2H1g(l:t)")) {
1470 0 : sigmaPtr = new Sigma2qqbar2Hglt(1);
1471 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1472 : }
1473 :
1474 : // Set up requested objects for BSM H2 production.
1475 0 : bool HiggsesH2 = settings.flag("HiggsBSM:allH2");
1476 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:ffbar2H2")) {
1477 0 : sigmaPtr = new Sigma1ffbar2H(2);
1478 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1479 : }
1480 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:gg2H2")) {
1481 0 : sigmaPtr = new Sigma1gg2H(2);
1482 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1483 : }
1484 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:gmgm2H2")) {
1485 0 : sigmaPtr = new Sigma1gmgm2H(2);
1486 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1487 : }
1488 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:ffbar2H2Z")) {
1489 0 : sigmaPtr = new Sigma2ffbar2HZ(2);
1490 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1491 : }
1492 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:ffbar2H2W")) {
1493 0 : sigmaPtr = new Sigma2ffbar2HW(2);
1494 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1495 : }
1496 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:ff2H2ff(t:ZZ)")) {
1497 0 : sigmaPtr = new Sigma3ff2HfftZZ(2);
1498 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1499 : }
1500 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:ff2H2ff(t:WW)")) {
1501 0 : sigmaPtr = new Sigma3ff2HfftWW(2);
1502 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1503 : }
1504 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:gg2H2ttbar")) {
1505 0 : sigmaPtr = new Sigma3gg2HQQbar(6,2);
1506 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1507 : }
1508 0 : if (HiggsesBSM || HiggsesH2 || settings.flag("HiggsBSM:qqbar2H2ttbar")) {
1509 0 : sigmaPtr = new Sigma3qqbar2HQQbar(6,2);
1510 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1511 : }
1512 :
1513 : // Further BSM H2 processes, not included in "all".
1514 0 : if (settings.flag("HiggsBSM:qg2H2q")) {
1515 0 : sigmaPtr = new Sigma2qg2Hq(4,2);
1516 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1517 0 : sigmaPtr = new Sigma2qg2Hq(5,2);
1518 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1519 : }
1520 0 : if (settings.flag("HiggsBSM:gg2H2bbbar")) {
1521 0 : sigmaPtr = new Sigma3gg2HQQbar(5,2);
1522 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1523 : }
1524 0 : if (settings.flag("HiggsBSM:qqbar2H2bbbar")) {
1525 0 : sigmaPtr = new Sigma3qqbar2HQQbar(5,2);
1526 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1527 : }
1528 0 : if (settings.flag("HiggsBSM:gg2H2g(l:t)")) {
1529 0 : sigmaPtr = new Sigma2gg2Hglt(2);
1530 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1531 : }
1532 0 : if (settings.flag("HiggsBSM:qg2H2q(l:t)")) {
1533 0 : sigmaPtr = new Sigma2qg2Hqlt(2);
1534 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1535 : }
1536 0 : if (settings.flag("HiggsBSM:qqbar2H2g(l:t)")) {
1537 0 : sigmaPtr = new Sigma2qqbar2Hglt(2);
1538 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1539 : }
1540 :
1541 : // Set up requested objects for BSM A3 production.
1542 0 : bool HiggsesA3 = settings.flag("HiggsBSM:allA3");
1543 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:ffbar2A3")) {
1544 0 : sigmaPtr = new Sigma1ffbar2H(3);
1545 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1546 : }
1547 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:gg2A3")) {
1548 0 : sigmaPtr = new Sigma1gg2H(3);
1549 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1550 : }
1551 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:gmgm2A3")) {
1552 0 : sigmaPtr = new Sigma1gmgm2H(3);
1553 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1554 : }
1555 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:ffbar2A3Z")) {
1556 0 : sigmaPtr = new Sigma2ffbar2HZ(3);
1557 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1558 : }
1559 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:ffbar2A3W")) {
1560 0 : sigmaPtr = new Sigma2ffbar2HW(3);
1561 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1562 : }
1563 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:ff2A3ff(t:ZZ)")) {
1564 0 : sigmaPtr = new Sigma3ff2HfftZZ(3);
1565 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1566 : }
1567 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:ff2A3ff(t:WW)")) {
1568 0 : sigmaPtr = new Sigma3ff2HfftWW(3);
1569 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1570 : }
1571 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:gg2A3ttbar")) {
1572 0 : sigmaPtr = new Sigma3gg2HQQbar(6,3);
1573 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1574 : }
1575 0 : if (HiggsesBSM || HiggsesA3 || settings.flag("HiggsBSM:qqbar2A3ttbar")) {
1576 0 : sigmaPtr = new Sigma3qqbar2HQQbar(6,3);
1577 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1578 : }
1579 :
1580 : // Further BSM A3 processes, not included in "all".
1581 0 : if (settings.flag("HiggsBSM:qg2A3q")) {
1582 0 : sigmaPtr = new Sigma2qg2Hq(4,3);
1583 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1584 0 : sigmaPtr = new Sigma2qg2Hq(5,3);
1585 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1586 : }
1587 0 : if (settings.flag("HiggsBSM:gg2A3bbbar")) {
1588 0 : sigmaPtr = new Sigma3gg2HQQbar(5,3);
1589 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1590 : }
1591 0 : if (settings.flag("HiggsBSM:qqbar2A3bbbar")) {
1592 0 : sigmaPtr = new Sigma3qqbar2HQQbar(5,3);
1593 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1594 : }
1595 0 : if (settings.flag("HiggsBSM:gg2A3g(l:t)")) {
1596 0 : sigmaPtr = new Sigma2gg2Hglt(3);
1597 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1598 : }
1599 0 : if (settings.flag("HiggsBSM:qg2A3q(l:t)")) {
1600 0 : sigmaPtr = new Sigma2qg2Hqlt(3);
1601 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1602 : }
1603 0 : if (settings.flag("HiggsBSM:qqbar2A3g(l:t)")) {
1604 0 : sigmaPtr = new Sigma2qqbar2Hglt(3);
1605 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1606 : }
1607 :
1608 : // Set up requested objects for Charged Higgs production
1609 0 : bool HiggsesChg = settings.flag("HiggsBSM:allH+-");
1610 0 : if (HiggsesBSM || HiggsesChg || settings.flag("HiggsBSM:ffbar2H+-")) {
1611 0 : sigmaPtr = new Sigma1ffbar2Hchg;
1612 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1613 : }
1614 0 : if (HiggsesBSM || HiggsesChg || settings.flag("HiggsBSM:bg2H+-t")) {
1615 0 : sigmaPtr = new Sigma2qg2Hchgq(6, 1062, "b g -> H+- t");
1616 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1617 : }
1618 :
1619 : // Set up requested objects for Higgs pair-production
1620 0 : bool HiggsesPairs = settings.flag("HiggsBSM:allHpair");
1621 0 : if (HiggsesBSM || HiggsesPairs || settings.flag("HiggsBSM:ffbar2A3H1")) {
1622 0 : sigmaPtr = new Sigma2ffbar2A3H12(1);
1623 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1624 : }
1625 0 : if (HiggsesBSM || HiggsesPairs || settings.flag("HiggsBSM:ffbar2A3H2")) {
1626 0 : sigmaPtr = new Sigma2ffbar2A3H12(2);
1627 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1628 : }
1629 0 : if (HiggsesBSM || HiggsesPairs || settings.flag("HiggsBSM:ffbar2H+-H1")) {
1630 0 : sigmaPtr = new Sigma2ffbar2HchgH12(1);
1631 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1632 : }
1633 0 : if (HiggsesBSM || HiggsesPairs || settings.flag("HiggsBSM:ffbar2H+-H2")) {
1634 0 : sigmaPtr = new Sigma2ffbar2HchgH12(2);
1635 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1636 : }
1637 0 : if (HiggsesBSM || HiggsesPairs || settings.flag("HiggsBSM:ffbar2H+H-")) {
1638 0 : sigmaPtr = new Sigma2ffbar2HposHneg();
1639 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1640 : }
1641 0 : }
1642 :
1643 : // Set up requested objects for SUSY pair processes.
1644 0 : if (couplings->isSUSY) {
1645 0 : CoupSUSY* coupSUSY = (CoupSUSY *) couplings;
1646 :
1647 0 : bool SUSYs = settings.flag("SUSY:all");
1648 0 : bool nmssm = settings.flag("SLHA:NMSSM");
1649 :
1650 : // Preselected SUSY codes.
1651 0 : setupIdVecs( settings);
1652 :
1653 : // MSSM: 4 neutralinos
1654 : int nNeut = 4;
1655 0 : if (nmssm) nNeut = 5;
1656 :
1657 : // Gluino-gluino
1658 0 : if (SUSYs || settings.flag("SUSY:gg2gluinogluino")) {
1659 : // Skip if outgoing codes not asked for
1660 0 : if (allowIdVals( 1000021, 1000021)) {
1661 0 : sigmaPtr = new Sigma2gg2gluinogluino();
1662 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1663 : }
1664 : }
1665 0 : if (SUSYs || settings.flag("SUSY:qqbar2gluinogluino")) {
1666 : // Skip if outgoing codes not asked for
1667 0 : if (allowIdVals( 1000021, 1000021)) {
1668 0 : sigmaPtr = new Sigma2qqbar2gluinogluino();
1669 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1670 : }
1671 : }
1672 :
1673 : // Gluino-squark
1674 0 : if (SUSYs || settings.flag("SUSY:qg2squarkgluino")) {
1675 : int iproc = 1202;
1676 0 : for (int idx = 1; idx <= 6; ++idx) {
1677 0 : for (int iso = 1; iso <= 2; ++iso) {
1678 0 : iproc++;
1679 0 : int id3 = iso + ((idx <= 3)
1680 0 : ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1681 : int id4 = 1000021;
1682 : // Skip if outgoing codes not asked for
1683 0 : if (!allowIdVals( id3, id4)) continue;
1684 0 : sigmaPtr = new Sigma2qg2squarkgluino(id3,iproc);
1685 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1686 0 : }
1687 : }
1688 0 : }
1689 :
1690 : // Squark-antisquark (gg initiated)
1691 0 : if (SUSYs || settings.flag("SUSY:gg2squarkantisquark")) {
1692 : int iproc = 1214;
1693 0 : for (int idx = 1; idx <= 6; ++idx) {
1694 0 : for (int iso = 1; iso <= 2; ++iso) {
1695 0 : iproc++;
1696 0 : int id = iso + ((idx <= 3)
1697 0 : ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1698 : // Skip if outgoing codes not asked for
1699 0 : if (!allowIdVals( id, id)) continue;
1700 0 : sigmaPtr = new Sigma2gg2squarkantisquark(id,iproc);
1701 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1702 0 : }
1703 : }
1704 0 : }
1705 :
1706 : // Squark-antisquark (qqbar initiated)
1707 0 : if (SUSYs || settings.flag("SUSY:qqbar2squarkantisquark")) {
1708 : int iproc = 1230;
1709 0 : for (int idx = 1; idx <= 6; ++idx) {
1710 0 : for (int iso = 1; iso <= 2; ++iso) {
1711 0 : for (int jso = iso; jso >= 1; --jso) {
1712 0 : for (int jdx = 1; jdx <= 6; ++jdx) {
1713 0 : if (iso == jso && jdx < idx) continue;
1714 0 : int id1 = iso + ((idx <= 3) ? 1000000+2*(idx-1)
1715 0 : : 2000000+2*(idx-4));
1716 0 : int id2 = jso + ((jdx <= 3) ? 1000000+2*(jdx-1)
1717 0 : : 2000000+2*(jdx-4));
1718 : // Update process number counter (for ~q~q, +2 if not self-conj)
1719 : //if (iproc == 1302) iproc=1310;
1720 0 : iproc++;
1721 0 : if (iso == jso && id1 != id2) iproc++;
1722 : // Skip if outgoing codes not asked for
1723 0 : if (!allowIdVals( id1, id2)) continue;
1724 0 : if (iso == jso && id1 != id2) {
1725 0 : sigmaPtr = new Sigma2qqbar2squarkantisquark(id1,-id2,iproc-1);
1726 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1727 0 : sigmaPtr = new Sigma2qqbar2squarkantisquark(id2,-id1,iproc);
1728 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1729 : } else {
1730 0 : sigmaPtr = new Sigma2qqbar2squarkantisquark(id1,-id2,iproc);
1731 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1732 : }
1733 0 : }
1734 : }
1735 : }
1736 : }
1737 0 : }
1738 :
1739 : // Squark-squark
1740 0 : if (SUSYs || settings.flag("SUSY:qq2squarksquark")) {
1741 : int iproc = 1350;
1742 0 : for (int idx = 1; idx <= 6; ++idx) {
1743 0 : for (int iso = 1; iso <= 2; ++iso) {
1744 0 : for (int jso = iso; jso >= 1; jso--) {
1745 0 : for (int jdx = 1; jdx <= 6; ++jdx) {
1746 0 : if (iso == jso && jdx < idx) continue;
1747 0 : iproc++;
1748 0 : int id1 = iso + ((idx <= 3)
1749 0 : ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1750 0 : int id2 = jso + ((jdx <= 3)
1751 0 : ? 1000000+2*(jdx-1) : 2000000+2*(jdx-4));
1752 : // Skip if outgoing codes not asked for
1753 0 : if (!allowIdVals( id1, id2)) continue;
1754 0 : sigmaPtr = new Sigma2qq2squarksquark(id1,id2,iproc);
1755 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1756 0 : }
1757 : }
1758 : }
1759 : }
1760 0 : }
1761 :
1762 : // Neutralino + squark
1763 0 : if (SUSYs || settings.flag("SUSY:qg2chi0squark")) {
1764 : int iproc = 1430;
1765 0 : for (int iNeut= 1; iNeut <= nNeut; iNeut++) {
1766 0 : for (int idx = 1; idx <= 6; idx++) {
1767 : bool isUp = false;
1768 0 : for (int iso = 1; iso <= 2; iso++) {
1769 0 : if (iso == 2) isUp = true;
1770 0 : iproc++;
1771 0 : int id3 = coupSUSY->idNeut(iNeut);
1772 0 : int id4 = iso + ((idx <= 3)
1773 0 : ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1774 : // Skip if outgoing codes not asked for
1775 0 : if (!allowIdVals( id3, id4)) continue;
1776 0 : sigmaPtr = new Sigma2qg2chi0squark(iNeut,idx,isUp,iproc);
1777 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1778 0 : }
1779 : }
1780 : }
1781 0 : }
1782 :
1783 : // Chargino + squark
1784 0 : if (SUSYs || settings.flag("SUSY:qg2chi+-squark")) {
1785 : int iproc = 1490;
1786 0 : for (int iChar = 1; iChar <= 2; iChar++) {
1787 0 : for (int idx = 1; idx <= 6; idx++) {
1788 : bool isUp = false;
1789 0 : for (int iso = 1; iso <= 2; iso++) {
1790 0 : if (iso == 2) isUp = true;
1791 0 : iproc++;
1792 0 : int id3 = coupSUSY->idChar(iChar);
1793 0 : int id4 = iso + ((idx <= 3)
1794 0 : ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1795 : // Skip if outgoing codes not asked for
1796 0 : if (!allowIdVals( id3, id4)) continue;
1797 0 : sigmaPtr = new Sigma2qg2charsquark(iChar,idx,isUp,iproc);
1798 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1799 0 : }
1800 : }
1801 : }
1802 0 : }
1803 :
1804 : // Neutralino pairs
1805 0 : if (SUSYs || settings.flag("SUSY:qqbar2chi0chi0")) {
1806 : int iproc = 1550;
1807 0 : for (int iNeut2 = 1; iNeut2 <= nNeut; iNeut2++) {
1808 0 : for (int iNeut1 = 1; iNeut1 <= iNeut2; iNeut1++) {
1809 0 : iproc++;
1810 : // Skip if outgoing codes not asked for
1811 0 : if (!allowIdVals( coupSUSY->idNeut(iNeut1),
1812 0 : coupSUSY->idNeut(iNeut2) ) ) continue;
1813 0 : sigmaPtr = new Sigma2qqbar2chi0chi0(iNeut1, iNeut2,iproc);
1814 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1815 : }
1816 : }
1817 0 : }
1818 :
1819 : // Neutralino-Chargino
1820 0 : if (SUSYs || settings.flag("SUSY:qqbar2chi+-chi0")) {
1821 : int iproc = 1570;
1822 0 : for (int iNeut = 1; iNeut <= nNeut; iNeut++) {
1823 0 : for (int iChar = 1; iChar <= 2; ++iChar) {
1824 0 : iproc += 2;
1825 : // Skip if outgoing codes not asked for
1826 0 : if (!allowIdVals( coupSUSY->idNeut(iNeut),
1827 0 : coupSUSY->idChar(iChar) ) ) continue;
1828 0 : sigmaPtr = new Sigma2qqbar2charchi0( iChar, iNeut, iproc-1);
1829 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1830 0 : sigmaPtr = new Sigma2qqbar2charchi0(-iChar, iNeut, iproc);
1831 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1832 : }
1833 : }
1834 0 : }
1835 :
1836 : // Chargino-Chargino
1837 0 : if (SUSYs || settings.flag("SUSY:qqbar2chi+chi-")) {
1838 : int iproc = 1590;
1839 0 : for (int i = 1; i <= 2; ++i) {
1840 0 : for (int j = 1; j <= 2; ++j) {
1841 0 : iproc++;
1842 : // Skip if outgoing codes not asked for
1843 0 : if (!allowIdVals( coupSUSY->idChar(i),
1844 0 : coupSUSY->idChar(j) ) ) continue;
1845 0 : sigmaPtr = new Sigma2qqbar2charchar( i,-j, iproc);
1846 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1847 : }
1848 : }
1849 0 : }
1850 :
1851 : // RPV squark production
1852 0 : if(SUSYs || settings.flag("SUSY:qq2antisquark")) {
1853 0 : for (int idx = 1; idx <= 6; ++idx) {
1854 0 : for (int iso = 1; iso <= 2; ++iso) {
1855 0 : int id1 = iso + ((idx <= 3) ? 1000000+2*(idx-1) : 2000000+2*(idx-4));
1856 : // Skip if outgoing code not asked for
1857 0 : if (!allowIdVals( id1, 0)) continue;
1858 0 : sigmaPtr = new Sigma1qq2antisquark(id1);
1859 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1860 0 : }
1861 : }
1862 0 : }
1863 :
1864 : // Neutralino-gluino
1865 0 : if (SUSYs || settings.flag("SUSY:qqbar2chi0gluino")) {
1866 : int iproc = 1600;
1867 0 : for (int iNeut = 1; iNeut <= nNeut; iNeut++) {
1868 0 : iproc++;
1869 : // Skip if outgoing codes not asked for
1870 0 : if (!allowIdVals( coupSUSY->idNeut(iNeut), 1000021)) continue;
1871 0 : sigmaPtr = new Sigma2qqbar2chi0gluino(iNeut, iproc);
1872 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1873 : }
1874 0 : }
1875 :
1876 : // Chargino-Gluino
1877 0 : if (SUSYs || settings.flag("SUSY:qqbar2chi+-gluino")) {
1878 : int iproc = 1620;
1879 0 : for (int iChar = 1; iChar <= 2; ++iChar) {
1880 0 : iproc ++;
1881 : // Skip if outgoing codes not asked for
1882 0 : if (!allowIdVals( coupSUSY->idChar(iChar), 1000021)) continue;
1883 0 : sigmaPtr = new Sigma2qqbar2chargluino( iChar, iproc);
1884 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1885 : }
1886 0 : }
1887 :
1888 : // Slepton-antislepton (qqbar initiated); Currently no RH sneutrinos
1889 0 : if (SUSYs || settings.flag("SUSY:qqbar2sleptonantislepton")) {
1890 : int iproc = 1650;
1891 0 : for (int idx = 1; idx <= 6; ++idx) {
1892 0 : for (int iso = 1; iso <= 2; ++iso) {
1893 0 : for (int jso = iso; jso >= 1; --jso) {
1894 0 : for (int jdx = 1; jdx <= 6; ++jdx) {
1895 0 : if (iso == jso && jdx < idx) continue;
1896 0 : int id1 = iso + ((idx <= 3) ? 1000010+2*(idx-1)
1897 0 : : 2000010+2*(idx-4));
1898 0 : int id2 = jso + ((jdx <= 3) ? 1000010+2*(jdx-1)
1899 0 : : 2000010+2*(jdx-4));
1900 : // Update process number counter
1901 0 : iproc++;
1902 0 : if (iso == jso && id1 != id2) iproc++;
1903 : // Exclude RH neutrinos from allowed final states
1904 0 : if (abs(id1) >= 2000012 && id1 % 2 == 0) continue;
1905 0 : if (abs(id2) >= 2000012 && id2 % 2 == 0) continue;
1906 : // Skip if outgoing codes not asked for
1907 0 : if (!allowIdVals( id1, id2)) continue;
1908 0 : if (iso == jso && id1 != id2) {
1909 : sigmaPtr
1910 0 : = new Sigma2qqbar2sleptonantislepton(id1,-id2,iproc-1);
1911 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1912 0 : sigmaPtr = new Sigma2qqbar2sleptonantislepton(id2,-id1,iproc);
1913 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1914 : } else {
1915 0 : sigmaPtr = new Sigma2qqbar2sleptonantislepton(id1,-id2,iproc);
1916 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1917 : }
1918 0 : }
1919 : }
1920 : }
1921 : }
1922 0 : }
1923 :
1924 0 : } // End of SUSY processes.
1925 :
1926 : // Set up requested objects for New-Gauge-Boson processes.
1927 0 : if (settings.flag("NewGaugeBoson:ffbar2gmZZprime")) {
1928 0 : sigmaPtr = new Sigma1ffbar2gmZZprime();
1929 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1930 : }
1931 0 : if (settings.flag("NewGaugeBoson:ffbar2Wprime")) {
1932 0 : sigmaPtr = new Sigma1ffbar2Wprime();
1933 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1934 : }
1935 0 : if (settings.flag("NewGaugeBoson:ffbar2R0")) {
1936 0 : sigmaPtr = new Sigma1ffbar2Rhorizontal();
1937 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1938 : }
1939 :
1940 : // Set up requested objects for Left-Right-Symmetry processes.
1941 0 : bool leftrights = settings.flag("LeftRightSymmmetry:all");
1942 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ffbar2ZR")) {
1943 0 : sigmaPtr = new Sigma1ffbar2ZRight();
1944 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1945 : }
1946 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ffbar2WR")) {
1947 0 : sigmaPtr = new Sigma1ffbar2WRight();
1948 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1949 : }
1950 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ll2HL")) {
1951 0 : sigmaPtr = new Sigma1ll2Hchgchg(1);
1952 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1953 : }
1954 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HLe")) {
1955 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(1, 11);
1956 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1957 : }
1958 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HLmu")) {
1959 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(1, 13);
1960 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1961 : }
1962 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HLtau")) {
1963 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(1, 15);
1964 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1965 : }
1966 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ff2HLff")) {
1967 0 : sigmaPtr = new Sigma3ff2HchgchgfftWW(1);
1968 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1969 : }
1970 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ffbar2HLHL")) {
1971 0 : sigmaPtr = new Sigma2ffbar2HchgchgHchgchg(1);
1972 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1973 : }
1974 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ll2HR")) {
1975 0 : sigmaPtr = new Sigma1ll2Hchgchg(2);
1976 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1977 : }
1978 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HRe")) {
1979 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(2, 11);
1980 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1981 : }
1982 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HRmu")) {
1983 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(2, 13);
1984 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1985 : }
1986 0 : if (leftrights || settings.flag("LeftRightSymmmetry:lgm2HRtau")) {
1987 0 : sigmaPtr = new Sigma2lgm2Hchgchgl(2, 15);
1988 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1989 : }
1990 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ff2HRff")) {
1991 0 : sigmaPtr = new Sigma3ff2HchgchgfftWW(2);
1992 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1993 : }
1994 0 : if (leftrights || settings.flag("LeftRightSymmmetry:ffbar2HRHR")) {
1995 0 : sigmaPtr = new Sigma2ffbar2HchgchgHchgchg(2);
1996 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
1997 : }
1998 :
1999 : // Set up requested objects for leptoquark LQ processes.
2000 0 : bool leptoquarks = settings.flag("LeptoQuark:all");
2001 0 : if (leptoquarks || settings.flag("LeptoQuark:ql2LQ")) {
2002 0 : sigmaPtr = new Sigma1ql2LeptoQuark;
2003 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2004 : }
2005 0 : if (leptoquarks || settings.flag("LeptoQuark:qg2LQl")) {
2006 0 : sigmaPtr = new Sigma2qg2LeptoQuarkl;
2007 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2008 : }
2009 0 : if (leptoquarks || settings.flag("LeptoQuark:gg2LQLQbar")) {
2010 0 : sigmaPtr = new Sigma2gg2LQLQbar;
2011 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2012 : }
2013 0 : if (leptoquarks || settings.flag("LeptoQuark:qqbar2LQLQbar")) {
2014 0 : sigmaPtr = new Sigma2qqbar2LQLQbar;
2015 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2016 : }
2017 :
2018 : // Set up requested objects for excited-fermion processes.
2019 0 : bool excitedfermions = settings.flag("ExcitedFermion:all");
2020 0 : if (excitedfermions || settings.flag("ExcitedFermion:dg2dStar")) {
2021 0 : sigmaPtr = new Sigma1qg2qStar(1);
2022 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2023 : }
2024 0 : if (excitedfermions || settings.flag("ExcitedFermion:ug2uStar")) {
2025 0 : sigmaPtr = new Sigma1qg2qStar(2);
2026 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2027 : }
2028 0 : if (excitedfermions || settings.flag("ExcitedFermion:sg2sStar")) {
2029 0 : sigmaPtr = new Sigma1qg2qStar(3);
2030 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2031 : }
2032 0 : if (excitedfermions || settings.flag("ExcitedFermion:cg2cStar")) {
2033 0 : sigmaPtr = new Sigma1qg2qStar(4);
2034 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2035 : }
2036 0 : if (excitedfermions || settings.flag("ExcitedFermion:bg2bStar")) {
2037 0 : sigmaPtr = new Sigma1qg2qStar(5);
2038 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2039 : }
2040 0 : if (excitedfermions || settings.flag("ExcitedFermion:egm2eStar")) {
2041 0 : sigmaPtr = new Sigma1lgm2lStar(11);
2042 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2043 : }
2044 0 : if (excitedfermions || settings.flag("ExcitedFermion:mugm2muStar")) {
2045 0 : sigmaPtr = new Sigma1lgm2lStar(13);
2046 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2047 : }
2048 0 : if (excitedfermions || settings.flag("ExcitedFermion:taugm2tauStar")) {
2049 0 : sigmaPtr = new Sigma1lgm2lStar(15);
2050 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2051 : }
2052 0 : if (excitedfermions || settings.flag("ExcitedFermion:qq2dStarq")) {
2053 0 : sigmaPtr = new Sigma2qq2qStarq(1);
2054 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2055 : }
2056 0 : if (excitedfermions || settings.flag("ExcitedFermion:qq2uStarq")) {
2057 0 : sigmaPtr = new Sigma2qq2qStarq(2);
2058 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2059 : }
2060 0 : if (excitedfermions || settings.flag("ExcitedFermion:qq2sStarq")) {
2061 0 : sigmaPtr = new Sigma2qq2qStarq(3);
2062 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2063 : }
2064 0 : if (excitedfermions || settings.flag("ExcitedFermion:qq2cStarq")) {
2065 0 : sigmaPtr = new Sigma2qq2qStarq(4);
2066 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2067 : }
2068 0 : if (excitedfermions || settings.flag("ExcitedFermion:qq2bStarq")) {
2069 0 : sigmaPtr = new Sigma2qq2qStarq(5);
2070 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2071 : }
2072 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2eStare")) {
2073 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(11);
2074 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2075 : }
2076 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2nueStarnue")) {
2077 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(12);
2078 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2079 : }
2080 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2muStarmu")) {
2081 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(13);
2082 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2083 : }
2084 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2numuStarnumu")) {
2085 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(14);
2086 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2087 : }
2088 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2tauStartau")) {
2089 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(15);
2090 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2091 : }
2092 0 : if (excitedfermions
2093 0 : || settings.flag("ExcitedFermion:qqbar2nutauStarnutau")) {
2094 0 : sigmaPtr = new Sigma2qqbar2lStarlbar(16);
2095 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2096 : }
2097 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2eStareStar")) {
2098 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(11);
2099 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2100 : }
2101 0 : if (excitedfermions
2102 0 : || settings.flag("ExcitedFermion:qqbar2nueStarnueStar")) {
2103 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(12);
2104 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2105 : }
2106 0 : if (excitedfermions || settings.flag("ExcitedFermion:qqbar2muStarmuStar")) {
2107 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(13);
2108 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2109 : }
2110 0 : if (excitedfermions
2111 0 : || settings.flag("ExcitedFermion:qqbar2numuStarnumuStar")) {
2112 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(14);
2113 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2114 : }
2115 0 : if (excitedfermions
2116 0 : || settings.flag("ExcitedFermion:qqbar2tauStartauStar")) {
2117 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(15);
2118 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2119 : }
2120 0 : if (excitedfermions
2121 0 : || settings.flag("ExcitedFermion:qqbar2nutauStarnutauStar")) {
2122 0 : sigmaPtr = new Sigma2qqbar2lStarlStarBar(16);
2123 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2124 : }
2125 :
2126 : // Set up requested objects for contact interaction processes.
2127 0 : if (settings.flag("ContactInteractions:QCqq2qq")) {
2128 0 : sigmaPtr = new Sigma2QCqq2qq();
2129 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2130 : }
2131 0 : if (settings.flag("ContactInteractions:QCqqbar2qqbar")) {
2132 0 : sigmaPtr = new Sigma2QCqqbar2qqbar();
2133 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2134 : }
2135 0 : if (settings.flag("ContactInteractions:QCffbar2eebar")) {
2136 0 : sigmaPtr = new Sigma2QCffbar2llbar(11, 4003);
2137 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2138 : }
2139 0 : if (settings.flag("ContactInteractions:QCffbar2mumubar")) {
2140 0 : sigmaPtr = new Sigma2QCffbar2llbar(13, 4004);
2141 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2142 : }
2143 0 : if (settings.flag("ContactInteractions:QCffbar2tautaubar")) {
2144 0 : sigmaPtr = new Sigma2QCffbar2llbar(15, 4005);
2145 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2146 : }
2147 :
2148 : // Set spin of particles in the Hidden Valley scenario.
2149 0 : int spinFv = settings.mode("HiddenValley:spinFv");
2150 0 : for (int i = 1; i < 7; ++i) {
2151 0 : if (particleDataPtr->spinType( 4900000 + i) != spinFv + 1)
2152 0 : particleDataPtr->spinType( 4900000 + i, spinFv + 1);
2153 0 : if (particleDataPtr->spinType( 4900010 + i) != spinFv + 1)
2154 0 : particleDataPtr->spinType( 4900010 + i, spinFv + 1);
2155 : }
2156 0 : if (spinFv != 1) {
2157 0 : if (particleDataPtr->spinType( 4900101) != 2)
2158 0 : particleDataPtr->spinType( 4900101, 2);
2159 : } else {
2160 0 : int spinqv = settings.mode("HiddenValley:spinqv");
2161 0 : if (particleDataPtr->spinType( 4900101) != 2 * spinqv + 1)
2162 0 : particleDataPtr->spinType( 4900101, 2 * spinqv + 1);
2163 : }
2164 :
2165 : // Set up requested objects for HiddenValley processes.
2166 0 : bool hiddenvalleys = settings.flag("HiddenValley:all");
2167 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2DvDvbar")) {
2168 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900001, 4901, spinFv,
2169 0 : "g g -> Dv Dvbar");
2170 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2171 : }
2172 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2UvUvbar")) {
2173 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900002, 4902, spinFv,
2174 0 : "g g -> Uv Uvbar");
2175 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2176 : }
2177 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2SvSvbar")) {
2178 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900003, 4903, spinFv,
2179 0 : "g g -> Sv Svbar");
2180 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2181 : }
2182 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2CvCvbar")) {
2183 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900004, 4904, spinFv,
2184 0 : "g g -> Cv Cvbar");
2185 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2186 : }
2187 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2BvBvbar")) {
2188 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900005, 4905, spinFv,
2189 0 : "g g -> Bv Bvbar");
2190 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2191 : }
2192 0 : if (hiddenvalleys || settings.flag("HiddenValley:gg2TvTvbar")) {
2193 0 : sigmaPtr = new Sigma2gg2qGqGbar( 4900006, 4906, spinFv,
2194 0 : "g g -> Tv Tvbar");
2195 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2196 : }
2197 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2DvDvbar")) {
2198 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900001, 4911, spinFv,
2199 0 : "q qbar -> Dv Dvbar");
2200 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2201 : }
2202 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2UvUvbar")) {
2203 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900002, 4912, spinFv,
2204 0 : "q qbar -> Uv Uvbar");
2205 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2206 : }
2207 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2SvSvbar")) {
2208 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900003, 4913, spinFv,
2209 0 : "q qbar -> Sv Svbar");
2210 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2211 : }
2212 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2CvCvbar")) {
2213 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900004, 4914, spinFv,
2214 0 : "q qbar -> Cv Cvbar");
2215 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2216 : }
2217 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2BvBvbar")) {
2218 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900005, 4915, spinFv,
2219 0 : "q qbar -> Bv Bvbar");
2220 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2221 : }
2222 0 : if (hiddenvalleys || settings.flag("HiddenValley:qqbar2TvTvbar")) {
2223 0 : sigmaPtr = new Sigma2qqbar2qGqGbar( 4900006, 4916, spinFv,
2224 0 : "q qbar -> Tv Tvbar");
2225 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2226 : }
2227 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2DvDvbar")) {
2228 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900001, 4921, spinFv,
2229 0 : "f fbar -> Dv Dvbar");
2230 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2231 : }
2232 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2UvUvbar")) {
2233 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900002, 4922, spinFv,
2234 0 : "f fbar -> Uv Uvbar");
2235 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2236 : }
2237 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2SvSvbar")) {
2238 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900003, 4923, spinFv,
2239 0 : "f fbar -> Sv Svbar");
2240 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2241 : }
2242 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2CvCvbar")) {
2243 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900004, 4924, spinFv,
2244 0 : "f fbar -> Cv Cvbar");
2245 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2246 : }
2247 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2BvBvbar")) {
2248 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900005, 4925, spinFv,
2249 0 : "f fbar -> Bv Bvbar");
2250 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2251 : }
2252 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2TvTvbar")) {
2253 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900006, 4926, spinFv,
2254 0 : "f fbar -> Tv Tvbar");
2255 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2256 : }
2257 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2EvEvbar")) {
2258 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900011, 4931, spinFv,
2259 0 : "f fbar -> Ev Evbar");
2260 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2261 : }
2262 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2nuEvnuEvbar")) {
2263 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900012, 4932, spinFv,
2264 0 : "f fbar -> nuEv nuEvbar");
2265 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2266 : }
2267 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2MUvMUvbar")) {
2268 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900013, 4933, spinFv,
2269 0 : "f fbar -> MUv MUvbar");
2270 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2271 : }
2272 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2nuMUvnuMUvbar")) {
2273 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900014, 4934, spinFv,
2274 0 : "f fbar -> nuMUv nuMUvbar");
2275 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2276 : }
2277 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2TAUvTAUvbar")) {
2278 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900015, 4935, spinFv,
2279 0 : "f fbar -> TAUv TAUvbar");
2280 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2281 : }
2282 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2nuTAUvnuTAUvbar")) {
2283 0 : sigmaPtr = new Sigma2ffbar2fGfGbar( 4900016, 4936, spinFv,
2284 0 : "f fbar -> nuTAUv nuTAUvbar");
2285 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2286 : }
2287 0 : if (hiddenvalleys || settings.flag("HiddenValley:ffbar2Zv")) {
2288 0 : sigmaPtr = new Sigma1ffbar2Zv();
2289 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2290 : }
2291 :
2292 : // Set up requested objects for RS extra-dimensional G* processes.
2293 0 : bool extraDimGstars = settings.flag("ExtraDimensionsG*:all");
2294 0 : if (extraDimGstars || settings.flag("ExtraDimensionsG*:gg2G*")) {
2295 0 : sigmaPtr = new Sigma1gg2GravitonStar;
2296 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2297 : }
2298 0 : if (extraDimGstars || settings.flag("ExtraDimensionsG*:ffbar2G*")) {
2299 0 : sigmaPtr = new Sigma1ffbar2GravitonStar;
2300 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2301 : }
2302 0 : if (settings.flag("ExtraDimensionsG*:gg2G*g")) {
2303 0 : sigmaPtr = new Sigma2gg2GravitonStarg;
2304 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2305 : }
2306 0 : if (settings.flag("ExtraDimensionsG*:qg2G*q")) {
2307 0 : sigmaPtr = new Sigma2qg2GravitonStarq;
2308 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2309 : }
2310 0 : if (settings.flag("ExtraDimensionsG*:qqbar2G*g")) {
2311 0 : sigmaPtr = new Sigma2qqbar2GravitonStarg;
2312 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2313 : }
2314 :
2315 : // Set up requested objects for RS extra-dimensional KKgluon processes.
2316 0 : if (settings.flag("ExtraDimensionsG*:qqbar2KKgluon*")) {
2317 0 : sigmaPtr = new Sigma1qqbar2KKgluonStar;
2318 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2319 : }
2320 :
2321 : // NOAM: Set up requested objects for TEV extra-dimensional processes.
2322 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2ddbar")) {
2323 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(1, 5061);
2324 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2325 : }
2326 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2uubar")) {
2327 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(2, 5062);
2328 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2329 : }
2330 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2ssbar")) {
2331 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(3, 5063);
2332 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2333 : }
2334 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2ccbar")) {
2335 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(4, 5064);
2336 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2337 : }
2338 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2bbbar")) {
2339 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(5, 5065);
2340 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2341 : }
2342 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2ttbar")) {
2343 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(6, 5066);
2344 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2345 : }
2346 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2e+e-")) {
2347 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(11, 5071);
2348 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2349 : }
2350 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2nuenuebar")) {
2351 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(12, 5072);
2352 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2353 : }
2354 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2mu+mu-")) {
2355 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(13, 5073);
2356 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2357 : }
2358 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2numunumubar")) {
2359 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(14, 5074);
2360 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2361 : }
2362 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2tau+tau-")) {
2363 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(15, 5075);
2364 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2365 : }
2366 0 : if (settings.flag("ExtraDimensionsTEV:ffbar2nutaunutaubar")) {
2367 0 : sigmaPtr = new Sigma2ffbar2TEVffbar(16, 5076);
2368 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2369 : }
2370 :
2371 : // Set up requested objects for large extra-dimensional G processes.
2372 0 : bool extraDimLEDmono = settings.flag("ExtraDimensionsLED:monojet");
2373 0 : if (extraDimLEDmono || settings.flag("ExtraDimensionsLED:gg2Gg")) {
2374 0 : sigmaPtr = new Sigma2gg2LEDUnparticleg( true );
2375 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2376 : }
2377 0 : if (extraDimLEDmono || settings.flag("ExtraDimensionsLED:qg2Gq")) {
2378 0 : sigmaPtr = new Sigma2qg2LEDUnparticleq( true );
2379 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2380 : }
2381 0 : if (extraDimLEDmono || settings.flag("ExtraDimensionsLED:qqbar2Gg")) {
2382 0 : sigmaPtr = new Sigma2qqbar2LEDUnparticleg( true );
2383 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2384 : }
2385 0 : if (settings.flag("ExtraDimensionsLED:ffbar2GZ")) {
2386 0 : sigmaPtr = new Sigma2ffbar2LEDUnparticleZ( true );
2387 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2388 : }
2389 0 : if (settings.flag("ExtraDimensionsLED:ffbar2Ggamma")) {
2390 0 : sigmaPtr = new Sigma2ffbar2LEDUnparticlegamma( true );
2391 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2392 : }
2393 0 : if (settings.flag("ExtraDimensionsLED:ffbar2gammagamma")) {
2394 0 : sigmaPtr = new Sigma2ffbar2LEDgammagamma( true );
2395 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2396 : }
2397 0 : if (settings.flag("ExtraDimensionsLED:gg2gammagamma")) {
2398 0 : sigmaPtr = new Sigma2gg2LEDgammagamma( true );
2399 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2400 : }
2401 0 : if (settings.flag("ExtraDimensionsLED:ffbar2llbar")) {
2402 0 : sigmaPtr = new Sigma2ffbar2LEDllbar( true );
2403 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2404 : }
2405 0 : if (settings.flag("ExtraDimensionsLED:gg2llbar")) {
2406 0 : sigmaPtr = new Sigma2gg2LEDllbar( true );
2407 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2408 : }
2409 0 : bool extraDimLEDdij = settings.flag("ExtraDimensionsLED:dijets");
2410 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:gg2DJgg")) {
2411 0 : sigmaPtr = new Sigma2gg2LEDgg;
2412 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2413 : }
2414 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:gg2DJqqbar")) {
2415 0 : sigmaPtr = new Sigma2gg2LEDqqbar;
2416 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2417 : }
2418 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:qg2DJqg")) {
2419 0 : sigmaPtr = new Sigma2qg2LEDqg;
2420 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2421 : }
2422 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:qq2DJqq")) {
2423 0 : sigmaPtr = new Sigma2qq2LEDqq;
2424 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2425 : }
2426 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:qqbar2DJgg")) {
2427 0 : sigmaPtr = new Sigma2qqbar2LEDgg;
2428 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2429 : }
2430 0 : if (extraDimLEDdij || settings.flag("ExtraDimensionsLED:qqbar2DJqqbarNew")) {
2431 0 : sigmaPtr = new Sigma2qqbar2LEDqqbarNew;
2432 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2433 : }
2434 :
2435 : // Set up requested objects for unparticle processes.
2436 0 : bool extraDimUnpartmono = settings.flag("ExtraDimensionsUnpart:monojet");
2437 0 : if (extraDimUnpartmono || settings.flag("ExtraDimensionsUnpart:gg2Ug")) {
2438 0 : sigmaPtr = new Sigma2gg2LEDUnparticleg( false );
2439 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2440 : }
2441 0 : if (extraDimUnpartmono || settings.flag("ExtraDimensionsUnpart:qg2Uq")) {
2442 0 : sigmaPtr = new Sigma2qg2LEDUnparticleq( false );
2443 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2444 : }
2445 0 : if (extraDimUnpartmono || settings.flag("ExtraDimensionsUnpart:qqbar2Ug")) {
2446 0 : sigmaPtr = new Sigma2qqbar2LEDUnparticleg( false );
2447 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2448 : }
2449 0 : if (settings.flag("ExtraDimensionsUnpart:ffbar2UZ")) {
2450 0 : sigmaPtr = new Sigma2ffbar2LEDUnparticleZ( false );
2451 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2452 : }
2453 0 : if (settings.flag("ExtraDimensionsUnpart:ffbar2Ugamma")) {
2454 0 : sigmaPtr = new Sigma2ffbar2LEDUnparticlegamma( false );
2455 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2456 : }
2457 0 : if (settings.flag("ExtraDimensionsUnpart:ffbar2gammagamma")) {
2458 0 : sigmaPtr = new Sigma2ffbar2LEDgammagamma( false );
2459 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2460 : }
2461 0 : if (settings.flag("ExtraDimensionsUnpart:gg2gammagamma")) {
2462 0 : sigmaPtr = new Sigma2gg2LEDgammagamma( false );
2463 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2464 : }
2465 0 : if (settings.flag("ExtraDimensionsUnpart:ffbar2llbar")) {
2466 0 : sigmaPtr = new Sigma2ffbar2LEDllbar( false );
2467 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2468 : }
2469 0 : if (settings.flag("ExtraDimensionsUnpart:gg2llbar")) {
2470 0 : sigmaPtr = new Sigma2gg2LEDllbar( false );
2471 0 : containerPtrs.push_back( new ProcessContainer(sigmaPtr) );
2472 : }
2473 :
2474 : // Done.
2475 : return true;
2476 :
2477 0 : }
2478 :
2479 : //--------------------------------------------------------------------------
2480 :
2481 : // Routine to initialize list of second hard processes.
2482 :
2483 : bool SetupContainers::init2(vector<ProcessContainer*>& container2Ptrs,
2484 : Settings& settings) {
2485 :
2486 : // Reset process list, if filled in previous subrun.
2487 0 : if (container2Ptrs.size() > 0) {
2488 0 : for (int i = 0; i < int(container2Ptrs.size()); ++i)
2489 0 : delete container2Ptrs[i];
2490 0 : container2Ptrs.clear();
2491 0 : }
2492 : SigmaProcess* sigmaPtr;
2493 :
2494 : // Two hard QCD jets.
2495 0 : if (settings.flag("SecondHard:TwoJets")) {
2496 0 : sigmaPtr = new Sigma2gg2gg;
2497 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2498 0 : sigmaPtr = new Sigma2gg2qqbar;
2499 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2500 0 : sigmaPtr = new Sigma2qg2qg;
2501 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2502 0 : sigmaPtr = new Sigma2qq2qq;
2503 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2504 0 : sigmaPtr = new Sigma2qqbar2gg;
2505 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2506 0 : sigmaPtr = new Sigma2qqbar2qqbarNew;
2507 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2508 0 : sigmaPtr = new Sigma2gg2QQbar(4, 121);
2509 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2510 0 : sigmaPtr = new Sigma2qqbar2QQbar(4, 122);
2511 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2512 0 : sigmaPtr = new Sigma2gg2QQbar(5, 123);
2513 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2514 0 : sigmaPtr = new Sigma2qqbar2QQbar(5, 124);
2515 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2516 0 : }
2517 :
2518 : // A prompt photon and a hard jet.
2519 0 : if (settings.flag("SecondHard:PhotonAndJet")) {
2520 0 : sigmaPtr = new Sigma2qg2qgamma;
2521 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2522 0 : sigmaPtr = new Sigma2qqbar2ggamma;
2523 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2524 0 : sigmaPtr = new Sigma2gg2ggamma;
2525 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2526 0 : }
2527 :
2528 : // Two prompt photons.
2529 0 : if (settings.flag("SecondHard:TwoPhotons")) {
2530 0 : sigmaPtr = new Sigma2ffbar2gammagamma;
2531 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2532 0 : sigmaPtr = new Sigma2gg2gammagamma;
2533 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2534 0 : }
2535 :
2536 : // Charmonium.
2537 0 : if (settings.flag("SecondHard:Charmonium")) {
2538 0 : vector<SigmaProcess*> charmoniumSigmaPtrs;
2539 0 : charmonium.setupSigma2gg(charmoniumSigmaPtrs, true);
2540 0 : charmonium.setupSigma2qg(charmoniumSigmaPtrs, true);
2541 0 : charmonium.setupSigma2qq(charmoniumSigmaPtrs, true);
2542 0 : for (unsigned int i = 0; i < charmoniumSigmaPtrs.size(); ++i)
2543 0 : container2Ptrs.push_back( new ProcessContainer(charmoniumSigmaPtrs[i]));
2544 0 : }
2545 :
2546 : // Bottomonium.
2547 0 : if (settings.flag("SecondHard:Bottomonium")) {
2548 0 : vector<SigmaProcess*> bottomoniumSigmaPtrs;
2549 0 : bottomonium.setupSigma2gg(bottomoniumSigmaPtrs, true);
2550 0 : bottomonium.setupSigma2qg(bottomoniumSigmaPtrs, true);
2551 0 : bottomonium.setupSigma2qq(bottomoniumSigmaPtrs, true);
2552 0 : for (unsigned int i = 0; i < bottomoniumSigmaPtrs.size(); ++i)
2553 0 : container2Ptrs.push_back( new ProcessContainer(bottomoniumSigmaPtrs[i]));
2554 0 : }
2555 :
2556 : // A single gamma*/Z0.
2557 0 : if (settings.flag("SecondHard:SingleGmZ")) {
2558 0 : sigmaPtr = new Sigma1ffbar2gmZ;
2559 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2560 0 : }
2561 :
2562 : // A single W+-.
2563 0 : if (settings.flag("SecondHard:SingleW")) {
2564 0 : sigmaPtr = new Sigma1ffbar2W;
2565 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2566 0 : }
2567 :
2568 : // A gamma*/Z0 and a hard jet.
2569 0 : if (settings.flag("SecondHard:GmZAndJet")) {
2570 0 : sigmaPtr = new Sigma2qqbar2gmZg;
2571 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2572 0 : sigmaPtr = new Sigma2qg2gmZq;
2573 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2574 0 : }
2575 :
2576 : // A W+- and a hard jet.
2577 0 : if (settings.flag("SecondHard:WAndJet")) {
2578 0 : sigmaPtr = new Sigma2qqbar2Wg;
2579 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2580 0 : sigmaPtr = new Sigma2qg2Wq;
2581 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2582 0 : }
2583 :
2584 : // Top pair production.
2585 0 : if (settings.flag("SecondHard:TopPair")) {
2586 0 : sigmaPtr = new Sigma2gg2QQbar(6, 601);
2587 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2588 0 : sigmaPtr = new Sigma2qqbar2QQbar(6, 602);
2589 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2590 0 : sigmaPtr = new Sigma2ffbar2FFbarsgmZ(6, 604);
2591 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2592 0 : }
2593 :
2594 : // Single top production.
2595 0 : if (settings.flag("SecondHard:SingleTop")) {
2596 0 : sigmaPtr = new Sigma2qq2QqtW(6, 603);
2597 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2598 0 : sigmaPtr = new Sigma2ffbar2FfbarsW(6, 0, 605);
2599 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2600 0 : }
2601 :
2602 : // Two b jets - already part of TwoJets sample above.
2603 0 : if (settings.flag("SecondHard:TwoBJets")) {
2604 0 : sigmaPtr = new Sigma2gg2QQbar(5, 123);
2605 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2606 0 : sigmaPtr = new Sigma2qqbar2QQbar(5, 124);
2607 0 : container2Ptrs.push_back( new ProcessContainer(sigmaPtr) );
2608 0 : }
2609 :
2610 : // Done.
2611 0 : return true;
2612 :
2613 0 : }
2614 :
2615 : //--------------------------------------------------------------------------
2616 :
2617 : // Set up arrays of allowed outgoing SUSY particles.
2618 :
2619 : void SetupContainers::setupIdVecs( Settings& settings) {
2620 :
2621 : // First array either none, one or many particles.
2622 0 : idVecA.resize(0);
2623 0 : if (settings.mode("SUSY:idA") != 0) {
2624 0 : idVecA.push_back( abs(settings.mode("SUSY:idA")) );
2625 0 : } else {
2626 0 : vector<int> idTmpA = settings.mvec("SUSY:idVecA");
2627 0 : for (int i = 0; i < int(idTmpA.size()); ++i)
2628 0 : if (idTmpA[i] != 0) idVecA.push_back( abs(idTmpA[i]) );
2629 0 : }
2630 0 : nVecA = idVecA.size();
2631 :
2632 : // Second array either none, one or many particles.
2633 0 : idVecB.resize(0);
2634 0 : if (settings.mode("SUSY:idB") != 0) {
2635 0 : idVecB.push_back( abs(settings.mode("SUSY:idB")) );
2636 0 : } else {
2637 0 : vector<int> idTmpB = settings.mvec("SUSY:idVecB");
2638 0 : for (int i = 0; i < int(idTmpB.size()); ++i)
2639 0 : if (idTmpB[i] != 0) idVecB.push_back( abs(idTmpB[i]) );
2640 0 : }
2641 0 : nVecB = idVecB.size();
2642 :
2643 0 : }
2644 :
2645 : //--------------------------------------------------------------------------
2646 :
2647 : // Check final state for allowed outgoing SUSY particles.
2648 : // Normally check two codes, but allow for only one.
2649 :
2650 : bool SetupContainers::allowIdVals( int idCheck1, int idCheck2) {
2651 :
2652 : // If empty arrays or id's no need for checks. Else need absolute values.
2653 0 : if (nVecA == 0 && nVecB == 0) return true;
2654 0 : if (idCheck1 == 0 && idCheck2 == 0) return true;
2655 0 : int idChk1 = abs(idCheck1);
2656 0 : int idChk2 = abs(idCheck2);
2657 :
2658 : // If only one outgoing particle then check idVecA and idVecB.
2659 0 : if (idChk1 == 0) swap(idChk1, idChk2);
2660 0 : if (idChk2 == 0) {
2661 0 : for (int i = 0; i < nVecA; ++i) if (idChk1 == idVecA[i]) return true;
2662 0 : for (int i = 0; i < nVecB; ++i) if (idChk1 == idVecB[i]) return true;
2663 0 : return false;
2664 : }
2665 :
2666 : // If empty array idVecB then compare with idVecA.
2667 0 : if (nVecB == 0) {
2668 0 : for (int i = 0; i < nVecA; ++i)
2669 0 : if (idChk1 == idVecA[i] || idChk2 == idVecA[i]) return true;
2670 0 : return false;
2671 : }
2672 :
2673 : // If empty array idVecA then compare with idVecB.
2674 0 : if (nVecA == 0) {
2675 0 : for (int i = 0; i < nVecB; ++i)
2676 0 : if (idChk1 == idVecB[i] || idChk2 == idVecB[i]) return true;
2677 0 : return false;
2678 : }
2679 :
2680 : // Else check that pair matches allowed combinations.
2681 0 : for (int i = 0; i < nVecA; ++i)
2682 0 : for (int j = 0; j < nVecB; ++j)
2683 0 : if ( (idChk1 == idVecA[i] && idChk2 == idVecB[j])
2684 0 : || (idChk2 == idVecA[i] && idChk1 == idVecB[j]) ) return true;
2685 0 : return false;
2686 :
2687 0 : }
2688 :
2689 : //==========================================================================
2690 :
2691 : } // end namespace Pythia8
|
