PYTHIA  8.312
Public Member Functions | List of all members
QEDemitSystem Class Reference

Class for a QED emission system. More...

#include <VinciaQED.h>

Inheritance diagram for QEDemitSystem:
QEDsystem

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
InfoinfoPtr {}
 Pointers.
 
PartonSystemspartonSystemsPtr {}
 
ParticleDataparticleDataPtr {}
 
RndmrndmPtr {}
 
SettingssettingsPtr {}
 
LoggerloggerPtr {}
 
VinciaCommonvinComPtr {}
 
bool isInitPtr
 
int iSys
 Event system.
 
vector< Vec4pNew
 
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: