Herwig 7 is hosted by Hepforge, IPPP Durham
Herwig  7.1.0
Herwig::ClusterFissioner Class Reference

This class handles clusters which are too heavy. More...

#include <ClusterFissioner.h>

Inheritance diagram for Herwig::ClusterFissioner:

Public Types

typedef pair< PPtr, PPtrPPair
 Definition for easy passing of two particles.
 
typedef pair< PPair, PPaircutType
 Definition for use in the cut function.
 
- Public Types inherited from ThePEG::InterfacedBase
enum  InitState
 
- Public Types inherited from ThePEG::Pointer::ReferenceCounted
typedef unsigned int CounterType
 

Public Member Functions

tPVector fission (ClusterVector &clusters, bool softUEisOn)
 Splits the clusters which are too heavy. More...
 
PPair produceHadron (tcPDPtr hadron, tPPtr newPtr, const Lorentz5Momentum &a, const LorentzPoint &b) const
 Produces a hadron and returns the flavour drawn from the vacuum. More...
 
Standard constructors and destructors.
 ClusterFissioner ()
 Default constructor.
 
Functions used by the persistent I/O system.
void persistentOutput (PersistentOStream &os) const
 Function used to write out object persistently. More...
 
void persistentInput (PersistentIStream &is, int version)
 Function used to read in object persistently. More...
 
virtual cutType cutTwo (ClusterPtr &, tPVector &finalhadrons, bool softUEisOn)
 Splits the input cluster. More...
 
virtual cutType cutThree (ClusterPtr &, tPVector &finalhadrons, bool softUEisOn)
 Split three-component cluster.
 
- Public Member Functions inherited from ThePEG::Interfaced
virtual bool defaultInit ()
 
PPtr getParticle (PID) const
 
PDPtr getParticleData (PID) const
 
bool used () const
 
void useMe () const
 
tEGPtr generator () const
 
void persistentOutput (PersistentOStream &os) const
 
void persistentInput (PersistentIStream &is, int version)
 
PPtr getParticle (PID) const
 
PDPtr getParticleData (PID) const
 
bool used () const
 
void useMe () const
 
tEGPtr generator () const
 
void persistentOutput (PersistentOStream &os) const
 
void persistentInput (PersistentIStream &is, int version)
 
- Public Member Functions inherited from ThePEG::InterfacedBase
string fullName () const
 
string name () const
 
string path () const
 
string comment () const
 
void setup (istream &is)
 
virtual void debugme () const
 
void update ()
 
void init ()
 
virtual bool preInitialize () const
 
void initrun ()
 
void finish ()
 
void touch ()
 
void reset ()
 
void clear ()
 
InitState state () const
 
bool locked () const
 
bool touched () const
 
void persistentOutput (PersistentOStream &os) const
 
void persistentInput (PersistentIStream &is, int version)
 
void update ()
 
void init ()
 
virtual bool preInitialize () const
 
void initrun ()
 
void finish ()
 
void touch ()
 
void reset ()
 
void clear ()
 
InitState state () const
 
bool locked () const
 
bool touched () const
 
void persistentOutput (PersistentOStream &os) const
 
void persistentInput (PersistentIStream &is, int version)
 
- Public Member Functions inherited from ThePEG::Base
void debug () const
 
- Public Member Functions inherited from ThePEG::Pointer::ReferenceCounted
CounterType referenceCount () const
 
- Public Member Functions inherited from ThePEG::Named
 Named (const string &newName=string())
 
const string & name () const
 
bool operator== (const Named &other) const
 
bool operator< (const Named &other) const
 

Static Public Member Functions

static void Init ()
 Standard Init function used to initialize the interfaces.
 
- Static Public Member Functions inherited from ThePEG::Interfaced
static void Init ()
 
- Static Public Member Functions inherited from ThePEG::InterfacedBase
static void Init ()
 
- Static Public Member Functions inherited from ThePEG::Base
static void Init ()
 

Protected Member Functions

PPair produceCluster (tPPtr ptrQ, tPPtr newPtr, const Lorentz5Momentum &a, const LorentzPoint &b, const Lorentz5Momentum &c, const Lorentz5Momentum &d, const bool rem, tPPtr spect=tPPtr(), bool remSpect=false) const
 Produces a cluster from the flavours passed in. More...
 
void drawNewFlavour (PPtr &newPtrPos, PPtr &newPtrNeg) const
 Returns the new quark-antiquark pair needed for fission of a heavy cluster. More...
 
Energy drawChildMass (const Energy M, const Energy m1, const Energy m2, const Energy m, const double exp, const bool soft) const
 Produces the mass of a child cluster. More...
 
void calculateKinematics (const Lorentz5Momentum &pClu, const Lorentz5Momentum &p0Q1, const bool toHadron1, const bool toHadron2, Lorentz5Momentum &pClu1, Lorentz5Momentum &pClu2, Lorentz5Momentum &pQ1, Lorentz5Momentum &pQb, Lorentz5Momentum &pQ2, Lorentz5Momentum &pQ2b) const
 Determines the kinematics of a heavy cluster decay C->C1 + C2.
 
void calculatePositions (const Lorentz5Momentum &pClu, const LorentzPoint &positionClu, const Lorentz5Momentum &pClu1, const Lorentz5Momentum &pClu2, LorentzPoint &positionClu1, LorentzPoint &positionClu2) const
 Determine the positions of the two children clusters. More...
 
Clone Methods.
virtual IBPtr clone () const
 Make a simple clone of this object. More...
 
virtual IBPtr fullclone () const
 Make a clone of this object, possibly modifying the cloned object to make it sane. More...
 
Access members for child classes.
HadronSelectorPtr hadronsSelector () const
 Access to the hadron selector.
 
Energy btClM () const
 Access to soft-cluster parameter.
 
double pSplitLight () const
 Cluster splitting paramater for light quarks.
 
double pSplitBottom () const
 Cluster splitting paramater for bottom quarks.
 
double pSplitCharm () const
 Cluster splitting paramater for charm quarks.
 
double pSplitExotic () const
 Cluster splitting paramater for exotic particles.
 
- Protected Member Functions inherited from ThePEG::Interfaced
void reporeg (IBPtr object, string name) const
 
bool setDefaultReference (PtrT &ptr, string classname, string objectname)
 
 Interfaced (const string &newName)
 
 Interfaced (const Interfaced &i)
 
void setGenerator (tEGPtr generator)
 
- Protected Member Functions inherited from ThePEG::InterfacedBase
 InterfacedBase (string newName)
 
 InterfacedBase (const InterfacedBase &i)
 
virtual void readSetup (istream &is)
 
virtual void doupdate ()
 
virtual void doinit ()
 
virtual void doinitrun ()
 
virtual void dofinish ()
 
virtual IVector getReferences ()
 
virtual void rebind (const TranslationMap &)
 
virtual void readSetup (istream &is)
 
virtual void doupdate ()
 
virtual void doinit ()
 
virtual void doinitrun ()
 
virtual void dofinish ()
 
virtual IVector getReferences ()
 
virtual void rebind (const TranslationMap &)
 
- Protected Member Functions inherited from ThePEG::Pointer::ReferenceCounted
 ReferenceCounted (const ReferenceCounted &)
 
ReferenceCountedoperator= (const ReferenceCounted &)
 
 ReferenceCounted (const ReferenceCounted &)
 
ReferenceCountedoperator= (const ReferenceCounted &)
 
- Protected Member Functions inherited from ThePEG::Named
const Namedoperator= (const Named &other)
 
const string & name (const string &newName)
 

Private Member Functions

ClusterFissioneroperator= (const ClusterFissioner &)
 Private and non-existent assignment operator.
 
void cut (stack< ClusterPtr > &, ClusterVector &, tPVector &finalhadrons, bool softUEisOn)
 This method directs the splitting of the heavy clusters. More...
 
bool isHeavy (tcClusterPtr)
 Check if a cluster is heavy enough to split again.
 

Private Attributes

HadronSelectorPtr _hadronsSelector
 A pointer to a Herwig::HadronSelector object for generating hadrons.
 
Energy _btClM
 Parameter used (2/b) for the beam cluster mass generation. More...
 
int _iopRem
 Flag used to determine what distributions to use for the cluster masses.
 
Tension _kappa
 The string constant.
 
The Cluster max mass,dependant on which quarks are involved, used to determine when

fission will occur.

Energy _clMaxLight
 
Energy _clMaxBottom
 
Energy _clMaxCharm
 
Energy _clMaxExotic
 
The power used to determine when cluster fission will occur.
double _clPowLight
 
double _clPowBottom
 
double _clPowCharm
 
double _clPowExotic
 
The power, dependant on whic quarks are involved, used in the cluster mass generation.
double _pSplitLight
 
double _pSplitBottom
 
double _pSplitCharm
 
double _pSplitExotic
 

Additional Inherited Members

- Public Attributes inherited from ThePEG::InterfacedBase
 initializing
 
 uninitialized
 
 initialized
 
 runready
 
- Public Attributes inherited from ThePEG::Pointer::ReferenceCounted
const unsigned long uniqueId
 
- Static Protected Member Functions inherited from ThePEG::Interfaced
static void registerRepository (IBPtr)
 
static void registerRepository (IBPtr, string newName)
 

Detailed Description

This class handles clusters which are too heavy.

Author
Philip Stephens
Alberto Ribon
Stefan Gieseke

This class does the job of chopping up either heavy clusters or beam clusters in two lighter ones. The procedure is repeated recursively until all of the cluster children have masses below some threshold values.

For the beam remnant clusters, at the moment what is done is the following. In the case that the soft underlying event is switched on, the beam remnant clusters are tagged as not available, therefore they will not be treated at all during the hadronization. In the case instead that the soft underlying event is switched off, then the beam remnant clusters are treated exactly as "normal" clusters, with the only exception of the mass spectrum used to generate the cluster children masses. For non-beam clusters, the masses of the cluster children are draw from a power-like mass distribution; for beam clusters, according to the value of the flag _IOpRem, either both children masses are draw from a fast-decreasing exponential mass distribution (case _IOpRem == 0, or, indendently by _IOpRem, in the special case that the beam cluster contains two beam remnants), or one mass from the exponential distribution (corresponding of the cluster child with the beam remnant) and the other with the usual power-like distribution (case _IOpRem == 1, which is the default one, as in Herwig 6.3).

The reason behind the use of a fast-decreasing exponential distribution is that to avoid a large transverse energy from the many sequential fissions that would otherwise occur due to the typical large cluster mass of beam clusters. Using instead an exponential distribution the masses of the two cluster children will be very small (order of GeV).

The rationale behind the implementation of the splitting of clusters has been to preserve all of the information about such splitting process. More explicitly a ThePEG::Step class is passed in and the new clusters are added to the step as the decay products of the heavy cluster. This approach has the twofold advantage to provide all of the information that could be needed (expecially in future developments), without any information loss, and furthermore it allows a better debugging.

See also
HadronSelector
The interfaces defined for ClusterFissioner.

Definition at line 71 of file ClusterFissioner.h.

Member Function Documentation

◆ calculatePositions()

void Herwig::ClusterFissioner::calculatePositions ( const Lorentz5Momentum &  pClu,
const LorentzPoint &  positionClu,
const Lorentz5Momentum &  pClu1,
const Lorentz5Momentum &  pClu2,
LorentzPoint &  positionClu1,
LorentzPoint &  positionClu2 
) const
protected

Determine the positions of the two children clusters.

This routine generates the momentum of the decay products. It also generates the momentum in the lab frame of the partons drawn out of the vacuum.

◆ clone()

virtual IBPtr Herwig::ClusterFissioner::clone ( ) const
protectedvirtual

Make a simple clone of this object.

Returns
a pointer to the new object.

Implements ThePEG::InterfacedBase.

◆ cut()

void Herwig::ClusterFissioner::cut ( stack< ClusterPtr > &  ,
ClusterVector ,
tPVector finalhadrons,
bool  softUEisOn 
)
private

This method directs the splitting of the heavy clusters.

This method does the splitting of the clusters and all of its cluster children, if heavy. All of these new children clusters are added to the collection of clusters. The method works as follows. Initially the vector contains just the stack of input pointers to the clusters to be split. Then it will be filled recursively by all of the cluster's children that are heavy enough to require to be split. In each loop, the last element of the vector is considered (only once because it is then removed from the vector).

Todo:
is the following still true? For normal, non-beam clusters, a power-like mass distribution is used, whereas for beam clusters a fast-decreasing exponential mass distribution is used instead. This avoids many iterative splitting which could produce an unphysical large transverse energy from a supposed soft beam remnant process.

◆ cutTwo()

virtual cutType Herwig::ClusterFissioner::cutTwo ( ClusterPtr &  ,
tPVector finalhadrons,
bool  softUEisOn 
)
virtual

Splits the input cluster.

Split the input cluster (which can be either an heavy non-beam cluster or a beam cluster). The result is two pairs of particles. The first element of each pair is new cluster/hadron, while the second element of each pair is the particle drawn from the vacuum to create the new cluster/hadron. Notice that this method treats also beam clusters by using a different mass spectrum used to generate the cluster child masses (see method drawChildMass). Split two-component cluster

◆ drawChildMass()

Energy Herwig::ClusterFissioner::drawChildMass ( const Energy  M,
const Energy  m1,
const Energy  m2,
const Energy  m,
const double  exp,
const bool  soft 
) const
protected

Produces the mass of a child cluster.

Draw the masses $M'$ of the the cluster child produced by the fission of an heavy cluster (of mass M). m1, m2 are the masses of the constituents of the cluster; m is the mass of the quark extract from the vacuum (together with its antiparticle). The algorithm produces the mass of the cluster formed with consituent m1. Two mass distributions can be used for the child cluster mass:

  1. power-like mass distribution ("normal" mass) with power exp

    \[ M' = {\rm rnd}((M-m_1-m_2-m)^P, m^p)^{1/P} + m_1 \]

    where $ P $ is a parameter of the model and $ \rm{rnd} $ is the function:

    \[ \rm{rnd}(a,b) = (1-r)a + r b \]

    and here $ r $ is a random number [0,1].
  2. fast-decreasing exponential mass distribution ("soft" mass) with rmin. rmin is given by

    \[ r_{\rm min} = \exp(-b (M - m_1 - m_2 - 2 m)) \]

    where $ b $ is a parameter of the model. The generated mass is given by

    \[ M' = m_1 + m - \frac{\log\left( {\rm rnd}(r_{\rm min}, 1-r_{\rm min})\right)}{b} \]

    .

The choice of which mass distribution should be used for each of the two cluster children is dictated by the parameter soft.

◆ drawNewFlavour()

void Herwig::ClusterFissioner::drawNewFlavour ( PPtr newPtrPos,
PPtr newPtrNeg 
) const
protected

Returns the new quark-antiquark pair needed for fission of a heavy cluster.

Equal probabilities are assumed for producing u, d, or s pairs.

◆ fission()

tPVector Herwig::ClusterFissioner::fission ( ClusterVector clusters,
bool  softUEisOn 
)

Splits the clusters which are too heavy.

Split either heavy clusters or beam clusters recursively until all children have mass below some threshold. Heavy clusters are those that satisfy the condition

\[ M^P > C^P + S^P \]

where $ M $ is the clusters mass, $ P $ is the parameter ClPow, $ C $ is the parameter ClMax and $ S $ is the sum of the clusters constituent partons. For beam clusters, they are split only if the soft underlying event is switched off, otherwise these clusters will be tagged as unavailable and they will not be treated by the hadronization altogether. In the case beam clusters will be split, the procedure is exactly the same as for normal non-beam clusters, with the only exception of the mass spectrum from which to draw the masses of the two cluster children (see method drawChildrenMasses for details).

◆ fullclone()

virtual IBPtr Herwig::ClusterFissioner::fullclone ( ) const
protectedvirtual

Make a clone of this object, possibly modifying the cloned object to make it sane.

Returns
a pointer to the new object.

Reimplemented from ThePEG::InterfacedBase.

◆ persistentInput()

void Herwig::ClusterFissioner::persistentInput ( PersistentIStream is,
int  version 
)

Function used to read in object persistently.

Parameters
isthe persistent input stream read from.
versionthe version number of the object when written.

◆ persistentOutput()

void Herwig::ClusterFissioner::persistentOutput ( PersistentOStream os) const

Function used to write out object persistently.

Parameters
osthe persistent output stream written to.

◆ produceCluster()

PPair Herwig::ClusterFissioner::produceCluster ( tPPtr  ptrQ,
tPPtr  newPtr,
const Lorentz5Momentum &  a,
const LorentzPoint &  b,
const Lorentz5Momentum &  c,
const Lorentz5Momentum &  d,
const bool  rem,
tPPtr  spect = tPPtr(),
bool  remSpect = false 
) const
protected

Produces a cluster from the flavours passed in.

This routine produces a new cluster with the flavours given by ptrQ and newPtr. The new 5 momentum is a and the parent momentum are c and d. C is for the ptrQ and d is for the new particle newPtr. rem specifies whether the existing particle is a beam remnant or not.

◆ produceHadron()

PPair Herwig::ClusterFissioner::produceHadron ( tcPDPtr  hadron,
tPPtr  newPtr,
const Lorentz5Momentum &  a,
const LorentzPoint &  b 
) const

Produces a hadron and returns the flavour drawn from the vacuum.

This routine produces a new hadron. It also sets the momentum and vertex to the values given.

Member Data Documentation

◆ _btClM

Energy Herwig::ClusterFissioner::_btClM
private

Parameter used (2/b) for the beam cluster mass generation.

Currently hard coded value.

Definition at line 370 of file ClusterFissioner.h.


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