The DireSpace class does spacelike showers. More...

#include <DireSpace.h>

Inheritance diagram for DireSpace:

Public Member Functions
	DireSpace ()
	Constructor.

	DireSpace (MergingHooksPtr mergingHooksPtrIn, PartonVertexPtr)

virtual	~DireSpace ()
	Destructor.

virtual void	init (BeamParticle beamAPtrIn, BeamParticle beamBPtrIn)
	Initialize generation. Possibility to force re-initialization by hand. More...

bool	initSplits ()

void	reinitPtr (Info infoPtrIn, MergingHooksPtr mergingHooksPtrIn, DireSplittingLibrary splittingsPtrIn, DireInfo *direInfoPtrIn)

void	initVariations ()
	Initialize bookkeeping of shower variations. More...

void	clear ()
	Reset parton shower. More...

void	setWeightContainerPtr (DireWeightContainer *weightsIn)

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 double	enhancePTmax () const
	Potential enhancement factor of pTmax scale for hardest emission.

void	resetWeights ()
	Prepare system for evolution; identify ME. More...

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

virtual void	update (int, Event &, bool=false)
	Update dipole list after each ISR emission (so not used for resonances). More...

void	updateAfterII (int iSysSelNow, int sideNow, int iDipSelNow, int eventSizeOldNow, int systemSizeOldNow, Event &event, int iDaughter, int iMother, int iSister, int iNewRecoiler, double pT2, double xNew)
	Update dipole list after initial-initial splitting. More...

void	updateAfterIF (int iSysSelNow, int sideNow, int iDipSelNow, int eventSizeOldNow, int systemSizeOldNow, Event &event, int iDaughter, int iRecoiler, int iMother, int iSister, int iNewRecoiler, int iNewOther, double pT2, double xNew)
	Update dipole list after initial-initial splitting. More...

virtual double	pTnext (Event &event, double pTbegAll, double pTendAll, int nRadIn=-1, bool=false)
	Select next pT in downwards evolution. More...

double	newPoint (const Event &event)
	Select next pT in downwards evolution of the existing dipoles. More...

double	pTnext (vector< DireSpaceEnd > dipEnds, Event event, double pTbegAll, double pTendAll, double m2dip, int type, double s=-1., double x=-1.)

double	noEmissionProbability (double pTbegAll, double pTendAll, double m2dip, int id, int type, double s=-1., double x=-1.)
	Select next pT in downwards evolution of the existing dipoles. More...

virtual bool	branch (Event &event)
	Setup branching kinematics. More...

bool	branch_II (Event &event, bool=false, DireSplitInfo *split=nullptr)

bool	branch_IF (Event &event, bool=false, DireSplitInfo *split=nullptr)

virtual Event	clustered (const Event &state, int iRad, int iEmt, int iRecAft, string name)
	Setup clustering kinematics.

pair< Event, pair< int, int > >	clustered_internal (const Event &state, int iRad, int iEmt, int iRecAft, string name)

bool	cluster_II (const Event &state, int iRad, int iEmt, int iRecAft, int idRadBef, Particle &radBef, Particle &recBef, Event &partialState)

bool	cluster_IF (const Event &state, int iRad, int iEmt, int iRecAft, int idRadBef, Particle &radBef, Particle &recBef, Event &partialState)

double	pT2Space (const Particle &rad, const Particle &emt, const Particle &rec)

double	pT2_II (const Particle &rad, const Particle &emt, const Particle &rec)

double	pT2_IF (const Particle &rad, const Particle &emt, const Particle &rec)

double	zSpace (const Particle &rad, const Particle &emt, const Particle &rec)

double	z_II (const Particle &rad, const Particle &emt, const Particle &rec)

double	z_IF (const Particle &rad, const Particle &emt, const Particle &rec)

double	m2dipSpace (const Particle &rad, const Particle &emt, const Particle &rec)

double	m2dip_II (const Particle &rad, const Particle &emt, const Particle &rec)

double	m2dip_IF (const Particle &rad, const Particle &emt, const Particle &rec)

virtual map< string, double >	getStateVariables (const Event &state, int rad, int emt, int rec, string name)

virtual bool	isSpacelike (const Event &state, int iRad, int, int, string)

virtual vector< string >	getSplittingName (const Event &state, int iRad, int iEmt, int)

virtual double	getSplittingProb (const Event &state, int iRad, int iEmt, int iRecAft, string)

virtual bool	allowedSplitting (const Event &state, int iRad, int iEmt)

virtual vector< int >	getRecoilers (const Event &state, int iRad, int iEmt, string name)

virtual double	getCoupling (double mu2Ren, string name)

bool	isSymmetric (string name, const Particle rad, const Particle emt)

int	FindParticle (const Particle &particle, const Event &event, bool checkStatus=true)

virtual void	list () const
	Print dipole list; for debug mainly. More...

Event	makeHardEvent (int iSys, const Event &state, bool isProcess=false)

bool	validMomentum (const Vec4 &p, int id, int status)
	Check that particle has sensible momentum. More...

bool	validEvent (const Event &state, bool isProcess=false)
	Check colour/flavour correctness of state. More...

bool	validMotherDaughter (const Event &state)
	Check that mother-daughter-relations are correctly set. More...

int	FindCol (int col, vector< int > iExc, const Event &event, int type, int iSys=-1)
	Find index colour partner for input colour. More...

BeamParticle *	getBeamA ()
	Pointers to the two incoming beams.

BeamParticle *	getBeamB ()

CoupSM *	getCoupSM ()
	Pointer to Standard Model couplings.

double	alphasNow (double pT2, double renormMultFacNow=1., int iSys=0)

bool	isInit ()

double	m2Max (int iDip, const Event &state)
	Function to calculate the absolute phase-sace boundary for emissions.

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 bool	initUncertainties ()
	Initialize data members for calculation of uncertainty bands.

virtual bool	initEnhancements ()
	Initialize data members for application of enhancements.

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
bool	dryrun

DireWeightContainer *	weights

DireInfo *	direInfoPtr

unordered_map< string, DireSplitting * >	splits
	List of splitting kernels.

Public Attributes inherited from SpaceShower
MergingHooksPtr	mergingHooksPtr {}
	Pointer to MergingHooks object for NLO merging.

WeightContainer *	weightContainerPtr {}

Protected Attributes
int	iSysSel
	Store properties to be returned by methods.

double	pTmaxFudge

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

Friends
class	DireTimes

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.

Detailed Description

The DireSpace class does spacelike showers.

Member Function Documentation

bool allowedSplitting	(	const Event &	state,
		int	iRad,
		int	iEmt
	)

virtual

Only consider initial-state emissions.

Gluon emission is allowed.

Q -> G Q is allowed.

Gluon branching to quarks is allowed.

Photon emission is allowed.

Q -> A Q is allowed.

L -> A L is allowed.

Photon branching to quarks is allowed.

Photon branching to leptons is allowed.

Z-boson emission is allowed.

Reimplemented from SpaceShower.

double alphasNow	(	double	pT2,
		double	renormMultFacNow = `1.`,
		int	iSys = `0`
	)

Function to calculate the correct alphaS/2*Pi value, including renormalisation scale variations + threshold matching.

Get beam for PDF alphaS, if necessary.

Get alphaS(k*pT^2) and subtractions.

Get kernel order.

Use simple kernels for showering secondary scatterings.

Now find the necessary thresholds so that alphaS can be matched correctly.

Done.

bool branch ( Event & event )

virtual

Setup branching kinematics.

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

This function is a wrapper for setting up the branching kinematics.

Done.

Reimplemented from SpaceShower.

bool branch_IF	(	Event &	event,
		bool	trial = `false`,
		DireSplitInfo *	split = `nullptr`
	)

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

Side on which branching occured.

Read in flavour and colour variables.

int iOldOther = (side==1) ? partonSystemsPtr->getInB(iSysSelNow) : partonSystemsPtr->getInA(iSysSelNow);

Read in kinematical variables.

Allow splitting kernel to overwrite phase space variables.

Get particle masses.

Emission.

Radiator mass.

Emission mass

Force emission massless by default.

Adjust the dipole kinematical mass to accomodate masses after branching.

Calculate CS variables.

Allow splitting kernel to overwrite phase space variables.

Current event and subsystem size.

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

Check if the first emission shoild be checked for removal

Keep track of the system's full final for global recoil.

Less book-keeping for local recoil scheme.

For global recoil, take copy of existing system, to be given modified kinematics. Incoming negative status.

For 1->3 splitting, intermediate mother is a gluon.

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.

g -> qbar + q.

Swap colours if radiated gluon carries momentum fraction z

Now reset if splitting information is available.

Daughter color transferred to quark mother "1", sister anti-color transferred to sister "1" color.

Daughter anticolor transferred to antiquark mother "1", sister color transferred to sister "1" anticolor.

Sister color transferred to quark mother "1", daughter anti-color transferred to sister "1" color.

Reset dummy mother colours.

Sister anticolor transferred to antiquark mother "1", daughter color transferred to sister "1" anti-color.

Reset dummy mother colours.

Add mother. For 1->3 splitting, attach "dummy" mother.

Add recoiler. For 1->3 splitting, attach "dummy" recoiler.

Remember other initial state.

For 1->3 splitting, add "real" mother.

Add new sister.

For 1->3 splitting, add "real" recoiler.

Second sister particle for 1->3 splitting.

References to the partons involved.

Replace old by new mother; update old recoiler.

Update mother and daughter pointers; also for beams.

Regular massive kinematics for 1+1 -> 2+1 splitting

Massive kinematics, in two schemes.

Local scheme.

Get dipole 4-momentum.

Calculate derived variables.

Now construct radiator in lab frame.

Construct dummy overall momentum.

Now produce momenta of emitted and recoiling particles, and ensure good momentum conservation. (More than one try only necessary in rare numerical instabilities.

Give up after too many tries.

Now construct the transverse momentum vector in the dipole CM frame.

Allow splitting kernel to overwrite phase space variables.

Construct left-over dipole momentum by momentum conservation.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Construct recoiler momentum by momentum conservation.

Gather total momentum for subsequent check that total pT vanishes.

Collect remaining final state momenta.

Global scheme.

Get dipole 4-momentum.

Calculate derived variables.

double saj = uCS/xCS*(q2 - m2s) + (m2r+m2e) * (1-uCS)/xCS;

Disallow kinematically impossible transverse momentum.

Now construct recoiler in lab frame.

Construct left-over dipole momentum by momentum conservation.

Allow splitting kernel to overwrite phase space variables.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Contruct radiator momentum by momentum conservation.

Boost to realign the incoming radiator.

Boost to rest frame of incoming particles A and B.

After this, the radiator has vanishing pT.

Restore the momentum fraction of the incoming particle that did not participate in the splitting.

After this, the inactive beam returns to the correct energy fraction.

Set all momenta.

Rotate and boost all final state particles to absorb the pT of the radiator.

Transform the emission to the new lab frame.

Store masses.

Check momenta.

Rotate and boost all final state particles to absorb the pT of the

Test that enough beam momentum remains.

Restore old beams.

Apply ME correction if necessary.

Update and add newly produced particles.

Add newly produced particle.

Update and add newly produced particles.

Add newly produced particle.

Update dipoles and beams. Note: dipEndSel no longer valid after this.

Perform 1+1 -> 3 + 1 splitting.

Perform 1->3 splitting as two consecutive steps.

Save momenta before the splitting.

Massive kinematics, in two schemes.

Local scheme.

1->3 splitting as one IF and one ("recoil-less") FF step. (aij)_tilde (k)_tilde -> (a) (i) (jk) -> (a) (i) (j) (k) Recoiler k shifts mass in first and second step.

double m2a = getMass(idMother,2);

Get dipole 4-momentum.

Perform first IF step.

Get transverse and parallel vector.

Calculate derived variables.

Disallow kinematically impossible transverse momentum.

Now construct radiator in lab frame.

Construct left-over dipole momentum by momentum conservation.

Allow splitting kernel to overwrite phase space variables.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Construct recoiler momentum by momentum conservation.

Set particle momenta. Mother (a) already fixed. No need to introduce dummy intermediate.

Second sister (i) already fixed.

Intermediate off-shell recoiler. To be decayed in second step.

Perform FF step.

Set up kinematics as 1->2 decay in pjk rest frame.

Allow splitting kernel to overwrite phase space variables.

Construct FF dipole momentum.

Calculate CS variables.

Calculate derived variables.

Not possible to construct kinematics if kT2 < 0.0

NaN kT2 can happen for a 1->3 splitting in which the g->QQ~ produces massive quarks Q.

Construct left-over dipole momentum by momentum conservation.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new radiator momentum.

Contruct the emission momentum by momentum conservation.

Set particle momenta.

Check momenta.

Test that enough beam momentum remains.

Restore old beams.

Update dipoles and beams, for first step. Note: dipEndSel no longer valid after this.

Update flavours, colours, status after first step.

Exempt intermediate off-shell recoiler from Pythia momentum checks.

Update dipoles and beams, for second step.

Global scheme.

1->3 splitting as two consecutive IF steps.

Perform first IF step.

Get dipole 4-momentum.

Calculate derived variables.

Disallow kinematically impossible transverse momentum.

Now construct recoiler in lab frame.

Construct left-over dipole momentum by momentum conservation.

Allow splitting kernel to overwrite phase space variables.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Contruct radiator momentum by momentum conservation.

Boost to realign the incoming radiator.

Boost to rest frame of incoming particles A and B.

After this, the radiator has vanishing pT.

Restore the momentum fraction of the incoming particle that did not participate in the splitting.

After this, the inactive beam returns to the correct energy fraction.

Boost and rotate final-state momenta.

Set all momenta.

Mother (a) already fixed. No need to introduce dummy intermediate.

Rotate and boost all final state particles to absorb the pT of the radiator.

Skip sister(i) and intermediate recoiler (jk), since already transformed.

Perform FF step.

Set up kinematics as 1->2 decay in pjk rest frame.

Allow splitting kernel to overwrite phase space variables.

Construct FF dipole momentum.

Calculate CS variables.

Calculate derived variables.

Not possible to construct kinematics if kT2 < 0.0

NaN kT2 can happen for a 1->3 splitting in which the g->QQ~ produces massive quarks Q.

Construct left-over dipole momentum by momentum conservation.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new radiator momentum.

Contruct the emission momentum by momentum conservation.

Set particle momenta.

Check momenta.

Check invariants.

Update dipoles and beams, for first step. Note: dipEndSel no longer valid after this.

Update flavours, colours, status after first step.

Exempt intermediate off-shell recoiler from Pythia momentum checks.

Update dipoles and beams, for second step.

Done with 1->3 splitting kinematics.

Temporarily set the daughters in the beams to zero, to allow mother-daughter relation checks.

Check if mother-daughter relations are correctly set. Check only possible if no MPI are present.

Restore correct daughters in the beams.

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

This case is identical to the case where the probability to accept the emission was indeed zero all along. In this case, neither acceptProbability nor rejectProbability would have been filled. Thus, remove the relevant entries from the weight container!

Clear accept/reject weights.

Store positions of new particles.

Set shower weight.

Store positions of new soft particles for (FSR) evolution.

Clear accept/reject weights.

Done without any errors.

bool branch_II	(	Event &	event,
		bool	trial = `false`,
		DireSplitInfo *	split = `nullptr`
	)

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

Side on which branching occured.

Read in flavour and colour variables.

Name of the splitting.

Read in kinematical variables.

Allow splitting kernel to overwrite phase space variables.

Get particle masses.

Emission.

Radiator mass.

Recoiler mass

Emission mass

Force emission massless by default.

Allow splitting kernel to overwrite phase space variables.

Get dipole 4-momentum.

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.

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

For 1->3 splitting, intermediate mother is a gluon.

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.

g -> qbar + q.

Swap colours if radiated gluon carries momentum fraction z

Now reset if splitting information is available.

Daughter color transferred to quark mother "1", sister anti-color transferred to sister "1" color.

Daughter anticolor transferred to antiquark mother "1", sister color transferred to sister "1" anticolor.

Sister color transferred to quark mother "1", daughter anti-color transferred to sister "1" color.

Reset dummy mother colours.

Sister anticolor transferred to antiquark mother "1", daughter color transferred to sister "1" anti-color.

Reset dummy mother colours.

Indices of partons involved. Add new sister. For 1->3 splitting, replace mother by dummy and attach "real" mother later.

Second sister particle for 1->3 splitting.

References to the partons involved.

Replace old by new mother; update new recoiler.

Update mother and daughter pointers; also for beams.

Regular massive kinematics for 1+1 -> 2+1 splitting

Calculate derived variables.

Not possible to construct kinematics if kT2 < 0.0

Now construct radiator in lab frame.

Set momenta.

Store momenta in case momentum construction fails.

Copy all unchanged particles to NewEvent

Construct dummy overall momentum.

Now produce momenta of emitted and final state particles, and ensure good momentum conservation. (More than one try only necessary in rare numerical instabilities.

Give up after too many tries.

Now construct the transverse momentum vector in the dipole CM frame.

Allow splitting kernel to overwrite phase space variables.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Set all momenta.

Gather total momentum for subsequent check that total pT vanishes.

Transform all final state momenta to distribute recoil.

If Lorentz transformation fails to be accurate enough, set pSum to force another trial.

Collect remaining final state momenta.

Check momenta.

Test that enough beam momentum remains.

Restore old beams.

Apply ME correction if necessary.

Update dipoles and beams. Note: dipEndSel no longer valid after this.

Perform 1+1 -> 3 + 1 splitting.

1->3 splitting as one II and one FF step.

Perform II step.

Calculate derived variables.

Disallow kinematically impossible transverse momentum.

Now construct radiator in lab frame.

Set momenta. Mother acts purely as a dummy, since we already have the final incoming momentum. Recoiler unchanged.

Now construct the transverse momentum vector in the dipole CM frame.

Allow splitting kernel to overwrite phase space variables.

Set up transverse momentum vector by using two perpendicular four-vectors

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new emission momentum.

Set all momenta.

Perform FF step.

Allow splitting kernel to overwrite phase space variables.

Calculate CS variables.

Construct FF dipole momentum.

Calculate derived variables.

Not possible to construct kinematics if kT2 < 0.0

NaN kT2 can happen for a 1->3 splitting in which the g->QQ~ produces massive quarks Q.

Construct left-over dipole momentum by momentum conservation.

Set up transverse momentum vector by using two perpendicular four-vectors.

Construct new radiator momentum.

Set particle momenta.

Gather total momentum for subsequent check that total pT vanishes.

Transform all final state momenta to distribute recoil.

Check momenta.

Check invariants

Check that total pT vanishes.

Test that enough beam momentum remains.

Restore old beams.

Update dipoles and beams. Note: dipEndSel no longer valid after this.

Update flavours, colours, status.

Update dipoles and beams. Note: dipEndSel no longer valid after this.

Temporarily set the daughters in the beams to zero, to allow mother-daughter relation checks.

Check if mother-daughter relations are correctly set. Check only possible if no MPI are present.

Restore correct daughters in the beams.

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

This case is identical to the case where the probability to accept the emission was indeed zero all along. In this case, neither acceptProbability nor rejectProbability would have been filled. Thus, remove the relevant entries from the weight container!

weights->calcWeight(pT2);

Clear accept/reject weights.

Store positions of new particles.

Set shower weight.

Store positions of new soft particles for (FSR) evolution.

Clear accept/reject weights.

Done without any errors.

void clear ( )

Reset parton shower.

Clear weighted shower book-keeping.

bool cluster_IF	(	const Event &	state,
		int	iRad,
		int	iEmt,
		int	iRecAft,
		int	idRadBef,
		Particle &	radBef,
		Particle &	recBef,
		Event &	partialState
	)

Calculate CS variables.

Get particle masses.

double m2e = 0.0;

Adjust the dipole kinematical mass to accomodate masses after branching.

Check phase space contraints.

Massive kinematics, in two schemes.

Get dipole 4-momentum.

Calculate derived variables.

double sjk = 2.*state[iRecAft].p()*state[iEmt].p();

Now construct radiator in lab frame.

Contruct recoiler momentum by momentum conservation.

Get dipole 4-momentum.

Calculate derived variables.

Now construct recoiler in lab frame.

Contruct radiator momentum by momentum conservation.

Boost to realign the incoming radiator.

Boost to rest frame of incoming particles A and B.

After this, the radiator has vanishing pT.

Restore the momentum fraction of the incoming particle that did not participate in the splitting.

After this, the inactive beam returns to the correct energy fraction.

Set all momenta.

Rotate and boost all final state particles to absorb the pT of the radiator.

Done

bool cluster_II	(	const Event &	state,
		int	iRad,
		int	iEmt,
		int	iRecAft,
		int	idRadBef,
		Particle &	radBef,
		Particle &	recBef,
		Event &	partialState
	)

Calculate CS variables.

Get particle masses.

Check phase space contraints.

Set up kinematics.

Set mass of initial recoiler to zero

Done

pair< Event, pair< int, int > > clustered_internal	(	const Event &	state,
		int	iRad,
		int	iEmt,
		int	iRecAft,
		string	name
	)

Flags for type of radiation

Construct the clustered event

Copy all unchanged particles to NewEvent

Copy all the junctions one by one

Find an appropriate scale for the hard process

Initialise scales for new event

Set properties of radiator/recoiler after the clustering Recoiler properties will be unchanged

Find flavour of radiator before splitting

Put dummy values for colours

Reset status if the reclustered radiator is a resonance.

Put mass for radiator and recoiler

Construct momenta and colours of clustered particles

Clustering not possible, e.g. because not in allowed phase space.

Put some dummy production scales for RecBefore, RadBefore

Append new recoiler and find new radiator colour

Assign the correct colour to re-clustered radiator.

Build the clustered event

Copy system and incoming beam particles to outState

Copy all the junctions one by one

Initialise scales for new event

Save position of radiator in new event record

Append first incoming particle

Find second incoming in input event

Append second incoming particle

Find second incoming in input event

Append new recoiler if not done already

Append new radiator if not done already

Force incoming partons to have "hard event" status

Append intermediate particle (careful not to append reclustered recoiler)

Append final state particles, resonances first

Then start appending partons

Then partons (not reclustered recoiler)

Force partons to have "hard event" status

Then the rest

Find intermediate and respective daughters

Find daughters in output state

If both daughters found, done Else put first final particle as first daughter and last final particle as second daughter

Set daughters and mothers

Find range of final state partons

Update event properties

Almost there... If an intermediate coloured parton exists which was directly colour connected to the radiator before the splitting, and the radiator before and after the splitting had only one colour, problems will arise since the colour of the radiator will be changed, whereas the intermediate parton still has the old colour. In effect, this means that when setting up a event for trial showering, one colour will be free. Hence, check for an intermediate coloured triplet resonance has been colour-connected to the "old" radiator. Find resonance

Find resonance connected to initial colour

Find resonance connected to initial anticolour

Find resonance connected to final state colour

Find resonance connected to final state anticolour

Now find this resonance in the reclustered state

Find reclustered radiator colours

Find resonance radiator colours

Check if any of the reclustered radiators colours match the resonance

If a resonance has been found, but no colours match, change the colour of the resonance

If a resonance has been found, but no colours match, and the position of the resonance in the event record has been changed, update the radiator mother

Now reset the beams, if necessary.

Now check event.

Check if the state is valid. If not, return empty state.

Done

int FindCol	(	int	col,
		vector< int >	iExc,
		const Event &	event,
		int	type,
		int	iSys = `-1`
	)

Find index colour partner for input colour.

Search event record for matching colour & anticolour

Skip if this index is excluded.

Search event record for matching colour & anticolour

Skip if this index is excluded.

Check incoming

if no matching colour / anticolour has been found, return false

int FindParticle	(	const Particle &	particle,
		const Event &	event,
		bool	checkStatus = `true`
	)

Auxiliary function to return the position of a particle. Should go int Event class eventually!

Function to in the input event find a particle with quantum numbers matching those of the input particle IN Particle : Particle to be searched for Event : Event to be searched in OUT int : > 0 : Position of matching particle in event < 0 : No match in event

vector< int > getRecoilers	(	const Event &	state,
		int	iRad,
		int	iEmt,
		string	name
	)

virtual

List of recoilers.

Reimplemented from SpaceShower.

virtual vector<string> getSplittingName	(	const Event &	state,
		int	iRad,
		int	iEmt,
		int
	)

inlinevirtual

From Pythia version 8.215 onwards. Return a string identifier of a splitting. Usage: getSplittingName( const Event& event, int iRad, int iEmt, int iRec)

Reimplemented from SpaceShower.

double getSplittingProb	(	const Event &	state,
		int	iRad,
		int	iEmt,
		int	iRecAft,
		string	name
	)

virtual

From Pythia version 8.215 onwards. Return the splitting probability. Usage: getSplittingProb( const Event& event, int iRad, int iEmt, int iRec)

Compute splitting probability. From Pythia version 8.215 onwards.

Get kernel order.

Do nothing if kernel says so, e.g. to avoid infinite loops if the kernel uses the History class.

Disallow below cut-off.

Upate type if this is a massive splitting.

Adjust the dipole kinematical mass to accomodate masses after branching.

Check phase space contraints.

Calculate splitting probability.

Get phi angle.

Setup splitting information.

Get splitting probability.

Get complete kernel.

Reset again.

Multiply with 1/pT^2. Note: No additional Jacobian factors, since for our choice of variables, we always have Jacobian_{mass to CS} * Jacobian_{CS to DIRE} * Propagator = 1/pT2

Make splitting probability positive if ME corrections are available.

Note: The additional factor 1/xCS for rescaling the initial flux is NOT included, so that we can apply PDF ratios [x1 f(x1)] / [x0 f(x0) ] later.

Reimplemented from SpaceShower.

map< string, double > getStateVariables	(	const Event &	state,
		int	rad,
		int	emt,
		int	rec,
		string	name
	)

virtual

From Pythia version 8.218 onwards. Return the evolution variable. Usage: getStateVariables( const Event& event, int iRad, int iEmt, int iRec, string name) Important note:

This map must contain an entry for the shower evolution variable, specified with key "t".
This map must contain an entry for the shower evolution variable from which the shower would be restarted after a branching. This entry must have key "tRS",
This map must contain an entry for the argument of used for the branching. This entry must have key "scaleAS".
This map must contain an entry for the argument of the PDFs used for the branching. This entry must have key "scalePDF".

From Pythia version 8.218 onwards. Return the evolution variable and splitting information. See header for more comments.

State variables for a shower splitting (radBef,recBef) –> (rad,emt,rec)

Book-keeping for particle before emission.

Variables defining the PS starting scales.

In this case, insert only dummy information except for PDF scale.

Find the shower starting scale. Find positions of incoming colliding partons.

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Now find non-QCD dipoles and/or update the existing dipoles.

Get x for both beams.

Store invariant masses of all dipole ends.

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.

Colour factors.

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 (inherited from Pythia).

Parameters of alphaStrong generation.

Set flavour thresholds by default Pythia masses, unless zero.

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.

Calculate nominal invariant mass of events. Set current pT0 scale to zero.

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

Derived parameters of QCD evolution.

Allow massive incoming particles. Currently not supported by Pythia.

Create maps of accept/reject weights

Set splitting library, if already exists.

Mode for higher-order kernels.

Various other parameters.

Possibility of two predetermined hard emissions in event.

Optional dampening at small pT's when large multiplicities.

Possibility to allow user veto of emission step.

Done.

Reimplemented from SpaceShower.

void initVariations ( )

Initialize bookkeeping of shower variations.

Create maps of accept/reject weights

Done.

virtual bool isSpacelike	(	const Event &	state,
		int	iRad,
		int	,
		int	,
		string
	)

inlinevirtual

From Pythia version 8.215 onwards. Check if attempted clustering is handled by timelike shower Usage: isSpacelike( const Event& event, int iRad, int iEmt, int iRec, string name)

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.

bool DireSpace::limitPTmax( Event& event, double Q2Fac, double) {

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.

Event makeHardEvent	(	int	iSys,
		const Event &	state,
		bool	isProcess = `false`
	)

Try to find incoming particle in other systems, i.e. if the current system arose from a resonance decay.

Attach the first incoming particle.

Attach the second incoming particle.

Careful when builing the sub-events: A particle that is currently intermediate in one system could be the pirogenitor of another system, i.e. when resonance decays are present. In this case, the intermediate particle in the current system should be final.

Set daughters of initial particles.

double newPoint ( const Event & event )

Select next pT in downwards evolution of the existing dipoles.

Starting values: no radiating dipole found.

Loop over all possible dipole ends.

Check whether dipole end should be allowed to shower.

Find properties of dipole and radiating dipole end.

Note dipole mass correction when recoiler is a rescatter.

Dipole properties.

Reset emission properties.

Reset properties of 1->3 splittings.

Now do evolution in pT2, for QCD

Update if found larger pT than current maximum.

End loop over dipole ends.

Unable to produce splitting.

Return nonvanishing value if found pT bigger than already found.

double noEmissionProbability	(	double	pTbegAll,
		double	pTendAll,
		double	m2dip,
		int	id,
		int	type,
		double	s = `-1.`,
		double	x = `-1.`
	)

virtual

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.

Make dummy event with two entries.

Setup two dipole ends for each flavor combination.

Add recoiler. For 1->3 splitting, attach "dummy" recoiler.

Now loop through possible recoilers.

Store participating partons as first set in list of all systems.

Find positions of incoming colliding partons.

Set starting scale.

Set output.

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

Reimplemented from SpaceShower.

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

virtual

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

Calculate remainder shower weight after MPI.

Clear accept/reject weights.

Store number of MPI, in case a subsequent MPI forces calculation and reset of shower weights.

Find positions of incoming colliding partons.

Rescattered partons cannot radiate.

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

Set splitting library.

Find matrix element corrections for system.

In case of DPS overwrite limitPTmaxIn by saved value.

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

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Now find non-QCD dipoles and/or update the existing dipoles.

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

Now update all dipoles.

Counter of proposed emissions.

Clear weighted shower book-keeping.

Reimplemented from SpaceShower.

double pT2Space	(	const Particle &	rad,
		const Particle &	emt,
		const Particle &	rec
	)

inline

Return ordering variable. From Pythia version 8.215 onwards no longer virtual.

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.

Remember if this is a trial emission.

Loop over all possible dipole ends.

Limit final state multiplicity. For debugging only

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.

Reset properties of 1->3 splittings.

Now do evolution in pT2, for QCD

Update if found larger pT than current maximum.

End loop over dipole ends.

Insert additional weights.

Spacelike shower tries to propose state changes last. If no state change occurs and timelike showers have also terminated, finalize the event with e.g. decaying resonances etc.

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

Reimplemented from SpaceShower.

double pTnext	(	vector< DireSpaceEnd >	dipEnds,
		Event	event,
		double	pTbegAll,
		double	pTendAll,
		double	m2dip,
		int	type,
		double	s = `-1.`,
		double	x = `-1.`
	)

Select next pT in downwards evolution, based only on dipole mass and incoming momentum fraction.

Starting values: no radiating dipole found.

Set splitting library.

Counter of proposed emissions.

Clear weighted shower book-keeping.

Loop over all possible dipole ends.

Limit final state multiplicity. For debugging only

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.

Reset properties of 1->3 splittings.

Now do evolution in pT2, for QCD

Update if found larger pT than current maximum.

End loop over dipole ends.

Insert additional weights.

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

void reinitPtr	(	Info *	infoPtrIn,
		MergingHooksPtr	mergingHooksPtrIn,
		DireSplittingLibrary *	splittingsPtrIn,
		DireInfo *	direInfoPtrIn
	)

inline

Initialize various pointers. (Separated from rest of init since not virtual.)

void resetWeights ( )

Prepare system for evolution; identify ME.

Function to reset generic things (called from DireTimes::prepareGlobal!)

Clear accept/reject weights.

void update	(	int	iSys,
		Event &	event,
		bool	= `false`
	)

virtual

Update dipole list after each ISR emission (so not used for resonances).

Update dipole list after each FSR emission. Usage: update( iSys, event).

Find positions of incoming colliding partons.

Rescattered partons cannot radiate.

Find matrix element corrections for system.

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Find dipole end formed by colour index.

Find dipole end formed by anticolour index.

Now find non-QCD dipoles and/or update the existing dipoles.

Now update all dipoles.

Reimplemented from SpaceShower.

void updateAfterIF	(	int	iSysSelNow,
		int	sideNow,
		int	iDipSelNow,
		int	eventSizeOldNow,
		int	systemSizeOldNow,
		Event &	event,
		int	iDaughter,
		int	iRecoiler,
		int	iMother,
		int	iSister,
		int	iNewRecoiler,
		int	iNewOther,
		double	pT2,
		double	xNew
	)

Update dipole list after initial-initial splitting.

Update the number of proposed emissions.

Bookkeep shower-induced resonances.

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

Update and add newly produced particles.

Add newly produced particle.

Remember shower-induced resonances.

Add newly produced particle.

Get new center-of-mass energy

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

Update info on radiating dipole ends (QCD).

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

Update info on beam remnants.

Redo choice of companion kind whenever new flavour.

Update ISR dipoles.

Pointer to selected dipole no longer valid after update, thus unset.

void updateAfterII	(	int	iSysSelNow,
		int	sideNow,
		int	iDipSelNow,
		int	eventSizeOldNow,
		int	systemSizeOldNow,
		Event &	event,
		int	iDaughter,
		int	iMother,
		int	iSister,
		int	iNewRecoiler,
		double	pT2,
		double	xNew
	)

Update dipole list after initial-initial splitting.

Update the number of proposed emissions.

Bookkeep shower-induced resonances.

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

Remember shower-induced resonances.

Get new center-of-mass energy

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

Update info on radiating dipole ends (QCD).

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

Update info on beam remnants.

Redo choice of companion kind whenever new flavour.

Update ISR dipoles.

Pointer to selected dipole no longer valid after update, thus unset.

bool validEvent	(	const Event &	state,
		bool	isProcess = `false`
	)

Check colour/flavour correctness of state.

Check for NaNs or INFs.

Done if the state is already broken.

Check if event is coloured

Check colour of quarks

No corresponding anticolour in final state

No corresponding colour in initial state

Check anticolour of antiquarks

No corresponding colour in final state

No corresponding anticolour in initial state

No uncontracted colour (anticolour) charge of gluons

No corresponding anticolour in final state

No corresponding colour in initial state

No corresponding colour in final state

No corresponding anticolour in initial state

Check charge sum in initial and final state

Check if particles are on mass shell

Check that overall pT is vanishing.

Done with loop over systems.

bool validMomentum	(	const Vec4 &	p,
		int	id,
		int	status
	)

Check that particle has sensible momentum.

Check colour/flavour correctness of state.

Check for NaNs and INFs.

Check if particles is on mass shell

Do not check on-shell condition for massive intermediate (!) resonances. Assuming all non-SM particles are heavy here!

Check for negative energies.

Done

bool validMotherDaughter ( const Event & state )

Check that mother-daughter-relations are correctly set.

Loop through the event and check that there are beam particles.

Check that mother and daughter lists not empty where not expected to.

Check that the particle appears in the daughters list of each mother.

Check that the particle appears in the mothers list of each daughter.

Mother-daughter relations not correct if any lists do not match.

Done.

double zSpace	(	const Particle &	rad,
		const Particle &	emt,
		const Particle &	rec
	)

inline

Return auxiliary variable. From Pythia version 8.215 onwards no longer virtual.

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

include/Pythia8/DireSpace.h
src/DireSpace.cc

Public Member Functions

Public Attributes

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation