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	deriveABLund (bool derivaA=false, bool deriveAExtraDiquark=false, bool deriveAExtraSQuark=false)
	Method to derive both a and b parameters (from <z> and RMSD(z)). More...

double	deriveBLund (double avgZ, double a, double mT2ref)
	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

WeightsFragmentation *	wgtsPtr {}
	Fragmentation weights container.

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 = {}

BeamParticlePtr	beamAPtr = {}

BeamParticlePtr	beamBPtr = {}

BeamParticlePtr	beamPomAPtr = {}

BeamParticlePtr	beamPomBPtr = {}

BeamParticlePtr	beamGamAPtr = {}

BeamParticlePtr	beamGamBPtr = {}

BeamParticlePtr	beamVMDAPtr = {}

BeamParticlePtr	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 deriveABLund	(	bool	deriveA = `false`,
		bool	deriveAExtraDiquark = `false`,
		bool	deriveAExtraSQuark = `false`
	)

Method to derive both a and b parameters (from <z> and RMSD(z)).

Method to derive bLund and, optionally, aLund, aExtraDiquark, and aExtraSQuark, from: avgZLund = <z(rho)>, rmsZLund = sqrt( <z(rho)^2> - <z(rho)>^2), facALundDiquark = (aLund + aExtraDiquark)/aLund, facALundSQuark = (aLund + aExtraStrange)/aLund, for reference (typical) values of the transverse mass mT.

Set up using reference mT2ref = mHad^2 + 2*sigmaPT^2 with mHad = mRho, mK*, mp+ for light mesons, strange mesons, and baryons.

Debug output if requested.

Simplest option: just derive bLund from requested avgZ.

Derive both aLund and bLund from requested avgZ and rmsZ.

Take big steps in the beginning, then smaller ones.

First see if we can get the right RMS.

Stop if we cannot possibly get a bigger width.

Then get the right mean.

Derive aExtraDiquark if requested.

Derive aExtraStrange if requested.

Print out derived value(s).

Set and check if derived bLund fell inside the nominal range.

If outside nominal range, force so fits can see behaviour.

Set and check if derived aLund fell inside the nominal range.

If outside nominal range, force so fits can see behaviour.

Set and check if derived aExtraDiquark fell inside the nominal range.

If outside nominal range, force so fits can see behaviour.

Set and check if derived aExtraDiquark fell inside the nominal range.

If outside nominal range, force so fits can see behaviour.

Issue warning if one or more parameters out of range.

No further calls needed since parameters updated in settings database.

double deriveBLund	(	double	avgZ,
		double	a,
		double	mT2ref
	)

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.

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

Solve for b and return.

void init ( )

virtual

Initialize data members.

Initialize data members of the string z selection.

Set the fragmentation weights container.

c and b quark masses.

Paramaters of Lund/Bowler symmetric fragmentation function.

Alternative parameterisation of Lund FF it terms of its average and optionally rms and multiplicative factors for aDiquark and aStrange.

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