herwig is hosted by Hepforge, IPPP Durham
Herwig  7.2.1
FFMassiveKinematics.h
1 // -*- C++ -*-
2 //
3 // FFMassiveKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator
4 // Copyright (C) 2002-2019 The Herwig Collaboration
5 //
6 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
7 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
8 //
9 #ifndef HERWIG_FFMassiveKinematics_H
10 #define HERWIG_FFMassiveKinematics_H
11 //
12 // This is the declaration of the FFMassiveKinematics class.
13 //
14 
15 #include "DipoleSplittingKinematics.h"
16 
17 namespace Herwig {
18 
19 using namespace ThePEG;
20 
30 
31 public:
32 
39 
43  virtual ~FFMassiveKinematics();
45 
46 public:
47 
53  virtual pair<double,double> kappaSupport(const DipoleSplittingInfo& dIndex) const;
54 
59  virtual pair<double,double> xiSupport(const DipoleSplittingInfo& dIndex) const;
60 
64  virtual pair<double,double> zBoundaries(Energy,
65  const DipoleSplittingInfo&,
66  const DipoleSplittingKernel&) const {
67  return {0.0,1.0};
68  }
69 
78  virtual Energy dipoleScale(const Lorentz5Momentum& pEmitter,
79  const Lorentz5Momentum& pSpectator) const;
80 
84  virtual Energy ptMax(Energy dScale,
85  double emX, double specX,
86  const DipoleSplittingInfo& dInfo,
87  const DipoleSplittingKernel& split) const;
88 
92  virtual Energy ptMax(Energy dScale,
93  double, double,
94  const DipoleIndex& dIndex,
95  const DipoleSplittingKernel& split,
96  tPPtr emitter, tPPtr spectator) const;
97 
101  virtual Energy ptMax(Energy,
102  double, double,
103  const DipoleIndex&,
104  const DipoleSplittingKernel&) const {
105  // Only the DipoleSplittingInfo version should be used for massive
106  // dipoles, for now anyway.
107  assert(false);
108  return ZERO;
109  }
110 
114  virtual Energy QMax(Energy dScale,
115  double emX, double specX,
116  const DipoleSplittingInfo& dInfo,
117  const DipoleSplittingKernel& split) const;
118 
122  virtual Energy QMax(Energy,
123  double, double,
124  const DipoleIndex&,
125  const DipoleSplittingKernel&) const {
126  // Only the DipoleSplittingInfo version should be used for massive
127  // dipoles, for now anyway.
128  assert(false);
129  return ZERO;
130  }
131 
135  virtual Energy PtFromQ(Energy scale, const DipoleSplittingInfo&) const;
136 
140  virtual Energy QFromPt(Energy scale, const DipoleSplittingInfo&) const;
141 
146  virtual double ptToRandom(Energy pt, Energy dScale,
147  double emX, double specX,
148  const DipoleIndex& dIndex,
149  const DipoleSplittingKernel& split) const;
150 
156  virtual bool generateSplitting(double kappa, double xi, double phi,
157  DipoleSplittingInfo& dIndex,
158  const DipoleSplittingKernel& split);
159 
165  virtual void generateKinematics(const Lorentz5Momentum& pEmitter,
166  const Lorentz5Momentum& pSpectator,
167  const DipoleSplittingInfo& dInfo);
168 
169 public:
170 
174  template <class T>
175  inline T rootOfKallen (T a, T b, T c) const {
176  if ( a*a + b*b + c*c - 2.*(a*b + a*c + b*c) > ZERO )
177  return sqrt(a*a + b*b + c*c - 2.*(a*b + a*c + b*c) ) ;
178  else
179  return ZERO; }
180 
186  ThreeVector<double> rotateToZ (Lorentz5Momentum& pTarget, Lorentz5Momentum& p1){
187  ThreeVector<double> oldAxis = pTarget.vect().unit();
188  double ct = oldAxis.z(); double st = sqrt( 1.-sqr(ct) ); // cos,sin(theta)
189  double cp = oldAxis.x()/st; double sp = oldAxis.y()/st; // cos,sin(phi)
190  pTarget.setZ( pTarget.vect().mag() ); pTarget.setX( 0.*GeV ); pTarget.setY( 0.*GeV );
191  Lorentz5Momentum p1old = p1;
192  p1.setX( sp*p1old.x() - cp*p1old.y() );
193  p1.setY( ct*cp*p1old.x() + ct*sp*p1old.y() - st*p1old.z() );
194  p1.setZ( st*cp*p1old.x() + st*sp*p1old.y() + ct*p1old.z() );
195  return oldAxis;
196  }
197 
198 public:
199 
206  void persistentOutput(PersistentOStream & os) const;
207 
213  void persistentInput(PersistentIStream & is, int version);
215 
222  static void Init();
223 
224 protected:
225 
232  virtual IBPtr clone() const;
233 
238  virtual IBPtr fullclone() const;
240 
241 
242 // If needed, insert declarations of virtual function defined in the
243 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
244 
245 
246 private:
247 
253 
258  FFMassiveKinematics & operator=(const FFMassiveKinematics &) = delete;
259 
260 };
261 
262 }
263 
264 #include "ThePEG/Utilities/ClassTraits.h"
265 
266 namespace ThePEG {
267 
272 template <>
273 struct BaseClassTrait<Herwig::FFMassiveKinematics,1> {
275  typedef Herwig::DipoleSplittingKinematics NthBase;
276 };
277 
280 template <>
281 struct ClassTraits<Herwig::FFMassiveKinematics>
282  : public ClassTraitsBase<Herwig::FFMassiveKinematics> {
284  static string className() { return "Herwig::FFMassiveKinematics"; }
292  static string library() { return "HwDipoleShower.so"; }
293 };
294 
297 }
298 
299 #endif /* HERWIG_FFMassiveKinematics_H */
double sqrt(int x)
DipoleSplittingKinematics is the base class for dipole splittings as performed in the dipole shower...
ThePEG::Ptr< InterfacedBase >::pointer IBPtr
DipoleIndex is used to index splitting generators for a particular dipole.
constexpr auto sqr(const T &x) -> decltype(x *x)
virtual Energy ptMax(Energy, double, double, const DipoleIndex &, const DipoleSplittingKernel &) const
Return the maximum pt for the given dipole scale.
virtual Energy QMax(Energy, double, double, const DipoleIndex &, const DipoleSplittingKernel &) const
Return the maximum virtuality for the given dipole scale.
ThreeVector< double > unit() const
ThePEG::Ptr< Particle >::transient_pointer tPPtr
-*- C++ -*-
virtual pair< double, double > zBoundaries(Energy, const DipoleSplittingInfo &, const DipoleSplittingKernel &) const
Return the boundaries on the momentum fraction.
ThreeVector< double > rotateToZ(Lorentz5Momentum &pTarget, Lorentz5Momentum &p1)
Perform a rotation on both momenta such that the first one will point along the (positive) z axis...
DipoleSplittingInfo contains all parameters to generate a full dipole splitting.
static ClassDescription< FFMassiveKinematics > initFFMassiveKinematics
The static object used to initialize the description of this class.
constexpr ZeroUnit ZERO
T rootOfKallen(T a, T b, T c) const
Triangular / Kallen function.
DipoleSplittingKernel is the base class for all kernels used within the dipole shower.
FFMassiveKinematics implements massive splittings off a final-final dipole.