The StringZ class is used to sample the fragmentation function f(z). More...

#include <FragmentationFlavZpT.h>

Inheritance diagram for StringZ:

Public Member Functions
	StringZ ()
	Constructor.

virtual	~StringZ ()
	Destructor.

virtual void	init ()
	Initialize data members. More...

virtual double	zFrag (int idOld, int idNew=0, double mT2=1.)
	Fragmentation function: top-level to determine parameters. More...

virtual double	zLund (double a, double b, double c=1., double head=1., double bNow=0., int idFrag=0, bool isOldSQuark=false, bool isNewSQuark=false, bool isOldDiquark=false, bool isNewDiquark=false)
	Fragmentation function: select z according to provided parameters. More...

virtual double	zPeterson (double epsilon)

virtual double	zLundMax (double a, double b, double c=1.)
	Determine the maximum for zLund. More...

virtual double	stopMass ()
	Parameters for stopping in the middle; overloaded for Hidden Valley.

virtual double	stopNewFlav ()

virtual double	stopSmear ()

virtual double	aAreaLund ()
	a and b fragmentation parameters needed in some operations.

virtual double	bAreaLund ()

bool	deriveBLund ()
	Method to derive bLund from <z> (for fixed a and reference mT2). More...

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

Protected Attributes
bool	useNonStandC
	Initialization data, to be read from Settings.

bool	useNonStandB

bool	useNonStandH

bool	usePetersonC

bool	usePetersonB

bool	usePetersonH

double	mc2

double	mb2

double	aLund

double	bLund

double	aExtraSQuark

double	aExtraDiquark

double	rFactC

double	rFactB

double	rFactH

double	aNonC

double	aNonB

double	aNonH

double	bNonC

double	bNonB

double	bNonH

double	epsilonC

double	epsilonB

double	epsilonH

double	stopM

double	stopNF

double	stopS

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

Static Protected Attributes
static const double	CFROMUNITY = 0.01
	Constants: could only be changed in the code itself. More...

static const double	AFROMZERO = 0.02

static const double	AFROMC = 0.01

static const double	EXPMAX = 50.
	Do not take exponent of too large or small number.

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 StringZ class is used to sample the fragmentation function f(z).

Member Function Documentation

bool deriveBLund ( )

Method to derive bLund from <z> (for fixed a and reference mT2).

Alternative parameterisation of the Lund function. Derive the bLund parameter given the average z for fixed a and mT2.

Set up using reference mT2 = mRho^2 + 2*sigmaPT^2

Define lundFF as a function of only b, fixing a, c and mT2 as parameters

Solve for b

Check if derived b fell inside the nominal range for bLund

Print out derived value for b (and mT2ref), noting if outside range.

If outside range, tell user but force anyway so fits can see behaviour.

No further calls needed since b parameter updated in settings database.

void init ( )

virtual

Initialize data members.

Initialize data members of the string z selection.

c and b quark masses.

Paramaters of Lund/Bowler symmetric fragmentation function.

Alternative parameterisation of Lund FF using average z(rho) instead of b.

Flags and parameters of nonstandard Lund fragmentation functions.

Flags and parameters of Peterson/SLAC fragmentation function.

Parameters for joining procedure.

Reimplemented in HVStringZ.

double zFrag	(	int	idOld,
		int	idNew = `0`,
		double	mT2 = `1.`
	)

virtual

Fragmentation function: top-level to determine parameters.

Generate the fraction z that the next hadron will take, using either Lund/Bowler or, for heavy, Peterson/SLAC functions. Note: for a heavy new coloured particle we assume pT negligible.

Find if old or new flavours correspond to diquarks.

Find heaviest quark in fragmenting parton/diquark.

Use Peterson where explicitly requested for heavy flavours.

Nonstandard a and b values implemented for heavy flavours.

Shape parameters of Lund symmetric fragmentation function.

Reimplemented in HVStringZ.

double zLund	(	double	a,
		double	b,
		double	c = `1.`,
		double	head = `1.`,
		double	bNow = `0.`,
		int	idFrag = `0`,
		bool	isOldSQuark = `false`,
		bool	isNewSQuark = `false`,
		bool	isOldDiquark = `false`,
		bool	isNewDiquark = `false`
	)

virtual

Fragmentation function: select z according to provided parameters.

The arguments beginning with head are only needed for reweighting.

Generate a random z according to the Lund/Bowler symmetric fragmentation function f(z) = (1 -z)^a * exp(-b/z) / z^c. Normalized so that f(z_max) = 1 it can also be written as f(z) = exp( a * ln( (1 - z) / (1 - z_max) ) + b * (1/z_max - 1/z)

c * ln(z_max/z) ).

Special cases for c = 1, a = 0 and a = c.

Determine position of maximum.

Subdivide z range if distribution very peaked near either endpoint.

Find integral of trial function everywhere bigger than f. (Dummy start values.)

When z_max is small use that f(z) < 1 for z < z_div = 2.75 * z_max, < (z_div/z)^c for z > z_div (=> logarithm for c = 1, else power).

When z_max large use that f(z) < exp( b * (z - z_div) ) for z < z_div with z_div messy expression, < 1 for z > z_div. To simplify expressions the integral is extended to z = -infinity.

Choice of z, preweighted for peaks at low or high z. (Dummy start values.)

Choice of z flat good enough for distribution peaked in the middle; if not this z can be reused as a random number in general.

When z_max small use flat below z_div and 1/z^c above z_div.

When z_max large use exp( b * (z -z_div) ) below z_div and flat above it.

Evaluate actual f(z) (if in physical range) and correct.

Loop over the variation parameters.

Skip non-standard c, b, or h.

Determine the varied a, b, and c parameters.

Determine position of the maximum. Assuming that no special options are being used, i.e bShape = bLund. This is because b is scaled by mT2.

When b is changed, so is c.

Determine the new position of maximum.

Recalculate the coefficients.

Determine the weight and reduce if necessary.

Done.

double zLundMax	(	double	a,
		double	b,
		double	c = `1.`
	)

virtual

Determine the maximum for zLund.

Normalization for Lund fragmentation function so that f <= 1. Special cases for a = 0 and a = c.

Determine position of maximum.

double zPeterson ( double epsilon )

virtual

Generate a random z according to the Peterson/SLAC formula f(z) = 1 / ( z * (1 - 1/z - epsilon/(1-z))^2 ) = z * (1-z)^2 / ((1-z)^2 + epsilon * z)^2.

For large epsilon pick z flat and reject, knowing that 4 * epsilon * f(z) < 1 everywhere.

Else split range, using that 4 * epsilon * f(z) < 4 * epsilon / (1 - z)^2 for 0 < z < 1 - 2 * sqrt(epsilon) < 1 for 1 - 2 * sqrt(epsilon) < z < 1

Member Data Documentation

const double CFROMUNITY = 0.01

staticprotected

Constants: could only be changed in the code itself.

The StringZ class.

Constants: could be changed here if desired, but normally should not. These are of technical nature, as described for each. When a or c are close to special cases, default to these.

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

include/Pythia8/FragmentationFlavZpT.h
src/FragmentationFlavZpT.cc

Public Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

Member Data Documentation