evtgen is hosted by Hepforge, IPPP Durham
EvtGen  2.0.0
Monte Carlo generator of particle decays, in particular the weak decays of heavy flavour particles such as B mesons.
EvtBaryonPCRFF.cpp
Go to the documentation of this file.
1 
2 /***********************************************************************
3 * Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
4 * *
5 * This file is part of EvtGen. *
6 * *
7 * EvtGen is free software: you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation, either version 3 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * EvtGen is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
19 ***********************************************************************/
20 
21 #include "EvtGenModels/EvtBaryonPCRFF.hh"
22 
23 #include "EvtGenBase/EvtConst.hh"
24 #include "EvtGenBase/EvtId.hh"
25 #include "EvtGenBase/EvtIdSet.hh"
26 #include "EvtGenBase/EvtPDL.hh"
27 #include "EvtGenBase/EvtPatches.hh"
28 #include "EvtGenBase/EvtReport.hh"
29 
30 #include <math.h>
31 #include <stdlib.h>
32 #include <string>
33 using std::endl;
34 
35 void EvtBaryonPCRFF::getdiracff( EvtId parent, EvtId daught, double q2,
36  double /* mass */, double* f1, double* f2,
37  double* f3, double* g1, double* g2, double* g3 )
38 {
39  // Baryons (partial list 5/28/04)
40  static EvtId LAMCP = EvtPDL::getId( "Lambda_c+" );
41  static EvtId LAMCM = EvtPDL::getId( "anti-Lambda_c-" );
42  static EvtId LAMC1P = EvtPDL::getId( "Lambda_c(2593)+" );
43  static EvtId LAMC1M = EvtPDL::getId( "anti-Lambda_c(2593)-" );
44  static EvtId LAMB = EvtPDL::getId( "Lambda_b0" );
45  static EvtId LAMBB = EvtPDL::getId( "anti-Lambda_b0" );
46 
47  double F1, F2, F3, G1, G2, G3;
48 
49  if ( parent == LAMB || parent == LAMBB ) {
50  // Implement constituent quark model form factors predicted
51  // by M. Pervin, W. Roberst, and S. Capstick, Phys. Rev. C72, 035201 (2005)
52 
53  if ( daught == LAMCP || daught == LAMCM ) {
54  // Parameters needed in the calculation;
55  double mQ = 5.28;
56  double mq = 1.89;
57  double md = 0.40;
58  double MLamB = EvtPDL::getMass( parent );
59  double MLamC = EvtPDL::getMass( daught );
60 
61  double aL = 0.59;
62  double aLp = 0.55;
63 
64  double aL2 = aL * aL;
65  double aLp2 = aLp * aLp;
66  double aLLp2 = 0.5 * ( aL2 + aLp2 );
67 
68  // relativistic correction factor
69  double k2 = 1.0;
70  double rho2 = 3. * md * md / ( 2. * k2 * aLLp2 );
71 
72  // w = scalar product of the 4 velocities of the Lb and Lc.
73  double w = 0.5 * ( MLamB * MLamB + MLamC * MLamC - q2 ) / MLamB /
74  MLamC;
75 
76  double I = pow( aL * aLp / aLLp2, 1.5 ) *
77  exp( -rho2 * ( w * w - 1. ) );
78 
79  // Calculate the form factors
80  F1 = I * ( 1.0 + ( md / aLLp2 ) * ( ( aLp2 / mq ) + ( aL2 / mQ ) ) );
81  F2 = -I * ( ( md / mq ) * ( aLp2 / aLLp2 ) -
82  aL2 * aLp2 / ( 4. * aLLp2 * mq * mQ ) );
83  F3 = -I * md * aL2 / ( mQ * aLLp2 );
84 
85  G1 = I * ( 1.0 - ( aL2 * aLp2 ) / ( 12. * aLLp2 * mq * mQ ) );
86  G2 = -I * ( md * aLp2 / ( mq * aLLp2 ) +
87  ( aL2 * aLp2 ) / ( 12. * aLLp2 * mq * mQ ) *
88  ( 1. + 12. * md * md / aLLp2 ) );
89  G3 = I * ( md * aL2 / ( mQ * aLLp2 ) +
90  md * md * aL2 * aLp2 / ( mq * mQ * aLLp2 * aLLp2 ) );
91 
92  // Set form factors to be passed to the amplitude calc.
93  *f1 = F1;
94  *f2 = F2;
95  *f3 = F3;
96  *g1 = G1;
97  *g2 = G2;
98  *g3 = G3;
99 
100  }
101 
102  else if ( daught == LAMC1P || daught == LAMC1M ) {
103  double mQ = 5.28;
104  double mq = 1.89;
105  double md = 0.40;
106  double MLamB = EvtPDL::getMass( parent );
107  double MLamC = EvtPDL::getMass( daught );
108 
109  double aL = 0.59;
110  double aLp = 0.47;
111 
112  double aL2 = aL * aL;
113  double aLp2 = aLp * aLp;
114  double aLLp2 = 0.5 * ( aL2 + aLp2 );
115 
116  // relativistic correction factor
117  double k2 = 1.0;
118  double rho2 = 3. * md * md / ( 2. * k2 * aLLp2 );
119 
120  // w = scalar product of the 4 velocities of the Lb and Lc.
121  double w = 0.5 * ( MLamB * MLamB + MLamC * MLamC - q2 ) / MLamB /
122  MLamC;
123 
124  double I = pow( aL * aLp / aLLp2, 2.5 ) *
125  exp( -rho2 * ( w * w - 1. ) );
126 
127  // Calculate the form factors
128  F1 = I * aL / 6.0 * ( 3.0 / mq - 1.0 / mQ );
129  F2 = -I * ( 2.0 * md / aL - aL / ( 2.0 * mq ) +
130  2. * md * md * aL / ( mQ * aLLp2 ) -
131  ( md * aL / ( 6. * mq * mQ * aLLp2 ) ) *
132  ( 3. * aL2 - 2. * aLp2 ) );
133  F3 = I * 2. * md * md * aL / ( mQ * aLLp2 );
134 
135  G1 = I * ( 2.0 * md / aL - aL / ( 6. * mQ ) +
136  ( md * aL / ( 6. * mq * mQ * aLLp2 ) ) *
137  ( 3. * aL2 - 2. * aLp2 ) );
138  G2 = I * ( -2. * md / aL + aL / ( 2. * mq ) + aL / ( 3. * mQ ) );
139  G3 = I * aL / ( 3. * mQ ) *
140  ( 1.0 - ( md / ( 2. * mq * aLLp2 ) ) * ( 3. * aL2 - 2. * aLp2 ) );
141 
142  // Set form factors to be passed to the amplitude calc.
143  *f1 = F1;
144  *f2 = F2;
145  *f3 = F3;
146  *g1 = G1;
147  *g2 = G2;
148  *g3 = G3;
149  }
150  }
151 
152  else {
153  *f1 = 1.0;
154  *f2 = 1.0;
155  *f3 = 0.0;
156  *g1 = 1.0;
157  *g2 = 1.0;
158  *g3 = 0.0;
159  }
160 
161  return;
162 }
163 
164 void EvtBaryonPCRFF::getraritaff( EvtId parent, EvtId daught, double q2,
165  double /* mass */, double* f1, double* f2,
166  double* f3, double* f4, double* g1,
167  double* g2, double* g3, double* g4 )
168 {
169  // Baryons (partial list 5/28/04)
170  static EvtId LAMB = EvtPDL::getId( "Lambda_b0" );
171  static EvtId LAMBB = EvtPDL::getId( "anti-Lambda_b0" );
172  static EvtId LAMC2P = EvtPDL::getId( "Lambda_c(2625)+" );
173  static EvtId LAMC2M = EvtPDL::getId( "anti-Lambda_c(2625)-" );
174 
175  double F1, F2, F3, F4, G1, G2, G3, G4;
176 
177  if ( parent == LAMB || parent == LAMBB ) {
178  // Implement constituent quark model form factors predicted
179  // by M. Pervin, W. Roberst, and S. Capstick, Phys. Rev. C72, 035201 (2005)
180 
181  if ( daught == LAMC2P || daught == LAMC2M ) {
182  double mQ = 5.28;
183  double mq = 1.89;
184  double md = 0.40;
185  double MLamB = EvtPDL::getMass( parent );
186  double MLamC = EvtPDL::getMass( daught );
187 
188  double aL = 0.59;
189  double aLp = 0.47;
190 
191  double aL2 = aL * aL;
192  double aLp2 = aLp * aLp;
193  double aLLp2 = 0.5 * ( aL2 + aLp2 );
194 
195  // relativistic correction factor
196  double k2 = 1.0;
197  double rho2 = 3. * md * md / ( 2. * k2 * aLLp2 );
198 
199  // w = scalar product of the 4 velocities of the Lb and Lc.
200  double w = 0.5 * ( MLamB * MLamB + MLamC * MLamC - q2 ) / MLamB /
201  MLamC;
202 
203  double I = -( 1. / sqrt( 3. ) ) * pow( aL * aLp / aLLp2, 2.5 ) *
204  exp( -rho2 * ( w * w - 1. ) );
205 
206  // Calculate the form factors
207  F1 = I * 3.0 * md / aL *
208  ( 1.0 + ( md / aLLp2 ) * ( ( aLp2 / mq ) + ( aL2 / mQ ) ) );
209  F2 = -I * ( ( 3. * md * md / mq ) * ( aLp2 / ( aLLp2 * aL2 ) ) -
210  5. * aL * aLp2 * md / ( 4. * aLLp2 * mq * mQ ) );
211  F3 = -I * ( 3. * md * md * aL / ( mQ * aLLp2 ) + aL / ( 2. * mQ ) );
212  F4 = I * aL / mQ;
213 
214  G1 = I * ( 3.0 * md / aL -
215  ( aL / ( 2. * mQ ) ) *
216  ( 1. + 3. * md * aLp2 / ( 2. * aLLp2 * mq ) ) );
217  G2 = -I * ( ( 3. * md * md / mq ) * ( aLp2 / ( aLLp2 * aL ) ) +
218  aL * aLp2 * md / ( 4. * aLLp2 * aLLp2 * mq * mQ ) *
219  ( aLLp2 + 12. * md * md ) );
220  G3 = I * aL / ( mQ * aLLp2 ) *
221  ( aLLp2 / 2. + 3. * md * md +
222  aLp2 * md / ( mq * aLLp2 ) * ( aLLp2 + 6. * md * md ) );
223  G4 = -I * ( aL / mQ + md / ( mq * mQ ) * aLp2 * aL / aLLp2 );
224 
225  // Set form factors to be passed to the amplitude calc.
226  *f1 = F1;
227  *f2 = F2;
228  *f3 = F3;
229  *f4 = F4;
230  *g1 = G1;
231  *g2 = G2;
232  *g3 = G3;
233  *g4 = G4;
234  }
235  }
236 
237  else {
238  *f1 = 1.0;
239  *f2 = 1.0;
240  *f3 = 0.0;
241  *f4 = 0.0;
242  *g1 = 1.0;
243  *g2 = 1.0;
244  *g3 = 0.0;
245  *g4 = 0.0;
246  }
247 
248  return;
249 }
250 
251 void EvtBaryonPCRFF::getscalarff( EvtId, EvtId, double, double, double*, double* )
252 {
253  EvtGenReport( EVTGEN_ERROR, "EvtGen" )
254  << "Not implemented :getscalarff in EvtBaryonPCRFF.\n";
255  ::abort();
256 }
257 
258 void EvtBaryonPCRFF::getvectorff( EvtId, EvtId, double, double, double*,
259  double*, double*, double* )
260 {
261  EvtGenReport( EVTGEN_ERROR, "EvtGen" )
262  << "Not implemented :getvectorff in EvtBaryonPCRFF.\n";
263  ::abort();
264 }
265 
266 void EvtBaryonPCRFF::gettensorff( EvtId, EvtId, double, double, double*,
267  double*, double*, double* )
268 {
269  EvtGenReport( EVTGEN_ERROR, "EvtGen" )
270  << "Not implemented :gettensorff in EvtBaryonPCRFF.\n";
271  ::abort();
272 }
273 
274 void EvtBaryonPCRFF::getbaryonff( EvtId, EvtId, double, double, double*,
275  double*, double*, double* )
276 {
277  EvtGenReport( EVTGEN_ERROR, "EvtGen" )
278  << "Not implemented :getbaryonff in EvtBaryonPCRFF.\n";
279  ::abort();
280 }
EvtBaryonPCRFF::gettensorff
void gettensorff(EvtId parent, EvtId daught, double t, double mass, double *hf, double *kf, double *bpf, double *bmf) override
Definition: EvtBaryonPCRFF.cpp:266
EvtBaryonPCRFF::getraritaff
void getraritaff(EvtId parent, EvtId daught, double q2, double mass, double *f1, double *f2, double *f3, double *f4, double *g1, double *g2, double *g3, double *g4) override
Definition: EvtBaryonPCRFF.cpp:164
EvtGenReport
std::ostream & EvtGenReport(EvtGenSeverity severity, const char *facility=0)
Definition: EvtReport.cpp:33
EvtBaryonPCRFF::getdiracff
void getdiracff(EvtId parent, EvtId daught, double q2, double mass, double *f1, double *f2, double *f3, double *g1, double *g2, double *g3) override
Definition: EvtBaryonPCRFF.cpp:35
EvtId
Definition: EvtId.hh:27
EvtBaryonPCRFF::getscalarff
void getscalarff(EvtId parent, EvtId daught, double t, double mass, double *fpf, double *f0f) override
Definition: EvtBaryonPCRFF.cpp:251
EvtBaryonPCRFF::getbaryonff
void getbaryonff(EvtId, EvtId, double, double, double *, double *, double *, double *) override
Definition: EvtBaryonPCRFF.cpp:274
EvtPDL::getId
static EvtId getId(const std::string &name)
Definition: EvtPDL.cpp:287
exp
EvtComplex exp(const EvtComplex &c)
Definition: EvtComplex.hh:240
EvtBaryonPCRFF::getvectorff
void getvectorff(EvtId parent, EvtId daught, double t, double mass, double *a1f, double *a2f, double *vf, double *a0f) override
Definition: EvtBaryonPCRFF.cpp:258
I
const EvtComplex I
Definition: EvtBsMuMuKK.cpp:38
EvtPDL::getMass
static double getMass(EvtId i)
Definition: EvtPDL.cpp:319
Generated by   doxygen 1.8.15