herwig
is hosted by
Hepforge
,
IPPP Durham
Herwig
7.2.1
Shower
Dipole
Kinematics
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
29
class
FFMassiveKinematics
:
public
DipoleSplittingKinematics
{
30
31
public
:
32
38
FFMassiveKinematics
();
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
252
static
ClassDescription<FFMassiveKinematics>
initFFMassiveKinematics
;
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 */
ThePEG::PersistentIStream
sqrt
double sqrt(int x)
Herwig::DipoleSplittingKinematics
DipoleSplittingKinematics is the base class for dipole splittings as performed in the dipole shower...
Definition:
DipoleSplittingKinematics.h:41
ThePEG::ClassDescription
ThePEG::PersistentOStream
ThePEG::ThreeVector
ThePEG::IBPtr
ThePEG::Ptr< InterfacedBase >::pointer IBPtr
Herwig::DipoleIndex
DipoleIndex is used to index splitting generators for a particular dipole.
Definition:
DipoleSplittingInfo.h:35
sqr
constexpr auto sqr(const T &x) -> decltype(x *x)
Herwig::FFMassiveKinematics::ptMax
virtual Energy ptMax(Energy, double, double, const DipoleIndex &, const DipoleSplittingKernel &) const
Return the maximum pt for the given dipole scale.
Definition:
FFMassiveKinematics.h:101
ThePEG
Herwig::FFMassiveKinematics::QMax
virtual Energy QMax(Energy, double, double, const DipoleIndex &, const DipoleSplittingKernel &) const
Return the maximum virtuality for the given dipole scale.
Definition:
FFMassiveKinematics.h:122
ThePEG::ThreeVector::unit
ThreeVector< double > unit() const
ThePEG::tPPtr
ThePEG::Ptr< Particle >::transient_pointer tPPtr
Herwig
-*- C++ -*-
Definition:
BasicConsistency.h:17
ThePEG::ClassTraits
Herwig::FFMassiveKinematics::zBoundaries
virtual pair< double, double > zBoundaries(Energy, const DipoleSplittingInfo &, const DipoleSplittingKernel &) const
Return the boundaries on the momentum fraction.
Definition:
FFMassiveKinematics.h:64
Herwig::FFMassiveKinematics::rotateToZ
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...
Definition:
FFMassiveKinematics.h:186
Herwig::DipoleSplittingInfo
DipoleSplittingInfo contains all parameters to generate a full dipole splitting.
Definition:
DipoleSplittingInfo.h:209
Herwig::FFMassiveKinematics::initFFMassiveKinematics
static ClassDescription< FFMassiveKinematics > initFFMassiveKinematics
The static object used to initialize the description of this class.
Definition:
FFMassiveKinematics.h:252
ThePEG::BaseClassTrait
ZERO
constexpr ZeroUnit ZERO
Herwig::FFMassiveKinematics::rootOfKallen
T rootOfKallen(T a, T b, T c) const
Triangular / Kallen function.
Definition:
FFMassiveKinematics.h:175
Herwig::DipoleSplittingKernel
DipoleSplittingKernel is the base class for all kernels used within the dipole shower.
Definition:
DipoleSplittingKernel.h:41
ThePEG::ClassTraitsBase
Herwig::FFMassiveKinematics
FFMassiveKinematics implements massive splittings off a final-final dipole.
Definition:
FFMassiveKinematics.h:29
Generated on Sat Apr 11 2020 14:50:29 for Herwig by
1.8.13