BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
EvtAmp Class Reference

#include <EvtAmp.hh>

Public Member Functions

 EvtAmp ()
virtual ~EvtAmp ()
 EvtAmp (const EvtAmp &amp)
void init (EvtId p, int ndaug, EvtId *daug)
void setAmp (int *ind, const EvtComplex &amp)
const EvtComplex & getAmp (int *ind) const
EvtSpinDensity getSpinDensity ()
EvtSpinDensity contract (int i, const EvtAmp &a)
EvtAmp contract (int i, const EvtSpinDensity &rho)
EvtAmp contract (int i, const EvtAmp &a1, const EvtAmp &a2)
EvtSpinDensity getForwardSpinDensity (EvtSpinDensity *rho_list, int k)
EvtSpinDensity getBackwardSpinDensity (EvtSpinDensity *rho_list)
EvtAmp & operator= (const EvtAmp &amp)
void vertex (const EvtComplex &amp)
void vertex (int i1, const EvtComplex &amp)
void vertex (int i1, int i2, const EvtComplex &amp)
void vertex (int i1, int i2, int i3, const EvtComplex &amp)
void vertex (int *i1, const EvtComplex &amp)
void dump ()

Friends

class EvtDecayAmp
class EvtKstarstargamma

Detailed Description

Definition at line 30 of file EvtAmp.hh.

Constructor & Destructor Documentation

◆ EvtAmp() [1/2]

EvtAmp::EvtAmp ( )

Definition at line 35 of file EvtAmp.cc.

35 {
36 _ndaug = 0;
37 _pstates = 0;
38 _nontrivial = 0;
39}

Referenced by contract(), contract(), contract(), EvtAmp(), getBackwardSpinDensity(), getForwardSpinDensity(), and operator=().

◆ ~EvtAmp()

virtual EvtAmp::~EvtAmp ( )
inlinevirtual

Definition at line 34 of file EvtAmp.hh.

34{}

◆ EvtAmp() [2/2]

EvtAmp::EvtAmp ( const EvtAmp & amp)

Definition at line 41 of file EvtAmp.cc.

41 {
42
43 int i;
44
45 _ndaug = amp._ndaug;
46 _pstates = amp._pstates;
47 for ( i = 0; i < _ndaug; i++ )
48 {
49 dstates[i] = amp.dstates[i];
50 _dnontrivial[i] = amp._dnontrivial[i];
51 }
52 _nontrivial = amp._nontrivial;
53
54 int namp = _pstates;
55
56 for ( i = 0; i < _nontrivial; i++ )
57 {
58 _nstate[i] = amp._nstate[i];
59 namp *= _nstate[i];
60 }
61
62 for ( i = 0; i < namp; i++ ) { _amp[i] = amp._amp[i]; }
63}

Member Function Documentation

◆ contract() [1/3]

EvtSpinDensity EvtAmp::contract ( int i,
const EvtAmp & a )

Definition at line 317 of file EvtAmp.cc.

317 {
318
319 int i, j, l;
320
321 EvtComplex temp;
322 EvtSpinDensity rho;
323
324 rho.SetDim( _nstate[k] );
325
326 int allloop = 1;
327 int indflag, ii;
328 for ( i = 0; i < _nontrivial; i++ ) { allloop *= _nstate[i]; }
329
330 int index[10];
331 int index1[10];
332 // int l;
333 for ( i = 0; i < _nstate[k]; i++ )
334 {
335
336 for ( j = 0; j < _nstate[k]; j++ )
337 {
338 if ( _nontrivial == 0 )
339 {
340 report( ERROR, "EvtGen" ) << "Should not be here1 EvtAmp!" << endl;
341 rho.Set( 0, 0, EvtComplex( 1.0, 0.0 ) );
342 return rho;
343 }
344
345 for ( ii = 0; ii < 10; ii++ )
346 {
347 index[ii] = 0;
348 index1[ii] = 0;
349 }
350 index[k] = i;
351 index1[k] = j;
352
353 temp = EvtComplex( 0.0 );
354
355 for ( l = 0; l < int( allloop / _nstate[k] ); l++ )
356 {
357
358 temp += getAmp( index ) * conj( amp2.getAmp( index1 ) );
359 indflag = 0;
360 for ( ii = 0; ii < _nontrivial; ii++ )
361 {
362 if ( ii != k )
363 {
364 if ( indflag == 0 )
365 {
366 if ( index[ii] == ( _nstate[ii] - 1 ) )
367 {
368 index[ii] = 0;
369 index1[ii] = 0;
370 }
371 else
372 {
373 indflag = 1;
374 index[ii] += 1;
375 index1[ii] += 1;
376 }
377 }
378 }
379 }
380 }
381 rho.Set( i, j, temp );
382 }
383 }
384
385 return rho;
386}
conj
Evt3Rank3C conj(const Evt3Rank3C &t2)
Definition Evt3Rank3C.cc:166
report
ostream & report(Severity severity, const char *facility)
Definition EvtReport.cc:34
ERROR
@ ERROR
Definition EvtReport.hh:49
EvtAmp::getAmp
const EvtComplex & getAmp(int *ind) const
Definition EvtAmp.cc:121
EvtSpinDensity::Set
void Set(int i, int j, const EvtComplex &rhoij)
Definition EvtSpinDensity.cc:91
EvtSpinDensity::SetDim
void SetDim(int n)
Definition EvtSpinDensity.cc:72

Referenced by getBackwardSpinDensity(), getForwardSpinDensity(), and EvtDecayAmp::makeDecay().

◆ contract() [2/3]

EvtAmp EvtAmp::contract ( int i,
const EvtAmp & a1,
const EvtAmp & a2 )

Definition at line 388 of file EvtAmp.cc.

388 {
389
390 assert( a2._pstates > 1 && a2._nontrivial == 1 );
391
392 EvtAmp tmp;
393 report( DEBUG, "EvtGen" ) << "EvtAmp::contract not written yet" << endl;
394 return tmp;
395}
DEBUG
@ DEBUG
Definition EvtReport.hh:53
EvtAmp::EvtAmp
EvtAmp()
Definition EvtAmp.cc:35

◆ contract() [3/3]

EvtAmp EvtAmp::contract ( int i,
const EvtSpinDensity & rho )

Definition at line 257 of file EvtAmp.cc.

257 {
258
259 EvtAmp temp;
260
261 int i, j;
262 temp._ndaug = _ndaug;
263 temp._pstates = _pstates;
264 temp._nontrivial = _nontrivial;
265
266 for ( i = 0; i < _ndaug; i++ )
267 {
268 temp.dstates[i] = dstates[i];
269 temp._dnontrivial[i] = _dnontrivial[i];
270 }
271
272 if ( _nontrivial == 0 )
273 { report( ERROR, "EvtGen" ) << "Should not be here EvtAmp!" << endl; }
274
275 for ( i = 0; i < _nontrivial; i++ ) { temp._nstate[i] = _nstate[i]; }
276
277 EvtComplex c;
278
279 int index[10];
280 for ( i = 0; i < 10; i++ ) { index[i] = 0; }
281
282 int allloop = 1;
283 int indflag, ii;
284 for ( i = 0; i < _nontrivial; i++ ) { allloop *= _nstate[i]; }
285
286 for ( i = 0; i < allloop; i++ )
287 {
288
289 c = EvtComplex( 0.0 );
290 int tempint = index[k];
291 for ( j = 0; j < _nstate[k]; j++ )
292 {
293 index[k] = j;
294 c += rho.Get( j, tempint ) * getAmp( index );
295 }
296 index[k] = tempint;
297
298 temp.setAmp( index, c );
299
300 indflag = 0;
301 for ( ii = 0; ii < _nontrivial; ii++ )
302 {
303 if ( indflag == 0 )
304 {
305 if ( index[ii] == ( _nstate[ii] - 1 ) ) { index[ii] = 0; }
306 else
307 {
308 indflag = 1;
309 index[ii] += 1;
310 }
311 }
312 }
313 }
314 return temp;
315}
EvtAmp::setAmp
void setAmp(int *ind, const EvtComplex &amp)
Definition EvtAmp.cc:108
EvtSpinDensity::Get
const EvtComplex & Get(int i, int j) const
Definition EvtSpinDensity.cc:96

◆ dump()

void EvtAmp::dump ( )

Definition at line 397 of file EvtAmp.cc.

397 {
398
399 int i, list[10];
400
401 report( DEBUG, "EvtGen" ) << "Number of daugthers:" << _ndaug << endl;
402 report( DEBUG, "EvtGen" ) << "Number of states of the parent:" << _pstates << endl;
403 report( DEBUG, "EvtGen" ) << "Number of states on daughters:";
404 for ( i = 0; i < _ndaug; i++ ) { report( DEBUG, "EvtGen" ) << dstates[i] << " "; }
405 report( DEBUG, "EvtGen" ) << endl;
406 report( DEBUG, "EvtGen" ) << "Nontrivial index of daughters:";
407 for ( i = 0; i < _ndaug; i++ ) { report( DEBUG, "EvtGen" ) << _dnontrivial[i] << " "; }
408 report( DEBUG, "EvtGen" ) << endl;
409 report( DEBUG, "EvtGen" ) << "number of nontrivial states:" << _nontrivial << endl;
410 report( DEBUG, "EvtGen" ) << "Nontrivial particles number of states:";
411 for ( i = 0; i < _nontrivial; i++ ) { report( DEBUG, "EvtGen" ) << _nstate[i] << " "; }
412 report( DEBUG, "EvtGen" ) << endl;
413 report( DEBUG, "EvtGen" ) << "Amplitudes:" << endl;
414 if ( _nontrivial == 0 )
415 {
416 list[0] = 0;
417 report( DEBUG, "EvtGen" ) << getAmp( list ) << endl;
418 }
419
420 int allloop[10];
421 allloop[0] = 1;
422 for ( i = 0; i < _nontrivial; i++ )
423 {
424 if ( i == 0 ) { allloop[i] *= _nstate[i]; }
425 else { allloop[i] = allloop[i - 1] * _nstate[i]; }
426 }
427 int index = 0;
428 for ( i = 0; i < allloop[_nontrivial - 1]; i++ )
429 {
430 report( DEBUG, "EvtGen" ) << getAmp( list ) << " ";
431 if ( i == allloop[index] - 1 )
432 {
433 index++;
434 report( DEBUG, "EvtGen" ) << endl;
435 }
436 }
437
438 report( DEBUG, "EvtGen" ) << "-----------------------------------" << endl;
439}

◆ getAmp()

const EvtComplex & EvtAmp::getAmp ( int * ind) const

Definition at line 121 of file EvtAmp.cc.

121 {
122
123 int nstatepad = 1;
124 int position = ind[0];
125
126 for ( int i = 1; i < _nontrivial; i++ )
127 {
128 nstatepad *= _nstate[i - 1];
129 position += nstatepad * ind[i];
130 }
131
132 return _amp[position];
133}

Referenced by contract(), contract(), and dump().

◆ getBackwardSpinDensity()

EvtSpinDensity EvtAmp::getBackwardSpinDensity ( EvtSpinDensity * rho_list)

Definition at line 197 of file EvtAmp.cc.

197 {
198
199 EvtSpinDensity rho;
200
201 rho.SetDim( _pstates );
202
203 if ( _pstates == 1 )
204 {
205 rho.Set( 0, 0, EvtComplex( 1.0, 0.0 ) );
206 return rho;
207 }
208
209 int k;
210
211 EvtAmp ampprime;
212
213 ampprime = ( *this );
214
215 for ( k = 0; k < _ndaug; k++ )
216 {
217
218 if ( dstates[k] != 1 )
219 { ampprime = ampprime.contract( _dnontrivial[k], rho_list[k + 1] ); }
220 }
221
222 return ampprime.contract( 0, ( *this ) );
223}
EvtAmp::contract
EvtSpinDensity contract(int i, const EvtAmp &a)
Definition EvtAmp.cc:317

◆ getForwardSpinDensity()

EvtSpinDensity EvtAmp::getForwardSpinDensity ( EvtSpinDensity * rho_list,
int k )

Definition at line 225 of file EvtAmp.cc.

225 {
226
227 EvtSpinDensity rho;
228
229 rho.SetDim( dstates[i] );
230
231 int k;
232
233 if ( dstates[i] == 1 )
234 {
235
236 rho.Set( 0, 0, EvtComplex( 1.0, 0.0 ) );
237
238 return rho;
239 }
240
241 EvtAmp ampprime;
242
243 ampprime = ( *this );
244
245 if ( _pstates != 1 ) { ampprime = ampprime.contract( 0, rho_list[0] ); }
246
247 for ( k = 0; k < i; k++ )
248 {
249
250 if ( dstates[k] != 1 )
251 { ampprime = ampprime.contract( _dnontrivial[k], rho_list[k + 1] ); }
252 }
253
254 return ampprime.contract( _dnontrivial[i], ( *this ) );
255}

◆ getSpinDensity()

EvtSpinDensity EvtAmp::getSpinDensity ( )

Definition at line 135 of file EvtAmp.cc.

135 {
136
137 EvtSpinDensity rho;
138 rho.SetDim( _pstates );
139
140 EvtComplex temp;
141
142 int i, j, n;
143
144 if ( _pstates == 1 )
145 {
146
147 if ( _nontrivial == 0 )
148 {
149
150 rho.Set( 0, 0, _amp[0] * conj( _amp[0] ) );
151 return rho;
152 }
153
154 n = 1;
155
156 temp = EvtComplex( 0.0 );
157
158 for ( i = 0; i < _nontrivial; i++ ) { n *= _nstate[i]; }
159
160 for ( i = 0; i < n; i++ ) { temp += _amp[i] * conj( _amp[i] ); }
161
162 rho.Set( 0, 0, temp );
163 ;
164
165 return rho;
166 }
167
168 else
169 {
170
171 for ( i = 0; i < _pstates; i++ )
172 {
173 for ( j = 0; j < _pstates; j++ )
174 {
175
176 temp = EvtComplex( 0.0 );
177
178 int kk;
179
180 int allloop = 1;
181 for ( kk = 0; kk < ( _nontrivial - 1 ); kk++ ) { allloop *= dstates[kk]; }
182
183 for ( kk = 0; kk < allloop; kk++ )
184 { temp += _amp[_pstates * kk + i] * conj( _amp[_pstates * kk + j] ); }
185
186 // if (_nontrivial>3){
187 // report(ERROR,"EvtGen") << "Can't handle so many states in EvtAmp!"<<endl;
188 //}
189
190 rho.Set( i, j, temp );
191 }
192 }
193 return rho;
194 }
195}
n
const Int_t n
Definition DataBase/tau_mode.c:57

Referenced by EvtbTosllAmp::CalcMaxProb(), and EvtSemiLeptonicAmp::CalcMaxProb().

◆ init()

void EvtAmp::init ( EvtId p,
int ndaug,
EvtId * daug )

Definition at line 65 of file EvtAmp.cc.

65 {
66 setNDaug( ndaugs );
67 int ichild;
68 int daug_states[100], parstates;
69 for ( ichild = 0; ichild < ndaugs; ichild++ )
70 { daug_states[ichild] = EvtSpinType::getSpinStates( EvtPDL::getSpinType( daug[ichild] ) ); }
71
72 parstates = EvtSpinType::getSpinStates( EvtPDL::getSpinType( p ) );
73
74 setNState( parstates, daug_states );
75}
EvtPDL::getSpinType
static EvtSpinType::spintype getSpinType(EvtId i)
Definition EvtPDL.hh:66
EvtSpinType::getSpinStates
static int getSpinStates(spintype stype)
Definition EvtSpinType.hh:67

Referenced by EvtbTosllAmp::CalcMaxProb(), and EvtSemiLeptonicAmp::CalcMaxProb().

◆ operator=()

EvtAmp & EvtAmp::operator= ( const EvtAmp & amp)

Definition at line 470 of file EvtAmp.cc.

470 {
471
472 int i;
473
474 _ndaug = amp._ndaug;
475 _pstates = amp._pstates;
476 for ( i = 0; i < _ndaug; i++ )
477 {
478 dstates[i] = amp.dstates[i];
479 _dnontrivial[i] = amp._dnontrivial[i];
480 }
481 _nontrivial = amp._nontrivial;
482
483 int namp = _pstates;
484
485 for ( i = 0; i < _nontrivial; i++ )
486 {
487 _nstate[i] = amp._nstate[i];
488 namp *= _nstate[i];
489 }
490
491 for ( i = 0; i < namp; i++ ) { _amp[i] = amp._amp[i]; }
492
493 return *this;
494}

◆ setAmp()

void EvtAmp::setAmp ( int * ind,
const EvtComplex & amp )

Definition at line 108 of file EvtAmp.cc.

108 {
109
110 int nstatepad = 1;
111 int position = ind[0];
112
113 for ( int i = 1; i < _nontrivial; i++ )
114 {
115 nstatepad *= _nstate[i - 1];
116 position += nstatepad * ind[i];
117 }
118 _amp[position] = a;
119}

Referenced by contract(), vertex(), vertex(), vertex(), vertex(), and vertex().

◆ vertex() [1/5]

void EvtAmp::vertex ( const EvtComplex & amp)

sets the amplitudes calculated in the decay objects

Definition at line 441 of file EvtAmp.cc.

441 {
442 int list[1];
443 list[0] = 0;
444 setAmp( list, c );
445}

Referenced by EvtbTosllScalarAmp::CalcAmp(), EvtbTosllVectorAmp::CalcAmp(), EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtSemiLeptonicTensorAmp::CalcAmp(), EvtSemiLeptonicVectorAmp::CalcAmp(), EvtHypNonLepton::calcAmp(), EvtEvalHelAmp::evalAmp(), and EvtSVVHelAmp::SVVHel().

◆ vertex() [2/5]

void EvtAmp::vertex ( int * i1,
const EvtComplex & amp )

sets the amplitudes calculated in the decay objects

Definition at line 468 of file EvtAmp.cc.

468{ setAmp( i1, c ); }

◆ vertex() [3/5]

void EvtAmp::vertex ( int i1,
const EvtComplex & amp )

sets the amplitudes calculated in the decay objects

Definition at line 447 of file EvtAmp.cc.

447 {
448 int list[1];
449 list[0] = i;
450 setAmp( list, c );
451}

◆ vertex() [4/5]

void EvtAmp::vertex ( int i1,
int i2,
const EvtComplex & amp )

sets the amplitudes calculated in the decay objects

Definition at line 453 of file EvtAmp.cc.

453 {
454 int list[2];
455 list[0] = i;
456 list[1] = j;
457 setAmp( list, c );
458}

◆ vertex() [5/5]

void EvtAmp::vertex ( int i1,
int i2,
int i3,
const EvtComplex & amp )

sets the amplitudes calculated in the decay objects

Definition at line 460 of file EvtAmp.cc.

460 {
461 int list[3];
462 list[0] = i;
463 list[1] = j;
464 list[2] = k;
465 setAmp( list, c );
466}

◆ EvtDecayAmp

friend class EvtDecayAmp
friend

Definition at line 85 of file EvtAmp.hh.

Referenced by EvtDecayAmp.

◆ EvtKstarstargamma

friend class EvtKstarstargamma
friend

Definition at line 86 of file EvtAmp.hh.

Referenced by EvtKstarstargamma.

The documentation for this class was generated from the following files: