File: ShowerParticle.h
Description:
This class represents a particle in the showering process.
It has much less information than the ThePEG Particle, and it has some
specifics information useful only during the showering process.
Notice that:
- ShowerParticle needs to inherit from HandlerBase
(rather than, more simply, from ReferenceCounted) becuse it needs
to create a ThePEG::Particle object, and therefore the method
HandlerBase::getParticle( id ) is used.
- it has been necessary to define a new class ShowerColourLine
in order to represent colour lines between ShowerParticle objects
because the similar ThePEG class ColourLine can be used only
with ThePEG Particle.
- for forward evolution, it is clear what does mean parent/child;
for backward evolution, however, it depends whether we want
to keep a physical picture or a Monte-Carlo effective one.
In the former case, an incoming particle (emitting particle)
splits into an emitted particle and the emitting particle after
the emission: the latter two are then children of the
emitting particle, the parent. In the Monte-Carlo effective
picture, we have that the particle close to the hard subprocess,
with higher (space-like) virtuality, splits into an emitted particle
and the emitting particle at lower virtuality: the latter two are,
in this case, the children of the first one, the parent. For obvious,
practical programming reasons, we choose the Monte-Carlo effective picture.
- the pointer to a SplitFun object is set only in the case
that the particle has undergone to a shower emission; similarly,
the pointer to a Decayer object is set only in the case
that the particle has undergone to a decay.
In the case of particle connected directly to the hard subprocess,
there is no pointer to the hard subprocess, but there is a method
(isFromHardSubprocess()) which returns true only in this case.
- the spin density matrix (rho), and the decay matrix (D) are
implemented as complex bivectors, that we typedef (in
ShowerConfig.h)
as ComplexMatrix, rather than as pair (one for the real part
and one for the imaginary part) of real true Matrix object as defined in
CLHEP (CLHEP/Matrix/Matrix.h : notice that there is no
complex matrices defined in CLHEP), becaue the rho-D propagation is not
indeed a true matrix multiplication: nested for loops are used instead.
This is exactly the same approach as in Fortran Herwig. Furthermore,
again similarly to what is done in Fortran Herwig, we keep one
single "matrix" for both rho and D, because we never need both rho and D
matrices for the same particle at the same time. In other words, when we
start evolving, even in a multi-scale showering, a time-like particle
(forward evolution), the "matrix" represents rho, whereas at the end of
the forward showering the "matrix" represents D; vice versa, for a space-like
particle (backward evolution), at the beginning the "matrix" represents D,
whereas at the end of backward showering the "matrix" represents rho.
***LOOKHERE***
--- The decayer has been defined as a transient pointer,
but maybe it shouldn't be transient at all, if for example
such decayer is not referenced by any other object...
***endLOOKHERE***
See
also:
namespace Herwig
CLASS
ShowerParticle:
Base class:
Private members:
inline ShowerParticle();
PPtr temp;
Public members:
inline void * operator new(size_t);
inline void operator delete(void *, size_t);
inline ShowerParticle(tcEventPDPtr);
inline ShowerParticle(const ShowerParticle &);
inline ShowerParticle(const Particle &);
virtual ~ShowerParticle();
Standard ctors and dtor.
explicit ShowerParticle(const ThePEG::Particle & inputP7Particle);
Create a ShowerParticle object from a ThePEG::Particle object.
This is useful at the beginning of the Showering, when we receive
the ThePEG particles (in the event record) from the hard subprocess.
PPtr createThePEGParticle() const;
Create a ThePEG::Particle object from this ShowerParticle object.
This is useful at the end of the Showering, when we have to update
the event record with ThePEG particles, using some of the
ShowerParticle objects produced by the showering
(which ones depends on the degree of detail of the showering we want to keep
in the event record).
inline const ParticleData & data() const;
inline tcPDPtr dataPtr() const { return _pdptr; }
inline void dataPtr(const tcPDPtr & inputParticleDataPtr);
Access/Set the particle data.
inline const Lorentz5Momentum & momentum() const;
inline void momentum(const Lorentz5Momentum & inputMomentum);
Access/Set the 5-momentum vector of the component (parton or diquark).
inline const LorentzPoint & position() const;
inline void position(const LorentzPoint & inputPosition);
Access/Set the particle 4-position. It is eventually used by the
Hadronization (for the colour reconnection).
inline void transform(const LorentzRotation & r);
void deepTransform(const LorentzRotation & r);
inline void deepBoost(double bx, double by, double bz);
Do Lorentz transformations on this particle and its decay products.
***LOOKHERE*** TO BE DEFINED : MAY BE IS ENOUGH ONE OF THE TWO
inline tShoColinePtr antiColourLine() const;
inline tShoColinePtr colourLine(bool anti = false) const;
Return the colour lines to which this particle is connected.
inline void setAntiColourLine(ShoColinePtr);
inline void setColourLine(ShoColinePtr, bool anti = false);
Set the colour lines to which this particle is connected.
inline tShoParPtr parent() const;
inline void parent(const tShoParPtr inputParent);
Access/Set the parent particle.
Notice that in the case of backward evolution splitting,
the parent is the one with higher (space-like) virtuality,
that is "closer" to the hard subprocess
inline bool isFinalState() const;
inline void setFinalState( const bool );
Access/Set the flag that tells if the particle is final state
or initial state.
inline bool isFromHardSubprocess() const;
inline void setFromHardSubprocess(const bool);
It returns true is the particle has no parent, which means
that it is connected directly to the hard subprocess
(incoming if it is space-like, outgoing it is time-like);
in all other cases, it returns false.
inline const ShowerParticleVector & children() const;
Return a const reference to the collection of decay products.
inline void addChild(const tShowerParticlePtr);
Add a child, setting child's parent pointer accordingly.
inline void removeChildren();
remove collection of children.
bool addChildren(const tShowerParticleVector &);
Add a collection of children, setting children's parent pointer
accordingly. The input children can be either the decay products
of this particle, or the radiated particle and emitting particle
after the emission. In the latter case, when the emitting particle
is a decayed particle, therefore having already children, the
method automatically transfers the decay products to the
decayed particle after the emission (which should be one of
particle in inputChildren). If some inconsistency is found,
then the method returns false; otherwise true.
inline double sudAlpha() const;
inline void sudAlpha(const double);
inline double sudBeta() const;
inline void sudBeta(const double);
inline Energy sudPx() const;
inline void sudPx(const Energy);
inline Energy sudPy() const;
inline void sudPy(const Energy);
inline Energy sudPperp() const;
inline Energy2 sudPperp2() const;
Access/Set Sudakov variables.
Notice that the ShowerKinematics object is logically
associated more with the branching vertex than with the radiating
particle itself, although it is stored in the ShowerParticle
object associated with the branching (radiating) particle.
Furthermore, the branching products have not ShowerKinematics
object (they eventually will have one only later if they branch).
Therefore this Sudakov variables can be considered as a useful
representation of the temporarily, preliminary, momentum of the
ShowerParticle object during the showering evolution,
whereas the momentum member describes the "final", "real" one.
inline tSplitFunPtr splitFun() const;
inline void setSplitFun(const tSplitFunPtr);
Access/Set the SplitFun object responsible of the
eventual branching of this particle.
inline tDecayerPtr decayer() const;
inline void decayer(const tDecayerPtr inputDecayer);
Access/Set the Decayer object responsible of the
eventual decay of this particle.
inline ShoKinPtr & showerKinematics();
void setShowerKinematics(const ShoKinPtr);
Access/Set the ShowerKinematics object.
inline vector<Energy> evolutionScales() const;
inline const tShowerParticleVector & partners() const;
Return (a const reference to) the vector of evolution scales
(q-tilda scales) and of (pointers to) the partners corresponding to each
considered interaction types (QCD, QED, EWK,...) defined in ShowerIndex.
The vector of (pointers to) the partners is needed only as the
most general way to decide in which frame the shower is described.
inline void setEvolutionScale(const ShowerIndex::InteractionType,
const Energy);
inline void setPartner(const ShowerIndex::InteractionType,
const tShowerParticlePtr);
Set the scale/partner for the specified interaction.
inline bool isRhoDUpdate() const;
inline void setRhoDUpdate(const bool);
Access/Set the flag that tells if the rho-D matrix has been updated.
inline ComplexMatrix & rhoD();
Access the rho-D (spin density matrix or decay matrix) of the particle.
inline bool isReconstructionFixedPoint() const;
inline void setReconstructionFixedPoint(const bool);
Access/Set the flag that tells if the particle should be
treated in a special way during the kinematics reconstruction
(see KinematicsReconstructor class).
In practice, it returns true when either the particle is childless,
or is a on-shell decaying particle (in which case we have to set the flag to
true before the showering of this particle: it is not enough to check
if decayer() is not null, because if it emits radiation
the decays products will be "transferred" to the particle
instance after the showering).
void printInfo();
prints info of a single particle in some predefined way, mainly
for debug purposes. Used by deepPrintInfo()!id>.
void deepPrintInfo();
print info of all children
void addChildrenEvtRec(const tStepPtr);
Lorentz5Momentum sumParentsMomenta();
get the sum of all parents momenta (only for plotting)
tShowerParticleVector getFSChildren();
get a list of all children of _particle that are in the final
state
inline tPPtr getP7base();
inline void setP7base(const tPPtr& );
Protected members:
inline virtual PPtr clone() const;
inline virtual PPtr fullclone() const;
Standard clone methods.
Private members:
ShowerParticle & operator=(const ShowerParticle &);
Private and non-existent assignment operator.
bool _isFinalState;
bool _rhoDUpdate;
bool _reconstructionFixedPoint;
bool _isFromHardSubprocess;
double _sudAlpha;
double _sudBeta;
Energy _sudPx;
Energy _sudPy;
tSplitFunPtr _splitFun;
ShoKinPtr _showerKinematics;
vector<Energy> _scales;
tShowerParticleVector _partners;
ComplexMatrix _rhoD;
tPPtr _p7base;
static ClassDescription<ShowerParticle> initShowerParticle;
namespace ThePEG
template <>
STRUCT
BaseClassTrait<Herwig::ShowerParticle,1>
Public members:
typedef EventRecordBase NthBase;
template <>
STRUCT
ClassTraits<Herwig::ShowerParticle>:
Public members:
public ClassTraitsBase<Herwig::ShowerParticle> {
static string className() { return "/Herwig++/ShowerParticle"; }
static TPtr create() { return TPtr::Create(Herwig::ShowerParticle(tcEventPDPtr())); }
DEFINED MACROS
INCLUDED FILES
ShowerConfig.h
ThePEG/Handlers/HandlerBase.h
Herwig++/Utilities/GlobalParameters.h
ThePEG/PDT/ParticleData.h
ThePEG/EventRecord/Particle.h
ThePEG/EventRecord/Step.h
ShowerKinematics.h
ShowerIndex.h
ShowerParticle.icc