DevelopmentPage/BeyondProjects: test_helasamp.py

File test_helasamp.py, 78.0 KB (added by Olivier Mattelaer, 14 years ago)
Line 
1################################################################################
2#
3# Copyright (c) 2009 The MadGraph Development team and Contributors
4#
5# This file is a part of the MadGraph 5 project, an application which
6# automatically generates Feynman diagrams and matrix elements for arbitrary
7# high-energy processes in the Standard Model and beyond.
8#
9# It is subject to the MadGraph license which should accompany this
10# distribution.
11#
12# For more information, please visit: http://madgraph.phys.ucl.ac.be
13#
14################################################################################
15"""Unit test Library for testing the Creation of Helas Amplitude created from
16the output of the Feynman Rules."""
17from __future__ import division
18import unittest
19import madgraph.interface.helasamp_object as HelasObject
20import madgraph.interface.helasamp_lib as HelasLib
21
22
23class TestVariable(unittest.TestCase):
24
25 def setUp(self):
26 self.var1 = HelasLib.Variable(2, 5, 'var1')
27 self.var2 = HelasLib.Variable(3, 7, 'var2')
28 self.var3 = HelasLib.Variable(11, 13, 'var3')
29
30
31 def testsumvarvar (self):
32 """ test the sum of two Variable Object"""
33
34 #Sum of Two Variable
35 sum = self.var1 + self.var2
36
37 #check sanity
38 self.assertEquals(sum.__class__,HelasLib.AddVariable)
39 self.assertTrue(self.var1 in sum)
40 self.assertTrue(self.var2 in sum)
41 self.assertEquals(len(sum),2)
42
43 #test prefactor, constant term treatment
44 self.assertEquals(sum.prefactor,1)
45 self.assertEquals(sum.constant_term,12)
46 self.assertTrue(self.var1 in sum)
47 for term in sum:
48 if term == self.var1:
49 self.assertEqual(term.prefactor, 2)
50 self.assertEqual(term.constant_term, 0)
51 elif term == self.var1:
52 self.assertEqual(term.prefactor, 3)
53 self.assertEqual(term.constant_term, 0)
54
55 self.assertEquals(self.var1.constant_term, 5) #constant term pass in sum
56 self.assertEquals(self.var2.constant_term, 7)
57 self.assertEquals(self.var1.prefactor, 2) #prefactor is preserve
58 self.assertEquals(self.var2.prefactor, 3)
59
60 def testrsumvarvar (self):
61 """ test the sum of two Variable Object (inverse order)"""
62
63 #Sum of Two Variable
64 sum = self.var2 + self.var1
65 #check sanity
66 self.assertEquals(sum.__class__,HelasLib.AddVariable)
67 self.assertTrue(self.var1 in sum)
68 self.assertTrue(self.var2 in sum)
69 self.assertEquals(len(sum),2)
70
71 #test prefactor, constant term treatment
72 self.assertEquals(sum.prefactor,1)
73 self.assertEquals(sum.constant_term,12)
74 self.assertTrue(self.var1 in sum)
75 for term in sum:
76 if term == self.var1:
77 self.assertEqual(term.prefactor, 2)
78 self.assertEqual(term.constant_term, 0)
79 elif term == self.var1:
80 self.assertEqual(term.prefactor, 3)
81 self.assertEqual(term.constant_term, 0)
82
83 self.assertEquals(self.var1.constant_term,5) #constant term pass in sum
84 self.assertEquals(self.var2.constant_term,7)
85 self.assertEquals(self.var1.prefactor,2) #prefactor is preserve
86 self.assertEquals(self.var2.prefactor,3)
87
88 def testsumvarint(self):
89 """ test the sum of one Variable with an integer"""
90
91 sum = self.var1 + 4
92 sum2 = 4 + self.var1
93
94 #check sanity
95 self.assertEquals(sum.__class__,HelasLib.Variable)
96 self.assertEquals(sum2.__class__,HelasLib.Variable)
97 self.assertFalse(self.var1 is sum2)
98 self.assertFalse(self.var1 is sum)
99
100 #test prefactor, constant term treatment
101 self.assertEquals(sum.prefactor,2)
102 self.assertEquals(sum.constant_term,9)
103 self.assertEquals(sum2.prefactor,2)
104 self.assertEquals(sum2.constant_term,9)
105 self.assertEquals(self.var1.prefactor,2)
106 self.assertEquals(self.var1.constant_term,5)
107
108 def testsumvaradd(self):
109 """ test the sum of one Variable with an AddVariable"""
110
111 add = HelasLib.AddVariable()
112 add.append(self.var1)
113 add.append(self.var2)
114
115 sum = self.var3 + add
116
117 self.assertEquals(sum.__class__,HelasLib.AddVariable)
118 self.assertTrue(self.var3 in sum)
119 self.assertEquals(len(sum), 3)
120 for data in sum:
121 if data == self.var3:
122 self.assertTrue(data is self.var3)
123
124 #test prefactor- constant_term
125 self.assertEquals(sum.prefactor, 1)
126 self.assertEquals(sum.constant_term, 25)
127 self.assertEquals(self.var1.prefactor,2)
128 self.assertEquals(self.var1.constant_term,0)
129
130
131 def testsumvarmult(self):
132 """ test the sum of one Variable with an MultVariable"""
133
134 mult = HelasLib.MultVariable()
135 mult.append(self.var1)
136 mult.append(self.var2)
137 mult.constant_term = -5
138
139 sum = self.var3 + mult
140
141 self.assertEquals(sum.__class__,HelasLib.AddVariable)
142 self.assertTrue(self.var3 in sum)
143 self.assertEquals(len(sum), 2)
144 for data in sum:
145 if data == self.var3:
146 self.assertFalse(data is self.var3)
147 self.assertEqual(data.prefactor, self.var3.prefactor)
148 self.assertEqual(data.constant_term, 0)
149
150 #test prefactor- constant_term
151 self.assertEquals(sum.prefactor, 1)
152 self.assertEquals(sum.constant_term, 8)
153 self.assertEquals(self.var3.prefactor, 11)
154 self.assertEquals(self.var3.constant_term, 13)
155
156 def testmultvarvar(self):
157 """product of Two Variable"""
158
159 prod = self.var1 * self.var2
160
161 #check sanity
162 self.assertEquals(prod.__class__,HelasLib.AddVariable)
163 self.assertTrue(self.var1 in prod) # presence of single term
164 self.assertTrue(self.var2 in prod) # presence of single term
165 self.assertEquals(len(prod),3)
166
167 #test the presence of quad_term
168 prod_class = [fact.__class__ for fact in prod]
169 self.assertTrue(HelasLib.MultVariable in prod_class)
170
171 #test each part
172 for term in prod:
173 if term == self.var1:
174 self.assertEquals(term.prefactor,14)
175 self.assertEquals(term.constant_term,0)
176 elif term == self.var2:
177 self.assertEquals(term.prefactor,15)
178 self.assertEquals(term.constant_term,0)
179 elif term.__class__ is HelasLib.MultVariable:
180 self.assertEquals(term.prefactor,6)
181 self.assertEquals(term.constant_term,0)
182 self.assertEquals(len(term),2)
183 self.assertTrue(self.var1 in term)
184 self.assertTrue(self.var2 in term)
185 else:
186 raise Exception
187
188 #test prefactor, constant term treatment
189 self.assertEquals(prod.prefactor,1)
190 self.assertEquals(prod.constant_term,35)
191
192 def testrmultvarvar(self):
193 """product of Two Variable"""
194
195 prod = self.var2 * self.var1
196
197 #check sanity
198 self.assertEquals(prod.__class__,HelasLib.AddVariable)
199 self.assertTrue(self.var1 in prod) # presence of single term
200 self.assertTrue(self.var2 in prod) # presence of single term
201 self.assertEquals(len(prod),3)
202
203 #test the presence of quad_term
204 prod_class = [fact.__class__ for fact in prod]
205 self.assertTrue(HelasLib.MultVariable in prod_class)
206
207 #test each part
208 for term in prod:
209 if term == self.var1:
210 self.assertEquals(term.prefactor,14)
211 self.assertEquals(term.constant_term,0)
212 elif term == self.var2:
213 self.assertEquals(term.prefactor,15)
214 self.assertEquals(term.constant_term,0)
215 elif term.__class__ is HelasLib.MultVariable:
216 self.assertEquals(term.prefactor,6)
217 self.assertEquals(term.constant_term,0)
218 self.assertEquals(len(term),2)
219 self.assertTrue(self.var1 in term)
220 self.assertTrue(self.var2 in term)
221 else:
222 raise Exception
223
224 #test prefactor, constant term treatment
225 self.assertEquals(prod.prefactor,1)
226 self.assertEquals(prod.constant_term,35)
227
228
229
230 def testmultvarvar2(self):
231 """product of Two Variable (one var without constant_term)"""
232
233 self.var2.constant_term = 0
234 prod = self.var1 * self.var2
235
236 #check sanity
237 self.assertEquals(prod.__class__,HelasLib.AddVariable)
238 self.assertFalse(self.var1 in prod) # presence of single term
239 self.assertTrue(self.var2 in prod) # presence of single term
240 self.assertEquals(len(prod),2)
241
242 #test the presence of quad_term
243 prod_class = [fact.__class__ for fact in prod]
244 self.assertTrue(HelasLib.MultVariable in prod_class)
245
246 #test each part
247 for term in prod:
248 if term == self.var2:
249 self.assertEquals(term.prefactor,15)
250 self.assertEquals(term.constant_term,0)
251 elif term.__class__ is HelasLib.MultVariable:
252 self.assertEquals(term.prefactor,6)
253 self.assertEquals(term.constant_term,0)
254 self.assertEquals(len(term),2)
255 self.assertTrue(self.var1 in term)
256 self.assertTrue(self.var2 in term)
257
258 #test prefactor, constant term treatment
259 self.assertEquals(prod.prefactor,1)
260 self.assertEquals(prod.constant_term,0)
261
262 def testmultvarvar3(self):
263 """product of Two Variable (both var without constant_term)"""
264
265 self.var1.constant_term = 0
266 self.var2.constant_term = 0
267 prod = self.var1 * self.var2
268
269 #check sanity
270 self.assertEquals(prod.__class__,HelasLib.MultVariable)
271 self.assertTrue(self.var1 in prod) # presence of single term
272 self.assertTrue(self.var2 in prod) # presence of single term
273 self.assertEquals(len(prod),2)
274
275
276 self.assertEquals(prod.prefactor,6)
277 self.assertEquals(prod.constant_term,0)
278
279
280 def testmultvarAdd(self):
281 """product of Variable with an AddVariable"""
282
283 add = self.var1 + self.var2
284 prod = self.var3 * add
285 #sanity check
286 self.assertEquals(prod.__class__, HelasLib.AddVariable)
287 self.assertEquals(len(prod), 5)
288
289 #check prefactor of each term
290 for term in prod:
291 if term == self.var1:
292 self.assertEquals(term.prefactor, 26)
293 elif term == self.var2:
294 self.assertEquals(term.prefactor, 39)
295 elif term == self.var3:
296 self.assertEquals(term.prefactor, 132)
297 elif self.var1 not in term:
298 self.assertEquals(term.prefactor, 33)
299 elif self.var2 not in term:
300 self.assertEquals(term.prefactor, 22)
301 else:
302 raise Exception('not valid term')
303
304 self.assertEquals(prod.constant_term, 156)
305
306
307 def testmultvarMult(self):
308 """product of Variable with an MultVariable"""
309
310 var1 = HelasLib.Variable(2)
311 var2 = HelasLib.Variable(3,0,'y')
312 mult = HelasLib.MultVariable()
313 mult.append(var1)
314 mult.append(var2)
315
316 self.var1.constant_term = 0
317 prod = self.var1 * mult
318
319 #Sanity
320 self.assertEquals(prod.__class__, HelasLib.MultVariable)
321 self.assertEquals(len(prod), 3)
322
323 #check prefactor
324 self.assertEquals(prod.prefactor, 12)
325
326 def testmultvarMult2(self):
327 """product of Variable with an MultVariable"""
328
329 var1 = HelasLib.Variable(2)
330 var2 = HelasLib.Variable(3,0,'y')
331 mult = HelasLib.MultVariable()
332 mult.append(var1)
333 mult.append(var2)
334 mult = mult + 2
335
336 prod = self.var1 * mult
337
338 #Sanity
339 self.assertEquals(prod.__class__, HelasLib.AddVariable)
340 self.assertEquals(len(prod), 3)
341
342 #check prefactor
343 for term in prod:
344 if term == self.var1:
345 self.assertEquals(term.prefactor, 4)
346 elif term.__class__ == HelasLib.MultVariable:
347 if self.var1 in term:
348 self.assertEquals(term.prefactor, 12)
349 else:
350 self.assertEquals(term.prefactor, 30)
351 self.assertFalse(term is mult)
352 else:
353 raise Exception('unvalid term %s' % term)
354 self.assertEquals(prod.constant_term, 10)
355
356
357 def testmultvarint(self):
358 """product of Var with an integer"""
359
360 prod1 = self.var1 * 2
361 prod2 = 2 * self.var2
362
363 #SanityCheck
364 self.assertTrue(prod1, HelasLib.Variable)
365 self.assertTrue(prod2, HelasLib.Variable)
366 self.assertEquals(prod1, self.var1)
367 self.assertEquals(prod2, self.var2)
368 self.assertFalse(prod1 is self.var1)
369 self.assertFalse(prod2 is self.var2)
370
371 #check prefactor - constant term
372 self.assertEquals(prod1.prefactor, 4)
373 self.assertEquals(prod1.constant_term, 10)
374 self.assertEquals(prod2.prefactor, 6)
375 self.assertEquals(prod2.constant_term, 14)
376
377class TestAddVariable(unittest.TestCase):
378
379 def setUp(self):
380 """Initialize basic object"""
381 self.var1 = HelasLib.Variable(2, 5, 'var1')
382 self.var2 = HelasLib.Variable(3, 7, 'var2')
383 self.add1 = HelasLib.AddVariable()
384 self.add1.append(self.var1)
385 self.add1.append(self.var2)
386
387 self.var3 = HelasLib.Variable(11, 13, 'var3')
388 self.var4 = HelasLib.Variable(4, 9, 'var4')
389 self.add2 = HelasLib.AddVariable()
390 self.add2.append(self.var3)
391 self.add2.append(self.var4)
392
393 def testsumaddint(self):
394 """Test the sum of an Add variable with an integer"""
395
396 sum = 5 + self.add1
397 sum2= self.add2 + 5
398
399 #Sanity Check
400 self.assertEquals(sum.__class__,HelasLib.AddVariable)
401 self.assertEquals(sum.__class__,HelasLib.AddVariable)
402 self.assertEquals(len(sum),2)
403 self.assertEquals(len(sum2),2)
404
405 #test constant term
406 self.assertEquals(sum.constant_term,17)
407 self.assertEquals(sum2.constant_term,27)
408
409 def testsumaddmult(self):
410 """Test the sum of an AddVariable with a MultVariable."""
411
412 var1 = HelasLib.Variable(2)
413 var2 = HelasLib.Variable(3)
414 mult = HelasLib.MultVariable()
415 mult.append(var1)
416 mult.append(var2)
417 mult.constant_term =2
418
419 sum = self.add1 + mult
420
421 #Sanity Check
422 self.assertEquals(sum.__class__, HelasLib.AddVariable)
423 self.assertEqual(len(sum), 3)
424 self.assertTrue(mult in sum)
425
426 #check new term
427 for term in sum:
428 if term.__class__ == HelasLib.AddVariable:
429 self.assertTrue(term.prefactor, 6)
430 self.assertTrue(term.constant_term, 0)
431
432 def testsumaddvar(self):
433 """Test the sum of an AddVariable with a Variable."""
434
435 var3 = HelasLib.Variable(11, 13, 'var3')
436 sum = self.add1 + var3
437 self.assertEquals(sum.__class__,HelasLib.AddVariable)
438 self.assertTrue(self.var1 in sum)
439 self.assertTrue(self.var2 in sum)
440 self.assertTrue(self.var3 in sum)
441 self.assertEquals(len(sum), 3)
442 for data in sum:
443 if data == self.var1:
444 self.assertEquals(data.prefactor,2)
445 self.assertEquals(data.constant_term,0)
446 elif data == self.var2:
447 self.assertEquals(data.prefactor,3)
448 self.assertEquals(data.constant_term,0)
449 elif data == self.var3:
450 self.assertEquals(data.prefactor,11)
451 self.assertEquals(data.constant_term,0)
452
453 #test prefactor- constant_term
454 self.assertEquals(sum.prefactor, 1)
455 self.assertEquals(sum.constant_term, 25)
456
457 def testsumaddadd(self):
458 """Test the sum of two add object"""
459
460 sum = self.add1 + self.add2
461
462 self.assertEquals(sum.__class__, HelasLib.AddVariable)
463 self.assertEquals(len(sum), 4)
464
465 self.assertTrue(self.var1 in sum)
466 self.assertTrue(self.var2 in sum)
467 self.assertTrue(self.var3 in sum)
468 self.assertTrue(self.var4 in sum)
469
470 for data in sum:
471 if data == self.var1:
472 self.assertEquals(data.prefactor, 2)
473 self.assertEquals(data.constant_term, 0)
474 elif data == self.var2:
475 self.assertEquals(data.prefactor, 3)
476 self.assertEquals(data.constant_term, 0)
477 elif data == self.var3:
478 self.assertEquals(data.prefactor, 11)
479 self.assertEquals(data.constant_term, 0)
480 elif data == self.var4:
481 self.assertEquals(data.prefactor, 4)
482 self.assertEquals(data.constant_term, 0)
483 #test prefactor- constant_term
484 self.assertEquals(sum.prefactor, 1)
485 self.assertEquals(sum.constant_term, 34)
486
487 def testmultaddint(self):
488 """test the multiplication of an AddVariable by a Integer"""
489
490 prod1 = 3 * self.add1
491 prod2 = self.add2 * 2
492
493 self.assertEquals(prod1.__class__, HelasLib.AddVariable)
494 self.assertEquals(prod1.__class__, HelasLib.AddVariable)
495 self.assertFalse(prod1 is self.add1)
496 self.assertFalse(prod2 is self.add2)
497 self.assertEquals(len(prod1), 2)
498 self.assertEquals(len(prod2), 2)
499
500 self.assertEquals(prod1.prefactor, 1)
501 self.assertEquals(prod2.prefactor, 1)
502 self.assertEquals(prod1.constant_term, 36)
503 self.assertEquals(prod2.constant_term, 44)
504
505 for data in prod1:
506 if data == self.var1:
507 self.assertEquals(data.prefactor, 6)
508 self.assertEquals(data.constant_term, 0)
509 elif data == self.var2:
510 self.assertEquals(data.prefactor, 9)
511 self.assertEquals(data.constant_term, 0)
512 for data in prod2:
513 if data == self.var3:
514 self.assertEquals(data.prefactor, 22)
515 self.assertEquals(data.constant_term, 0)
516 elif data == self.var4:
517 self.assertEquals(data.prefactor, 8)
518 self.assertEquals(data.constant_term, 0)
519
520
521
522 def testmultaddvar(self):
523 """Test the multiplication of an Addvariable with a Variable"""
524
525 var3 = HelasLib.Variable(11, 13, 'var3')
526 prod = self.add1 * var3
527
528 #sanity check
529 self.assertEquals(prod.__class__, HelasLib.AddVariable)
530 self.assertEquals(len(prod), 5)
531
532 #check prefactor of each term
533 for term in prod:
534 if term == self.var1:
535 self.assertEquals(term.prefactor, 26)
536 elif term == self.var2:
537 self.assertEquals(term.prefactor, 39)
538 elif term == self.var3:
539 self.assertEquals(term.prefactor, 132)
540 elif self.var1 not in term:
541 self.assertEquals(term.prefactor, 33)
542 elif self.var2 not in term:
543 self.assertEquals(term.prefactor, 22)
544 else:
545 raise Exception('not valid term')
546
547 self.assertEquals(prod.constant_term, 156)
548
549
550 def testmultaddmult(self):
551 """Test the multiplication of an AddVariable with a MultVariable."""
552
553 var3 = HelasLib.Variable(2, 0, 'var3')
554 var4 = HelasLib.Variable(1, 0, 'var4')
555 prod = self.add1 * (var3 *var4)
556
557 self.assertEqual(prod.__class__, HelasLib.AddVariable)
558 self.assertEqual(len(prod), 3)
559
560 for data in prod:
561 if self.var1 in data:
562 self.assertEqual(data.__class__, HelasLib.MultVariable)
563 self.assertEqual(data.prefactor, 4)
564 elif self.var2 in data:
565 self.assertEqual(data.__class__, HelasLib.MultVariable)
566 self.assertEqual(data.prefactor, 6)
567 else:
568 self.assertEqual(data.__class__, HelasLib.MultVariable)
569 self.assertEqual(data.prefactor, 24)
570 self.assertEqual(prod.prefactor, 1)
571 self.assertEqual(prod.constant_term, 0)
572
573 def testmultaddmult2(self):
574 """Test the multiplication of an AddVariable with a MultVariable."""
575
576 var3 = HelasLib.Variable(2, 0, 'var3')
577 var4 = HelasLib.Variable(1, 0, 'var4')
578 mult = (var3 * var4) + 3
579 prod = self.add1 * mult
580
581 self.assertEqual(prod.__class__, HelasLib.AddVariable)
582 self.assertEqual(len(prod), 5)
583
584 for data in prod:
585 if data == self.var1:
586 self.assertEqual(data.prefactor, 6)
587 elif data == self.var2:
588 self.assertEqual(data.prefactor, 9)
589 elif self.var1 in data:
590 self.assertEqual(data.__class__, HelasLib.MultVariable)
591 self.assertEqual(data.prefactor, 4)
592 elif self.var2 in data:
593 self.assertEqual(data.__class__, HelasLib.MultVariable)
594 self.assertEqual(data.prefactor, 6)
595 else:
596 self.assertEqual(data.__class__, HelasLib.MultVariable)
597 self.assertEqual(data.prefactor, 24)
598 self.assertEqual(prod.prefactor, 1)
599 self.assertEqual(prod.constant_term, 36)
600
601
602 def testmultaddadd(self):
603 """Test the multiplication between two AddVariable."""
604
605 prod = self.add1 * self.add2
606 self.assertEqual(prod.__class__, HelasLib.AddVariable)
607 self.assertEqual(len(prod), 8)
608
609 for data in prod:
610 if data == self.var1:
611 self.assertEqual(data.prefactor, 44)
612 elif data == self.var2:
613 self.assertEqual(data.prefactor, 66)
614 elif data == self.var3:
615 self.assertEqual(data.prefactor, 132)
616 elif data == self.var4:
617 self.assertEqual(data.prefactor, 48)
618 elif self.var1 in data and self.var3 in data:
619 self.assertEqual(data.__class__, HelasLib.MultVariable)
620 self.assertEqual(data.prefactor, 22)
621 elif self.var1 in data:
622 self.assertEqual(data.__class__, HelasLib.MultVariable)
623 self.assertEqual(data.prefactor, 8)
624 elif self.var2 in data and self.var3 in data:
625 self.assertEqual(data.__class__, HelasLib.MultVariable)
626 self.assertEqual(data.prefactor, 33)
627 else:
628 self.assertEqual(data.__class__, HelasLib.MultVariable)
629 self.assertEqual(data.prefactor, 12)
630 self.assertEqual(prod.constant_term, 22*12)
631
632
633
634class TestMultVariable(unittest.TestCase):
635
636 def setUp(self):
637 self.var1 = HelasLib.Variable(2, 0, 'var1')
638 self.var2 = HelasLib.Variable(3, 0, 'var2')
639 self.var3 = HelasLib.Variable(4, 0, 'var3')
640 self.var4 = HelasLib.Variable(5, 0, 'var4')
641
642 self.mult1 = self.var1 * self.var2
643 self.mult2 = self.var3 * self.var4
644 self.mult3 = self.mult2 + 2
645 self.mult4 = self.mult1 + 2
646
647 def testequality(self):
648 """test the definition of Equality"""
649
650 #test with mult obj
651 self.assertEqual(self.mult1, self.mult4)
652 self.assertEqual(self.mult2, self.mult3)
653 self.assertNotEqual(self.mult1, self.mult2)
654 self.assertNotEqual(self.mult1, self.mult3)
655 self.assertNotEqual(self.mult4, self.mult2)
656 self.assertNotEqual(self.mult4, self.mult3)
657
658 #test with other type of obj
659 self.assertNotEqual(self.mult1, 32)
660 self.assertNotEqual(self.mult1, self.var1)
661 self.assertNotEqual(self.mult1, self.var1 + self.var2)
662
663 def testsummultmul(self):
664 """Test the sum of two MultVariable"""
665
666 sum = self.mult1 + self.mult2
667 self.assertEqual(sum.__class__, HelasLib.AddVariable)
668 self.assertEqual(len(sum),2)
669 self.assertEqual(sum.constant_term, 0)
670 self.assertEqual(sum.prefactor, 1)
671
672 for term in sum:
673 if self.var1 in term:
674 self.assertEqual(term.prefactor, 6)
675 self.assertEqual(term.constant_term, 0)
676 self.assertFalse(term is self.mult1)
677 else:
678 self.assertEqual(term.prefactor, 20)
679 self.assertEqual(term.constant_term, 0)
680 self.assertFalse(term is self.mult2)
681
682 sum = self.mult1 + self.mult3
683
684 self.assertEqual(sum.__class__, HelasLib.AddVariable)
685 self.assertEqual(len(sum),2)
686 self.assertEqual(sum.constant_term, 2)
687 self.assertEqual(sum.prefactor, 1)
688
689 for term in sum:
690 if self.var1 in term:
691 self.assertEqual(term.prefactor, 6)
692 self.assertEqual(term.constant_term, 0)
693 self.assertFalse(term is self.mult1)
694 else:
695 self.assertEqual(term.prefactor, 20)
696 self.assertEqual(term.constant_term, 0)
697 self.assertFalse(term is self.mult2)
698
699
700 sum = self.mult1 - self.mult4
701 sum = sum.simplify()
702 self.assertEqual(sum.__class__, HelasLib.ConstantObject)
703 self.assertEqual(len(sum),0)
704 self.assertEqual(sum.constant_term, -2)
705 self.assertEqual(sum.prefactor, 1)
706
707
708 def test_obj_are_not_modified(self):
709 """Check that a sum-product-... doesn't change part of the objects"""
710
711 sum = self.mult1 + self.mult2
712 for term in sum:
713 self.assertFalse(term is self.mult1)
714 self.assertFalse(term is self.mult2)
715
716
717 sum2 = sum - (self.mult1 + self.mult2)
718 #for term in sum:
719 # for term2 in sum2:
720 # self.assertFalse(term is term2)
721
722 sum2 = sum2.simplify()
723
724 #check that sum2 is zero
725 self.assertEqual(len(sum2), 0)
726 self.assertEqual(sum2.__class__, HelasLib.ConstantObject)
727 self.assertEqual(sum2, 0)
728
729 #check that the sum is not modify in this game
730 self.assertEqual(sum.__class__, HelasLib.AddVariable)
731 self.assertEqual(len(sum), 2)
732 self.assertEqual(sum.prefactor, 1)
733 self.assertEqual(sum.constant_term, 0)
734
735 for data in sum:
736 self.assertEqual(data.constant_term, 0)
737 self.assertEqual(len(data), 2)
738 if self.var1 in data:
739 self.assertEqual(data.prefactor, 6)
740 self.assertTrue(self.var2 in data)
741 else:
742 self.assertEqual(data.prefactor, 20)
743 self.assertTrue(self.var3 in data)
744 self.assertTrue(self.var4 in data)
745
746 def testsummultint(self):
747 """Test the sum of a MultVariable object with a number"""
748
749 sum1 = self.mult1 + 2
750 sum2 = 3 + self.mult1
751
752 self.assertEqual(sum1.__class__, HelasLib.MultVariable)
753 self.assertEqual(len(sum1), 2)
754 self.assertFalse(sum1 is self.mult1)
755 self.assertEqual(sum1.prefactor, 6)
756 self.assertEqual(sum1.constant_term, 2)
757
758 self.assertEqual(sum2.__class__, HelasLib.MultVariable)
759 self.assertEqual(len(sum2), 2)
760 self.assertFalse(sum2 is self.mult1)
761 self.assertEqual(sum2.prefactor, 6)
762 self.assertEqual(sum2.constant_term, 3)
763
764 def testsummultadd(self):
765 """Test the sum of an MultVariable with a AddVariable."""
766
767 var1 = HelasLib.Variable(2,4,'xxx')
768 var2 = HelasLib.Variable(3,5,'yyy')
769 add = var1 + var2
770
771 sum = self.mult3 + add
772 #Sanity Check
773 self.assertEquals(sum.__class__, HelasLib.AddVariable)
774 self.assertEqual(len(sum), 3)
775 self.assertTrue(var1 in sum)
776 self.assertTrue(var2 in sum)
777
778 #check new term
779 for term in sum:
780 if term.__class__ == HelasLib.MultVariable:
781 self.assertEqual(term.prefactor, 20)
782 self.assertEqual(term.constant_term, 0)
783 self.assertTrue(self.var3 in term)
784 self.assertTrue(self.var4 in term)
785 elif term == var1:
786 self.assertEqual(term.prefactor, 2)
787 self.assertEqual(term.constant_term, 0)
788 elif term == var2:
789 self.assertEqual(term.prefactor, 3)
790 self.assertEqual(term.constant_term, 0)
791
792 self.assertEqual(sum.prefactor, 1)
793 self.assertEqual(sum.constant_term, 11)
794
795 def testsummulvar(self):
796 """Test the sum of a MultVariable with a Variable"""
797
798
799 var = HelasLib.Variable(3,4,'xxx')
800 sum = self.mult3 + var
801
802 self.assertEquals(sum.__class__,HelasLib.AddVariable)
803 self.assertTrue(var in sum)
804 self.assertEquals(len(sum), 2)
805 for term in sum:
806 if term == var:
807 self.assertEquals(term.prefactor, 3)
808 self.assertEquals(term.constant_term,0)
809 self.assertFalse(term is var)
810 else:
811 self.assertTrue(self.var3 in term)
812 self.assertTrue(self.var4 in term)
813 self.assertEqual(term.prefactor, 20)
814 self.assertEqual(term.constant_term, 0)
815
816 #test prefactor- constant_term
817 self.assertEquals(sum.prefactor, 1)
818 self.assertEquals(sum.constant_term, 6)
819 self.assertEquals(var.prefactor, 3)
820 self.assertEquals(var.constant_term,4)
821 self.assertEquals(self.mult3.prefactor, 20)
822 self.assertEquals(self.mult3.constant_term, 2)
823
824 def testmultmultint(self):
825 """Test the multiplication of an MultVariable with an integer"""
826
827 prod1 = self.mult1 * 2
828
829 self.assertEqual(prod1.__class__, HelasLib.MultVariable)
830 self.assertEqual(len(prod1), 2)
831 self.assertFalse(prod1 is self.mult1)
832 self.assertEqual(prod1.prefactor, 12)
833 self.assertEqual(prod1.constant_term, 0)
834 for fact in prod1:
835 if fact == self.var1:
836 self.assertEqual(fact.prefactor, 1)
837 self.assertEqual(fact.constant_term, 0)
838 if fact == self.var2:
839 self.assertEqual(fact.prefactor, 1)
840 self.assertEqual(fact.constant_term, 0)
841
842 prod2 = 2 * self.mult1
843
844 self.assertEqual(prod2.__class__, HelasLib.MultVariable)
845 self.assertEqual(len(prod2), 2)
846 self.assertEqual(prod2.prefactor, 12)
847 self.assertEqual(prod2.constant_term, 0)
848 for fact in prod1:
849 if fact == self.var1:
850 self.assertEqual(fact.prefactor, 1)
851 self.assertEqual(fact.constant_term, 0)
852 if fact == self.var2:
853 self.assertEqual(fact.prefactor, 1)
854 self.assertEqual(fact.constant_term, 0)
855
856 prod3 = 2 * self.mult3
857
858 self.assertEqual(prod3.__class__, HelasLib.MultVariable)
859 self.assertEqual(len(prod3), 2)
860 self.assertFalse(prod3 is self.mult3)
861 self.assertEqual(prod3.prefactor, 40)
862 self.assertEqual(prod3.constant_term, 4)
863 for fact in prod1:
864 if fact == self.var3:
865 self.assertEqual(fact.prefactor, 1)
866 self.assertEqual(fact.constant_term, 0)
867 if fact == self.var4:
868 self.assertEqual(fact.prefactor, 1)
869 self.assertEqual(fact.constant_term, 0)
870 prod4 = 2 * self.mult3
871
872 self.assertEqual(prod4.__class__, HelasLib.MultVariable)
873 self.assertEqual(len(prod4), 2)
874 self.assertFalse(prod4 is self.mult3)
875 self.assertEqual(prod4.prefactor, 40)
876 self.assertEqual(prod4.constant_term, 4)
877 for fact in prod1:
878 if fact == self.var3:
879 self.assertEqual(fact.prefactor, 1)
880 self.assertEqual(fact.constant_term, 0)
881 if fact == self.var4:
882 self.assertEqual(fact.prefactor, 1)
883 self.assertEqual(fact.constant_term, 0)
884
885 def testmultmultmult(self):
886 """test the multiplication of two MultVariable"""
887
888 prod1 = self.mult1 * self.mult2
889 self.assertEqual(prod1.__class__, HelasLib.MultVariable)
890 self.assertEqual(len(prod1), 4)
891 self.assertTrue(self.var1 in prod1)
892 self.assertTrue(self.var2 in prod1)
893 self.assertTrue(self.var3 in prod1)
894 self.assertTrue(self.var4 in prod1)
895 self.assertEqual(prod1.prefactor, 120)
896 self.assertEqual(prod1.constant_term, 0)
897
898 for fact in prod1:
899 self.assertEqual(fact.prefactor, 1)
900 self.assertEqual(fact.constant_term, 0)
901
902 prod2 = self.mult1 * self.mult3
903
904 self.assertEqual(prod2.__class__, HelasLib.AddVariable)
905 self.assertEqual(len(prod2), 2)
906
907 self.assertEqual(prod2.prefactor, 1)
908 self.assertEqual(prod2.constant_term, 0)
909 for term in prod2:
910 if self.var3 in term:
911 self.assertEqual(term.prefactor, 120)
912 self.assertEqual(term.constant_term, 0)
913 self.assertTrue(self.var1 in term)
914 self.assertTrue(self.var2 in term)
915 self.assertTrue(self.var4 in term)
916 self.assertEqual(len(term), 4)
917 self.assertEqual(term.__class__,HelasLib.MultVariable)
918 elif self.var1 in term:
919 self.assertEqual(term.prefactor, 12)
920 self.assertEqual(term.constant_term, 0)
921 self.assertTrue(self.var2 in term)
922 self.assertEqual(len(term), 2)
923 self.assertEqual(term.__class__,HelasLib.MultVariable)
924
925
926
927 prod3 = self.mult3 * self.mult4
928 self.assertEqual(prod3.__class__, HelasLib.AddVariable)
929 self.assertEqual(len(prod3), 3)
930
931 self.assertEqual(prod3.prefactor, 1)
932 self.assertEqual(prod3.constant_term, 4)
933
934 for term in prod3:
935 if self.var1 in term and self.var3 in term:
936 self.assertEqual(term.prefactor, 120)
937 self.assertEqual(term.constant_term, 0)
938 self.assertTrue(self.var2 in term)
939 self.assertTrue(self.var4 in term)
940 self.assertEqual(len(term), 4)
941 self.assertEqual(term.__class__, HelasLib.MultVariable)
942 elif self.var1 in term:
943 self.assertEqual(term.prefactor, 12)
944 self.assertEqual(term.constant_term, 0)
945 self.assertTrue(self.var2 in term)
946 self.assertEqual(len(term), 2)
947 self.assertEqual(term.__class__, HelasLib.MultVariable)
948 elif self.var3 in term:
949 self.assertEqual(term.prefactor, 40)
950 self.assertEqual(term.constant_term, 0)
951 self.assertTrue(self.var4 in term)
952 self.assertEqual(len(term), 2)
953 self.assertEqual(term.__class__, HelasLib.MultVariable)
954
955 self.assertEqual(self.var1.prefactor, 2)
956 self.assertEqual(self.var1.constant_term, 0)
957 self.assertEqual(self.var2.prefactor, 3)
958 self.assertEqual(self.var2.constant_term, 0)
959 self.assertEqual(self.var3.prefactor, 4)
960 self.assertEqual(self.var3.constant_term, 0)
961 self.assertEqual(self.var4.prefactor, 5)
962 self.assertEqual(self.var4.constant_term, 0)
963
964
965class TestFracVariable(unittest.TestCase):
966 """ Class to test the Operation linked to a FracVariable """
967
968 def setUp(self):
969 """ some building block """
970
971 self.p1 = HelasObject.P(1,2)
972 self.p2 = HelasObject.P(1,3)
973 self.mass1 = HelasObject.Mass(2)
974 self.mass2 = HelasObject.Mass(3)
975 self.frac1 = HelasLib.FracVariable(self.p1, self.mass1)
976 self.frac2 = HelasLib.FracVariable(self.p2, self.mass2)
977
978 def testcreation(self):
979 """ test if we can create FracVariable Object with division"""
980
981 #
982 # First check the creation at Lorentz Object
983 #
984 frac1= self.p1 / self.mass1
985 self.assertEqual(frac1.__class__, HelasLib.FracVariable)
986 self.assertEqual(frac1, self.frac1)
987 # Verif that the object are different
988 self.assertFalse(frac1.numerator is self.p1)
989 self.assertFalse(frac1.denominator is self.mass1)
990
991 sum = self.p1 +self.p2
992 frac2 = sum / self.mass1
993 self.assertEqual(frac2.__class__, HelasLib.FracVariable)
994 self.assertEqual(frac2.numerator, sum)
995 self.assertEqual(frac2.denominator, self.mass1)
996 # Verif that the object are different
997 self.assertFalse(frac2.numerator is sum)
998 self.assertFalse(frac2.denominator is self.mass1)
999
1000 prod = self.p1 * self.p2
1001 frac3 = prod / self.mass1
1002 self.assertEqual(frac3.__class__, HelasLib.FracVariable)
1003 self.assertEqual(frac3.numerator, prod)
1004 self.assertEqual(frac3.denominator, self.mass1)
1005 # Verif that the object are different
1006 self.assertFalse(frac3.numerator is prod)
1007 self.assertFalse(frac3.denominator is self.mass1)
1008
1009 frac4 = 2 / self.mass1
1010 self.assertEqual(frac4.__class__, HelasLib.FracVariable)
1011 self.assertTrue(isinstance(frac4.numerator, int))
1012 self.assertEqual(frac4.numerator, 2)
1013 self.assertTrue(isinstance(frac4.denominator,HelasLib.Variable))
1014 self.assertEqual(frac4.denominator, self.mass1)
1015 self.assertFalse(frac4.denominator is self.mass1)
1016
1017 sum = (self.mass1 + self.mass2)
1018 frac4 = 2 / sum
1019 self.assertEqual(frac4.__class__, HelasLib.FracVariable)
1020 self.assertTrue(isinstance(frac4.numerator, int))
1021 self.assertEqual(frac4.numerator, 2)
1022 self.assertTrue(isinstance(frac4.denominator,HelasLib.AddVariable))
1023 self.assertEqual(frac4.denominator, sum)
1024 self.assertFalse(frac4.denominator is sum)
1025
1026 prod = self.mass1 * self.mass2
1027 frac4 = 2 / prod
1028 self.assertEqual(frac4.__class__, HelasLib.FracVariable)
1029 self.assertTrue(isinstance(frac4.numerator, int))
1030 self.assertEqual(frac4.numerator, 2)
1031 self.assertTrue(isinstance(frac4.denominator,HelasLib.MultVariable))
1032 self.assertTrue(isinstance(frac4.denominator,HelasLib.MultLorentz))
1033 self.assertEqual(frac4.denominator, prod)
1034 self.assertFalse(frac4.denominator is prod)
1035
1036
1037 def testmultiplacation(self):
1038 """Frac Variable can be multiply by any object"""
1039
1040 #product with Variable
1041 prod1 = self.frac1 * self.p1
1042 self.assertEqual(prod1.__class__, HelasLib.FracVariable)
1043 self.assertEqual(prod1.numerator, self.p1 * self.p1)
1044 self.assertEqual(prod1.denominator, self.mass1)
1045
1046 prod2 = self.p1 * self.frac1
1047 self.assertEqual(prod2.__class__, HelasLib.FracVariable)
1048 self.assertEqual(prod2.numerator, self.p1 * self.p1)
1049 self.assertEqual(prod2.denominator, self.mass1)
1050
1051 #product with MultVariable
1052 prod = self.p1 * self.p2
1053 prod2 = prod * self.frac1
1054 self.assertEqual(prod2.__class__, HelasLib.FracVariable)
1055 self.assertEqual(prod2.numerator, self.p1 * self.p2 * self.p1)
1056 self.assertEqual(prod2.denominator, self.mass1)
1057
1058 prod3 = self.frac1 * prod
1059 self.assertEqual(prod3.__class__, HelasLib.FracVariable)
1060 self.assertEqual(prod3.numerator, self.p1 * self.p2 * self.p1)
1061 self.assertEqual(prod3.denominator, self.mass1)
1062
1063 # Product with SumVariable
1064 sum = self.p1 +self.p2
1065 prod2 = sum * self.frac1
1066 self.assertEqual(prod2.__class__, HelasLib.FracVariable)
1067 self.assertEqual(prod2.numerator, sum * self.p1)
1068 self.assertEqual(prod2.denominator, self.mass1)
1069
1070 prod3 = self.frac1 * sum
1071 self.assertEqual(prod3.__class__, HelasLib.FracVariable)
1072 self.assertEqual(prod3.numerator, sum * self.p1)
1073 self.assertEqual(prod3.denominator, self.mass1)
1074
1075
1076 # Product with FracVariable
1077 prod = self.frac1 * self.frac2
1078 self.assertEqual(prod.__class__, HelasLib.FracVariable)
1079 self.assertEqual(prod.numerator.__class__, HelasLib.MultLorentz)
1080 self.assertEqual(prod.numerator, self.p2 * self.p1)
1081 self.assertEqual(prod.denominator, self.mass1 * self.mass2)
1082
1083 prod3 = self.frac2 * self.frac1
1084 self.assertEqual(prod3.__class__, HelasLib.FracVariable)
1085 self.assertEqual(prod3.numerator, self.p2 * self.p1)
1086 self.assertEqual(prod3.denominator, self.mass1 * self.mass2)
1087
1088
1089 def testdivision(self):
1090 """ Test division with a FracVariable """
1091
1092 #divide with Variable
1093 prod1 = self.frac1 / self.p1
1094 self.assertEqual(prod1.__class__, HelasLib.FracVariable)
1095 self.assertEqual(prod1.numerator, self.p1)
1096 self.assertEqual(prod1.denominator, self.p1 * self.mass1)
1097
1098 #divide with a MultVariable
1099 prod= self.p1 * self.p2
1100 prod3 = self.frac1 / prod
1101 self.assertEqual(prod3.__class__, HelasLib.FracVariable)
1102 self.assertEqual(prod3.numerator, self.p1)
1103 self.assertEqual(prod3.denominator, self.mass1 * self.p1 * self.p2)
1104
1105 # divide with AddVariable
1106 sum = self.p1 +self.p2
1107 prod2 = self.frac1 / sum
1108 self.assertEqual(prod2.__class__, HelasLib.FracVariable)
1109 self.assertEqual(prod2.numerator, self.p1)
1110 self.assertEqual(prod2.denominator, sum * self.mass1)
1111
1112
1113
1114
1115class testLorentzObject(unittest.TestCase):
1116 """ Class to test the Operation linked to a Lorentz Object"""
1117
1118 def setUp(self):
1119
1120 self.p1= HelasObject.P(1,2)
1121 self.p2= HelasObject.P(1,3)
1122 self.p3= HelasObject.P(2,2)
1123 self.p4= HelasObject.P(2,3)
1124
1125 def testbasicoperation(self):
1126 """Test the sum/product run correctly on High level object.
1127 Those test will be basic since everything should derive from particle
1128 """
1129
1130 new = self.p1 * self.p2 + self.p3 * self.p4
1131 self.assertEqual(new.__class__, HelasLib.AddVariable)
1132 self.assertEqual(len(new), 2)
1133
1134 new2 = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)
1135
1136 self.assertEqual(new2.__class__, HelasLib.MultLorentz)
1137 self.assertEqual(len(new2), 2)
1138
1139 new2 += HelasObject.Gamma(1,2,3) * HelasObject.P(1,3)
1140 self.assertEqual(new2.__class__, HelasLib.AddVariable)
1141 self.assertEqual(len(new2), 2)
1142 self.assertNotEqual(new, new2)
1143
1144 def test_equality(self):
1145 """test the equality of Lorentz Object"""
1146
1147 self.assertEqual(self.p1,self.p1)
1148 self.assertNotEqual(self.p1,self.p2)
1149 self.assertNotEqual(self.p1,self.p3)
1150 self.assertNotEqual(self.p1,self.p4)
1151 self.assertEqual(self.p1, HelasObject.P(1,2))
1152
1153 self.assertNotEqual(self.p1, HelasObject.Gamma(1,2,3))
1154
1155 new = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)
1156 new2 = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)
1157 self.assertEqual(new, new2)
1158
1159 #Check that sum indices are not consider for equality
1160 new3 = HelasObject.Gamma(3,2,3) * HelasObject.P(3,2)
1161 self.assertEqual(new, new3)
1162
1163 new4 = HelasObject.P(3,2) * HelasObject.Gamma(3,2,3)
1164 self.assertEqual(new, new4)
1165 self.assertEqual(new3, new4)
1166
1167 new5 = HelasObject.P(4,2) * HelasObject.Gamma(4,2,3)
1168 self.assertEqual(new, new5)
1169 self.assertEqual(new3, new5)
1170 self.assertEqual(new4, new5)
1171
1172 new6 = HelasObject.P(3,2) * HelasObject.Gamma(3,3,2)
1173 self.assertNotEqual(new, new6)
1174
1175 new7 = HelasObject.P(3,4) * HelasObject.Gamma(3,2,3)
1176 self.assertNotEqual(new, new7)
1177
1178 #Test contraction on spin
1179 new = HelasObject.Gamma(3,3,2) * HelasObject.Gamma(2,2,4) * \
1180 HelasObject.P(3,3) * HelasObject.P(2,4)
1181 new2 = HelasObject.Gamma(3,3,2) * HelasObject.Gamma(2,2,4) * \
1182 HelasObject.P(3,4) * HelasObject.P(2,3)
1183 self.assertNotEqual(new,new2)
1184
1185 new3 = HelasObject.P(1,3) * HelasObject.Gamma(1,3,1) * HelasObject.P(4,4) * \
1186 HelasObject.Gamma(4,1,4)
1187 self.assertEqual(new, new3)
1188 self.assertNotEqual(new2, new3)
1189
1190 new4 = HelasObject.P(1,3) * HelasObject.Gamma(1,3,2) * HelasObject.P(4,4) * \
1191 HelasObject.Gamma(4,1,4)
1192 self.assertNotEqual(new,new4)
1193
1194 def testexpand(self):
1195 """Test if the expansion from HighLevel to LowLevel works correctly"""
1196
1197 #expand a single object
1198 obj = HelasObject.P(1,2)
1199 low_level = obj.expand()
1200
1201 self.assertEqual(low_level[:], [HelasLib.ScalarVariable('p2_0',[2]), \
1202 HelasLib.ScalarVariable('p2_1',[2]), \
1203 HelasLib.ScalarVariable('p2_2',[2]), \
1204 HelasLib.ScalarVariable('p2_3',[2])])
1205
1206 #expand a product
1207 obj = HelasObject.P(1,2) * HelasObject.P(2,3)
1208 low_level = obj.expand()
1209
1210 for ind in low_level.listindices():
1211 self.assertEqual(low_level.get_rep(ind), \
1212 HelasLib.ScalarVariable('p2_%s' % ind[0]) * \
1213 HelasLib.ScalarVariable('p3_%s' % ind[1]))
1214
1215 #expand a sum
1216 obj = HelasObject.P(1,2) + HelasObject.P(1,3)
1217 low_level = obj.expand()
1218
1219 for ind in low_level.listindices():
1220 self.assertEqual(low_level.get_rep(ind), \
1221 HelasLib.ScalarVariable('p2_%s' % ind[0]) + \
1222 HelasLib.ScalarVariable('p3_%s' % ind[0]))
1223
1224 #expand zero
1225 obj = HelasObject.P(1,2) - HelasObject.P(1,2)
1226 obj = obj.simplify()
1227 low_level = obj.expand()
1228 pass_in_check = 0
1229 for ind in low_level.listindices():
1230 pass_in_check += 1
1231 self.assertEqual(low_level.get_rep(ind), 0)
1232 self.assertEqual(pass_in_check, 1)
1233
1234 #expand zero without first simplification
1235 obj = HelasObject.P(1,2) - HelasObject.P(1,2)
1236 low_level = obj.expand()
1237 pass_in_check = 0
1238 for ind in low_level.listindices():
1239 pass_in_check += 1
1240 self.assertEqual(low_level.get_rep(ind), 0)
1241 self.assertEqual(pass_in_check, 4)
1242
1243 #expand standard frac variable
1244 obj = HelasObject.P(1,2) / HelasObject.P(1,2)
1245 obj = obj.expand()
1246 result = [HelasLib.ScalarVariable('p2_0',[2]), \
1247 HelasLib.ScalarVariable('p2_1',[2]), \
1248 HelasLib.ScalarVariable('p2_2',[2]), \
1249 HelasLib.ScalarVariable('p2_3',[2])]
1250 self.assertEqual(obj.numerator[:], result)
1251 self.assertEqual(obj.denominator[:], result)
1252
1253 #expand standard frac variable with number numerator
1254 obj = 1 / HelasObject.P(1,2)
1255 obj = obj.expand()
1256 result = [HelasLib.ScalarVariable('p2_0',[2]), \
1257 HelasLib.ScalarVariable('p2_1',[2]), \
1258 HelasLib.ScalarVariable('p2_2',[2]), \
1259 HelasLib.ScalarVariable('p2_3',[2])]
1260 self.assertEqual(obj.numerator, 1)
1261 self.assertEqual(obj.denominator[:], result)
1262
1263
1264 # Check for the prefactor
1265 obj = 36 * HelasObject.P(1,2)
1266 obj = obj.expand()
1267 for ind in obj.listindices():
1268 expression = obj.get_rep(ind)
1269 self.assertEqual(expression.prefactor, 36)
1270
1271 # Check for the prefactor
1272 obj = 36 * HelasObject.P(1,2) * HelasObject.P(2,2)
1273 obj = obj.expand()
1274 for ind in obj.listindices():
1275 expression = obj.get_rep(ind)
1276 self.assertEqual(expression.prefactor, 36)
1277
1278
1279 def testTraceofObject(self):
1280 """Check that we can output the trace of an object"""
1281
1282 obj = HelasObject.Gamma(1,1,1)
1283 obj.expand()
1284 obj.simplify()
1285
1286 def testscalarmanipulation(self):
1287 """Deal correctly with Scalar type of LorentzObject"""
1288
1289 obj= HelasObject.Mass(3)
1290 obj = obj.simplify()
1291 low_level = obj.expand()
1292 for ind in low_level.listindices():
1293 self.assertEqual(low_level.get_rep(ind).__class__, HelasLib.ScalarVariable)
1294 self.assertEqual(low_level.get_rep(ind), HelasLib.ScalarVariable('mass3',[3]))
1295
1296 obj= HelasObject.Mass(3) * HelasObject.P(1,2)
1297 obj = obj.simplify()
1298 low_level = obj.expand()
1299 self.assertEqual(low_level.__class__, HelasLib.LorentzObjectRepresentation)
1300 for ind in low_level.listindices():
1301 self.assertEqual(low_level.get_rep(ind).__class__, HelasLib.MultVariable)
1302 self.assertEqual(low_level.get_rep(ind), HelasLib.ScalarVariable('mass3',[3])
1303 * HelasLib.ScalarVariable('p2_%s' % ind[0],[0]))
1304
1305
1306class TestLorentzObjectRepresentation(unittest.TestCase):
1307 """Class to test the operation in the LorentzObjectRepresentation"""
1308
1309 #for lorentz manipulation
1310 p1nu = HelasObject.P(1,1)
1311 p1nu = p1nu.expand()
1312 p1mu = HelasObject.P(2,1)
1313 p1mu = p1mu.expand()
1314 p2nu = HelasObject.P(1,2)
1315 p2nu = p2nu.expand()
1316 p2mu = HelasObject.P(2,2)
1317 p2mu = p2mu.expand()
1318
1319 #for lorentz - spin manipulation
1320 gamma_nu_ij = HelasObject.Gamma(1,1,2)
1321 gamma_nu_ij = gamma_nu_ij.expand()
1322 gamma_nu_ji = HelasObject.Gamma(1,2,1)
1323 gamma_nu_ji = gamma_nu_ji.expand()
1324 gamma_mu_ij = HelasObject.Gamma(2,1,2)
1325 gamma_mu_ij = gamma_mu_ij.expand()
1326 gamma_nu_jk = HelasObject.Gamma(1,2,3)
1327 gamma_nu_jk = gamma_nu_jk.expand()
1328 gamma_mu_jk = HelasObject.Gamma(2,2,3)
1329 gamma_mu_jk = gamma_mu_jk.expand()
1330 gamma_nu_kl = HelasObject.Gamma(1,3,4)
1331 gamma_nu_kl = gamma_nu_kl.expand()
1332 gamma_mu_kl = HelasObject.Gamma(2,3,4)
1333 gamma_mu_kl = gamma_mu_kl.expand()
1334 gamma_mu_ki = HelasObject.Gamma(2,3,1)
1335 gamma_mu_ki = gamma_mu_ki.expand()
1336
1337 def testlistindices(self):
1338 """test that we return the correct list of indices"""
1339
1340 #only lorentz indices
1341 test1 = HelasLib.LorentzObjectRepresentation([],[1,2],[],[])
1342
1343 already_use=[]
1344 for ind in test1.listindices():
1345 self.assertFalse(ind in already_use, '%s appear two times' % ind)
1346 already_use.append(list(ind))
1347 for value in ind:
1348 self.assertTrue(value >= 0)
1349 self.assertTrue(value < 4)
1350 self.assertEqual(len(already_use), 16)
1351
1352 #only spin indices
1353 test1 = HelasLib.LorentzObjectRepresentation([],[],[1,2,3],[])
1354
1355 already_use=[]
1356 for ind in test1.listindices():
1357 self.assertFalse(ind in already_use, '%s appear two times' % ind)
1358 already_use.append(list(ind))
1359 for value in ind:
1360 self.assertTrue(value >= 0)
1361 self.assertTrue(value < 4)
1362 self.assertEqual(len(already_use), 64)
1363
1364 #mix of indices
1365 test1 = HelasLib.LorentzObjectRepresentation([],[1],[1,2,3],[])
1366
1367 already_use=[]
1368 for ind in test1.listindices():
1369 self.assertFalse(ind in already_use, '%s appear two times' % ind)
1370 already_use.append(list(ind))
1371 for value in ind:
1372 self.assertTrue(value >= 0)
1373 self.assertTrue(value < 4)
1374 self.assertEqual(len(already_use), 256)
1375
1376 #only one indice
1377 test1 = HelasLib.LorentzObjectRepresentation([],[1],[],[])
1378
1379 already_use=[]
1380 for ind in test1.listindices():
1381 self.assertFalse(ind in already_use, '%s appear two times' % ind)
1382 already_use.append(list(ind))
1383 for value in ind:
1384 self.assertTrue(value >= 0)
1385 self.assertTrue(value < 4)
1386 self.assertEqual(len(already_use), 4)
1387
1388 #no indices
1389 test1 = HelasLib.LorentzObjectRepresentation(38,[],[],[])
1390
1391 already_use=[]
1392 for ind in test1.listindices():
1393 self.assertEqual(ind,[0])
1394 already_use.append(list(ind))
1395 self.assertEqual(len(already_use), 1)
1396
1397 def testgetrepresentation(self):
1398 """Check the way to find representation"""
1399
1400 data=[[1, 2, 3 , 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
1401
1402 repr1 = HelasLib.LorentzObjectRepresentation(data, [1], [1], [])
1403 repr2 = HelasLib.LorentzObjectRepresentation(data, [1, 2], [], [])
1404 repr3 = HelasLib.LorentzObjectRepresentation(data, [], [1, 2], [])
1405
1406 for ind in repr1.listindices():
1407 self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1408 self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1409 self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1410
1411
1412 #check the dealing with scalar
1413 repr4 = HelasLib.LorentzObjectRepresentation(49, [], [], [])
1414 for ind in repr4.listindices():
1415 self.assertEquals(repr4.get_rep(ind), 49)
1416
1417 def testsetrepresentation(self):
1418 """Check the way to set a representation"""
1419
1420 goal=[[1, 2, 3 , 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
1421
1422 repr1 = HelasLib.LorentzObjectRepresentation([], [1], [1], [])
1423 repr2 = HelasLib.LorentzObjectRepresentation([], [1, 2], [], [])
1424 repr3 = HelasLib.LorentzObjectRepresentation([], [], [1, 2], [])
1425
1426 for ind in repr1.listindices():
1427 repr1.set_rep(ind, (ind[0]+1)*(ind[1]+1))
1428 repr2.set_rep(ind, (ind[0]+1)*(ind[1]+1))
1429 repr3.set_rep(ind, (ind[0]+1)*(ind[1]+1))
1430
1431 for ind in repr1.listindices():
1432 self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1433 self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1434 self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1435
1436 for ind in repr1.listindices():
1437 self.assertEquals(repr1.get_rep(ind), goal[ind[0]][ind[1]])
1438 self.assertEquals(repr2.get_rep(ind), goal[ind[0]][ind[1]])
1439 self.assertEquals(repr3.get_rep(ind), goal[ind[0]][ind[1]])
1440
1441 self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1442 self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1443 self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))
1444
1445
1446 def testtensorialproductlorentz(self):
1447 """Test that two object have correct product"""
1448
1449 product = self.p1nu * self.p2mu
1450
1451 #check global
1452 self.assertTrue(isinstance(product, HelasLib.LorentzObjectRepresentation))
1453 self.assertEquals(product.lorentz_ind, [1,2])
1454 self.assertEqual(product.spin_ind, [])
1455 self.assertEqual(product.tag, ['p1','p2'])
1456
1457 #check the representation
1458 for ind in product.listindices():
1459 rep = product.get_rep(ind)
1460 self.assertEqual(rep.__class__, HelasLib.MultVariable)
1461 self.assertEqual(len(rep), 2)
1462 for data in rep:
1463 if not( data.variable == 'p1_%s' % ind[0] or data.variable == \
1464 'p2_%s' % ind[1]):
1465 raise Exception('invalid product')
1466 self.assertNotEqual(rep[0].variable, rep[1].variable)
1467
1468
1469 def testtensorialproductspin(self):
1470 """test the product in spin indices"""
1471
1472 product1 = self.gamma_nu_ij * self.gamma_mu_kl
1473
1474 #check global
1475 self.assertTrue(isinstance(product1, HelasLib.LorentzObjectRepresentation))
1476 self.assertEquals(product1.lorentz_ind, [1,2])
1477 self.assertEqual(product1.spin_ind, [1,2,3,4])
1478 self.assertEqual(product1.tag, [])
1479
1480 #check the representation
1481 for ind in product1.listindices():
1482 rep = product1.get_rep(ind)
1483
1484 fact1 = self.gamma_nu_ij.get_rep([ind[0],ind[2],ind[3]])
1485 fact2 = self.gamma_mu_kl.get_rep([ind[1],ind[4],ind[5]])
1486 self.assertEqual(rep, fact1 * fact2)
1487
1488
1489 #Check with a lorentz contraction
1490 product2 = self.gamma_nu_ij * self.gamma_nu_kl
1491
1492 #check global
1493 self.assertTrue(isinstance(product2, HelasLib.LorentzObjectRepresentation))
1494 self.assertEquals(product2.lorentz_ind, [])
1495 self.assertEqual(product2.spin_ind, [1,2,3,4])
1496 self.assertEqual(product2.tag, [])
1497
1498 #check the representation
1499 for ind in product2.listindices():
1500 rep = product2.get_rep(ind)
1501
1502 sol = product1.get_rep([0,0] + ind) - product1.get_rep([1,1] + ind) - \
1503 product1.get_rep([2,2] + ind) -product1.get_rep([3,3] + ind)
1504
1505 product1.get_rep([2,2] + ind),product1.get_rep([3,3] + ind)
1506 self.assertEqual(rep, sol)
1507
1508
1509 def testspincontraction(self):
1510 """Test the spin contraction"""
1511 prod0 = self.gamma_mu_ij * self.gamma_nu_kl
1512 prod1 = self.gamma_mu_ij * self.gamma_nu_jk
1513
1514 #check global
1515 self.assertTrue(isinstance(prod1, HelasLib.LorentzObjectRepresentation))
1516 self.assertEquals(prod1.lorentz_ind, [2, 1])
1517 self.assertEqual(prod1.spin_ind, [1,3])
1518
1519 for ind in prod1.listindices():
1520
1521 rep = prod1.get_rep(ind)
1522 sol = prod0.get_rep([ind[0], ind[1], ind[2], 0, 0, ind[3]]) + \
1523 prod0.get_rep([ind[0], ind[1], ind[2], 1, 1, ind[3]]) + \
1524 prod0.get_rep([ind[0], ind[1], ind[2], 2, 2, ind[3]]) + \
1525 prod0.get_rep([ind[0], ind[1], ind[2], 3, 3, ind[3]])
1526 self.assertEqual(rep, sol)
1527
1528
1529 prod2 = self.gamma_mu_ij * self.gamma_mu_jk
1530
1531 #check global
1532 self.assertTrue(isinstance(prod2, HelasLib.LorentzObjectRepresentation))
1533 self.assertEquals(prod2.lorentz_ind, [])
1534 self.assertEqual(prod2.spin_ind, [1,3])
1535
1536 for ind in prod2.listindices():
1537
1538 rep = prod2.get_rep(ind)
1539 sol = prod1.get_rep([0, 0, ind[0], ind[1]]) \
1540 - prod1.get_rep([1, 1, ind[0], ind[1]]) + \
1541 - prod1.get_rep([2, 2, ind[0], ind[1]]) + \
1542 - prod1.get_rep([3, 3, ind[0], ind[1]])
1543
1544 self.assertEqual(rep, sol)
1545
1546 #test 3-> scalar
1547 prod3 = self.gamma_nu_ij * self.gamma_nu_ji
1548
1549 #check global
1550 self.assertTrue(isinstance(prod3, HelasLib.LorentzObjectRepresentation))
1551 self.assertEquals(prod3.lorentz_ind, [])
1552 self.assertEqual(prod3.spin_ind, [])
1553
1554 for ind in prod3.listindices():
1555
1556 rep = prod3.get_rep(ind)
1557 sol = prod2.get_rep([0,0]) \
1558 + prod2.get_rep([1,1]) \
1559 + prod2.get_rep([2,2]) \
1560 + prod2.get_rep([3,3])
1561 self.assertEqual(rep, sol)
1562
1563 #test 4-> scalar
1564 prod3 = self.gamma_nu_ji * self.gamma_nu_ij
1565
1566 #check global
1567 self.assertTrue(isinstance(prod3, HelasLib.LorentzObjectRepresentation))
1568 self.assertEquals(prod3.lorentz_ind, [])
1569 self.assertEqual(prod3.spin_ind, [])
1570
1571 for ind in prod3.listindices():
1572
1573 rep = prod3.get_rep(ind)
1574 sol = prod2.get_rep([0,0]) \
1575 + prod2.get_rep([1,1]) \
1576 + prod2.get_rep([2,2]) \
1577 + prod2.get_rep([3,3])
1578 self.assertEqual(rep, sol)
1579
1580
1581
1582 def testEinsteinsum(self):
1583 """Test the Einstein summation"""
1584
1585 prod1 = self.p1nu * self.p2mu * self.p2nu
1586
1587 #check global
1588 self.assertTrue(isinstance(prod1, HelasLib.LorentzObjectRepresentation))
1589 self.assertEquals(prod1.lorentz_ind, [2])
1590 self.assertEqual(prod1.spin_ind, [])
1591 self.assertEqual(prod1.tag, ['p1','p2','p2'])
1592
1593 #check the representation
1594 for ind in prod1.listindices():
1595 rep = prod1.get_rep(ind)
1596 self.assertEqual(rep.__class__, HelasLib.AddVariable)
1597 self.assertEqual(len(rep), 4)
1598 for data in rep:
1599 self.assertEqual(data.__class__, HelasLib.MultVariable)
1600 self.assertEqual(len(data), 3)
1601
1602 # Returning a scalar
1603 prod2 = self.p1nu * self.p2nu
1604
1605 #check global
1606 self.assertTrue(isinstance(prod2, HelasLib.LorentzObjectRepresentation))
1607 self.assertEquals(prod2.lorentz_ind, [])
1608 self.assertEqual(prod2.spin_ind, [])
1609 self.assertEqual(prod2.tag, ['p1','p2'])
1610
1611 #check the representation
1612 for ind in prod2.listindices():
1613 rep = prod2.get_rep(ind)
1614 self.assertEqual(rep.__class__, HelasLib.AddVariable)
1615 self.assertEqual(len(rep), 4)
1616 for data in rep:
1617 self.assertEqual(data.__class__, HelasLib.MultVariable)
1618 self.assertEqual(len(data), 2)
1619 self.assertNotEqual(data[0].variable, data[1].variable)
1620
1621 def testeinsteinsum2(self):
1622
1623 obj = HelasLib.LorentzObject([1,2],[],[])
1624 obj.representation = HelasLib.LorentzObjectRepresentation(
1625 [[0, 0, 0, -1], [0, 0, -1, 0], [0, 1, 0, 0], [1, 0, 0,0]], [1,2], [], [])
1626
1627 obj2 = obj.expand()
1628 self.assertEqual(obj2.get_rep((0,3)), -1)
1629 self.assertEqual(obj2.get_rep((1,2)), -1)
1630 self.assertEqual(obj2.get_rep((2,1)), 1)
1631 self.assertEqual(obj2.get_rep((3,0)), 1)
1632
1633 new= obj * HelasObject.P(2,2)
1634 new = new.simplify()
1635 new = new.expand()
1636 new = new.simplify()
1637 self.assertEqual(new.__class__, HelasLib.LorentzObjectRepresentation)
1638 self.assertEqual(new.lorentz_ind, [1])
1639 self.assertEqual(new.get_rep([3]), HelasLib.ScalarVariable('p2_0'))
1640 self.assertEqual(new.get_rep([2]), HelasLib.ScalarVariable('p2_1'))
1641 self.assertEqual(new.get_rep([1]), HelasLib.ScalarVariable('p2_2'))
1642 self.assertEqual(new.get_rep([0]), HelasLib.ScalarVariable('p2_3'))
1643 self.assertEqual(new.get_rep([0]).prefactor, 1)
1644 self.assertEqual(new.get_rep([1]).prefactor, 1)
1645 self.assertEqual(new.get_rep([2]).prefactor, -1)
1646 self.assertEqual(new.get_rep([3]).prefactor, 1)
1647
1648 def testspinsum(self):
1649
1650 obj = HelasLib.LorentzObject([],[1,2],[])
1651 obj.representation = HelasLib.LorentzObjectRepresentation(
1652 [[0, 0, 0, -1], [0, 0, -1, 0], [0, 1, 0, 0], [1, 0, 0,0]], [], [1,2], [])
1653
1654 obj2 = obj.expand()
1655 self.assertEqual(obj2.get_rep((0,3)), -1)
1656 self.assertEqual(obj2.get_rep((1,2)), -1)
1657 self.assertEqual(obj2.get_rep((2,1)), 1)
1658 self.assertEqual(obj2.get_rep((3,0)), 1)
1659
1660 new= obj * HelasObject.Spinor(2,2)
1661 new = new.simplify()
1662 new = new.expand()
1663 new = new.simplify()
1664 self.assertEqual(new.__class__, HelasLib.LorentzObjectRepresentation)
1665 self.assertEqual(new.spin_ind, [1])
1666 self.assertEqual(new.get_rep([3]), HelasLib.ScalarVariable('f2_1'))
1667 self.assertEqual(new.get_rep([2]), HelasLib.ScalarVariable('f2_2'))
1668 self.assertEqual(new.get_rep([1]), HelasLib.ScalarVariable('f2_3'))
1669 self.assertEqual(new.get_rep([0]), HelasLib.ScalarVariable('f2_4'))
1670 self.assertEqual(new.get_rep([0]).prefactor, -1)
1671 self.assertEqual(new.get_rep([1]).prefactor, -1)
1672 self.assertEqual(new.get_rep([2]).prefactor, 1)
1673 self.assertEqual(new.get_rep([3]).prefactor, 1)
1674
1675
1676
1677 def testsumofLorentzObj(self):
1678 """ Check the sumation of LorentzObject"""
1679
1680 sum = self.p1nu + self.p2nu
1681
1682 #check global
1683 self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))
1684 self.assertEquals(sum.lorentz_ind, [1])
1685 self.assertEqual(sum.spin_ind, [])
1686 self.assertEqual(sum.tag, ['p1','p2'])
1687
1688 #check the representation
1689 for ind in sum.listindices():
1690 rep = sum.get_rep(ind)
1691 self.assertEqual(rep.__class__, HelasLib.AddVariable)
1692 self.assertEqual(len(rep), 2)
1693 for data in rep:
1694 self.assertEqual(data.__class__, HelasLib.ScalarVariable)
1695
1696 ##
1697 ## check more complex with indices in wrong order
1698 ##
1699
1700 sum = self.p1nu * self.p2mu + self.p1mu * self.p2nu
1701
1702 #check global
1703 self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))
1704 self.assertEquals(sum.lorentz_ind, [1, 2])
1705 self.assertEqual(sum.spin_ind, [])
1706 tag = list(sum.tag)
1707
1708 #check the representation
1709 for ind in sum.listindices():
1710 rep = sum.get_rep(ind)
1711 if rep.prefactor == 1:
1712 self.assertEqual(rep.__class__, HelasLib.AddVariable)
1713 self.assertEqual(len(rep), 2)
1714 for data in rep:
1715 self.assertEqual(data.__class__, HelasLib.MultVariable)
1716 self.assertEqual(data.prefactor, 1)
1717 else:
1718 self.assertEqual(rep.__class__, HelasLib.MultVariable)
1719 self.assertEqual(len(rep), 2)
1720 self.assertEqual(rep.prefactor,2)
1721
1722 sum2 = sum - (self.p1nu * self.p2mu + self.p2nu * self.p1mu)
1723 for ind in sum2.listindices():
1724 rep = sum2.get_rep(ind)
1725 self.assertEqual(rep, 0)
1726
1727
1728 #check sum is unchanged
1729 self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))
1730 self.assertEquals(sum.lorentz_ind, [1, 2])
1731 self.assertEqual(sum.spin_ind, [])
1732 self.assertEqual(sum.tag, tag)
1733 for ind in sum.listindices():
1734 rep = sum.get_rep(ind)
1735 if rep.prefactor == 1:
1736 self.assertEqual(rep.__class__, HelasLib.AddVariable)
1737 self.assertEqual(len(rep), 2)
1738 for data in rep:
1739 self.assertEqual(data.__class__, HelasLib.MultVariable)
1740 self.assertEqual(data.prefactor,1)
1741 else:
1742 self.assertEqual(rep.__class__, HelasLib.MultVariable)
1743 self.assertEqual(len(rep), 2)
1744 self.assertEqual(rep.prefactor,2)
1745 self.assertEqual(sum, self.p1nu * self.p2mu + self.p1mu * self.p2nu)
1746
1747 sumbis = self.p1nu * self.p2mu + self.p1mu * self.p2nu
1748 for ind in sumbis.listindices():
1749 self.assertEqual(sumbis.get_rep(ind),sum.get_rep(ind))
1750
1751 sum -= sumbis
1752 for ind in sum.listindices():
1753 rep = sum.get_rep(ind)
1754 self.assertEqual(rep, 0)
1755 self.assertEqual(sum,sum2)
1756
1757 #check wrong sum
1758 self.assertRaises( \
1759 HelasLib.LorentzObjectRepresentation.LorentzObjectRepresentationError, \
1760 HelasLib.LorentzObjectRepresentation.__add__,self.p1nu,self.p2mu)
1761
1762class TestSomeObjectProperty(unittest.TestCase):
1763 """Test that some property pass correctly for Object"""
1764
1765 def testmassisdiffaswidth(self):
1766 """Ensure that a mass object is different of a width object"""
1767
1768 mass = HelasObject.Mass(1)
1769 width = HelasObject.Width(1)
1770 self.assertNotEqual(mass, width)
1771 self.assertNotEqual(mass * mass, mass * width)
1772
1773
1774 mass = mass.expand()
1775 width = width.expand()
1776 self.assertNotEqual(mass, width)
1777 self.assertNotEqual(mass * mass, mass * width)
1778
1779 mass = mass.simplify()
1780 width = width.simplify()
1781 self.assertNotEqual(mass, width)
1782 self.assertNotEqual(mass * mass, mass * width)
1783
1784 mass = HelasObject.Mass(1)
1785 width = HelasObject.Width(1)
1786 sum = mass * mass + mass * width
1787 sum.simplify()
1788 self.assertEqual(sum.__class__, HelasLib.AddVariable)
1789 self.assertEqual(len(sum), 2)
1790
1791 def testIdentityMatrix(self):
1792 """ Test the Identity Matrix"""
1793 Identity = HelasObject.Identity
1794 Gamma = HelasObject.Gamma
1795 Gamma5 = HelasObject.Gamma5
1796 Metric = HelasObject.Metric
1797
1798 #Test at low level
1799 obj1 = Gamma(1,1,2).expand()
1800 obj2 = Identity(1,3).expand() * Gamma(1,3,2).expand()
1801 self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)
1802 self.assertEqual(obj1.spin_ind, obj2.spin_ind)
1803 self.assertEqual(obj1, obj2)
1804
1805 #Gamma = Identity * Gamma
1806 obj1 = Gamma(1,1,2)
1807 obj2 = Identity(1,3) * Gamma(1,3,2)
1808 obj1 = obj1.simplify().expand().simplify()
1809 obj2 = obj2.simplify().expand().simplify()
1810 self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)
1811 self.assertEqual(obj1.spin_ind, obj2.spin_ind)
1812 for ind in obj1.listindices():
1813 self.assertEqual(obj1.get_rep(ind),obj2.get_rep(ind))
1814 self.assertEqual(obj1, obj2)
1815
1816 #Gamma = Identity * Identity * Gamma
1817 #at low level
1818 obj1 = Gamma(1,1,2).expand()
1819 obj2 = Identity(3,4).expand() * Gamma(1,4,2).expand()
1820 obj3 = Identity(1,3).expand() *obj2
1821 self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)
1822 self.assertEqual(obj1.lorentz_ind, obj3.lorentz_ind)
1823 self.assertEqual(obj2.spin_ind, [3,2])
1824 self.assertEqual(obj1.spin_ind, obj3.spin_ind)
1825 for ind in obj1.listindices():
1826 self.assertEqual(obj1.get_rep(ind),obj3.get_rep(ind))
1827 self.assertEqual(obj1, obj3)
1828
1829 #at High Level
1830 obj1 = Gamma(1,1,2)
1831 obj2 = Identity(1,3) * Identity(3,4)
1832 obj3 = obj2 * Gamma(1,4,2)
1833 obj1 = obj1.simplify().expand().simplify()
1834 obj2 = obj2.simplify().expand().simplify()
1835 obj3 = obj3.simplify().expand().simplify()
1836 #self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)
1837 self.assertEqual(obj1.lorentz_ind, obj3.lorentz_ind)
1838 self.assertEqual(obj2.spin_ind, [1,4])
1839 self.assertEqual(obj1.spin_ind, obj3.spin_ind)
1840 for ind in obj1.listindices():
1841 self.assertEqual(obj1.get_rep(ind),obj3.get_rep(ind))
1842 self.assertEqual(obj1, obj3)
1843
1844 #at High Level
1845 obj1 = Gamma(1,1,2)
1846 obj2 = Identity(1,3) * Identity(3,4) * Gamma(1,4,2)
1847 obj1 = obj1.simplify().expand().simplify()
1848 obj2 = obj2.simplify().expand().simplify()
1849 self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)
1850 self.assertEqual(obj2.spin_ind, [1,2])
1851 self.assertEqual(obj1.spin_ind, obj2.spin_ind)
1852 for ind in obj1.listindices():
1853 self.assertEqual(obj1.get_rep(ind),obj2.get_rep(ind))
1854 self.assertEqual(obj1, obj2)
1855
1856 def testGammaAlgebra(self):
1857 """Test the coherence between gamma/gamma5/sigma/projector"""
1858 Gamma = HelasObject.Gamma
1859 Gamma5 = HelasObject.Gamma5
1860 Sigma = HelasObject.Sigma
1861 ProjM = HelasObject.ProjM
1862 ProjP = HelasObject.ProjP
1863 Identity = HelasObject.Identity
1864 Metric = HelasObject.Metric
1865
1866 #Gamma5 = i *Gamma0 * Gamma1 * Gamma2 * Gamma3
1867 gamma5 = complex(0,1) * Gamma(0,1,2) * Gamma(1,2,3) * Gamma(2,3,4) * \
1868 Gamma(3,4,5)
1869 gamma5_2 = Gamma5(1,5)
1870
1871 gamma5 = gamma5.expand().simplify()
1872 gamma5_2 = gamma5_2.expand().simplify()
1873
1874 for ind in gamma5_2.listindices():
1875 component1 = gamma5.get_rep([0,1,2,3] + ind)
1876 component2 = gamma5_2.get_rep(ind)
1877 self.assertEqual(component1, component2)
1878
1879 #ProjP = (1+ Gamma5)/2
1880
1881 projp = 1/2 * (Identity(1,2) + Gamma5(1,2))
1882 projp = projp.simplify()
1883 projp = projp.expand()
1884 projp = projp.simplify()
1885
1886 projp2 = ProjP(1,2)
1887 projp2 = projp2.simplify()
1888 projp2 = projp2.expand()
1889 projp2 = projp2.simplify()
1890
1891 self.assertEqual(projp,projp2)
1892
1893 #ProjM = (1 - Gamma5)/2
1894
1895 projm = 1/2 * (Identity(1,2) - Gamma5(1,2))
1896 projm = projm.simplify()
1897 projm = projm.expand()
1898 projm = projm.simplify()
1899
1900 projm2 = ProjM(1,2)
1901 projm2 = projm2.simplify()
1902 projm2 = projm2.expand()
1903 projm2 = projm2.simplify()
1904
1905 self.assertEqual(projm,projm2)
1906
1907 # Identity = ProjP + ProjM
1908 identity= ProjM(1,2) + ProjP(1,2)
1909 identity = identity.simplify().expand().simplify()
1910
1911 identity2 = Identity(1,2)
1912 identity2 = identity2.simplify().expand().simplify()
1913
1914 self.assertEqual(identity,identity2)
1915
1916 #metric_mu_nu = 1/2 {Gamma_nu, Gamma_mu}
1917 metric = 1/2 * (Gamma(1,1,2)*Gamma(2,2,3) + Gamma(2,1,2)*Gamma(1,2,3))
1918 metric = metric.simplify().expand().simplify()
1919
1920 metric2 = Metric(1,2) * Identity(1,3)
1921 metric2 = metric2.simplify().expand().simplify()
1922 self.assertEqual(metric, metric2)
1923
1924 #Sigma_mu_nu = 1/(2i) * [Gamma_mu, Gamma_nu]
1925 sigma = complex(0, 1/2) * (Gamma(1,1,2)*Gamma(2,2,3) - Gamma(2,1,2)*Gamma(1,2,3))
1926 sigma = sigma.simplify().expand().simplify()
1927
1928 sigma2 = Sigma(1,2,1,3)
1929 sigma2 = sigma2.simplify().expand().simplify()
1930 self.assertEqual(sigma, sigma2)
1931class TestConstantObject(unittest.TestCase):
1932 """Check the different Operation for a Constant Object"""
1933
1934 def testsum(self):
1935
1936 const = HelasLib.ConstantObject(1)
1937 p = HelasObject.P(1,1)
1938
1939 sum = const + p
1940 self.assertEqual(type(sum),type(p))
1941 self.assertEqual(sum, p)
1942 self.assertEqual(sum.constant_term, 1)
1943
1944 p2 = HelasObject.P(1,2)
1945 add = p + p2
1946 sum = const + add
1947 self.assertEqual(type(sum),type(add))
1948 self.assertEqual(sum, add)
1949 self.assertEqual(sum.constant_term, 1)
1950
1951 p2 = HelasObject.P(1,2)
1952 add = p * p2
1953 sum = const + add
1954 self.assertEqual(type(sum),type(add))
1955 self.assertEqual(sum, add)
1956 self.assertEqual(sum.constant_term, 1)
1957
1958class TestSimplify(unittest.TestCase):
1959 """Check that the simplification works correctly"""
1960
1961 def testsimplifyMultLorentz(self):
1962
1963 # For Standard Product : No Simplification
1964 prod = HelasObject.Gamma(1, 2, 3) * HelasObject.Gamma(3, 4, 5)
1965
1966 simp = prod.simplify()
1967 self.assertEqual(simp, prod)
1968
1969 # Look if Multiply by Propagator
1970
1971 prod = HelasObject.Gamma(1, 2, 3) * HelasObject.SpinorPropagator(1, 2 ,3) / \
1972 HelasObject.DenominatorPropagator(3)
1973 simp = prod.simplify()
1974
1975 self.assertEqual(simp.__class__, HelasLib.FracVariable)
1976 self.assertEqual(simp.denominator.__class__, HelasLib.AddVariable)
1977 simp = simp.expand()
1978 simp = simp.simplify()
1979 self.assertEqual(simp.denominator.__class__, HelasLib.LorentzObjectRepresentation)
1980 denominator = simp.denominator.get_rep([0])
1981 for data in denominator:
1982 if HelasLib.ScalarVariable('p3_0') in data:
1983 self.assertEqual(data.prefactor, 1)
1984 elif HelasLib.ScalarVariable('p3_1') in data:
1985 self.assertEqual(data.prefactor, -1)
1986 elif HelasLib.ScalarVariable('p3_2') in data:
1987 self.assertEqual(data.prefactor, -1)
1988 elif HelasLib.ScalarVariable('p3_3') in data:
1989 self.assertEqual(data.prefactor, -1)
1990 elif HelasLib.ScalarVariable('width3') in data:
1991 self.assertEqual(data.prefactor, complex(0,1))
1992 elif HelasLib.ScalarVariable('mass3') in data:
1993 self.assertEqual(data.prefactor, -1)
1994
1995
1996 def testsimplifyFracVariable(self):
1997
1998 # For Standard Product : No Simplification
1999
2000
2001
2002
2003 prod = HelasObject.Gamma(1, 2, 3) * HelasObject.Gamma(3, 4, 5)
2004
2005 simp = prod.simplify()
2006 self.assertEqual(simp, prod)
2007
2008 # Look if Multiply by Propagator
2009
2010 prod = HelasObject.Gamma(1, 2, 3) * HelasObject.SpinorPropagator(1, 2 ,3) / \
2011 HelasObject.DenominatorPropagator(3)
2012 simp = prod.simplify()
2013
2014 self.assertEqual(simp.__class__, HelasLib.FracVariable)
2015 self.assertEqual(simp.denominator.__class__, HelasLib.AddVariable)
2016
2017