PYTHIA  8.303
Public Member Functions | List of all members
SimpleSpaceShower Class Reference

The SimpleSpaceShower class does spacelike showers. More...

#include <SimpleSpaceShower.h>

Inheritance diagram for SimpleSpaceShower:
SpaceShower PhysicsBase

Public Member Functions

 SimpleSpaceShower ()
 Constructor.
 
virtual ~SimpleSpaceShower ()
 Destructor.
 
virtual void init (BeamParticle *beamAPtrIn, BeamParticle *beamBPtrIn)
 Initialize generation. Possibility to force re-initialization by hand. 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 void prepare (int iSys, Event &event, bool limitPTmaxIn=true)
 Prepare system for evolution; identify ME. More...
 
virtual void update (int iSys, Event &event, bool hasWeakRad=false)
 Update dipole list after each FSR emission. More...
 
virtual double pTnext (Event &event, double pTbegAll, double pTendAll, int nRadIn=-1, bool doTrialIn=false)
 Select next pT in downwards evolution. More...
 
virtual bool branch (Event &event)
 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 doRestart () const
 Flag for failure in branch(...) that will force a retry of parton level.
 
virtual bool wasGamma2qqbar ()
 Tell if latest scattering was a gamma->qqbar.
 
virtual bool getHasWeaklyRadiated ()
 Tell whether ISR has done a weak emission.
 
virtual int system () const
 Tell which system was the last processed one.
 
virtual double enhancePTmax () const
 Potential enhancement factor of pTmax scale for hardest emission.
 
- Public Member Functions inherited from SpaceShower
 SpaceShower ()=default
 Constructor.
 
virtual ~SpaceShower ()
 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 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 isSpacelike (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 SpaceShower
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 SpaceShower
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 SpaceShower.
 
bool uVarMuSoftCorr {}
 
bool uVarMPIshowers {}
 
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 > varQ2GQmuRfac
 
map< int, double > varG2QQmuRfac
 
map< int, double > varX2XGmuRfac
 
map< int, double > varG2GGcNS
 
map< int, double > varQ2QGcNS
 
map< int, double > varQ2GQcNS
 
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 SimpleSpaceShower class does spacelike showers.

Member Function Documentation

bool branch ( Event event)
virtual

ME corrections and kinematics that may give failure.

Kinematics of branching. Construct mother -> daughter + sister, with recoiler on other side.

Side on which branching occured.

Read in flavour and colour variables.

Recoil parton may be rescatterer, requiring special processing.

Read in kinematical variables.

Flag for gamma -> q qbar splittings.

Current beam particle.

If gamma -> q qbar splitting and nMPI > 1 then only save pT2 value and construct the kinematics in beamRemnants.

Read in MEtype. Four-vectors to reconstruct.

Rescatter: kinematics may fail; use the rescatterFail flag to tell parton level to try again.

Kinematics for II dipole. Construct kinematics of mother, sister and recoiler in old rest frame. Normally both mother and recoiler are taken massless.

More complicated kinematics when recoiler not massless. May fail.

Common final kinematics steps for both normal and rescattering.

Kinematics of IF dipole. Construct kinematics in old rest frame of daughter + colour partner. Mother and recoiler massless but massive colour partner.

Construct kinematics.

Do not change the momentum of the recoiler (in event frame).

Flat azimuthal angle.

Evaluate coefficient of azimuthal asymmetry from gluon polarization.

Bias phi distribution for polarization.

Boost back to the rest frame of daughter + recoiler.

Add azimuthal part to the kinematics.

Current event and subsystem size.

Save properties to be restored in case of user-hook veto of emission.

Check if the first emission should be checked for removal.

Check if doing uncertainty variations

Save further properties to be restored.

Take copy of existing system, to be given modified kinematics. Incoming negative status. Rescattered also negative, but after copy.

Define colour flow in branching. Default corresponds to f -> f + gamma.

q -> q + g and 50% of g -> g + g; need new colour.

qbar -> qbar + g and other 50% of g -> g + g; need new colour.

q -> g + q.

qbar -> g + qbar

g -> q + qbar but not gamma -> q + qbar.

g -> qbar + q but not gamma -> qbar + q.

q -> gamma + q.

qbar -> gamma + qbar.

gamma -> q + qbar.

gamma -> qbar + q.

Indices of partons involved. Add new sister.

References to the partons involved.

Allow setting of vertex for daughter parton, recoiler and sister.

Replace old by new mother; update new recoiler.

Update the colour partner in case of dipole recoil.

Update mother and daughter pointers; also for beams.

Special checks to set weak particles status equal to 47.

Normal azimuth and boost procedure for II dipole.

Find boost to old rest frame.

Initially select phi angle of branching at random.

Evaluate coefficient of azimuthal asymmetry from gluon polarization.

If interference: try to match sister (anti)colour to final state.

Boost final-state parton to current frame of new kinematics.

Bias phi distribution for polarization and interference.

Include rotation -phi on boost to old rest frame.

Find boost from old rest frame to event cm frame.

The boost to the new rest frame.

Alignment of radiator + recoiler to +- z axis, and rotation +phi. Note: with spacelike (E < 0) recoiler p'_x_mother < 0 can happen!

Boost to radiator + recoiler in event cm frame.

ME correction for weak emissions in the t-channel.

Start by finding the correct outgoing particles for the ME correction.

Rotate with -phi to keep correct for the later +phi rotation.

Calculate the actual weight.

If weighting fails then restore event record to state before emission.

Perform cumulative rotation/boost operation. Mother, recoiler and sister from old rest frame to event cm frame.

The rest from (and to) event cm frame.

Simpler special boost procedure for IF dipole.

Find boost from daughter + colour partner rest frame to the event frame.

Boost mother, sister and new colour partner (recoiler already fine).

Remove double counting. Only implemented for QCD hard processes and for the first emission.

Find outgoing particles.

Set start pT2 as pT2 of emitted particle and therefore no cut.

Check for angle between weak boson and quarks (require final state particle to be a fermion).

Check for angle between recoiler and radiator, if quark anti-quark pair, or if the recoiler is a gluon.

Clean up event if the emission should be removed.

Allow veto of branching. If so restore event record to before emission.

Recover delayed shower-accept probability for uncertainty variations. This should occur after ISR emission veto, because that is a phase space restriction.

Decide if we are going to accept or reject this branching. (Without wasting time generating random numbers if pAccept = 1.)

Default values 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 of rejected splittings.

If doing uncertainty variations, calculate accept/reject reweightings.

Veto if necessary. Return false if we decided to reject this branching.

Restore kinematics before returning.

Update list of partons in system; adding newly produced one.

Add dipoles for q -> g q, where the daughter is the gluon.

If original was a Drell-Yan, keep as Drell-Yan.

Add dipoles for q -> q gamma, where the daughter is the gamma.

If original was a Drell-Yan, keep as Drell-Yan.

dipEnd array may have expanded and been moved, so regenerate dipEndSel.

Set flag to tell that a weak emission has happened.

Update list of QCD emissions in side A and B in given iSysSel This is used to veto jets in W/z events.

Update info on radiating dipole ends (QCD, QED or weak).

Look if there is a IF dipole in case of dipole recoil.

Kill weak dipole if mother becomes gluon / photon.

Kill ME corrections after first emission for everything but weak showers.

Update info on recoiling dipole ends (QCD or QED).

Look if there is an IF dipole in case of dipole recoil.

Optionally also kill recoiler ME corrections after first emission.

Remove weak dipoles if we only want a single emission.

Set polarisation of mother for weak emissions.

Update info on beam remnants.

Redo choice of companion kind whenever new flavour.

Store branching values of current dipole. (For rapidity ordering.)

Update history if recoiler rescatters.

Start list of rescatterers that force changed kinematics.

Start iterate over list of such rescatterers.

Identify partons that induce or are affected by rescatter shift. In following Old is before change of kinematics, New after, Out scatterer in outstate and In in instate of another system. Daughter sequence is (iOutOld ->) iOutNew -> iInNew -> iInOld.

Copy incoming partons of rescattered system and hook them up.

Copy outgoing partons of rescattered system and hook them up.

Status could be negative for parton that rescatters in its turn.

Hook up new outgoing with new incoming parton.

Rescale recoiling incoming parton for correct invariant mass.

Rescatter: A previous boost may cause the light cone momentum of a rescattered parton to change sign. If this happens, tell parton level to try again.

Boost outgoing partons to new frame of incoming.

Update list of partons in system.

Update info on radiating dipole ends (QCD or QED).

Update info on beam remnants.

End iterate over list of rescatterers.

Check that beam momentum not used up by rescattered-system boosts.

If gamma -> q qbar valid with photon beam no need for remnants.

Done without any errors.

Reimplemented from SpaceShower.

void init ( BeamParticle beamAPtrIn,
BeamParticle beamBPtrIn 
)
virtual

Initialize generation. Possibility to force re-initialization by hand.

Initialize alphaStrong, alphaEM and related pTmin parameters.

Store input pointers for future use.

Main flags to switch on and off branchings.

Matching in pT of hard interaction to shower evolution.

Optionally force emissions to be ordered in rapidity/angle.

Charm, bottom and lepton mass thresholds.

Parameters of scale choices.

Parameters of alphaStrong generation.

Initialize alpha_strong generation.

Lambda for 5, 4 and 3 flavours.

Regularization of QCD evolution for pT -> 0. Can be taken same as for multiparton interactions, or be set separately.

Different parametrization for photon-photon collisions.

Calculate nominal invariant mass of events.

Set current pT0 scale according to the chosen parametrization.

Restrict pTmin to ensure that alpha_s(pTmin^2 + pT_0^2) does not blow up.

Parameters of alphaEM generation.

Initialize alphaEM generation.

Parameters of QED evolution.

Derived parameters of QCD evolution.

Parameters of weak evolution.

Various other parameters.

Do not do phiIntAsym if dipoleRecoil is on, to avoid doublecounting.

Z0 and W+- properties needed for weak showers.

Possibility of two predetermined hard emissions in event.

gamma->qqbar splittings handled differently with and without MPIs.

Optional dampening at small pT's when large multiplicities.

Possibility to allow user veto of emission step.

Default values for the weak shower.

Disallow simultaneous splitting and trial emission enhancements.

Properties for enhanced emissions.

Enable automated uncertainty variations.

Possibility to set parton vertex information.

Reimplemented from SpaceShower.

bool initUncertainties ( )
virtual

Initialize data members for calculation of uncertainty bands.

Initialize the choices of uncertainty variations of the shower.

Only initialize once

Populate lists of uncertainty variations for SimpleSpaceShower, by keyword.

Reset uncertainty variation maps.

Maps that must be known by TimeShower

List of keywords recognised by SimpleSpaceShower.

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

Get atomized variation strings, not necessarily all relevant for FSR

Expand uVars if PDFmembers has been chosen

Parse each string in uniqueVarsIn to look for recognized keywords.

does the key match an fsr one?

Parse each string in uVars to look for recognised keywords. Convert to lowercase (to be case-insensitive). Also remove "=" signs and extra spaces, so "key=value", "key = value" mapped to "key value"

Loop over all keywords.

Transform string to lowercase to avoid case-dependence.

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

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

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

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

Prepare system for evolution; identify ME.

Prepare system for evolution; identify ME. Routine may be called after multiparton interactions, for a new subystem.

Reset W/Z radiation flag and counters at first call for new event.

Find positions of incoming colliding partons.

Rescattered partons cannot radiate.

Reset dipole-ends list for first interaction. Also resonances.

Find matrix element corrections for system.

In case of DPS overwrite limitPTmaxIn by saved value.

Maximum pT scale for dipole ends.

Find dipole ends for QCD radiation. Note: colour type can change during evolution, so book also if zero.

Look if there is an IF dipole in case of dipole recoil.

Look if there is an IF dipole in case of dipole recoil.

Find dipole ends for QED radiation. Note: charge type can change during evolution, so book also if zero.

Special: photons have charge zero, but can evolve (only off Q for now)

Special: photons have charge zero, but can evolve (only off Q for now)

Find dipole ends for weak radiation. No right-handed W emission. Currently leptons are not allow to emit W bosons and only emissions from the hard process are included.

Normal internal setup.

Determine what type of 2 -> 2 process it is.

Nonidentical incoming flavours.

No quark matches the outgoing, choose randomly.

In case of same quark flavours, choose randomly.

Set up weak dipole ends for first incoming parton.

Set up weak dipole ends for second incoming parton.

External setup from infoPtr.

Get information.

Loop over dipoles.

Only consider ISR dipoles.

Find ME.

Find MEtype.

Find correct polarization, if it is already set use it. Otherwise pick randomly.

Add the dipoles.

Store the z and pT2 values of the last previous splitting when an event history has already been constructed.

Reimplemented from SpaceShower.

double pTnext ( Event event,
double  pTbegAll,
double  pTendAll,
int  nRadIn = -1,
bool  doTrialIn = false 
)
virtual

Select next pT in downwards evolution.

Select next pT in downwards evolution of the existing dipoles.

Current cm energy, in case it varies between events.

Starting values: no radiating dipole found.

Check if enhanced emissions should be applied.

Starting values for enhanced emissions.

Loop over all possible dipole ends.

Check whether dipole end should be allowed to shower.

Determine lower cut for evolution, for QCD or QED (q or l).

Find properties of dipole and radiating dipole end.

If reconstructed back to the beam photon, no further ISR emissions.

Note dipole mass correction when recoiler is a rescatter.

Prepare kinematics for final-state dipole recoil.

Stop if m2ColPair is negative.

Now do evolution in pT2, for QCD, QED or weak.

Update if found larger pT than current maximum.

End loop over dipole ends.

Return nonvanishing value if found pT is bigger than already found.

Reimplemented from SpaceShower.

void update ( int  iSys,
Event event,
bool  hasWeakRad = false 
)
virtual

Update dipole list after each FSR emission.

Remove weak dipoles if FSR already emitted a W/Z and only a single weak emission is permited. Update colour partner in case of dipole recoil.

Update colour partner in case of dipole recoil.

Reimplemented from SpaceShower.


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