|
PYTHIA
8.311
|
The SimpleTimeShower class does timelike showers. More...
#include <SimpleTimeShower.h>
Public Member Functions | |
| SimpleTimeShower () | |
| Constructor. | |
| virtual | ~SimpleTimeShower () override |
| Destructor. | |
| virtual void | init (BeamParticle *beamAPtrIn=0, BeamParticle *beamBPtrIn=0) override |
| Initialize alphaStrong and related pTmin parameters. More... | |
| virtual bool | limitPTmax (Event &event, double Q2Fac=0., double Q2Ren=0.) override |
| Find whether to limit maximum scale of emissions, and whether to dampen. More... | |
| virtual int | shower (int iBeg, int iEnd, Event &event, double pTmax, int nBranchMax=0) override |
| Top-level routine to do a full time-like shower in resonance decay. More... | |
| virtual int | showerQED (int i1, int i2, Event &event, double pTmax) override |
| Top-level routine for QED radiation in hadronic decay to two leptons. More... | |
| virtual void | prepareProcess (Event &process, Event &, vector< int > &) override |
| Prepare process-level event for shower + interleaved resonance decays. More... | |
| virtual void | prepareGlobal (Event &event) override |
| Global recoil: reset counters and store locations of outgoing partons. More... | |
| virtual void | prepare (int iSys, Event &event, bool limitPTmaxIn=true) override |
| Prepare system for evolution after each new interaction; identify ME. More... | |
| virtual void | rescatterUpdate (int iSys, Event &event) override |
| Update dipole list after a multiparton interactions rescattering. More... | |
| virtual void | update (int iSys, Event &event, bool hasWeakRad=false) override |
| Update dipole list after each ISR emission. More... | |
| virtual double | pTnext (Event &event, double pTbegAll, double pTendAll, bool isFirstTrial=false, bool doTrialIn=false) override |
| Select next pT for FSR in downwards evolution. More... | |
| virtual double | pTnextResDec () override |
| Select next pT for interleaved resonance decays. | |
| virtual bool | branch (Event &event, bool isInterleaved=false) override |
| ME corrections and kinematics that may give failure. More... | |
| virtual bool | resonanceShower (Event &process, Event &event, vector< int > &iPos, double qRestart) override |
| virtual void | list () const override |
| Print dipole list; for debug mainly. More... | |
| virtual bool | initUncertainties () override |
| Initialize data members for calculation of uncertainty bands. More... | |
| virtual bool | initEnhancements () override |
| Initialize data members for application of enhancements. More... | |
| virtual bool | getHasWeaklyRadiated () override |
| Tell whether FSR has done a weak emission. | |
| virtual int | system () const override |
| Tell which system was the last processed one. | |
| virtual double | enhancePTmax () override |
| Potential enhancement factor of pTmax scale for hardest emission. | |
| virtual double | pTLastInShower () override |
| Provide the pT scale of the last branching in the above shower. | |
| double | noEmissionProbability (double pTbegAll, double pTendAll, double m2dip, int id, int type, double s=-1., double x=-1.) override |
| double | pTnext (vector< TimeDipoleEnd > dipEnds, Event event, double pTbegAll, double pTendAll, double m2dip, int id, int type, double s=-1., double x=-1.) |
 Public Member Functions inherited from TimeShower | |
| TimeShower ()=default | |
| Constructor. | |
| virtual | ~TimeShower () |
| Destructor. | |
| void | initPtrs (MergingHooksPtr mergingHooksPtrIn, PartonVertexPtr partonVertexPtrIn, WeightContainer *weightContainerPtrIn) |
| void | reassignBeamPtrs (BeamParticle *beamAPtrIn, BeamParticle *beamBPtrIn, int beamOffsetIn=0) |
| New beams possible for handling of hard diffraction. (Not virtual.) | |
| virtual int | showerQEDafterRemnants (Event &) |
| virtual Event | clustered (const Event &, int, int, int, string) |
| Return clustering kinematics - as needed for merging. More... | |
| virtual map< string, double > | getStateVariables (const Event &, int, int, int, string) |
| virtual bool | isTimelike (const Event &, int, int, int, string) |
| virtual vector< string > | getSplittingName (const Event &, int, int, int) |
| virtual double | getSplittingProb (const Event &, int, int, int, string) |
| virtual bool | allowedSplitting (const Event &, int, int) |
| virtual vector< int > | getRecoilers (const Event &, int, int, string) |
| virtual double | enhanceFactor (const string &name) |
| Public Member Functions inherited from PhysicsBase | |
| void | initInfoPtr (Info &infoPtrIn) |
| This function is called from above for physics objects used in a run. More... | |
| virtual | ~PhysicsBase () |
| Empty virtual destructor. | |
| bool | flag (string key) const |
| Shorthand to read settings values. | |
| int | mode (string key) const |
| double | parm (string key) const |
| string | word (string key) const |
| vector< bool > | fvec (string key) const |
| vector< int > | mvec (string key) const |
| vector< double > | pvec (string key) const |
| vector< string > | wvec (string key) const |
Public Attributes | |
| int | pdfMode |
| bool | useSystems |
| Public Attributes inherited from TimeShower | |
| MergingHooksPtr | mergingHooksPtr {} |
| Pointer to MergingHooks object for NLO merging. | |
| WeightContainer * | weightContainerPtr {} |
Additional Inherited Members | |
| Public Types inherited from PhysicsBase | |
| enum | Status { INCOMPLETE = -1, COMPLETE = 0, CONSTRUCTOR_FAILED, INIT_FAILED, LHEF_END, LOWENERGY_FAILED, PROCESSLEVEL_FAILED, PROCESSLEVEL_USERVETO, MERGING_FAILED, PARTONLEVEL_FAILED, PARTONLEVEL_USERVETO, HADRONLEVEL_FAILED, CHECK_FAILED, OTHER_UNPHYSICAL, HEAVYION_FAILED, HADRONLEVEL_USERVETO } |
| Enumerate the different status codes the event generation can have. | |
| Protected Member Functions inherited from PhysicsBase | |
| PhysicsBase () | |
| Default constructor. | |
| virtual void | onInitInfoPtr () |
| virtual void | onBeginEvent () |
| This function is called in the very beginning of each Pythia::next call. | |
| virtual void | onEndEvent (Status) |
| virtual void | onStat () |
| This function is called from the Pythia::stat() call. | |
| void | registerSubObject (PhysicsBase &pb) |
| Register a sub object that should have its information in sync with this. | |
| Protected Attributes inherited from TimeShower | |
| int | beamOffset {} |
| Beam location offset in event. | |
| PartonVertexPtr | partonVertexPtr {} |
| Pointer to assign space-time vertices during parton evolution. | |
| bool | doUncertainties {} |
| Store uncertainty variations relevant to TimeShower. | |
| bool | uVarMuSoftCorr {} |
| bool | uVarMPIshowers {} |
| bool | noResVariations {} |
| bool | noProcVariations {} |
| int | nUncertaintyVariations {} |
| int | nVarQCD {} |
| int | uVarNflavQ {} |
| double | dASmax {} |
| double | cNSpTmin {} |
| double | uVarpTmin2 {} |
| double | overFactor {} |
| double | overFactorEnhance {} |
| map< int, double > | varG2GGmuRfac |
| map< int, double > | varQ2QGmuRfac |
| map< int, double > | varG2QQmuRfac |
| map< int, double > | varX2XGmuRfac |
| map< int, double > | varG2GGcNS |
| map< int, double > | varQ2QGcNS |
| map< int, double > | varG2QQcNS |
| map< int, double > | varX2XGcNS |
| map< int, double > * | varPDFplus |
| map< int, double > * | varPDFminus |
| map< int, double > * | varPDFmember |
| unordered_map< string, double > | enhanceFSR |
| Protected Attributes inherited from PhysicsBase | |
| Info * | infoPtr = {} |
| Settings * | settingsPtr = {} |
| Pointer to the settings database. | |
| ParticleData * | particleDataPtr = {} |
| Pointer to the particle data table. | |
| Logger * | loggerPtr = {} |
| Pointer to logger. | |
| HadronWidths * | hadronWidthsPtr = {} |
| Pointer to the hadron widths data table. | |
| Rndm * | rndmPtr = {} |
| Pointer to the random number generator. | |
| CoupSM * | coupSMPtr = {} |
| Pointers to SM and SUSY couplings. | |
| CoupSUSY * | coupSUSYPtr = {} |
| BeamSetup * | beamSetupPtr = {} |
| BeamParticle * | beamAPtr = {} |
| BeamParticle * | beamBPtr = {} |
| BeamParticle * | beamPomAPtr = {} |
| BeamParticle * | beamPomBPtr = {} |
| BeamParticle * | beamGamAPtr = {} |
| BeamParticle * | beamGamBPtr = {} |
| BeamParticle * | beamVMDAPtr = {} |
| BeamParticle * | beamVMDBPtr = {} |
| PartonSystems * | partonSystemsPtr = {} |
| Pointer to information on subcollision parton locations. | |
| SigmaTotal * | sigmaTotPtr = {} |
| Pointers to the total/elastic/diffractive cross sections. | |
| SigmaCombined * | sigmaCmbPtr = {} |
| set< PhysicsBase * > | subObjects |
| UserHooksPtr | userHooksPtr |
The SimpleTimeShower class does timelike showers.
|
overridevirtual |
ME corrections and kinematics that may give failure.
ME corrections and kinematics that may give failure. Notation: radBef, recBef = radiator, recoiler before emission, rad, rec, emt = radiator, recoiler, emitted efter emission. (rad, emt distinguished by colour flow for g -> q qbar.)
Check if this system is part of the hard scattering (including resonance decay products).
Check if global recoil should be used in resonance showers.
Do not use global recoil if the radiator line has already branched.
Check if global recoil should be used.
Switch off global recoil after first trial emission
Check if global recoil should be used.
No global recoil for H-events.
Check if the first emission should be studied for removal.
Check if ME corrections should apply to this branching.
Find initial radiator and recoiler particles in dipole branching.
Find their momenta, with special sum for global recoil.
Include all particles in all hard systems (hard production system, systems of resonance decay products) in the global recoil momentum.
Find old incoming momenta for weak shower t-channel ME correction.
Trace back to original mother. MPI not allowed to radiate weakly.
u d -> u d && u g -> u g.
In case of no match, assign random combination.
u u -> u u, assign random combination.
Default flavours and colour tags for new particles in dipole branching.
Prepare for Hidden Valley colour assignment.
Sometimes need to patch up colType in junction systems.
Negate colour type if recoiler is initial-state quark.
Perform junction tests for all colour (anti)triplets.
Default OK for photon, photon_HV, or singlet onium emission.
New colour tag required for gluon emission.
New flavours for g -> q qbar; split colours.
New flavours for gamma -> f fbar, and maybe also colours.
New Hidden Valley colour tag for gluon_HV emission.
Change fermion flavour by W emissions.
Construct kinematics in dipole rest frame: begin simple (like g -> g g).
Radiator flavour changed if W emission, so find new mass.
Kinematics reduction for f -> f W/Z when m_f > 0 (and m_W/Z > 0) or q -> q gamma_v when m_q > 0 and m_gamma_v > 0.
Special set up for color octet production from a gluon.
Kinematics reduction for q -> q g/gamma/g_HV when m_q > 0.
Kinematics reduction for g -> q qbar or gamma -> f fbar when m_f > 0;
If an onia splitting, set the branching variables.
Reject g/gv emission where mass effects have reduced pT below cutoff. Separate cut for gv could be added if needed.
Find rest frame and angles of original dipole.
Evaluate coefficient of azimuthal asymmetry from gluon polarization.
Begin construction of new dipole kinematics: pick azimuthal angle.
Define kinematics of branching in dipole rest frame.
Rotate and boost dipole products to the event frame.
New: To avoid instabilities for violent boosts, ensure that an incoming recoiler always has zero px and py.
Azimuthal phi weighting: loop to new phi value if required.
Kinematics when recoiler is initial-state parton.
New: Return if the x-value for the incoming recoiler is nonsense.
PS dec 2010: check if radiator has flexible normalization
Define new particles from dipole branching.
Recoiler either in final or in initial state
Special checks to set weak particles status equal to 56. This is needed for decaying the particles. Also set polarisation.
Recover delayed shower-accept probability for uncertainty variations.
ME corrections can lead to branching being rejected.
Optional reweighting to dipole with decaying coloured (e.g., top) mother. Skip if ME corrections are already made (= first emission in many cases).
Check if newly emitted gluon matches decaying resonance colour line.
Recoiler should now be a colour-neutral particle (i.e., W for t -> bW). (Allow triplet for exotic colour flows, eg 3 in 3->38 or 8->33bar.)
Check if there are any singlets at all among the daughters.
Use dipole partons after or before emission (after recommended).
Denominator: eikonal weight with X as recoiler (= W for t->bW).
If recoilDeadCone = on, include Recoiler mass term in denominator.
Numerator: eikonal weight with resonance as recoiler.
Reweight accept probability by eikonal ratio Resonance / X recoiler.
Decide if we are going to accept or reject this branching. (Without wasting time generating random numbers if pAccept = 1.)
Determine if this FSR is part of process or resonance showering
If doing uncertainty variations, calculate accept/reject reweightings.
Check if variations are allowed in MPIs.
Check if to allow variations in resonance decays.
Check if to allow variations in process.
Check if below cutoff for calculating variations
Early return if allowed.
Rescatter: if the recoiling partner is not in the same system as the radiator, fix up intermediate systems (can lead to emissions being vetoed)
For photon-beam recoiler check that room for remnants after branching.
If recoiler kinematics fixed by ISR can't act as recoiler.
One-remnant system.
Two-remnants systems.
Save properties to be restored in case of user-hook veto of emission.
Shower may occur at a displaced vertex.
Put new particles into the event record.
Add Hidden Valley colour info where relevant.
Allow setting of new parton production vertex.
Mark original dipole partons as branched and set daughters/mothers.
Add Hidden Valley colour info where relevant.
Global recoil: need to find relevant rotation+boost for recoilers: boost+rotate to rest frame, boost along z axis, rotate+boost back.
Global recoil: copy particles, and rotate+boost momenta (not vertices).
Allow veto of branching. If so restore event record to before emission.
Default settings for uncertainty calculations.
Calculate event weight for enhanced emission rate.
Check if emission weight was enhanced. Get enhance weight factor.
Move backwards as last elements have highest pT, thus are chosen splittings.
If the accept and veto probabilities are not the same as the standard ones then this becomes complicated.
Check emission veto.
Increment counter to handle counting of rejected emissions.
Not sure of the impact here: will have to look at the code
Reset enhance factors after usage.
For enhanced trial shower: always accept here, and then reject in History::trialShower with 1-1/enhance
Emission veto is a phase space restriction, and should not be included in the uncertainty calculation.
Return false if we decided to reject this branching. Veto if necessary.
Increment counter to handle counting of rejected emissions. (used for global recoil tests)
For global recoil restore the one nominal recoiler, for bookkeeping.
For initial-state recoiler also update beam and sHat info.
For global recoil: if everything went as expected, remove the line from the list of "hard lines" that are allowed to use global recoil.
Update number of splittings that have been produced with global recoil.
Photon emission: update to new dipole ends; add new photon "dipole".
When recoiler was uncharged particle, in resonance decays, assign recoil to emitted photons.
Gluon emission: update both dipole ends and add two new ones.
Optionally also kill ME corrections after first emission.
PS dec 2010: check normalization of radiating dipole Dipole corresponding to the newly created colour tag has normal strength
Optionally also kill ME corrections after first emission.
Strive to match colour to anticolour inside closed system.
PS dec 2010: if the (iRadBef,iRecBef) dipole was flexible, the same should be true for this (opposite) end. If so, this end keeps the modified normalization, so we shouldn't need to do anything.
Weak shower can have gluons as recoiler. Always choose the outgoing gluon that produces the highest invariant mass.
When recoiler was uncoloured particle, in resonance decays, assign recoil to coloured particle.
PS dec 2010: the (iEmt,iRec) dipole "inherits" flexible normalization
Onium emission: update to new dipole ends.
Gluon branching to q qbar: update current dipole and other of gluon.
Strive to match colour to anticolour inside closed system.
Note: gluino -> quark + squark gives a deeper radiation dip than the more obvious alternative photon decay, so is more realistic.
Choose recoiler to Z/W to get largest mass.
Gluon branching to q qbar: also add two charge dipole ends. Note: gluino -> quark + squark gives a deeper radiation dip than the more obvious alternative photon decay, so is more realistic.
Gluon branching to q qbar: also add weak dipoles. Randomly decided whether to use left or right quarks.
Gluon branching to q qbar: also add onium dipoles.
Photon branching to f fbar: inactivate photon "dipole"; optionally add new charge and colour dipole ends. (But not W or Z ends, since W/Z are heavier than gamma*.)
MEtype = 102 for charge in vector decay.
MEtype = 11 for colour in vector decay.
Photon_HV emission: update to new dipole ends.
Gluon_HV emission: update to new dipole ends.
When recoiler was un-HV-coloured particle, in resonance decays, assign recoil to HV-coloured particle.
W/Z emission, if only a single weak emission is allowed.
Reset dipSel if dipEnd.push_back() has caused reallocation above.
Copy or set lifetime for new final state.
Now update other dipoles that also involved the radiator or recoiler.
PS dec 2010: if radiator was flexible and now is normal, there may be other flexible dipoles that need updating.
PS Apr 2011 Update any junctions downstream of this branching (if necessary) (This happens, e.g., via LHEF, when adding showers to intermediate coloured resonances whose decays involved junctions)
Number of incoming colour lines for this junction.
Check radiator colour or anticolour, depending on junction kind (if junction, incoming = anticolours, and vice versa)
Loop over incoming junction ends
If match, update junction end with new upstream (anti)colour
Finally update the list of all partons in all systems.
Possibility to add more emitted particles.
Remove dead dipole ends.
Done.
Reimplemented from TimeShower.
|
overridevirtual |
Initialize alphaStrong and related pTmin parameters.
Initialize alphaStrong, alphaEM and related pTmin parameters.
Store input pointers for future use.
Inputs for control of MECs.
Main flags.
Some possible corrections to main evolution behaviour.
If SimpleSpaceShower does dipole recoil then SimpleTimeShower must adjust.
Matching in pT of hard interaction or MPI to shower evolution.
Charm and bottom mass thresholds.
Parameters of scale choices.
Parameters of alphaStrong generation.
Initialize alphaStrong generation.
Lambda for 5, 4 and 3 flavours.
Parameters of QCD evolution. Warn if pTmin must be raised.
Parameters of alphaEM generation.
Initialize alphaEM generation.
Parameters of QED evolution.
Parameters of weak evolution.
Parameters of interleaved resonance decays.
Parameters of onium evolution.
Consisteny check for gamma -> f fbar variables.
Possibility of a global recoil stategy, e.g. for MC.
Number of splittings produced with global recoil.
Number of partons in Born-like events, to distinguish between S and H.
Flag to allow to start from a scale smaller than scalup.
Flag to allow to start from a scale smaller than scalup.
Z0 and W+- properties needed for gamma/Z0 mixing and weak showers.
May have to fix up recoils related to rescattering.
Hidden Valley parameters for further shower activity.
Derived quantities for Hidden Valley.
Initialize running coupling in Hidden Valley.
Adjust a too low pThvCut.
Possibility of two predetermined hard emissions in event.
Possibility to allow user veto of emission step.
Set initial value, just in case.
Default values for the weak shower.
Disallow simultaneous splitting and trial emission enhancements.
Initialize variables set in pTnext but not in showerQED.
Let the onium emitters know if we are ehnancing.
Properties for enhanced emissions.
Enable automated uncertainty variations.
Possibility to set parton vertex information.
Reimplemented from TimeShower.
|
overridevirtual |
Initialize data members for application of enhancements.
Initialize the choices of uncertainty variations of the shower.
Reimplemented from TimeShower.
|
overridevirtual |
Initialize data members for calculation of uncertainty bands.
Initialize the choices of uncertainty variations of the shower.
Populate lists of uncertainty variations for SimpleTimeShower, by keyword.
Variations handled by SpaceShower.
Reset uncertainty variation maps.
Initialise atomized variation strings, not necessarily all relevant for FSR. Return false if init does not succeed.
Extract those that are relevant to FSR.
Only perform for the first call to Timeshower
Loop over all keywords.
Transform string to lowercase to avoid case-dependence.
Skip if empty or keyword not found.
Extract variation value/factor.
Store (iWeight,value) pairs RECALL: use lowercase for all keys here (since converted above).
Tell that we found at least one recognized and parseable keyword.
End loop over QCD keywords
Tell whether this uncertainty variation contained >= 1 QCD variation.
End loop over UVars.
Let the calling function know if we found anything.
Reimplemented from TimeShower.
|
overridevirtual |
Find whether to limit maximum scale of emissions, and whether to dampen.
Find whether to limit maximum scale of emissions. Also allow for dampening at factorization or renormalization scale.
Find whether to limit pT. Begin by user-set cases.
Always restrict SoftQCD processes.
Look if any quark (u, d, s, c, b), gluon or photon in final state. Also count number of heavy coloured particles, like top.
Dampening at factorization or renormalization scale; only for hardest.
Done.
Reimplemented from TimeShower.
|
overridevirtual |
Print dipole list; for debug mainly.
Print the list of dipoles.
Header.
Loop over dipole list and print it.
Done.
Reimplemented from TimeShower.
|
overridevirtual |
Functions to directly extract the probability of no emission between two scales. These functions are not used in the Pythia core code, but can be used by external programs to interface with the shower directly.
Function to directly extract the probability of no emission between two scales. This function is not used in the Pythia core code, but can be used by external programs to extract no-emission probabilities from Pythia.
First, create a dummy event with two entries from the inputs.
Setup two dipole ends for each flavor combination.
After this, the inactive beam returns to the correct energy fraction.
Add recoiler. For 1->3 splitting, attach "dummy" recoiler.
Now initialize other internal classes from the inputs, so that parton shower methods that rely on beam and system information can be used.
Store participating partons as first set in list of all systems.
Find positions of incoming colliding partons and extract all dipoles that should be used in the evolution.
Set output and produce many trial showers (to obtain a statisically stable no-emission probability value)
Reset process scale so that shower starting scale is correctly set.
Get pT before reclustering
If the maximal scale and the minimal scale coincide (as would be the case for the corrected scales of unordered histories), do not generate Sudakov
Get trial shower pT.
Done if evolution scale has fallen below minimum
Reset starting scale.
Done
Calculate the value of the no-emssion probabilty.
Clean up, done.
Reimplemented from TimeShower.
|
overridevirtual |
Prepare system for evolution after each new interaction; identify ME.
Prepare system for evolution; identify ME.
Reset W/Z radiation flag at first call for new event.
Reset dipole-ends list for first interaction and for resonance decays.
No dipoles for 2 -> 1 processes.
In case of DPS overwrite limitPTmaxIn by saved value.
Reset number of proposed splittings. Used for global recoil. First check if this system belongs to the hard scattering.
If the system belongs to the hard scattering, initialise counter of proposed emissions.
Loop through final state of system to find possible dipole ends.
Identify colour octet onium state. Check whether QCD shower allowed.
Find dipole end formed by colour index.
Find dipole end formed by anticolour index.
Find "charge-dipole" and "photon-dipole" ends.
Find weak diple ends.
Find Hidden Valley dipole ends.
End loop over system final state. Have now found the dipole ends.
Special setup for weak dipoles if they are setup externally.
Loop through dipole ends to find matrix element corrections.
Update dipole list after a multiparton interactions rescattering.
Reimplemented from TimeShower.
|
overridevirtual |
Global recoil: reset counters and store locations of outgoing partons.
Global recoils: reset some counters.
Global recoils: store positions of hard outgoing partons. No global recoil for H events.
Reset nFinalBorn on an event-by-event basis.
Add number of heavy coloured objects in lowest multiplicity state.
Reimplemented from TimeShower.
Prepare process-level event for shower + interleaved resonance decays.
Prepare process-level event for shower + interleaved resonance decays. Usage: prepareProcess( process, event, iPos). iPos provides mapping from process to event entries (before showering).
Nothing to do if not doing interleaved resonance decays
Initialise recursion-depth counter (for nested sequential decays), and vector of resonance-decay pT scales.
Find resonances coming directly from the hard process. (Ones from sequential decays irrelevant until their mothers have decayed.)
Set interleaving scale: width or offshellness
Reimplemented from TimeShower.
|
overridevirtual |
Select next pT for FSR in downwards evolution.
Select next pT in downwards evolution of the existing dipoles.
Begin loop over all possible radiating dipole ends.
Check if enhanced emissions should be applied.
Starting values for enhanced emissions.
Check if this system is part of the hard scattering (including resonance decay products).
Check if global recoil should be used.
Do not use global recoil if the radiator line has already branched.
Check if global recoil should be used.
Switch off global recoil after first trial emission.
Switch off global recoil after first emission
No global recoil for H-events.
Dipole properties; normal local recoil.
Dipole properties, alternative global recoil. Squares.
Include all particles in all hard systems (hard production system, systems of resonance decay products) in the global recoil momentum.
Find maximum evolution scale for dipole.
For global recoil, always set the starting scale for first emission.
Find mass of colour dipole.
Choose minimal scale.
Do not try splitting if the corrected dipole mass is negative.
Do QCD, QED, weak, onia or HV evolution if it makes sense.
Update if found larger pT than current maximum.
Update the number of proposed timelike emissions.
Return nonvanishing value if found pT bigger than already found.
Reimplemented from TimeShower.
| double pTnext | ( | vector< TimeDipoleEnd > | dipEnds, |
| Event | event, | ||
| double | pTbegAll, | ||
| double | pTendAll, | ||
| double | m2dip, | ||
| int | id, | ||
| int | type, | ||
| double | s = -1., |
||
| double | x = -1. |
||
| ) |
Function to select next pT in downwards evolution of the existing dipoles. This function is not used in the Pythia core code, but can be used by external programs. Thus, this function relies exclusively on its inputs, such that it can be used by an external code. Apart from this, this function is a copy of the interal-use function "pTnext( event, pTbegAll, pTendAll, isFirstTrial, doTrialIn)" defined above, but stripped of any non-QCD showers.
Starting values: no radiating dipole found.
Loop over all possible dipole ends.
Find properties of dipole and radiating dipole end.
Note dipole mass correction when recoiler is a rescatter.
Reset emission properties.
Find maximum evolution scale for dipole.
Do QCD, QED, weak or HV evolution if it makes sense.
Update if found larger pT than current maximum.
End loop over dipole ends.
Return nonvanishing value if found pT is bigger than already found.
|
overridevirtual |
Update dipole list after a multiparton interactions rescattering.
Loop over two incoming partons in system; find their rescattering mother. (iOut is outgoing from old system = incoming iIn of rescattering system.)
Loop over all dipoles.
Kill dipoles where rescattered parton is radiator.
No matrix element for dipoles between scatterings.
Update dipoles where outgoing rescattered parton is recoiler.
Colour dipole: recoil in final state, initial state or new.
This line in case mother is a rescattered parton.
If above options failed, then create new dipole.
Anticolour dipole: recoil in final state, initial state or new.
This line in case mother is a rescattered parton.
If above options failed, then create new dipole.
Charge or photon dipoles: same flavour in final or initial state.
This line in case mother is a rescattered parton.
If above options failed, then create new dipole
End of loop over dipoles and two incoming sides.
Reimplemented from TimeShower.
|
overridevirtual |
Do a resonance decay + resonance shower (including any nested decays). May be called recursively for nested decays. Usage: resonanceShower( process, event, iPos, pTmerge), where iPos maps process to event entries, and pTmerge is the scale at which this system should be merged into its parent system.
Do a resonance decay, including showering of resonance system (with preserved resonance mass) down to the scale pTmerge, at which the produced partons are merged back into the system that produced the resonance (iSysMot). Note: this method can be called recursively for nested resonance decays.
Keep track of how many times resonanceShower has called itself.
Save which resonance is currently being handled (since iHardResDecSav may be overwritten when called recursively).
Do not try this resonance again (to avoid risk of infinite loop). If we fail, PartonLevel will have a (non-interleaved) chance at end of evolution.
Mother in hard process and in complete event. iPosPtr indicates position in complete event before shower evolution started, so may have moved.
Prepare to move daughters from process to event record
Mother can have been moved by showering (in any of previous steps), so prepare to update colour and momentum information for system.
Construct boost matrix to go from process to event frame.
Check if this decay contains one (or more) junction structure(s) that should be copied from process to event as part of this decay.
Check for junctions that were already copied (e.g., by setupHardSys)
Mark this junction as already copied (force to be skipped).
Move daughters from process to event and apply boosts + colour updates.
Copy daughter from process to event.
Update iPos map from process to event
Now set properties of this daughter in event.
Currently outgoing ones should not count as decayed.
Check if this decay contains a junction in hard event.
Only consider junctions that can appear in decays.
Check if colour of hard mother matches an incoming junction leg.
Only check mother once (not once for every daughter).
Check if daughter colour matches an outgoing junction leg.
If we have 3 matches, copy down junction from process to event.
Check for changed colors and update as necessary.
Mark junction as copied (to avoid later recopying)
Update colour and momentum information.
Sextet mothers have additional (negative) tag
Update vertex information.
Finally, check if daughter is itself a resonance. If so, add interleaving scale.
End loop over resonance daughters.
If everything worked, mark mother in event record as decayed.
Set daughters.
Add new system for this resonance decay + shower, + any nested resonance decays that may be done (recursively) while handling this system. (Partons will be moved from this system to upstream one at end.)
Insert resonance into system, then add daughters.
Userhooks and Trial showers accounted for here in PartonLevel. TODO: discuss whether to include that here and how. Should become clear if we want to replace guts of PartonLevel::resonanceShowers by calls to this method. For now, just do pure showers. Save current list of dipole ends, then clear so resonance shower does not interfere with other systems.
Begin evolution down in pT, allowing for nested resonance decays.
Interleave (intra-system) FSR and resonance decays.
Do a final-state emission.
Check system
Do a resonance decay, nested (recursively) inside the current one.
Do nothing.
Check loop counter to avoid infinite loop.
Check for abort condition.
Udate upstream parton system. Replace outgoing resonance by its first daughter. Then add remaining partons.
Now delete the new system, otherwise beam remnant handling breaks.
Restore dipole ends from upstream system, updating recoilers as needed.
Resonance does not exist any more: cannot be a radiator.
Check if recoiler needs to be updated.
Is recoiler in initial state?
Does recoiler still exist? (E.g., decayed resonance needs to be replaced by suitable decay product.)
Check for broken colour connections. TODO: Junction colour flows.
Add new dipole ends from resonance-decay system.
Update system (iSysRes -> iSysMot).
If resonance carried colour, check for new recoilers. (This is what allows recoils outside system below pTmerge.)
If resonance had QED charge, also allow to find new QED recoilers for radiators with same charge sign as mother.
Attempt to fix any dipoles that look broken.
Else this dipole end is good to go; copy as is.
Done.
Reimplemented from TimeShower.
|
overridevirtual |
Top-level routine to do a full time-like shower in resonance decay.
Add new system, automatically with two empty beam slots.
Loop over allowed range to find all final-state particles. Check if they all have same single mother => resonance decay.
Look for common resonance-decay mother.
Let prepare routine do the setup.
Begin evolution down in pT from hard pT scale.
Do a final-state emission (if allowed).
Keep on evolving until nothing is left to be done.
Return number of emissions that were performed.
Reimplemented from TimeShower.
|
overridevirtual |
Top-level routine for QED radiation in hadronic decay to two leptons.
Top-level routine for QED radiation in hadronic decay to two leptons. Intentionally only does photon radiation, i.e. no photon branchings.
Add new system, automatically with two empty beam slots.
Add incoming (decaying) particle; assumed = event[i1].mother1()
Charge type of two leptons tells whether MEtype is gamma*/Z0 or W+-.
Fill dipole-ends list.
Begin evolution down in pT from hard pT scale.
Begin loop over all possible radiating dipole ends.
Dipole properties.
Find maximum evolution scale for dipole.
Do QED evolution where relevant.
Update if found larger pT than current maximum. End dipole loop.
Do a final-state emission (if allowed).
Find initial radiator and recoiler particles in dipole branching.
Construct kinematics in dipole rest frame; massless emitter.
Kinematics reduction for radiator mass.
Store kinematics of branching in dipole rest frame.
Rotate and boost dipole products to the event frame.
Define new particles from dipole branching.
ME corrections can lead to branching being rejected.
Shower may occur at a displaced vertex, or for unstable particle.
Put new particles into the event record.
Update to new dipole ends.
Update other dipoles that also involved the radiator or recoiler.
Done with branching
Keep on evolving until nothing is left to be done.
Return number of emissions that were performed.
Reimplemented from TimeShower.
|
overridevirtual |
Update dipole list after each ISR emission.
Update dipole list after each ISR emission (so not used for resonances).
Start list of rescatterers that gave further changed systems in ISR.
Find new and old positions of incoming partons in the system.
Ditto for outgoing partons, except the newly created one.
Add non-final to list of rescatterers.
Swap beams to let 0 be side on which branching occured.
Loop over all dipole ends belonging to the system or to the recoil system, if different.
Replace radiator (always in final state so simple).
Replace ME partner (always in final state, if exists, so simple).
Recoiler: by default pick old one, only moved. Note excluded beam.
QCD recoiler: check if colour hooks up with new final parton.
QCD recoiler: check if colour hooks up with new beam parton.
QCD recoiler: emergency catch of mismatches e.g. when gluinos.
QED/photon recoiler: either to new particle or remains to beam.
Recoiler in another system: keep it as is.
Done. Kill dipole if failed to find new recoiler.
Kill weak dipoles if ISR emitted W/Z and only a single weak emission is allowed.
Set the weak radiated variable to true if already radiated.
Find new dipole end formed by colour index.
Find new dipole end formed by anticolour index.
Find new "charge-dipole" and "photon-dipole" ends.
Find new weak dipole. Uses the size of dipEnd to tell whether a new dipole is added.
If added new dipole update the ME correction and me partner.
If added new dipole, update the ME correction and me partner.
Start iterate over list of rescatterers - may be empty.
Identify systems that rescatterers belong to.
Find new and old positions of incoming partons in the system.
Ditto for outgoing partons.
Add non-final to list of rescatterers.
Loop over all dipole ends belonging to the system or to the recoil system, if different.
Replace radiator (always in final state so simple).
Replace ME partner (always in final state, if exists, so simple).
Replace recoiler.
End iterate over list of rescatterers.
Reimplemented from TimeShower.
1.8.11
