PYTHIA  8.303
Public Member Functions | 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 ()
 Destructor.
 
virtual void init (BeamParticle *beamAPtrIn=0, BeamParticle *beamBPtrIn=0)
 Initialize alphaStrong and related pTmin parameters. More...
 
virtual bool limitPTmax (Event &event, double Q2Fac=0., double Q2Ren=0.)
 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)
 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)
 Top-level routine for QED radiation in hadronic decay to two leptons. More...
 
virtual void prepareGlobal (Event &event)
 Global recoil: reset counters and store locations of outgoing partons. More...
 
virtual void prepare (int iSys, Event &event, bool limitPTmaxIn=true)
 Prepare system for evolution after each new interaction; identify ME. More...
 
virtual void rescatterUpdate (int iSys, Event &event)
 Update dipole list after a multiparton interactions rescattering. More...
 
virtual void update (int iSys, Event &event, bool hasWeakRad=false)
 Update dipole list after each ISR emission. More...
 
virtual double pTnext (Event &event, double pTbegAll, double pTendAll, bool isFirstTrial=false, bool doTrialIn=false)
 Select next pT in downwards evolution. More...
 
virtual bool branch (Event &event, bool isInterleaved=false)
 ME corrections and kinematics that may give failure. More...
 
virtual void list () const
 Print dipole list; for debug mainly. More...
 
virtual bool initUncertainties ()
 Initialize data members for calculation of uncertainty bands. More...
 
virtual bool getHasWeaklyRadiated ()
 Tell whether FSR has done a weak emission.
 
virtual int system () const
 Tell which system was the last processed one.
 
virtual double enhancePTmax ()
 Potential enhancement factor of pTmax scale for hardest emission.
 
virtual double pTLastInShower ()
 Provide the pT scale of the last branching in the above shower.
 
- 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)
 
- 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
 

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
}
 Enumerate the different status codes the event generation can have.
 
- Public Attributes inherited from TimeShower
MergingHooksPtr mergingHooksPtr {}
 Pointer to MergingHooks object for NLO merging.
 
WeightContainerweightContainerPtr {}
 
- 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 {}
 
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
 
- Protected Attributes inherited from PhysicsBase
InfoinfoPtr = {}
 
SettingssettingsPtr = {}
 Pointer to the settings database.
 
ParticleDataparticleDataPtr = {}
 Pointer to the particle data table.
 
HadronWidthshadronWidthsPtr = {}
 Pointer to the hadron widths data table.
 
RndmrndmPtr = {}
 Pointer to the random number generator.
 
CoupSMcoupSMPtr = {}
 Pointers to SM and SUSY couplings.
 
CoupSUSYcoupSUSYPtr = {}
 
BeamParticlebeamAPtr = {}
 
BeamParticlebeamBPtr = {}
 
BeamParticlebeamPomAPtr = {}
 
BeamParticlebeamPomBPtr = {}
 
BeamParticlebeamGamAPtr = {}
 
BeamParticlebeamGamBPtr = {}
 
BeamParticlebeamVMDAPtr = {}
 
BeamParticlebeamVMDBPtr = {}
 
PartonSystemspartonSystemsPtr = {}
 Pointer to information on subcollision parton locations.
 
SigmaTotalsigmaTotPtr = {}
 Pointer to the total/elastic/diffractive cross sections.
 
set< PhysicsBase * > subObjects
 
UserHooksPtr userHooksPtr
 

Detailed Description

The SimpleTimeShower class does timelike showers.

Member Function Documentation

bool branch ( Event event,
bool  isInterleaved = false 
)
virtual

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.

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.

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 gluon_HV 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.

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.

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;

Reject g emission where mass effects have reduced pT below cutoff.

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.

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.

Allow setting of new parton production vertex.

Mark original dipole partons as branched and set daughters/mothers.

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.

Check emission veto.

Calculate new event weight.

Reset enhance factors after usage.

Set events weights, so that these could be used externally.

Increment counter to handle counting of rejected emissions.

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.

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

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.

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.

W/Z emission, if only a single weak emission is allowed.

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.

Done.

Reimplemented from TimeShower.

void init ( BeamParticle beamAPtrIn = 0,
BeamParticle beamBPtrIn = 0 
)
virtual

Initialize alphaStrong and related pTmin parameters.

Initialize alphaStrong, alphaEM and related pTmin parameters.

Store input pointers for future use.

Main flags.

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.

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.

Fraction and colour factor of gluon emission off onium octat state.

Z0 and W+- properties needed for gamma/Z0 mixing and weak showers.

May have to fix up recoils related to rescattering.

Hidden Valley scenario with further shower activity.

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.

Properties for enhanced emissions.

Enable automated uncertainty variations.

Possibility to set parton vertex information.

Reimplemented from TimeShower.

bool initUncertainties ( )
virtual

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.

Store number of QCD variations (as separator to QED ones).

Get atomized variation strings, not necessarily all relevant for FSR

Parse each string in uniqueVarsIn to look for recognized keywords.

does the key match an fsr one?

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. 
)
virtual

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
virtual

Print dipole list; for debug mainly.

Print the list of dipoles.

Header.

Loop over dipole list and print it.

Done.

Reimplemented from TimeShower.

void prepare ( int  iSys,
Event event,
bool  limitPTmaxIn = true 
)
virtual

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)
virtual

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.

double pTnext ( Event event,
double  pTbegAll,
double  pTendAll,
bool  isFirstTrial = false,
bool  doTrialIn = false 
)
virtual

Select next pT 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 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.

void rescatterUpdate ( int  iSys,
Event event 
)
virtual

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.

int shower ( int  iBeg,
int  iEnd,
Event event,
double  pTmax,
int  nBranchMax = 0 
)
virtual

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 
)
virtual

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 
)
virtual

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: