Dipole/Kinematics/FIMassiveKinematics.h

0001 // -*- C++ -*-
0002 //
0003 // FILightKinematics.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_FILightKinematics_H
0010 #define HERWIG_FILightKinematics_H
0011 //
0012 // This is the declaration of the FILightKinematics class.
0013 //
0014
0015 #include "DipoleSplittingKinematics.h"
0016
0017 namespace Herwig {
0018
0019 using namespace ThePEG;
0020
0021 /**
0022  * \ingroup DipoleShower
0023  * \author Simon Platzer, Martin Stoll
0024  *
0025  * \brief FIMassiveKinematics implements massless splittings
0026  * off a final-initial dipole.
0027  *
0028  */
0029 class FIMassiveKinematics: public DipoleSplittingKinematics {
0030
0031 public:
0032
0033   /**
0034    * The default constructor.
0035    */
0036   FIMassiveKinematics();
0037
0038 public:
0039
0040   /**
0041    * Return the boundaries in between the evolution
0042    * variable random number is to be sampled; the lower
0043    * cuoff is assumed to correspond to the infrared cutoff.
0044    */
0045   virtual pair<double,double> kappaSupport(const DipoleSplittingInfo& dIndex) const;
0046
0047   /**
0048    * Return the boundaries in between the momentum
0049    * fraction random number is to be sampled.
0050    */
0051   virtual pair<double,double> xiSupport(const DipoleSplittingInfo& dIndex) const;
0052
0053   /**
0054    * Return the boundaries on the momentum fraction
0055    */
0056   virtual pair<double,double> zBoundaries(Energy,
0057                       const DipoleSplittingInfo&,
0058                       const DipoleSplittingKernel&) const {
0059     return {0.0,1.0};
0060   }
0061
0062   /**
0063    * Return the dipole scale associated to the
0064    * given pair of emitter and spectator. This
0065    * should be the invariant mass or absolute value
0066    * final/final or initial/initial and the absolute
0067    * value of the momentum transfer for intial/final or
0068    * final/initial dipoles.
0069    */
0070   virtual Energy dipoleScale(const Lorentz5Momentum& pEmitter,
0071                  const Lorentz5Momentum& pSpectator) const;
0072
0073   /**
0074    * Return the maximum pt for the given dipole scale.
0075    */
0076   virtual Energy ptMax(Energy dScale,
0077                double emX, double specX,
0078                const DipoleSplittingInfo& dInfo,
0079                const DipoleSplittingKernel& split) const;
0080
0081   /**
0082    * Return the maximum pt for the given dipole scale.
0083    */
0084   virtual Energy ptMax(Energy dScale,
0085                double, double,
0086                const DipoleIndex& dIndex,
0087                const DipoleSplittingKernel& split,
0088                tPPtr emitter, tPPtr) const;
0089
0090   /**
0091    * Return the maximum pt for the given dipole scale.
0092    */
0093   virtual Energy ptMax(Energy,
0094                double, double,
0095                const DipoleIndex&,
0096                const DipoleSplittingKernel&) const {
0097       // Only the DipoleSplittingInfo version should be used for massive
0098       // dipoles, for now anyway.
0099     assert(false);
0100     return ZERO;
0101   }
0102
0103   /**
0104    * Return the maximum virtuality for the given dipole scale.
0105    */
0106   virtual Energy QMax(Energy dScale,
0107               double emX, double specX,
0108               const DipoleSplittingInfo& dInfo,
0109               const DipoleSplittingKernel& split) const;
0110
0111   /**
0112    * Return the maximum virtuality for the given dipole scale.
0113    */
0114   virtual Energy QMax(Energy,
0115               double, double,
0116               const DipoleIndex&,
0117               const DipoleSplittingKernel&) const {
0118     // Only the DipoleSplittingInfo version should be used for massive
0119     // dipoles, for now anyway.
0120     assert(false);
0121     return ZERO;
0122   }
0123
0124   /**
0125    * Return the pt given a virtuality.
0126    */
0127   virtual Energy PtFromQ(Energy scale, const DipoleSplittingInfo&) const;
0128
0129   /**
0130    * Return the virtuality given a pt.
0131    */
0132   virtual Energy QFromPt(Energy scale, const DipoleSplittingInfo&) const;
0133
0134   /**
0135    * Return the random number associated to
0136    * the given pt.
0137    */
0138   virtual double ptToRandom(Energy pt, Energy dScale,
0139                 double emX, double specX,
0140                 const DipoleIndex& dIndex,
0141                 const DipoleSplittingKernel&) const;
0142
0143   /**
0144    * Generate splitting variables given three random numbers
0145    * and the momentum fractions of the emitter and spectator.
0146    * Return true on success.
0147    */
0148   virtual bool generateSplitting(double kappa, double xi, double phi,
0149                  DipoleSplittingInfo& dIndex,
0150                  const DipoleSplittingKernel&);
0151
0152   /**
0153    * Generate the full kinematics given emitter and
0154    * spectator momentum and a previously completeted
0155    * DipoleSplittingInfo object.
0156    */
0157   virtual void generateKinematics(const Lorentz5Momentum& pEmitter,
0158                   const Lorentz5Momentum& pSpectator,
0159                   const DipoleSplittingInfo& dInfo);
0160
0161 public:
0162
0163   /**
0164    * Triangular / Kallen function
0165    */
0166   template <class T>
0167   inline double rootOfKallen (T a, T b, T c) const {
0168     double sres=a*a + b*b + c*c - 2.*( a*b+a*c+b*c );
0169     return sres>0.?sqrt( sres ):0.; }
0170
0171
0172 public:
0173
0174   /** @name Functions used by the persistent I/O system. */
0175   //@{
0176   /**
0177    * Function used to write out object persistently.
0178    * @param os the persistent output stream written to.
0179    */
0180   void persistentOutput(PersistentOStream & os) const;
0181
0182   /**
0183    * Function used to read in object persistently.
0184    * @param is the persistent input stream read from.
0185    * @param version the version number of the object when written.
0186    */
0187   void persistentInput(PersistentIStream & is, int version);
0188   //@}
0189
0190   /**
0191    * The standard Init function used to initialize the interfaces.
0192    * Called exactly once for each class by the class description system
0193    * before the main function starts or
0194    * when this class is dynamically loaded.
0195    */
0196   static void Init();
0197
0198 protected:
0199
0200   /** @name Clone Methods. */
0201   //@{
0202   /**
0203    * Make a simple clone of this object.
0204    * @return a pointer to the new object.
0205    */
0206   virtual IBPtr clone() const;
0207
0208   /** Make a clone of this object, possibly modifying the cloned object
0209    * to make it sane.
0210    * @return a pointer to the new object.
0211    */
0212   virtual IBPtr fullclone() const;
0213   //@}
0214
0215
0216 // If needed, insert declarations of virtual function defined in the
0217 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
0218
0219
0220 private:
0221
0222   /**
0223    * The static object used to initialize the description of this class.
0224    * Indicates that this is a concrete class with persistent data.
0225    */
0226   static ClassDescription<FIMassiveKinematics> initFIMassiveKinematics;
0227
0228   /**
0229    * The assignment operator is private and must never be called.
0230    * In fact, it should not even be implemented.
0231    */
0232   FIMassiveKinematics & operator=(const FIMassiveKinematics &) = delete;
0233
0234 };
0235
0236 }
0237
0238 #include "ThePEG/Utilities/ClassTraits.h"
0239
0240 namespace ThePEG {
0241
0242 /** @cond TRAITSPECIALIZATIONS */
0243
0244 /** This template specialization informs ThePEG about the
0245  *  base classes of FIMassiveKinematics. */
0246 template <>
0247 struct BaseClassTrait<Herwig::FIMassiveKinematics,1> {
0248   /** Typedef of the first base class of FIMassiveKinematics. */
0249   typedef Herwig::DipoleSplittingKinematics NthBase;
0250 };
0251
0252 /** This template specialization informs ThePEG about the name of
0253  *  the FIMassiveKinematics class and the shared object where it is defined. */
0254 template <>
0255 struct ClassTraits<Herwig::FIMassiveKinematics>
0256   : public ClassTraitsBase<Herwig::FIMassiveKinematics> {
0257   /** Return a platform-independent class name */
0258   static string className() { return "Herwig::FIMassiveKinematics"; }
0259   /**
0260    * The name of a file containing the dynamic library where the class
0261    * FIMassiveKinematics is implemented. It may also include several, space-separated,
0262    * libraries if the class FIMassiveKinematics depends on other classes (base classes
0263    * excepted). In this case the listed libraries will be dynamically
0264    * linked in the order they are specified.
0265    */
0266   static string library() { return "HwDipoleShower.so"; }
0267 };
0268
0269 /** @endcond */
0270
0271 }
0272
0273 #endif /* HERWIG_FIMassiveKinematics_H */