EvtGen 2.2.0
Monte Carlo generator of particle decays, in particular the weak decays of heavy flavour particles such as B mesons.
Loading...
Searching...
No Matches
EvtD0mixDalitz.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/EvtD0mixDalitz.hh"
22
23#include "EvtGenBase/EvtDalitzPlot.hh"
24#include "EvtGenBase/EvtDalitzReso.hh"
25#include "EvtGenBase/EvtPDL.hh"
26#include "EvtGenBase/EvtParticle.hh"
27#include "EvtGenBase/EvtRandom.hh"
28#include "EvtGenBase/EvtResonance.hh"
29
30#include <cmath> // for std::fabs
31
32// Initialize the static variables.
33const EvtSpinType::spintype& EvtD0mixDalitz::m_SCALAR = EvtSpinType::SCALAR;
34const EvtSpinType::spintype& EvtD0mixDalitz::m_VECTOR = EvtSpinType::VECTOR;
35const EvtSpinType::spintype& EvtD0mixDalitz::m_TENSOR = EvtSpinType::TENSOR;
36
37const EvtDalitzReso::CouplingType& EvtD0mixDalitz::m_EtaPic = EvtDalitzReso::EtaPic;
38const EvtDalitzReso::CouplingType& EvtD0mixDalitz::m_PicPicKK =
39 EvtDalitzReso::PicPicKK;
40
41const EvtDalitzReso::NumType& EvtD0mixDalitz::m_RBW =
42 EvtDalitzReso::RBW_CLEO_ZEMACH;
43const EvtDalitzReso::NumType& EvtD0mixDalitz::m_GS = EvtDalitzReso::GS_CLEO_ZEMACH;
44const EvtDalitzReso::NumType& EvtD0mixDalitz::m_KMAT = EvtDalitzReso::K_MATRIX;
45
46const EvtCyclic3::Pair& EvtD0mixDalitz::m_AB = EvtCyclic3::AB;
47const EvtCyclic3::Pair& EvtD0mixDalitz::m_AC = EvtCyclic3::AC;
48const EvtCyclic3::Pair& EvtD0mixDalitz::m_BC = EvtCyclic3::BC;
49
50void EvtD0mixDalitz::init()
51{
52 // check that there are 0 arguments
53 checkNDaug( 3 );
54
55 if ( getNArg() ) {
56 if ( getNArg() == 2 ) {
57 m_x = getArg( 0 );
58 m_y = getArg( 1 );
59 } else if ( getNArg() == 4 ) {
60 m_x = getArg( 0 );
61 m_y = getArg( 1 );
62 m_qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
63 } else if ( getNArg() == 5 ) {
64 m_x = getArg( 0 );
65 m_y = getArg( 1 );
66 m_qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
67 m_isRBWmodel = !getArg(
68 4 ); // RBW by default. If arg4 is set, do K-matrix.
69 } else {
70 EvtGenReport( EVTGEN_ERROR, "EvtD0mixDalitz" )
71 << "Number of arguments for this model must be 0, 2, 4 or 5:"
72 << std::endl
73 << "[ x y ][ qp.re qp.im ][ doK-matrix ]" << std::endl
74 << "Check your dec file." << std::endl;
75 exit( 1 );
76 }
77 }
78
79 checkSpinParent( m_SCALAR );
80 checkSpinDaughter( 0, m_SCALAR );
81 checkSpinDaughter( 1, m_SCALAR );
82 checkSpinDaughter( 2, m_SCALAR );
83
84 readPDGValues();
85
86 // Get the EvtId of the D0 and its (3) daughters.
87 EvtId parId = getParentId();
88
89 EvtId dau[3];
90 for ( int index = 0; index < 3; index++ )
91 dau[index] = getDaug( index );
92
93 if ( parId == m_D0 ) // Look for K0bar h+ h-. The order must be K[0SL] h+ h-
94 for ( int index = 0; index < 3; index++ )
95 if ( ( dau[index] == m_K0B ) || ( dau[index] == m_KS ) ||
96 ( dau[index] == m_KL ) )
97 m_d1 = index;
98 else if ( ( dau[index] == m_PIP ) || ( dau[index] == m_KP ) )
99 m_d2 = index;
100 else if ( ( dau[index] == m_PIM ) || ( dau[index] == m_KM ) )
101 m_d3 = index;
102 else
103 reportInvalidAndExit();
104 else if ( parId == m_D0B ) // Look for K0 h+ h-. The order must be K[0SL] h- h+
105 for ( int index = 0; index < 3; index++ )
106 if ( ( dau[index] == m_K0 ) || ( dau[index] == m_KS ) ||
107 ( dau[index] == m_KL ) )
108 m_d1 = index;
109 else if ( ( dau[index] == m_PIM ) || ( dau[index] == m_KM ) )
110 m_d2 = index;
111 else if ( ( dau[index] == m_PIP ) || ( dau[index] == m_KP ) )
112 m_d3 = index;
113 else
114 reportInvalidAndExit();
115 else
116 reportInvalidAndExit();
117
118 // If the D meson is a D0bar, the expressions should use p/q instead of q/p.
119 if ( parId == m_D0B )
120 m_qp = 1.0 / m_qp;
121
122 // At this point, if parId is D0bar, the amplitude is the D0bar amplitude, the conjugated amplitude
123 // is the amplitude of the D0 decay, and m_qp means p/q, so it is like changing the meaning of
124 // A <-> Abar, and p <-> q. It is just a trick so after this point the code for D0bar can be the
125 // same as the code for D0.
126
127 // Check if we're dealing with Ks pi pi or with Ks K K.
128 m_isKsPiPi = false;
129 if ( dau[m_d2] == m_PIP || dau[m_d2] == m_PIM )
130 m_isKsPiPi = true;
131}
132
133void EvtD0mixDalitz::decay( EvtParticle* part )
134{
135 // Same structure for all of these decays.
136 part->initializePhaseSpace( getNDaug(), getDaugs() );
137 EvtVector4R pA = part->getDaug( m_d1 )->getP4();
138 EvtVector4R pB = part->getDaug( m_d2 )->getP4();
139 EvtVector4R pC = part->getDaug( m_d3 )->getP4();
140
141 // Squared invariant masses.
142 double m2AB = ( pA + pB ).mass2();
143 double m2AC = ( pA + pC ).mass2();
144 double m2BC = ( pB + pC ).mass2();
145
146 // Dalitz amplitudes of the decay of the particle and that of the antiparticle.
147 EvtComplex ampDalitz;
148 EvtComplex ampAntiDalitz;
149
150 if ( m_isKsPiPi ) { // For Ks pi pi
151 EvtDalitzPoint point( m_mKs, m_mPi, m_mPi, m2AB, m2BC, m2AC );
152 EvtDalitzPoint antiPoint( m_mKs, m_mPi, m_mPi, m2AC, m2BC, m2AB );
153
154 ampDalitz = dalitzKsPiPi( point );
155 ampAntiDalitz = dalitzKsPiPi( antiPoint );
156 } else { // For Ks K K
157 EvtDalitzPoint point( m_mKs, m_mK, m_mK, m2AB, m2BC, m2AC );
158 EvtDalitzPoint antiPoint( m_mKs, m_mK, m_mK, m2AC, m2BC, m2AB );
159
160 ampDalitz = dalitzKsKK( point );
161 ampAntiDalitz = dalitzKsKK( antiPoint );
162 }
163
164 // Assume there's no direct CP violation.
165 EvtComplex barAOverA = ampAntiDalitz / ampDalitz;
166
167 // CP violation in the interference. m_qp implements CP violation in the mixing.
168 EvtComplex chi = m_qp * barAOverA;
169
170 // Generate a negative exponential life time. p( gt ) = ( 1 - y ) * e^{ - ( 1 - y ) gt }
171 double gt = -log( EvtRandom::Flat() ) / ( 1.0 - std::fabs( m_y ) );
172 part->setLifetime( gt / m_gamma );
173
174 // Compute time dependent amplitude.
175 EvtComplex amp = 0.5 * ampDalitz * exp( -std::fabs( m_y ) * gt / 2.0 ) *
176 ( ( 1.0 + chi ) * h1( gt ) + ( 1.0 - chi ) * h2( gt ) );
177
178 vertex( amp );
179
180 return;
181}
182
183void EvtD0mixDalitz::readPDGValues()
184{
185 // Define the EvtIds.
186 m_D0 = EvtPDL::getId( "D0" );
187 m_D0B = EvtPDL::getId( "anti-D0" );
188 m_KM = EvtPDL::getId( "K-" );
189 m_KP = EvtPDL::getId( "K+" );
190 m_K0 = EvtPDL::getId( "K0" );
191 m_K0B = EvtPDL::getId( "anti-K0" );
192 m_KL = EvtPDL::getId( "K_L0" );
193 m_KS = EvtPDL::getId( "K_S0" );
194 m_PIM = EvtPDL::getId( "pi-" );
195 m_PIP = EvtPDL::getId( "pi+" );
196
197 // Read the relevant masses.
198 m_mD0 = EvtPDL::getMass( m_D0 );
199 m_mKs = EvtPDL::getMass( m_KS );
200 m_mPi = EvtPDL::getMass( m_PIP );
201 m_mK = EvtPDL::getMass( m_KP );
202
203 // Compute the decay rate from the parameter in the evt.pdl file.
204 m_ctau = EvtPDL::getctau( EvtPDL::getId( "D0" ) );
205
206 m_gamma = 1.0 / m_ctau; // ALERT: Gamma is not 1 / tau.
207}
208
209EvtComplex EvtD0mixDalitz::dalitzKsPiPi( const EvtDalitzPoint& point )
210{
211 static const EvtDalitzPlot plot( m_mKs, m_mPi, m_mPi, m_mD0 );
212
213 EvtComplex amp = 0.;
214
215 if ( m_isRBWmodel ) {
216 // This corresponds to relativistic Breit-Wigner distributions. Not K-matrix.
217 // Defining resonances.
218 static const EvtDalitzReso KStarm( plot, m_BC, m_AC, m_VECTOR, 0.893606,
219 0.0463407, m_RBW );
220 static const EvtDalitzReso KStarp( plot, m_BC, m_AB, m_VECTOR, 0.893606,
221 0.0463407, m_RBW );
222 static const EvtDalitzReso rho0( plot, m_AC, m_BC, m_VECTOR, 0.7758,
223 0.1464, m_GS );
224 static const EvtDalitzReso omega( plot, m_AC, m_BC, m_VECTOR, 0.78259,
225 0.00849, m_RBW );
226 static const EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.975,
227 0.044, m_RBW );
228 static const EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.434,
229 0.173, m_RBW );
230 static const EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754,
231 0.1851, m_RBW );
232 static const EvtDalitzReso K0Starm_1430( plot, m_BC, m_AC, m_SCALAR,
233 1.459, 0.175, m_RBW );
234 static const EvtDalitzReso K0Starp_1430( plot, m_BC, m_AB, m_SCALAR,
235 1.459, 0.175, m_RBW );
236 static const EvtDalitzReso K2Starm_1430( plot, m_BC, m_AC, m_TENSOR,
237 1.4256, 0.0985, m_RBW );
238 static const EvtDalitzReso K2Starp_1430( plot, m_BC, m_AB, m_TENSOR,
239 1.4256, 0.0985, m_RBW );
240 static const EvtDalitzReso sigma( plot, m_AC, m_BC, m_SCALAR, 0.527699,
241 0.511861, m_RBW );
242 static const EvtDalitzReso sigma2( plot, m_AC, m_BC, m_SCALAR, 1.03327,
243 0.0987890, m_RBW );
244 static const EvtDalitzReso KStarm_1680( plot, m_BC, m_AC, m_VECTOR,
245 1.677, 0.205, m_RBW );
246
247 // Adding terms to the amplitude with their corresponding amplitude and phase terms.
248 amp += EvtComplex( 0.848984, 0.893618 );
249 amp += EvtComplex( -1.16356, 1.19933 ) * KStarm.evaluate( point );
250 amp += EvtComplex( 0.106051, -0.118513 ) * KStarp.evaluate( point );
251 amp += EvtComplex( 1.0, 0.0 ) * rho0.evaluate( point );
252 amp += EvtComplex( -0.0249569, 0.0388072 ) * omega.evaluate( point );
253 amp += EvtComplex( -0.423586, -0.236099 ) * f0_980.evaluate( point );
254 amp += EvtComplex( -2.16486, 3.62385 ) * f0_1370.evaluate( point );
255 amp += EvtComplex( 0.217748, -0.133327 ) * f2_1270.evaluate( point );
256 amp += EvtComplex( 1.62128, 1.06816 ) * K0Starm_1430.evaluate( point );
257 amp += EvtComplex( 0.148802, 0.0897144 ) * K0Starp_1430.evaluate( point );
258 amp += EvtComplex( 1.15489, -0.773363 ) * K2Starm_1430.evaluate( point );
259 amp += EvtComplex( 0.140865, -0.165378 ) * K2Starp_1430.evaluate( point );
260 amp += EvtComplex( -1.55556, -0.931685 ) * sigma.evaluate( point );
261 amp += EvtComplex( -0.273791, -0.0535596 ) * sigma2.evaluate( point );
262 amp += EvtComplex( -1.69720, 0.128038 ) * KStarm_1680.evaluate( point );
263 } else {
264 // This corresponds to the complete model (RBW, GS, LASS and K-matrix).
265 // Defining resonances.
266 static const EvtDalitzReso KStarm( plot, m_BC, m_AC, m_VECTOR, 0.893619,
267 0.0466508, m_RBW );
268 static const EvtDalitzReso KStarp( plot, m_BC, m_AB, m_VECTOR, 0.893619,
269 0.0466508, m_RBW );
270 static const EvtDalitzReso rho0( plot, m_AC, m_BC, m_VECTOR, 0.7758,
271 0.1464, m_GS );
272 static const EvtDalitzReso omega( plot, m_AC, m_BC, m_VECTOR, 0.78259,
273 0.00849, m_RBW );
274 static const EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754,
275 0.1851, m_RBW );
276 static const EvtDalitzReso K0Starm_1430( plot, m_AC, 1.46312, 0.232393,
277 1.0746, -1.83214, .803516,
278 2.32788, 1.0,
279 -5.31306 ); // LASS
280 static const EvtDalitzReso K0Starp_1430( plot, m_AB, 1.46312, 0.232393,
281 1.0746, -1.83214, .803516,
282 2.32788, 1.0,
283 -5.31306 ); // LASS
284 static const EvtDalitzReso K2Starm_1430( plot, m_BC, m_AC, m_TENSOR,
285 1.4256, 0.0985, m_RBW );
286 static const EvtDalitzReso K2Starp_1430( plot, m_BC, m_AB, m_TENSOR,
287 1.4256, 0.0985, m_RBW );
288 static const EvtDalitzReso KStarm_1680( plot, m_BC, m_AC, m_VECTOR,
289 1.677, 0.205, m_RBW );
290
291 // Defining K-matrix.
292 static const EvtComplex fr12( 1.87981, -0.628378 );
293 static const EvtComplex fr13( 4.3242, 2.75019 );
294 static const EvtComplex fr14( 3.22336, 0.271048 );
295 static const EvtComplex fr15( 0.0, 0.0 );
296 static const EvtDalitzReso Pole1( plot, m_BC, "Pole1", m_KMAT, fr12,
297 fr13, fr14, fr15, -0.0694725 );
298 static const EvtDalitzReso Pole2( plot, m_BC, "Pole2", m_KMAT, fr12,
299 fr13, fr14, fr15, -0.0694725 );
300 static const EvtDalitzReso Pole3( plot, m_BC, "Pole3", m_KMAT, fr12,
301 fr13, fr14, fr15, -0.0694725 );
302 static const EvtDalitzReso Pole4( plot, m_BC, "Pole4", m_KMAT, fr12,
303 fr13, fr14, fr15, -0.0694725 );
304 static const EvtDalitzReso kmatrix( plot, m_BC, "f11prod", m_KMAT, fr12,
305 fr13, fr14, fr15, -0.0694725 );
306
307 // Adding terms to the amplitude with their corresponding amplitude and phase terms.
308 amp += EvtComplex( -1.31394, 1.14072 ) * KStarm.evaluate( point );
309 amp += EvtComplex( 0.116239, -0.107287 ) * KStarp.evaluate( point );
310 amp += EvtComplex( 1.0, 0.0 ) * rho0.evaluate( point );
311 amp += EvtComplex( -0.0313343, 0.0424013 ) * omega.evaluate( point );
312 amp += EvtComplex( 0.559412, -0.232336 ) * f2_1270.evaluate( point );
313 amp += EvtComplex( 7.35400, -3.67637 ) * K0Starm_1430.evaluate( point );
314 amp += EvtComplex( 0.255913, -0.190459 ) * K0Starp_1430.evaluate( point );
315 amp += EvtComplex( 1.05397, -0.936297 ) * K2Starm_1430.evaluate( point );
316 amp += EvtComplex( -0.00760136, -0.0908624 ) *
317 K2Starp_1430.evaluate( point );
318 amp += EvtComplex( -1.45336, -0.164494 ) * KStarm_1680.evaluate( point );
319 amp += EvtComplex( -1.81830, 9.10680 ) * Pole1.evaluate( point );
320 amp += EvtComplex( 10.1751, 3.87961 ) * Pole2.evaluate( point );
321 amp += EvtComplex( 23.6569, -4.94551 ) * Pole3.evaluate( point );
322 amp += EvtComplex( 0.0725431, -9.16264 ) * Pole4.evaluate( point );
323 amp += EvtComplex( -2.19449, -7.62666 ) * kmatrix.evaluate( point );
324
325 amp *= 0.97; // Multiply by a constant in order to use the same maximum as RBW model.
326 }
327
328 return amp;
329}
330
331EvtComplex EvtD0mixDalitz::dalitzKsKK( const EvtDalitzPoint& point )
332{
333 static const EvtDalitzPlot plot( m_mKs, m_mK, m_mK, m_mD0 );
334
335 // Defining resonances.
336 static const EvtDalitzReso a00_980( plot, m_AC, m_BC, m_SCALAR, 0.999,
337 m_RBW, 0.550173, 0.324, m_EtaPic );
338 static const EvtDalitzReso phi( plot, m_AC, m_BC, m_VECTOR, 1.01943,
339 0.00459319, m_RBW );
340 static const EvtDalitzReso a0p_980( plot, m_AC, m_AB, m_SCALAR, 0.999,
341 m_RBW, 0.550173, 0.324, m_EtaPic );
342 static const EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.350,
343 0.265, m_RBW );
344 static const EvtDalitzReso a0m_980( plot, m_AB, m_AC, m_SCALAR, 0.999,
345 m_RBW, 0.550173, 0.324, m_EtaPic );
346 static const EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.965, m_RBW,
347 0.695, 0.165, m_PicPicKK );
348 static const EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754,
349 0.1851, m_RBW );
350 static const EvtDalitzReso a00_1450( plot, m_AC, m_BC, m_SCALAR, 1.474,
351 0.265, m_RBW );
352 static const EvtDalitzReso a0p_1450( plot, m_AC, m_AB, m_SCALAR, 1.474,
353 0.265, m_RBW );
354 static const EvtDalitzReso a0m_1450( plot, m_AB, m_AC, m_SCALAR, 1.474,
355 0.265, m_RBW );
356
357 // Adding terms to the amplitude with their corresponding amplitude and phase terms.
358 EvtComplex amp( 0., 0. ); // Phase space amplitude.
359 amp += EvtComplex( 1.0, 0.0 ) * a00_980.evaluate( point );
360 amp += EvtComplex( -0.126314, 0.188701 ) * phi.evaluate( point );
361 amp += EvtComplex( -0.561428, 0.0135338 ) * a0p_980.evaluate( point );
362 amp += EvtComplex( 0.035, -0.00110488 ) * f0_1370.evaluate( point );
363 amp += EvtComplex( -0.0872735, 0.0791190 ) * a0m_980.evaluate( point );
364 amp += EvtComplex( 0.0, 0.0 ) * f0_980.evaluate( point );
365 amp += EvtComplex( 0.257341, -0.0408343 ) * f2_1270.evaluate( point );
366 amp += EvtComplex( -0.0614342, -0.649930 ) * a00_1450.evaluate( point );
367 amp += EvtComplex( -0.104629, 0.830120 ) * a0p_1450.evaluate( point );
368 amp += EvtComplex( 0.0, 0.0 ) * a0m_1450.evaluate( point );
369
370 return 2.8 *
371 amp; // Multiply by 2.8 in order to reuse the same probmax as Ks pi pi.
372}
373
374// < f | H | D^0 (t) > = 1/2 * [ ( 1 + \chi_f ) * A_f * e_1(gt) + ( 1 - \chi_f ) * A_f * e_2(gt) ]
375// < f | H | D^0 (t) > = 1/2 * exp( -gamma t / 2 ) * [ ( 1 + \chi_f ) * A_f * h_1(t) + ( 1 - \chi_f ) * A_f * h_2(t) ]
376// e{1,2}( gt ) = exp( -gt / 2 ) * h{1,2}( gt ).
377EvtComplex EvtD0mixDalitz::h1( const double& gt ) const
378{
379 return exp( -EvtComplex( m_y, m_x ) * gt / 2. );
380}
381
382EvtComplex EvtD0mixDalitz::h2( const double& gt ) const
383{
384 return exp( EvtComplex( m_y, m_x ) * gt / 2. );
385}
exp
EvtComplex exp(const EvtComplex &c)
Definition EvtComplex.hh:242
EvtGenReport
std::ostream & EvtGenReport(EvtGenSeverity severity, const char *facility=nullptr)
Definition EvtReport.cpp:32
EVTGEN_ERROR
@ EVTGEN_ERROR
Definition EvtReport.hh:49
EvtD0mixDalitz::decay
void decay(EvtParticle *p) override
Definition EvtD0mixDalitz.cpp:133
EvtD0mixDalitz::m_AB
static const EvtCyclic3::Pair & m_AB
Definition EvtD0mixDalitz.hh:65
EvtD0mixDalitz::h1
EvtComplex h1(const double &ct) const
Definition EvtD0mixDalitz.cpp:377
EvtD0mixDalitz::init
void init() override
Definition EvtD0mixDalitz.cpp:50
EvtD0mixDalitz::m_PicPicKK
static const EvtDalitzReso::CouplingType & m_PicPicKK
Definition EvtD0mixDalitz.hh:59
EvtD0mixDalitz::m_EtaPic
static const EvtDalitzReso::CouplingType & m_EtaPic
Definition EvtD0mixDalitz.hh:58
EvtD0mixDalitz::m_GS
static const EvtDalitzReso::NumType & m_GS
Definition EvtD0mixDalitz.hh:62
EvtD0mixDalitz::m_VECTOR
static const EvtSpinType::spintype & m_VECTOR
Definition EvtD0mixDalitz.hh:55
EvtD0mixDalitz::m_SCALAR
static const EvtSpinType::spintype & m_SCALAR
Definition EvtD0mixDalitz.hh:54
EvtD0mixDalitz::h2
EvtComplex h2(const double &ct) const
Definition EvtD0mixDalitz.cpp:382
EvtD0mixDalitz::dalitzKsPiPi
EvtComplex dalitzKsPiPi(const EvtDalitzPoint &point)
Definition EvtD0mixDalitz.cpp:209
EvtD0mixDalitz::m_AC
static const EvtCyclic3::Pair & m_AC
Definition EvtD0mixDalitz.hh:66
EvtD0mixDalitz::m_RBW
static const EvtDalitzReso::NumType & m_RBW
Definition EvtD0mixDalitz.hh:61
EvtD0mixDalitz::m_TENSOR
static const EvtSpinType::spintype & m_TENSOR
Definition EvtD0mixDalitz.hh:56
EvtD0mixDalitz::reportInvalidAndExit
void reportInvalidAndExit() const
Definition EvtD0mixDalitz.hh:105
EvtD0mixDalitz::m_BC
static const EvtCyclic3::Pair & m_BC
Definition EvtD0mixDalitz.hh:67
EvtD0mixDalitz::m_KMAT
static const EvtDalitzReso::NumType & m_KMAT
Definition EvtD0mixDalitz.hh:63
EvtD0mixDalitz::dalitzKsKK
EvtComplex dalitzKsKK(const EvtDalitzPoint &point)
Definition EvtD0mixDalitz.cpp:331
EvtDalitzReso::evaluate
EvtComplex evaluate(const EvtDalitzPoint &p) const
Definition EvtDalitzReso.cpp:308
EvtDecayAmp::vertex
void vertex(const EvtComplex &amp)
Definition EvtDecayAmp.hh:37
EvtDecayBase::checkSpinDaughter
void checkSpinDaughter(int d1, EvtSpinType::spintype sp)
Definition EvtDecayBase.cpp:547
EvtDecayBase::getNDaug
int getNDaug() const
Definition EvtDecayBase.hh:64
EvtDecayBase::checkSpinParent
void checkSpinParent(EvtSpinType::spintype sp)
Definition EvtDecayBase.cpp:534
EvtDecayBase::getNArg
int getNArg() const
Definition EvtDecayBase.hh:67
EvtDecayBase::getArg
double getArg(unsigned int j)
Definition EvtDecayBase.cpp:578
EvtDecayBase::getParentId
EvtId getParentId() const
Definition EvtDecayBase.hh:60
EvtDecayBase::getDaug
EvtId getDaug(int i) const
Definition EvtDecayBase.hh:66
EvtDecayBase::checkNDaug
void checkNDaug(int d1, int d2=-1)
Definition EvtDecayBase.cpp:516
EvtDecayBase::getDaugs
const EvtId * getDaugs() const
Definition EvtDecayBase.hh:65
EvtId
Definition EvtId.hh:27
EvtPDL::getMass
static double getMass(EvtId i)
Definition EvtPDL.cpp:311
EvtPDL::getctau
static double getctau(EvtId i)
Definition EvtPDL.cpp:351
EvtPDL::getId
static EvtId getId(const std::string &name)
Definition EvtPDL.cpp:283
EvtParticle::initializePhaseSpace
double initializePhaseSpace(size_t numdaughter, const EvtId *daughters, bool forceResetMasses=false, double poleSize=-1., int whichTwo1=0, int whichTwo2=1)
Definition EvtParticle.cpp:1100
EvtParticle::getP4
const EvtVector4R & getP4() const
Definition EvtParticle.cpp:144
EvtParticle::setLifetime
void setLifetime(double tau)
Definition EvtParticle.cpp:95
EvtParticle::getDaug
EvtParticle * getDaug(const int i)
Definition EvtParticle.hh:173
EvtRandom::Flat
static double Flat()
Definition EvtRandom.cpp:95
Generated by doxygen 1.16.1