herwig is hosted by Hepforge, IPPP Durham
Herwig++  2.7.0
FFMassiveKinematics.h
00001 // -*- C++ -*-
00002 //
00003 // FFMassiveKinematics.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
00004 // Copyright (C) 2002-2007 The Herwig Collaboration
00005 //
00006 // Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
00007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
00008 //
00009 #ifndef HERWIG_FFMassiveKinematics_H
00010 #define HERWIG_FFMassiveKinematics_H
00011 //
00012 // This is the declaration of the FFMassiveKinematics class.
00013 //
00014 
00015 #include "DipoleSplittingKinematics.h"
00016 
00017 namespace Herwig {
00018 
00019 using namespace ThePEG;
00020 
00029 class FFMassiveKinematics: public DipoleSplittingKinematics {
00030 
00031 public:
00032 
00038   FFMassiveKinematics();
00039 
00043   virtual ~FFMassiveKinematics();
00045 
00046 public:
00047 
00053   virtual pair<double,double> kappaSupport(const DipoleSplittingInfo& dIndex) const;
00054 
00059   virtual pair<double,double> xiSupport(const DipoleSplittingInfo& dIndex) const;
00060 
00064   virtual pair<double,double> zBoundaries(Energy,
00065                                           const DipoleSplittingInfo&,
00066                                           const DipoleSplittingKernel&) const {
00067     return make_pair(0.0,1.0);
00068   }
00069 
00078   virtual Energy dipoleScale(const Lorentz5Momentum& pEmitter,
00079                              const Lorentz5Momentum& pSpectator) const;
00080 
00084   virtual Energy ptMax(Energy dScale, 
00085                        double emX, double specX,
00086                        const DipoleIndex& ind,
00087                        const DipoleSplittingKernel& split) const;
00088 
00092   virtual Energy QMax(Energy dScale, 
00093                       double emX, double specX,
00094                       const DipoleIndex& dIndex,
00095                       const DipoleSplittingKernel& split) const;
00096 
00100   virtual Energy PtFromQ(Energy scale, const DipoleSplittingInfo&) const;
00101 
00105   virtual Energy QFromPt(Energy scale, const DipoleSplittingInfo&) const;
00106 
00111   virtual double ptToRandom(Energy pt, Energy dScale,
00112                             double emX, double specX,
00113                             const DipoleIndex& dIndex,
00114                             const DipoleSplittingKernel& split) const;
00115 
00121   virtual bool generateSplitting(double kappa, double xi, double phi,
00122                                  DipoleSplittingInfo& dIndex,
00123                                  const DipoleSplittingKernel& split);
00124 
00130   virtual void generateKinematics(const Lorentz5Momentum& pEmitter,
00131                                   const Lorentz5Momentum& pSpectator,
00132                                   const DipoleSplittingInfo& dInfo);
00133 
00134 public:
00135   
00139   template <class T>
00140   inline double rootOfKallen (T a, T b, T c) const {
00141     return sqrt( a*a + b*b + c*c - 2.*( a*b+a*c+b*c ) ); }
00142   
00148   ThreeVector<double> rotateToZ (Lorentz5Momentum& pTarget, Lorentz5Momentum& p1){
00149     ThreeVector<double> oldAxis = pTarget.vect().unit();
00150     double ct = oldAxis.z(); double st = sqrt( 1.-sqr(ct) ); // cos,sin(theta)
00151     double cp = oldAxis.x()/st; double sp = oldAxis.y()/st; // cos,sin(phi)
00152     pTarget.setZ( pTarget.vect().mag() ); pTarget.setX( 0.*GeV ); pTarget.setY( 0.*GeV );
00153     Lorentz5Momentum p1old = p1;
00154     p1.setX(    sp*p1old.x() -    cp*p1old.y()                );
00155     p1.setY( ct*cp*p1old.x() + ct*sp*p1old.y() - st*p1old.z() );
00156     p1.setZ( st*cp*p1old.x() + st*sp*p1old.y() + ct*p1old.z() );
00157     return oldAxis;
00158   }
00159 
00160 public:
00161 
00168   void persistentOutput(PersistentOStream & os) const;
00169 
00175   void persistentInput(PersistentIStream & is, int version);
00177 
00184   static void Init();
00185 
00186 protected:
00187 
00194   virtual IBPtr clone() const;
00195 
00200   virtual IBPtr fullclone() const;
00202 
00203 
00204 // If needed, insert declarations of virtual function defined in the
00205 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
00206 
00207 
00208 private:
00209 
00214   static ClassDescription<FFMassiveKinematics> initFFMassiveKinematics;
00215 
00220   FFMassiveKinematics & operator=(const FFMassiveKinematics &);
00221 
00222 };
00223 
00224 }
00225 
00226 #include "ThePEG/Utilities/ClassTraits.h"
00227 
00228 namespace ThePEG {
00229 
00234 template <>
00235 struct BaseClassTrait<Herwig::FFMassiveKinematics,1> {
00237   typedef Herwig::DipoleSplittingKinematics NthBase;
00238 };
00239 
00242 template <>
00243 struct ClassTraits<Herwig::FFMassiveKinematics>
00244   : public ClassTraitsBase<Herwig::FFMassiveKinematics> {
00246   static string className() { return "Herwig::FFMassiveKinematics"; }
00254   static string library() { return "HwDipoleShower.so"; }
00255 };
00256 
00259 }
00260 
00261 #endif /* HERWIG_FFMassiveKinematics_H */