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
|
---|
16 | the output of the Feynman Rules."""
|
---|
17 | from __future__ import division
|
---|
18 | import unittest
|
---|
19 | import madgraph.interface.helasamp_object as HelasObject
|
---|
20 | import madgraph.interface.helasamp_lib as HelasLib
|
---|
21 |
|
---|
22 |
|
---|
23 | class 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 |
|
---|
377 | class 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 |
|
---|
634 | class 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 |
|
---|
965 | class 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 |
|
---|
1115 | class 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 |
|
---|
1306 | class 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 |
|
---|
1762 | class 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)
|
---|
1931 | class 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 |
|
---|
1958 | class 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 |
|
---|