Merge lp:~maddevelopers/mg5amcnlo/aloha_debug_spin32 into lp:~madteam/mg5amcnlo/trunk

[Olivier Mattelaer]

ALOHA UPDATE
* Allow a New Object PSlash
* DEFINE SPIN 3/2 propagator (Not full support of spin3/2 yet)
* Change Sigma definition to i/4 [gamma_mu, gamma_nu]
FIX
* allow for power of mass larger than two
* fix a problem when adding two spinorial tensor with index not define in the same order

[Johan Alwall (johan-alwall)]

Hello Olivier,

For the ALOHA-specific parts I don't have any opinion, there I trust you and Priscila. Besides that I'm happy to see that you have written proper tests for all new functionality. Did you also test the bugs that you fixed?

Thanks!
Johan

review: Needs Information

[Olivier Mattelaer (olivier-mattelaer)]

Hi Johan,

> Besides that I'm happy to see that you have written proper tests
> for all new functionality.

Sure, that's very very important in the case of aloha where the
structure of the code is quite advance and tricky.

> Did you also test the bugs that you fixed?

In fact that the test of the new functionality who make me discover
those bugs.
But beyond those tests, I have indeed add some specific tests
associated to those bugs.

Thanks,

Olivier

On 09-août-11, at 23:13, Johan Alwall wrote:

> Review: Needs Information
> Hello Olivier,
>
> For the ALOHA-specific parts I don't have any opinion, there I trust
> you and Priscila. Besides that I'm happy to see that you have
> written proper tests for all new functionality. Did you also test
> the bugs that you fixed?
>
> Thanks!
> Johan
> --
> https://code.launchpad.net/~maddevelopers/madgraph5/
> aloha_debug_spin32/+merge/70943
> Your team MadDevelopers is subscribed to branch lp:~maddevelopers/
> madgraph5/aloha_debug_spin32.

[Johan Alwall (johan-alwall)]

review: Approve

[Olivier Mattelaer (olivier-mattelaer)]

I discussed with Priscila, and she also approve :D
So I'm going to merge it.

=== modified file 'aloha/__init__.py'
--- aloha/__init__.py	2010-06-09 22:12:44 +0000
+++ aloha/__init__.py	2011-08-09 19:07:29 +0000
@@ -0,0 +1,1 @@
+#depth = 0 # for debug
\ No newline at end of file

=== modified file 'aloha/aloha_lib.py'
--- aloha/aloha_lib.py	2011-03-21 16:10:45 +0000
+++ aloha/aloha_lib.py	2011-08-09 19:07:29 +0000
@@ -264,7 +264,8 @@
         new = self[0].expand()
         for item in self[1:]:
             obj = item.expand()
-            new += obj      
+            new += obj
+
         return new
         
     
@@ -421,6 +422,7 @@
         maxvar = maxvar.__class__(maxvar.variable)
         if max <= 1:
             #no factorization possible
+            #aloha.depth -=1
             return self
         else:
             # split in MAXVAR * NEWADD + CONSTANT
@@ -430,6 +432,7 @@
             #fill NEWADD and CONSTANT
             for term in self:
                 if maxvar == term:
+                    term = term.copy()
                     term.power -= 1
                     if term.power:
                         newadd.append(term.simplify())
@@ -453,15 +456,21 @@
                     constant.append(term)
 
             #factorize the result
-            if len(newadd) > 1:
+            try:
+                cur_len = len(newadd)
+            except:
+                cur_len = 0
+            if cur_len > 1:
                 try:
                     newadd = newadd.factorize()
-                except:
-                    raise Exception('fail to factorize')
+                except Exception, error:
+                    raise
+                    #raise Exception('fail to factorize: %s' % error)
             else:
                 #take away the useless AddVariable to going back to a Variable class
                 newadd = newadd[0]
 
+
             # recombine the factor. First ensure that the power of the object is
             #one. Then recombine
             if maxvar.power > 1:
@@ -484,10 +493,11 @@
             if constant:
                 constant = constant.factorize()
                 #aloha.depth -=1
-                #print ' ' * 4 * aloha.depth + 'return', AddVariable([newadd, constant])
+                # ' ' * 4 * aloha.depth + 'return', AddVariable([newadd, constant])
                 return AddVariable([newadd, constant])
             else:
                 if constant.vartype == 5 and constant != 0:
+                    #aloha.depth -=1
                     return AddVariable([newadd, constant])
                 #aloha.depth -=1
                 #print ' ' * 4 * aloha.depth + 'return:', newadd
@@ -824,7 +834,10 @@
         
     def __eq__(self, obj):
         """ identical if the variable is the same """
-        return not obj.vartype and self.variable == obj.variable
+        if hasattr(obj,'vartype'):
+            return not obj.vartype and self.variable == obj.variable
+        else:
+            return False
         
     def __str__(self):
         text = ''
@@ -918,7 +931,7 @@
         """ expand each part of the product and combine them.
             Try to use a smart order in order to minimize the number of uncontracted indices.
         """
-        
+
         self.unused = self[:] # list of not expanded
         # made in a list the intersting starting point for the computation
         basic_end_point = [var for var in self if var.contract_first] 
@@ -927,7 +940,6 @@
         
         while self.unused:
             #Loop untill we have expand everything
-            
             if not current:
                 # First we need to have a starting point
                 try: 
@@ -1196,9 +1208,16 @@
                 return self.representation
             else:
                 return self.prefactor * self.representation
-        else:
-            # not possible to have power beyon 2
+        elif self.power == 2:
+            # not possible to have power beyon 2 except for scalar object
             return self.prefactor * self.representation * self.representation
+        else:
+            assert self.lorentz_ind == self.spin_ind == []
+            name =  self.representation.get_rep([0]).variable
+            new = ScalarVariable(name, prefactor=self.prefactor,
+                                                               power=self.power)
+            return LorentzObjectRepresentation(
+                                new, self.lorentz_ind, self.spin_ind)
         
     def create_representation(self):
         raise self.VariableError("This Object %s doesn't have define representation" % self.__class__.__name__)
@@ -1298,7 +1317,6 @@
     def __add__(self, obj, fact=1):
         assert(obj.vartype == 4 == self.vartype) # are LorentzObjectRepresentation
         
-        
         if self.lorentz_ind != obj.lorentz_ind or self.spin_ind != obj.spin_ind:
             # if the order of indices are different compute a mapping 
             switch_order = []
@@ -1316,7 +1334,7 @@
                     index = obj.spin_ind.index(value)
                 except:
                     raise self.LorentzObjectRepresentationError("Invalid" + \
-                                "addition. Object doen't have the same indices")
+                                "addition. Object doen't have the same indices %s != %s" % (self.spin_ind, obj.spin_ind) )
                 else:
                     switch_order.append(self.nb_lor + index)            
             switch = lambda ind : tuple([ind[switch_order[i]] for i in range(len(ind))])
@@ -1324,20 +1342,24 @@
             # no mapping needed (define switch as identity)
             switch = lambda ind : (ind)
    
-        assert tuple(self.lorentz_ind) == tuple(switch(obj.lorentz_ind)), '%s!=%s' % (self.lorentz_ind, switch(obj.lorentz_ind))
-
+        
+        assert tuple(self.lorentz_ind+self.spin_ind) == tuple(switch(obj.lorentz_ind+obj.spin_ind)), '%s!=%s' % (self.lorentz_ind+self.spin_ind, switch(obj.lorentz_ind+self.spin_ind))
+        assert tuple(self.lorentz_ind) == tuple(switch(obj.lorentz_ind)), '%s!=%s' % (tuple(self.lorentz_ind), switch(obj.lorentz_ind))
+        
         # define an empty representation
-        new = LorentzObjectRepresentation({}, obj.lorentz_ind, self.spin_ind)
+        new = LorentzObjectRepresentation({}, obj.lorentz_ind, obj.spin_ind)
         
         # loop over all indices and fullfill the new object         
         if fact == 1:
             for ind in self.listindices():
                 value = obj.get_rep(ind) + self.get_rep(switch(ind))
+                #value = self.get_rep(ind) + obj.get_rep(switch(ind))
                 new.set_rep(ind, value)
         else:
             for ind in self.listindices():
                 #permute index for the second object
                 value = self.get_rep(switch(ind)) + fact * obj.get_rep(ind)
+                #value = fact * obj.get_rep(switch(ind)) + self.get_rep(ind)
                 new.set_rep(ind, value)            
 
         return new

=== modified file 'aloha/aloha_object.py'
--- aloha/aloha_object.py	2011-03-17 10:52:14 +0000
+++ aloha/aloha_object.py	2011-08-09 19:07:29 +0000
@@ -59,6 +59,44 @@
                                     self.lorentz_ind, [])
 
 #===============================================================================
+# Pslash
+#===============================================================================
+class PSlash(aloha_lib.LorentzObject):
+    """ Gamma Matrices """
+    
+    #gamma0 = [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]]
+    #gamma1 = [[0, 0, 0, 1], [0, 0, 1, 0], [0, -1, 0, 0], [-1, 0, 0, 0]]
+    #gamma2 = [[0, 0, 0, -complex(0,1)],[0, 0, complex(0,1), 0],
+    #                    [0, complex(0,1), 0, 0], [-complex(0,1), 0, 0, 0]]
+    #gamma3 = [[0, 0, 1, 0], [0, 0, 0, -1], [-1, 0, 0, 0], [0, 1, 0, 0]]
+    #    
+    #gamma = [gamma0, gamma1, gamma2, gamma3]
+
+    def __init__(self, spin1, spin2, particle, prefactor=1):
+        
+        self.particle = particle
+        aloha_lib.LorentzObject.__init__(self,[], [spin1, spin2], \
+                                                            prefactor=prefactor)
+    
+    def create_representation(self):
+        """create representation"""
+        p0 = aloha_lib.ScalarVariable('P%s_0' % self.particle)
+        p1 = aloha_lib.ScalarVariable('P%s_1' % self.particle)
+        p2 = aloha_lib.ScalarVariable('P%s_2' % self.particle)
+        p3 = aloha_lib.ScalarVariable('P%s_3' % self.particle)    
+    
+    
+        gamma = {
+             (0, 0): 0, (0, 1): 0, (0, 2): p0-p3, (0, 3): -1*p1+1j*p2,
+             (1, 0): 0, (1, 1): 0, (1, 2): -1*p1-1j*p2, (1, 3): p0+p3,
+             (2, 0): p0+p3, (2, 1): p1-1j*p2, (2, 2): 0, (2, 3): 0,
+             (3, 0): p1+1j*p2, (3, 1): p0-p3, (3, 2): 0, (3, 3): 0}
+
+                
+        self.representation = aloha_lib.LorentzObjectRepresentation(gamma,
+                                self.lorentz_ind,self.spin_ind)
+
+#===============================================================================
 # Mass
 #===============================================================================
 class Mass(aloha_lib.LorentzObject):
@@ -180,7 +218,52 @@
                                     {(0,): self.sub0, (1,): self.sub1, \
                                      (2,): self.sub2, (3,): self.sub3},  
                                     self.lorentz_ind, [])
-        
+
+#===============================================================================
+# Spin3/2
+#===============================================================================
+class Spin2(aloha_lib.LorentzObject):
+    """ Helas Object for a Spin2"""
+    
+    def __init__(self, lorentz, spin, particle, prefactor=1):
+        
+        self.particle = particle
+            
+        aloha_lib.LorentzObject.__init__(self, [lorentz], [spin], \
+                                 prefactor=prefactor)
+    
+    def create_representation(self):
+
+        self.sub00 = aloha_lib.ScalarVariable('R%s_1' % self.particle)
+        self.sub01 = aloha_lib.ScalarVariable('R%s_2' % self.particle)
+        self.sub02 = aloha_lib.ScalarVariable('R%s_3' % self.particle)
+        self.sub03 = aloha_lib.ScalarVariable('R%s_4' % self.particle)
+
+        self.sub10 = aloha_lib.ScalarVariable('R%s_5' % self.particle)
+        self.sub11 = aloha_lib.ScalarVariable('R%s_6' % self.particle)
+        self.sub12 = aloha_lib.ScalarVariable('R%s_7' % self.particle)
+        self.sub13 = aloha_lib.ScalarVariable('R%s_8' % self.particle)
+    
+        self.sub20 = aloha_lib.ScalarVariable('R%s_9' % self.particle)
+        self.sub21 = aloha_lib.ScalarVariable('R%s_10' % self.particle)
+        self.sub22 = aloha_lib.ScalarVariable('R%s_11' % self.particle)
+        self.sub23 = aloha_lib.ScalarVariable('R%s_12' % self.particle)
+    
+        self.sub30 = aloha_lib.ScalarVariable('R%s_13' % self.particle)
+        self.sub31 = aloha_lib.ScalarVariable('R%s_14' % self.particle)
+        self.sub32 = aloha_lib.ScalarVariable('R%s_15' % self.particle)
+        self.sub33 = aloha_lib.ScalarVariable('R%s_16' % self.particle)
+        
+        rep = {(0,0): self.sub00, (0,1): self.sub01, (0,2): self.sub02, (0,3): self.sub03,
+               (1,0): self.sub10, (1,1): self.sub11, (1,2): self.sub12, (1,3): self.sub13,
+               (2,0): self.sub20, (2,1): self.sub21, (2,2): self.sub22, (2,3): self.sub23,
+               (3,0): self.sub30, (3,1): self.sub31, (3,2): self.sub32, (3,3): self.sub33}
+        
+                
+        self.representation= aloha_lib.LorentzObjectRepresentation( rep, \
+                                    self.lorentz_ind, self.spin_ind)
+
+
 #===============================================================================
 # Spin2
 #===============================================================================
@@ -279,7 +362,9 @@
 # Sigma
 #===============================================================================
 class Sigma(aloha_lib.LorentzObject):
-    """ Gamma Matrices """
+    """ Sigma Matrices """
+    
+    
     
     #zero = [[0,0,0,0]]*4
     #i = complex(0,1)
@@ -303,69 +388,69 @@
     #        [inv(sigma02), inv(sigma12), zero, sigma23],\
     #        [inv(sigma03), inv(sigma13), inv(sigma23), zero]]
 
-    sigma={(0, 2, 0, 1): -1, (3, 1, 2, 0): 0, (3, 2, 3, 1): 0, (1, 3, 1, 3): 0, 
-           (2, 3, 3, 2): 1, (2, 1, 3, 1): 0, (0, 2, 2, 1): 0, (3, 1, 0, 0): 0, 
+    sigma={(0, 2, 0, 1): -0.5, (3, 1, 2, 0): 0, (3, 2, 3, 1): 0, (1, 3, 1, 3): 0, 
+           (2, 3, 3, 2): 0.5, (2, 1, 3, 1): 0, (0, 2, 2, 1): 0, (3, 1, 0, 0): 0, 
            (2, 3, 3, 1): 0, (3, 3, 1, 2): 0, (3, 1, 0, 3): 0, (1, 1, 0, 3): 0, 
-           (0, 1, 2, 2): 0, (3, 2, 3, 2): -1, (2, 1, 0, 1): 0, (3, 3, 3, 3): 0, 
+           (0, 1, 2, 2): 0, (3, 2, 3, 2): -0.5, (2, 1, 0, 1): 0, (3, 3, 3, 3): 0, 
            (1, 1, 2, 2): 0, (2, 2, 3, 2): 0, (2, 1, 2, 1): 0, (0, 1, 0, 3): 0, 
-           (2, 1, 2, 2): -1, (1, 2, 2, 1): 0, (2, 2, 1, 3): 0, (0, 3, 1, 3): 0, 
+           (2, 1, 2, 2): -0.5, (1, 2, 2, 1): 0, (2, 2, 1, 3): 0, (0, 3, 1, 3): 0, 
            (3, 0, 3, 2): 0, (1, 2, 0, 1): 0, (3, 0, 3, 1): 0, (0, 0, 2, 2): 0, 
            (1, 2, 0, 2): 0, (2, 0, 0, 3): 0, (0, 0, 2, 1): 0, (0, 3, 3, 2): 0, 
-           (3, 0, 1, 1): -1j, (3, 2, 0, 1): -1, (1, 0, 1, 0): 1j, (0, 0, 0, 1): 0,
-            (0, 2, 1, 1): 0, (3, 1, 3, 2): 1j, (3, 2, 2, 1): 0, (1, 3, 2, 3): 1j, 
+           (3, 0, 1, 1): -0.5j, (3, 2, 0, 1): -0.5, (1, 0, 1, 0): 0.5j, (0, 0, 0, 1): 0,
+            (0, 2, 1, 1): 0, (3, 1, 3, 2): 0.5j, (3, 2, 2, 1): 0, (1, 3, 2, 3): 0.5j, 
             (1, 0, 3, 0): 0, (3, 2, 2, 2): 0, (0, 2, 3, 1): 0, (1, 0, 3, 3): 0, 
-            (2, 3, 2, 1): 0, (0, 2, 3, 2): -1, (3, 1, 1, 3): 0, (1, 1, 1, 3): 0, 
-            (1, 3, 0, 2): 0, (2, 3, 0, 1): 1, (1, 1, 1, 0): 0, (2, 3, 0, 2): 0, 
+            (2, 3, 2, 1): 0, (0, 2, 3, 2): -0.5, (3, 1, 1, 3): 0, (1, 1, 1, 3): 0, 
+            (1, 3, 0, 2): 0, (2, 3, 0, 1): 0.5, (1, 1, 1, 0): 0, (2, 3, 0, 2): 0, 
             (3, 3, 0, 3): 0, (1, 1, 3, 0): 0, (0, 1, 3, 3): 0, (2, 2, 0, 1): 0, 
-            (2, 1, 1, 0): 0, (3, 3, 2, 2): 0, (2, 3, 1, 0): 1, (2, 2, 2, 3): 0, 
-            (0, 3, 0, 3): 0, (0, 1, 1, 2): 0, (0, 3, 0, 0): -1j, (2, 3, 1, 1): 0, 
+            (2, 1, 1, 0): 0, (3, 3, 2, 2): 0, (2, 3, 1, 0): 0.5, (2, 2, 2, 3): 0, 
+            (0, 3, 0, 3): 0, (0, 1, 1, 2): 0, (0, 3, 0, 0): -0.5j, (2, 3, 1, 1): 0, 
             (1, 2, 3, 0): 0, (2, 0, 1, 3): 0, (0, 0, 3, 1): 0, (0, 3, 2, 0): 0, 
-            (2, 3, 1, 2): 0, (2, 0, 1, 0): -1, (1, 2, 1, 0): 0, (3, 0, 0, 2): 0, 
+            (2, 3, 1, 2): 0, (2, 0, 1, 0): -0.5, (1, 2, 1, 0): 0, (3, 0, 0, 2): 0, 
             (1, 0, 0, 2): 0, (0, 0, 1, 1): 0, (1, 2, 1, 3): 0, (2, 3, 1, 3): 0, 
-            (2, 0, 3, 0): 0, (0, 0, 1, 2): 0, (1, 3, 3, 3): 0, (3, 2, 1, 0): -1, 
-            (1, 3, 3, 0): 0, (1, 0, 2, 3): -1j, (0, 2, 0, 0): 0, (3, 1, 2, 3): -1j, 
-            (3, 2, 3, 0): 0, (1, 3, 1, 0): -1j, (3, 2, 3, 3): 0, (0, 2, 2, 0): 0, 
-            (2, 3, 3, 0): 0, (3, 3, 1, 3): 0, (0, 2, 2, 3): 1, (3, 1, 0, 2): 0, 
-            (1, 1, 0, 2): 0, (3, 3, 1, 0): 0, (0, 1, 2, 3): 1j, (1, 1, 0, 1): 0,
+            (2, 0, 3, 0): 0, (0, 0, 1, 2): 0, (1, 3, 3, 3): 0, (3, 2, 1, 0): -0.5, 
+            (1, 3, 3, 0): 0, (1, 0, 2, 3): -0.5j, (0, 2, 0, 0): 0, (3, 1, 2, 3): -0.5j, 
+            (3, 2, 3, 0): 0, (1, 3, 1, 0): -0.5j, (3, 2, 3, 3): 0, (0, 2, 2, 0): 0, 
+            (2, 3, 3, 0): 0, (3, 3, 1, 3): 0, (0, 2, 2, 3): 0.5, (3, 1, 0, 2): 0, 
+            (1, 1, 0, 2): 0, (3, 3, 1, 0): 0, (0, 1, 2, 3): 0.5j, (1, 1, 0, 1): 0,
             (2, 1, 0, 2): 0, (0, 1, 2, 0): 0, (3, 3, 3, 0): 0, (1, 1, 2, 1): 0,
             (2, 2, 3, 3): 0, (0, 1, 0, 0): 0, (2, 2, 3, 0): 0, (2, 1, 2, 3): 0,
-            (1, 2, 2, 2): 1, (2, 2, 1, 0): 0, (0, 3, 1, 2): 0, (0, 3, 1, 1): 1j, 
+            (1, 2, 2, 2): 0.5, (2, 2, 1, 0): 0, (0, 3, 1, 2): 0, (0, 3, 1, 1): 0.5j, 
             (3, 0, 3, 0): 0, (1, 2, 0, 3): 0, (2, 0, 0, 2): 0, (0, 0, 2, 0): 0, 
-            (0, 3, 3, 1): 0, (3, 0, 1, 0): 0, (2, 0, 0, 1): 1, (3, 2, 0, 2): 0, 
+            (0, 3, 3, 1): 0, (3, 0, 1, 0): 0, (2, 0, 0, 1): 0.5, (3, 2, 0, 2): 0, 
             (3, 0, 1, 3): 0, (1, 0, 1, 3): 0, (0, 0, 0, 0): 0, (0, 2, 1, 2): 0, 
             (3, 1, 3, 3): 0, (0, 0, 0, 3): 0, (1, 3, 2, 2): 0, (3, 1, 3, 0): 0, 
-            (3, 2, 2, 3): -1, (1, 3, 2, 1): 0, (1, 0, 3, 2): -1j, (2, 3, 2, 2): 0, 
-            (0, 2, 3, 3): 0, (3, 1, 1, 0): 1j, (1, 3, 0, 1): 1j, (1, 1, 1, 1): 0, 
+            (3, 2, 2, 3): -0.5, (1, 3, 2, 1): 0, (1, 0, 3, 2): -0.5j, (2, 3, 2, 2): 0, 
+            (0, 2, 3, 3): 0, (3, 1, 1, 0): 0.5j, (1, 3, 0, 1): 0.5j, (1, 1, 1, 1): 0, 
             (2, 1, 3, 2): 0, (2, 3, 0, 3): 0, (3, 3, 0, 2): 0, (1, 1, 3, 1): 0, 
-            (3, 3, 0, 1): 0, (2, 1, 3, 3): 1, (0, 1, 3, 2): 1j, (1, 1, 3, 2): 0, 
+            (3, 3, 0, 1): 0, (2, 1, 3, 3): 0.5, (0, 1, 3, 2): 0.5j, (1, 1, 3, 2): 0, 
             (2, 1, 1, 3): 0, (3, 0, 2, 1): 0, (0, 1, 3, 1): 0, (3, 3, 2, 1): 0, 
             (2, 2, 2, 2): 0, (0, 1, 1, 1): 0, (2, 2, 2, 1): 0, (0, 3, 0, 1): 0, 
-            (3, 0, 2, 2): -1j, (1, 2, 3, 3): -1, (0, 0, 3, 2): 0, (0, 3, 2, 1): 0, 
-            (2, 0, 1, 1): 0, (2, 2, 0, 0): 0, (0, 3, 2, 2): 1j, (3, 0, 0, 3): 0, 
+            (3, 0, 2, 2): -0.5j, (1, 2, 3, 3): -0.5, (0, 0, 3, 2): 0, (0, 3, 2, 1): 0, 
+            (2, 0, 1, 1): 0, (2, 2, 0, 0): 0, (0, 3, 2, 2): 0.5j, (3, 0, 0, 3): 0, 
             (1, 0, 0, 3): 0, (1, 2, 1, 2): 0, (2, 0, 3, 1): 0, (1, 0, 0, 0): 0, 
-            (0, 0, 1, 3): 0, (2, 0, 3, 2): 1, (3, 2, 1, 3): 0, (1, 3, 3, 1): 0, 
+            (0, 0, 1, 3): 0, (2, 0, 3, 2): 0.5, (3, 2, 1, 3): 0, (1, 3, 3, 1): 0, 
             (1, 0, 2, 0): 0, (2, 2, 0, 2): 0, (0, 2, 0, 3): 0, (3, 1, 2, 2): 0, 
             (1, 3, 1, 1): 0, (3, 1, 2, 1): 0, (2, 2, 0, 3): 0, (3, 0, 0, 1): 0, 
-            (1, 3, 1, 2): 0, (2, 3, 3, 3): 0, (0, 2, 2, 2): 0, (3, 1, 0, 1): -1j, 
+            (1, 3, 1, 2): 0, (2, 3, 3, 3): 0, (0, 2, 2, 2): 0, (3, 1, 0, 1): -0.5j, 
             (3, 3, 1, 1): 0, (1, 1, 0, 0): 0, (2, 1, 0, 3): 0, (0, 1, 2, 1): 0, 
-            (3, 3, 3, 1): 0, (2, 1, 0, 0): -1, (1, 1, 2, 0): 0, (3, 3, 3, 2): 0, 
-            (0, 1, 0, 1): -1j, (1, 1, 2, 3): 0, (2, 2, 3, 1): 0, (2, 1, 2, 0): 0,
+            (3, 3, 3, 1): 0, (2, 1, 0, 0): -0.5, (1, 1, 2, 0): 0, (3, 3, 3, 2): 0, 
+            (0, 1, 0, 1): -0.5j, (1, 1, 2, 3): 0, (2, 2, 3, 1): 0, (2, 1, 2, 0): 0,
              (0, 1, 0, 2): 0, (1, 2, 2, 3): 0, (2, 0, 2, 1): 0, (2, 2, 1, 1): 0, 
-             (1, 2, 2, 0): 0, (2, 2, 1, 2): 0, (0, 3, 1, 0): 0, (3, 0, 3, 3): 1j, 
-             (2, 1, 3, 0): 0, (1, 2, 0, 0): 1, (0, 0, 2, 3): 0, (0, 3, 3, 0): 0, 
-             (2, 0, 0, 0): 0, (3, 2, 0, 3): 0, (0, 3, 3, 3): -1j, (3, 0, 1, 2): 0, 
+             (1, 2, 2, 0): 0, (2, 2, 1, 2): 0, (0, 3, 1, 0): 0, (3, 0, 3, 3): 0.5j, 
+             (2, 1, 3, 0): 0, (1, 2, 0, 0): 0.5, (0, 0, 2, 3): 0, (0, 3, 3, 0): 0, 
+             (2, 0, 0, 0): 0, (3, 2, 0, 3): 0, (0, 3, 3, 3): -0.5j, (3, 0, 1, 2): 0, 
              (1, 0, 1, 2): 0, (3, 2, 0, 0): 0, (0, 2, 1, 3): 0, (1, 0, 1, 1): 0, 
-             (0, 0, 0, 2): 0, (0, 2, 1, 0): 1, (3, 1, 3, 1): 0, (3, 2, 2, 0): 0, 
-             (1, 3, 2, 0): 0, (1, 0, 3, 1): 0, (2, 3, 2, 3): 1, (0, 2, 3, 0): 0, 
+             (0, 0, 0, 2): 0, (0, 2, 1, 0): 0.5, (3, 1, 3, 1): 0, (3, 2, 2, 0): 0, 
+             (1, 3, 2, 0): 0, (1, 0, 3, 1): 0, (2, 3, 2, 3): 0.5, (0, 2, 3, 0): 0, 
              (3, 1, 1, 1): 0, (2, 3, 2, 0): 0, (1, 3, 0, 0): 0, (3, 1, 1, 2): 0, 
              (1, 1, 1, 2): 0, (1, 3, 0, 3): 0, (2, 3, 0, 0): 0, (2, 0, 2, 0): 0, 
              (3, 3, 0, 0): 0, (1, 1, 3, 3): 0, (2, 1, 1, 2): 0, (0, 1, 3, 0): 0, 
-             (3, 3, 2, 0): 0, (2, 1, 1, 1): 1, (2, 0, 2, 2): 0, (3, 3, 2, 3): 0, 
-             (0, 1, 1, 0): -1j, (2, 2, 2, 0): 0, (0, 3, 0, 2): 0, (3, 0, 2, 3): 0, 
-             (0, 1, 1, 3): 0, (2, 0, 2, 3): -1, (1, 2, 3, 2): 0, (3, 0, 2, 0): 0, 
+             (3, 3, 2, 0): 0, (2, 1, 1, 1): 0.5, (2, 0, 2, 2): 0, (3, 3, 2, 3): 0, 
+             (0, 1, 1, 0): -0.5j, (2, 2, 2, 0): 0, (0, 3, 0, 2): 0, (3, 0, 2, 3): 0, 
+             (0, 1, 1, 3): 0, (2, 0, 2, 3): -0.5, (1, 2, 3, 2): 0, (3, 0, 2, 0): 0, 
              (0, 0, 3, 3): 0, (1, 2, 3, 1): 0, (2, 0, 1, 2): 0, (0, 0, 3, 0): 0, 
-             (0, 3, 2, 3): 0, (3, 0, 0, 0): 1j, (1, 2, 1, 1): -1, (1, 0, 0, 1): 1j, 
-             (0, 0, 1, 0): 0, (2, 0, 3, 3): 0, (3, 2, 1, 2): 0, (1, 3, 3, 2): -1j, 
+             (0, 3, 2, 3): 0, (3, 0, 0, 0): 0.5j, (1, 2, 1, 1): -0.5, (1, 0, 0, 1): 0.5j, 
+             (0, 0, 1, 0): 0, (2, 0, 3, 3): 0, (3, 2, 1, 2): 0, (1, 3, 3, 2): -0.5j, 
              (1, 0, 2, 1): 0, (3, 2, 1, 1): 0, (0, 2, 0, 2): 0, (1, 0, 2, 2): 0}
 
     def __init__(self, lorentz1, lorentz2, spin1, spin2, prefactor=1):
@@ -687,6 +772,21 @@
 VectorPropagator = lambda l1, l2, part: complex(0,1) * (-1 * Metric(l1, l2) + OverMass2(part) * \
                                     Metric(l1,'I3')* P('I3', part) * P(l2, part))
 
+#Spin3halfPropagator =  lambda mu, nu, s1, s2, part: -1*( Gamma(-1,s1,s2)*P(-1,part) + Identity(s1,s2)*Mass(part)) * (Metric(mu,nu)-Metric(mu,'I3')*P('I3',part)*P(nu,part)*OverMass2(part)) \
+#         - 1/3 * (Gamma(mu,s1,-2) + Identity(s1, -2) *  P(mu, part) * Mass(part) * OverMass2(part))* \
+#                             (Gamma('alpha',-2,-3) * P('alpha', part) - Identity(-2,-3) * Mass(part)) \
+#                             * (Gamma(nu, -3, s2) + Identity(-3, s2) * P(nu, part) * Mass(part) * OverMass2(part) ) \
+#            -1*( Gamma(-1,s1,s2)*P(-1,part) + Identity(s1,s2)*Mass(part)) * (Metric(mu,nu)-Metric(mu,'I3')*P('I3',part)*P(nu,part)*OverMass2(part)) \
+
+Spin3halfPropagator =  lambda mu, nu, s1, s2, part:  - 1/3 * (Gamma(mu,s1,-2) + Identity(s1, -2) *  P(mu, part) * Mass(part) * OverMass2(part))* \
+                             (PSlash(-2,-3, part) - Identity(-2,-3) * Mass(part)) * \
+                             ( Gamma(nu, -3, s2)+ Mass(part) * OverMass2(part) * Identity(-3, s2) * P(nu, part) )
+
+Spin3halfPropagator =  lambda mu, nu, s1, s2, part:  - 1/3 * (Gamma(mu,s1,-2) + Identity(s1, -2) *  P(mu, part) * Mass(part) * OverMass2(part))* \
+                             (PSlash(-2,-3, part) - Identity(-2,-3) * Mass(part)) * \
+                             ( Gamma(nu, -3, s2)+ Mass(part) * OverMass2(part) * Identity(-3, s2) * P(nu, part) )
+                             
+
 Spin2masslessPropagator = lambda mu, nu, alpha, beta: complex(0,1/2)*( Metric(mu, alpha)* Metric(nu, beta) +\
                      Metric(mu, beta) * Metric(nu, alpha) - Metric(mu, nu) * Metric(alpha, beta))
 

=== removed file 'models/mssm/._.DS_Store'
Binary files models/mssm/._.DS_Store	2010-08-11 15:35:33 +0000 and models/mssm/._.DS_Store	1970-01-01 00:00:00 +0000 differ
=== modified file 'tests/unit_tests/various/test_aloha.py'
--- tests/unit_tests/various/test_aloha.py	2011-07-22 12:29:10 +0000
+++ tests/unit_tests/various/test_aloha.py	2011-08-09 19:07:29 +0000
@@ -16,6 +16,7 @@
 the output of the Feynman Rules."""
 from __future__ import division
 
+import math
 import os
 import time
 import aloha.aloha_object as aloha_obj
@@ -25,6 +26,7 @@
 import models.sm.object_library as object_library
 import tests.unit_tests as unittest
 
+
 class TestVariable(unittest.TestCase):
 
     def setUp(self):
@@ -474,7 +476,6 @@
         sum = p1 * p2 + p1 * p3 + 2 * p1 + 2 *p1 * p2 * p4
         sum = sum.factorize()
         #Should return p1*(p2(2*p4 + 1) + p3 + 2)
-    
         self.assertEqual(sum.__class__,aloha_lib.MultVariable)
         self.assertEqual(len(sum),2)
         for fact in sum:
@@ -580,6 +581,32 @@
         self.assertEqual(eval(str(expr1)), value)
 
 
+    def test_factorization5(self):
+        """check that P [gamma + P/M] == (/p+M) [Onshell]"""
+
+        P1_0 = aloha_lib.ScalarVariable('p1')
+        P1_1 = aloha_lib.ScalarVariable('p2')
+        P1_2 = aloha_lib.ScalarVariable('p3')
+        P1_3 = aloha_lib.ScalarVariable('p4')        
+        M1  = aloha_lib.ScalarVariable('m1') 
+    
+        p1, p2, p3, p4, m1 = 1,2,3,4,5
+    
+        data = (P1_0**2 * M1 - P1_1**2 * M1 + M1)
+        value = eval(str(data))
+        data2 = data.factorize()
+        self.assertEqual(eval(str(data2)), value)
+        
+        #check that original object is still un-touched
+        self.assertEqual(eval(str(data)), value)
+
+
+
+    
+
+
+
+
     
 class TestMultVariable(unittest.TestCase):
 
@@ -1245,7 +1272,96 @@
             self.assertEqual(low_level.get_rep(ind).__class__, aloha_lib.MultVariable)
             self.assertEqual(low_level.get_rep(ind), aloha_lib.ScalarVariable('M3') 
                                 * aloha_lib.ScalarVariable('P2_%s' % ind[0]))
-            
+    
+    
+    def test_spin32propagator(self):
+        """check various property of the spin3/2 propagator"""
+        
+        Metric = aloha_obj.Metric
+        P = aloha_obj.P
+        OM = aloha_obj.OverMass2
+        Gamma = aloha_obj.Gamma
+        Identity = aloha_obj.Identity
+        t = 1
+        mu, nu, s0, s1, s2 = 2,3,4,5,6
+        
+        zero = P(mu,t) * aloha_obj.Spin3halfPropagator(mu,nu,s1,s2, t)
+        zero = zero.expand()
+        P1_0, P1_1, P1_2, P1_3 = 2,0,0,0
+        OM1 = 1/(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        M1 = math.sqrt(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        for ind in zero.listindices():
+            data = zero.get_rep(ind)
+            self.assertAlmostEqual(eval(str(zero.get_rep(ind))),0)    
+     
+    def test_mass_overmass(self):
+        """check various property of the spin3/2 propagator"""
+        
+        Metric = aloha_obj.Metric
+        P = aloha_obj.P
+        OM = aloha_obj.OverMass2
+        Gamma = aloha_obj.Gamma
+        Identity = aloha_obj.Identity
+        Gamma = aloha_obj.Gamma
+        PSlash = aloha_obj.PSlash
+        Mass = aloha_obj.Mass
+        OverMass2 = aloha_obj.OverMass2
+        Identity = aloha_obj.Identity
+        t = 1
+        mu, nu, s0, s1, s2 = 2,3,4,5,6
+        Spin3halfPropagator =  lambda nu, s1, s2, part: (P(-1,part)**2 - Mass(part)*Mass(part)) * \
+                             (Mass(part) * Identity(-3, s2) )  
+        
+        #- 1/3 * (PSlash(s1,-2,part) + Identity(s1, -2) * Mass(part))* \
+        #                     (PSlash(-2,-3, part) - Identity(-2,-3) * Mass(part)) * \
+        #                     (P(-1,part)**2 - Mass(part)*Mass(part))
+        #                     (Mass(part) * Identity(-3, s2) )
+                                     
+        zero = Spin3halfPropagator(nu,s1,s2, t)
+        zero = zero.expand()
+        P1_0, P1_1, P1_2, P1_3 = 2,0,0,0
+        OM1 = 1/(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        M1 = math.sqrt(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        M99 = M1
+        for ind in zero.listindices():
+            data = zero.get_rep(ind)
+            self.assertAlmostEqual(eval(str(zero.get_rep(ind))),0)     
+ 
+ 
+        
+
+    def test_part_spin32propagator(self):
+        P = aloha_obj.P
+        OM = aloha_obj.OverMass2
+        Gamma = aloha_obj.Gamma
+        Identity = aloha_obj.Identity
+        Mass = aloha_obj.Mass
+        Pslash = aloha_obj.PSlash
+        part = 1
+        mu, nu, s0, s1, s2,s3 = 2,3,4,5,6,7
+        
+        
+        paranthesis = (Gamma(mu,s1,s2) + Identity(s1, s2) *  P(mu, part) * Mass(part) * OM(part)) * Gamma(nu,s2,s3)
+        paranthesis = Gamma(mu,s1,s2) * Gamma(nu,s2,s3) + Identity(s1, s2) *  P(mu, part) * Mass(part) * OM(part) * Gamma(nu,s2,s3)
+        #paranthesis =  Gamma(mu,s1,s2) * Gamma(nu,s2,s3)
+        goal = (Pslash(s1,s2,part) + Mass(part) * Identity(s1,s2)  ) * Gamma(nu, s2, s3)
+        #goal = Pslash(s1,s2,part) * Gamma(nu, s2, s3)
+        goal2= P(mu,part) * paranthesis 
+        goal2 =  P(mu,part) * Gamma(mu,s1,s2) * Gamma(nu,s2,s3) + Identity(s1, s2) *  P(mu,part) * P(mu, part) * Mass(part) * OM(part) * Gamma(nu,s2,s3)
+        zero = goal2 - goal
+        
+        #zero = zero.simplify()
+        zero=zero.expand()
+        P1_0, P1_1, P1_2, P1_3 = 20,3,4,5
+        OM1 = 1/(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        M1 = math.sqrt(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+        for ind in zero.listindices():
+            data = zero.get_rep(ind)
+            self.assertEqual(eval(str(data)),0)
+
+
+    
+    
     def test_spin2propagator(self):
         """Check that the two definition are coherent"""
         
@@ -2189,18 +2305,18 @@
         prod_gam2 = Gamma(2,1,2) * Gamma(1,2,3)
         self.assertNotEqual(prod_gam, prod_gam2)
     
-        # Sigma_mu_nu * Sigma_mu_nu = 12* Id
+        # Sigma_mu_nu * Sigma_mu_nu = 3* Id
         sigma_cont  = Sigma(1,2,1,2) * Sigma(1,2,2,1) 
         sigma_cont = sigma_cont.expand().simplify()
-        self.assertEqual(sigma_cont.get_rep((0,)), 48)
+        self.assertEqual(sigma_cont.get_rep((0,)), 12)
 
-        # Sigma_mu_nu * Gamma_nu = 3i * Gamma_nu # Trace
+        # Sigma_mu_nu * Gamma_nu = 3/2i * Gamma_nu # Trace
         prod = Sigma(1,2,'a','b') * Gamma(2,'b','a')
         prod = prod.expand().simplify()
         self.assertEqual(prod.get_rep((0,)), 0)
 
-        # Sigma_mu_nu * Gamma_nu = 3i * Gamma_nu # Full
-        zero = Sigma(1,2,'a','b') * Gamma(2,'b','c') - complex(0,3) * Gamma(1,'a','c')
+        # Sigma_mu_nu * Gamma_nu = 3/2i * Gamma_nu # Full
+        zero = Sigma(1,2,'a','b') * Gamma(2,'b','c') - complex(0,3/2) * Gamma(1,'a','c')
         zero = zero.expand().simplify()
         for ind in zero.listindices():
             self.assertEqual(zero.get_rep(ind), 0, '%s != 0.0for %s' % \
@@ -2231,7 +2347,44 @@
             self.assertEqual(zero.get_rep(ind), 0, '%s != 0.0for %s' % \
                              (zero.get_rep(ind), ind))  
     
-        
+    
+    def test_Pslashproperty(self):
+        """Test Pslash"""
+    
+        Gamma = aloha_obj.Gamma
+        P = aloha_obj.P
+        M = aloha_obj.Mass
+        PSlash = aloha_obj.PSlash
+        Identity = aloha_obj.Identity
+        
+        
+        ps1 = PSlash(1,2,3).simplify().expand().simplify()
+        
+        ps2 = Gamma(-1,1,2) * P(-1,3)
+        ps2 = ps2.simplify().expand().simplify()
+        zero = ps1 - ps2
+        zero = zero.simplify()
+        for ind in zero.listindices():
+            self.assertEqual(zero.get_rep(ind), 0, '%s != 0.0for %s' % \
+                             (zero.get_rep(ind), ind)) 
+            
+        
+        #checking that (/p + m)(/p-m)=0 (for onshell)
+        expr = (PSlash(1,2,1)+ M(1))*(PSlash(2,3,1)-M(1))
+        P1_0, P1_1, P1_2, P1_3 = 7,2,3,5
+        M1 = math.sqrt(P1_0 **2 - P1_1 **2 -P1_2 **2 -P1_3 **2)
+
+        for ind in zero.listindices():
+            data = zero.get_rep(ind)
+            self.assertAlmostEqual(eval(str(data)), 0)  
+         
+        #checking that (/p + m)(/p-m)(P)=0 (for onshell)
+        expr = (PSlash(1,2,1)+ M(1))*(PSlash(2,3,1)-M(1))*(Gamma(4,3,4)*Identity(3,4) * P(4,1))
+        for ind in zero.listindices():
+            data = zero.get_rep(ind)
+            self.assertAlmostEqual(eval(str(data)), 0)  
+
+    
     def testGammaAlgebraDefinition(self):
         """Test the coherence between gamma/gamma5/sigma/projector"""
         Gamma = aloha_obj.Gamma
@@ -2322,34 +2475,32 @@
         self.assertEqual(metric, metric2)
 
        
-        #Sigma_mu_nu = i/2 * [Gamma_mu, Gamma_nu]
-        sigma = complex(0, 1/2) * (Gamma(1,1,2)*Gamma(2,2,3) - Gamma(2,1,2)*Gamma(1,2,3))
-
-        #handly build
-        sigma_2 = aloha_lib.LorentzObjectRepresentation({},[2,1],[3,1])
-        prod_gam = Gamma(1,1,2) * Gamma(2,2,3)
-        prod_gam = prod_gam.expand().simplify()
-        for ind in prod_gam.listindices():
-            if ind[0] == ind[1]:
-                sigma_2.set_rep(ind, 0)
-            else:
-                value = complex(0, 1)* (prod_gam.get_rep(ind))
-                sigma_2.set_rep(ind, value)
-     
-        sigma_3 = Sigma(1,2,1,3)
-        diff1 = sigma - sigma_3
-        diff1 = diff1.simplify()
-        diff1 = diff1.expand()
-        diff1 = diff1.simplify()
-        
-        for ind in diff1.listindices():
-            self.assertEqual(diff1.get_rep(ind), 0)
-        
-        diff1 = sigma.expand() + -1 * sigma_2
-        diff1 = diff1.simplify()
-        for ind in diff1.listindices():
-            self.assertEqual(diff1.get_rep(ind), 0, 'not zero %s for %s' 
-                             % (diff1.get_rep(ind),ind ))
+
+        sigma = complex(0, 1/4) * (Gamma(1,3,2)*Gamma(2,2,1) - Gamma(2,3,2)*Gamma(1,2,1))
+        sigma2 = sigma.expand()
+        
+        zero = Sigma(1,2,3,1) - sigma
+        zero = zero.expand()
+        for ind in zero.listindices(): 
+            self.assertEqual(zero.get_rep(ind), 0)        
+        
+        mu, nu, rho, sigma = 1,2,3,4
+        commutator = Sigma(mu,nu,1,2) * Sigma(rho, sigma,2,3) - Sigma(rho,sigma,1,2) * Sigma(mu, nu,2,3) 
+        algebra = -1j * Metric(mu,rho) * Sigma(nu,sigma,1,3) + \
+                  1j * Metric(nu,rho) * Sigma(mu,sigma,1,3) + \
+                  -1j * Metric(nu,sigma) * Sigma(mu,rho,1,3) + \
+                  1j * Metric(mu,sigma) * Sigma(nu,rho,1,3)
+        
+        zero = commutator - algebra
+        zero = zero.simplify().expand().simplify()
+        for ind in zero.listindices(): 
+            self.assertEqual(zero.get_rep(ind), 0)         
+        
+        
+        
+        
+        
+
             
 #    def test_Spin2Contraction(self): 
 #        """check spin2 contraction"""