SimpleSpaceShower Class Reference

The SimpleSpaceShower class does spacelike showers. More...

#include <SimpleSpaceShower.h>

Inheritance diagram for SimpleSpaceShower:

Public Member Functions
	SimpleSpaceShower ()
	Constructor.
virtual	~SimpleSpaceShower () override
	Destructor.
virtual void	init (BeamParticle *beamAPtrIn, BeamParticle *beamBPtrIn) override
	Initialize generation. Possibility to force re-initialization by hand. 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 void	prepare (int iSys, Event &event, bool limitPTmaxIn=true) override
	Prepare system for evolution; identify ME. More...
virtual void	update (int iSys, Event &event, bool hasWeakRad=false) override
	Update dipole list after each FSR emission. More...
virtual double	pTnext (Event &event, double pTbegAll, double pTendAll, int nRadIn=-1, bool doTrialIn=false) override
	Select next pT in downwards evolution. More...
virtual bool	branch (Event &event) override
	ME corrections and kinematics that may give failure. More...
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	doRestart () const override
	Flag for failure in branch(...) that will force a retry of parton level.
virtual bool	wasGamma2qqbar () override
	Tell if latest scattering was a gamma->qqbar.
virtual bool	getHasWeaklyRadiated () override
	Tell whether ISR has done a weak emission.
virtual int	system () const override
	Tell which system was the last processed one.
virtual double	enhancePTmax () const override
	Potential enhancement factor of pTmax scale for hardest emission.
double	noEmissionProbability (double pTbegAll, double pTendAll, double m2dip, int id, int type, double s=-1., double x=-1.) override
double	pTnext (vector< SpaceDipoleEnd > dipEnds, Event event, double pTbegAll, double pTendAll, double m2dip, int id, int type, double s=-1., double x=-1.)
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)
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
Public Attributes inherited from SpaceShower
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 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
unordered_map< string, double >	enhanceISR
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

Detailed Description

The SimpleSpaceShower class does spacelike showers.

Member Function Documentation

bool branch ( Event &  event )

overridevirtual

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.

Also copy Hidden Valley colours where relevant.

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.

Calculate new event weight.

Reset enhance factors after use

Increment counter of rejected splittings.

Set enhanced trial.

For enhanced trial shower: always accept here, and then reject in History::trialShower with 1-1/enhance

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  )

overridevirtual

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.

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

bool initEnhancements ( )

overridevirtual

Initialize data members for application of enhancements.

Initialize the choices of uncertainty variations of the shower.

Reimplemented from SpaceShower.

bool initUncertainties ( )

overridevirtual

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

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

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

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

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. Current cm energy, in case it varies between events.

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

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

overridevirtual

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  )

overridevirtual

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.

Prevent emissions from unresolved beams.

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.

double pTnext	(	vector< SpaceDipoleEnd >	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 internal-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.

Check whether dipole end should be allowed to shower.

Determine lower cut for evolution for QCD

Find properties of dipole and radiating dipole end.

Note dipole mass correction when recoiler is a rescatter.

Dipole properties.

Reset emission properties.

Now do evolution in pT2, for QCD

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

overridevirtual

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:

• include/Pythia8/SimpleSpaceShower.h
• src/SimpleSpaceShower.cc