Class for a QED emission system. More...

#include <VinciaQED.h>

Inheritance diagram for QEDemitSystem:

Public Member Functions
void	init (BeamParticle beamAPtrIn, BeamParticle beamBPtrIn, int verboseIn) override
	Initialise settings for current run. More...

void	prepare (int iSysIn, Event &event, double q2CutIn, bool isBelowHadIn, vector< double > evolutionWindowsIn, AlphaEM alIn) override
	Prepare a parton system for photon emission evolution. More...

void	buildSystem (Event &event) override
	Set up antenna pairing for incoherent mode. More...

double	q2Next (Event &event, double q2Start) override
	Generate a trial scale. More...

bool	acceptTrial (Event &event) override
	Generate kinematics and check veto. More...

void	updateEvent (Event &event) override
	Update the envent. More...

bool	isInitial () override
	Branching type.

void	print () override
	Print the QED emit internal system. More...

double	aTrial (QEDemitElemental *ele, double sxj, double syj, double sxy)
	Trial antenna function. More...

double	aPhys (QEDemitElemental *ele, double sxj, double syj, double sxy)
	Physical antenna function. More...

double	pdfRatio (bool isA, double eOld, double eNew, int id, double Qt2)
	Ratio between PDFs.

Public Member Functions inherited from QEDsystem
	QEDsystem ()
	Constructor.

virtual	~QEDsystem ()=default
	Destructor.

void	initPtr (Info infoPtrIn, ParticleData particleDataPtrIn, PartonSystems partonSystemsPtrIn, Rndm rndmPtrIn, Settings settingsPtrIn, VinciaCommon vinComPtrIn)
	Initialize pointers. More...

virtual void	setVerbose (int verboseIn)

virtual void	updatePartonSystems ()
	Update the parton systems. More...

virtual bool	isSplitting ()
	Methods to tell which type of brancher this is.

Additional Inherited Members
Protected Attributes inherited from QEDsystem
Info *	infoPtr {}
	Pointers.

PartonSystems *	partonSystemsPtr {}

ParticleData *	particleDataPtr {}

Rndm *	rndmPtr {}

Settings *	settingsPtr {}

Logger *	loggerPtr {}

VinciaCommon *	vinComPtr {}

bool	isInitPtr

int	iSys
	Event system.

vector< Vec4 >	pNew

int	verbose
	Verbose setting.

int	jNew
	Information for partonSystems.

map< int, int >	iReplace

double	shat

Detailed Description

Class for a QED emission system.

Member Function Documentation

bool acceptTrial ( Event & event )

overridevirtual

Generate kinematics and check veto.

Check the veto. Return false if branching should be vetoed.

Mark trial as used.

Pre- and post-branching momenta.

Global recoil momenta.

II.

Pre-branching momenta.

Collect the recoiling final state particles.

Kinematics.

Check if new energies don't exceed hadronic maxima.

IF.

Check phase space.

Pre-branching momenta.

Kinematics. (Could in principle allow for global, but not done for now since more complicated and difference presumably too small to be relevant.)

Check if new energy doesn't exceed the hadronic maximum.

RF.

Check phase space.

Pre-branching momenta.

Collect the recoiling final state particles.

Do kinematics.

Replace momenta with boosted counterpart.

Check if nothing got messed up along the way.

FF.

Check phase space.

Pre-branching momenta.

Kinematics.

Dipole.

Construct recoiler momentum.

Check phase space.

Pre-branching momenta.

Kinematics.

Save.

Compute veto probability.

Add alpha veto.

Add antenna veto. Simple veto for eleTrial in eleVec.

Note that charge factor is included at generation step.

Construct full branching kernel for eleTrial in eleMat. Perform sector check too.

Build map of momenta & invariants with new photon.

Loop over the first column in eleMat.

If the particle is in eleTrial, use shower variables.

Otherwise get the momenta elsewhere

If global recoil, get them from pRec.

Find index.

Otherwise use momentum from event.

Then build aPhys.

Sector veto.

Add aPhysNew to aPhys.

Set aPhys to zeto if below zero.

Check overestimate.

Add antenna veto.

Add PDF veto.

Perform veto.

Done.

Implements QEDsystem.

double aPhys	(	QEDemitElemental *	ele,
		double	sxj,
		double	syj,
		double	sxy
	)

Physical antenna function.

FF.

Eikonal.

Check if x is a W or a fermion.

Check if y is a W or a fermion.

FF (dipole).

IF.

Eikonal + initial state fermion. The initial state is never a W and has no mass.

II.

Eikonal + fermion.

RF.

Eikonal.

Check if x is a W or a fermion

Check if y is a W or a fermion.

double aTrial	(	QEDemitElemental *	ele,
		double	sxj,
		double	syj,
		double	sxy
	)

Trial antenna function.

FF.

IF.

II.

RF.

void buildSystem ( Event & event )

overridevirtual

Set up antenna pairing for incoherent mode.

Verbose output.

Clear previous antennae.

Construct hungarian algorithm solver.

Below hadronization scale.

Find all (final-state) quarks and leptons.

For now, ignore quarks that are connected to junctions. In principle, we could add them, and any antijunction dittos.

Currently no showering below hadronisation scale if no leptons.

Sort all leptons into maps.

Find all colour strings.

Get initial quark and add to pseudo particle.

Find next colour-connected particle.

Get charge of pseudoparticle and sort into maps.

Strings with only quarks are total charge 1 or -1.

Strings with a diquark can be charge 2 or -2. Add these twice to list of recoilers.

If no leptons and overall hadronic system has charge = 0, do nothing.

Solve assignment problem.

Only keep antennae with at least one lepton.

If two leptons, add regular antenna.

If lepton + pseudoparticle, add dipole.

Above hadronization scale.

Collect relevant particles.

Catch cases (like hadron->partons decays) where an explicit charged mother may not have been added to the partonSystem as a resonance.

Guess that the decaying particle is mother of first parton.

Check daughter list consistent with whole system.

First check charge conservation.

Decide whether to use pairing (1) or coherent (2) algorithm.

Dipole-Pairing Algorithm.

Separate particles into charge types.

Get index in pos/negChargeTypes.

Flip charge contribution of initial state.

Clear list of charged particles.

Solve assignment problems.

Set up matrix of weights.

If either index is out of range. Add some random large weight.

Find solution.

Add pairings to list of emitElementals. Add unpaired particles to index list for coherent algorithm.

Create eleMat.

Compute overestimate constant.

Implements QEDsystem.

void init	(	BeamParticle *	beamAPtrIn,
		BeamParticle *	beamBPtrIn,
		int	verboseIn
	)

overridevirtual

Initialise settings for current run.

QEDemitSystem member functions.

Initialize settings for current run.

Verbose setting.

Set beam pointers.

QED mode for hard systems: pairing or multipole.

(If weak shower used for hard systems, use pairing as fallback.

QED mode for MPI cannot be more sophisticated than that of hard process.

Other QED settings.

Constants.

Initialized.

Implements QEDsystem.

void prepare	(	int	iSysIn,
		Event &	event,
		double	q2CutIn,
		bool	isBelowHadIn,
		vector< double >	evolutionWindowsIn,
		AlphaEM	alIn
	)

overridevirtual

Prepare a parton system for photon emission evolution.

Prepare a QED system.

Verbose output.

Input.

Build internal system.

Done.

Implements QEDsystem.

void print ( )

overridevirtual

Print the QED emit internal system.

Print the internal state of a QEDemitSystem.

Implements QEDsystem.

double q2Next	(	Event &	event,
		double	q2Start
	)

overridevirtual

Generate a trial scale.

Don't do anything if empty!

Check if qTrial is below the cutoff.

Find lower value from evolution window.

Generate a scale.

Pull scales from eleVec.

Pull scales from eleMat.

Verbose output.

Check if evolution window was crossed.

Reset all trials.

Otherwise return trial scale.

Implements QEDsystem.

void updateEvent ( Event & event )

overridevirtual

Update the envent.

Update the event after accepted emission.

Clear information for replacing later in partonSystems.

Invariants to determine order of photon mothers

Different procedures for dipoles and antennae. 1) If it is a dipole:

Set up new particles.

Shower may occur at a displaced vertex, or for unstable particle.

Add to event and save updates to be done on PartonSystems later.

Set old particles to negative.

Update mother-daughter structure.

Boost momenta and update.

Copy the recoiler.

Change the momentum.

Save update to be done on PartonSystems later.

2) If it is an RF:

Set up new particles.

Shower may occur at a displaced vertex, or for unstable particle.

Add branched particles to event.

Save update to be done on PartonSystems later.

Set old particles to negative.

Update event for global recoil.

Copy the recoiler.

Change the momentum.

Save update to be done on PartonSystems later.

3) If it is an antenna:

Set up new particles.

Shower may occur at a displaced vertex, or for unstable particle.

Add branched particles to event.

Save changes to be done on PartonSystems later.

Set old particles to negative.

Update everything.

Update beam daughters.

Update event for global recoil.

Copy the recoiler.

Change the momentum.

Save update to be done on PartonSystems later.

Save sHat for parton systems.

Update beams.

Check that x is always a with pz>0.

Update beam daughter.

Save sHat for PartonSystems.

Update beams.

Update event pointers.

Implements QEDsystem.

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

include/Pythia8/VinciaQED.h
src/VinciaQED.cc

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation