BOSS 7.0.6
BESIII Offline Software System
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Friends | List of all members
EvtGammaMatrix Class Reference

#include <EvtGammaMatrix.hh>

Public Member Functions

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

Static Public Member Functions

static const EvtGammaMatrix & g0 ()
 
static const EvtGammaMatrix & g1 ()
 
static const EvtGammaMatrix & g2 ()
 
static const EvtGammaMatrix & g3 ()
 
static const EvtGammaMatrix & g5 ()
 
static const EvtGammaMatrix & id ()
 
static const EvtGammaMatrix & va0 ()
 
static const EvtGammaMatrix & va1 ()
 
static const EvtGammaMatrix & va2 ()
 
static const EvtGammaMatrix & va3 ()
 
static const EvtGammaMatrix & v0 ()
 
static const EvtGammaMatrix & v1 ()
 
static const EvtGammaMatrix & v2 ()
 
static const EvtGammaMatrix & v3 ()
 
static const EvtGammaMatrix & sigmaUpper (unsigned int mu, unsigned int nu)
 
static const EvtGammaMatrix & sigmaLower (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}
EvtCyclic3::first
Index first(Pair i)
Definition: EvtCyclic3.cc:195

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}
sigma
TTree * sigma
Definition: CurConst_dEdXCal.cxx:6
I
const DifComplex I
EvtGammaMatrix::g0
static const EvtGammaMatrix & g0()
Definition: EvtGammaMatrix.cc:235
EvtGammaMatrix::g2
static const EvtGammaMatrix & g2()
Definition: EvtGammaMatrix.cc:293
EvtGammaMatrix::g1
static const EvtGammaMatrix & g1()
Definition: EvtGammaMatrix.cc:265
EvtGammaMatrix::g3
static const EvtGammaMatrix & g3()
Definition: EvtGammaMatrix.cc:322
EvtTensor4C::get
const EvtComplex & get(int i, int j) const
Definition: EvtTensor4C.hh:126
EvtTensor4C::g
static const EvtTensor4C & g()
Definition: EvtTensor4C.cc:47
b
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}
report
ostream & report(Severity severity, const char *facility)
Definition: EvtReport.cc:36
ERROR
@ ERROR
Definition: EvtReport.hh:49

◆ 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 Function Documentation

◆ EvtDiracSpinor::adjoint

EvtDiracSpinor EvtDiracSpinor::adjoint ( ) const
friend

◆ 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}
conj
Evt3Rank3C conj(const Evt3Rank3C &t2)
Definition: Evt3Rank3C.cc:175
EvtDiracSpinor::get_spinor
const EvtComplex & get_spinor(int i) const
Definition: EvtDiracSpinor.cc:60

◆ 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}
EvtDiracSpinor::set_spinor
void set_spinor(int i, const EvtComplex &sp)
Definition: EvtDiracSpinor.cc:46

◆ 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: