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

#include <EvtTensor4C.hh>

Public Member Functions

 EvtTensor4C ()
 EvtTensor4C (double t00, double t11, double t22, double t33)
 EvtTensor4C (const EvtTensor4C &t1)
virtual ~EvtTensor4C ()
EvtTensor4C & operator= (const EvtTensor4C &t1)
EvtTensor4C & operator*= (const EvtComplex &c)
EvtTensor4C & operator*= (double d)
EvtTensor4C & addDirProd (const EvtVector4R &p1, const EvtVector4R &p2)
void set (int i, int j, const EvtComplex &c)
void setdiag (double t00, double t11, double t22, double t33)
const EvtComplex & get (int i, int j) const
EvtComplex trace () const
void zero ()
void applyRotateEuler (double alpha, double beta, double gamma)
void applyBoostTo (const EvtVector4R &p4)
void applyBoostTo (const EvtVector3R &boost)
EvtTensor4C & operator+= (const EvtTensor4C &t2)
EvtTensor4C & operator-= (const EvtTensor4C &t2)
EvtTensor4C conj () const
EvtVector4C cont1 (const EvtVector4C &v4) const
EvtVector4C cont2 (const EvtVector4C &v4) const
EvtVector4C cont1 (const EvtVector4R &v4) const
EvtVector4C cont2 (const EvtVector4R &v4) const

Static Public Member Functions

static const EvtTensor4C & g ()

Friends

EvtTensor4C rotateEuler (const EvtTensor4C &e, double alpha, double beta, double gamma)
EvtTensor4C boostTo (const EvtTensor4C &e, const EvtVector4R p4)
EvtTensor4C boostTo (const EvtTensor4C &e, const EvtVector3R boost)
EvtTensor4C directProd (const EvtVector4C &c1, const EvtVector4C &c2)
EvtTensor4C directProd (const EvtVector4C &c1, const EvtVector4R &c2)
EvtTensor4C directProd (const EvtVector4R &c1, const EvtVector4R &c2)
EvtTensor4C dual (const EvtTensor4C &t2)
EvtTensor4C conj (const EvtTensor4C &t2)
EvtTensor4C cont22 (const EvtTensor4C &t1, const EvtTensor4C &t2)
EvtTensor4C cont11 (const EvtTensor4C &t1, const EvtTensor4C &t2)
EvtTensor4C operator* (const EvtTensor4C &t1, const EvtComplex &c)
EvtTensor4C operator* (const EvtComplex &c, const EvtTensor4C &t1)
EvtTensor4C operator* (const EvtTensor4C &t1, double d)
EvtTensor4C operator* (double d, const EvtTensor4C &t1)
EvtComplex cont (const EvtTensor4C &t1, const EvtTensor4C &t2)
EvtTensor4C operator+ (const EvtTensor4C &t1, const EvtTensor4C &t2)
EvtTensor4C operator- (const EvtTensor4C &t1, const EvtTensor4C &t2)
std::ostream & operator<< (std::ostream &s, const EvtTensor4C &t)

Detailed Description

Definition at line 51 of file EvtTensor4C.hh.

Constructor & Destructor Documentation

◆ EvtTensor4C() [1/3]

EvtTensor4C::EvtTensor4C ( )
inline

Definition at line 73 of file EvtTensor4C.hh.

73{ ; }

Referenced by addDirProd(), boostTo, boostTo, conj(), conj, cont, cont11, cont22, directProd, directProd, directProd, dual, EvtTensor4C(), g(), operator*, operator*, operator*, operator*, operator*=(), operator*=(), operator+, operator+=(), operator-, operator-=(), operator<<, operator=(), and rotateEuler.

◆ EvtTensor4C() [2/3]

EvtTensor4C::EvtTensor4C ( double t00,
double t11,
double t22,
double t33 )
inline

Definition at line 75 of file EvtTensor4C.hh.

75 {
76 setdiag( t00, t11, t22, t33 );
77 }
EvtTensor4C::setdiag
void setdiag(double t00, double t11, double t22, double t33)
Definition EvtTensor4C.cc:190

◆ EvtTensor4C() [3/3]

EvtTensor4C::EvtTensor4C ( const EvtTensor4C & t1)

Definition at line 31 of file EvtTensor4C.cc.

31 {
32
33 int i, j;
34
35 for ( i = 0; i < 4; i++ )
36 {
37 for ( j = 0; j < 4; j++ ) { t[i][j] = t1.t[i][j]; }
38 }
39}

◆ ~EvtTensor4C()

EvtTensor4C::~EvtTensor4C ( )
virtual

Definition at line 41 of file EvtTensor4C.cc.

41{}

Member Function Documentation

◆ addDirProd()

EvtTensor4C & EvtTensor4C::addDirProd ( const EvtVector4R & p1,
const EvtVector4R & p2 )

Definition at line 318 of file EvtTensor4C.cc.

318 {
319
320 int i, j;
321
322 for ( i = 0; i < 4; i++ )
323 {
324 for ( j = 0; j < 4; j++ ) { t[i][j] += p1.get( i ) * p2.get( j ); }
325 }
326 return *this;
327}
p2
double p2[4]
Definition BabayagaNLO.cxx:41
p1
double p1[4]
Definition BabayagaNLO.cxx:41

Referenced by EvtSemiLeptonicVectorAmp::CalcAmp().

◆ applyBoostTo() [1/2]

void EvtTensor4C::applyBoostTo ( const EvtVector3R & boost)

Definition at line 104 of file EvtTensor4C.cc.

104 {
105
106 double bx, by, bz, gamma, b2;
107 double lambda[4][4];
108 EvtComplex tt[4][4];
109
110 bx = boost.get( 0 );
111 by = boost.get( 1 );
112 bz = boost.get( 2 );
113
114 double bxx = bx * bx;
115 double byy = by * by;
116 double bzz = bz * bz;
117
118 b2 = bxx + byy + bzz;
119
120 if ( b2 == 0.0 ) { return; }
121
122 assert( b2 < 1.0 );
123
124 gamma = 1.0 / sqrt( 1 - b2 );
125
126 int i, j, k;
127
128 if ( b2 == 0.0 ) { return; }
129
130 lambda[0][0] = gamma;
131 lambda[0][1] = gamma * bx;
132 lambda[1][0] = gamma * bx;
133 lambda[0][2] = gamma * by;
134 lambda[2][0] = gamma * by;
135 lambda[0][3] = gamma * bz;
136 lambda[3][0] = gamma * bz;
137
138 lambda[1][1] = 1.0 + ( gamma - 1.0 ) * bx * bx / b2;
139 lambda[2][2] = 1.0 + ( gamma - 1.0 ) * by * by / b2;
140 lambda[3][3] = 1.0 + ( gamma - 1.0 ) * bz * bz / b2;
141
142 lambda[1][2] = ( gamma - 1.0 ) * bx * by / b2;
143 lambda[2][1] = ( gamma - 1.0 ) * bx * by / b2;
144
145 lambda[1][3] = ( gamma - 1.0 ) * bx * bz / b2;
146 lambda[3][1] = ( gamma - 1.0 ) * bx * bz / b2;
147
148 lambda[3][2] = ( gamma - 1.0 ) * bz * by / b2;
149 lambda[2][3] = ( gamma - 1.0 ) * bz * by / b2;
150
151 for ( i = 0; i < 4; i++ )
152 {
153 for ( j = 0; j < 4; j++ )
154 {
155 tt[i][j] = EvtComplex( 0.0 );
156 for ( k = 0; k < 4; k++ ) { tt[i][j] = tt[i][j] + lambda[j][k] * t[i][k]; }
157 }
158 }
159
160 for ( i = 0; i < 4; i++ )
161 {
162 for ( j = 0; j < 4; j++ )
163 {
164 t[i][j] = EvtComplex( 0.0 );
165 for ( k = 0; k < 4; k++ ) { t[i][j] = t[i][j] + lambda[i][k] * tt[k][j]; }
166 }
167 }
168}
EvtVector3R::get
double get(int i) const
Definition EvtVector3R.hh:122

◆ applyBoostTo() [2/2]

void EvtTensor4C::applyBoostTo ( const EvtVector4R & p4)

Definition at line 93 of file EvtTensor4C.cc.

93 {
94
95 double e = p4.get( 0 );
96
97 EvtVector3R boost( p4.get( 1 ) / e, p4.get( 2 ) / e, p4.get( 3 ) / e );
98
99 applyBoostTo( boost );
100
101 return;
102}
EvtTensor4C::applyBoostTo
void applyBoostTo(const EvtVector4R &p4)
Definition EvtTensor4C.cc:93
EvtVector4R::get
double get(int i) const
Definition EvtVector4R.hh:171

Referenced by applyBoostTo(), boostTo, boostTo, and EvtTensorParticle::epsTensorParent().

◆ applyRotateEuler()

void EvtTensor4C::applyRotateEuler ( double alpha,
double beta,
double gamma )

Definition at line 466 of file EvtTensor4C.cc.

466 {
467
468 EvtComplex tt[4][4];
469 double sp, st, sk, cp, ct, ck;
470 double lambda[4][4];
471
472 sp = sin( phi );
473 st = sin( theta );
474 sk = sin( ksi );
475 cp = cos( phi );
476 ct = cos( theta );
477 ck = cos( ksi );
478
479 lambda[0][0] = 1.0;
480 lambda[0][1] = 0.0;
481 lambda[1][0] = 0.0;
482 lambda[0][2] = 0.0;
483 lambda[2][0] = 0.0;
484 lambda[0][3] = 0.0;
485 lambda[3][0] = 0.0;
486
487 lambda[1][1] = ck * ct * cp - sk * sp;
488 lambda[1][2] = -sk * ct * cp - ck * sp;
489 lambda[1][3] = st * cp;
490
491 lambda[2][1] = ck * ct * sp + sk * cp;
492 lambda[2][2] = -sk * ct * sp + ck * cp;
493 lambda[2][3] = st * sp;
494
495 lambda[3][1] = -ck * st;
496 lambda[3][2] = sk * st;
497 lambda[3][3] = ct;
498
499 int i, j, k;
500
501 for ( i = 0; i < 4; i++ )
502 {
503 for ( j = 0; j < 4; j++ )
504 {
505 tt[i][j] = EvtComplex( 0.0 );
506 for ( k = 0; k < 4; k++ ) { tt[i][j] += lambda[j][k] * t[i][k]; }
507 }
508 }
509
510 for ( i = 0; i < 4; i++ )
511 {
512 for ( j = 0; j < 4; j++ )
513 {
514 t[i][j] = EvtComplex( 0.0 );
515 for ( k = 0; k < 4; k++ ) { t[i][j] += lambda[i][k] * tt[k][j]; }
516 }
517 }
518}
sin
double sin(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:185
cos
double cos(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:187

Referenced by rotateEuler.

◆ conj()

EvtTensor4C EvtTensor4C::conj ( ) const

Definition at line 60 of file EvtTensor4C.cc.

60 {
61 EvtTensor4C temp;
62
63 int i, j;
64
65 for ( i = 0; i < 4; i++ )
66 {
67 for ( j = 0; j < 4; j++ ) { temp.set( j, i, ::conj( t[i][j] ) ); }
68 }
69 return temp;
70}
EvtTensor4C::set
void set(int i, int j, const EvtComplex &c)
Definition EvtTensor4C.hh:117
EvtTensor4C::conj
EvtTensor4C conj() const
Definition EvtTensor4C.cc:60

◆ cont1() [1/2]

EvtVector4C EvtTensor4C::cont1 ( const EvtVector4C & v4) const

Definition at line 410 of file EvtTensor4C.cc.

410 {
411 EvtVector4C temp;
412
413 int i;
414
415 for ( i = 0; i < 4; i++ )
416 {
417 temp.set( i, t[0][i] * v4.get( 0 ) - t[1][i] * v4.get( 1 ) - t[2][i] * v4.get( 2 ) -
418 t[3][i] * v4.get( 3 ) );
419 }
420
421 return temp;
422}
EvtVector4C::set
void set(int, const EvtComplex &)
Definition EvtVector4C.hh:104
EvtVector4C::get
const EvtComplex & get(int) const
Definition EvtVector4C.hh:125

Referenced by EvtSemiLeptonicVectorAmp::CalcAmp(), EvtBHadronic::decay(), EvtKstarnunu::decay(), EvtSSDCP::decay(), EvtSTS::decay(), EvtSTSCP::decay(), EvtSVPCP::decay(), EvtSVPHelAmp::decay(), EvtTSS::decay(), EvtTVSPwave::decay(), EvtVSPPwave::decay(), and EvtVVSPwave::decay().

◆ cont1() [2/2]

EvtVector4C EvtTensor4C::cont1 ( const EvtVector4R & v4) const

Definition at line 438 of file EvtTensor4C.cc.

438 {
439 EvtVector4C temp;
440
441 int i;
442
443 for ( i = 0; i < 4; i++ )
444 {
445 temp.set( i, t[0][i] * v4.get( 0 ) - t[1][i] * v4.get( 1 ) - t[2][i] * v4.get( 2 ) -
446 t[3][i] * v4.get( 3 ) );
447 }
448
449 return temp;
450}

◆ cont2() [1/2]

EvtVector4C EvtTensor4C::cont2 ( const EvtVector4C & v4) const

Definition at line 424 of file EvtTensor4C.cc.

424 {
425 EvtVector4C temp;
426
427 int i;
428
429 for ( i = 0; i < 4; i++ )
430 {
431 temp.set( i, t[i][0] * v4.get( 0 ) - t[i][1] * v4.get( 1 ) - t[i][2] * v4.get( 2 ) -
432 t[i][3] * v4.get( 3 ) );
433 }
434
435 return temp;
436}

Referenced by EvtSemiLeptonicTensorAmp::CalcAmp(), EvtBHadronic::decay(), EvtLNuGamma::decay(), EvtDecayPlaneNormalAngle(), and EvtVector4R::scalartripler3().

◆ cont2() [2/2]

EvtVector4C EvtTensor4C::cont2 ( const EvtVector4R & v4) const

Definition at line 452 of file EvtTensor4C.cc.

452 {
453 EvtVector4C temp;
454
455 int i;
456
457 for ( i = 0; i < 4; i++ )
458 {
459 temp.set( i, t[i][0] * v4.get( 0 ) - t[i][1] * v4.get( 1 ) - t[i][2] * v4.get( 2 ) -
460 t[i][3] * v4.get( 3 ) );
461 }
462
463 return temp;
464}

◆ g()

const EvtTensor4C & EvtTensor4C::g ( )
static

Definition at line 43 of file EvtTensor4C.cc.

43 {
44
45 static EvtTensor4C g_metric( 1.0, -1.0, -1.0, -1.0 );
46
47 return g_metric;
48}

Referenced by EvtbTosllVectorAmp::CalcAmp(), EvtSemiLeptonicVectorAmp::CalcAmp(), EvtKstarnunu::decay(), EvtPi0Dalitz::decay(), EvtGammaMatrix::sigmaLower(), and EvtGammaMatrix::sigmaUpper().

◆ get()

const EvtComplex & EvtTensor4C::get ( int i,
int j ) const
inline

Definition at line 119 of file EvtTensor4C.hh.

119{ return t[i][j]; }

Referenced by conj, cont11, cont22, dual, EvtDiracSpinor::EvtLeptonTCurrent, EvtDiracSpinor::EvtLeptonTg5Current, operator+=(), operator-=(), and EvtGammaMatrix::sigmaLower().

◆ operator*=() [1/2]

EvtTensor4C & EvtTensor4C::operator*= ( const EvtComplex & c)

Definition at line 231 of file EvtTensor4C.cc.

231 {
232 int i, j;
233
234 for ( i = 0; i < 4; i++ )
235 {
236 for ( j = 0; j < 4; j++ ) { t[i][j] *= c; }
237 }
238 return *this;
239}

◆ operator*=() [2/2]

EvtTensor4C & EvtTensor4C::operator*= ( double d)

Definition at line 251 of file EvtTensor4C.cc.

251 {
252 int i, j;
253
254 for ( i = 0; i < 4; i++ )
255 {
256 for ( j = 0; j < 4; j++ ) { t[i][j] *= EvtComplex( d, 0.0 ); }
257 }
258 return *this;
259}

◆ operator+=()

EvtTensor4C & EvtTensor4C::operator+= ( const EvtTensor4C & t2)

Definition at line 209 of file EvtTensor4C.cc.

209 {
210
211 int i, j;
212
213 for ( i = 0; i < 4; i++ )
214 {
215 for ( j = 0; j < 4; j++ ) { t[i][j] += t2.get( i, j ); }
216 }
217 return *this;
218}
EvtTensor4C::get
const EvtComplex & get(int i, int j) const
Definition EvtTensor4C.hh:119

◆ operator-=()

EvtTensor4C & EvtTensor4C::operator-= ( const EvtTensor4C & t2)

Definition at line 220 of file EvtTensor4C.cc.

220 {
221
222 int i, j;
223
224 for ( i = 0; i < 4; i++ )
225 {
226 for ( j = 0; j < 4; j++ ) { t[i][j] -= t2.get( i, j ); }
227 }
228 return *this;
229}

◆ operator=()

EvtTensor4C & EvtTensor4C::operator= ( const EvtTensor4C & t1)

Definition at line 50 of file EvtTensor4C.cc.

50 {
51 int i, j;
52
53 for ( i = 0; i < 4; i++ )
54 {
55 for ( j = 0; j < 4; j++ ) { t[i][j] = t1.t[i][j]; }
56 }
57 return *this;
58}

◆ set()

void EvtTensor4C::set ( int i,
int j,
const EvtComplex & c )
inline

Definition at line 117 of file EvtTensor4C.hh.

117{ t[i][j] = c; }

Referenced by conj, cont11, cont22, directProd, directProd, dual, EvtDiracSpinor::EvtLeptonTCurrent, EvtDiracSpinor::EvtLeptonTg5Current, and operator*().

◆ setdiag()

void EvtTensor4C::setdiag ( double t00,
double t11,
double t22,
double t33 )

Definition at line 190 of file EvtTensor4C.cc.

190 {
191 t[0][0] = EvtComplex( g00 );
192 t[1][1] = EvtComplex( g11 );
193 t[2][2] = EvtComplex( g22 );
194 t[3][3] = EvtComplex( g33 );
195 t[0][1] = EvtComplex( 0.0 );
196 t[0][2] = EvtComplex( 0.0 );
197 t[0][3] = EvtComplex( 0.0 );
198 t[1][0] = EvtComplex( 0.0 );
199 t[1][2] = EvtComplex( 0.0 );
200 t[1][3] = EvtComplex( 0.0 );
201 t[2][0] = EvtComplex( 0.0 );
202 t[2][1] = EvtComplex( 0.0 );
203 t[2][3] = EvtComplex( 0.0 );
204 t[3][0] = EvtComplex( 0.0 );
205 t[3][1] = EvtComplex( 0.0 );
206 t[3][2] = EvtComplex( 0.0 );
207}

Referenced by EvtBHadronic::decay(), EvtSVPCP::decay(), EvtSVPHelAmp::decay(), EvtVVSPwave::decay(), and EvtTensor4C().

◆ trace()

EvtComplex EvtTensor4C::trace ( ) const
inline

Definition at line 121 of file EvtTensor4C.hh.

121{ return t[0][0] - t[1][1] - t[2][2] - t[3][3]; }

◆ zero()

void EvtTensor4C::zero ( )

Definition at line 170 of file EvtTensor4C.cc.

170 {
171 int i, j;
172 for ( i = 0; i < 4; i++ )
173 {
174 for ( j = 0; j < 4; j++ ) { t[i][j] = EvtComplex( 0.0, 0.0 ); }
175 }
176}

Referenced by EvtDiracSpinor::EvtLeptonTCurrent, and EvtDiracSpinor::EvtLeptonTg5Current.

◆ boostTo [1/2]

EvtTensor4C boostTo ( const EvtTensor4C & e,
const EvtVector3R boost )
friend

Definition at line 86 of file EvtTensor4C.cc.

86 {
87
88 EvtTensor4C tmp( rs );
89 tmp.applyBoostTo( boost );
90 return tmp;
91}

◆ boostTo [2/2]

EvtTensor4C boostTo ( const EvtTensor4C & e,
const EvtVector4R p4 )
friend

Definition at line 79 of file EvtTensor4C.cc.

79 {
80
81 EvtTensor4C tmp( rs );
82 tmp.applyBoostTo( p4 );
83 return tmp;
84}

◆ conj

EvtTensor4C conj ( const EvtTensor4C & t2)
friend

Definition at line 359 of file EvtTensor4C.cc.

359 {
360 EvtTensor4C temp;
361
362 int i, j;
363
364 for ( i = 0; i < 4; i++ )
365 {
366 for ( j = 0; j < 4; j++ ) { temp.set( i, j, ::conj( ( t2.get( i, j ) ) ) ); }
367 }
368
369 return temp;
370}

Referenced by conj.

◆ cont

EvtComplex cont ( const EvtTensor4C & t1,
const EvtTensor4C & t2 )
friend

Definition at line 271 of file EvtTensor4C.cc.

271 {
272
273 EvtComplex sum( 0.0, 0.0 );
274 int i, j;
275
276 for ( i = 0; i < 4; i++ )
277 {
278 for ( j = 0; j < 4; j++ ) { sum += t1.t[i][j] * t2.t[i][j]; }
279 }
280
281 return sum;
282}

◆ cont11

EvtTensor4C cont11 ( const EvtTensor4C & t1,
const EvtTensor4C & t2 )
friend

Definition at line 391 of file EvtTensor4C.cc.

391 {
392 EvtTensor4C temp;
393
394 int i, j;
395 EvtComplex c;
396
397 for ( i = 0; i < 4; i++ )
398 {
399 for ( j = 0; j < 4; j++ )
400 {
401 c = t1.get( 0, i ) * t2.get( 0, j ) - t1.get( 1, i ) * t2.get( 1, j ) -
402 t1.get( 2, i ) * t2.get( 2, j ) - t1.get( 3, i ) * t2.get( 3, j );
403 temp.set( i, j, c );
404 }
405 }
406
407 return temp;
408}

◆ cont22

EvtTensor4C cont22 ( const EvtTensor4C & t1,
const EvtTensor4C & t2 )
friend

Definition at line 372 of file EvtTensor4C.cc.

372 {
373 EvtTensor4C temp;
374
375 int i, j;
376 EvtComplex c;
377
378 for ( i = 0; i < 4; i++ )
379 {
380 for ( j = 0; j < 4; j++ )
381 {
382 c = t1.get( i, 0 ) * t2.get( j, 0 ) - t1.get( i, 1 ) * t2.get( j, 1 ) -
383 t1.get( i, 2 ) * t2.get( j, 2 ) - t1.get( i, 3 ) * t2.get( j, 3 );
384 temp.set( i, j, c );
385 }
386 }
387
388 return temp;
389}

◆ directProd [1/3]

EvtTensor4C directProd ( const EvtVector4C & c1,
const EvtVector4C & c2 )
friend

Definition at line 284 of file EvtTensor4C.cc.

284 {
285 EvtTensor4C temp;
286 int i, j;
287
288 for ( i = 0; i < 4; i++ )
289 {
290 for ( j = 0; j < 4; j++ ) { temp.set( i, j, c1.get( i ) * c2.get( j ) ); }
291 }
292 return temp;
293}

◆ directProd [2/3]

EvtTensor4C directProd ( const EvtVector4C & c1,
const EvtVector4R & c2 )
friend

Definition at line 295 of file EvtTensor4C.cc.

295 {
296 EvtTensor4C temp;
297 int i, j;
298
299 for ( i = 0; i < 4; i++ )
300 {
301 for ( j = 0; j < 4; j++ ) { temp.set( i, j, c1.get( i ) * c2.get( j ) ); }
302 }
303 return temp;
304}

◆ directProd [3/3]

EvtTensor4C directProd ( const EvtVector4R & c1,
const EvtVector4R & c2 )
friend

Definition at line 306 of file EvtTensor4C.cc.

306 {
307
308 EvtTensor4C temp;
309 int i, j;
310
311 for ( i = 0; i < 4; i++ )
312 {
313 for ( j = 0; j < 4; j++ ) { temp.t[i][j] = EvtComplex( c1.get( i ) * c2.get( j ), 0.0 ); }
314 }
315 return temp;
316}

◆ dual

EvtTensor4C dual ( const EvtTensor4C & t2)
friend

Definition at line 329 of file EvtTensor4C.cc.

329 {
330
331 EvtTensor4C temp;
332
333 temp.set( 0, 0, EvtComplex( 0.0, 0.0 ) );
334 temp.set( 1, 1, EvtComplex( 0.0, 0.0 ) );
335 temp.set( 2, 2, EvtComplex( 0.0, 0.0 ) );
336 temp.set( 3, 3, EvtComplex( 0.0, 0.0 ) );
337
338 temp.set( 0, 1, t2.get( 3, 2 ) - t2.get( 2, 3 ) );
339 temp.set( 0, 2, -t2.get( 3, 1 ) + t2.get( 1, 3 ) );
340 temp.set( 0, 3, t2.get( 2, 1 ) - t2.get( 1, 2 ) );
341
342 temp.set( 1, 2, -t2.get( 3, 0 ) + t2.get( 0, 3 ) );
343 temp.set( 1, 3, t2.get( 2, 0 ) - t2.get( 0, 2 ) );
344
345 temp.set( 2, 3, -t2.get( 1, 0 ) + t2.get( 0, 1 ) );
346
347 temp.set( 1, 0, -temp.get( 0, 1 ) );
348 temp.set( 2, 0, -temp.get( 0, 2 ) );
349 temp.set( 3, 0, -temp.get( 0, 3 ) );
350
351 temp.set( 2, 1, -temp.get( 1, 2 ) );
352 temp.set( 3, 1, -temp.get( 1, 3 ) );
353
354 temp.set( 3, 2, -temp.get( 2, 3 ) );
355
356 return temp;
357}

◆ operator* [1/4]

EvtTensor4C operator* ( const EvtComplex & c,
const EvtTensor4C & t1 )
friend

Definition at line 246 of file EvtTensor4C.cc.

246 {
247
248 return EvtTensor4C( t1 ) *= c;
249}

◆ operator* [2/4]

EvtTensor4C operator* ( const EvtTensor4C & t1,
const EvtComplex & c )
friend

Definition at line 241 of file EvtTensor4C.cc.

241 {
242
243 return EvtTensor4C( t1 ) *= c;
244}

◆ operator* [3/4]

EvtTensor4C operator* ( const EvtTensor4C & t1,
double d )
friend

Definition at line 261 of file EvtTensor4C.cc.

261 {
262
263 return EvtTensor4C( t1 ) *= EvtComplex( d, 0.0 );
264}

◆ operator* [4/4]

EvtTensor4C operator* ( double d,
const EvtTensor4C & t1 )
friend

Definition at line 266 of file EvtTensor4C.cc.

266 {
267
268 return EvtTensor4C( t1 ) *= EvtComplex( d, 0.0 );
269}

◆ operator+

EvtTensor4C operator+ ( const EvtTensor4C & t1,
const EvtTensor4C & t2 )
friend

Definition at line 107 of file EvtTensor4C.hh.

107 {
108
109 return EvtTensor4C( t1 ) += t2;
110}

◆ operator-

EvtTensor4C operator- ( const EvtTensor4C & t1,
const EvtTensor4C & t2 )
friend

Definition at line 112 of file EvtTensor4C.hh.

112 {
113
114 return EvtTensor4C( t1 ) -= t2;
115}

◆ operator<<

std::ostream & operator<< ( std::ostream & s,
const EvtTensor4C & t )
friend

◆ rotateEuler

EvtTensor4C rotateEuler ( const EvtTensor4C & e,
double alpha,
double beta,
double gamma )
friend

Definition at line 72 of file EvtTensor4C.cc.

72 {
73
74 EvtTensor4C tmp( rs );
75 tmp.applyRotateEuler( alpha, beta, gamma );
76 return tmp;
77}
alpha
double alpha
Definition EvtPhokharaDef.hh:17
The documentation for this class was generated from the following files: