Line data Source code
1 : //--------------------------------------------------------------------------
2 : //
3 : // Environment:
4 : // This software is part of the EvtGen package developed jointly
5 : // for the BaBar and CLEO collaborations. If you use all or part
6 : // of it, please give an appropriate acknowledgement.
7 : //
8 : // Copyright Information: See EvtGen/COPYRIGHT
9 : // Copyright (C) 2003 Caltech
10 : //
11 : // Module: EvtGen/EvtBBScalar
12 : //
13 : // Description:Implementation of the decay B- -> lambda p_bar pi according to
14 : // hep-ph/0204185, hep-ph/0211240
15 : // This model is intended to be applicable to all decays of the type B-> baryon baryon scalar
16 : //
17 : // Modification history:
18 : //
19 : // Jan Strube March 24, 2006 Module created
20 : //
21 : //------------------------------------------------------------------------
22 : #include "EvtGenBase/EvtPatches.hh"
23 :
24 : #include "EvtGenModels/EvtBBScalar.hh"
25 : #include "EvtGenBase/EvtGammaMatrix.hh"
26 : #include "EvtGenBase/EvtDiracSpinor.hh"
27 : #include "EvtGenBase/EvtSpinType.hh"
28 : #include "EvtGenBase/EvtTensor4C.hh"
29 : #include <cmath>
30 :
31 : using namespace std;
32 :
33 : const float pi = 3.14159;
34 6 : const EvtComplex EvtBBScalar::I = EvtComplex(0, 1);
35 6 : const EvtComplex EvtBBScalar::V_ub = EvtComplex(3.67e-3*cos(60/180*pi), 3.67e-3*cos(60/180*pi));
36 6 : const EvtComplex EvtBBScalar::V_us_star = EvtComplex(0.22, 0);
37 6 : const EvtComplex EvtBBScalar::a1 = EvtComplex(1.05, 0);
38 6 : const EvtComplex EvtBBScalar::V_tb = EvtComplex(0.99915, 0);
39 6 : const EvtComplex EvtBBScalar::V_ts_star = EvtComplex(-0.04029-0.000813*cos(60/180*pi), -0.000813*cos(60/180*pi));
40 6 : const EvtComplex EvtBBScalar::a4 = EvtComplex(-387.3e-4, -121e-4);
41 6 : const EvtComplex EvtBBScalar::a6 = EvtComplex(-555.3e-4, -121e-4);
42 : const double EvtBBScalar::x[] = {420.96, -10485.50, 100639.97, -433916.61, 613780.15};
43 : const double EvtBBScalar::y[] = {292.62, -735.73};
44 : const double EvtBBScalar::m_s = 0.120;
45 : const double EvtBBScalar::m_u = 0.029 * 0.120;
46 : const double EvtBBScalar::m_b = 4.88;
47 :
48 :
49 0 : EvtBBScalar::EvtBBScalar()
50 0 : : EvtDecayAmp()
51 0 : , _massRatio(0)
52 0 : , _baryonMassSum(0)
53 0 : {
54 0 : FormFactor dummy;
55 0 : dummy.value = 0.36;
56 0 : dummy.sigma1 = 0.43;
57 0 : dummy.sigma2 = 0.0;
58 0 : dummy.mV = 5.42;
59 0 : _f1Map.insert(make_pair(string("K"), dummy));
60 0 : dummy.sigma1 = 0.70;
61 0 : dummy.sigma2 = 0.27;
62 0 : _f0Map.insert(make_pair(string("K"), dummy));
63 0 : dummy.value = 0.29;
64 0 : dummy.sigma1 = 0.48;
65 0 : dummy.sigma2 = 0.0;
66 0 : dummy.mV = 5.32;
67 0 : _f1Map.insert(make_pair(string("pi"), dummy));
68 0 : dummy.sigma1 = 0.76;
69 0 : dummy.sigma2 = 0.28;
70 0 : _f0Map.insert(make_pair(string("pi"), dummy));
71 0 : }
72 :
73 :
74 :
75 : std::string EvtBBScalar::getName(){
76 0 : return "B_TO_2BARYON_SCALAR";
77 : }
78 :
79 : EvtDecayBase* EvtBBScalar::clone(){
80 0 : return new EvtBBScalar;
81 0 : }
82 :
83 :
84 : void EvtBBScalar::setKnownBaryonTypes(const EvtId& baryon) {
85 0 : int baryonId = EvtPDL::getStdHep(baryon);
86 0 : if (EvtPDL::getStdHep(EvtPDL::getId("Lambda0")) == baryonId
87 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-Lambda0")) == baryonId ) {
88 0 : _baryonCombination.set(Lambda);
89 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("p+")) == baryonId
90 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-p-")) == baryonId ) {
91 0 : _baryonCombination.set(Proton);
92 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("n0")) == baryonId
93 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-n0")) == baryonId) {
94 0 : _baryonCombination.set(Neutron);
95 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("Sigma0")) == baryonId
96 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-Sigma0")) == baryonId ) {
97 0 : _baryonCombination.set(Sigma0);
98 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("Sigma-")) == baryonId
99 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-Sigma+")) == baryonId ) {
100 0 : _baryonCombination.set(Sigma_minus);
101 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("Xi0")) == baryonId
102 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-Xi0")) == baryonId) {
103 0 : _baryonCombination.set(Xi0);
104 0 : } else if (EvtPDL::getStdHep(EvtPDL::getId("Xi-")) == baryonId
105 0 : or EvtPDL::getStdHep(EvtPDL::getId("anti-Xi+")) == baryonId) {
106 0 : _baryonCombination.set(Xi_minus);
107 : } else {
108 0 : report(Severity::Error, "EvtGen")
109 0 : << "EvtBBScalar::init: Don't know what to do with this type as the first or second baryon\n";
110 0 : exit(2);
111 : }
112 0 : }
113 :
114 : double EvtBBScalar::baryonF1F2(double t) const {
115 : // check for known form factors for combination of baryons
116 0 : if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
117 0 : return -sqrt(1.5) * G_p(t);
118 0 : } else if (_baryonCombination.test(Sigma0) and _baryonCombination.test(Proton)) {
119 0 : return -sqrt(0.5) * (G_p(t) + 2* G_n(t));
120 0 : } else if (_baryonCombination.test(Sigma_minus) and _baryonCombination.test(Neutron)) {
121 0 : return -G_p(t) - 2* G_n(t);
122 0 : } else if (_baryonCombination.test(Xi0) and _baryonCombination.test(Sigma_minus)) {
123 0 : return G_p(t) - G_n(t);
124 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Sigma0)) {
125 0 : return sqrt(0.5) * (G_p(t) - G_n(t));
126 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Lambda)) {
127 0 : return sqrt(1.5) * (G_p(t) + G_n(t));
128 : } else {
129 0 : report(Severity::Error, "EvtGen")
130 0 : << "EvtBBScalar::baryonF1F2: Don't know what to do with this type as the first or second baryon\n";
131 0 : exit(2);
132 : }
133 0 : }
134 :
135 : double EvtBBScalar::formFactorFit(double t, const vector<double>& params) const {
136 : static const double gamma = 2.148;
137 : static const double Lambda_0 = 0.3;
138 : double result = 0;
139 0 : for (size_t i=0; i<params.size(); ++i) {
140 0 : result += params[i]/pow(t, static_cast<int>(i+1));
141 : }
142 0 : return result * pow(log(t/pow(Lambda_0, 2)), -gamma);
143 : }
144 :
145 :
146 : double EvtBBScalar::G_p(double t) const {
147 0 : const vector<double> v_x(x, x+5);
148 0 : return formFactorFit(t, v_x);
149 0 : }
150 :
151 : double EvtBBScalar::G_n(double t) const {
152 0 : const vector<double> v_y(y, y+2);
153 0 : return -formFactorFit(t, v_y);
154 0 : }
155 :
156 : double EvtBBScalar::baryon_gA(double t) const {
157 : // check for known form factors for combination of baryons
158 0 : if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
159 0 : return -1/sqrt(6.) * (D_A(t) + 3*F_A(t));
160 0 : } else if (_baryonCombination.test(Sigma0) and _baryonCombination.test(Proton)) {
161 0 : return 1/sqrt(2.) * (D_A(t) - F_A(t));
162 0 : } else if (_baryonCombination.test(Sigma_minus) and _baryonCombination.test(Neutron)) {
163 0 : return D_A(t) - F_A(t);
164 0 : } else if (_baryonCombination.test(Xi0) and _baryonCombination.test(Sigma_minus)) {
165 0 : return D_A(t) + F_A(t);
166 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Sigma0)) {
167 0 : return 1/sqrt(2.) * (D_A(t) + F_A(t));
168 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Lambda)) {
169 0 : return -1 / sqrt(6.) * (D_A(t) - 3*F_A(t));
170 : } else {
171 0 : report(Severity::Error, "EvtGen")
172 0 : << "EvtBBScalar::baryon_gA: Don't know what to do with this type as the first or second baryon\n";
173 0 : exit(2);
174 : }
175 0 : }
176 :
177 : double EvtBBScalar::baryon_gP(double t) const {
178 : // check for known form factors for combination of baryons
179 0 : if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
180 0 : return -1/sqrt(6.) * (D_P(t) + 3*F_P(t));
181 0 : } else if (_baryonCombination.test(Sigma0) and _baryonCombination.test(Proton)) {
182 0 : return 1/sqrt(2.) * (D_P(t) - F_P(t));
183 0 : } else if (_baryonCombination.test(Sigma_minus) and _baryonCombination.test(Neutron)) {
184 0 : return D_P(t) - F_P(t);
185 0 : } else if (_baryonCombination.test(Xi0) and _baryonCombination.test(Sigma_minus)) {
186 0 : return D_P(t) + F_P(t);
187 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Sigma0)) {
188 0 : return 1/sqrt(2.) * (D_P(t) + F_P(t));
189 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Lambda)) {
190 0 : return -1 / sqrt(6.) * (D_P(t) - 3*F_P(t));
191 : } else {
192 0 : report(Severity::Error, "EvtGen")
193 0 : << "EvtBBScalar::baryon_gP: Don't know what to do with this type as the first or second baryon\n";
194 0 : exit(2);
195 : }
196 0 : }
197 :
198 : double EvtBBScalar::baryon_fS(double t) const {
199 : // check for known form factors for combination of baryons
200 0 : if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
201 0 : return -1/sqrt(6.) * (D_S(t) + 3*F_S(t));
202 0 : } else if (_baryonCombination.test(Sigma0) and _baryonCombination.test(Proton)) {
203 0 : return 1/sqrt(2.) * (D_S(t) - F_S(t));
204 0 : } else if (_baryonCombination.test(Sigma_minus) and _baryonCombination.test(Neutron)) {
205 0 : return D_S(t) - F_S(t);
206 0 : } else if (_baryonCombination.test(Xi0) and _baryonCombination.test(Sigma_minus)) {
207 0 : return D_S(t) + F_S(t);
208 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Sigma0)) {
209 0 : return 1/sqrt(2.) * (D_S(t) + F_S(t));
210 0 : } else if (_baryonCombination.test(Xi_minus) and _baryonCombination.test(Lambda)) {
211 0 : return -1 / sqrt(6.) * (D_S(t) - 3*F_S(t));
212 : } else {
213 0 : report(Severity::Error, "EvtGen")
214 0 : << "EvtBBScalar::baryon_fS: Don't know what to do with this type as the first or second baryon\n";
215 0 : exit(2);
216 : }
217 0 : }
218 :
219 : double EvtBBScalar::D_A(double t) const {
220 0 : const double d_tilde[] = {x[0]-1.5*y[0], -478};
221 0 : const vector<double> v_d_tilde(d_tilde, d_tilde+2);
222 0 : return formFactorFit(t, v_d_tilde);
223 0 : }
224 :
225 : double EvtBBScalar::F_A(double t) const {
226 0 : const double f_tilde[] = {2./3*x[0]+0.5*y[0], -478};
227 0 : const vector<double> v_f_tilde(f_tilde, f_tilde+2);
228 0 : return formFactorFit(t, v_f_tilde);
229 0 : }
230 :
231 : double EvtBBScalar::D_P(double t) const {
232 0 : const double d_bar[] = {1.5*y[0]* _massRatio, /*-952*/0};
233 0 : const vector<double> v_d_bar(d_bar, d_bar+2);
234 0 : return formFactorFit(t, v_d_bar);
235 0 : }
236 :
237 : double EvtBBScalar::F_P(double t) const {
238 0 : const double f_bar[] = {(x[0]-0.5*y[0]) * _massRatio, /*-952*/0};
239 0 : const vector<double> v_f_bar(f_bar, f_bar+2);
240 0 : return formFactorFit(t, v_f_bar);
241 0 : }
242 :
243 : double EvtBBScalar::D_S(double t) const {
244 0 : return -1.5 * _massRatio * G_n(t);
245 : }
246 :
247 : double EvtBBScalar::F_S(double t) const {
248 0 : return (G_p(t) + 0.5*G_n(t)) * _massRatio;
249 : }
250 :
251 : double EvtBBScalar::baryon_hA(double t) const {
252 0 : return (1/_massRatio*baryon_gP(t)-baryon_gA(t))*pow(_baryonMassSum, 2)/t;
253 : }
254 :
255 :
256 : void EvtBBScalar::init() {
257 : // no arguments, daughter lambda p_bar pi
258 : // charge conservation is checked by base class
259 0 : checkNArg(0);
260 0 : checkNDaug(3);
261 0 : checkSpinParent(EvtSpinType::SCALAR);
262 0 : checkSpinDaughter(0, EvtSpinType::DIRAC);
263 0 : checkSpinDaughter(1, EvtSpinType::DIRAC);
264 0 : checkSpinDaughter(2, EvtSpinType::SCALAR);
265 0 : EvtId baryon1 = getDaug(0);
266 0 : EvtId baryon2 = getDaug(1);
267 0 : EvtId scalar = getDaug(2);
268 0 : int scalarId = EvtPDL::getStdHep(scalar);
269 :
270 : // Different form factors for the B-pi or B-K transition.
271 0 : if ( scalarId == EvtPDL::getStdHep(EvtPDL::getId("pi+"))
272 0 : or scalarId == EvtPDL::getStdHep(EvtPDL::getId("pi-"))
273 0 : or scalarId == EvtPDL::getStdHep(EvtPDL::getId("pi0"))) {
274 0 : _scalarType = "pi";
275 0 : } else if (scalarId == EvtPDL::getStdHep(EvtPDL::getId("K+"))
276 0 : or scalarId == EvtPDL::getStdHep(EvtPDL::getId("K-"))
277 0 : or scalarId == EvtPDL::getStdHep(EvtPDL::getId("K0"))
278 0 : or scalarId == EvtPDL::getStdHep(EvtPDL::getId("anti-K0"))) {
279 0 : _scalarType = "K";
280 : } else {
281 0 : report(Severity::Error, "EvtGen")
282 0 : << "EvtBBScalar::init: Can only deal with Kaons or pions as the third particle\n"
283 0 : << "\tFound: " << scalarId << endl;
284 0 : exit(2);
285 : }
286 : // check for known particles
287 0 : setKnownBaryonTypes(baryon1);
288 0 : setKnownBaryonTypes(baryon2);
289 0 : double mass1 = EvtPDL::getMass(baryon1);
290 0 : double mass2 = EvtPDL::getMass(baryon2);
291 : // This whole model deals only with baryons that differ in s-u
292 0 : if (mass1 > mass2)
293 0 : _massRatio = (mass1-mass2) / (m_s-m_u);
294 : else
295 0 : _massRatio = (mass2-mass1) / (m_s-m_u);
296 0 : _baryonMassSum = mass1 + mass2;
297 0 : }
298 :
299 :
300 : // initialize phasespace and calculate the amplitude
301 : void EvtBBScalar::decay(EvtParticle* p) {
302 0 : p->initializePhaseSpace(getNDaug(), getDaugs());
303 0 : EvtVector4R B_Momentum = p->getP4Lab();
304 0 : EvtDiracParticle* theLambda = dynamic_cast<EvtDiracParticle*>(p->getDaug(0));
305 0 : EvtDiracParticle* theAntiP = dynamic_cast<EvtDiracParticle*>(p->getDaug(1));
306 0 : EvtScalarParticle* theScalar = dynamic_cast<EvtScalarParticle*>(p->getDaug(2));
307 0 : EvtVector4R scalarMomentum = theScalar->getP4Lab();
308 :
309 : // The amplitude consists of three matrix elements. These will be calculated one by one here.
310 :
311 : // loop over all possible spin states
312 0 : for (int i=0; i<2; ++i) {
313 0 : EvtDiracSpinor lambdaPol = theLambda->spParent(i);
314 0 : for (int j=0; j<2; ++j) {
315 0 : EvtDiracSpinor antiP_Pol = theAntiP->spParent(j);
316 0 : EvtVector4C theAmplitudePartA = amp_A(B_Momentum, scalarMomentum);
317 0 : EvtComplex amplitude;
318 0 : for (int index=0; index<4; ++index) {
319 0 : amplitude += theAmplitudePartA.get(index)
320 0 : * ( const_B*amp_B(theLambda, lambdaPol, theAntiP, antiP_Pol, index)
321 0 : + const_C*amp_C(theLambda, lambdaPol, theAntiP, antiP_Pol, index) );
322 : }
323 0 : vertex(i, j, amplitude);
324 0 : }
325 0 : }
326 0 : }
327 :
328 : void EvtBBScalar::initProbMax()
329 : {
330 : // setProbMax(1);
331 0 : setProbMax(0.2); // found by trial and error
332 0 : }
333 :
334 : // Form factor f1 for B-pi transition
335 : double EvtBBScalar::B_pi_f1(double t) const
336 : {
337 0 : FormFactor f = _f1Map[_scalarType];
338 0 : double mv2 = f.mV*f.mV;
339 0 : return f.value / ((1-t/mv2) * (1-f.sigma1*t/mv2+f.sigma2*t*t/mv2/mv2));
340 : }
341 :
342 : // Form factor f0 for B-pi transition
343 : double EvtBBScalar::B_pi_f0(double t) const
344 : {
345 0 : FormFactor f = _f0Map[_scalarType];
346 0 : double mv2 = f.mV*f.mV;
347 0 : return f.value / (1 - f.sigma1*t/mv2 + f.sigma2*t*t/mv2/mv2);
348 : }
349 :
350 : // constants of the B and C parts of the amplitude
351 6 : const EvtComplex EvtBBScalar::const_B = V_ub*V_us_star*a1 - V_tb*V_ts_star*a4;
352 6 : const EvtComplex EvtBBScalar::const_C = 2*a6*V_tb*V_ts_star;
353 :
354 : // part A of the amplitude, see hep-ph/0204185
355 : const EvtVector4C
356 : EvtBBScalar::amp_A(const EvtVector4R& p4B, const EvtVector4R& p4Scalar)
357 : {
358 0 : double mB2 = p4B.mass2();
359 0 : double mScalar2 = p4Scalar.mass2();
360 0 : double t = (p4B-p4Scalar).mass2();
361 0 : return ((p4B+p4Scalar) - (mB2-mScalar2)/t * (p4B-p4Scalar)) * B_pi_f1(t)
362 0 : + (mB2-mScalar2)/t * (p4B-p4Scalar) * B_pi_f0(t);
363 0 : }
364 :
365 : // part B of the amplitude, Vector and Axial Vector parts
366 : const EvtComplex
367 : EvtBBScalar::amp_B(const EvtDiracParticle* baryon1, const EvtDiracSpinor& b1Pol
368 : , const EvtDiracParticle* baryon2, const EvtDiracSpinor& b2Pol
369 : , int index)
370 : {
371 0 : return amp_B_vectorPart(baryon1, b1Pol, baryon2, b2Pol, index)
372 0 : - amp_B_axialPart(baryon1, b1Pol, baryon2, b2Pol, index);
373 : }
374 :
375 :
376 : const EvtComplex
377 : EvtBBScalar::amp_B_vectorPart(const EvtDiracParticle* baryon1, const EvtDiracSpinor& b1Pol
378 : , const EvtDiracParticle* baryon2, const EvtDiracSpinor& b2Pol
379 : , int index)
380 : {
381 0 : double t = (baryon1->getP4Lab() + baryon2->getP4Lab()).mass2();
382 0 : EvtGammaMatrix gamma;
383 0 : for (int i=0; i<4; ++i) {
384 0 : gamma += EvtTensor4C::g().get(index, i) * EvtGammaMatrix::g(i);
385 : }
386 : // The F2 contribution that is written out in the paper is neglected here.
387 : // see hep-ph/0204185
388 0 : EvtDiracSpinor A = EvtComplex(baryonF1F2(t))*b2Pol ;
389 0 : EvtDiracSpinor Adjb1Pol = b1Pol.adjoint() ;
390 0 : EvtDiracSpinor gammaA = gamma * A ;
391 0 : return Adjb1Pol * gammaA ;
392 : // return b1Pol.adjoint()*(gamma*(EvtComplex(baryonF1F2(t))*b2Pol));
393 0 : }
394 :
395 : const EvtComplex
396 : EvtBBScalar::amp_B_axialPart(const EvtDiracParticle* baryon1, const EvtDiracSpinor& b1Pol
397 : , const EvtDiracParticle* baryon2, const EvtDiracSpinor& b2Pol
398 : , int index)
399 : {
400 0 : EvtGammaMatrix gamma;
401 0 : for (int i=0; i<4; ++i) {
402 0 : gamma += EvtTensor4C::g().get(index, i) * EvtGammaMatrix::g(i);
403 : }
404 0 : double t = (baryon1->getP4Lab() + baryon2->getP4Lab()).mass2();
405 0 : double mSum = baryon1->mass() + baryon2->mass();
406 0 : EvtVector4C momentum_upper = (baryon1->getP4Lab()+baryon2->getP4Lab());
407 0 : EvtVector4C momentum;
408 0 : for (int mu=0; mu<0; ++mu) {
409 0 : EvtComplex dummy;
410 0 : for (int i=0; i<4; ++i) {
411 0 : dummy += EvtTensor4C::g().get(index, i)*momentum_upper.get(i);
412 : }
413 0 : momentum.set(mu, dummy);
414 0 : }
415 0 : return b1Pol.adjoint() * (((baryon_gA(t) * gamma +
416 0 : EvtGammaMatrix::id()*baryon_hA(t)/mSum*momentum.get(index))
417 0 : * EvtGammaMatrix::g5()) * b2Pol);
418 0 : }
419 :
420 :
421 : // part C of the amplitude, Scalar and Pseudoscalar parts
422 : const EvtComplex
423 : EvtBBScalar::amp_C(const EvtDiracParticle* baryon1, const EvtDiracSpinor& b1Pol
424 : , const EvtDiracParticle* baryon2, const EvtDiracSpinor& b2Pol
425 : , int index)
426 : {
427 0 : EvtVector4C baryonSumP4_upper = baryon1->getP4Lab() + baryon2->getP4Lab();
428 0 : EvtVector4C baryonSumP4;
429 0 : for (int mu=0; mu<4; ++mu) {
430 0 : EvtComplex dummy;
431 0 : for (int i=0; i<4; ++i) {
432 0 : dummy += EvtTensor4C::g().get(mu, i) * baryonSumP4_upper.get(i);
433 : }
434 0 : baryonSumP4.set(mu, dummy);
435 0 : }
436 0 : double t = (baryon1->getP4Lab() + baryon2->getP4Lab()).mass2();
437 0 : return baryonSumP4.get(index)/(m_b-m_u)*(amp_C_scalarPart(b1Pol, b2Pol, t) + amp_C_pseudoscalarPart(b1Pol, b2Pol, t));
438 0 : }
439 :
440 :
441 : const EvtComplex
442 : EvtBBScalar::amp_C_scalarPart(const EvtDiracSpinor& b1Pol, const EvtDiracSpinor& b2Pol, double t)
443 : {
444 0 : return baryon_fS(t) * b1Pol.adjoint()*b2Pol;
445 0 : }
446 :
447 : const EvtComplex
448 : EvtBBScalar::amp_C_pseudoscalarPart(const EvtDiracSpinor& b1Pol, const EvtDiracSpinor& b2Pol, double t)
449 : {
450 0 : return baryon_gP(t) * b1Pol.adjoint()*(EvtGammaMatrix::g5()*b2Pol);
451 0 : }
452 :
|
