#include <VinciaFSR.h>

Inheritance diagram for VinciaFSR:

Public Member Functions
	VinciaFSR ()
	Constructor.

	~VinciaFSR ()
	Destructor.

void	init (BeamParticle beamAPtrIn=0, BeamParticle beamBPtrIn=0) override
	Initialize alphaStrong and related pTmin parameters (TimeShower). More...

void	onBeginEvent () override
	Force reset at beginning of each event.

bool	limitPTmax (Event &event, double q2Fac, double q2Ren) override
	Possible limitation of first emission (TimeShower). More...

int	shower (int iBeg, int iEnd, Event &event, double pTmax, int nBranchMax=0) override

int	showerQED (int iBeg, int iEnd, Event &event, double pTmax) override
	Method to add QED showers in hadron decays (TimeShower). More...

int	showerQEDafterRemnants (Event &event) override

void	prepareProcess (Event &process, Event &event, vector< int > &iPosBefShow) override

void	prepare (int iSys, Event &event, bool limitPTmaxIn) override
	Prepare system for evolution (TimeShower). More...

void	update (int iSys, Event &event, bool hasWeakRad=false) override
	Update antenna list after each ISR emission (TimeShower). More...

double	pTnext (Event &event, double pTbegAll, double pTendAll, bool isFirstTrial=false, bool doTrialIn=false) override
	Select next pT in downwards evolution (TimeShower). More...

double	pTnextResDec () override
	Select next pT for interleaved resonance decays.

bool	branch (Event &event, bool isInterleaved=false) override
	Branch event, including accept/reject veto (TimeShower). More...

bool	resonanceShower (Event &process, Event &event, vector< int > &iPos, double qRestart) override

void	list () const override
	Utility to print antenna list; for debug mainly (TimeShower). More...

bool	getHasWeaklyRadiated () override
	Tell whether FSR has done a weak emission. More...

int	system () const override
	Tell which system was the last processed one (TimeShower).

double	enhancePTmax () override

double	pTLastInShower () override

void	initVinciaPtrs (VinciaColour colourPtrIn, shared_ptr< VinciaISR > isrPtrIn, MECs mecsPtrIn, Resolution resolutionPtrIn, VinciaCommon vinComPtrIn, VinciaWeights *vinWeightsPtrIn)
	Initialise pointers to Vincia objects. More...

void	setDiagnosticsPtr (shared_ptr< VinciaDiagnostics > diagnosticsPtrIn)
	Set pointer to object to use for diagnostics and profiling.

void	setEWShowerPtr (VinciaModulePtr ewShowerPtrIn)
	Set EW shower module.

void	setQEDShowerHardPtr (VinciaModulePtr qedShowerPtrIn)
	Set QED shower module for hard scattering (and resonance decays).

void	setQEDShowerSoftPtr (VinciaModulePtr qedShowerPtrIn)
	Set QED shower module for MPI and hadronization.

void	initAntPtr (AntennaSetFSR *antSetIn)
	Initialize pointers to antenna sets.

AntennaFunction *	getAntFunPtr (enum AntFunType antFunType)
	Wrapper function to return a specific antenna inside an antenna set.

vector< enum AntFunType >	getAntFunTypes ()
	Wrapper to return all AntFunTypes that are contained in antSetPtr.

void	header ()
	Print header information (version, settings, parameters, etc.). More...

void	setIsTrialShower (bool isTrialShowerIn)
	Communicate information about trial showers for merging.

void	setIsTrialShowerRes (bool isTrialShowerResIn)

void	saveBornState (int iSys, Event &born)
	Save flavour content of Born state. More...

void	saveBornForTrialShower (Event &born)
	Save the flavour content of Born for trial shower. More...

bool	check (int iSys, Event &event)
	Check self-consistency, for specific iSys >= 0 or all systems (iSys < 0). More...

void	setVerbose (int verboseIn)
	Set verbosity level.

Public Member Functions inherited from TimeShower
	TimeShower ()=default
	Constructor.

virtual	~TimeShower ()
	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 void	prepareGlobal (Event &)

virtual void	rescatterUpdate (int, Event &)

virtual bool	initUncertainties ()
	Initialize data members for calculation of uncertainty bands.

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

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	isTimelike (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)

virtual double	noEmissionProbability (double, double, double, int, int, double, double)

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

Friends
class	VinciaISR
	Allow VinciaISR and VinciaHistory to access private information.

class	VinciaHistory

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.

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

WeightContainer *	weightContainerPtr {}

Protected Member Functions inherited from PhysicsBase
	PhysicsBase ()
	Default constructor.

virtual void	onInitInfoPtr ()

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

bool	uVarMuSoftCorr {}

bool	uVarMPIshowers {}

bool	noResVariations {}

bool	noProcVariations {}

int	nUncertaintyVariations {}

int	nVarQCD {}

int	uVarNflavQ {}

double	dASmax {}

double	cNSpTmin {}

double	uVarpTmin2 {}

double	overFactor {}

double	overFactorEnhance {}

map< int, double >	varG2GGmuRfac

map< int, double >	varQ2QGmuRfac

map< int, double >	varG2QQmuRfac

map< int, double >	varX2XGmuRfac

map< int, double >	varG2GGcNS

map< int, double >	varQ2QGcNS

map< int, double >	varG2QQcNS

map< int, double >	varX2XGcNS

map< int, double > *	varPDFplus

map< int, double > *	varPDFminus

map< int, double > *	varPDFmember

unordered_map< string, double >	enhanceFSR

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 VinciaFSR class for resonant decays. Inherits from TimeShower in Pythia 8 so can be used as alternative to TimeShower. Methods that must replace ones in TimeShower are marked with override.

Member Function Documentation

bool branch	(	Event &	event,
		bool	isInterleaved = `false`
	)

overridevirtual

Branch event, including accept/reject veto (TimeShower).

Verbose output.

Diagnostics.

Initialise info on this branching.

EW branchings

Do the EW branching, including a resonance shower if branching is a resonance decay. The idea is that after the branching, the overall event has the same number of parton systems as before, which have all been evolved down to the current evolution scale.

QCD Branchings.

Do the QCD branching.

Ensure any damped power showers are only applied to hardest emission.

Save info variables.

Diagnostics.

Done.

Reimplemented from TimeShower.

bool check	(	int	iSys,
		Event &	event
	)

Check self-consistency, for specific iSys >= 0 or all systems (iSys < 0).

Check event.

All FF emitters must be final-state particles.

If specific iSys requested, only check that system.

All FF splitters must be final-state particles.

All RF emitters must be initial-final systems

All RF splitters must be initial-final systems

double enhancePTmax ( )

inlineoverridevirtual

Potential enhancement factor of pTmax scale for hardest emission. Used if limitPTmax = true (TimeShower).

Reimplemented from TimeShower.

bool getHasWeaklyRadiated ( )

inlineoverridevirtual

Tell whether FSR has done a weak emission.

Initialize data members for calculation of uncertainty bands (TimeShower, no Vincia implementation yet). virtual bool initUncertainties();

Reimplemented from TimeShower.

void header ( )

Print header information (version, settings, parameters, etc.).

Must be initialised before printing header.

Avoid printing header on multiple threads.

Avoid printing header several times.

Print header information about shower.

Print header information about alphaS

Print header information about IR regularization.

Information about EW/QED showers.

Further information about EW.

Print header information about antenna functions.

FF and RF antennae.

Print antenna name.

Print colour/charge factor.

Put asterisk next to QG colour factor if using -1/NC2 correction.

II and IF antennae.

Print antenna name.

Print colour/charge factor.

Print header information about matrix-element Corrections.

Print references. TODO: Init output should be restructured into a vector<string> where each piece of Vincia adds lines, and a separate vector<string> for references.

Vincia QCD shower.

Vincia QED multipole shower.

Vincia Weak shower.

Vincia Merging.

Vincia Powheg Hook

Pythia 8 main reference.

void init	(	BeamParticle *	beamAPtrIn = `0`,
		BeamParticle *	beamBPtrIn = `0`
	)

overridevirtual

Initialize alphaStrong and related pTmin parameters (TimeShower).

The VinciaFSR class for resonant decays.

The following methods control main flow of shower and are inherited from TimeShower. Any method re-implementing a TimeShower method is appended with (TimeShower).

Initialize alphaStrong and related pTmin parameters (TimeShower).

Check if already initialized.

Showers on/off.

TODO: everything is evolved in PT in this version of VINCIA.

Parameters of interleaved resonance decays.

Store input pointers for future use.

Assume all events in same run have same beam-beam ECM.

Possibility to allow user veto of emission step.

canVetoISREmission is part of the overlap veto to avoid filling the same phase space with EW and QCD radiation starting from different hard processes. If there is no weak shower, there is also no overlap and thus no veto needed.

Number of active quark flavours

Number of flavours to be treated as massless (can be made user-specifiable in future if desired).

Global flag for helicity dependence.

Global flag for sector showers on/off.

Merging flags.

Perturbative cutoff. Since emissions and splittings can have different evolution measures, in principle allow for different cutoff scales, for now forced same.

Allow perturbative g->qq splittings to lower scales.

Set shower alphaS pointer.

Currently, CMW is applied to both emissions and splittings.

AlphaS parameters.

Smallest allowed scale for running alphaS.

For constant alphaS, set max = value (for efficiency).

Settings for enhanced (biased) kernels.

Explicitly allow heavy-quark enhancements only, not suppression

Resize pAccept to the maximum number of elements.

Initialize parameters for shower starting scale.

Initialize the FSR antenna functions.

All OK.

Reimplemented from TimeShower.

void initVinciaPtrs	(	VinciaColour *	colourPtrIn,
		shared_ptr< VinciaISR >	isrPtrIn,
		MECs *	mecsPtrIn,
		Resolution *	resolutionPtrIn,
		VinciaCommon *	vinComPtrIn,
		VinciaWeights *	vinWeightsPtrIn
	)

Initialise pointers to Vincia objects.

The following methods for merging not yet implemented in Vincia: Event clustered() map<string, double> getStateVariables (const Event &, int, int, int, string) bool isTimelike() vector<string> getSplittingName() double getSplittingProb() bool allowedSplitting() vector<int> getRecoilers() The remaining public functions Vincia only, i.e. not inherited from Pythia 8.

bool limitPTmax	(	Event &	event,
		double	q2Fac,
		double	q2Ren
	)

overridevirtual

Possible limitation of first emission (TimeShower).

Determines if max pT limit should be imposed on first emission. Note: in Vincia, the second argument is purely dummy.

Initialise for wimpy showers.

Check if limiting pT of first emission in each system.

Initialise for wimpy showers as default, then check if should modify.

Force wimpy showers.

Also always restrict all systems for processes of SoftQCD type.

Force power showers for hard system(s); MPI still wimpy.

Check if there are jets, photons, or heavy quarks in final state.

Look if jets, photons, and heavy coloured particles in final states of each system. (Top is counted as heavy unless g->ttbar is allowed.)

If no QCD/QED partons detected, allow to go to phase-space maximum.

For power showers, check if dampening should be applied.

Use the input factorisation-scale argument, or compute as geometric mean of the system's incoming A and B "scale" values.

General pTlimitHard is AND of the individual ones.

Verbose output

End loop over systems.

Return true/false.

Reimplemented from TimeShower.

void list ( ) const

overridevirtual

Utility to print antenna list; for debug mainly (TimeShower).

Utility to print antenna list; for DEBUG mainly (TimeShower).

Loop over antenna lists and print them.

Are there interleaved resonance decays?

Reimplemented from TimeShower.

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

overridevirtual

Prepare system for evolution (TimeShower).

Used for global recoil scheme (TimeShower, no Vincia implementation yet). void prepareGlobal(Event&);

Check if we are supposed to do anything

Last chance to print header if not done already.

Resetting for each new event (or non-interleaved decay of a resonance or hadron) to be showered.

Print event and antenna list before cleanup.

Do the following only once per new event to shower.

Reset counters in new events.

Set hard-system handler to EW or QED showers.

Do this for each new stage of showering (main, non-interleaved resonance decays, hadron decays).

Verbose output.

Make sure any existing branchers in this system are cleared out.

Reconstruct lookup tables for existing branchers.

Colour, Anticolour.

Gluon(Colour side) + Recoiler.

Gluon(Anticolour side) + Recoiler.

Resonance always first. (Negative for reversed colour flow.)

Verbose output.

Allow to quit after a certain number of emissions per event (just for testing).

Sanity check: at least two particles in system.

We don't have a starting scale for this system yet.

After prepare we always have zero branchings.

Note, for 2->2 systems, ISR::prepare() is called before FRS::prepare() (if doISR) so ISR may already have done everything.

Ensure consistency between ISR + FSR lists.

If ISR::prepare() not called for this system, prepare it now.

Assume system 0 is the hard system (if not just a single particle). Allows for case of forced final-state showers off a user-supplied final state without beams or decaying resonance, see shower().

Make light quarks (and initial-state partons) explicitly massless.

Then see if we know how to compute matrix elements for this conf.

Decide if we should be doing ME corrections for next order.

Initialize polarisation flag.

Colourise hard process and MPI systems first time they are encountered.

Set up QCD antennae.

In merging, allow to only generate emissions inside resonance systems.

Just clear what we've got.

Set up QCD antennae.

Save Born state, used later to reject sectors that involve clustering away the "hard" (Born) partons. (For trial showers, this step is done already, in VinciaMerging::getWeightCKKWL().)

Set up QED/EW systems. (Note: trial showers are pure QCD.)

Check if doing full EW or "just" QED.

MPI and non-resonance (eg hadron-) decay systems always use QED.

Set starting scale for this system

Let others know we got to the end.

Reimplemented from TimeShower.

void prepareProcess	(	Event &	process,
		Event &	event,
		vector< int > &	iBefShower
	)

overridevirtual

Prepare process-level event for shower + interleaved resonance decays. Usage: prepareProcess( process, event, iPos). iPos provides mapping from process to event entries (before showering).

Prepare process-level event for showering + interleaved resonance decays. Usage: prepareProcess( process, event, iPos). iPos provides mapping from process to event entries (before showering).

Signal that prepare() should treat this as a new event.

Initialise recursion-depth counter (for nested sequential decays), and vector of resonance-decay pT scales.

Find resonances in process-level event record.

Compute pT scales for resonances with decays included in the hard process. (Sequential decays irrelevant until mothers have decayed.)

Set interleaving scale: width or offshellness

EW and Helicity Showers require helicity selection.

Define hard-scattering state (with and then without prompt res decays).

Save Incoming legs first.

Skip "system" and beam particles.

Add incoming partons to state (final states added below, depending on interleaved resonance-decay settings).

Check if there are any unpolarised partons in this state. Check if any partons in this state need helicities.

If no helicities need to be selected, we are done.

Special case: no status-21 incoming partons (user defined): Start from first non-trivial single entry.

If doing interleaved resonance decays, first try with prompt decays included, then allow to try without.

Reset state to incoming only, then add final ones.

Loop over 2->N Born process.

If doing interleaving, resonances with decay scales > scale/2 are treated as prompt (no showering). Include daughters instead.

Force outgoing partons in state to have code 23.

Stable final-state particle, or resonance treated as stable.

Force outgoing partons in state to have code 23.

Check if we have the relevant Hard-Process Matrix Element.

If we pass sanity check,

Else print warning that something unexpected happened.

If state now contains polarisations, copy to process and event.

Consistency checks.

Copy pol() to process.

Copy pol() to main event record.

Verbose output. Print new process-level and event-level event records with helicity assignments.

Finished.

Reimplemented from TimeShower.

double pTLastInShower ( )

inlineoverridevirtual

Provide the pT scale of the last branching in the above shower (TimeShower).

Reimplemented from TimeShower.

double pTnext	(	Event &	event,
		double	pTbegAll,
		double	pTendAll,
		bool	isFirstTrial = `false`,
		bool	doTrialIn = `false`
	)

overridevirtual

Select next pT in downwards evolution (TimeShower).

Check if we are supposed to do anything.

Profiling.

Denote VINCIA scales by "q", PYTHIA ones by "pTevol".

End scale is set wrong for merging in resonances.

Initialise.

Generate next gluon-emission trial scale (above qEndAll).

Generate next gluon-splitting trial scale and compare to current qWin.

Generate next resonance gluon-emission trial and compare to current qWin.

For now, issue a warning that merging in RF systems is not validated.

Generate nex resonance gluon-splitting trial and compare to current qWin.

For now, issue a warning that merging in RF systems is not validated.

Generate next EW trial scale and compare to current qWin. (Trial showers are pure QCD.)

EW emissions in the hard system.

QED emissions in MPI systems (only if we are not in a resonance decay)

Check for winning condition. Note: EW resonance decays can go all the way to zero.

Mark QCD as the loser.

Mark EW as the loser.

If non-zero branching scale found: continue.

Else no more branchings. Finalize.

Profiling.

Reimplemented from TimeShower.

bool resonanceShower	(	Event &	process,
		Event &	event,
		vector< int > &	iPosBefShow,
		double	pTmerge
	)

overridevirtual

Do a resonance decay + resonance shower (including any nested decays). May be called recursively for nested decays. Usage: resonanceShower( process, event, iPos, pTmerge), where iPos maps process to event entries, and pTmerge is the scale at which this system should be merged into its parent system.

Handle a resonance decay, including showering of resonance system (with preserved resonance mass) down to the scale pTmerge, at which the produced partons are merged back into the system that produced the resonance (iSysMot). Assumes decay channel and kinematics already selected and present in process or event record. Note: this method can be called recursively for nested resonance decays.

Verbose output.

Keep track of how many times resonanceShower has called itself.

Is this a decay already in the event record? (E.g., produced by EW shower.) If so, we can ignore the process event record and just need to do the (interleaved) resonance shower off the decay products.

Else assume this is a resonance decay from the hard process. Update and copy down decay products (including junctions). Then do interleaved resonance shower.

Save which resonance is currently being handled (since iHardResDecSav may be overwritten when called recursively).

Do not try this resonance again (to avoid risk of infinite loop). If we fail, PartonLevel will have a (non-interleaved) chance at end of evolution.

Mother in hard process and in event recrd. iPosBefShow indicates position in complete event before shower evolution started, so may have moved.

If this particle has already been decayed (eg by EW shower), then no need to do anything further.

Prepare to move daughters from process to event record

Mother can have been moved by showering (in any of previous steps), so prepare to update colour and momentum information for system.

Construct boost matrix to go from process to event frame.

Check if this decay contains one (or more) junction structure(s) that should be copied from process to event as part of this decay.

Check for junctions that were already copied (e.g., by setupHardSys)

Mark this junction as already copied (force to be skipped).

TODO "colourise": allow to assign subleading colour indices to any new colour lines produced in the decay.

Move daughters from process to event and apply boosts + colour updates.

Copy daughter from process to event.

Update iPos map from process to event

Now set properties of this daughter in event.

Currently outgoing ones should not count as decayed.

Check if this decay contains a junction in hard event.

Only consider junctions that can appear in decays.

Check if colour of hard mother matches an incoming junction leg.

Only check mother once (not once for every daughter).

Check if daughter colour matches an outgoing junction leg.

If we have 3 matches, copy down junction from process to event.

Check for changed colors and update as necessary.

Mark junction as copied (to avoid later recopying)

Update colour and momentum information.

Sextet mothers have additional (negative) tag

Update vertex information.

Finally, check if daughter is itself a resonance. If so, add interleaving scale.

End loop over resonance daughters.

If everything worked, mark mother decayed and set daughters.

Update table of pre-shower process->event indices in case of changes.

If this is a recursive call, upstream system is the one which was added most recently.

Sanity check.

Add new system for this resonance decay + shower, + any nested resonance decays that may be done (recursively) while handling this system. (Partons will be moved from this system to upstream one at end.)

Insert resonance into system, then add daughters.

Check if we should assign polarisations to this system.

Force reselect daughter polarisations if mother changed helicity.

Check if daughters have helicities.

Force all outgoing particles to have code 23.

Check if this daughter needs to be polarised.

First, step up one system and see if we can polarise iSysMot+iSysRes.

Add all outgoing partons from mother system except resonance.

Add resonance daughters to stateMot.

First try if MG interface can select helicities using stateMot.

Copy daughter polarisations into event record.

Consistency check.

Else see if MG or EW shower can select helicities using stateRes. Note: require mother (stateRes[0]) to have a helicity.

Copy daughter polarisations into event record.

Consistency check.

Userhooks and Trial showers accounted for here in PartonLevel. TODO: discuss whether to include that here and how. For now, just do pure showers.

Begin evolution down in pT, allowing for nested resonance decays.

Interleave (intra-system) FSR and resonance decays.

Do a final-state emission.

Do a resonance decay from hard (process) event, nested (recursively) inside the current one.

Do nothing.

Check loop counter to avoid infinite loop.

Check for abort condition.

Udate upstream parton system. Replace outgoing resonance by its first daughter. Then add remaining partons.

Now delete the new system, otherwise beam remnant handling breaks.

Also clear added QED systems.

Reset antenna list for continued evolution in upstream system.

Done.

Reimplemented from TimeShower.

void saveBornForTrialShower ( Event & born )

Save the flavour content of Born for trial shower.

Save flavour content of Born state for trial shower (in merging).

Initialise.

Index of system we do the trial shower for.

Only resolve Born for resonance systems.

We have to find the resonance system. NOTE: by convention (!) this will be the only hadronically decaying one.

Otherwise always increase counter.

Get indices of daughters.

Skip if not quarks or gluons.

Otherwise this is our system and we save the Born info.

Print information.

void saveBornState	(	int	iSys,
		Event &	born
	)

Save flavour content of Born state.

Save the flavour content of system in Born state (needed for sector shower).

Initialise.

We want to resolve the Born only when we have a non-QCD coupling in Born.

If there are non-QCD partons in the system, resolve Born. (Also do this if there are no incoming partons, when using forceTimeShower to shower off specific user-defined configuration.)

Print information.

int shower	(	int	iBeg,
		int	iEnd,
		Event &	event,
		double	pTmax,
		int	nBranchMax = `0`
	)

overridevirtual

Top-level routine to do a full time-like shower in resonance decay (TimeShower).

Verbose output.

Add new system, automatically with two empty beam slots.

Verbose output.

Loop over allowed range to find all final-state particles.

Let prepare routine do the setup. (isPrepared = false forces clearing of any previous information.)

Begin evolution down in pT from hard pT scale.

Do a final-state emission (if allowed).

Keep on evolving until nothing is left to be done.

Return number of emissions that were performed.

Reimplemented from TimeShower.

int showerQED	(	int	iBeg,
		int	iEnd,
		Event &	event,
		double	pTmax
	)

overridevirtual

Method to add QED showers in hadron decays (TimeShower).

Check if we are supposed to do anything.

Construct a little QED system out of the given particles.

We could check if they all have the same mother and treat as resonance decay, but currently do not.

After branching accepted, update event, partonSystems, and antennae.

Reimplemented from TimeShower.

int showerQEDafterRemnants ( Event & event )

overridevirtual

Method to add QED showers to partons below colour resolution scale (TimeShower).

Check if we are supposed to do anything.

Prepare for showering below hadronisation scale. Include partons from all current systems (pass iSys = -1).

Retrieve iSys for remnant system.

After branching accepted, update event, partonSystems, and antennae.

Move post-remnant-shower partons back into their respective systems.

If this parton is still present, keep it and skip to next.

Replaced disappeared particle by iBot if latter is final. Else overwrite with the one at the back, and then pop back. (Example of latter: photon that has branched to fermion pair.)

Finally only keep partons in iSysRem that are not in any other system.

If QED shower did not do anything, the updated post-remnant system will only have remnant partons in it. Remove it if no partons left.

Force decays of any left-over resonances from the weak shower.

branch() automatically adds resonance shower.

Reimplemented from TimeShower.

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

overridevirtual

Update antenna list after each ISR emission (TimeShower).

Update FF, RF, and QED/EW antenna lists after each ISR emission.

Update antenna list after a multiple interactions rescattering (TimeShower, no Vincia implementation yet). void rescatterUpdate( int iSys, Event& event);

Do nothing if not prepared for FSR.

Update any EW branchers in system.

Return now if not doing QCD final-final branchings.

Sanity check

Count number of branches.

Particles in the list are already updated by ISR. Find and save all colours and anticolours; find all FF antennae.

In principle, the colour maps could here be used to look for any unmatched tags -> junctions.

Sanity check: can only shower QCD systems with more than 1 FF connection.

Update any final-state antennae with partons changed by ISR branching.

Update any antennae with legs that were modified by the ISR branching, i.e. whose current legs have been marked with status < 0.

Get new positions from indexOfCol, indexOfAcol (could also use daughter information from old i0, i1).

Update emitter (and update pointer if location changed).

Update lookup map and erase old keys.

Add new keys.

Update splitters.

Remove the antennae out of the list. This way we can check later if ISR added a new FF antenna i0/i1 is colour/anticolour.

Is there a FF connection left?

i0/iNew[0] is colour.

i1/iNew[2] is anticolour.

Don't include II or IF antennae.

Store new trial QCD gluon emission antenna.

Store new trial QCD gluon splitting antenna(e).

Decide if we should be doing ME corrections for next order.

Sanity check.

Reimplemented from TimeShower.

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

include/Pythia8/VinciaFSR.h
src/VinciaFSR.cc

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation