BOSS 7.1.2
BESIII Offline Software System
Loading...
Searching...
No Matches
EvtGammaMatrix Class Reference

#include <EvtGammaMatrix.hh>

Public Member Functions

 EvtGammaMatrix ()
 
virtual ~EvtGammaMatrix ()
 
 EvtGammaMatrix (const EvtGammaMatrix &gm)
 
EvtGammaMatrixoperator= (const EvtGammaMatrix &gm)
 
void init ()
 
EvtGammaMatrixoperator+= (const EvtGammaMatrix &g)
 
EvtGammaMatrixoperator-= (const EvtGammaMatrix &g)
 
EvtGammaMatrixoperator*= (const EvtGammaMatrix &g)
 

Static Public Member Functions

static const EvtGammaMatrixg0 ()
 
static const EvtGammaMatrixg1 ()
 
static const EvtGammaMatrixg2 ()
 
static const EvtGammaMatrixg3 ()
 
static const EvtGammaMatrixg5 ()
 
static const EvtGammaMatrixid ()
 
static const EvtGammaMatrixva0 ()
 
static const EvtGammaMatrixva1 ()
 
static const EvtGammaMatrixva2 ()
 
static const EvtGammaMatrixva3 ()
 
static const EvtGammaMatrixv0 ()
 
static const EvtGammaMatrixv1 ()
 
static const EvtGammaMatrixv2 ()
 
static const EvtGammaMatrixv3 ()
 
static const EvtGammaMatrixsigmaUpper (unsigned int mu, unsigned int nu)
 
static const EvtGammaMatrixsigmaLower (unsigned int mu, unsigned int nu)
 

Friends

EvtGammaMatrix operator* (const EvtComplex &c, const EvtGammaMatrix &g)
 
EvtGammaMatrix operator* (const EvtGammaMatrix &g, const EvtComplex &c)
 
EvtGammaMatrix operator/ (const EvtGammaMatrix &g, const double d)
 
EvtDiracSpinor operator* (const EvtGammaMatrix &g, const EvtDiracSpinor &d)
 
EvtComplex operator* (const EvtDiracSpinor &d, const EvtDiracSpinor &dp)
 
EvtGammaMatrix operator+ (const EvtGammaMatrix &g1, const EvtGammaMatrix &g2)
 
EvtGammaMatrix operator- (const EvtGammaMatrix &g1, const EvtGammaMatrix &g2)
 
EvtGammaMatrix operator* (const EvtGammaMatrix &g1, const EvtGammaMatrix &g2)
 
std::ostream & operator<< (std::ostream &s, const EvtGammaMatrix &v)
 
EvtDiracSpinor EvtDiracSpinor::adjoint () const
 

Detailed Description

Definition at line 43 of file EvtGammaMatrix.hh.

Constructor & Destructor Documentation

◆ EvtGammaMatrix() [1/2]

EvtGammaMatrix::EvtGammaMatrix ( )

Definition at line 34 of file EvtGammaMatrix.cc.

34 {
35 int i,j;
36
37 for(i=0;i<4;i++){
38 for(j=0;j<4;j++){
39 gamma[i][j]=EvtComplex(0.0,0.0);
40 }
41 }
42}

◆ ~EvtGammaMatrix()

EvtGammaMatrix::~EvtGammaMatrix ( )
virtual

Definition at line 90 of file EvtGammaMatrix.cc.

90{}

◆ EvtGammaMatrix() [2/2]

EvtGammaMatrix::EvtGammaMatrix ( const EvtGammaMatrix & gm)

Definition at line 80 of file EvtGammaMatrix.cc.

80 {
81 int i,j;
82
83 for(i=0;i<4;i++){
84 for(j=0;j<4;j++){
85 gamma[i][j]=gm.gamma[i][j];
86 }
87 }
88}

Member Function Documentation

◆ g0()

const EvtGammaMatrix & EvtGammaMatrix::g0 ( )
static

Definition at line 235 of file EvtGammaMatrix.cc.

235 {
236
237 static EvtGammaMatrix g;
238 static int first=1;
239
240 if (first){
241
242 first=0;
243
244 int i,j;
245
246 for(i=0;i<4;i++){
247 for(j=0;j<4;j++){
248 g.gamma[i][j]=EvtComplex(0.0,0.0);
249 }
250 }
251
252 g.gamma[0][0]=EvtComplex(1.0,0.0);
253 g.gamma[1][1]=EvtComplex(1.0,0.0);
254 g.gamma[2][2]=EvtComplex(-1.0,0.0);
255 g.gamma[3][3]=EvtComplex(-1.0,0.0);
256 }
257
258 return g;
259
260}
Index first(Pair i)

Referenced by EvtDiracSpinor::adjoint(), EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtBsquark::decay(), sigmaLower(), sigmaUpper(), and slash().

◆ g1()

const EvtGammaMatrix & EvtGammaMatrix::g1 ( )
static

Definition at line 265 of file EvtGammaMatrix.cc.

265 {
266
267 static EvtGammaMatrix g;
268 static int first=1;
269
270 if (first){
271 first=0;
272 int i,j;
273
274 for(i=0;i<4;i++){
275 for(j=0;j<4;j++){
276 g.gamma[i][j]=EvtComplex(0.0,0.0);
277 }
278 }
279
280 g.gamma[0][3]=EvtComplex(1.0,0.0);
281 g.gamma[1][2]=EvtComplex(1.0,0.0);
282 g.gamma[2][1]=EvtComplex(-1.0,0.0);
283 g.gamma[3][0]=EvtComplex(-1.0,0.0);
284 }
285
286 return g;
287
288}

Referenced by EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtBsquark::decay(), sigmaLower(), sigmaUpper(), and slash().

◆ g2()

const EvtGammaMatrix & EvtGammaMatrix::g2 ( )
static

Definition at line 293 of file EvtGammaMatrix.cc.

293 {
294
295 static EvtGammaMatrix g;
296 static int first=1;
297
298 if (first){
299 first=0;
300 int i,j;
301
302 for(i=0;i<4;i++){
303 for(j=0;j<4;j++){
304 g.gamma[i][j]=EvtComplex(0.0,0.0);
305 }
306 }
307
308 g.gamma[0][3]=EvtComplex(0.0,-1.0);
309 g.gamma[1][2]=EvtComplex(0.0,1.0);
310 g.gamma[2][1]=EvtComplex(0.0,1.0);
311 g.gamma[3][0]=EvtComplex(0.0,-1.0);
312 }
313
314 return g;
315
316}

Referenced by EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtBsquark::decay(), sigmaLower(), sigmaUpper(), and slash().

◆ g3()

const EvtGammaMatrix & EvtGammaMatrix::g3 ( )
static

Definition at line 322 of file EvtGammaMatrix.cc.

322 {
323
324 static EvtGammaMatrix g;
325 static int first=1;
326
327 if (first){
328 first=0;
329 int i,j;
330
331 for(i=0;i<4;i++){
332 for(j=0;j<4;j++){
333 g.gamma[i][j]=EvtComplex(0.0,0.0);
334 }
335 }
336
337 g.gamma[0][2]=EvtComplex(1.0,0.0);
338 g.gamma[1][3]=EvtComplex(-1.0,0.0);
339 g.gamma[2][0]=EvtComplex(-1.0,0.0);
340 g.gamma[3][1]=EvtComplex(1.0,0.0);
341 }
342
343 return g;
344
345}

Referenced by EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtBsquark::decay(), sigmaLower(), sigmaUpper(), and slash().

◆ g5()

const EvtGammaMatrix & EvtGammaMatrix::g5 ( )
static

Definition at line 350 of file EvtGammaMatrix.cc.

350 {
351
352 static EvtGammaMatrix g;
353 static int first=1;
354
355 if (first){
356
357 int i,j;
358
359 for(i=0;i<4;i++){
360 for(j=0;j<4;j++){
361 g.gamma[i][j]=EvtComplex(0.0,0.0);
362 }
363 }
364
365 g.gamma[0][2]=EvtComplex(1.0,0.0);
366 g.gamma[1][3]=EvtComplex(1.0,0.0);
367 g.gamma[2][0]=EvtComplex(1.0,0.0);
368 g.gamma[3][1]=EvtComplex(1.0,0.0);
369 }
370
371 return g;
372
373}

Referenced by EvtSemiLeptonicBaryonAmp::CalcAmp(), EvtBsquark::decay(), and EvtLambdaP_BarGamma::decay().

◆ id()

const EvtGammaMatrix & EvtGammaMatrix::id ( )
static

Definition at line 491 of file EvtGammaMatrix.cc.

491 {
492
493 static EvtGammaMatrix g;
494 static int first=1;
495
496 if (first){
497
498 int i,j;
499
500 for(i=0;i<4;i++){
501 for(j=0;j<4;j++){
502 g.gamma[i][j]=EvtComplex(0.0,0.0);
503 }
504 }
505
506 g.gamma[0][0]=EvtComplex(1.0,0.0);
507 g.gamma[1][1]=EvtComplex(1.0,0.0);
508 g.gamma[2][2]=EvtComplex(1.0,0.0);
509 g.gamma[3][3]=EvtComplex(1.0,0.0);
510 }
511
512 return g;
513
514}

Referenced by EvtBsquark::decay(), and EvtLambdaP_BarGamma::decay().

◆ init()

void EvtGammaMatrix::init ( )

Definition at line 103 of file EvtGammaMatrix.cc.

103 {
104 int i,j;
105
106 for(i=0;i<4;i++){
107 for(j=0;j<4;j++){
108 gamma[i][j]=EvtComplex(0.0,0.0);
109 }
110 }
111}

Referenced by sigmaUpper().

◆ operator*=()

EvtGammaMatrix & EvtGammaMatrix::operator*= ( const EvtGammaMatrix & g)

Definition at line 549 of file EvtGammaMatrix.cc.

549 {
550
551 int i,j,k;
552 EvtGammaMatrix temp;
553
554 for(i=0;i<4;i++){
555 for(j=0;j<4;j++){
556 temp.gamma[i][j]=EvtComplex(0.0,0.0);
557 for(k=0;k<4;k++){
558 temp.gamma[i][j]+=gamma[i][k]*g.gamma[k][j];
559 }
560 }
561 }
562
563 for(i=0;i<4;i++){
564 for(j=0;j<4;j++){
565 gamma[i][j]=temp.gamma[i][j];
566 }
567 }
568
569 return *this;
570}

◆ operator+=()

EvtGammaMatrix & EvtGammaMatrix::operator+= ( const EvtGammaMatrix & g)

Definition at line 519 of file EvtGammaMatrix.cc.

519 {
520
521 int i,j;
522
523 for(i=0;i<4;i++){
524 for(j=0;j<4;j++){
525 gamma[i][j]+=g.gamma[i][j];
526 }
527 }
528 return *this;
529}

◆ operator-=()

EvtGammaMatrix & EvtGammaMatrix::operator-= ( const EvtGammaMatrix & g)

Definition at line 535 of file EvtGammaMatrix.cc.

535 {
536
537 int i,j;
538
539 for(i=0;i<4;i++){
540 for(j=0;j<4;j++){
541 gamma[i][j]-=g.gamma[i][j];
542 }
543 }
544 return *this;
545}

◆ operator=()

EvtGammaMatrix & EvtGammaMatrix::operator= ( const EvtGammaMatrix & gm)

Definition at line 92 of file EvtGammaMatrix.cc.

92 {
93 int i,j;
94
95 for(i=0;i<4;i++){
96 for(j=0;j<4;j++){
97 gamma[i][j]=gm.gamma[i][j];
98 }
99 }
100 return *this;
101}

◆ sigmaLower()

const EvtGammaMatrix & EvtGammaMatrix::sigmaLower ( unsigned int mu,
unsigned int nu )
static

Definition at line 646 of file EvtGammaMatrix.cc.

647{
648 const EvtComplex I(0, 1);
649 EvtGammaMatrix a, b;
650 static EvtGammaMatrix sigma[4][4];
651 static bool hasBeenCalled = false;
652 static const EvtTensor4C eta = EvtTensor4C::g();
653
654 if (!hasBeenCalled) // has to be initialized only at the first call
655 {
656 // lower index
657 for (int i=0; i<4; ++i)
658 {
659 a = eta.get(i, 0)*g0() + eta.get(i, 1)*g1() + eta.get(i, 2)*g2() + eta.get(i, 3)*g3();
660 for (int j=0; j<4; ++j)
661 {
662 b = eta.get(j, 0)*g0() + eta.get(j, 1)*g1() + eta.get(j, 2)*g2() + eta.get(j, 3)*g3();
663 sigma[i][j] = I/2 * (a*b - b*a);
664 }
665 }
666 }
667 return sigma[mu][nu];
668}
TTree * sigma
const DifComplex I
static const EvtGammaMatrix & g0()
static const EvtGammaMatrix & g2()
static const EvtGammaMatrix & g1()
static const EvtGammaMatrix & g3()
const EvtComplex & get(int i, int j) const
static const EvtTensor4C & g()
const double b
Definition slope.cxx:9

Referenced by EvtLambdaP_BarGamma::decay().

◆ sigmaUpper()

const EvtGammaMatrix & EvtGammaMatrix::sigmaUpper ( unsigned int mu,
unsigned int nu )
static

Definition at line 604 of file EvtGammaMatrix.cc.

605{
606 EvtGammaMatrix a, b;
607 static const EvtTensor4C eta = EvtTensor4C::g(); //metric
608 static EvtGammaMatrix sigma[4][4];
609 static bool hasBeenCalled = false;
610 if (!hasBeenCalled)
611 {
612 EvtComplex I(0, 1);
613 for (int i=0; i<4; ++i)
614 sigma[i][i].init(); // set to 0
615
616 EvtGammaMatrix s01 = I/2 * (g0()*g1() - g1()*g0());
617 EvtGammaMatrix s02 = I/2 * (g0()*g2() - g2()*g0());
618 EvtGammaMatrix s03 = I/2 * (g0()*g3() - g3()*g0());
619 EvtGammaMatrix s12 = I/2 * (g1()*g2() - g2()*g1());
620 EvtGammaMatrix s13 = I/2 * (g1()*g3() - g3()*g1());
621 EvtGammaMatrix s23 = I/2 * (g2()*g3() - g3()*g2());
622 sigma[0][1] = s01;
623 sigma[1][0] = -1*s01;
624 sigma[0][2] = s02;
625 sigma[2][0] = -1*s02;
626 sigma[0][3] = s03;
627 sigma[3][0] = -1*s03;
628 sigma[1][2] = s12;
629 sigma[2][1] = -1*s12;
630 sigma[1][3] = s13;
631 sigma[3][1] = -1*s13;
632 sigma[2][3] = s23;
633 sigma[3][2] = -1*s23;
634 }
635 hasBeenCalled = true;
636
637 if (mu > 3 || nu > 3)
638 {
639 report(ERROR, "EvtSigmaTensor") << "Expected index between 0 and 3, but found " << nu << "!" << endl;
640 assert(0);
641 }
642 return sigma[mu][nu];
643
644}
ostream & report(Severity severity, const char *facility)
Definition EvtReport.cc:36
@ ERROR
Definition EvtReport.hh:49
double double double double * s12
Definition qcdloop1.h:77
double double double double double * s23
Definition qcdloop1.h:77

◆ v0()

const EvtGammaMatrix & EvtGammaMatrix::v0 ( )
static

Definition at line 377 of file EvtGammaMatrix.cc.

377 {
378
379 static EvtGammaMatrix g;
380 static int first=1;
381
382 if (first){
383
384 int i,j;
385
386 for(i=0;i<4;i++){
387 for(j=0;j<4;j++){
388 g.gamma[i][j]=EvtComplex(0.0,0.0);
389 }
390 }
391
392 g.gamma[0][0]=EvtComplex(1.0,0.0);
393 g.gamma[1][1]=EvtComplex(1.0,0.0);
394 g.gamma[2][2]=EvtComplex(1.0,0.0);
395 g.gamma[3][3]=EvtComplex(1.0,0.0);
396 }
397
398 return g;
399
400}

◆ v1()

const EvtGammaMatrix & EvtGammaMatrix::v1 ( )
static

Definition at line 406 of file EvtGammaMatrix.cc.

406 {
407
408 static EvtGammaMatrix g;
409 static int first=1;
410
411 if (first){
412
413 int i,j;
414
415 for(i=0;i<4;i++){
416 for(j=0;j<4;j++){
417 g.gamma[i][j]=EvtComplex(0.0,0.0);
418 }
419 }
420
421 g.gamma[0][3]=EvtComplex(1.0,0.0);
422 g.gamma[1][2]=EvtComplex(1.0,0.0);
423 g.gamma[2][1]=EvtComplex(1.0,0.0);
424 g.gamma[3][0]=EvtComplex(1.0,0.0);
425 }
426
427 return g;
428
429}

◆ v2()

const EvtGammaMatrix & EvtGammaMatrix::v2 ( )
static

Definition at line 434 of file EvtGammaMatrix.cc.

434 {
435
436 static EvtGammaMatrix g;
437 static int first=1;
438
439 if (first){
440
441 int i,j;
442
443 for(i=0;i<4;i++){
444 for(j=0;j<4;j++){
445 g.gamma[i][j]=EvtComplex(0.0,0.0);
446 }
447 }
448
449 g.gamma[0][3]=EvtComplex(0.0,-1.0);
450 g.gamma[1][2]=EvtComplex(0.0,1.0);
451 g.gamma[2][1]=EvtComplex(0.0,-1.0);
452 g.gamma[3][0]=EvtComplex(0.0,1.0);
453 }
454
455 return g;
456
457}

◆ v3()

const EvtGammaMatrix & EvtGammaMatrix::v3 ( )
static

Definition at line 462 of file EvtGammaMatrix.cc.

462 {
463
464 static EvtGammaMatrix g;
465 static int first=1;
466
467 if (first){
468
469 int i,j;
470
471 for(i=0;i<4;i++){
472 for(j=0;j<4;j++){
473 g.gamma[i][j]=EvtComplex(0.0,0.0);
474 }
475 }
476
477 g.gamma[0][2]=EvtComplex(1.0,0.0);
478 g.gamma[1][3]=EvtComplex(-1.0,0.0);
479 g.gamma[2][0]=EvtComplex(1.0,0.0);
480 g.gamma[3][1]=EvtComplex(-1.0,0.0);
481 }
482
483 return g;
484
485}

◆ va0()

const EvtGammaMatrix & EvtGammaMatrix::va0 ( )
static

Definition at line 113 of file EvtGammaMatrix.cc.

113 {
114
115 static EvtGammaMatrix g;
116 static int first=1;
117
118 if (first){
119 g.gamma[0][0]=EvtComplex(1.0,0.0);
120 g.gamma[0][1]=EvtComplex(0.0,0.0);
121 g.gamma[0][2]=EvtComplex(-1.0,0.0);
122 g.gamma[0][3]=EvtComplex(0.0,0.0);
123 g.gamma[1][0]=EvtComplex(0.0,0.0);
124 g.gamma[1][1]=EvtComplex(1.0,0.0);
125 g.gamma[1][2]=EvtComplex(0.0,0.0);
126 g.gamma[1][3]=EvtComplex(-1.0,0.0);
127 g.gamma[2][0]=EvtComplex(-1.0,0.0);
128 g.gamma[2][1]=EvtComplex(0.0,0.0);
129 g.gamma[2][2]=EvtComplex(1.0,0.0);
130 g.gamma[2][3]=EvtComplex(0.0,0.0);
131 g.gamma[3][0]=EvtComplex(0.0,0.0);
132 g.gamma[3][1]=EvtComplex(-1.0,0.0);
133 g.gamma[3][2]=EvtComplex(0.0,0.0);
134 g.gamma[3][3]=EvtComplex(1.0,0.0);
135 }
136
137 return g;
138
139}

◆ va1()

const EvtGammaMatrix & EvtGammaMatrix::va1 ( )
static

Definition at line 142 of file EvtGammaMatrix.cc.

142 {
143
144 static EvtGammaMatrix g;
145 static int first=1;
146
147 if (first){
148 g.gamma[0][0]=EvtComplex(0.0,0.0);
149 g.gamma[0][1]=EvtComplex(-1.0,0.0);
150 g.gamma[0][2]=EvtComplex(0.0,0.0);
151 g.gamma[0][3]=EvtComplex(1.0,0.0);
152 g.gamma[1][0]=EvtComplex(-1.0,0.0);
153 g.gamma[1][1]=EvtComplex(0.0,0.0);
154 g.gamma[1][2]=EvtComplex(1.0,0.0);
155 g.gamma[1][3]=EvtComplex(0.0,0.0);
156 g.gamma[2][0]=EvtComplex(0.0,0.0);
157 g.gamma[2][1]=EvtComplex(1.0,0.0);
158 g.gamma[2][2]=EvtComplex(0.0,0.0);
159 g.gamma[2][3]=EvtComplex(-1.0,0.0);
160 g.gamma[3][0]=EvtComplex(1.0,0.0);
161 g.gamma[3][1]=EvtComplex(0.0,0.0);
162 g.gamma[3][2]=EvtComplex(-1.0,0.0);
163 g.gamma[3][3]=EvtComplex(0.0,0.0);
164 }
165
166 return g;
167
168}

◆ va2()

const EvtGammaMatrix & EvtGammaMatrix::va2 ( )
static

Definition at line 172 of file EvtGammaMatrix.cc.

172 {
173
174 static EvtGammaMatrix g;
175 static int first=1;
176
177 if (first){
178 g.gamma[0][0]=EvtComplex(0.0,0.0);
179 g.gamma[0][1]=EvtComplex(0.0,1.0);
180 g.gamma[0][2]=EvtComplex(0.0,0.0);
181 g.gamma[0][3]=EvtComplex(0.0,-1.0);
182 g.gamma[1][0]=EvtComplex(0.0,-1.0);
183 g.gamma[1][1]=EvtComplex(0.0,0.0);
184 g.gamma[1][2]=EvtComplex(0.0,1.0);
185 g.gamma[1][3]=EvtComplex(0.0,0.0);
186 g.gamma[2][0]=EvtComplex(0.0,0.0);
187 g.gamma[2][1]=EvtComplex(0.0,-1.0);
188 g.gamma[2][2]=EvtComplex(0.0,0.0);
189 g.gamma[2][3]=EvtComplex(0.0,1.0);
190 g.gamma[3][0]=EvtComplex(0.0,1.0);
191 g.gamma[3][1]=EvtComplex(0.0,0.0);
192 g.gamma[3][2]=EvtComplex(0.0,-1.0);
193 g.gamma[3][3]=EvtComplex(0.0,0.0);
194 }
195
196 return g;
197
198}

◆ va3()

const EvtGammaMatrix & EvtGammaMatrix::va3 ( )
static

Definition at line 203 of file EvtGammaMatrix.cc.

203 {
204
205 static EvtGammaMatrix g;
206 static int first=1;
207
208 if (first){
209 g.gamma[0][0]=EvtComplex(-1.0,0.0);
210 g.gamma[0][1]=EvtComplex(0.0,0.0);
211 g.gamma[0][2]=EvtComplex(1.0,0.0);
212 g.gamma[0][3]=EvtComplex(0.0,0.0);
213 g.gamma[1][0]=EvtComplex(0.0,0.0);
214 g.gamma[1][1]=EvtComplex(1.0,0.0);
215 g.gamma[1][2]=EvtComplex(0.0,0.0);
216 g.gamma[1][3]=EvtComplex(-1.0,0.0);
217 g.gamma[2][0]=EvtComplex(1.0,0.0);
218 g.gamma[2][1]=EvtComplex(0.0,0.0);
219 g.gamma[2][2]=EvtComplex(-1.0,0.0);
220 g.gamma[2][3]=EvtComplex(0.0,0.0);
221 g.gamma[3][0]=EvtComplex(0.0,0.0);
222 g.gamma[3][1]=EvtComplex(-1.0,0.0);
223 g.gamma[3][2]=EvtComplex(0.0,0.0);
224 g.gamma[3][3]=EvtComplex(1.0,0.0);
225 }
226
227 return g;
228
229}

Friends And Related Symbol Documentation

◆ EvtDiracSpinor::adjoint

◆ operator* [1/5]

EvtGammaMatrix operator* ( const EvtComplex & c,
const EvtGammaMatrix & g )
friend

Definition at line 50 of file EvtGammaMatrix.cc.

50 {
51 int i,j;
52
53 EvtGammaMatrix temp;
54
55 for(i=0;i<4;i++){
56 for(j=0;j<4;j++){
57 temp.gamma[i][j]=g.gamma[i][j]*c;
58 }
59 }
60
61 return temp;
62
63}

◆ operator* [2/5]

EvtComplex operator* ( const EvtDiracSpinor & d,
const EvtDiracSpinor & dp )
friend

Definition at line 589 of file EvtGammaMatrix.cc.

589 {
590
591 int i;
592 EvtComplex temp;
593
594 temp=EvtComplex(0.0,0.0);
595
596 for(i=0;i<4;i++){
597 temp+=::conj(d.get_spinor(i))*dp.get_spinor(i);
598 }
599 return temp;
600}
Evt3Rank3C conj(const Evt3Rank3C &t2)
const EvtComplex & get_spinor(int i) const

◆ operator* [3/5]

EvtGammaMatrix operator* ( const EvtGammaMatrix & g,
const EvtComplex & c )
friend

Definition at line 44 of file EvtGammaMatrix.cc.

45{
46 return c*g;
47}

◆ operator* [4/5]

EvtDiracSpinor operator* ( const EvtGammaMatrix & g,
const EvtDiracSpinor & d )
friend

Definition at line 573 of file EvtGammaMatrix.cc.

573 {
574
575 int i,j;
576 EvtDiracSpinor temp;
577
578 for(i=0;i<4;i++){
579 temp.set_spinor(i,EvtComplex(0.0,0.0));
580 for(j=0;j<4;j++){
581 temp.set_spinor(i,temp.get_spinor(i)+g.gamma[i][j]*d.get_spinor(j));
582 }
583 }
584
585 return temp;
586}
void set_spinor(int i, const EvtComplex &sp)

◆ operator* [5/5]

EvtGammaMatrix operator* ( const EvtGammaMatrix & g1,
const EvtGammaMatrix & g2 )
friend

Definition at line 100 of file EvtGammaMatrix.hh.

100 {
101 return EvtGammaMatrix(g1)*=g2;
102}

◆ operator+

EvtGammaMatrix operator+ ( const EvtGammaMatrix & g1,
const EvtGammaMatrix & g2 )
friend

Definition at line 92 of file EvtGammaMatrix.hh.

92 {
93 return EvtGammaMatrix(g1)+=g2;
94}

◆ operator-

EvtGammaMatrix operator- ( const EvtGammaMatrix & g1,
const EvtGammaMatrix & g2 )
friend

Definition at line 96 of file EvtGammaMatrix.hh.

96 {
97 return EvtGammaMatrix(g1)-=g2;
98}

◆ operator/

EvtGammaMatrix operator/ ( const EvtGammaMatrix & g,
const double d )
friend

Definition at line 104 of file EvtGammaMatrix.hh.

105{
106 return g * EvtComplex(1/d,0);
107}

◆ operator<<

std::ostream & operator<< ( std::ostream & s,
const EvtGammaMatrix & v )
friend

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