PYTHIA  8.312
Public Member Functions | Public Attributes | List of all members
SimpleTimeShower Class Reference

The SimpleTimeShower class does timelike showers. More...

#include <SimpleTimeShower.h>

Inheritance diagram for SimpleTimeShower:
TimeShower PhysicsBase

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.
 
WeightContainerweightContainerPtr {}
 

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
InfoinfoPtr = {}
 
SettingssettingsPtr = {}
 Pointer to the settings database.
 
ParticleDataparticleDataPtr = {}
 Pointer to the particle data table.
 
LoggerloggerPtr = {}
 Pointer to logger.
 
HadronWidthshadronWidthsPtr = {}
 Pointer to the hadron widths data table.
 
RndmrndmPtr = {}
 Pointer to the random number generator.
 
CoupSMcoupSMPtr = {}
 Pointers to SM and SUSY couplings.
 
CoupSUSYcoupSUSYPtr = {}
 
BeamSetupbeamSetupPtr = {}
 
BeamParticlebeamAPtr = {}
 
BeamParticlebeamBPtr = {}
 
BeamParticlebeamPomAPtr = {}
 
BeamParticlebeamPomBPtr = {}
 
BeamParticlebeamGamAPtr = {}
 
BeamParticlebeamGamBPtr = {}
 
BeamParticlebeamVMDAPtr = {}
 
BeamParticlebeamVMDBPtr = {}
 
PartonSystemspartonSystemsPtr = {}
 Pointer to information on subcollision parton locations.
 
SigmaTotalsigmaTotPtr = {}
 Pointers to the total/elastic/diffractive cross sections.
 
SigmaCombinedsigmaCmbPtr = {}
 
set< PhysicsBase * > subObjects
 
UserHooksPtr userHooksPtr
 

Detailed Description

The SimpleTimeShower class does timelike showers.

Member Function Documentation

bool branch ( Event event,
bool  isInterleaved = false 
)
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.

void init ( BeamParticle beamAPtrIn = 0,
BeamParticle beamBPtrIn = 0 
)
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.

bool initEnhancements ( )
overridevirtual

Initialize data members for application of enhancements.

Initialize the choices of uncertainty variations of the shower.

Reimplemented from TimeShower.

bool initUncertainties ( )
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.

bool limitPTmax ( Event event,
double  Q2Fac = 0.,
double  Q2Ren = 0. 
)
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.

void list ( ) const
overridevirtual

Print dipole list; for debug mainly.

Print the list of dipoles.

Header.

Loop over dipole list and print it.

Done.

Reimplemented from TimeShower.

double noEmissionProbability ( double  pTbegAll,
double  pTendAll,
double  m2dip,
int  idA,
int  type,
double  s = -1.,
double  x = -1. 
)
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.

void prepare ( int  iSys,
Event event,
bool  limitPTmaxIn = true 
)
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.

void prepareGlobal ( Event event)
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.

void prepareProcess ( Event process,
Event ,
vector< int > &   
)
overridevirtual

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.

double pTnext ( Event event,
double  pTbegAll,
double  pTendAll,
bool  isFirstTrial = false,
bool  doTrialIn = false 
)
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.

void rescatterUpdate ( int  iSys,
Event event 
)
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.

bool resonanceShower ( Event process,
Event event,
vector< int > &  iPosBefShow,
double  pTmerge 
)
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.

int shower ( int  iBeg,
int  iEnd,
Event event,
double  pTmax,
int  nBranchMax = 0 
)
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.

int showerQED ( int  i1,
int  i2,
Event event,
double  pTmax 
)
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.

void update ( int  iSys,
Event event,
bool  hasWeakRad = false 
)
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.


The documentation for this class was generated from the following files: