PYTHIA  8.303
Public Member Functions | List of all members
StringFragmentation Class Reference

#include <StringFragmentation.h>

Inheritance diagram for StringFragmentation:
PhysicsBase

Public Member Functions

 StringFragmentation ()
 Constructor.
 
void init (StringFlav *flavSelPtrIn, StringPT *pTSelPtrIn, StringZ *zSelPtrIn, FragModPtr fragModPtrIn=NULL)
 Initialize and save pointers. More...
 
bool fragment (int iSub, ColConfig &colConfig, Event &event)
 Do the fragmentation: driver routine. More...
 
RotBstMatrix junctionRestFrame (Vec4 &p0, Vec4 &p1, Vec4 &p2)
 Find the boost matrix to the rest frame of a junction. 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
 

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
}
 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.
 
- Protected Attributes inherited from PhysicsBase
InfoinfoPtr = {}
 
SettingssettingsPtr = {}
 Pointer to the settings database.
 
ParticleDataparticleDataPtr = {}
 Pointer to the particle data table.
 
HadronWidthshadronWidthsPtr = {}
 Pointer to the hadron widths data table.
 
RndmrndmPtr = {}
 Pointer to the random number generator.
 
CoupSMcoupSMPtr = {}
 Pointers to SM and SUSY couplings.
 
CoupSUSYcoupSUSYPtr = {}
 
BeamParticlebeamAPtr = {}
 
BeamParticlebeamBPtr = {}
 
BeamParticlebeamPomAPtr = {}
 
BeamParticlebeamPomBPtr = {}
 
BeamParticlebeamGamAPtr = {}
 
BeamParticlebeamGamBPtr = {}
 
BeamParticlebeamVMDAPtr = {}
 
BeamParticlebeamVMDBPtr = {}
 
PartonSystemspartonSystemsPtr = {}
 Pointer to information on subcollision parton locations.
 
SigmaTotalsigmaTotPtr = {}
 Pointer to the total/elastic/diffractive cross sections.
 
set< PhysicsBase * > subObjects
 
UserHooksPtr userHooksPtr
 

Detailed Description

The StringFragmentation class contains the top-level routines to fragment a colour singlet partonic system.

Member Function Documentation

bool fragment ( int  iSub,
ColConfig colConfig,
Event event 
)

Do the fragmentation: driver routine.

Perform the fragmentation.

Find partons and their total four-momentum.

Rapidity pairs [yMin, yMax] of string piece ends.

Reset the local event record and vertex arrays.

For closed gluon string: pick first breakup region.

For junction topology: fragment off two of the string legs. Then iParton overwritten to remaining leg + leftover diquark.

Set up kinematics of string evolution ( = motion).

Fallback loop, when joining in the middle fails. Bailout if stuck.

After several failed tries join some (extra) nearby partons.

After several failed tries gradually allow larger stop mass.

Set up flavours of two string ends, and reset other info.

Begin fragmentation loop, interleaved from the two ends.

Variables used to help identifying baryons from junction splittings.

Keep track of the momentum of hadrons taken from left and right.

Inform the UserHooks about the string to he hadronised.

Take a step either from the positive or the negative end.

Check how many nearby string pieces there are for the next hadron.

The FlavourRope treatment changes the fragmentation parameters.

Possibility for a user to change the fragmentation parameters.

Construct trial hadron and check that energy remains.

Construct kinematics of the new hadron and store it.

Change status code if hadron from junction.

Possibility for a user to veto the hadron production.

Provide full particle info for veto decision.

Bookkeeping of momentum taken away.

Append produced hadron.

Update string end and remaining momentum.

End of fragmentation loop.

Check how many nearby string pieces there are for the last hadron.

When done, join in the middle. If this works, then really done.

Else remove produced particles (except from first two junction legs) and start all over.

Junctions & extra joins: remove fictitious end, restore original partons.

Store the hadrons in the normal event record, ordered from one end.

Store hadron production space-time vertices.

Done.

void init ( StringFlav flavSelPtrIn,
StringPT pTSelPtrIn,
StringZ zSelPtrIn,
FragModPtr  fragModPtrIn = NULL 
)

Initialize and save pointers.

Save pointers.

Initialize the StringFragmentation class.

Calculation and definition of hadron space-time production vertices.

Tracing of colours for primary hadrons.

Joining of nearby partons along the string.

Initialize the b parameter of the z spectrum, used when joining jets.

Charm and bottom quark masses used for space-time offset.

MPI pT0, used for calculating effective number of strings.

Initialize the hadrons instance of an event record.

Send on pointers to the two StringEnd instances.

Check for number of nearby string pieces (nNSP) or not.

RotBstMatrix junctionRestFrame ( Vec4 p0,
Vec4 p1,
Vec4 p2 
)

Find the boost matrix to the rest frame of a junction.

Find the boost matrix to the rest frame of a junction, given the three respective endpoint four-momenta.

Calculate masses and other invariants.

Requirement (eiMax)_j = pi*pj/mj < (eiMax)_k = pi*pk/mk, used below, here rewritten as pi*pj * mk < pi*pk * mj and squared.

Initially pick i to be the most massive parton. but allow other tries.

Pick j to give minimal eiMax, and k the third vector.

Alternative names according to i, j, k conventions.

Trivial to find new parton energies if all three partons are massless.

Else find three-momentum range for parton i and values at extremes.

Minimum when i is at rest.

Maximum estimated when j + k is at rest, alternatively j at rest.

If unexpected values at upper endpoint then pick another parton.

Start binary + linear search to find solution inside range.

Derive momentum of other two partons and distance to root.

Replace lower or upper bound by new value.

Pick next i momentum to explore, hopefully closer to root.

If arrived here then either succeeded or exhausted possibilities.

Now we know the energies in the junction rest frame.

Boost (copy of) partons to their rest frame.

Construct difference vectors and the boost to junction rest frame.

Add two boosts, giving final result.


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