|
PYTHIA
8.312
|
#include <VinciaCommon.h>
Public Member Functions | |
| bool | initPtr (Info *infoPtrIn) |
| Initialize pointers. | |
| bool | init () |
| Initialize data members. More... | |
| double | mHadMin (const int id1, const int id2) |
| bool | showerChecks (Event &event, bool ISR) |
| void | resetCounters () |
| Function to reset counters (print once every event for now). | |
| int | getNf (double q) |
| Get number of active flavors at a given Q scale. | |
| double | getShowerStartingScale (int iSys, const Event &event, double sbbSav) |
| Get the shower starting scale. More... | |
| vector< VinciaClustering > | findClusterings (const vector< Particle > &state, map< int, int > nFlavsBorn) |
| vector< VinciaClustering > | findClusterings (const vector< Particle > &state, int nqpMin=0, int ngMin=0) |
| bool | isValidClustering (const VinciaClustering &clus, const Event &event, int verboseIn) |
| Check if clustering is sensible, i.e., corresponds to an existing antenna. More... | |
| bool | clus3to2 (const VinciaClustering &clus, const Event &event, vector< Particle > &pClustered) |
| Perform a clustering. More... | |
| bool | clus3to2 (const VinciaClustering &clus, const vector< Particle > &state, vector< Particle > &pClustered) |
| bool | getCols3to2 (const Particle *a, const Particle *j, const Particle *b, const VinciaClustering &clus, pair< int, int > &colsA, pair< int, int > &colsB) |
| Helper functions to perform clustering. More... | |
| bool | getMomenta3to2 (vector< Vec4 > &momNow, vector< Vec4 > &momClus, const VinciaClustering &clus, int iOffset=0) |
| bool | map3to2FF (vector< Vec4 > &pClu, const vector< Vec4 > pIn, int kMapType, int a=0, int r=1, int b=2, double mI=0.0, double mK=0.0) |
| 3->2 clustering maps. | |
| bool | map3to2RF (vector< Vec4 > &pClu, const vector< Vec4 > &pIn, int a=0, int r=1, int b=2, double mK=0.) |
| Inverse kinematic map for the resonance-final antenna. More... | |
| bool | map3to2IF (vector< Vec4 > &pClu, const vector< Vec4 > &pIn, int a=0, int r=1, int b=2, double mj=0., double mk=0., double mK=0.) |
| bool | map3to2II (vector< Vec4 > &pClu, const vector< Vec4 > &pIn, bool doBoost, int a=0, int r=2, int b=1, double mj=0.) |
| bool | map2to3FF (vector< Vec4 > &pNew, const vector< Vec4 > &pOld, int kMapType, const vector< double > &invariants, double phi, vector< double > masses) |
| bool | map2to3II (vector< Vec4 > &pNew, vector< Vec4 > &pRec, vector< Vec4 > &pOld, double sAB, double saj, double sjb, double sab, double phi, double m2j=0.0) |
| bool | map2to3IFlocal (vector< Vec4 > &pNew, const vector< Vec4 > &pOld, double sOldAK, double saj, double sjk, double sak, double phi, double m2oldK, double m2j, double m2k) |
| bool | map2to3IFglobal (vector< Vec4 > &pNew, vector< Vec4 > &pRec, const vector< Vec4 > &pOld, const Vec4 &pB, double sAK, double saj, double sjk, double sak, double phi, double mK2, double mj2, double mk2) |
| bool | map2toNRF (vector< Vec4 > &pAfter, const vector< Vec4 > pBefore, unsigned int posR, unsigned int posF, const vector< double > invariants, double phi, const vector< double > masses) |
| Resonance decay kinematic maps. More... | |
| bool | map1to2RF (vector< Vec4 > &pNew, const Vec4 pRes, double m1, double m2, double theta, double phi) |
| 1->2 decay map for (already offshell) resonance decay More... | |
| bool | onShellCM (Vec4 &p1, Vec4 &p2, double m1, double m2, double tol=1e-6) |
| Check if 2-particle system is on-shell and rescale if not. More... | |
| bool | mapToMassless (int iSys, Event &event, bool makeNewCopies) |
| Force initial-state and light-flavour partons to be massless. More... | |
| bool | mapToMassive (Vec4 &p1, Vec4 &p2, double m1, double m2) |
| vector< Particle > | makeParticleList (const int iSys, const Event &event, const vector< Particle > &pNew=vector< Particle >(), const vector< int > &iOld=vector< int >()) |
| Make list of particles as vector<Particle>. More... | |
| vector< VinciaClustering > | findAntennae (Event &state, int i1, int i2, int i3) |
| bool | colourConnected (const Particle &ptcl1, const Particle &ptcl2) |
| Check whether two particles are colour connected. More... | |
| void | list (const vector< Particle > &state, string title="", bool footer=true) |
| Print a list of Particles. More... | |
| void | list (const vector< VinciaClustering > &clusterings, string title="", bool footer=true) |
| Print a list of VinciaClusterings. More... | |
| int | getVerbose () |
| Get/set verbose parameter. | |
| void | setVerbose (int verboseIn) |
Public Attributes | |
| AlphaStrong | alphaStrong {} |
| AlphaStrong | alphaStrongCMW {} |
| AlphaStrong | alphaStrongDef {} |
| AlphaStrong | alphaStrongDefCMW {} |
| AlphaStrong | alphaS {} |
| Couplings for use in merging. | |
| AlphaEM | alphaEM {} |
| double | mu2freeze {} |
| double | mu2min {} |
| double | alphaSmax {} |
| double | ms {} |
| Quark masses. | |
| double | mc {} |
| double | mb {} |
| double | mt {} |
| int | nFlavZeroMass {} |
| double | epTolErr {} |
| Checks. | |
| double | epTolWarn {} |
| double | mTolErr {} |
| double | mTolWarn {} |
Class which contains functions and variables shared by the VinciaShower and VinciaMatching classes.
| bool clus3to2 | ( | const VinciaClustering & | clus, |
| const Event & | event, | ||
| vector< Particle > & | pClustered | ||
| ) |
Perform a clustering.
Save indices of daughters in event.
TODO polarisations.
Find clustered colours.
Check if the colour assignment created singlet particles.
Find clustered momenta.
Initialise clustered particles (momenta are set in loop below).
Set list of clustered particles with new momenta.
Done.
| bool clus3to2 | ( | const VinciaClustering & | clus, |
| const vector< Particle > & | state, | ||
| vector< Particle > & | pClustered | ||
| ) |
Save indices of daughters in event.
TODO polarisations.
Find clustered colours.
Check if the colour assignment created singlet particles.
Find clustered momenta.
Initialise clustered particles (momenta are set in loop below).
Set list of clustered particles with new momenta.
Done.
Check whether two particles are colour connected.
Check whether two particles are colour-connected.
| vector< VinciaClustering > findAntennae | ( | Event & | state, |
| int | i1, | ||
| int | i2, | ||
| int | i3 | ||
| ) |
Method to find all antennae that can produce a branching. IN: indices of clustering in event, where i2 is the emission. OUT: vector of VinciaClusterings. Also swap daughters to match antenna function convention if needed (e.g. for GXSplitFF, when dau2 and dau3 form the quark pair).
Based on current state, find all antennae for this branching and swap daughters if needed.
Initialise.
Final-final branching.
Gluon emission.
No flavour change for gluon emissions.
Save.
Gluon splitting.
Check colour connection to find out who is splitting.
Check flavours.
Check colour connection.
Daughters 1 and 2 are clustered to a gluon.
Save.
Initial-initial branching.
Gluon emission.
No flavour change for gluon emissions.
Save.
For splittings, we can have more than one antenna.
Quark conversion of clus.dau1.
Check that the colour connection is sensible, otherwise skip.
Daughters 1 and 2 are clustered to a gluon.
Save.
Quark conversion of clus.dau3.
Swap daughters.
Check that the colour connection is sensible, otherwise skip.
Now daughters 1 and 2 are clustered to a gluon.
Save.
Gluon splitting of clus.dau1.
Check that the colour connection is sensible, otherwise skip.
Daughters 1 and 2 are clustered to quark of anti-flavour of 2. Dau 3 does not change flavour.
Save.
Gluon splitting of clus.dau3.
Swap daughters.
Check that the colour connection is sensible, otherwise skip.
Daughters 1 and 2 are clustered to quark of anti-flavour of 2. Dau 3 does not change flavour.
Save.
Resonance-final branching.
Always assume clus.dau1 is resonance.
Resonance always stays the same.
Gluon emission.
No flavour change for gluon emissions.
Save.
Explicitly check colour connection.
Daughters 2 and 3 get clustered to a gluon.
Save.
Initial-final branching.
Always assume dau1 is in the initial state.
Gluon emission.
No flavour change for gluon emissions.
Save.
For gluon splittings, we have more than one antenna.
Gluon splitting in the final state.
Daughters 2 and 3 are clustered to a gluon.
Save.
Gluon splitting in the initial state.
Check that the colour connection is sensible, skip otherwise.
Daughters 1 and 2 are clustered to quark of anti-flavour of 2. Dau 3 does not change flavour.
Save.
Quark conversion (in the initial state).
Check that the colour connection is sensible, skip otherwise.
Daughters 1 and 2 are clustered to a gluon.
Save.
| vector< VinciaClustering > findClusterings | ( | const vector< Particle > & | state, |
| map< int, int > | nFlavsBorn | ||
| ) |
Method to find all possible clusterings for a given system, given we want to resolve a certain Born configuration, i.e., not cluster more gluons or quark flavours as we had in the Born.
Find all possible clusterings for given configuration (optionally while retaining a Born configuration).
Check if we have sufficient information about the flavours in Born.
Vector of all clusterings.
Initialise information about state.
Initial-state colour treated as anticolour.
Helicity flipped for initial state.
Initial-state quark treated as antiquark (and vice versa).
Loop through all 3 -> 2 clusterings.
Gluon emission.
Check if we are allowed to cluster this gluon.
Get colour-connected partners.
Get antenna function information.
Final-final.
Resonance-final.
Final-resonance: swap ia and ib.
Initial-final.
Final-initial: swap ia and ib.
Initial-initial.
Save clustering to list of all clusterings.
For quarks, distinguish different cases.
If initial-state quark: only conversion possible.
Find colour-connected partner of j.
Loop over all same-flavour (anti)quarks.
Get flavour partner.
Check that we do not try to cluster the colour partner.
Check if we are allowed to cluster this flavour.
Get antenna information.
Append clustering to list.
We do not consider any "other" emission into the initial state.
From here on, j is guaranteed to be in the final state.
Find colour-connected partner of j.
Gluon splitting in the initial state. Note: this does not reduce the total number of quarks!
The gluon now takes the role of a.
The recoiler is the other parton colour-connected to the gluon.
Get antenna information.
Append clustering to list.
From here on, we would reduce the number of quarks, so check if we are allowed to cluster this flavour.
Loop over all same-flavour (anti)quarks.
Get flavour partner.
Check that we do not try to cluster the colour partner.
Get antenna information.
Gluon splitting in the final state.
Final-final gluon splitting.
Final-resonance gluon splitting: swap ia and ib.
Final-initial gluon splitting: swap ia and ib.
Quark conversion (in the initial state).
Initial-final quark conversion.
Initial-initial quark conversion.
Append clustering to list.
Other clusterings (n -> m, QED, EW, ...) to be implemented here.
Summary.
| vector< VinciaClustering > findClusterings | ( | const vector< Particle > & | state, |
| int | nqpMin = 0, |
||
| int | ngMin = 0 |
||
| ) |
Method to find all possible clusterings while retaining a certain minimal number of quark pairs and gluons.
Find all possible clusterings for given configuration while retaining a minimum number of quark pairs and gluons in the event.
Initialise.
Dummy flavour map.
Find number of quark pairs in current state.
Find all tentative clusterings.
Erase those reducing the number of quark pairs below the minimum. (Only when the current state has the minimum number of quark pairs).
Note: no QXSplit, as this leaves the total number of quark pairs invariant.
| bool getCols3to2 | ( | const Particle * | a, |
| const Particle * | j, | ||
| const Particle * | b, | ||
| const VinciaClustering & | clus, | ||
| pair< int, int > & | colsA, | ||
| pair< int, int > & | colsB | ||
| ) |
Helper functions to perform clustering.
Get clustered colours in 3->2 clustering.
Is the emission an antiquark?
Colours and colour chains of clustered particles (mothers).
Final-final gluon splitting.
Resonance-final gluon splitting.
Gluon emission.
Choose to annihilate colour pair of dau2 and dau3.
Note: by construction, b and j are always in the final state.
Initial-state gluon splitting.
Quark conversion.
Find out whether daughters have been swapped to not have "emissions into the initial state", cf. setClusterlist in VinciaHistory.
&& !ajColCon) {
&& jbColCon) {
Final-state gluon splitting.
Gluon emission.
Choose to annihilate colour pair of dau1 and dau2.
Dau1 is definitely initial and dau2 final.
| bool getMomenta3to2 | ( | vector< Vec4 > & | momNow, |
| vector< Vec4 > & | momClus, | ||
| const VinciaClustering & | clus, | ||
| int | iOffset = 0 |
||
| ) |
Get clustered momenta in 3->2 clustering. Note: iOffset shifts the indices stored in the VinciaClustering object. Is needed when these point to an event record.
Fetch indices.
Fetch masses (for clarity).
Cluster momenta according to antenna function.
Use antenna index to identify resonance-final branchings.
Otherwise final-final branching.
Use antenna index to identify initial-final branchings.
Otherwise initial-initial branching.
| double getShowerStartingScale | ( | int | iSys, |
| const Event & | event, | ||
| double | sbbSav | ||
| ) |
| bool init | ( | ) |
Initialize data members.
The VinciaCommon class.
Initialize the class.
Check initPtr.
Verbosity level and checks.
Counters
Quark masses
Number of flavours to treat as massless in clustering and kinematics maps.
Strong coupling for use in merging.
Default alphaS, with and without CMW.
User alphaS, with and without CMW.
Freeze and minimum scales.
Find the overall minimum scale. Take into account the freezeout scale, Lambda pole, and alphaSmax.
EM coupling for use in merging. Dummy, as no EW clusterings.
Return.
| bool isValidClustering | ( | const VinciaClustering & | clus, |
| const Event & | event, | ||
| int | verboseIn | ||
| ) |
Check if clustering is sensible, i.e., corresponds to an existing antenna.
Fetch daughters.
Do not consider emissions into the initial state.
Fetch colour connection.
Quark-antiquark clusterings.
We can have multiple antennae contributing to this state. Only return false if nothing is found.
(Initial-state) quark conversion on side a.
Quark a needs to have the same flavour as j and must not be colour-connected to it to not create singlet gluons.
Initial-state gluon splitting on side a.
Gluon a has to be colour-connected with both j and b.
Final-state gluon splitting on side a.
Quark a needs to have the antiflavour of j and must not be colour-connected to it to not create singlet gluons.
(Initial-state) quark conversion on side b.
Quark b needs to have the same flavour as j and must not be colour-connected to it to not create singlet gluons.
Initial-state gluon splitting on side b.
Gluon a has to be colour-connected with both j and b.
Final-state gluon splitting on side b.
Quark b needs to have the antiflavour of j and must not be colour-connected to it to not create singlet gluons.
If nothing was found, return false.
For gluon emissions, dau2 should be colour-connected with 1 and 3.
| void list | ( | const vector< Particle > & | state, |
| string | title = "", |
||
| bool | footer = true |
||
| ) |
Print a list of Particles.
Print a list of particles.
| void list | ( | const vector< VinciaClustering > & | clusterings, |
| string | title = "", |
||
| bool | footer = true |
||
| ) |
Print a list of VinciaClusterings.
Print a list of clusterings.
Get breakdown of clusterings.
| vector< Particle > makeParticleList | ( | const int | iSys, |
| const Event & | event, | ||
| const vector< Particle > & | pNew = vector<Particle>(), |
||
| const vector< int > & | iOld = vector<int>() |
||
| ) |
Make list of particles as vector<Particle>.
Make list of particles as vector<Particle>. First 1 or 2 entries : incoming particle(s). Subseqent entries : outgoing particles. The two last arguments are optional and allow to specify a list of indices to be ignored, and a set of particles to be added, e.g. in the context of setting up a trial state after a branching. The newly added particles are then at the end of the respective lists, i.e. a newly added incoming particle is the last incoming one and newly added outgoing ones are the last among the outgoing ones.
Put incoming ones (initial-state partons or decaying resonance) first.
reserve size for state
Exclude any partons in old state that should be replaced.
Exclude any partons in old state that should be replaced.
If neither hasInAB() nor hasInRes(), assume hadron decay. Find mother.
Add any post-branching incoming particles.
Note: state size can be zero at this point if this is a forced shower off a user-defined final state without any specified decaying resonance or incoming beams; see e.g., VinciaFSR::shower().
Then put outgoing ones.
Do not add any that are marked as branched.
Add any post-branching outgoing partons.
Return the state.
| bool map1to2RF | ( | vector< Vec4 > & | pNew, |
| const Vec4 | pRes, | ||
| double | m1, | ||
| double | m2, | ||
| double | theta, | ||
| double | phi | ||
| ) |
1->2 decay map for (already offshell) resonance decay
1->2 decay map for (already offshell) resonance decay.
Fetch resonance mass.
Square input masses.
Set up kinematics in the CoM frame.
No solution if kallenFunction negative.
Rotate.
Boost to lab frame.
Check.
|
inline |
2->3 kinematics maps for FF branchings. Original implementations; massless by Skands, massive by Ritzmann.
| bool map2to3IFglobal | ( | vector< Vec4 > & | pNew, |
| vector< Vec4 > & | pRec, | ||
| const vector< Vec4 > & | pOld, | ||
| const Vec4 & | pB, | ||
| double | sAK, | ||
| double | saj, | ||
| double | sjk, | ||
| double | sak, | ||
| double | phi, | ||
| double | mK2, | ||
| double | mj2, | ||
| double | mk2 | ||
| ) |
2->3 kinematics map for global recoils, for general mj,mk. Assumes partons from proton explicitly massless.
Set up some variables for boosting pT.
Rotate and boost.
Check if pT was properly boosted, allow 0.1% difference.
Set up starting (massless) solution. Saved in case of restart.
Initialise from massless solution.
Root finding with Newton-Raphson in 5D.
Current Newton-Raphson error
Construct function.
Construct Jacobian.
Invert Jacobian and append identity.
Find column max.
Swap maximum row with current row.
Reduce current column.
Solve equation Ax = b for upper triangular matrix A.
Remove remaining identity.
Find next iteration.
Perform sanity checks to decide if we should reset.
Check for nans.
vNew[4] is a sqrt - should not be negative.
Check for all negative solution.
Do reset.
Start again from massless values.
Randomly vary variables.
Compute current error.
Set to new values.
Did we fail solving?
Construct post-branching momenta.
Check if these momenta are on-shell
Set up the boost.
Perform boost.
Force the initial state to be on the beam axis.
Perform boost on the rest of the system and return.
| bool map2to3IFlocal | ( | vector< Vec4 > & | pNew, |
| const vector< Vec4 > & | pOld, | ||
| double | sAK, | ||
| double | saj, | ||
| double | sjk, | ||
| double | sak, | ||
| double | phi, | ||
| double | mK2, | ||
| double | mj2, | ||
| double | mk2 | ||
| ) |
2->3 kinematics maps for IF branchings. General massive case implemented by Verheyen.
2->3 kinematics map for local recoils, for general mj,mk. Assumes partons from proton explicitly massless
Check invariants.
Check if we're inside massive phase space.
Set up some variables for boosting pT.
Rotate and boost.
Check if pT was properly boosted, allow 0.1% difference.
Construct post-branching initial-state momentum (explicitly massless).
Construct post-branching final-state momenta.
Check the invariants, allow 0.1% difference (due to boost).
|
inline |
2->3 kinematics maps for II branchings. Original implementations: massless by Fischer, massive by Verheyen.
| bool map2toNRF | ( | vector< Vec4 > & | pAfter, |
| const vector< Vec4 > | pBefore, | ||
| unsigned int | posR, | ||
| unsigned int | posF, | ||
| const vector< double > | invariants, | ||
| double | phi, | ||
| const vector< double > | masses | ||
| ) |
Resonance decay kinematic maps.
Implementations of resonance kineatic maps for massive partons. Inputs are as follows: pBefore = momenta of resonance and all downstream recoilers before emission. posF = position in pBefore of the momentum of the F end of the antenna. invariants = yaj and yjk scaled invariants. phi = azimuthal angle of gluon emission. mui = masses of a, j, k. The output is as follows: pAfter = momenta of resonance, emission and all downstream recoilers after emission. [0] = pa - will be unchanged [1] = pj [2] = pk [i>3] = recoilers
Momentum of "R", "F" end of antenna, and sum of downstream recoilers.
Recoil AK system.
Add pa, pj, and k. Check mass.
If only a single recoiler, it just takes the remaining momentum.
Boost the downstream recoilers appropriately
Check mass.
Done.
| bool map3to2IF | ( | vector< Vec4 > & | pClu, |
| const vector< Vec4 > & | pIn, | ||
| int | a = 0, |
||
| int | r = 1, |
||
| int | b = 2, |
||
| double | mj = 0., |
||
| double | mk = 0., |
||
| double | mK = 0. |
||
| ) |
Implementations of IF clustering maps for massive partons. NOTE: particle A and a are assumed massless (no initial-state masses).
Initialise and sanity check.
Save momenta for clustering.
Verbose output.
Calculate invariants.
| bool map3to2II | ( | vector< Vec4 > & | pClu, |
| const vector< Vec4 > & | pIn, | ||
| bool | doBoost, | ||
| int | a = 0, |
||
| int | r = 2, |
||
| int | b = 1, |
||
| double | mj = 0. |
||
| ) |
Implementations of II clustering maps for massive partons. NOTE: particle A, a, B, and b are assumed massless.
Initialisation and sanity check.
Save momenta for clustering.
Verbose output.
Calculate invariants.
Scale factors and momenta.
Clustered momenta and recoilers.
Perform boost - if doBoost, we boost back to the lab frame. Adjust recoiling momenta.
Otherwise stay in the current frame. Adjust clustered momenta.
| bool map3to2RF | ( | vector< Vec4 > & | pClu, |
| const vector< Vec4 > & | pIn, | ||
| int | a = 0, |
||
| int | r = 1, |
||
| int | b = 2, |
||
| double | mK = 0. |
||
| ) |
Inverse kinematic map for the resonance-final antenna.
1) Extract momenta.
Momenta to cluster.
Get pX'.
2) Momenta are completely pre-determined by the masses. Take mK as input - may change if e.g. clustering a splitting.
3) Boost to Top Centre of Mass frame.
pX along z.
4) Fetch the orientation of X' and rotate X
5) Boost back to lab frame.
6) Boost recoilers and save clustered momenta.
Check sum.
Map a massless antenna to equivalent massive one. Boolean returns true if a modification was made.
| bool mapToMassless | ( | int | iSys, |
| Event & | event, | ||
| bool | makeNewCopies | ||
| ) |
Force initial-state and light-flavour partons to be massless.
Map partons partonSystems[iSys] to equivalent massless ones. Return true if succeeded. Note, a method using only Particles or Vec4 as input could in principle be split off from this, if needed, but has not been required so far.
Start by making new copies, if requested to do so.
Copy incoming partons, interpret the copying operation as the two incoming partons recoiling off each other. Assign status code -42, incoming copy of recoiler (as mother).
Note, a decaying resonance is not copied to preserve structure of production and decay. Copy outgoing partons (use status code 52).
End if new copies requested.
Initial-state partons, always assumed massless in VINCIA.
Below we assume iA is the one with pz > 0; swap if opposite case.
Transverse components assumed zero: check.
Verbose output.
Define explicitly massless momenta (same as in Pythia::PartonLevel).
End make initial-state partons massless.
Final-state partons.
Return if nothing needs to be done.
Create copy of original momenta (in case of failure).
Boost to CM if original system not at rest.
Define vector for computing CM energy of modified system.
Identify particles to be made massless (by ID code) and rescale their momenta along direction of motion.
Sanity check.
Restore masses in case any were already changed.
Failed.
Check new 4-vector.
End check new 4-vector.
End if massless flavour with mass > 0.
Add to new CM momentum.
End loop over FS particles.
New system generally has smaller invariant mass and some motion. Determine if additional scalings or boosts are needed.
Update event record (masses already updated above).
If the new system has a different CM energy, rescale all energies and momenta to restore the same CM energy as before.
Then boost to CM frame (preserves CM energy).
Boost to new CM frame
If required, also boost back to frame of input system
Update event record (masses already updated above).
End do boosts.
Verbose output: final configuration.
End make final-state momenta massless.
We made it.
| double mHadMin | ( | const int | id1in, |
| const int | id2in | ||
| ) |
Function to check for the hadronization cutoff for a colour connected parton pair.
Function to find the lowest meson mass for a parton pair treating gluons as down quarks. Used to determine hadronisation boundaries consistent with assumption of string length > 1 meson.
Treat gluons as down quarks for purposes of minimum meson mass.
No hadronisation cut for ID codes >= 6.
ID of would-be pseudoscalar meson.
Special for ssbar, use eta rather than eta'.
Check if 2-particle system is on-shell and rescale if not.
Define massive on-shell momenta.
If this got them closer to mass shell, replace momenta.
| bool showerChecks | ( | Event & | event, |
| bool | ISR | ||
| ) |
Function to check the event after each branching. Added by NF to see if certain Pythia warnings/error are caused by the shower.
Function to check the event after each branching, mostly copied from Pythia8.
Only for verbose >= Logger::REPORT.
First check if this event has any beams.
Count incoming partons with negative momentum and charge.
If beam remnants were added, define incoming as sum of beams.
If there are incoming beams (but no remnants yet), use incoming partons.
No beams. Incoming defined by partons with mother = 0.
Loop over particles in the event.
Look for any unrecognized particle codes.
Check that colour assignments are the expected ones.
Look for particles with mismatched or not-a-number energy/momentum/mass.
Look for particles with not-a-number vertex/lifetime.
Add final-state four-momentum and charge.
End of particle loop.
Check energy-momentum/charge conservation.
Check that mother and daughter information match for each particle.
Loop through the event and check mother/daughter lists.
Check that mother and daughter lists not empty where not expected to.
Check that the particle appears in the daughters list of each mother.
Check that the particle appears in the mothers list of each daughter.
End loop through the event.
Warn if any errors were found.
Print some more info.
Made it to here: no major problems.
| AlphaStrong alphaStrong {} |
Public data members: strong coupling in MSbar and CMW schemes, user and default choices,
1.8.11
