Merge lp:~madteam/mg5amcnlo/new_color into lp:~madteam/mg5amcnlo/trunk

[Michel Herquet]

[Michel Herquet (herquet)]

The color modules:
color_algebra: where the base classes ColorObjects (and children T, Tr, f and d) are defined
color_amp: where the ColorBasis is built
color_square: where the ColorMatrix is built

Important points to review:
-) Proposal for new tests
-) Code structure/clarity/comments

[Tim Stelzer (tstelzer)]

Very nice, and very clear. Only part that took me a bit extra to understand were canonical and immutable representations. So perhaps in definition could add couple of lines explaining their purpose.

review: Approve

[Olivier Mattelaer (olivier-mattelaer)]

Trully nice, quite clear.

The only point who trully trouble me is ColorString which is anything but a string. Could you think of rename this class and the instance associate to this one.

Event if it's trully well written, my feeling is that we can sometimes split functions in subfunction to increase intention and readability.
for example:
   -> color_square l.90: put all the except part in a function
   -> color_amp l.36: the routine colorize can be splitted in three.
                      i.e. having two routine dealing with one vertex one for id=0 and another for id!=0

but this is not mandatory at all.

and to finish some pointless details:

-> color_algebra l.448: For readability, it's not better to put a space after the lambda (nothing is specified in PEP08 on this specific case)

-> color_amp line 158: the code content in the try is too much larger. it calls two different functions. such that the try can hidden a keyError produces inside those functions.
At least simplify() should be in the part else:

->color square l.85: potentially same type of problem. In this cas 3 different KeyError are potentially raised. Are you 200% that only the first can create KeyError?

-> color square l.67: unused argument contrib_list1 (and two line after contrib_list2)
why not use a .keys() instead of .enumerate()

Very good work!!!

review: Needs Fixing

[lp:~madteam/mg5amcnlo/new_color]

69. By Michel Herquet on 2010-01-14

New version to adress Tim and Olivier's comments

[Olivier Mattelaer (olivier-mattelaer)]

thanks for those modifications!!

review: Approve

[Johan Alwall (johan-alwall)]

Comments for color:

* Overall:
  - Very nicely commented and readable code
  - Apparently highly (maximally?) optimized
  - Extremely neat and clear solutions

* Why create three modules instead of just one bigger module?
Do you foresee uses of color_algebra without the others?
Do you suggest that we should break up other models as well?
Is there a problem that there are parts of a module that are not used?
I would have expected that we only want to separate a module into
components if they belong to different parts of the directory
structure, such as core and io. I think it is important that we follow
the same philosophy, and this should be fixed before the merge if possible.

color_amp.py:
* line 87+: I think we need to make sure we order interactions in the
same way (between helas calls and color). I order according to cyclic
order in interaction and leg number. But we can take that after the merge.

color_square.py:
* line 43: "Be careful that" -> "Note that" (the formulation is a bit
confusing)

color_algebra.py:
* No comments, the code seems great!

review: Needs Information

[lp:~madteam/mg5amcnlo/new_color]

70. By Michel Herquet on 2010-01-16

Fix Johan's comment

[Michel Herquet (herquet)]

On Jan 15, 2010, at 3:59 PM, Johan Alwall wrote:

> Review: Needs Information
> Comments for color:
>
> * Overall:
> - Very nicely commented and readable code
> - Apparently highly (maximally?) optimized
> - Extremely neat and clear solutions
Thanks!

> * Why create three modules instead of just one bigger module?
> Do you foresee uses of color_algebra without the others?
> Do you suggest that we should break up other models as well?
> Is there a problem that there are parts of a module that are not used?
> I would have expected that we only want to separate a module into
> components if they belong to different parts of the directory
> structure, such as core and io. I think it is important that we follow
> the same philosophy, and this should be fixed before the merge if possible.
I agree, let's discuss this as a first step in the merge procedure. My current
POV is that we should give a good equilibrium between structure
clarity and readability (long files are hard to deal with). Also color_algebra
can indeed be used independently of v5, while it's not the case for the two
other modules. But maybe we can merge those...

> color_amp.py:
> * line 87+: I think we need to make sure we order interactions in the
> same way (between helas calls and color). I order according to cyclic
> order in interaction and leg number. But we can take that after the merge.
Right.

> color_square.py:
> * line 43: "Be careful that" -> "Note that" (the formulation is a bit
> confusing)
Fixed.

> color_algebra.py:
> * No comments, the code seems great!
Thank for your time reviewing it!

>
> --
> https://code.launchpad.net/~madteam/madgraph5/new_color/+merge/17008
> You proposed lp:~madteam/madgraph5/new_color for merging.

Michel Herquet
---------------------------------------------------------------------------------
Postdoctoral researcher in Particle Physics Phenomenology

NIKHEF - Theory group E-mail: <email address hidden>
Science Park 105 Tel: [phone]
1098 XG Amsterdam Skype: mherquet
The Netherlands G-chat: <email address hidden>

[Johan Alwall (johan-alwall)]

Thanks, great job!

review: Approve

[lp:~madteam/mg5amcnlo/new_color]

71. By Michel Herquet on 2010-01-21

Merge color_square and color_amp

72. By Michel Herquet on 2010-01-21

Last revision before merge

=== modified file '.project'
--- .project	2009-12-17 12:45:20 +0000
+++ .project	2010-01-21 09:19:15 +0000
@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
+<<<<<<< TREE
 	<name>MG-process-devel</name>
+=======
+	<name>MG-new_color</name>
+>>>>>>> MERGE-SOURCE
 	<comment></comment>
 	<projects>
 	</projects>

=== modified file '.pydevproject'
--- .pydevproject	2010-01-21 09:12:43 +0000
+++ .pydevproject	2010-01-21 09:19:15 +0000
@@ -5,6 +5,6 @@
 <pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.6</pydev_property>
 <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
 <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
-<path>/MG-trunk</path>
+<path>/MG-new_color</path>
 </pydev_pathproperty>
 </pydev_project>

=== modified file 'madgraph/VERSION'
--- madgraph/VERSION	2009-10-21 14:20:40 +0000
+++ madgraph/VERSION	2010-01-21 09:19:15 +0000
@@ -1,2 +1,2 @@
-version = 0.2.0
-date = 2009-11-05
\ No newline at end of file
+version = 0.3.0/color
+date = 2010-01-11
\ No newline at end of file

=== modified file 'madgraph/core/base_objects.py'
--- madgraph/core/base_objects.py	2010-01-20 03:15:48 +0000
+++ madgraph/core/base_objects.py	2010-01-21 09:19:15 +0000
@@ -21,6 +21,8 @@
 import logging
 import re
 
+import madgraph.core.color_algebra as color
+
 #===============================================================================
 # PhysicsObject
 #===============================================================================
@@ -461,8 +463,18 @@
                     raise self.PhysicsObjectError, \
                         "%s is not a valid integer" % str(value[order])
 
-        if name in ['color', 'lorentz']:
-            #Should be a list of strings
+        if name in ['color']:
+            #Should be a list of list strings
+            if not isinstance(value, list):
+                raise self.PhysicsObjectError, \
+                        "%s is not a valid list of Color Strings" % str(value)
+            for mycolstring in value:
+                if not isinstance(mycolstring, color.ColorString):
+                    raise self.PhysicsObjectError, \
+                            "%s is not a valid list of Color Strings" % str(value)
+
+        if name in ['lorentz']:
+            #Should be a list of list strings
             if not isinstance(value, list):
                 raise self.PhysicsObjectError, \
                         "%s is not a valid list of strings" % str(value)
@@ -478,11 +490,6 @@
                         "%s is not a valid dictionary for couplings" % \
                                                                 str(value)
 
-            if len(value) != len(self['color']) * len(self['lorentz']):
-                raise self.PhysicsObjectError, \
-                        "Dictionary " + str(value) + \
-                        " for couplings has not the right number of entry"
-
             for key in value.keys():
                 if not isinstance(key, tuple):
                     raise self.PhysicsObjectError, \
@@ -542,6 +549,29 @@
             else:
                 ref_dict_to1[pdg_tuple] = [(pdg_part, self['id'])]
 
+    def __str__(self):
+        """String representation of an interaction. Outputs valid Python 
+        with improved format. Overrides the PhysicsObject __str__ to only
+        display PDG code of involved particles."""
+
+        mystr = '{\n'
+
+        for prop in self.get_sorted_keys():
+            if isinstance(self[prop], str):
+                mystr = mystr + '    \'' + prop + '\': \'' + \
+                        self[prop] + '\',\n'
+            elif isinstance(self[prop], float):
+                mystr = mystr + '    \'' + prop + '\': %.2f,\n' % self[prop]
+            elif isinstance(self[prop], ParticleList):
+                mystr = mystr + '    \'' + prop + '\': [%s],\n' % \
+                   ','.join([str(part.get_pdg_code()) for part in self[prop]])
+            else:
+                mystr = mystr + '    \'' + prop + '\': ' + \
+                        repr(self[prop]) + ',\n'
+        mystr = mystr.rstrip(',\n')
+        mystr = mystr + '\n}'
+
+        return mystr
 
 #===============================================================================
 # InteractionList
@@ -1067,7 +1097,11 @@
             for vert in self['vertices']:
                 mystr = mystr + '('
                 for leg in vert['legs'][:-1]:
+<<<<<<< TREE
                     mystr = mystr + str(leg['number']) + '(%s)' % str(leg['id']) + ','
+=======
+                    mystr = mystr + str(leg['number']) + ','
+>>>>>>> MERGE-SOURCE
                 if self['vertices'].index(vert) < len(self['vertices']) - 1:
                     # Do not want ">" in the last vertex
                     mystr = mystr[:-1] + '>'

=== added file 'madgraph/core/color_algebra.py'
--- madgraph/core/color_algebra.py	1970-01-01 00:00:00 +0000
+++ madgraph/core/color_algebra.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,607 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+"""Classes and methods required for all calculations related to SU(N) color 
+algebra."""
+
+import array
+import copy
+import fractions
+import itertools
+
+#===============================================================================
+# ColorObject
+#===============================================================================
+class ColorObject(array.array):
+    """Parent class for all color objects like T, Tr, f, d, ... Any new color 
+    object MUST inherit from this class!"""
+
+    def __new__(self, *args):
+        """Create a new ColorObject, assuming an integer array"""
+
+        return super(ColorObject, self).__new__(self, 'i', args)
+
+    def __str__(self):
+        """Returns a standard string representation."""
+
+        return '%s(%s)' % (self.__class__.__name__,
+                           ','.join([str(i) for i in self]))
+
+    __repr__ = __str__
+
+    def simplify(self):
+        """Simplification rules, to be overwritten for each new color object!
+        Should return a color factor or None if no simplification is possible"""
+        return None
+
+    def pair_simplify(self, other):
+        """Pair simplification rules, to be overwritten for each new color 
+        object! Should return a color factor or None if no simplification 
+        is possible"""
+        return None
+
+    def complex_conjugate(self):
+        """Complex conjugation. By default, the ordering of color index is
+        reversed. Can be overwritten for specific color objects like T,..."""
+
+        self.reverse()
+
+    def replace_indices(self, repl_dict):
+        """Replace current indices following the rules listed in the replacement
+        dictionary written as {old_index:new_index,...}. Deals correctly with
+        the replacement by allowing only one single replacement."""
+
+        for i, index in enumerate(self):
+            try:
+                self[i] = repl_dict[index]
+            except KeyError:
+                continue
+
+    def create_copy(self):
+        """Return a real copy of the current object."""
+        return globals()[self.__class__.__name__](*self)
+
+    __copy__ = create_copy
+
+#===============================================================================
+# Tr
+#===============================================================================
+class Tr(ColorObject):
+    """The trace color object"""
+
+    def simplify(self):
+        """Implement simple trace simplifications and cyclicity, and
+        Tr(a,x,b,x,c) = 1/2(Tr(a,c)Tr(b)-1/Nc Tr(a,b,c))"""
+
+        # Tr(a)=0
+        if len(self) == 1:
+            col_str = ColorString()
+            col_str.coeff = fractions.Fraction(0, 1)
+            return ColorFactor([col_str])
+
+        # Tr()=Nc
+        if len(self) == 0:
+            col_str = ColorString()
+            col_str.Nc_power = 1
+            return ColorFactor([col_str])
+
+        # Always order starting from smallest index
+        if self[0] != min(self):
+            pos = self.index(min(self))
+            new = self[pos:] + self[:pos]
+            return ColorFactor([ColorString([Tr(*new)])])
+
+        # Tr(a,x,b,x,c) = 1/2(Tr(a,c)Tr(b)-1/Nc Tr(a,b,c))
+        for i1, index1 in enumerate(self):
+            for i2, index2 in enumerate(self[i1 + 1:]):
+                if index1 == index2:
+                    a = self[:i1]
+                    b = self[i1 + 1:i1 + i2 + 1]
+                    c = self[i1 + i2 + 2:]
+                    col_str1 = ColorString([Tr(*(a + c)), Tr(*b)])
+                    col_str2 = ColorString([Tr(*(a + b + c))])
+                    col_str1.coeff = fractions.Fraction(1, 2)
+                    col_str2.coeff = fractions.Fraction(-1, 2)
+                    col_str2.Nc_power = -1
+                    return ColorFactor([col_str1, col_str2])
+
+        return None
+
+    def pair_simplify(self, col_obj):
+        """Implement Tr product simplification: 
+        Tr(a,x,b)Tr(c,x,d) = 1/2(Tr(a,d,c,b)-1/Nc Tr(a,b)Tr(c,d)) and
+        Tr(a,x,b)T(c,x,d,i,j) = 1/2(T(c,b,a,d,i,j)-1/Nc Tr(a,b)T(c,d,i,j))"""
+
+        # Tr(a,x,b)Tr(c,x,d) = 1/2(Tr(a,d,c,b)-1/Nc Tr(a,b)Tr(c,d))
+        if isinstance(col_obj, Tr):
+            for i1, index1 in enumerate(self):
+                for i2, index2 in enumerate(col_obj):
+                    if index1 == index2:
+                        a = self[:i1]
+                        b = self[i1 + 1:]
+                        c = col_obj[:i2]
+                        d = col_obj[i2 + 1:]
+                        col_str1 = ColorString([Tr(*(a + d + c + b))])
+                        col_str2 = ColorString([Tr(*(a + b)), Tr(*(c + d))])
+                        col_str1.coeff = fractions.Fraction(1, 2)
+                        col_str2.coeff = fractions.Fraction(-1, 2)
+                        col_str2.Nc_power = -1
+                        return ColorFactor([col_str1, col_str2])
+
+        # Tr(a,x,b)T(c,x,d,i,j) = 1/2(T(c,b,a,d,i,j)-1/Nc Tr(a,b)T(c,d,i,j))
+        if isinstance(col_obj, T):
+            for i1, index1 in enumerate(self):
+                for i2, index2 in enumerate(col_obj[:-2]):
+                    if index1 == index2:
+                        a = self[:i1]
+                        b = self[i1 + 1:]
+                        c = col_obj[:i2]
+                        d = col_obj[i2 + 1:-2]
+                        ij = col_obj[-2:]
+                        col_str1 = ColorString([T(*(c + b + a + d + ij))])
+                        col_str2 = ColorString([Tr(*(a + b)), T(*(c + d) + ij)])
+                        col_str1.coeff = fractions.Fraction(1, 2)
+                        col_str2.coeff = fractions.Fraction(-1, 2)
+                        col_str2.Nc_power = -1
+                        return ColorFactor([col_str1, col_str2])
+
+        return None
+
+#===============================================================================
+# T
+#===============================================================================
+class T(ColorObject):
+    """The T color object. Last two indices have a special meaning"""
+
+    def __init__(self, *args):
+        """Check for at least two indices"""
+
+        super(T, self).__init__()
+        if len(args) < 2:
+            raise ValueError, \
+                "T objects must have at least two indices!"
+
+    def simplify(self):
+        """Implement T(a,b,c,...,i,i) = Tr(a,b,c,...) and
+        T(a,x,b,x,c,i,j) = 1/2(T(a,c,i,j)Tr(b)-1/Nc T(a,b,c,i,j))"""
+
+        # T(a,b,c,...,i,i) = Tr(a,b,c,...)
+        if self[-2] == self[-1]:
+            return ColorFactor([ColorString([Tr(*self[:-2])])])
+
+        # T(a,x,b,x,c,i,j) = 1/2(T(a,c,i,j)Tr(b)-1/Nc T(a,b,c,i,j))
+        for i1, index1 in enumerate(self[:-2]):
+            for i2, index2 in enumerate(self[i1 + 1:-2]):
+                if index1 == index2:
+                    a = self[:i1]
+                    b = self[i1 + 1:i1 + i2 + 1]
+                    c = self[i1 + i2 + 2:-2]
+                    ij = self[-2:]
+                    col_str1 = ColorString([T(*(a + c + ij)), Tr(*b)])
+                    col_str2 = ColorString([T(*(a + b + c + ij))])
+                    col_str1.coeff = fractions.Fraction(1, 2)
+                    col_str2.coeff = fractions.Fraction(-1, 2)
+                    col_str2.Nc_power = -1
+                    return ColorFactor([col_str1, col_str2])
+
+        return None
+
+    def pair_simplify(self, col_obj, simplify_T_product=False):
+        """Implement T(a,...,i,j)T(b,...,j,k) = T(a,...,b,...,i,k)
+        and T(a,x,b,i,j)T(c,x,d,k,l) = 1/2(T(a,d,i,l)T(c,b,k,j)    
+                                        -1/Nc T(a,b,i,j)T(c,d,k,l))
+        but only if the simplify_T_product tag is True."""
+
+        if isinstance(col_obj, T):
+            ij1 = self[-2:]
+            ij2 = col_obj[-2:]
+
+            # T(a,...,i,j)T(b,...,j,k) = T(a,...,b,...,i,k)
+            if ij1[1] == ij2[0]:
+                return ColorFactor([ColorString([T(*(self[:-2] + \
+                                                   col_obj[:-2] + \
+                                                   array.array('i', [ij1[0],
+                                                               ij2[1]])))])])
+            # T(a,x,b,i,j)T(c,x,d,k,l) = 1/2(T(a,d,i,l)T(c,b,k,j)    
+            #                          -1/Nc T(a,b,i,j)T(c,d,k,l))
+            if simplify_T_product:
+                for i1, index1 in enumerate(self[:-2]):
+                    for i2, index2 in enumerate(col_obj[:-2]):
+                        if index1 == index2:
+                            a = self[:i1]
+                            b = self[i1 + 1:-2]
+                            c = col_obj[:i2]
+                            d = col_obj[i2 + 1:-2]
+                            col_str1 = ColorString([T(*(a + d + \
+                                                       array.array('i',
+                                                        [ij1[0], ij2[1]]))),
+                                                   T(*(c + b + \
+                                                       array.array('i',
+                                                        [ij2[0], ij1[1]])))])
+                            col_str2 = ColorString([T(*(a + b + \
+                                                       array.array('i',
+                                                        [ij1[0], ij1[1]]))),
+                                                   T(*(c + d + \
+                                                       array.array('i',
+                                                        [ij2[0], ij2[1]])))])
+                            col_str1.coeff = fractions.Fraction(1, 2)
+                            col_str2.coeff = fractions.Fraction(-1, 2)
+                            col_str2.Nc_power = -1
+                            return ColorFactor([col_str1, col_str2])
+
+    def complex_conjugate(self):
+        """Complex conjugation. Overwritten here because the two last indices
+        should be treated differently"""
+
+        # T(a,b,c,i,j)* = T(c,b,a,j,i)
+        l1 = self[:-2]
+        l1.reverse()
+        l2 = self[-2:]
+        l2.reverse()
+        self[:] = l1 + l2
+
+#===============================================================================
+# f
+#===============================================================================
+class f(ColorObject):
+    """The f color object"""
+
+    def __init__(self, *args):
+        """Ensure f and d objects have strictly 3 indices"""
+
+        super(f, self).__init__()
+        if len(args) != 3:
+            raise ValueError, \
+                "f and d objects must have three indices!"
+
+    def simplify(self):
+        """Implement only the replacement rule 
+        f(a,b,c)=-2ITr(a,b,c)+2ITr(c,b,a)"""
+
+        indices = self[:]
+        col_str1 = ColorString([Tr(*indices)])
+        indices.reverse()
+        col_str2 = ColorString([Tr(*indices)])
+
+        col_str1.coeff = fractions.Fraction(-2, 1)
+        col_str2.coeff = fractions.Fraction(2, 1)
+
+        col_str1.is_imaginary = True
+        col_str2.is_imaginary = True
+
+        return ColorFactor([col_str1, col_str2])
+
+#===============================================================================
+# d
+#===============================================================================
+class d(f):
+    """The d color object"""
+
+    def simplify(self):
+        """Implement only the replacement rule 
+        d(a,b,c)=2Tr(a,b,c)+2Tr(c,b,a)"""
+
+        indices = self[:]
+        col_str1 = ColorString([Tr(*indices)])
+        indices.reverse()
+        col_str2 = ColorString([Tr(*indices)])
+
+        col_str1.coeff = fractions.Fraction(2, 1)
+        col_str2.coeff = fractions.Fraction(2, 1)
+
+        return ColorFactor([col_str1, col_str2])
+
+#===============================================================================
+# ColorString
+#===============================================================================
+class ColorString(list):
+    """A list of ColorObjects with an implicit multiplication between,
+    together with a Fraction coefficient and a tag
+    to indicate if the coefficient is real or imaginary. ColorStrings can be
+    simplified, by simplifying their elements."""
+
+    coeff = fractions.Fraction(1, 1)
+    is_imaginary = False
+    Nc_power = 0
+
+    def __init__(self, init_list=[],
+                 coeff=fractions.Fraction(1, 1),
+                 is_imaginary=False, Nc_power=0):
+        """Overrides norm list constructor to implement easy modification
+        of coeff, is_imaginary and Nc_power"""
+
+        if init_list:
+            self.extend(init_list)
+        self.coeff = coeff
+        self.is_imaginary = is_imaginary
+        self.Nc_power = Nc_power
+
+    def __str__(self):
+        """Returns a standard string representation based on color object
+        representations"""
+
+        coeff_str = str(self.coeff)
+        if self.is_imaginary:
+            coeff_str += ' I'
+        if self.Nc_power > 0:
+            coeff_str += ' Nc^%i' % self.Nc_power
+        elif self.Nc_power < 0:
+            coeff_str += ' 1/Nc^%i' % abs(self.Nc_power)
+        return '%s %s' % (coeff_str,
+                         ' '.join([str(col_obj) for col_obj in self]))
+
+    __repr__ = __str__
+
+    def product(self, other):
+        """Multiply self with other."""
+
+        self.coeff = self.coeff * other.coeff
+
+        self.Nc_power = self.Nc_power + other.Nc_power
+
+        # Complex algebra
+        if self.is_imaginary and other.is_imaginary:
+            self.is_imaginary = False
+            self.coeff = -self.coeff
+        elif self.is_imaginary or other.is_imaginary:
+            self.is_imaginary = True
+
+        self.extend(other)
+
+    def simplify(self):
+        """Simplify the current ColorString by applying simplify rules on
+        each element and building a new ColorFactor to return if necessary"""
+
+        # First, try sto simplify element by element
+        for i1, col_obj1 in enumerate(self):
+            res = col_obj1.simplify()
+            # If a simplification possibility is found...
+            if res:
+                # Create a color factor to store the answer...
+                res_col_factor = ColorFactor()
+                # Obtained my multiplying the initial string minus the color
+                # object to simplify with all color strings in the result
+                for second_col_str in res:
+                    first_col_str = copy.copy(self)
+                    del first_col_str[i1]
+                    first_col_str.product(second_col_str)
+                    # This sort is necessary to ensure ordering of ColorObjects
+                    # remains the same for comparison
+                    first_col_str.sort()
+                    res_col_factor.append(first_col_str)
+                return res_col_factor
+
+        # Second, try to simplify pairs
+        for i1, col_obj1 in enumerate(self):
+
+            for i2, col_obj2 in enumerate(self[i1 + 1:]):
+                res = col_obj1.pair_simplify(col_obj2)
+                # Try both pairing
+                if not res:
+                    res = col_obj2.pair_simplify(col_obj1)
+                if res:
+                    res_col_factor = ColorFactor()
+                    for second_col_str in res:
+                        first_col_str = copy.copy(self)
+                        del first_col_str[i1]
+                        del first_col_str[i1 + i2]
+                        first_col_str.product(second_col_str)
+                        first_col_str.sort()
+                        res_col_factor.append(first_col_str)
+                    return res_col_factor
+
+        return None
+
+    def add(self, other):
+        """Add string other to current string. ONLY USE WITH SIMILAR STRINGS!"""
+
+        self.coeff = self.coeff + other.coeff
+
+    def complex_conjugate(self):
+        """Returns the complex conjugate of the current color string"""
+
+        compl_conj_str = copy.copy(self)
+        for col_obj in compl_conj_str:
+            col_obj.complex_conjugate()
+        if compl_conj_str.is_imaginary:
+            compl_conj_str.coeff = -compl_conj_str.coeff
+
+        return compl_conj_str
+
+    def to_immutable(self):
+        """Returns an immutable object summarizing the color structure of the
+        current color string. Format is ((name1,indices1),...) where name is the
+        class name of the color object and indices a tuple corresponding to its
+        indices. An immutable object, in Python, is built on tuples, strings and
+        numbers, i.e. objects which cannot be modified. Their crucial property
+        is that they can be used as dictionary keys!"""
+
+        ret_list = [(col_obj.__class__.__name__, tuple(col_obj)) \
+                        for col_obj in self]
+        ret_list.sort()
+        return tuple(ret_list)
+
+    def from_immutable(self, immutable_rep):
+        """Fill the current object with Color Objects created using an immutable
+        representation."""
+
+        del self[:]
+
+        for col_tuple in immutable_rep:
+            self.append(globals()[col_tuple[0]](*col_tuple[1]))
+
+    def replace_indices(self, repl_dict):
+        """Replace current indices following the rules listed in the replacement
+        dictionary written as {old_index:new_index,...}, does that for ALL 
+        color objects."""
+
+        map(lambda col_obj: col_obj.replace_indices(repl_dict), self)
+
+    def create_copy(self):
+        """Returns a real copy of self, non trivial because bug in 
+        copy.deepcopy"""
+
+        res = ColorString()
+        for col_obj in self:
+            res.append(col_obj.create_copy())
+        res.coeff = self.coeff
+        res.is_imaginary = self.is_imaginary
+        res.Nc_power = self.Nc_power
+
+        return res
+
+    __copy__ = create_copy
+
+    def set_Nc(self, Nc=3):
+        """Returns a tuple, with the first entry being the string coefficient 
+        with Nc replaced (by default by 3), and the second one being True
+        or False if the coefficient is imaginary or not. Raise an error if there
+        are still non trivial color objects."""
+
+        if self:
+            raise ValueError, \
+                "String %s cannot be simplified to a number!" % str(self)
+
+        if self.Nc_power >= 0:
+            return (self.coeff * fractions.Fraction(\
+                                            int(Nc ** self.Nc_power), 1),
+                    self.is_imaginary)
+        else:
+            return (self.coeff * fractions.Fraction(\
+                                            1, int(Nc ** abs(self.Nc_power))),
+                    self.is_imaginary)
+
+    def to_canonical(self, immutable=None):
+        """Returns the canonical representation of the immutable representation 
+        (i.e., first index is 1, ...). This allow for an easy comparison of
+        two color strings, i.e. independently of the actual index names (only
+        relative positions matter). Also returns the conversion dictionary.
+        If no immutable representation is given, use the one build from self."""
+
+        if not immutable:
+            immutable = self.to_immutable()
+
+        replaced_indices = {}
+        curr_ind = 1
+        return_list = []
+
+        for elem in immutable:
+            can_elem = [elem[0], []]
+            for index in elem[1]:
+                try:
+                    new_index = replaced_indices[index]
+                except KeyError:
+                    new_index = curr_ind
+                    curr_ind += 1
+                    replaced_indices[index] = new_index
+                can_elem[1].append(new_index)
+            return_list.append((can_elem[0], tuple(can_elem[1])))
+
+        return_list.sort()
+
+        return (tuple(return_list), replaced_indices)
+#===============================================================================
+# ColorFactor
+#===============================================================================
+class ColorFactor(list):
+    """ColorFactor objects are list of ColorString with an implicit summation.
+    They can be simplified by simplifying all their elements."""
+
+    def __str__(self):
+        """Returns a nice string for print"""
+
+        return '+'.join(['(%s)' % str(col_str) for col_str in self])
+
+    def append_str(self, new_str):
+        """Special append taking care of adding new string to strings already
+        existing with the same structure."""
+
+        for col_str in self:
+            # Check if strings are similar, this IS the optimal way of doing
+            # it. Note that first line only compare the lists, not the 
+            # properties associated
+            if col_str == new_str and \
+               col_str.Nc_power == new_str.Nc_power and \
+               col_str.is_imaginary == new_str.is_imaginary:
+                # Add them
+                col_str.add(new_str)
+                return True
+
+        # If no correspondence is found, append anyway
+        self.append(new_str)
+        return False
+
+    def extend_str(self, new_col_fact):
+        """Special extend taking care of adding new strings to strings already
+        existing with the same structure."""
+
+        for col_str in new_col_fact:
+            self.append_str(col_str)
+
+    def simplify(self):
+        """Returns a new color factor where each color string has been
+        simplified once and similar strings have been added."""
+
+        new_col_factor = ColorFactor()
+        # Simplify
+        for col_str in self:
+            res = col_str.simplify()
+            if res:
+                new_col_factor.extend_str(res)
+            else:
+                new_col_factor.append_str(col_str)
+
+        # Only returns non zero elements
+        return ColorFactor([col_str for col_str in \
+                            new_col_factor if col_str.coeff != 0])
+
+    def full_simplify(self):
+        """Simplify the current color factor until the result is stable"""
+
+        result = copy.copy(self)
+        while(True):
+            ref = copy.copy(result)
+            result = result.simplify()
+            if result == ref:
+                return result
+
+    def set_Nc(self, Nc=3):
+        """Returns a tuple containing real and imaginary parts of the current
+        color factor, when Nc is replaced (3 by default)."""
+
+        return (sum([cs.set_Nc(Nc)[0] for cs in self if not cs.is_imaginary]),
+                sum([cs.set_Nc(Nc)[0] for cs in self if cs.is_imaginary]))
+
+
+    def replace_indices(self, repl_dict):
+        """Replace current indices following the rules listed in the replacement
+        dictionary written as {old_index:new_index,...}, does that for ALL 
+        color strings."""
+
+        map(lambda col_str:col_str.replace_indices(repl_dict), self)
+
+    def create_copy(self):
+        """Returns a real copy of self, non trivial because bug in 
+        copy.deepcopy"""
+
+        res = ColorFactor()
+        for col_str in self:
+            res.append(col_str.create_copy())
+
+        return res
+
+    __copy__ = create_copy
+
+

=== added file 'madgraph/core/color_amp.py'
--- madgraph/core/color_amp.py	1970-01-01 00:00:00 +0000
+++ madgraph/core/color_amp.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,439 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+import copy
+import operator
+import re
+
+import madgraph.core.color_algebra as color_algebra
+
+"""Classes, methods and functions required to write QCD color information 
+for a diagram and build a color basis, and to square a QCD color string for
+squared diagrams and interference terms."""
+
+#===============================================================================
+# ColorBasis
+#===============================================================================
+class ColorBasis(dict):
+    """The ColorBasis object is a dictionary created from an amplitude. Keys
+    are the different color structures present in the amplitude. Values have
+    the format (diag,(index c1, index c2,...), coeff, is_imaginary, Nc_power) 
+    where diag is the diagram index, (index c1, index c2,...) the list of 
+    indices corresponding to the chose color parts for each vertex in the 
+    diagram, coeff the corresponding coefficient (a fraction), is_imaginary
+    if this contribution is real or complex, and Nc_power the Nc power."""
+
+    # Dictionary to save simplifications already done in a canonical form
+    _canonical_dict = {}
+
+    def colorize(self, diagram, model):
+        """Takes a diagram and a model and outputs a dictionary with keys being
+        color coefficient index tuples and values a color string (before 
+        simplification)."""
+
+        # The smallest value used to create new summed indices
+        min_index = -1000
+        # The dictionary to be output
+        res_dict = {}
+        # The dictionary for book keeping of replaced indices
+        repl_dict = {}
+
+        for vertex in diagram.get('vertices'):
+
+        # SPECIAL VERTEX WITH ID = 0 -------------------------------------------
+
+            if vertex['id'] == 0:
+                self.add_vertex_id_0(vertex, repl_dict, res_dict)
+                # Return since this must be the last vertex
+                return res_dict
+
+        # NORMAL VERTICES WITH ID != 0 -----------------------------------------
+            min_index, res_dict = self.add_vertex(vertex, diagram, model,
+                            repl_dict, res_dict, min_index)
+
+        return res_dict
+
+    def add_vertex_id_0(self, vertex, repl_dict, res_dict):
+        """Update the repl_dict and res_dict when vertex has id=0, i.e. for
+        the special case of an identity vertex."""
+
+        # For vertex (i1,i2), replace all i2 by i1
+        old_num = vertex.get('legs')[1].get('number')
+        new_num = vertex.get('legs')[0].get('number')
+        # Be careful i1 or i2 might have been replaced themselves
+        try:
+            old_num = repl_dict[old_num]
+        except KeyError:
+            pass
+        try:
+            new_num = repl_dict[new_num]
+        except KeyError:
+            pass
+        # Do the replacement
+        for (ind_chain, col_str_chain) in res_dict.items():
+            col_str_chain.replace_indices({old_num:new_num})
+
+    def add_vertex(self, vertex, diagram, model,
+                   repl_dict, res_dict, min_index):
+        """Update repl_dict, res_dict and min_index for normal vertices.
+        Returns the min_index reached and the result dictionary in a tuple."""
+
+        # Create a list of pdg codes entering the vertex ordered as in
+        # interactions.py
+        list_pdg = [part.get_pdg_code() for part in \
+               model.get_interaction(vertex.get('id')).get('particles')]
+
+        # Create a dictionary pdg code --> leg(s)
+        dict_pdg_leg = {}
+        for index, leg in enumerate(vertex.get('legs')):
+            curr_num = leg.get('number')
+            curr_pdg = leg.get('id')
+            # If this is the last leg and not the last vertex, 
+            # flip part/antipart, and replace last index by a new 
+            # summed index
+            if index == len(vertex.get('legs')) - 1 and \
+                vertex != diagram.get('vertices')[-1]:
+                part = model.get('particle_dict')[curr_pdg]
+                curr_pdg = \
+                    model.get('particle_dict')[curr_pdg].get_anti_pdg_code()
+                repl_dict[curr_num] = min_index
+                min_index = min_index - 1
+            try:
+                curr_num = repl_dict[curr_num]
+            except KeyError:
+                pass
+            try:
+                dict_pdg_leg[curr_pdg].append(curr_num)
+            except KeyError:
+                dict_pdg_leg[curr_pdg] = [curr_num]
+
+        # Create a list of associated leg number following the same order
+        list_numbers = []
+        for pdg_code in list_pdg:
+            list_numbers.append(dict_pdg_leg[pdg_code].pop())
+        # ... and the associated dictionary for replacement
+        match_dict = dict(enumerate(list_numbers))
+
+        # Update the result dict using the current vertex ColorString object
+        # If more than one, create different entries
+        new_res_dict = {}
+        for i, col_str in \
+                enumerate(model.get_interaction(vertex['id'])['color']):
+            # Build the new element
+            mod_col_str = col_str.create_copy()
+
+            # Replace summed (negative) internal indices
+            list_neg = []
+            for col_obj in mod_col_str:
+                list_neg.extend([ind for ind in col_obj if ind < 0])
+            internal_indices_dict = {}
+            # This notation is to remove duplicates
+            for index in list(set(list_neg)):
+                internal_indices_dict[index] = min_index
+                min_index = min_index - 1
+            mod_col_str.replace_indices(internal_indices_dict)
+
+            # Replace other (positive) indices using the match_dic
+            mod_col_str.replace_indices(match_dict)
+            # If we are considering the first vertex, simply create
+            # new entries
+            if not res_dict:
+                new_res_dict[tuple([i])] = mod_col_str
+            #... otherwise, loop over existing elements and multiply
+            # the color strings
+            else:
+                for ind_chain, col_str_chain in res_dict.items():
+                    new_col_str_chain = col_str_chain.create_copy()
+                    new_col_str_chain.product(mod_col_str)
+                    new_res_dict[tuple(list(ind_chain) + [i])] = \
+                        new_col_str_chain
+
+        return (min_index, new_res_dict)
+
+
+    def update_color_basis(self, colorize_dict, index):
+        """Update the current color basis by adding information from 
+        the colorize dictionary (produced by the colorize routine)
+        associated to diagram with index index. Keep track of simplification
+        results for maximal optimization."""
+
+        # loop over possible color chains
+        for col_chain, col_str in colorize_dict.items():
+
+            # Create a canonical immutable representation of the the string
+            canonical_rep, rep_dict = col_str.to_canonical()
+            try:
+                # If this representation has already been considered,
+                # recycle the result. 
+                col_fact = copy.copy(self._canonical_dict[canonical_rep])
+
+            except KeyError:
+                # If the representation is really new
+
+                # Create and simplify a color factor for the considered chain
+                col_fact = color_algebra.ColorFactor([col_str])
+                col_fact = col_fact.full_simplify()
+
+                # Save the result for further use
+                canonical_col_fact = copy.copy(col_fact)
+                canonical_col_fact.replace_indices(rep_dict)
+                self._canonical_dict[canonical_rep] = canonical_col_fact
+
+            else:
+                # If this representation has already been considered,
+                # adapt the result
+                # Note that we have to replace back
+                # the indices to match the initial convention. 
+                col_fact.replace_indices(self._invert_dict(rep_dict))
+                # Must simplify once to put traces in a canonical ordering
+                col_fact = col_fact.simplify()
+
+            # loop over color strings in the resulting color factor
+            for col_str in col_fact:
+                immutable_col_str = col_str.to_immutable()
+                # if the color structure is already present in the present basis
+                # update it
+                basis_entry = (index,
+                                col_chain,
+                                col_str.coeff,
+                                col_str.is_imaginary,
+                                col_str.Nc_power)
+                try:
+                    self[immutable_col_str].append(basis_entry)
+                except KeyError:
+                    self[immutable_col_str] = [basis_entry]
+
+    def build(self, amplitude, model):
+        """Build the a color basis object using information contained in
+        amplitude and model"""
+
+        for index, diagram in enumerate(amplitude['diagrams']):
+            colorize_dict = self.colorize(diagram, model)
+            self.update_color_basis(colorize_dict, index)
+
+    def __init__(self, *args):
+        """Initialize a new color basis object, either empty or filled (0
+        or 2 arguments). If two arguments are given, the first one is 
+        interpreted as the amplitude and the second one as the model."""
+
+        if len(args) not in (0, 2):
+            raise ValueError, \
+                "Object ColorBasis must be initialized with 0 or 2 arguments"
+
+        if len(args) == 2:
+            self.build(*args)
+
+    def __str__(self):
+        """Returns a nicely formatted string for display"""
+
+        my_str = ""
+        for k, v in self.items():
+            for name, indices in k:
+                my_str = my_str + name + str(indices)
+            my_str = my_str + ': '
+            for contrib in v:
+                imag_str = ''
+                if contrib[3]:
+                    imag_str = 'I'
+                my_str = my_str + '(diag:%i, chain:%s, coeff:%s%s, Nc:%i) ' % \
+                                    (contrib[0], contrib[1], contrib[2],
+                                     imag_str, contrib[4])
+            my_str = my_str + '\n'
+        return my_str
+
+    def _invert_dict(self, mydict):
+        """Helper method to invert dictionary dict"""
+
+        return dict([v, k] for k, v in mydict.items())
+
+#===============================================================================
+# ColorMatrix
+#===============================================================================
+class ColorMatrix(dict):
+    """A color matrix, i.e. a dictionary with pairs (i,j) as keys where i
+    and j refer to elements of color basis objects. Values are Color Factor
+    objects. Also contains two additional dictonaries, one with the fixed Nc
+    representation of the matrix, and the other one with the "inverted" matrix,
+    i.e. a dictionary where keys are values of the color matrix."""
+
+    _col_basis1 = None
+    _col_basis2 = None
+    col_matrix_fixed_Nc = {}
+    inverted_col_matrix = {}
+
+    def __init__(self, col_basis, col_basis2=None,
+                 Nc=3, Nc_power_min=None, Nc_power_max=None):
+        """Initialize a color matrix with one or two color basis objects. If
+        only one color basis is given, the other one is assumed to be equal.
+        As options, any value of Nc and minimal/maximal power of Nc can also be 
+        provided. Note that the min/max power constraint is applied
+        only at the end, so that it does NOT speed up the calculation."""
+
+        self._col_basis1 = col_basis
+        if col_basis2:
+            self._col_basis2 = col_basis2
+            self.build_matrix(Nc, Nc_power_min, Nc_power_max)
+        else:
+            self._col_basis2 = col_basis
+            # If the two color basis are equal, assumes the color matrix is 
+            # symmetric
+            self.build_matrix(Nc, Nc_power_min, Nc_power_max, is_symmetric=True)
+
+    def build_matrix(self, Nc=3,
+                     Nc_power_min=None,
+                     Nc_power_max=None,
+                     is_symmetric=False):
+        """Create the matrix using internal color basis objects. Use the stored
+        color basis objects and takes Nc and Nc_min/max parameters as __init__.
+        If is_isymmetric is True, build only half of the matrix which is assumed
+        to be symmetric."""
+
+        canonical_dict = {}
+
+        for i1, struct1 in \
+                    enumerate(self._col_basis1.keys()):
+            for i2, struct2 in \
+                    enumerate(self._col_basis2.keys()):
+
+                # Only scan upper right triangle if symmetric
+                if is_symmetric and i2 < i1:
+                    continue
+
+                # Fix indices in struct2 knowing summed indices in struct1
+                # to avoid duplicates
+                new_struct2 = self.fix_summed_indices(struct1, struct2)
+
+                # Build a canonical representation of the two immutable struct
+                canonical_entry, dummy = \
+                            color_algebra.ColorString().to_canonical(struct1 + \
+                                                                   new_struct2)
+
+                try:
+                    # If this has already been calculated, use the result
+                    result, result_fixed_Nc = canonical_dict[canonical_entry]
+
+                except KeyError:
+                    # Otherwise calculate the result
+                    result, result_fixed_Nc = \
+                            self.create_new_entry(struct1,
+                                                  new_struct2,
+                                                  Nc_power_min,
+                                                  Nc_power_max,
+                                                  Nc)
+                    # Store both results
+                    canonical_dict[canonical_entry] = (result, result_fixed_Nc)
+
+                # Store the full result...
+                self[(i1, i2)] = result
+                if is_symmetric:
+                    self[(i2, i1)] = result
+
+                # the fixed Nc one ...
+                self.col_matrix_fixed_Nc[(i1, i2)] = result_fixed_Nc
+                if is_symmetric:
+                    self.col_matrix_fixed_Nc[(i2, i1)] = result_fixed_Nc
+                # and update the inverted dict
+                if result_fixed_Nc in self.inverted_col_matrix.keys():
+                    self.inverted_col_matrix[result_fixed_Nc].append((i1,
+                                                                      i2))
+                    if is_symmetric:
+                        self.inverted_col_matrix[result_fixed_Nc].append((i2,
+                                                                          i1))
+                else:
+                    self.inverted_col_matrix[result_fixed_Nc] = [(i1, i2)]
+                    if is_symmetric:
+                        self.inverted_col_matrix[result_fixed_Nc] = [(i2, i1)]
+
+    def create_new_entry(self, struct1, struct2,
+                         Nc_power_min, Nc_power_max, Nc):
+        """ Create a new product result, and result with fixed Nc for two color
+        basis entries. Implement Nc power limits."""
+
+        # Create color string objects corresponding to color basis 
+        # keys
+        col_str = color_algebra.ColorString()
+        col_str.from_immutable(struct1)
+
+        col_str2 = color_algebra.ColorString()
+        col_str2.from_immutable(struct2)
+
+        # Complex conjugate the second one and multiply the two
+        col_str.product(col_str2.complex_conjugate())
+
+        # Create a color factor to store the result and simplify it
+        # taking into account the limit on Nc
+        col_fact = color_algebra.ColorFactor([col_str])
+        result = col_fact.full_simplify()
+
+        # Keep only terms with Nc_max >= Nc power >= Nc_min
+        if Nc_power_min is not None:
+            result[:] = [col_str for col_str in result \
+                         if col_str.Nc_power >= Nc_power_min]
+        if Nc_power_max is not None:
+            result[:] = [col_str for col_str in result \
+                         if col_str.Nc_power <= Nc_power_max]
+
+        # Calculate the fixed Nc representation
+        result_fixed_Nc = result.set_Nc(Nc)
+
+        return result, result_fixed_Nc
+
+    def __str__(self):
+        """Returns a nicely formatted string with the fixed Nc representation
+        of the current matrix (only the real part)"""
+
+        mystr = '\n\t' + '\t'.join([str(i) for i in \
+                                    range(len(self._col_basis2))])
+
+        for i1 in range(len(self._col_basis1)):
+            mystr = mystr + '\n' + str(i1) + '\t'
+            mystr = mystr + '\t'.join(['%i/%i' % \
+                        (self.col_matrix_fixed_Nc[(i1, i2)][0].numerator,
+                        self.col_matrix_fixed_Nc[(i1, i2)][0].denominator) \
+                        for i2 in range(len(self._col_basis2))])
+
+        return mystr
+
+    @classmethod
+    def fix_summed_indices(self, struct1, struct2):
+        """Returns a copy of the immutable Color String representation struct2 
+        where summed indices are modified to avoid duplicates with those
+        appearing in struct1. Assumes internal summed indices are negative."""
+
+        # First, determines what is the smallest index appearing in struct1
+        min_index = min(reduce(operator.add,
+                                [list(elem[1]) for elem in struct1])) - 1
+        # Second, determines the summed indices in struct2 and create a 
+        # replacement dictionary
+        repl_dict = {}
+        list2 = reduce(operator.add,
+                       [list(elem[1]) for elem in struct1])
+        for summed_index in list(set([i for i in list2 \
+                                      if list2.count(i) == 2])):
+            repl_dict[summed_index] = min_index
+            min_index -= 1
+
+        # Three, create a new immutable struct by doing replacements in struct2
+        return_list = []
+        for elem in struct2:
+            fix_elem = [elem[0], []]
+            for index in elem[1]:
+                try:
+                    fix_elem[1].append(repl_dict[index])
+                except:
+                    fix_elem[1].append(index)
+            return_list.append((elem[0], tuple(fix_elem[1])))
+
+        return tuple(return_list)

=== modified file 'madgraph/interface/cmd_interface.py'
--- madgraph/interface/cmd_interface.py	2010-01-04 06:44:15 +0000
+++ madgraph/interface/cmd_interface.py	2010-01-21 09:19:15 +0000
@@ -28,8 +28,13 @@
 
 import madgraph.iolibs.misc as misc
 import madgraph.iolibs.files as files
+<<<<<<< TREE
 import madgraph.iolibs.import_v4 as import_v4
 import madgraph.iolibs.export_v4 as export_v4
+=======
+import madgraph.iolibs.import_model_v4 as import_v4
+import madgraph.iolibs.save_model as save_model
+>>>>>>> MERGE-SOURCE
 
 import madgraph.core.base_objects as base_objects
 import madgraph.core.diagram_generation as diagram_generation
@@ -204,6 +209,37 @@
                                         base_dir=\
                                           self.split_arg(line[0:begidx])[2])
 
+    def do_save(self, line):
+        """Save information to file"""
+
+        args = self.split_arg(line)
+        if len(args) != 2:
+            self.help_save()
+            return False
+
+        if args[0] == 'model':
+            if self.__curr_model:
+                save_model.save_model(args[1], self.__curr_model)
+        else:
+            print 'No model to save!'
+
+    def complete_save(self, text, line, begidx, endidx):
+        "Complete the save command"
+
+        # Format
+        if len(self.split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, ['model'])
+
+        # Filename if directory is not given
+        if len(self.split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(self.split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          self.split_arg(line[0:begidx])[2])
+
     # Display
     def do_display(self, line):
         """Display current internal status"""
@@ -535,6 +571,11 @@
         sys.exit(1)
 
     # In-line help
+    def help_save(self):
+        print "syntax: save model|... PATH"
+        print "-- save information as files in PATH"
+
+    # In-line help
     def help_import(self):
         print "syntax: import " + "|".join(self.__import_formats) + \
               " FILENAME"

=== modified file 'madgraph/iolibs/files.py'
--- madgraph/iolibs/files.py	2009-12-15 06:14:57 +0000
+++ madgraph/iolibs/files.py	2010-01-21 09:19:15 +0000
@@ -37,6 +37,7 @@
         return None
 
     return ret_value
+<<<<<<< TREE
 
 #===============================================================================
 # write_to_file
@@ -58,3 +59,26 @@
         return None
 
     return ret_value
+=======
+
+#===============================================================================
+# write_to_file
+#===============================================================================
+def write_to_file(filename, myfunct, *args):
+    """Open a file for writing, apply the function myfunct (with sock as an arg) 
+    on its content and return the result. Deals properly with errors and
+    returns None if something goes wrong. 
+    """
+
+    try:
+        sock = open(filename, 'w')
+        try:
+            ret_value = myfunct(sock, *args)
+        finally:
+            sock.close()
+    except IOError, (errno, strerror):
+        logging.error("I/O error (%s): %s" % (errno, strerror))
+        return None
+
+    return ret_value
+>>>>>>> MERGE-SOURCE

=== renamed file 'madgraph/iolibs/import_v4.py' => 'madgraph/iolibs/import_model_v4.py'
--- madgraph/iolibs/import_v4.py	2009-12-12 08:42:16 +0000
+++ madgraph/iolibs/import_model_v4.py	2010-01-21 09:19:15 +0000
@@ -158,6 +158,7 @@
                 # Give a dummy 'guess' values for color and Lorentz structures
                 # Those will have to be replaced by a proper guess!
 
+<<<<<<< TREE
                 myinter.set('color', ['guess'])
 
                 # Set the Lorentz structure. Default for 3-particle
@@ -180,6 +181,10 @@
                     myinter.get('lorentz')[0] =\
                                               myinter.get('lorentz')[0]\
                                               + values[3 * len(part_list) - 4].upper()
+=======
+                myinter.set('color', [['C1']])
+                myinter.set('lorentz', ['L1'])
+>>>>>>> MERGE-SOURCE
 
                 # Use the other strings to fill variable names and tags
                 if len(part_list) == 3:

=== added file 'madgraph/iolibs/save_model.py'
--- madgraph/iolibs/save_model.py	1970-01-01 00:00:00 +0000
+++ madgraph/iolibs/save_model.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,89 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+"""Function to save model files."""
+
+import logging
+import os
+
+import madgraph.iolibs.files as files
+import madgraph.core.base_objects as base_objects
+
+def save_particles(fsock, part_list):
+    """Save particle objects contained in part_list in the stream fsock"""
+
+    if not isinstance(part_list, base_objects.ParticleList):
+        raise ValueError, \
+            "Object %s is not a valid ParticleList" % repr(part_list)
+
+    fsock.write("particles = [\n")
+
+    for part in part_list:
+        if part_list.index(part) != len(part_list) - 1:
+            fsock.write(str(part) + ',')
+        else:
+            fsock.write(str(part))
+
+    fsock.write("]")
+
+def save_interactions(fsock, inter_list):
+    """Save interaction objects contained in inter_list in the stream fsock"""
+
+    if not isinstance(inter_list, base_objects.InteractionList):
+        raise ValueError, \
+            "Object %s is not a valid InteractionList" % repr(inter_list)
+
+    fsock.write("interactions = [\n")
+
+    for inter in inter_list:
+        if inter_list.index(inter) != len(inter_list) - 1:
+            fsock.write(str(inter) + ',')
+        else:
+            fsock.write(str(inter))
+
+    fsock.write("]")
+
+def save_model(path, model):
+    """Save a full model in directory path (try to create if necessary)."""
+
+    if not isinstance(model, base_objects.Model):
+        raise ValueError, \
+            "Object %s is not a valid Model" % repr(model)
+
+    if not isinstance(path, str):
+        raise ValueError, \
+            "Object %s is not a path string" % repr(path)
+
+    if not os.path.isdir(path):
+        logging.warning("Path %s does not exist, try to make it..." % str(path))
+        try:
+            os.mkdir(path)
+        except IOError, (errno, strerror):
+            logging.error("I/O error (%s): %s" % (errno, strerror))
+            return None
+
+    print "Saving particles...",
+    files.write_to_file(os.path.join(path, 'particles.py'),
+                        save_particles,
+                        model['particles'])
+    print "%i particles saved to %s" % (len(model['particles']),
+                                      os.path.join(path, 'particles.py'))
+
+    print "Saving interactions...",
+    files.write_to_file(os.path.join(path, 'interactions.py'),
+                        save_interactions,
+                        model['interactions'])
+    print "%i interactions saved to %s" % (len(model['interactions']),
+                                      os.path.join(path, 'interactions.py'))

=== modified file 'tests/test_manager.py'
--- tests/test_manager.py	2009-10-07 11:56:20 +0000
+++ tests/test_manager.py	2010-01-21 09:19:15 +0000
@@ -37,9 +37,13 @@
 import unittest
 
 #Add the ROOT dir to the current PYTHONPATH
+
+# Only for profiling with -m cProfile!
+#root_path = os.path.split(os.path.dirname(os.path.realpath(sys.argv[0])))[0]
+#sys.path.append(root_path)
+
 root_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
 sys.path.append(root_path)
-
 #===============================================================================
 # run
 #===============================================================================

=== modified file 'tests/unit_tests/core/test_base_objects.py'
--- tests/unit_tests/core/test_base_objects.py	2010-01-01 07:58:00 +0000
+++ tests/unit_tests/core/test_base_objects.py	2010-01-21 09:19:15 +0000
@@ -19,6 +19,7 @@
 import unittest
 
 import madgraph.core.base_objects as base_objects
+import madgraph.core.color_algebra as color
 
 #===============================================================================
 # ParticleTest
@@ -261,7 +262,8 @@
 
         self.mydict = {'id': 1,
                        'particles': base_objects.ParticleList([self.mypart] * 4),
-                       'color': ['C1', 'C2'],
+                       'color': [color.ColorString([color.f(1, 2, 3)]),
+                                 color.ColorString([color.d(1, 2, 3)])],
                        'lorentz':['L1', 'L2'],
                        'couplings':{(0, 0):'g00',
                                     (0, 1):'g01',
@@ -329,7 +331,8 @@
                                       base_objects.ParticleList([self.mypart] * 3)],
                         'wrong_list':[1, 'x ', [self.mypart, 1], [1, 2]]},
                        {'prop':'color',
-                        'right_list':[[], ['C1'], ['C1', 'C2']],
+                        'right_list':[[], [color.ColorString([color.f(1, 2, 3)]),
+                                           color.ColorString([color.f(1, 2, 3)])]],
                         'wrong_list':[1, 'a', ['a', 1]]},
                        {'prop':'lorentz',
                         'right_list':[[], ['L1'], ['L1', 'L2']],
@@ -346,9 +349,7 @@
                         'wrong_list':[{(0):'g00', (0, 1):'g01',
                                        (1, 0):'g10', (1, 2):'g11'},
                                       {(0, 0):'g00', (0, 1):'g01',
-                                       (1, 0):'g10', (1, 2):'g11'},
-                                      {(0, 0):'g00', (0, 1):'g01',
-                                       (1, 0):'g10'}]}
+                                       (1, 0):'g10', (1, 2):'g11'}]}
                        ]
 
         mytestinter = self.myinter
@@ -364,9 +365,9 @@
 
         goal = "{\n"
         goal = goal + "    \'id\': %d,\n" % self.myinter['id']
-        goal = goal + "    \'particles\': %s,\n" % \
-                            repr(base_objects.ParticleList([self.mypart] * 4))
-        goal = goal + "    \'color\': [\'C1\', \'C2\'],\n"
+        goal = goal + "    \'particles\': [%s],\n" % \
+                            ','.join([str(self.mypart.get_pdg_code())]*4)
+        goal = goal + "    \'color\': [1 f(1,2,3), 1 d(1,2,3)],\n"
         goal = goal + "    \'lorentz\': [\'L1\', \'L2\'],\n"
         goal = goal + "    \'couplings\': %s,\n" % \
                                     repr(self.myinter['couplings'])
@@ -539,7 +540,8 @@
                                             [self.mypartlist[0], \
                                              antit, \
                                              self.mypartlist[1]]),
-                      'color': ['C1'],
+                      'color': [color.ColorString([color.f(1, 2, 3),
+                                                   color.d(1, 2, 3)])],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQQ'},
                       'orders':{'QCD':1}}))

=== added file 'tests/unit_tests/core/test_color_algebra.py'
--- tests/unit_tests/core/test_color_algebra.py	1970-01-01 00:00:00 +0000
+++ tests/unit_tests/core/test_color_algebra.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,352 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+"""Unit test library for the color algebra related routines 
+in the core library"""
+
+import copy
+import fractions
+import unittest
+
+import madgraph.core.color_algebra as color
+#
+class ColorObjectTest(unittest.TestCase):
+    """Test class for the ColorObject objects"""
+
+    def test_standard(self):
+        """Test the standard routines of ColorObject"""
+
+        my_color_object = color.ColorObject(-1, 2, 3)
+        my_color_object.append(4)
+
+        self.assertEqual('ColorObject(-1,2,3,4)', str(my_color_object))
+
+
+    def test_Tr_simplify(self):
+        """Test simplification of trace objects"""
+
+        # Test Tr(a)=0
+        self.assertEqual(color.Tr(-1).simplify(),
+                         color.ColorFactor([color.ColorString(coeff=0)]))
+
+        # Test Tr()=Nc
+        col_str = color.ColorString()
+        col_str.Nc_power = 1
+        self.assertEqual(color.Tr().simplify(), color.ColorFactor([col_str]))
+
+        # Test cyclicity
+        col_str = color.ColorString([color.Tr(1, 2, 3, 4, 5)])
+        self.assertEqual(color.Tr(3, 4, 5, 1, 2).simplify(),
+                         color.ColorFactor([col_str]))
+
+        # Tr(a,x,b,x,c) = 1/2(Tr(a,c)Tr(b)-1/Nc Tr(a,b,c))
+        col_str1 = color.ColorString([color.Tr(1, 2, 4), color.Tr(3)])
+        col_str2 = color.ColorString([color.Tr(1, 2, 3, 4)])
+        col_str1.coeff = fractions.Fraction(1, 2)
+        col_str2.coeff = fractions.Fraction(-1, 2)
+        col_str2.Nc_power = -1
+        my_tr = color.Tr(1, 2, 100, 3, 100, 4)
+        self.assertEqual(my_tr.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+
+        my_tr = color.Tr(1, 2, 100, 100, 4)
+
+        col_str1 = color.ColorString([color.Tr(1, 2, 4), color.Tr()])
+        col_str2 = color.ColorString([color.Tr(1, 2, 4)])
+        self.assertEqual(my_tr.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+
+        my_tr = color.Tr(100, 100)
+        col_str1 = color.ColorString([color.Tr(), color.Tr()])
+        col_str2 = color.ColorString([color.Tr()])
+        self.assertEqual(my_tr.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+
+    def test_Tr_pair_simplify(self):
+        """Test Tr object product simplification"""
+
+        my_Tr1 = color.Tr(1, 2, 3)
+        my_Tr2 = color.Tr(4, 2, 5)
+        my_T = color.T(4, 2, 5, 101, 102)
+
+        col_str1 = color.ColorString([color.Tr(1, 5, 4, 3)])
+        col_str2 = color.ColorString([color.Tr(1, 3), color.Tr(4, 5)])
+        col_str1.coeff = fractions.Fraction(1, 2)
+        col_str2.coeff = fractions.Fraction(-1, 2)
+        col_str2.Nc_power = -1
+        self.assertEqual(my_Tr1.pair_simplify(my_Tr2),
+                         color.ColorFactor([col_str1, col_str2]))
+
+        col_str1 = color.ColorString([color.T(4, 3, 1, 5, 101, 102)])
+        col_str2 = color.ColorString([color.Tr(1, 3), color.T(4, 5, 101, 102)])
+        self.assertEqual(my_Tr1.pair_simplify(my_T),
+                         color.ColorFactor([col_str1, col_str2]))
+
+
+    def test_T_simplify(self):
+        """Test T simplify"""
+
+        # T(a,b,c,...,i,i) = Tr(a,b,c,...)
+        self.assertEqual(color.T(1, 2, 3, 100, 100).simplify(),
+                         color.ColorFactor([\
+                                    color.ColorString([color.Tr(1, 2, 3)])]))
+
+        # T(a,x,b,x,c,i,j) = 1/2(T(a,c,i,j)Tr(b)-1/Nc T(a,b,c,i,j))
+        my_T = color.T(1, 2, 100, 3, 100, 4, 101, 102)
+        col_str1 = color.ColorString([color.T(1, 2, 4, 101, 102), color.Tr(3)])
+        col_str2 = color.ColorString([color.T(1, 2, 3, 4, 101, 102)])
+        col_str1.coeff = fractions.Fraction(1, 2)
+        col_str2.coeff = fractions.Fraction(-1, 2)
+        col_str2.Nc_power = -1
+        self.assertEqual(my_T.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+        self.assertEqual(my_T.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+    def test_T_pair_simplify(self):
+        """Test T object products simplifications"""
+
+        my_T1 = color.T(1, 2, 3, 101, 102)
+        my_T2 = color.T(4, 5, 102, 103)
+        self.assertEqual(my_T1.pair_simplify(my_T2),
+                         color.ColorFactor([color.ColorString([\
+                                        color.T(1, 2, 3, 4, 5, 101, 103)])]))
+
+        my_T3 = color.T(4, 2, 5, 103, 104)
+        col_str1 = color.ColorString([color.T(1, 5, 101, 104),
+                                     color.T(4, 3, 103, 102)])
+        col_str2 = color.ColorString([color.T(1, 3, 101, 102),
+                                     color.T(4, 5, 103, 104)])
+        col_str1.coeff = fractions.Fraction(1, 2)
+        col_str2.coeff = fractions.Fraction(-1, 2)
+        col_str2.Nc_power = -1
+        self.assertEqual(my_T1.pair_simplify(my_T3, simplify_T_product=True),
+                         color.ColorFactor([col_str1, col_str2]))
+
+    def test_f_object(self):
+        """Test the f color object"""
+        # T should have exactly 3 indices!
+        self.assertRaises(ValueError,
+                         color.f,
+                         1, 2, 3, 4)
+
+        # Simplify should always return the same ColorFactor
+        my_f = color.f(1, 2, 3)
+        col_str1 = color.ColorString([color.Tr(1, 2, 3)])
+        col_str2 = color.ColorString([color.Tr(3, 2, 1)])
+        col_str1.coeff = fractions.Fraction(-2, 1)
+        col_str2.coeff = fractions.Fraction(2, 1)
+        col_str1.is_imaginary = True
+        col_str2.is_imaginary = True
+
+        self.assertEqual(my_f.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+
+    def test_d_object(self):
+        """Test the d color object"""
+        # T should have exactly 3 indices!
+        self.assertRaises(ValueError,
+                         color.d,
+                         1, 2)
+
+        # Simplify should always return the same ColorFactor
+        my_d = color.d(1, 2, 3)
+        col_str1 = color.ColorString([color.Tr(1, 2, 3)])
+        col_str2 = color.ColorString([color.Tr(3, 2, 1)])
+        col_str1.coeff = fractions.Fraction(2, 1)
+        col_str2.coeff = fractions.Fraction(2, 1)
+
+        self.assertEqual(my_d.simplify(),
+                         color.ColorFactor([col_str1, col_str2]))
+
+
+class ColorStringTest(unittest.TestCase):
+    """Test class for the ColorString objects"""
+
+    my_col_string = color.ColorString()
+
+    def setUp(self):
+        """Initialize the ColorString test"""
+        # Create a test color string
+
+        test_f = color.f(1, 2, 3)
+        test_d = color.d(4, 5, 6)
+
+        self.my_col_string = color.ColorString([test_f, test_d],
+                                               coeff=fractions.Fraction(2, 3),
+                                               Nc_power= -2,
+                                               is_imaginary=True)
+
+    def test_representation(self):
+        """Test ColorString representation"""
+
+        self.assertEqual(str(self.my_col_string),
+                         "2/3 I 1/Nc^2 f(1,2,3) d(4,5,6)")
+
+    def test_product(self):
+        """Test the product of two color strings"""
+        test = copy.copy(self.my_col_string)
+        test.product(self.my_col_string)
+        self.assertEqual(str(test),
+                         "-4/9 1/Nc^4 f(1,2,3) d(4,5,6) f(1,2,3) d(4,5,6)")
+
+
+    def test_simplify(self):
+        """Test the simplification of a string"""
+
+        # Simplification of one term
+        self.assertEqual(str(self.my_col_string.simplify()),
+            '(4/3 1/Nc^2 Tr(1,2,3) d(4,5,6))+(-4/3 1/Nc^2 Tr(3,2,1) d(4,5,6))')
+
+    def test_complex_conjugate(self):
+        """Test the complex conjugation of a color string"""
+
+        my_color_string = color.ColorString([color.T(3, 4, 102, 103),
+                                             color.Tr(1, 2, 3)])
+        my_color_string.is_imaginary = True
+
+        self.assertEqual(str(my_color_string.complex_conjugate()),
+                         '-1 I T(4,3,103,102) Tr(3,2,1)')
+
+    def test_to_immutable(self):
+        """Test the immutable representation of a color string structure"""
+
+        self.assertEqual(self.my_col_string.to_immutable(),
+                         (('d', (4, 5, 6)), ('f', (1, 2, 3))))
+
+    def test_from_immutable(self):
+        """Test the creation of a color string using its immutable rep"""
+
+        test_str = copy.copy(self.my_col_string)
+        test_str.from_immutable((('f', (1, 2, 3)), ('d', (4, 5, 6))))
+
+        self.assertEqual(test_str, self.my_col_string)
+
+    def test_replace_indices(self):
+        """Test indices replacement"""
+
+        repl_dict = {1:2, 2:3, 3:1}
+
+        my_color_string = color.ColorString([color.T(1, 2, 3, 4),
+                                             color.Tr(3, 2, 1)])
+
+        my_color_string.replace_indices(repl_dict)
+        self.assertEqual(str(my_color_string),
+                         '1 T(2,3,1,4) Tr(1,3,2)')
+
+    def test_color_string_canonical(self):
+        """Test the canonical representation of a immutable color string"""
+
+        immutable1 = (('f', (2, 3, 4)), ('T', (4, 2, 5)))
+        immutable2 = (('T', (3, 5)),)
+
+        self.assertEqual(color.ColorString().to_canonical(immutable1 + \
+                                                               immutable2)[0],
+                         (('T', (2, 4)), ('T', (3, 1, 4)), ('f', (1, 2, 3))))
+
+class ColorFactorTest(unittest.TestCase):
+    """Test class for the ColorFactor objects"""
+
+    def test_f_d_sum(self):
+        """Test f and d sum with the right weights giving a Tr"""
+
+        col_str1 = color.ColorString([color.d(1, 2, 3)])
+        col_str1.coeff = fractions.Fraction(1, 4)
+        col_str2 = color.ColorString([color.f(1, 2, 3)])
+        col_str2.coeff = fractions.Fraction(1, 4)
+        col_str2.is_imaginary = True
+
+        my_color_factor = color.ColorFactor([col_str1, col_str2])
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+                         '(1 Tr(1,2,3))')
+
+    def test_f_product(self):
+        """Test the fully contracted product of two f's"""
+
+        my_color_factor = color.ColorFactor([\
+                    color.ColorString([color.f(1, 2, 3), color.f(1, 2, 3)])])
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+                         '(-1 Nc^1 )+(1 Nc^3 )')
+
+
+    def test_d_product(self):
+        """Test the fully contracted product of two d's"""
+
+        my_color_factor = color.ColorFactor([\
+                    color.ColorString([color.d(1, 2, 3), color.d(1, 2, 3)])])
+
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+                         '(-5 Nc^1 )+(4 1/Nc^1 )+(1 Nc^3 )')
+
+    def test_f_d_product(self):
+        """Test the fully contracted product of f and d"""
+
+        my_color_factor = color.ColorFactor([\
+                    color.ColorString([color.f(1, 2, 3), color.d(1, 2, 3)])])
+
+
+        self.assertEqual(str(my_color_factor.full_simplify()), '')
+
+    def test_three_f_chain(self):
+        """Test a chain of three f's"""
+
+        my_color_factor = color.ColorFactor([\
+                    color.ColorString([color.f(1, 2, -1),
+                                       color.f(-1, 3, -2),
+                                       color.f(-2, 4, 5)])])
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+        "(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,4,5,3))+(-2 I Tr(1,2,3,5,4))" + \
+        "+(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,4,5,3,2))" + \
+        "+(2 I Tr(1,3,5,4,2))+(-2 I Tr(1,5,4,3,2))")
+
+    def test_Tr_product(self):
+        """Test a non trivial product of two traces"""
+
+        my_color_factor = color.ColorFactor([\
+                    color.ColorString([color.Tr(1, 2, 3, 4, 5, 6, 7),
+                                       color.Tr(1, 7, 6, 5, 4, 3, 2)])])
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+        "(1/128 Nc^7 )+(-7/128 Nc^5 )+(21/128 Nc^3 )+(-35/128 Nc^1 )" + \
+        "+(35/128 1/Nc^1 )+(-21/128 1/Nc^3 )+(3/64 1/Nc^5 )")
+
+    def test_T_f_product(self):
+        """Test a non trivial T f f product"""
+
+        my_color_factor = color.ColorFactor([\
+                                    color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1, -1000, 5),
+                                               color.f(-1, 4, 3)])])
+
+        self.assertEqual(str(my_color_factor.full_simplify()),
+        "(-1 T(5,4,3,1,2))+(1 T(5,3,4,1,2))+(1 T(4,3,5,1,2))+(-1 T(3,4,5,1,2))")
+
+
+    def test_gluons(self):
+        """Test simplification of chains of f"""
+
+        my_col_fact = color.ColorFactor([color.ColorString([color.f(-3, 1, 2),
+                                    color.f(-1, 3, 4),
+                                    color.f(-1, 5, -3)
+                                    ])])
+
+        self.assertEqual(str(my_col_fact.full_simplify()),
+        '(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,5,3,4))+(-2 I Tr(1,2,4,3,5))+' + \
+        '(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,5,3,4,2))+' + \
+        '(2 I Tr(1,4,3,5,2))+(-2 I Tr(1,5,4,3,2))')
+

=== added file 'tests/unit_tests/core/test_color_amp.py'
--- tests/unit_tests/core/test_color_amp.py	1970-01-01 00:00:00 +0000
+++ tests/unit_tests/core/test_color_amp.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,600 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+"""Unit test library for the routines of the core library related to writing
+color information for diagrams."""
+
+import copy
+import fractions
+import unittest
+
+import madgraph.core.base_objects as base_objects
+import madgraph.core.diagram_generation as diagram_generation
+
+import madgraph.core.color_amp as color_amp
+import madgraph.core.color_algebra as color
+
+class ColorAmpTest(unittest.TestCase):
+    """Test class for the color_amp module"""
+
+    mypartlist = base_objects.ParticleList()
+    myinterlist = base_objects.InteractionList()
+    mymodel = base_objects.Model()
+
+    def setUp(self):
+        # A gluon
+        self.mypartlist.append(base_objects.Particle({'name':'g',
+                      'antiname':'g',
+                      'spin':3,
+                      'color':8,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'g',
+                      'antitexname':'g',
+                      'line':'curly',
+                      'charge':0.,
+                      'pdg_code':21,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':True}))
+
+        # A quark U and its antiparticle
+        self.mypartlist.append(base_objects.Particle({'name':'u',
+                      'antiname':'u~',
+                      'spin':2,
+                      'color':3,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'u',
+                      'antitexname':'\bar u',
+                      'line':'straight',
+                      'charge':2. / 3.,
+                      'pdg_code':2,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':False}))
+        antiu = copy.copy(self.mypartlist[1])
+        antiu.set('is_part', False)
+
+        # A quark D and its antiparticle
+        self.mypartlist.append(base_objects.Particle({'name':'d',
+                      'antiname':'d~',
+                      'spin':2,
+                      'color':3,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'u',
+                      'antitexname':'\bar u',
+                      'line':'straight',
+                      'charge':-1. / 3.,
+                      'pdg_code':1,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':False}))
+        antid = copy.copy(self.mypartlist[2])
+        antid.set('is_part', False)
+
+        # A photon
+        self.mypartlist.append(base_objects.Particle({'name':'a',
+                      'antiname':'a',
+                      'spin':3,
+                      'color':1,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'\gamma',
+                      'antitexname':'\gamma',
+                      'line':'wavy',
+                      'charge':0.,
+                      'pdg_code':22,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':True}))
+
+        # A Higgs
+        self.mypartlist.append(base_objects.Particle({'name':'h',
+                      'antiname':'h',
+                      'spin':1,
+                      'color':1,
+                      'mass':'mh',
+                      'width':'wh',
+                      'texname':'h',
+                      'antitexname':'h',
+                      'line':'dashed',
+                      'charge':0.,
+                      'pdg_code':25,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':True}))
+
+        # 3 gluon vertiex
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 1,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[0]] * 3),
+                      'color': [color.ColorString([color.f(0, 1, 2)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'G'},
+                      'orders':{'QCD':1}}))
+
+        # 4 gluon vertex
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 2,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[0]] * 4),
+                      'color': [color.ColorString([color.f(-1, 0, 2),
+                                                   color.f(-1, 1, 3)]),
+                                color.ColorString([color.f(-1, 0, 3),
+                                                   color.f(-1, 1, 2)]),
+                                color.ColorString([color.f(-1, 0, 1),
+                                                   color.f(-1, 2, 3)])],
+                      'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
+                      'couplings':{(0, 0):'G^2',
+                                   (1, 1):'G^2',
+                                   (2, 2):'G^2'},
+                      'orders':{'QCD':2}}))
+
+        # Gluon couplings to up and down quarks
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 3,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[1], \
+                                             antiu, \
+                                             self.mypartlist[0]]),
+                      'color': [color.ColorString([color.T(2, 0, 1)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'GQQ'},
+                      'orders':{'QCD':1}}))
+
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 4,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[2], \
+                                             antid, \
+                                             self.mypartlist[0]]),
+                      'color': [color.ColorString([color.T(2, 0, 1)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'GQQ'},
+                      'orders':{'QCD':1}}))
+
+        # Photon coupling to up
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 5,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[1], \
+                                             antiu, \
+                                             self.mypartlist[3]]),
+                      'color': [color.ColorString([color.T(0, 1)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'GQED'},
+                      'orders':{'QED':1}}))
+
+        self.mymodel.set('particles', self.mypartlist)
+        self.mymodel.set('interactions', self.myinterlist)
+
+    def test_colorize_uu_gg(self):
+        """Test the colorize function for uu~ > gg"""
+
+        myleglist = base_objects.LegList()
+
+        myleglist.append(base_objects.Leg({'id':-2,
+                                         'state':'initial'}))
+        myleglist.append(base_objects.Leg({'id':2,
+                                         'state':'initial'}))
+
+        myleglist.extend([base_objects.Leg({'id':21,
+                                            'state':'final'})] * 2)
+
+        myprocess = base_objects.Process({'legs':myleglist,
+                                        'model':self.mymodel})
+
+        myamplitude = diagram_generation.Amplitude()
+
+        myamplitude.set('process', myprocess)
+
+        myamplitude.generate_diagrams()
+
+        my_col_basis = color_amp.ColorBasis()
+
+        # S channel
+        col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
+                                     self.mymodel)
+
+        goal_dict = {(0, 0):color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1000, 4, 3)])}
+
+        self.assertEqual(col_dict, goal_dict)
+
+        # T channel
+        col_dict = my_col_basis.colorize(myamplitude['diagrams'][1],
+                                     self.mymodel)
+
+        goal_dict = {(0, 0):color.ColorString([color.T(3, 1, -1000),
+                                               color.T(4, -1000, 2)])}
+
+        self.assertEqual(col_dict, goal_dict)
+
+        # U channel
+        col_dict = my_col_basis.colorize(myamplitude['diagrams'][2],
+                                     self.mymodel)
+
+        goal_dict = {(0, 0):color.ColorString([color.T(4, 1, -1000),
+                                               color.T(3, -1000, 2)])}
+
+        self.assertEqual(col_dict, goal_dict)
+
+    def test_colorize_uux_ggg(self):
+        """Test the colorize function for uu~ > ggg"""
+
+        myleglist = base_objects.LegList()
+
+        myleglist.append(base_objects.Leg({'id':-2,
+                                         'state':'initial'}))
+        myleglist.append(base_objects.Leg({'id':2,
+                                         'state':'initial'}))
+
+        myleglist.extend([base_objects.Leg({'id':21,
+                                            'state':'final'})] * 3)
+
+        myprocess = base_objects.Process({'legs':myleglist,
+                                        'model':self.mymodel})
+
+        myamplitude = diagram_generation.Amplitude()
+
+        myamplitude.set('process', myprocess)
+
+        myamplitude.generate_diagrams()
+
+        my_col_basis = color_amp.ColorBasis()
+
+        # First diagram with two 3-gluon vertices
+        col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
+                                     self.mymodel)
+
+        goal_dict = {(0, 0, 0):color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1001, 4, 3),
+                                               color.f(5, -1001, -1000)])}
+
+        self.assertEqual(col_dict, goal_dict)
+
+        # Diagram with one 4-gluon vertex
+        col_dict = my_col_basis.colorize(myamplitude['diagrams'][3],
+                                     self.mymodel)
+
+        goal_dict = {(0, 0):color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1002, -1000, 4),
+                                               color.f(-1002, 5, 3)]),
+                     (0, 1):color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1003, -1000, 3),
+                                               color.f(-1003, 5, 4)]),
+                     (0, 2):color.ColorString([color.T(-1000, 1, 2),
+                                               color.f(-1004, -1000, 5),
+                                               color.f(-1004, 4, 3)])}
+
+        self.assertEqual(col_dict, goal_dict)
+
+    def test_color_basis_uux_aggg(self):
+        """Test the color basis building for uu~ > aggg (3! elements)"""
+
+        myleglist = base_objects.LegList()
+
+        myleglist.append(base_objects.Leg({'id':2,
+                                         'state':'initial'}))
+        myleglist.append(base_objects.Leg({'id':-2,
+                                         'state':'initial'}))
+
+        myleglist.append(base_objects.Leg({'id':22,
+                                         'state':'final'}))
+        myleglist.extend([base_objects.Leg({'id':21,
+                                            'state':'final'})] * 3)
+
+        myprocess = base_objects.Process({'legs':myleglist,
+                                        'model':self.mymodel})
+
+        myamplitude = diagram_generation.Amplitude()
+
+        myamplitude.set('process', myprocess)
+
+        myamplitude.generate_diagrams()
+
+        new_col_basis = color_amp.ColorBasis(myamplitude, self.mymodel)
+
+        self.assertEqual(len(new_col_basis), 6)
+
+class ColorSquareTest(unittest.TestCase):
+    """Test class for the color_amp module"""
+
+    mypartlist = base_objects.ParticleList()
+    myinterlist = base_objects.InteractionList()
+    mymodel = base_objects.Model()
+
+    def setUp(self):
+        # A gluon
+        self.mypartlist.append(base_objects.Particle({'name':'g',
+                      'antiname':'g',
+                      'spin':3,
+                      'color':8,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'g',
+                      'antitexname':'g',
+                      'line':'curly',
+                      'charge':0.,
+                      'pdg_code':21,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':True}))
+
+        # A quark U and its antiparticle
+        self.mypartlist.append(base_objects.Particle({'name':'u',
+                      'antiname':'u~',
+                      'spin':2,
+                      'color':3,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'u',
+                      'antitexname':'\bar u',
+                      'line':'straight',
+                      'charge':2. / 3.,
+                      'pdg_code':2,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':False}))
+        antiu = copy.copy(self.mypartlist[1])
+        antiu.set('is_part', False)
+
+        # A quark D and its antiparticle
+        self.mypartlist.append(base_objects.Particle({'name':'d',
+                      'antiname':'d~',
+                      'spin':2,
+                      'color':3,
+                      'mass':'zero',
+                      'width':'zero',
+                      'texname':'u',
+                      'antitexname':'\bar u',
+                      'line':'straight',
+                      'charge':-1. / 3.,
+                      'pdg_code':1,
+                      'propagating':True,
+                      'is_part':True,
+                      'self_antipart':False}))
+        antid = copy.copy(self.mypartlist[2])
+        antid.set('is_part', False)
+
+        # 3 gluon vertiex
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 1,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[0]] * 3),
+                      'color': [color.ColorString([color.f(0, 1, 2)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'G'},
+                      'orders':{'QCD':1}}))
+
+        # 4 gluon vertex
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 2,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[0]] * 4),
+                      'color': [color.ColorString([color.f(-1, 0, 2),
+                                                   color.f(-1, 1, 3)]),
+                                color.ColorString([color.f(-1, 0, 3),
+                                                   color.f(-1, 1, 2)]),
+                                color.ColorString([color.f(-1, 0, 1),
+                                                   color.f(-1, 2, 3)])],
+                      'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
+                      'couplings':{(0, 0):'G^2',
+                                   (1, 1):'G^2',
+                                   (2, 2):'G^2'},
+                      'orders':{'QCD':2}}))
+
+        # Gluon couplings to up and down quarks
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 3,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[1], \
+                                             antiu, \
+                                             self.mypartlist[0]]),
+                      'color': [color.ColorString([color.T(2, 0, 1)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'GQQ'},
+                      'orders':{'QCD':1}}))
+
+        self.myinterlist.append(base_objects.Interaction({
+                      'id': 4,
+                      'particles': base_objects.ParticleList(\
+                                            [self.mypartlist[2], \
+                                             antid, \
+                                             self.mypartlist[0]]),
+                      'color': [color.ColorString([color.T(2, 0, 1)])],
+                      'lorentz':['L1'],
+                      'couplings':{(0, 0):'GQQ'},
+                      'orders':{'QCD':1}}))
+
+
+        self.mymodel.set('particles', self.mypartlist)
+        self.mymodel.set('interactions', self.myinterlist)
+
+    def test_color_matrix_multi_gluons(self):
+        """Test the color matrix building for gg > n*g with n up to 3"""
+
+        goal = [fractions.Fraction(7, 3),
+                fractions.Fraction(19, 6),
+                fractions.Fraction(455, 108),
+                fractions.Fraction(3641, 648)]
+
+        goal_line1 = [(fractions.Fraction(7, 3), fractions.Fraction(-2, 3)),
+                      (fractions.Fraction(19, 6), fractions.Fraction(-1, 3),
+                       fractions.Fraction(-1, 3), fractions.Fraction(-1, 3),
+                       fractions.Fraction(2, 3), fractions.Fraction(-1, 3)),
+                    (fractions.Fraction(455, 108), fractions.Fraction(-29, 54),
+                       fractions.Fraction(17, 27), fractions.Fraction(7, 54),
+                       fractions.Fraction(-1, 27), fractions.Fraction(17, 27),
+                       fractions.Fraction(5, 108), fractions.Fraction(7, 54),
+                       fractions.Fraction(7, 54), fractions.Fraction(-1, 27),
+                       fractions.Fraction(7, 54), fractions.Fraction(5, 108),
+                       fractions.Fraction(-10, 27), fractions.Fraction(-29, 54),
+                       fractions.Fraction(-29, 54), fractions.Fraction(-29, 54),
+                       fractions.Fraction(-29, 54), fractions.Fraction(7, 54),
+                       fractions.Fraction(17, 27), fractions.Fraction(-1, 27),
+                       fractions.Fraction(-1, 27), fractions.Fraction(17, 27),
+                       fractions.Fraction(-1, 27), fractions.Fraction(17, 27))]
+
+        for n in range(3):
+            myleglist = base_objects.LegList()
+
+            myleglist.append(base_objects.Leg({'id':21,
+                                             'state':'initial'}))
+            myleglist.append(base_objects.Leg({'id':21,
+                                             'state':'initial'}))
+
+            myleglist.extend([base_objects.Leg({'id':21,
+                                                'state':'final'})] * (n + 1))
+
+            myprocess = base_objects.Process({'legs':myleglist,
+                                            'model':self.mymodel})
+
+            myamplitude = diagram_generation.Amplitude()
+
+            myamplitude.set('process', myprocess)
+
+            myamplitude.generate_diagrams()
+
+            col_basis = color_amp.ColorBasis(myamplitude, self.mymodel)
+
+            col_matrix = color_amp.ColorMatrix(col_basis, Nc=3)
+
+            # Check diagonal
+            for i in range(len(col_basis.items())):
+                self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
+                                 (goal[n], 0))
+
+            # Check first line
+            for i in range(len(col_basis.items())):
+                self.assertEqual(col_matrix.col_matrix_fixed_Nc[(0, i)],
+                                 (goal_line1[n][i], 0))
+
+    def test_color_matrix_multi_quarks(self):
+        """Test the color matrix building for qq~ > n*(qq~) with n up to 2"""
+
+        goal = [fractions.Fraction(2, 1),
+                fractions.Fraction(72, 54)]
+
+
+
+        goal_line1 = [(fractions.Fraction(2, 1), fractions.Fraction(-2, 3)),
+                      (fractions.Fraction(4, 3), fractions.Fraction(-5, 27),
+                       fractions.Fraction(7, 6), fractions.Fraction(-1, 3),
+                       fractions.Fraction(1, 9), fractions.Fraction(-7, 18),
+                       fractions.Fraction(-5, 27), fractions.Fraction(-7, 18),
+                       fractions.Fraction(1, 18), fractions.Fraction(31, 27),
+                       fractions.Fraction(-5, 27), fractions.Fraction(-7, 18),
+                       fractions.Fraction(-1, 3), fractions.Fraction(31, 27),
+                       fractions.Fraction(-1, 3), fractions.Fraction(-4, 9),
+                       fractions.Fraction(1, 9), fractions.Fraction(7, 6),
+                       fractions.Fraction(-1, 6), fractions.Fraction(-5, 27),
+                       fractions.Fraction(-1, 54), fractions.Fraction(1, 9),
+                       fractions.Fraction(1, 18), fractions.Fraction(1, 18),
+                       fractions.Fraction(4, 27), fractions.Fraction(-1, 54),
+                       fractions.Fraction(5, 9), fractions.Fraction(1, 9),
+                       fractions.Fraction(-4, 9), fractions.Fraction(-1, 54),
+                       fractions.Fraction(71, 54), fractions.Fraction(1, 18),
+                       fractions.Fraction(-7, 18), fractions.Fraction(-1, 3),
+                       fractions.Fraction(-1, 54), fractions.Fraction(5, 9))
+                      ]
+
+        for n in range(2):
+            myleglist = base_objects.LegList()
+
+            myleglist.append(base_objects.Leg({'id':2,
+                                             'state':'initial'}))
+            myleglist.append(base_objects.Leg({'id':-2,
+                                             'state':'initial'}))
+
+            myleglist.extend([base_objects.Leg({'id':2,
+                                                'state':'final'}),
+                             base_objects.Leg({'id':-2,
+                                                'state':'final'})] * (n + 1))
+
+            myprocess = base_objects.Process({'legs':myleglist,
+                                            'model':self.mymodel})
+
+            myamplitude = diagram_generation.Amplitude()
+
+            myamplitude.set('process', myprocess)
+
+            myamplitude.generate_diagrams()
+
+            col_basis = color_amp.ColorBasis(myamplitude, self.mymodel)
+
+            col_matrix = color_amp.ColorMatrix(col_basis, Nc=3)
+
+            # Check diagonal
+            for i in range(len(col_basis.items())):
+                self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
+                                 (goal[n], 0))
+
+            # Check first line
+            for i in range(len(col_basis.items())):
+                self.assertEqual(col_matrix.col_matrix_fixed_Nc[(0, i)],
+                                 (goal_line1[n][i], 0))
+
+    def test_color_matrix_Nc_restrictions(self):
+        """Test the Nc power restriction during color basis building """
+
+        goal = [fractions.Fraction(3, 8),
+                fractions.Fraction(-9, 4),
+                fractions.Fraction(45, 16)]
+
+        for n in range(3):
+            myleglist = base_objects.LegList()
+
+            myleglist.append(base_objects.Leg({'id':21,
+                                             'state':'initial'}))
+            myleglist.append(base_objects.Leg({'id':21,
+                                             'state':'initial'}))
+
+            myleglist.extend([base_objects.Leg({'id':21,
+                                                'state':'final'})] * 2)
+
+            myprocess = base_objects.Process({'legs':myleglist,
+                                            'model':self.mymodel})
+
+            myamplitude = diagram_generation.Amplitude()
+
+            myamplitude.set('process', myprocess)
+
+            myamplitude.generate_diagrams()
+
+            col_basis = color_amp.ColorBasis(myamplitude, self.mymodel)
+
+            col_matrix = color_amp.ColorMatrix(col_basis, Nc=3,
+                                                  Nc_power_min=n,
+                                                  Nc_power_max=2 * n)
+
+            for i in range(len(col_basis.items())):
+                self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
+                                 (goal[n], 0))
+
+
+    def test_color_matrix_fixed_indices(self):
+        """Test index fixing for immutable color string"""
+
+        immutable1 = (('f', (1, -1, -3)), ('T', (-1, -3, 4)))
+        immutable2 = (('d', (1, -2, -1)), ('T', (-1, -2, 4)))
+
+        self.assertEqual(color_amp.ColorMatrix.fix_summed_indices(immutable1,
+                                                               immutable2),
+                         (('d', (1, -2, -5)), ('T', (-5, -2, 4))))
+

=== modified file 'tests/unit_tests/core/test_diagram_generation.py'
--- tests/unit_tests/core/test_diagram_generation.py	2010-01-04 06:44:15 +0000
+++ tests/unit_tests/core/test_diagram_generation.py	2010-01-21 09:19:15 +0000
@@ -231,7 +231,7 @@
                       'id': 1,
                       'particles': base_objects.ParticleList(\
                                             [self.mypartlist[0]] * 3),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'G'},
                       'orders':{'QCD':1}}))
@@ -241,7 +241,7 @@
                       'id': 2,
                       'particles': base_objects.ParticleList(\
                                             [self.mypartlist[0]] * 4),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'G^2'},
                       'orders':{'QCD':2}}))
@@ -253,7 +253,7 @@
                                             [self.mypartlist[1], \
                                              antiu, \
                                              self.mypartlist[0]]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQQ'},
                       'orders':{'QCD':1}}))
@@ -264,7 +264,7 @@
                                             [self.mypartlist[1], \
                                              antiu, \
                                              self.mypartlist[3]]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))
@@ -275,7 +275,7 @@
                                             [self.mypartlist[2], \
                                              antid, \
                                              self.mypartlist[0]]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQQ'},
                       'orders':{'QCD':1}}))
@@ -286,7 +286,7 @@
                                             [self.mypartlist[2], \
                                              antid, \
                                              self.mypartlist[3]]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))
@@ -299,7 +299,7 @@
                                             [self.mypartlist[4], \
                                              antie, \
                                              self.mypartlist[3]]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))
@@ -1019,7 +1019,7 @@
                                             [antid, \
                                              u, \
                                              wminus]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))
@@ -1032,7 +1032,7 @@
                                             [antiu, \
                                              d, \
                                              wplus]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))
@@ -1045,7 +1045,7 @@
                                             [nuebar, \
                                              eminus, \
                                              wplus]),
-                      'color': ['C1'],
+                      'color': [['C1']],
                       'lorentz':['L1'],
                       'couplings':{(0, 0):'GQED'},
                       'orders':{'QED':1}}))

=== renamed file 'tests/unit_tests/iolibs/test_import_v4.py' => 'tests/unit_tests/iolibs/test_import_model_v4.py'
--- tests/unit_tests/iolibs/test_import_v4.py	2009-12-12 08:42:16 +0000
+++ tests/unit_tests/iolibs/test_import_model_v4.py	2010-01-21 09:19:15 +0000
@@ -19,7 +19,7 @@
 import unittest
 import copy
 
-import madgraph.iolibs.import_v4 as import_v4
+import madgraph.iolibs.import_model_v4 as import_v4
 import madgraph.core.base_objects as base_objects
 
 #===============================================================================
@@ -28,12 +28,6 @@
 class IOImportV4Test(unittest.TestCase):
     """Test class for the import v4 module"""
 
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
     def test_read_particles(self):
         """Test the output of import particles.dat file"""
 
@@ -136,7 +130,7 @@
         wmin = copy.copy(myparts[14])
         wmin.set('is_part', False)
         eplus = copy.copy(myparts[3])
-        eplus.set('is_part',False)
+        eplus.set('is_part', False)
         enu = copy.copy(myparts[0])
         photon = copy.copy(myparts[12])
         gluon = copy.copy(myparts[15])
@@ -149,8 +143,13 @@
                                                                 wplus,
                                                                 wmin,
                                                                 photon]),
+<<<<<<< TREE
                                      'color':['guess'],
                                      'lorentz':[''],
+=======
+                                     'color':[['C1']],
+                                     'lorentz':['L1'],
+>>>>>>> MERGE-SOURCE
                                      'couplings':{(0, 0):'MGVX3'},
                                      'orders':{'QED':1}}),
                      base_objects.Interaction(
@@ -159,8 +158,13 @@
                                                                 gluon,
                                                                 gluon,
                                                                 t1]),
+<<<<<<< TREE
                                      'color':['guess'],
                                      'lorentz':['A'],
+=======
+                                     'color':[['C1']],
+                                     'lorentz':['L1'],
+>>>>>>> MERGE-SOURCE
                                      'couplings':{(0, 0):'MGVX2'},
                                      'orders':{'QCD':1}}),
                      base_objects.Interaction(
@@ -170,10 +174,16 @@
                                                                 wmin,
                                                                 wplus,
                                                                 wmin]),
+<<<<<<< TREE
                                      'color':['guess'],
                                      'lorentz':['WWWWN', ''],
                                      'couplings':{(0, 0):'MGVX6',
                                                   (0, 1):'DUM0'},
+=======
+                                     'color':[['C1']],
+                                     'lorentz':['L1'],
+                                     'couplings':{(0, 0):'MGVX6'},
+>>>>>>> MERGE-SOURCE
                                      'orders':{'QED':2}}),
 
                      base_objects.Interaction(
@@ -182,8 +192,13 @@
                                                                 eplus,
                                                                 enu,
                                                                 wmin]),
+<<<<<<< TREE
                                      'color':['guess'],
                                      'lorentz':[''],
+=======
+                                     'color':[['C1']],
+                                     'lorentz':['L1'],
+>>>>>>> MERGE-SOURCE
                                      'couplings':{(0, 0):'MGVX24'},
                                      'orders':{'QED':1}})])
 

=== added file 'tests/unit_tests/iolibs/test_save_model.py'
--- tests/unit_tests/iolibs/test_save_model.py	1970-01-01 00:00:00 +0000
+++ tests/unit_tests/iolibs/test_save_model.py	2010-01-21 09:19:15 +0000
@@ -0,0 +1,127 @@
+################################################################################
+#
+# Copyright (c) 2009 The MadGraph Development team and Contributors
+#
+# This file is a part of the MadGraph 5 project, an application which 
+# automatically generates Feynman diagrams and matrix elements for arbitrary
+# high-energy processes in the Standard Model and beyond.
+#
+# It is subject to the MadGraph license which should accompany this 
+# distribution.
+#
+# For more information, please visit: http://madgraph.phys.ucl.ac.be
+#
+################################################################################
+
+"""Unit test library for the save model routines"""
+
+import StringIO
+import unittest
+
+import madgraph.core.base_objects as base_objects
+
+import madgraph.iolibs.files as files
+import madgraph.iolibs.save_model as save_model
+
+class IOSaveModel(unittest.TestCase):
+    """Unit test class for the save model routines"""
+
+    def test_error_particle_save(self):
+        """Test error raising for particle save"""
+
+        fsock = StringIO.StringIO('')
+
+        my_part_list = "This is not a particle list"
+
+        self.assertRaises(ValueError,
+                         save_model.save_particles,
+                         fsock, my_part_list)
+
+    def test_particle_save(self):
+        """Test the particle save routine"""
+
+        mypartlist = \
+        base_objects.ParticleList(\
+                                [base_objects.Particle({'name':'ve',
+                                                      'antiname':'ve~',
+                                                      'spin':2,
+                                                      'color':1,
+                                                      'mass':'ZERO',
+                                                      'width':'ZERO',
+                                                      'texname':'ve',
+                                                      'antitexname':'ve',
+                                                      'line':'straight',
+                                                      'charge': 0.,
+                                                      'pdg_code':12,
+                                                      'propagating':True,
+                                                      'is_part':True,
+                                                      'self_antipart':False}),
+                                 base_objects.Particle({'name':'w+',
+                                                      'antiname':'w-',
+                                                      'spin':3,
+                                                      'color':1,
+                                                      'mass':'MW',
+                                                      'width':'WW',
+                                                      'texname':'W',
+                                                      'antitexname':'W',
+                                                      'line':'wavy',
+                                                      'charge':0.,
+                                                      'pdg_code':24,
+                                                      'propagating':True,
+                                                      'is_part':True,
+                                                      'self_antipart':False})])
+
+        fsock = StringIO.StringIO()
+        save_model.save_particles(fsock, mypartlist)
+
+        goal_str = "particles = [\n%s,%s]" % (str(mypartlist[0]),
+                                            str(mypartlist[1]))
+
+        self.assertEqual(fsock.getvalue(), goal_str)
+
+    def test_error_interaction_save(self):
+        """Test error raising for interaction save"""
+
+        fsock = StringIO.StringIO('')
+
+        my_inter_list = "This is not an interaction list"
+
+        self.assertRaises(ValueError,
+                         save_model.save_interactions,
+                         fsock, my_inter_list)
+
+    def test_interaction_save(self):
+        """Test the interaction save routine"""
+
+        mypart = base_objects.Particle({'name':'t',
+                      'antiname':'t~',
+                      'spin':2,
+                      'color':3,
+                      'mass':'mt',
+                      'width':'wt',
+                      'texname':'t',
+                      'antitexname':'\\overline{t}',
+                      'line':'straight',
+                      'charge':2. / 3.,
+                      'pdg_code':6,
+                      'propagating':True,
+                      'is_part':True})
+
+        myinterlist = base_objects.InteractionList([\
+                        base_objects.Interaction({'id': 1,
+                       'particles': base_objects.ParticleList([mypart] * 4),
+                       'color': ['C1', 'C2'],
+                       'lorentz':['L1', 'L2'],
+                       'couplings':{(0, 0):'g00',
+                                    (0, 1):'g01',
+                                    (1, 0):'g10',
+                                    (1, 1):'g11'},
+                       'orders':{'QCD':1, 'QED':1}})])
+
+        fsock = StringIO.StringIO()
+        save_model.save_interactions(fsock, myinterlist)
+
+        goal_str = "interactions = [\n%s]" % str(myinterlist[0])
+
+        self.assertEqual(fsock.getvalue(), goal_str)
+