QTilde/Kinematics/ShowerKinematics.h

0001 // -*- C++ -*-
0002 //
0003 // ShowerKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef HERWIG_ShowerKinematics_H
0010 #define HERWIG_ShowerKinematics_H
0011 //
0012 // This is the declaration of the ShowerKinematics class.
0013 //
0014
0015 #include "Herwig/Shower/QTilde/ShowerConfig.h"
0016 #include "ThePEG/Config/ThePEG.h"
0017 #include "Herwig/Shower/QTilde/SplittingFunctions/SudakovFormFactor.h"
0018 #include "Herwig/Shower/QTilde/Kinematics/ShowerKinematics.fh"
0019
0020 namespace Herwig {
0021
0022 using namespace ThePEG;
0023
0024 /**\ingroup Shower
0025  *
0026  * This is the abstract base class from which all other shower
0027  * kinematics classes derive. The main purpose of the
0028  * shower kinematics classes is to allow the reconstruction
0029  * of jet masses, at the end of the showering (indeed, for
0030  * multi-scale showering, at the end of each scale-range evolution).
0031  * This is necessary for the kinematics reshuffling
0032  * in order to compensate the recoil of the emissions.
0033  * The KinematicsReconstructor class is in
0034  * charge of this job, and which is the main "user" of
0035  * ShowerKinematics and its derived classes.
0036  * How this is done depends on the choice of kinematics variables
0037  * and whether the jet is time-like (forward evolved) or
0038  * space-like (backward evolved), whereas the class ShowerKinematics
0039  * describes only the common features which are independent by them.
0040  *
0041  *  In general there are a number of methods specific to a shower approach
0042  *
0043  * @see KinematicsReconstructor
0044  */
0045 class ShowerKinematics: public Base {
0046
0047 public:
0048
0049   /**
0050    * The default constructor.
0051    */
0052   ShowerKinematics() : Base(),
0053                _scale(), _z( 0.0 ), _phi( 0.0 ), _pt(),
0054                _sudakov() {}
0055
0056   /**
0057    * The default constructor.
0058    */
0059   ShowerKinematics(Energy scale, double z, double phi, Energy pt, tSudakovPtr sud)
0060     : Base(),
0061       _scale(scale), _z(z), _phi(phi), _pt(pt),
0062       _sudakov(sud) {}
0063
0064   /**
0065    *  The updateChildren and updateParent
0066    *  members to update the values of the \f$\alpha\f$ and
0067    *  \f$p_\perp\f$ variables during the shower evolution.
0068    */
0069   //@{
0070   /**
0071    * Along with the showering evolution --- going forward for
0072    * time-like (forward) evolution, and going backward for space-like
0073    * (backward) evolution --- the kinematical variables of the
0074    * branching products are calculated and updated from the knowledge
0075    * of the parent kinematics.
0076    * @param parent   The parent
0077    * @param children The children
0078    * @param partnerType The type of evolution partner
0079    */
0080   virtual void updateChildren(const tShowerParticlePtr parent,
0081                   const ShowerParticleVector & children,
0082                   unsigned int pTscheme,
0083                   ShowerPartnerType partnerType) const;
0084
0085   virtual void resetChildren( const tShowerParticlePtr parent,
0086                   const ShowerParticleVector & children) const;
0087
0088   /**
0089    * Update the parent Kinematics from the knowledge of the kinematics
0090    * of the children. This method will be used by the KinematicsReconstructor.
0091    * @param parent   The parent
0092    * @param children The children
0093    * @param partnerType The type of evolution partner
0094    */
0095   virtual void updateParent(const tShowerParticlePtr parent,
0096                 const ShowerParticleVector & children,
0097                 unsigned int pTscheme,
0098                 ShowerPartnerType partnerType) const;
0099
0100   /**
0101    * Update the kinematical data of a particle when a reconstruction
0102    * fixpoint was found. This will highly depend on the kind of
0103    * kinematics chosen and will be defined in the inherited concrete
0104    * classes. This method will be used by the KinematicsReconstructor.
0105    * @param last The particle.
0106    * @param px The \f$x\f$ component of the \f$p_T\f$.
0107    * @param py The \f$y\f$ component of the \f$p_T\f$.
0108    */
0109   virtual void updateLast(const tShowerParticlePtr last,
0110               Energy px, Energy py) const;
0111   //@}
0112
0113   /**
0114    *  The reconstructLast, reconstructChildren and reconstructParent members
0115    *  are used during the reconstruction
0116    */
0117   //@{
0118   /**
0119    * Along with the showering evolution --- going forward for
0120    * time-like (forward) evolution, and going backward for space-like
0121    * (backward) evolution --- the kinematical variables of the
0122    * branching products are calculated and updated from the knowledge
0123    * of the parent kinematics.
0124    * @param parent   The parent
0125    * @param children The children
0126    */
0127   virtual void reconstructChildren(const tShowerParticlePtr parent,
0128                   const ShowerParticleVector & children) const;
0129
0130   /**
0131    * Reconstruct the parent Kinematics from the knowledge of the kinematics
0132    * of the children. This method will be used by the KinematicsReconstructor.
0133    * @param parent   The parent
0134    * @param children The children
0135    */
0136   virtual void reconstructParent(const tShowerParticlePtr parent,
0137                  const ParticleVector & children) const;
0138
0139   /**
0140    * Update the kinematical data of a particle when a reconstruction
0141    * fixpoint was found. This will highly depend on the kind of
0142    * kinematics chosen and will be defined in the inherited concrete
0143    * classes. This method will be used by the KinematicsReconstructor.
0144    * @param last The particle.
0145    * @param mass The mass to be used, if less than zero on-shell
0146    */
0147   virtual void reconstructLast(const tShowerParticlePtr last, Energy mass=-1.*GeV) const;
0148   //@}
0149
0150 public:
0151
0152   /**
0153    *  Set/Get methods for the kinematic variables
0154    */
0155   //@{
0156   /**
0157    * Access the scale of the splitting.
0158    */
0159   Energy scale() const { return _scale; }
0160
0161   /**
0162    * Set the scale of the splitting.
0163    */
0164   void scale(const Energy in) { _scale=in; }
0165
0166   /**
0167    *  Access the energy fraction, \f$z\f$.
0168    */
0169   double z() const { return _z; }
0170
0171   /**
0172    *  Set the energy fraction, \f$z\f$.
0173    */
0174   void z(const double in) { _z=in; }
0175
0176   /**
0177    *  Access the azimuthal angle, \f$\phi\f$.
0178    */
0179   double phi() const { return _phi; }
0180
0181   /**
0182    *  Set the azimuthal angle, \f$\phi\f$.
0183    */
0184   void phi(const double in) { _phi=in; }
0185
0186   /**
0187    *  Access the relative \f$p_T\f$ for the branching
0188    */
0189   Energy pT() const { return _pt; }
0190
0191   /**
0192    *  Set the relative \f$p_T\f$ for the branching
0193    */
0194   void pT(const Energy in) const { _pt=in; }
0195   //@}
0196
0197   /**
0198    *  Set and get methods for the SplittingFunction object
0199    */
0200   //@{
0201   /**
0202    * Access the SplittingFunction object responsible of the
0203    * eventual branching of this particle.
0204    */
0205   tSplittingFnPtr splittingFn() const { return _sudakov-> splittingFn(); }
0206   //@}
0207
0208   /**
0209    *  Set and get methods for the SudakovFormFactor object
0210    */
0211   /**
0212    * Access the SudakovFormFactor object responsible of the
0213    * eventual branching of this particle.
0214    */
0215   tSudakovPtr SudakovFormFactor() const { return _sudakov; }
0216
0217   /**
0218    * Set the SudakovFormFactor object responsible of the
0219    * eventual branching of this particle.
0220    */
0221   void SudakovFormFactor(const tSudakovPtr sud) { _sudakov=sud; }
0222   //@}
0223
0224 private:
0225
0226   /**
0227    * The assignment operator is private and must never be called.
0228    * In fact, it should not even be implemented.
0229    */
0230   ShowerKinematics & operator=(const ShowerKinematics &) = delete;
0231
0232 private:
0233
0234   /**
0235    *  The \f$\tilde{q}\f$ evolution variable.
0236    */
0237   Energy _scale;
0238
0239   /**
0240    *  The energy fraction, \f$z\f$
0241    */
0242   double _z;
0243
0244   /**
0245    *  The azimuthal angle, \f$\phi\f$.
0246    */
0247   double _phi;
0248
0249   /**
0250    *  The relative \f$p_T\f$
0251    */
0252   mutable Energy _pt;
0253
0254   /**
0255    *  The splitting function for the branching of the particle
0256    */
0257   tSudakovPtr _sudakov;
0258
0259 };
0260
0261 }
0262
0263 #endif /* HERWIG_ShowerKinematics_H */