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

[Olivier Mattelaer]

This version includes mostly modification in the cmd interface in order to authorize strict security restriction on what can (or cann't) be done via the web interface.

This is off course linked to a web interface:
http://madgraph.phys.ucl.ac.be/new_gen_proc_card_mg5.html
In order to be operational you should have javascript activated (which is quite common).
This authorize, for example, to forbid heft and quarkonium model if we run with MG5.

[Johan Alwall (johan-alwall)]

Hi Olivier!

This is really cool! Great job!

I made some tests, and have a few questions:
- What happened here:
http://<email address hidden>/PROC11/index.html
?
(I defined the process p p > t t~ QED=0, t > j j b, t~ > l- vl b~ in
the proc line, and chose MG4 syntax).
It looks like the generation just died once the SM was loaded, and
there's error message.
In the same process, you see that the card page doesn't look that
good. We need to think about how to treat QED/QCD orders in a better
way in the gen_cardhtml-pl script.
- We need a link describing the MG5 syntax, and if you could provide a
warning message when MG5 is chosen (by Javascript) saying that for
decay chains, the coupling orders only apply to the core process, that
would be great!
- I would like to be able to upload an MG4 proc_card to MG5, and right
now it's not clear how to do this. I think there should be two
different upload fields, one for MG5 proc_cards, one for MG4
proc_cards, and for the latter there should be a choice which
generator should be used.

All the best,
Johan

[Johan Alwall (johan-alwall)]

Hi again Olivier,

I tried choosing MG5 syntax, but also that went wrong, see
http://<email address hidden>/PROC16/index.html

All the best,
Johan

[Johan Alwall (johan-alwall)]

Sorry for spamming you Olivier, but I have one more question:

Yesterday, I updated the newprocess_mg5 script so that the output of
mg5 is piped to the proc_log.txt file. In the web version, it seems
that only the stdout and not the logging output appears in the file.
It would be very nice to have the full logging output in the file,
since this is a good way to check exactly what is happening during the
generation, and corresponds closer to the output of MG4.

Best,
Johan

[lp:~madteam/mg5amcnlo/MG5_on_web]

140. By Olivier Mattelaer on 2010-05-14

correct bug when choosing mg5 format and specifying orders/decay chains

[Olivier Mattelaer (olivier-mattelaer)]

Hi Johan, Thanks a lot for all your comment:

>I tried choosing MG5 syntax, but also that went wrong, see
>http://<email address hidden>/PROC16/index.html

ok this was a stupid mistake on my side... so this is solve.

>- I would like to be able to upload an MG4 proc_card to MG5, and right
>now it's not clear how to do this. I think there should be two
>different upload fields, one for MG5 proc_cards, one for MG4
>proc_cards, and for the latter there should be a choice which
>generator should be used.

In fact you have all those possibilities... But ok this is not that clear...
In fact my way to do is that you have one upload field where you can choose to upload either a MG4 or MG5 proc_card. If you upload a MG4 proc_card then when usually you confirm that the upload is correct. You will see a new box authorizing you to choose MG4 or MG5 to run this card.

>Yesterday, I updated the newprocess_mg5 script so that the output of
>mg5 is piped to the proc_log.txt file. In the web version, it seems
>that only the stdout and not the logging output appears in the file.
>It would be very nice to have the full logging output in the file,
>since this is a good way to check exactly what is happening during the
>generation, and corresponds closer to the output of MG4.

As for MG4 the newprocess for mg5 are disconected from the MG_ME one, and it's slightly different from the standard one. I will take a look at your modification, to see if they are compatible.

>>- We need a link describing the MG5 syntax, and if you could provide a
>>warning message when MG5 is chosen (by Javascript) saying that for
>>decay chains, the coupling orders only apply to the core process, that
>>would be great!

The warning is interesting once but it will be fastly boring...
So I suggest that we put it for the moment, and then at point or another simply remove this warning.

For the link, we should use epidoc in order to help us I think ;-)

>>- What happened here:
>>http://<email address hidden>/PROC11/index.html
>>?
>>(I defined the process p p > t t~ QED=0, t > j j b, t~ > l- vl b~ in
>>the proc line, and chose MG4 syntax).
>>It looks like the generation just died once the SM was loaded, and
>>there's error message.

This is quite strange... I'll take a look but I simply don't understand what happen...

[Johan Alwall (johan-alwall)]

Hi Olivier,

> In fact you have all those possibilities... But ok this is not that clear...
> In fact my way to do is that you have one upload field where you can choose to upload either a MG4 or MG5 proc_card. If you upload a MG4 proc_card then when usually you confirm that the upload is correct. You will see a new box authorizing you to choose MG4 or MG5 to run this card.

Ah, I was hoping this was the case, but it was not clear. Just add a
line saying "Choose MG version to use for this MG4 card:" or something
like that. I tried it, and the upload worked, but once again not the
generation:
http://<email address hidden>/PROC21/index.html

I should add that I have done a number of generations that work
perfectly (using only MG4 syntax in the process definition test
field), e.g.
http://<email address hidden>/PROC20/index.html
So most of the time your page is working fine!

> As for MG4 the newprocess for mg5 are disconected from the MG_ME one, and it's slightly different from the standard one. I will take a look at your modification, to see if they are compatible.

It's just a matter of adding "2>&1" after ">> proc_log.txt".

>>>- We need a link describing the MG5 syntax, and if you could provide a
>>>warning message when MG5 is chosen (by Javascript) saying that for
>>>decay chains, the coupling orders only apply to the core process, that
>>>would be great!
>
> The warning is interesting once but it will be fastly boring...
> So I suggest that we put it for the moment, and then at point or another simply remove this warning.

Ok it's not really necessary, I think it's enough that it is described
in the link.

> For the link, we should use epidoc in order to help us I think ;-)

I didn't mean a link to the complete MG5 manual, just a short note
about process generation syntax and some examples, max. 10 lines.

>>>- What happened here:
>>>http://<email address hidden>/PROC11/index.html
>>>?
>
> This is quite strange... I'll take a look but I simply don't understand what happen...

Ok thanks!

[Olivier Mattelaer (olivier-mattelaer)]

Hi Johan,

>>It's just a matter of adding "2>&1" after ">> proc_log.txt".
Done

>>>- What happened here:
>>>http://<email address hidden>/PROC11/index.html
>>>?
>
> This is quite strange... I'll take a look but I simply don't understand what happen...

Not sure what the problem was, but it's work on my computer (selecting mg5 and mg4 syntax)
http://<email address hidden>/PROC2/index.html
http://<email address hidden>/PROC6/index.html

But please retry on your side.

>>Ah, I was hoping this was the case, but it was not clear. Just add a
>>line saying "Choose MG version to use for this MG4 card:" or something
>>like that.

Sure (done)

[Johan Alwall (johan-alwall)]

Hi Olivier,

>>>It's just a matter of adding "2>&1" after ">> proc_log.txt".
> Done

Great, thanks!

> Not sure what the problem was, but it's work on my computer (selecting mg5 and mg4 syntax)
> http://<email address hidden>/PROC2/index.html
> http://<email address hidden>/PROC6/index.html

Ok now it works on my side too, great!

I get a problem when I'm uploading a proc_card though (probably it's
not the upload but the process, please take a look):
http://<email address hidden>/PROC24/index.html
I think the problem might be that you expect a comment after the
coupling definition.

One presentation detail: You are now extracting also the comma (",")
when you extract the coupling, which makes the process definition look
funny:

Process: p p > t t~ t > j j b, t~ > l- vl~ b~
 QED=0,

I noticed in the proc_card_mg5.dat that the model import comes twice,
once before the import proc_v4 line and once after. Is this on purpose
or a "bug"?

Thanks, all the best,
Johan

[lp:~madteam/mg5amcnlo/MG5_on_web]

141. By Olivier Mattelaer on 2010-05-17

Correct the bug (and test) find by johan

[Olivier Mattelaer (olivier-mattelaer)]

> I get a problem when I'm uploading a proc_card though (probably it's
> not the upload but the process, please take a look):
> http://<email address hidden>/PROC24/index.html
> I think the problem might be that you expect a comment after the
> coupling definition.
>

In fact that's the pure comment line which was not treated correctly by the regexp.
Solve (and add a test for this)

> One presentation detail: You are now extracting also the comma (",")
> when you extract the coupling, which makes the process definition look
> funny:
>
> Process: p p > t t~ t > j j b, t~ > l- vl~ b~
> QED=0,

Corrected

> I noticed in the proc_card_mg5.dat that the model import comes twice,
> once before the import proc_v4 line and once after. Is this on purpose
> or a "bug"?

I put it for debugging purpose, I think I can remove it now.

>
> Thanks, all the best,
> Johan

Thanks

Olivier

[Johan Alwall (johan-alwall)]

Hi again Olivier,

Great, all my previous points are now very nicely taken care of. Thanks!

I submitted a proc_card with a mistake - I hadn't defined the
multiparticle label "j". In this case, the error treatment doesn't
work very well for the web generation (see
http://<email address hidden>/PROC26/proc_log.txt).
It says
ERROR:root:Invalid characters: j j
ERROR:root:Invalid characters: j j
but doesn't stop the generation as in the regular (non-web)
generation. I think it's better to do as in the command-line case, to
stop generation with a warning message if some particles are not
available, since this indicates that the result will not be what the
user expected, and it would save time for the user to just exit the
generation gracefully with a reasonable error message.

After this detail I think we're good to go public! :-D
(Of course I haven't looked at the security aspect, I'm no expert
there. I will take a look at the code before I approve though.)

Thanks,
Johan

[lp:~madteam/mg5amcnlo/MG5_on_web]

142. By Olivier Mattelaer on 2010-05-18

more explicit error message
more smart check for options validity
raise an error if the particles are not recognized in v4 conversion

143. By Olivier Mattelaer on 2010-05-18

catch the error if a particle is not define in the MG4 conversion

[Olivier Mattelaer (olivier-mattelaer)]

Hi Johan,

In fact you have basically the same problem on shell mode.
indeed if you run
generate J J > J J
it will stop with a beautiful error message
but if you run
import command file
with the same process, then it's impossible to know if generate J J > J J stops normally or not.
So this problem is not related with the web interface at all. And the only correct way to solve this is to raise error that we can catch at the level of the cmd. In order to stop ALL executed command.
This could be done for version 0.5.0 if you want.

In fact the special case of this problem is slightly more easy, since the first error appears before the call to generate (in the conversion of the MG4 proc_card). In consequence it's possible to always raise an error and catch it inside the import. In order to stop it correctly. So this specific case is solved. But we should think about this for next version. I think

[Johan Alwall (johan-alwall)]

Hi Olivier,

I have now gone through the code, and it looks really nice, great
refactorng. Just a few comments:

HelpToCmd:
- "HelpToCmd" sounds funny, I think "HelpForCmd" is better English
- Can you add all options to the help printouts? help_makehtml
doesn't mention the --nojpg option

CheckValidForCmd:
- It would be good I think if we have lists for all commands that have
options, and always check against the list. That way there's
one less thing to remember if we add new options to a command.
Ex: check_add, where the 'process' option check is now hard-coded,
check_import, check_load etc. These should be defined in a separate
class CmdOptions I guess (which is of course also used in complete -
or just define them in the CompleteForCmd class).
- For check_add, if the option is not 'process', it should print the
help message, not "Empty or wrong format process...".

CmdFile:
- Is this just a temporary debug solution? Either remove or change doc
line.

MadGraphCmd: - do_history: Add version info as well in the header,
for completeness (and possible future debugging).

Thanks a lot!
Johan

[lp:~madteam/mg5amcnlo/MG5_on_web]

144. By Olivier Mattelaer on 2010-05-18

wrong help message

[Johan Alwall (johan-alwall)]

Hi Olivier,

Could you please address my comments from 2010-05-19 (either by answering them or by fixing them)?
Did anybody approve the branch before you merged it?

Thanks,
Johan

=== modified file '.pydevproject'
--- .pydevproject	2010-04-30 21:38:06 +0000
+++ .pydevproject	2010-05-19 07:36:39 +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>/history_and_v4_proc_card</path>
+<path>/MG5_on_web</path>
 </pydev_pathproperty>
 </pydev_project>

=== modified file 'bin/mg5'
--- bin/mg5	2010-05-06 19:22:46 +0000
+++ bin/mg5	2010-05-19 07:36:39 +0000
@@ -37,6 +37,8 @@
                   help="logging level (DEBUG|INFO|WARNING|ERROR|CRITICAL) [%default]")
 parser.add_option("-f", "--file", default='',
 					help="use script file FILE")
+parser.add_option("","--web", action="store_true", default=False, dest='web', \
+                 help='force to be in secure mode')
 
 (options, args) = parser.parse_args()
 if len(args) == 0:
@@ -54,12 +56,19 @@
         input_file = args[0]
     else:
         input_file = options.file
-        
     input_file = cmd_interface.CmdFile(input_file,'rU')
-    cmd_line = cmd_interface.MadGraphCmd(stdin=input_file)
-    cmd_line.use_rawinput = False #put it in non interactive mode
-    cmd_line.cmdloop()
+    if options.web:
+        cmd_line = cmd_interface.MadGraphCmdWeb(stdin=input_file)
+        cmd_line.use_rawinput = False #put it in non interactive mode
+        cmd_line.cmdloop()    
+    else:
+        cmd_line = cmd_interface.MadGraphCmdShell(stdin=input_file)
+        cmd_line.use_rawinput = False #put it in non interactive mode
+        cmd_line.cmdloop()
 else:
     # Interactive mode
-    cmd_interface.MadGraphCmd().cmdloop()
+    if options.web:
+        cmd_interface.MadGraphCmdWeb().cmdloop()
+    else:
+        cmd_interface.MadGraphCmdShell().cmdloop()
 

=== added file 'madgraph/interface/cmd_interface.py'
--- madgraph/interface/cmd_interface.py	1970-01-01 00:00:00 +0000
+++ madgraph/interface/cmd_interface.py	2010-05-19 07:36:39 +0000
@@ -0,0 +1,1866 @@
+################################################################################
+#
+# 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
+#
+################################################################################
+"""A user friendly command line interface to access MadGraph features.
+   Uses the cmd package for command interpretation and tab completion.
+"""
+
+import atexit
+import cmd
+import logging
+import optparse
+import os
+import re
+import readline
+import subprocess
+import sys
+import time
+
+import madgraph.iolibs.misc as misc
+import madgraph.iolibs.files as files
+
+import madgraph.iolibs.import_v4 as import_v4
+#import madgraph.iolibs.save_model as save_model
+import madgraph.iolibs.save_load_object as save_load_object
+import madgraph.iolibs.export_v4 as export_v4
+
+import madgraph.core.base_objects as base_objects
+import madgraph.core.diagram_generation as diagram_generation
+
+import madgraph.core.helas_objects as helas_objects
+import madgraph.iolibs.drawing as draw_lib
+import madgraph.iolibs.drawing_eps as draw
+
+#position of MG5
+root_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
+root_path = os.path.split(root_path)[0]
+
+#position of MG_ME
+MGME_dir = None
+MGME_dir_possibility = [os.path.join(root_path, os.path.pardir),
+                os.path.join(os.getcwd(), os.path.pardir),
+                os.getcwd()]
+
+for position in MGME_dir_possibility:
+    if os.path.exists(os.path.join(position, 'MGMEVersion.txt')) and \
+                    os.path.exists(os.path.join(position, 'UpdateNotes.txt')):
+        MGME_dir = os.path.realpath(position)
+        break
+del MGME_dir_possibility
+#===============================================================================
+# CmdExtended
+#===============================================================================
+class CmdExtended(cmd.Cmd):
+    """Extension of the cmd.Cmd command line.
+    This extensions supports linesbreak, history
+    support commentary
+    """
+
+    class MadGraphCmdError(Exception):
+        """Exception raised if an error occurs in the execution
+        of command."""
+        pass
+
+    def __init__(self, *arg, **opt):
+        """add possibility of line break/history """
+        
+        self.history = []
+        self.save_line = ''
+        cmd.Cmd.__init__(self, *arg, **opt)
+
+    def precmd(self, line):
+        """ force the printing of the line if this is executed with an stdin """
+        # Update the history of this suite of command
+        self.history.append(line)
+        
+        # Print the calling line in the non interactive mode    
+        if not self.use_rawinput:
+            print line
+        
+        #Check if they are a save line:
+        if self.save_line:
+            line = self.save_line + line 
+            self.save_line = ''
+        
+        #Check that the line is complete
+        if line.endswith('\\'):
+            self.save_line = line[:-1]
+            return '' # do nothing   
+        
+        #remove comment
+        if '#' in line:
+            line = line.split('#')[0]
+            
+        # execute the line command
+        return line
+
+    def exec_cmd(self, line):
+        """for third party call, call the line with pre and postfix treatment"""
+        
+        print line
+        line = self.precmd(line)
+        stop = self.onecmd(line)
+        stop = self.postcmd(stop, line)
+        return stop      
+
+    def emptyline(self):
+        """If empty line, do nothing. Default is repeat previous command."""
+        pass
+    
+    def default(self, line):
+        """Default action if line is not recognized"""
+
+        # Faulty command
+        print "Command \"%s\" not recognized, please try again" % \
+                                                                 line.split()[0]
+    # Quit
+    def do_quit(self, line):
+        sys.exit(1)
+
+    # Aliases
+    do_EOF = do_quit
+   
+
+#===============================================================================
+# Helper function
+#=============================================================================
+def split_arg(line):
+    """Split a line of arguments"""
+    return line.split()
+ 
+
+#===============================================================================
+# HelpToCmd
+#===============================================================================
+class HelpToCmd(object):
+    """ The Series of help routine for the MadGraphCmd"""    
+    
+    def help_save(self):
+        print "syntax: save %s FILENAME" % "|".join(self._save_opts)
+        print "-- save information as file FILENAME"
+
+
+    def help_load(self):
+        print "syntax: load %s FILENAME" % "|".join(self._save_opts)
+        print "-- load information from file FILENAME"
+
+    def help_import(self):
+        
+        print "syntax: import " + "|".join(self._import_formats) + \
+              " FILENAME"
+        print "-- imports file(s) in various formats"
+        print
+        print "   import model_v4 MODEL_info :"
+        print "      Import a MG4 Model in MG5 Model"""
+        print "      Model_info could be the name of the model"""
+        print "                 or the path to MG4_Model directory"""
+        print
+        print "   import proc_v4 [PATH] :"  
+        print "      Execute MG5 based on a proc_card.dat in MG4 format."""
+        print "      Path to the proc_card is optional if you have setup a"
+        print "      madevent directory"
+        print 
+        print "   import command PATH :"
+        print "      Execute the list of command in the file at PATH"
+        
+    def help_display(self):
+        print "syntax: display " + "|".join(self._display_opts)
+        print "-- display a the status of various internal state variables"
+
+    def help_setup(self):
+        print "syntax madevent_v4 name|.|auto [options]"
+        print "-- Create a copy of the V4 Template in the MG_ME directory."
+        print "   name will be the name of the copy the madevent Template that"
+        print "     will be use by default in following steps"
+        print "   If you put '.' instead of a name, the code will try to locate"
+        print "     a valid copy of the Template under focus"
+        print "   If you put 'auto' instead an automatic name will be created"  
+        print "   options:"
+        print "      -f: force the cleaning of the directory if this one exist"
+        print "      -d PATH: specify the directory where to create name"
+        print "      -noclean: no cleaning perform in name"
+        print "   Example:"
+        print "       setup madevent_v4 MYRUN"
+        print "       setup madevent_v4 MYRUN -d ../MG_ME -f"
+        
+    def help_generate(self):
+
+        print "syntax: generate INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2=ORDER2"
+        print "-- generate diagrams for a given process"
+        print "   Example: u d~ > w+ > m+ vm g $ a / z h QED=3 QCD=0 @1"
+        print "Decay chain syntax:"
+        print "   core process, decay1, (decay2, (decay3, ...)), ...  etc"
+        print "   Example: g g > t~ t @2, (t~ > W- b~, W- > e- ve~), t > W+ b"
+        print "   Note that identical particles will all be decayed"
+
+    def help_add(self):
+
+        print "syntax: add process INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2=ORDER2"
+        print "-- generate diagrams for a process and add to existing processes"
+        print "   Syntax example: u d~ > w+ > m+ vm g $ a / z h QED=3 QCD=0 @1"
+        print "Decay chain syntax:"
+        print "   core process, decay1, (decay2, (decay3, ...)), ...  etc"
+        print "   Example: g g > t~ t @2, (t~ > W- b~, W- > e- ve~), t > W+ b"
+        print "   Note that identical particles will all be decayed"
+
+    def help_define(self):
+        print "syntax: define multipart_name [ part_name_list ]"
+        print "-- define a multiparticle"
+        print "   Example: define p u u~ c c~ d d~ s s~"
+
+    def help_export(self):
+        print "syntax: export " + "|".join(self._export_formats) + \
+              " FILEPATH"
+        print """-- export matrix elements. For standalone_v4, the resulting
+        files will be FILEPATH/matrix_\"process_string\".f. For sa_dirs_v4,
+        the result is a set of complete MG4 Standalone process directories.
+        For madevent_v4, the path needs to be to a MadEvent SubProcesses
+        directory, and the result is the Pxxx directories (including the
+        diagram .ps and .jpg files) for the subprocesses as well as a
+        correctly generated subproc.mg file. Note that if you have run the 
+        'setup', FILEPATH is optional."""
+
+    def help_history(self):
+        print "syntax: history [FILEPATH] [-clean] "
+        print "-- write in the specified files all the call to MG5 that you have"""
+        print "   perform since that you have open this command line applet."""
+        print "   -clean option will remove all the entry of the history"""
+
+    def help_makehtml(self):
+        print "syntax: makehtlm madevent_v4 [PATH]"
+        print "-- create the web page related to the directory PATH"
+        print "   by default PATH is the directory defined with the setup command"
+        
+
+    def help_draw(self):
+        _draw_parser.print_help()
+
+    def help_shell(self):
+        print "syntax: shell CMD (or ! CMD)"
+        print "-- run the shell command CMD and catch output"
+
+    def help_quit(self):
+        print "syntax: quit"
+        print "-- terminates the application"
+    
+    help_EOF = help_quit
+    
+    def help_help(self):
+        print "syntax: help"
+        print "-- access to the in-line help" 
+
+#===============================================================================
+# CheckValidForCmd
+#===============================================================================
+class CheckValidForCmd(object):
+    """ The Series of help routine for the MadGraphCmd"""
+    
+    def check_add(self, args):
+        """check the validity of line
+        syntax: add process PROCESS 
+        """
+        
+        if len(args) < 1:
+            self.help_generate()
+            return False
+        
+        if len(self._curr_model['particles']) == 0:
+            print "No particle list currently active, please create one first!"
+            return False
+
+        if len(self._curr_model['interactions']) == 0:
+            print "No interaction list currently active," + \
+            " please create one first!"
+            return False
+
+        if len(args) < 2:
+            self.help_add()
+            return False
+        
+        if args[0] != 'process':
+            print "Empty or wrong format process, please try again."
+            return False
+        
+        return True
+    
+    def check_define(self, args):
+        """check the validity of line
+        syntax: define multipart_name [ part_name_list ]
+        """
+        
+        if len(args) < 1:
+            self.help_define()
+            return False
+
+        if len(self._curr_model['particles']) == 0:
+            print "No particle list currently active, please create one first!"
+            return False
+        
+        return True
+
+    def check_display(self, args):
+        """check the validity of line
+        syntax: display XXXXX
+        """
+            
+        if len(args) != 1:
+            self.help_display()
+            return False
+        else:
+            return True
+    
+    def check_draw(self, args):
+        """check the validity of line
+        syntax: draw FILEPATH [option=value]
+        """
+        if len(args) < 1:
+            self.help_draw()
+            return False
+        
+        if not self._curr_amps:
+            print "No process generated, please generate a process!"
+            return False
+
+        if not os.path.isdir(args[0]):
+            print "%s is not a valid directory for export file" % args[1]
+            return False
+        
+        return True
+    
+    def check_export(self, args):
+        """check the validity of line
+        syntax: export MODE FILEPATH
+        """  
+        if len(args) == 0 or (len(args) == 1 and not self._export_dir) or \
+                                           args[0] not in self._export_formats:
+            self.help_export()
+            return False
+
+        if not self._curr_amps:
+            print "No process generated, please generate a process!"
+            return False
+
+        if len(args) == 1:
+            path = os.path.join(self._export_dir, 'SubProcesses')
+        else:
+            path = args[1]
+
+        if not os.path.isdir(path):
+            print "%s is not a valid directory for export file" % path
+            if args[0] == 'madevent_v4':
+                print "to create a valid output directory you can use the command"
+                print "$> setup madevent_v4 auto"
+                print " and then run export as follow:"
+                print "$> export madevent_v4" 
+            return False
+        
+        if args[0] == 'madevent_v4' and  not os.path.isdir(
+                                        os.path.join(path,'..','SubProcesses')):
+            print "%s is not a valid directory for export file" % path
+            print "to create a valid output directory you can use the command"
+            print "$> setup madevent_v4 auto" 
+            print " and then run export as follow:"
+            print "$> export madevent_v4" 
+            return False
+
+        return path
+    
+    def check_generate(self, line):
+        """check the validity of line"""
+        
+        if len(line) < 1:
+            self.help_generate()
+            return False
+
+        if len(self._curr_model['particles']) == 0:
+            print "No particle list currently active, please create one first!"
+            return False
+
+        if len(self._curr_model['interactions']) == 0:
+            print "No interaction list currently active," + \
+            " please create one first!"
+            return False
+    
+        return True
+    
+    def check_history(self, args):
+        """check the validity of line"""
+        
+        if len(args) > 1:
+            self.help_history()
+            return False
+        
+        if len(args):
+            if args[0] not in ['clean', '.']:
+                dirpath = os.path.dirname(args[0])
+                if dirpath and not os.path.exists(dirpath):
+                    print "invalid path"
+                    return False
+            elif args[0] == '.' and not self._export_dir:
+                print 'no export dir configure'
+                return False
+        return True
+    
+    def check_import(self, args):
+        """check the validity of line"""
+        
+        if not args or  args[0] not in self._import_formats:
+            self.help_import()
+            return False
+        
+        if args[0] != 'proc_v4' and len(args) != 2:
+            self.help_import()
+            return False
+        
+        if args[0] == 'proc_v4' and len(args)!=2 and not self._export_dir:
+            self.help_import()
+            return False            
+        
+        return True
+    
+    def check_load(self, args):
+        """ check the validity of the line"""
+        
+        if len(args) != 2:
+            self.help_load()
+            return False
+        return True
+        
+    def check_makehtml(self, args):
+        """check the validity of the line"""
+    
+        if len(args) < 1:
+            self.help_makehtml()
+            return False
+        
+        if args[0] != 'madevent_v4':
+            self.help_makehtml()
+            return False
+        
+        if (len(args) == 1 and not self._export_dir) or \
+                        (len(args) > 1 and not os.path.isdir(args[1])):
+            self.help_makehtml()
+            return False
+        return True
+    
+    def check_save(self, args):
+        """ check the validity of the line"""
+        if len(args) != 2:
+            self.help_save()
+            return False
+        return True
+    
+    def check_setup(self, args):
+        """ check the validity of the line"""
+        
+        if len(args) < 2:
+            self.help_setup()
+            return False
+        
+        if not self._model_dir:
+            print 'No model found. Please import a model first and then retry'
+            print '  for example do : import model_v4 sm'
+            return False
+        return True
+
+#===============================================================================
+# CheckValidForCmdWeb
+#===============================================================================
+class CheckValidForCmdWeb(CheckValidForCmd):
+    """ Check the validity of input line for web entry
+    (no explicit path authorized)"""
+    
+    def check_draw(self, args):
+        """check the validity of line
+        syntax: draw FILEPATH [option=value]
+        """
+        # return False since they are always a path
+        return False
+      
+    def check_export(self, args):
+        """check the validity of line
+        syntax: export MODE FILEPATH
+        No FilePath authorized on the web
+        """  
+        if len(args) > 1:
+            return False
+        
+        return CheckValidForCmd.check_export(self, args)
+    
+    def check_history(self, args):
+        """check the validity of line
+        No Path authorize for the Web"""
+        
+        if len(args) == 2 and args[1] not in ['.','clean']:
+            return False
+        
+        return CheckValidForCmd.check_history(self, args)
+        
+    def check_import(self, args):
+        """check the validity of line
+        No Path authorize for the Web"""
+        
+        if len(args) >= 2 and args[0] == 'proc_v4' and args[1] != '.':
+            return False
+
+        if len(args) >= 1 and args[0] == 'command':
+            return False
+        
+        for arg in args:
+            if '/' in arg:
+                print 'Path are not authorized on the web'
+                return False
+             
+        return CheckValidForCmd.check_import(self, args)
+        
+    def check_makehtml(self, args):
+        """check the validity of the line
+        No Path authorize for the Web"""
+    
+        if len(args) > 1:
+            return False
+        
+        return CheckValidForCmd.check_makehtml(self, args)
+        
+    def check_load(self, args):
+        """ check the validity of the line
+        No Path authorize for the Web"""
+        
+        if len(args)==2:
+            if args[0] != 'model':
+                print 'only model can be load online'
+                return False
+            if 'model.pkl' not in args[1]:
+                print 'not valid format'
+                return False
+            if not os.path.realpath(args[1]).startswith(os.path.join(MGME_dir, \
+                                                                    'Models')):
+                return False
+            
+        
+    def check_save(self, args):
+        """ not authorize on web"""
+        return False
+    
+    
+    def check_setup(self, args):
+        """ check the validity of the line"""
+        
+        if not CheckValidForCmd.check_setup(self, args):
+            return False
+        
+        if '/' in args[2]:
+            return False
+        
+        return True
+    
+#===============================================================================
+# CompleteForCmd
+#===============================================================================
+class CompleteForCmd(CheckValidForCmd):
+    """ The Series of help routine for the MadGraphCmd"""
+    
+    def list_completion(self, text, list):
+        """Propose completions of text in list"""
+        if not text:
+            completions = list
+        else:
+            completions = [ f
+                            for f in list
+                            if f.startswith(text)
+                            ]
+        return completions
+
+    def path_completion(self, text, base_dir=None):
+        """Propose completions of text to compose a valid path"""
+
+        if base_dir is None:
+            base_dir = os.getcwd()
+
+        completion = [f
+                       for f in os.listdir(base_dir)
+                       if f.startswith(text) and \
+                            os.path.isfile(os.path.join(base_dir, f))
+                       ]
+
+        completion = completion + \
+                     [f + '/'
+                       for f in os.listdir(base_dir)
+                       if f.startswith(text) and \
+                            os.path.isdir(os.path.join(base_dir, f))
+                     ]
+
+        return completion      
+    
+            
+    def complete_makehtml(self, text, line, begidx, endidx):
+        """ format: makehtlm madevent_v4 [PATH] [--nojpeg]"""
+        
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, ['madevent_v4'])
+        
+        if text.startswith('-'):
+            return self.list_completion(text, ['--nojpeg'])
+
+        # Filename if directory is not given
+        if len(split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[2])
+
+    def complete_export(self, text, line, begidx, endidx):
+        "Complete the export command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._export_formats)
+
+        # Filename if directory is not given
+        if len(split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[2])
+    
+    def complete_history(self, text, line, begidx, endidx):
+        "Complete the add command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.path_completion(text)
+        
+    def complete_add(self, text, line, begidx, endidx):
+        "Complete the add command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._add_opts)
+        
+    def complete_display(self, text, line, begidx, endidx):
+        "Complete the display command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._display_opts)
+
+    def complete_draw(self, text, line, begidx, endidx):
+        "Complete the import command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.path_completion(text)
+
+
+        #option
+        if len(split_arg(line[0:begidx])) >= 2:
+            opt = ['horizontal', 'external=', 'max_size=', 'add_gap=',
+                                'non_propagating','--']
+            return self.list_completion(text, opt)
+
+    def complete_load(self, text, line, begidx, endidx):
+        "Complete the load command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._save_opts)
+
+        # Filename if directory is not given
+        if len(split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[2])
+
+    def complete_save(self, text, line, begidx, endidx):
+        "Complete the save command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._save_opts)
+
+        # Filename if directory is not given
+        if len(split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[2])
+
+    def complete_setup(self, text, line, begidx, endidx):
+        "Complete the setup command"
+
+        possible_option = ['-d ', '-f', '-noclean']
+        possible_option2 = ['d ', 'f', 'noclean']
+        possible_format = ['madevent_v4']
+        #don't propose directory use by MG_ME
+        forbidden_name = ['MadGraphII', 'Template', 'pythia-pgs', 'CVS',
+                            'Calculators', 'MadAnalysis', 'SimpleAnalysis', 
+                            'mg5', 'DECAY', 'EventConverter', 'Models', 
+                            'ExRootAnalysis', 'HELAS', 'Transfer_Fct']
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, possible_format)
+        
+        #name of the run =>proposes old run name
+        if len(split_arg(line[0:begidx])) == 2: 
+            content = [name for name in os.listdir(MGME_dir) if \
+                                    name not in forbidden_name and \
+                                    os.path.isdir(os.path.join(MGME_dir, name))]
+            content += ['.', 'auto']
+            return self.list_completion(text, content)
+
+        # Returning options
+        if len(split_arg(line[0:begidx])) > 2:
+            if split_arg(line[0:begidx])[-1] == '-d':
+                return self.path_completion(text)
+            elif  split_arg(line[0:begidx])[-2] == '-d' and line[-1] != ' ':
+                return self.path_completion(text, \
+                                             split_arg(line[0:begidx])[-1])
+            elif split_arg(line[0:begidx])[-1] == '-':
+                return self.list_completion(text, possible_option2)
+            else:
+                return self.list_completion(text, possible_option)
+
+    def complete_shell(self, text, line, begidx, endidx):
+        """ add path for shell """
+
+        # Filename if directory is given
+        #
+        if len(split_arg(line[0:begidx])) > 1 and line[begidx-1] == os.path.sep:
+            if not text:
+                text = ''
+            output = self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[-1])
+        else:
+            output = self.path_completion(text)
+        return output
+
+    def complete_import(self, text, line, begidx, endidx):
+        "Complete the import command"
+
+        # Format
+        if len(split_arg(line[0:begidx])) == 1:
+            return self.list_completion(text, self._import_formats)
+
+        # Filename if directory is not given
+        if len(split_arg(line[0:begidx])) == 2:
+            return self.path_completion(text)
+
+        # Filename if directory is given
+        if len(split_arg(line[0:begidx])) == 3:
+            return self.path_completion(text,
+                                        base_dir=\
+                                          split_arg(line[0:begidx])[2])
+
+  
+
+
+    
+#===============================================================================
+# MadGraphCmd
+#===============================================================================
+class MadGraphCmd(CmdExtended, HelpToCmd):
+    """The command line processor of MadGraph"""    
+    
+    _curr_model = base_objects.Model()
+    _model_dir = None
+    _curr_amps = diagram_generation.AmplitudeList()
+    _curr_matrix_elements = helas_objects.HelasMultiProcess()
+    _curr_fortran_model = export_v4.HelasFortranModel()
+    _multiparticles = {}
+
+    _display_opts = ['particles', 'interactions', 'processes', 'multiparticles']
+    _add_opts = ['process']
+    _save_opts = ['model', 'processes']
+    _import_formats = ['model_v4', 'proc_v4', 'command']
+    _export_formats = ['standalone_v4', 'sa_dirs_v4', 'madevent_v4']
+        
+    def __init__(self, *arg, **opt):
+        """ add a tracker of the history """
+
+        CmdExtended.__init__(self, *arg, **opt)
+        self._generate_info = "" # store the first generated process
+        
+        # Detect If this script is launched from a valid copy of the Template
+        #and if so store this position as standard output directory
+        if 'Cards' in os.listdir('.'):
+            #Check for ./
+            self._export_dir = os.path.realpath('.')
+        elif 'Cards' in os.listdir('..'):
+            #Check for ../
+            self._export_dir = os.path.realpath('..')
+        elif self.stdin != sys.stdin:
+            #Check for position defined by the input files
+            input_path = os.path.realpath(self.stdin.name).split(os.path.sep)
+            if input_path[-2] == 'Cards':
+                self._export_dir = os.path.sep.join(input_path[:-2])
+            else:
+                self._export_dir = None
+        else:
+            self._export_dir = None
+            
+    # Add a process to the existing multiprocess definition
+    # Generate a new amplitude
+    def do_add(self, line):
+        """Generate an amplitude for a given process and add to
+        existing amplitudes
+        syntax:
+        """
+
+        args = split_arg(line)
+        if not self.check_add(args):
+            return
+
+        if args[0] == 'process':
+            # Rejoin line
+            line = ' '.join(args[1:])
+            
+            # store the first process (for the perl script)
+            if not self._generate_info:
+                self._generate_info = line
+                
+            # Reset Helas matrix elements
+            self._curr_matrix_elements = helas_objects.HelasMultiProcess()
+
+            try:
+                if line.find(',') == -1:
+                    myprocdef = self.extract_process(line)
+                else:
+                    myprocdef, line = self.extract_decay_chain_process(line)
+            except self.MadGraphCmdError, error:
+                print "Empty or wrong format process, please try again. Error:" 
+                print error
+                myprocdef = None
+
+            if myprocdef:
+
+                cpu_time1 = time.time()
+
+                myproc = diagram_generation.MultiProcess(myprocdef)
+
+                for amp in myproc.get('amplitudes'):
+                    if amp not in self._curr_amps:
+                        self._curr_amps.append(amp)
+                    else:
+                        print "Warning: Already in processes:"
+                        print amp.nice_string_processes()
+
+                cpu_time2 = time.time()
+
+                nprocs = len(myproc.get('amplitudes'))
+                ndiags = sum([amp.get_number_of_diagrams() for \
+                                  amp in myproc.get('amplitudes')])
+                print "%i processes with %i diagrams generated in %0.3f s" % \
+                      (nprocs, ndiags, (cpu_time2 - cpu_time1))
+                ndiags = sum([amp.get_number_of_diagrams() for \
+                                  amp in self._curr_amps])
+                print "Total: %i processes with %i diagrams" % \
+                      (len(self._curr_amps), ndiags)                
+  
+    # Define a multiparticle label
+    def do_define(self, line):
+        """Define a multiparticle"""
+
+        # Particle names always lowercase
+        line = line.lower()
+        args = split_arg(line)
+        if not self.check_define(args):
+            return
+
+
+        label = args[0]
+        pdg_list = []
+
+        for part_name in args[1:]:
+
+            mypart = self._curr_model['particles'].find_name(part_name)
+
+            if mypart:
+                pdg_list.append(mypart.get_pdg_code())
+            else:
+                print "No particle %s in model: skipped" % part_name
+
+        if not pdg_list:
+            print """Empty or wrong format for multiparticle.
+            Please try again."""
+
+        self._multiparticles[label] = pdg_list
+    
+    # Display
+    def do_display(self, line):
+        """Display current internal status"""
+
+        args = split_arg(line)
+        if not self.check_display(args):
+            return
+
+        if args[0] == 'particles':
+            print "Current model contains %i particles:" % \
+                    len(self._curr_model['particles'])
+            part_antipart = [part for part in self._curr_model['particles'] \
+                             if not part['self_antipart']]
+            part_self = [part for part in self._curr_model['particles'] \
+                             if part['self_antipart']]
+            for part in part_antipart:
+                print part['name'] + '/' + part['antiname'],
+            print ''
+            for part in part_self:
+                print part['name'],
+            print ''
+
+        if args[0] == 'interactions':
+            print "Current model contains %i interactions" % \
+                    len(self._curr_model['interactions'])
+            for inter in self._curr_model['interactions']:
+                print str(inter['id']) + ':',
+                for part in inter['particles']:
+                    if part['is_part']:
+                        print part['name'],
+                    else:
+                        print part['antiname'],
+                print
+
+        if args[0] == 'processes':
+            for amp in self._curr_amps:
+                print amp.nice_string()
+        if args[0] == 'multiparticles':
+            print 'Multiparticle labels:'
+            for key in self._multiparticles:
+                print key, " = ", self._multiparticles[key]
+    
+    def do_draw(self, line):
+        """ draw the Feynman diagram for the given process """
+
+        args = split_arg(line)
+        if not self.check_draw(args):
+            return
+        
+
+        (options, args) = _draw_parser.parse_args(args)
+        options = draw_lib.DrawOption(options)
+        start = time.time()
+        
+
+        # Collect amplitudes
+        amplitudes = diagram_generation.AmplitudeList()
+
+        for amp in self._curr_amps:
+            amplitudes.extend(amp.get_amplitudes())            
+
+        for amp in amplitudes:
+            filename = os.path.join(args[0], 'diagrams_' + \
+                                    amp.get('process').shell_string() + ".eps")
+            plot = draw.MultiEpsDiagramDrawer(amp['diagrams'],
+                                              filename,
+                                              model=self._curr_model,
+                                              amplitude='')
+
+            logging.info("Drawing " + \
+                         amp.get('process').nice_string())
+            #plot.draw(opt=options)
+            plot.draw()
+            print "Wrote file " + filename
+
+        stop = time.time()
+        print 'time to draw', stop - start    
+    
+    # Export a matrix element
+    def do_export(self, line):
+        """Export a generated amplitude to file"""
+
+        def generate_matrix_elements(self):
+            """Helper function to generate the matrix elements before
+            exporting"""
+
+            cpu_time1 = time.time()
+            if not self._curr_matrix_elements.get('matrix_elements'):
+                self._curr_matrix_elements = \
+                             helas_objects.HelasMultiProcess(\
+                                           self._curr_amps)
+            cpu_time2 = time.time()
+
+            ndiags = sum([len(me.get('diagrams')) for \
+                          me in self._curr_matrix_elements.\
+                          get('matrix_elements')])
+
+            return ndiags, cpu_time2 - cpu_time1
+
+        # Start of the actual routine
+
+        args = split_arg(line)
+        path = self.check_export(args) #if valid return the path of the output
+        if not path:
+            return 
+
+        ndiags, cpu_time = generate_matrix_elements(self)
+        calls = 0
+
+        if args[0] == 'standalone_v4':
+            for me in self._curr_matrix_elements.get('matrix_elements'):
+                filename = os.path.join(path, 'matrix_' + \
+                           me.get('processes')[0].shell_string() + ".f")
+                if os.path.isfile(filename):
+                    print "Overwriting existing file %s" % filename
+                else:
+                    print "Creating new file %s" % filename
+                calls = calls + files.write_to_file(filename,
+                                   export_v4.write_matrix_element_v4_standalone,
+                                   me, self._curr_fortran_model)
+
+
+        if args[0] == 'sa_dirs_v4':
+            for me in self._curr_matrix_elements.get('matrix_elements'):
+                calls = calls + \
+                        export_v4.generate_subprocess_directory_v4_standalone(\
+                            me, self._curr_fortran_model, path)
+
+        if args[0] == 'madevent_v4':
+            for me in self._curr_matrix_elements.get('matrix_elements'):
+                calls = calls + \
+                        export_v4.generate_subprocess_directory_v4_madevent(\
+                            me, self._curr_fortran_model, path)
+            
+            card_path = os.path.join(path, os.path.pardir, 'SubProcesses', \
+                                                              'procdef_mg5.dat')
+            if self._generate_info:
+                export_v4.write_procdef_mg5(card_path,
+                                os.path.split(self._model_dir)[-1],
+                                self._generate_info)
+                
+        print ("Generated helas calls for %d subprocesses " + \
+              "(%d diagrams) in %0.3f s") % \
+              (len(self._curr_matrix_elements.get('matrix_elements')),
+               ndiags, cpu_time)
+
+        print "Wrote %d helas calls" % calls
+
+        # Replace the amplitudes with the actual amplitudes from the
+        # matrix elements, which allows proper diagram drawing also of
+        # decay chain processes
+        self._curr_amps = diagram_generation.AmplitudeList(\
+               [me.get('base_amplitude') for me in \
+                self._curr_matrix_elements.get('matrix_elements')])
+    
+    
+    # Generate a new amplitude
+    def do_generate(self, line):
+        """Generate an amplitude for a given process"""
+
+        if not self.check_generate(line):
+            return
+
+        # Reset Helas matrix elements
+        self._curr_matrix_elements = helas_objects.HelasMultiProcess()
+        self._generate_info = line
+
+        try:
+            if ',' not in line:
+                myprocdef = self.extract_process(line)
+            else:
+                myprocdef, line = self.extract_decay_chain_process(line)
+        except self.MadGraphCmdError as error:
+            print "Empty or wrong format process, please try again. Error:\n" \
+                  + str(error)
+            myprocdef = None
+            
+        if myprocdef:
+            
+            cpu_time1 = time.time()
+            myproc = diagram_generation.MultiProcess(myprocdef)
+            self._curr_amps = myproc.get('amplitudes')
+            cpu_time2 = time.time()
+
+            nprocs = len(self._curr_amps)
+            ndiags = sum([amp.get_number_of_diagrams() for \
+                              amp in self._curr_amps])
+            print "%i processes with %i diagrams generated in %0.3f s" % \
+                  (nprocs, ndiags, (cpu_time2 - cpu_time1))
+
+        else:
+            print "Empty or wrong format process, please try again."    
+    
+    
+    def extract_process(self, line, proc_number = 0):
+        """Extract a process definition from a string. Returns
+        a ProcessDefinition."""
+
+        # Perform sanity modifications on the lines:
+        # Add a space before any > , $ /
+        space_before=re.compile(r"(?P<carac>\S)(?P<tag>[/\,\\$\\>])")
+        line = space_before.sub(r'\g<carac> \g<tag>',line)       
+        # Add a space after any + - ~ > , $ / 
+        space_after=re.compile(r"(?P<tag>[+-/\,\\$\\>~])(?P<carac>[^\s+-])")
+        line = space_after.sub(r'\g<tag> \g<carac>',line)
+        
+        
+        # Use regular expressions to extract s-channel propagators,
+        # forbidden s-channel propagators/particles, coupling orders
+        # and process number, starting from the back
+
+        # Start with process number (identified by "@")
+        proc_number_pattern = re.compile("^(.+)@\s*(\d+)\s*(.*)$")
+        proc_number_re = proc_number_pattern.match(line)
+        if proc_number_re:
+            proc_number = int(proc_number_re.group(2))
+            line = proc_number_re.group(1) + \
+                   proc_number_re.group(3)
+
+        # Start with coupling orders (identified by "=")
+        order_pattern = re.compile("^(.+)\s+(\w+)\s*=\s*(\d+)\s*$")
+        order_re = order_pattern.match(line)
+        orders = {}
+        while order_re:
+            orders[order_re.group(2)] = int(order_re.group(3))
+            line = order_re.group(1)
+            order_re = order_pattern.match(line)
+
+        # Particle names always lowercase
+        line = line.lower()
+
+        # Now check for forbidden particles, specified using "/"
+        slash = line.find("/")
+        dollar = line.find("$")
+        forbidden_particles = ""
+        if slash > 0:
+            if dollar > slash:
+                forbidden_particles_re = re.match("^(.+)\s*/\s*(.+\s*)(\$.*)$", line)
+            else:
+                forbidden_particles_re = re.match("^(.+)\s*/\s*(.+\s*)$", line)
+            if forbidden_particles_re:
+                forbidden_particles = forbidden_particles_re.group(2)
+                line = forbidden_particles_re.group(1)
+                if len(forbidden_particles_re.groups()) > 2:
+                    line = line + forbidden_particles_re.group(3)
+
+        # Now check for forbidden schannels, specified using "$"
+        forbidden_schannels_re = re.match("^(.+)\s*\$\s*(.+)\s*$", line)
+        forbidden_schannels = ""
+        if forbidden_schannels_re:
+            forbidden_schannels = forbidden_schannels_re.group(2)
+            line = forbidden_schannels_re.group(1)
+
+        # Now check for required schannels, specified using "> >"
+        required_schannels_re = re.match("^(.+?)>(.+?)>(.+)$", line)
+        required_schannels = ""
+        if required_schannels_re:
+            required_schannels = required_schannels_re.group(2)
+            line = required_schannels_re.group(1) + ">" + \
+                   required_schannels_re.group(3)
+
+        args = split_arg(line)
+
+        myleglist = base_objects.MultiLegList()
+        state = False
+
+        # Extract process
+        for part_name in args:
+
+            if part_name == '>':
+                if not myleglist:
+                    raise self.MadGraphCmdError, \
+                          "No final state particles"
+                state = True
+                continue
+
+            mylegids = []
+            if part_name in self._multiparticles:
+                mylegids.extend(self._multiparticles[part_name])
+            else:
+                mypart = self._curr_model['particles'].find_name(part_name)
+                if mypart:
+                    mylegids.append(mypart.get_pdg_code())
+
+            if mylegids:
+                myleglist.append(base_objects.MultiLeg({'ids':mylegids,
+                                                        'state':state}))
+            else:
+                raise self.MadGraphCmdError, \
+                      "No particle %s in model" % part_name
+
+        if filter(lambda leg: leg.get('state') == True, myleglist):
+            # We have a valid process
+
+            # Now extract restrictions
+            forbidden_particle_ids = []
+            forbidden_schannel_ids = []
+            required_schannel_ids = []
+
+            #decay_process = len(filter(lambda leg: \
+            #                           leg.get('state') == False,
+            #                           myleglist)) == 1
+
+            if forbidden_particles:
+                args = split_arg(forbidden_particles)
+                for part_name in args:
+                    if part_name in self._multiparticles:
+                        forbidden_particle_ids.extend( \
+                                               self._multiparticles[part_name])
+                    else:
+                        mypart = self._curr_model['particles'].find_name( \
+                                                                      part_name)
+                        if mypart:
+                            forbidden_particle_ids.append(mypart.get_pdg_code())
+
+            if forbidden_schannels:
+                args = split_arg(forbidden_schannels)
+                for part_name in args:
+                    if part_name in self._multiparticles:
+                        forbidden_schannel_ids.extend(\
+                                               self._multiparticles[part_name])
+                    else:
+                        mypart = self._curr_model['particles'].find_name(\
+                                                                      part_name)
+                        if mypart:
+                            forbidden_schannel_ids.append(mypart.get_pdg_code())
+
+            if required_schannels:
+                args = split_arg(required_schannels)
+                for part_name in args:
+                    if part_name in self._multiparticles:
+                        required_schannel_ids.extend(\
+                                               self._multiparticles[part_name])
+                    else:
+                        mypart = self._curr_model['particles'].find_name(\
+                                                                      part_name)
+                        if mypart:
+                            required_schannel_ids.append(mypart.get_pdg_code())
+
+            return \
+                base_objects.ProcessDefinition({'legs': myleglist,
+                                'model': self._curr_model,
+                                'id': proc_number,
+                                'orders': orders,
+                                'forbidden_particles': forbidden_particle_ids,
+                                'forbidden_s_channels': forbidden_schannel_ids,
+                                'required_s_channels': required_schannel_ids
+                                 })
+        #                       'is_decay_chain': decay_process\
+        else:
+            return None
+
+    def extract_decay_chain_process(self, line, level_down=False):
+        """Recursively extract a decay chain process definition from a
+        string. Returns a ProcessDefinition."""
+
+        # Start with process number (identified by "@")
+        proc_number_pattern = re.compile("^(.+)@\s*(\d+)\s*(.*)$")
+        proc_number_re = proc_number_pattern.match(line)
+        proc_number = 0
+        if proc_number_re:
+            proc_number = int(proc_number_re.group(2))
+            line = proc_number_re.group(1) + \
+                   proc_number_re.group(3)
+            print line
+            
+        index_comma = line.find(",")
+        index_par = line.find(")")
+        min_index = index_comma
+        if index_par > -1 and (index_par < min_index or min_index == -1):
+            min_index = index_par
+        
+        if min_index > -1:
+            core_process = self.extract_process(line[:min_index], proc_number)
+        else:
+            core_process = self.extract_process(line, proc_number)
+
+        #level_down = False
+
+        while index_comma > -1:
+            line = line[index_comma + 1:]
+            index_par = line.find(')')
+            if line.lstrip()[0] == '(':
+                # Go down one level in process hierarchy
+                #level_down = True
+                line = line.lstrip()[1:]
+                # This is where recursion happens
+                decay_process, line = \
+                            self.extract_decay_chain_process(line,
+                                                             level_down=True)
+                index_comma = line.find(",")
+                index_par = line.find(')')
+            else:
+                index_comma = line.find(",")
+                min_index = index_comma
+                if index_par > -1 and \
+                       (index_par < min_index or min_index == -1):
+                    min_index = index_par
+                if min_index > -1:
+                    decay_process = self.extract_process(line[:min_index])
+                else:
+                    decay_process = self.extract_process(line)
+
+            core_process.get('decay_chains').append(decay_process)
+
+            if level_down:
+                if index_par == -1:
+                    raise self.MadGraphCmdError, \
+                      "Missing ending parenthesis for decay process"
+
+                if index_par < index_comma:
+                    line = line[index_par + 1:]
+                    level_down = False
+                    break
+
+        if level_down:
+            index_par = line.find(')')
+            if index_par == -1:
+                raise self.MadGraphCmdError, \
+                      "Missing ending parenthesis for decay process"
+            line = line[index_par + 1:]
+            
+        # Return the core process (ends recursion when there are no
+        # more decays)
+        return core_process, line
+    
+    # Write the list of command line use in this session
+    def do_history(self, line):
+        """write in a file the suite of command that was used"""
+        
+        args = split_arg(line)
+        if not self.check_history(args):
+            return
+
+        if len(args) == 0:
+            print '\n'.join(self.history)
+            return False
+        elif args[0] == 'clean':
+            self.history = []
+            print 'history is cleaned'
+            return False
+        elif args[0] == '.':
+            output_file = os.path.join(self._export_dir, 'Cards', \
+                                                            'proc_card_mg5.dat')
+            output_file = open(output_file, 'w')
+        else:
+            output_file = open(args[0], 'w')
+            
+        
+        # Define a simple header for the file
+        creation_time = time.asctime() 
+        time_info = \
+        '#     automaticaly generated the %s%s*\n' % (creation_time, ' ' * \
+                                                      (26 - len(creation_time)))
+        text = \
+        '#***********************************************************\n' + \
+        '#                         MadGraph 5                       *\n' + \
+        '#                                                          *\n' + \
+        "#                 *                       *                *\n" + \
+        "#                   *        * *        *                  *\n" + \
+        "#                     * * * * 5 * * * *                    *\n" + \
+        "#                   *        * *        *                  *\n" + \
+        "#                 *                       *                *\n" + \
+        "#                                                          *\n" + \
+        "#                                                          *\n" + \
+        "#    The MadGraph Development Team - Please visit us at    *\n" + \
+        "#    https://server06.fynu.ucl.ac.be/projects/madgraph     *\n" + \
+        '#                                                          *\n' + \
+        '#***********************************************************\n' + \
+        '#                                                          *\n' + \
+        '#               Command File for MadGraph 5                *\n' + \
+        '#                                                          *\n' + \
+        '#     run as ./bin/mg5  filename                           *\n' + \
+        time_info + \
+        '#                                                          *\n' + \
+        '#***********************************************************\n'
+        
+        #Avoid repetition of header
+        if self.history[0] == '#'+'*' * 59:
+            text=''
+        # Add the comand used 
+        text += '\n'.join(self.history) + '\n' 
+        
+        #write this information in a file
+        output_file.write(text)
+        output_file.close()
+    
+    # Import files
+    def do_import(self, line):
+        """Import files with external formats"""
+
+        def import_v4file(self, filepath):
+            """Helper function to load a v4 file from file path filepath"""
+            filename = os.path.basename(filepath)
+            if filename.endswith('particles.dat'):
+                self._curr_model.set('particles',
+                                     files.read_from_file(
+                                            filepath,
+                                            import_v4.read_particles_v4))
+                print "%d particles imported" % \
+                      len(self._curr_model['particles'])
+                return True
+            elif filename.endswith('interactions.dat'):
+                if len(self._curr_model['particles']) == 0:
+                    print "No particle list currently active,",
+                    print "please create one first!"
+                    return False
+                self._curr_model.set('interactions',
+                                     files.read_from_file(
+                                            filepath,
+                                            import_v4.read_interactions_v4,
+                                            self._curr_model['particles']))
+                print "%d interactions imported" % \
+                      len(self._curr_model['interactions'])
+                return True
+           
+            #not valid File
+            return False
+
+        args = split_arg(line)
+        if not self.check_import(args):
+            return
+        
+        if args[0] == 'model_v4':
+            # Check for a file
+            if os.path.isfile(args[1]):
+                suceed = import_v4file(self, args[1])
+                if not suceed:
+                    print "%s is not a valid v4 file name" % \
+                                        os.path.basename(args[1])
+                else:
+                    self._model_dir = os.path.dirname(args[1])
+                return
+            
+            # Check for a valid directory
+            if os.path.isdir(args[1]):
+                self._model_dir = args[1]
+            elif MGME_dir and os.path.isdir(os.path.join(MGME_dir, 'Models', \
+                                                                      args[1])):
+                self._model_dir = os.path.join(MGME_dir, 'Models', args[1])
+            elif not MGME_dir:
+                print "Path %s is not a valid pathname" % args[1]
+                print "and no MG_ME installation detected in other to search in Models"
+                return False                
+            else:
+                print "Path %s is not a valid pathname" % args[1]
+                return False
+            
+            #Load the directory
+            if os.path.exists(os.path.join(self._model_dir, 'model.pkl')):
+                self.do_load('model %s' % os.path.join(self._model_dir, \
+                                                                   'model.pkl'))
+                return
+            files_to_import = ('particles.dat', 'interactions.dat')
+            for filename in files_to_import:
+                if os.path.isfile(os.path.join(self._model_dir, filename)):
+                    import_v4file(self, os.path.join(self._model_dir, \
+                                                                      filename))
+                else:
+                    print "%s files doesn't exist in %s directory" % \
+                                        (filename, os.path.basename(args[1]))
+            #save model for next usage
+            self.do_save('model %s ' % os.path.join(self._model_dir, \
+                                                                   'model.pkl'))
+        
+        elif args[0] == 'proc_v4':
+            
+            if len(args) == 1 and self._export_dir:
+                proc_card = os.path.join(self._export_dir, 'Cards', \
+                                                                'proc_card.dat')
+            elif len(args) == 2:
+                proc_card = args[1]
+                # Check the status of export and try to use file position is no
+                #self._export dir are define
+                if os.path.isdir(args[1]):
+                    proc_card = os.path.join(proc_card, 'Cards', \
+                                                                'proc_card.dat')    
+                self.check_for_export_dir(os.path.realpath(proc_card))
+            else:
+                logging.error('No default directory are setup')
+                return
+ 
+            #convert and excecute the card
+            self.import_mg4_proc_card(proc_card)   
+                                     
+        elif args[0] == 'command':
+            if not os.path.isfile(args[1]):
+                print "Path %s is not a valid pathname" % args[1]
+            else:
+                # Check the status of export and try to use file position is no
+                #self._export dir are define
+                self.check_for_export_dir(args[1])
+                # Execute the card
+                self.import_mg5_proc_card(args[1])
+        else:
+            self.help_import()
+            return False
+    
+    
+    def import_mg4_proc_card(self, filepath):
+        """ read a V4 proc card, convert it and run it in mg5"""
+        
+        # change the status of this line in the history -> pass in comment
+        self.history[-1] = '#%s' % self.history[-1]
+         
+        # read the proc_card.dat
+        reader = files.read_from_file(filepath, import_v4.read_proc_card_v4)
+        
+        if MGME_dir:
+            #model_dir = os.path.join(MGME_dir, 'Models')
+            line = self.exec_cmd('import model_v4 %s' % (reader.model))
+        else:
+            logging.error('No MG_ME installation detected')
+            return    
+
+
+        # Now that we have the model we can split the information
+        try:
+            lines = reader.extract_command_lines(self._curr_model)
+        except import_v4.ParticleError as why:
+            print why
+            print 'stop import proc_card_v4'
+            return
+            
+        for line in lines:
+            self.exec_cmd(line)
+    
+        return 
+
+    def import_mg5_proc_card(self, filepath):
+        # change the status of this line in the history -> pass in comment
+        self.history[-1] = '#%s' % self.history[-1]
+ 
+        # Read the lines of the file and execute them
+        for line in CmdFile(filepath):
+            #remove pointless spaces and \n
+            line = line.replace('\n', '').strip()
+            # execute the line if this one is not empty
+            if line:
+                self.exec_cmd(line)
+
+        return
+    
+    def check_for_export_dir(self, filepath):
+        """Check if the files is in a valid export directory and assign it to
+        export path if if is"""
+        
+        # keep previous if a previous one is defined
+        if self._export_dir:
+            return
+        
+        path_split = filepath.split(os.path.sep)
+        if len(path_split)>2 and path_split[-2] == 'Cards':
+            self._export_dir = os.path.sep.join(path_split[:-2])
+                
+    
+
+    def do_load(self, line):
+        """Load information from file"""
+
+        args = split_arg(line)
+        if not self.check_load(args):
+            print 'not accepted'
+            return
+
+
+        cpu_time1 = time.time()
+        if args[0] == 'model':
+            self._curr_model = save_load_object.load_from_file(args[1])
+            #save_model.save_model(args[1], self._curr_model)
+            if isinstance(self._curr_model, base_objects.Model):
+                cpu_time2 = time.time()
+                print "Loaded model from file in %0.3f s" % \
+                      (cpu_time2 - cpu_time1)
+            else:
+                print 'Error: Could not load model from file ', args[1]
+        elif args[0] == 'processes':
+            self._curr_amps = save_load_object.load_from_file(args[1])
+            if isinstance(self._curr_amps, diagram_generation.AmplitudeList):
+                cpu_time2 = time.time()
+                print "Loaded processes from file in %0.3f s" % \
+                      (cpu_time2 - cpu_time1)
+                if self._curr_amps and not self._curr_model.get('name'):
+                    self._curr_model = self._curr_amps[0].\
+                                        get('process').get('model')
+                    print "Model set from process."
+            else:
+                print 'Error: Could not load processes from file ', args[1]
+        else:
+            self.help_save()
+    
+    def do_save(self, line):
+        """Save information to file"""
+
+        args = split_arg(line)
+        if not self.check_save(args):
+            return False
+
+        if args[0] == 'model':
+            if self._curr_model:
+                #save_model.save_model(args[1], self._curr_model)
+                if save_load_object.save_to_file(args[1], self._curr_model):
+                    print 'Saved model to file ', args[1]
+            else:
+                print 'No model to save!'
+        elif args[0] == 'processes':
+            if self._curr_amps:
+                if save_load_object.save_to_file(args[1], self._curr_amps):
+                    print 'Saved processes to file ', args[1]
+            else:
+                print 'No processes to save!'
+        else:
+            self.help_save()
+            
+            
+    def do_makehtml(self, line):
+        """ make the html output for a MAdevent directory """
+        
+        args = split_arg(line)
+        if not self.check_makehtml(args):
+            return
+                   
+        
+        if self._export_dir:
+            dir_path = self._export_dir
+        else: 
+            dir_path = args[1]
+            
+        #look if the user ask to bypass the jpeg creation
+        if '--nojpeg' in args:
+            makejpg = False
+        else:
+            makejpg = True
+            
+        os.system('touch %s/done' % os.path.join(dir_path,'SubProcesses'))        
+        export_v4.create_v4_webpage(dir_path, makejpg)
+
+
+
+    def do_setup(self, line):
+        """Initialize a new Template or reinitialize one"""
+        
+        args = split_arg(line)
+        if not self.check_setup(args):
+            return False
+        
+        clean = '-noclean' not in args
+        force = '-f' in args 
+        dir = '-d' in args
+        if dir:
+            mgme_dir = args[args.find('-d') + 1]
+        else:
+            mgme_dir = MGME_dir
+                                
+        # Check for special directory treatment
+        if args[1] == '.':
+            if self._export_dir:
+                dir_path = self._export_dir
+            else:
+                print 'No possible working directory are detected'
+                self.help_setup()    
+                return False
+        elif args[1] == 'auto':
+            name_dir = lambda i: 'PROC_%s_%s' % \
+                                        (os.path.split(self._model_dir)[-1], i)
+            auto_path = lambda i: os.path.join(self.writing_dir, name_dir(i))     
+            
+            for i in range(500):
+                if os.path.isdir(auto_path(i)):
+                    continue
+                else:
+                    dir_path = auto_path(i) 
+                    break
+        else:    
+            dir_path = os.path.join(self.writing_dir, args[1])
+        
+        if not force and os.path.isdir(dir_path):
+            print 'INFO: directory %s already exists.' % args[1]
+            if clean:
+                print 'If you continue this directory will be cleaned'
+
+            answer = raw_input('Do you want to continue? [y/n]')
+            if answer != 'y':
+                print 'stop'
+                return False
+
+        export_v4.copy_v4template(mgme_dir, dir_path, self._model_dir, clean)
+        # Import the model
+        print 'import model files %s in directory %s' % \
+                       (os.path.basename(self._model_dir), args[1])        
+        export_v4.export_model(self._model_dir, dir_path)
+        self._export_dir = dir_path
+
+#===============================================================================
+# MadGraphCmd
+#===============================================================================
+class MadGraphCmdWeb(MadGraphCmd, CheckValidForCmdWeb):
+    """The command line processor of MadGraph"""         
+ 
+    def __init__(self, *arg, **opt):
+    
+        if os.environ.has_key('_CONDOR_SCRATCH_DIR'):
+            self.writing_dir = os.path.join(os.environ['_CONDOR_SCRATCH_DIR'], \
+                                                                 os.path.pardir)
+        else:
+            self.writing_dir = os.path.join(os.environ['MADGRAPH_DATA'],
+                               os.environ['REMOTE_USER'])
+        
+        #standard initialization
+        MadGraphCmd.__init__(self, *arg, **opt)
+
+#===============================================================================
+# MadGraphCmd
+#===============================================================================
+class MadGraphCmdShell(MadGraphCmd, CompleteForCmd, CheckValidForCmd):
+    """The command line processor of MadGraph""" 
+    
+    writing_dir = MGME_dir
+    
+    def preloop(self):
+        """Initializing before starting the main loop"""
+
+        self.prompt = 'mg5>'
+
+        readline.parse_and_bind("tab: complete")
+
+        # initialize command history
+        history_file = os.path.join(os.environ['HOME'], '.mg5history')
+        try:
+            readline.read_history_file(history_file)
+        except IOError:
+            pass
+        atexit.register(readline.write_history_file, history_file)
+
+        # If possible, build an info line with current version number 
+        # and date, from the VERSION text file
+
+        info = misc.get_pkg_info()
+        info_line = ""
+
+        if info.has_key('version') and  info.has_key('date'):
+            len_version = len(info['version'])
+            len_date = len(info['date'])
+            if len_version + len_date < 30:
+                info_line = "*         VERSION %s %s %s         *\n" % \
+                            (info['version'],
+                            (30 - len_version - len_date) * ' ',
+                            info['date'])
+
+        self.intro = \
+        "************************************************************\n" + \
+        "*                                                          *\n" + \
+        "*           W E L C O M E  to  M A D G R A P H  5          *\n" + \
+        "*                                                          *\n" + \
+        "*                                                          *\n" + \
+        "*                 *                       *                *\n" + \
+        "*                   *        * *        *                  *\n" + \
+        "*                     * * * * 5 * * * *                    *\n" + \
+        "*                   *        * *        *                  *\n" + \
+        "*                 *                       *                *\n" + \
+        "*                                                          *\n" + \
+        info_line + \
+        "*                                                          *\n" + \
+        "*    The MadGraph Development Team - Please visit us at    *\n" + \
+        "*    https://server06.fynu.ucl.ac.be/projects/madgraph     *\n" + \
+        "*                                                          *\n" + \
+        "*               Type 'help' for in-line help.              *\n" + \
+        "*                                                          *\n" + \
+        "************************************************************"
+
+    # Access to shell
+    def do_shell(self, line):
+        "Run a shell command"
+
+        if line.strip() is '':
+            self.help_shell()
+        else:
+            print "running shell command:", line
+            subprocess.call(line, shell=True)
+
+#===============================================================================
+# 
+#===============================================================================
+class CmdFile(file):
+    """ a class for command input file -in order to debug cmd \n problem"""
+    
+    def __init__(self, name, opt='rU'):
+        
+        file.__init__(self, name, opt)
+        self.text = file.read(self)
+        self.close()
+        self.lines = self.text.split('\n')
+    
+    def readline(self, *arg, **opt):
+        """readline method treating correctly a line whithout \n at the end
+           (add it)
+        """
+        if self.lines:
+            line = self.lines.pop(0)
+        else:
+            return ''
+        
+        if line.endswith('\n'):
+            return line
+        else:
+            return line + '\n'
+    
+    def __next__(self):
+        return self.lines.__next__()    
+    def __iter__(self):
+        return self.lines.__iter__()
+  
+#===============================================================================
+# Draw Command Parser
+#=============================================================================== 
+_usage =  "draw FILEPATH [options]\n" + \
+         "-- draw the diagrams in eps format\n" + \
+         "   Files will be FILEPATH/diagrams_\"process_string\".eps \n" + \
+         "   Example: draw plot_dir . \n"
+_draw_parser = optparse.OptionParser(usage=_usage)
+_draw_parser.add_option("", "--horizontal", default=False, 
+                   action='store_true', help="force S-channel to be horizontal")
+_draw_parser.add_option("", "--external", default=0, type='float',
+                    help="authorizes external particles to end at top or " + \
+                    "bottom of diagram. If bigger than zero this tune the " + \
+                    "length of those line.")
+_draw_parser.add_option("", "--max_size", default=1.5, type='float',
+                         help="this forbids external line bigger than max_size")
+_draw_parser.add_option("", "--non_propagating", default=True, \
+                          dest="contract_non_propagating", action='store_false', 
+                          help= "avoid contractions of non propagating lines") 
+_draw_parser.add_option("", "--add_gap", default=0, type='float', \
+                          help= "set the x-distance between external particles")  
+  
+    
+    
+    
+#===============================================================================
+# __main__
+#===============================================================================
+
+if __name__ == '__main__':
+    
+    run_option = sys.argv
+    if len(run_option) > 1:
+        # The first argument of sys.argv is the name of the program
+        input_file = open(run_option[1], 'rU')
+        cmd_line = MadGraphCmd(stdin=input_file)
+        cmd_line.use_rawinput = False #put it in non interactive mode
+        cmd_line.cmdloop()
+    else:
+        # Interactive mode
+        MadGraphCmd().cmdloop()    

=== removed file 'madgraph/interface/cmd_interface.py'
--- madgraph/interface/cmd_interface.py	2010-05-11 13:38:25 +0000
+++ madgraph/interface/cmd_interface.py	1970-01-01 00:00:00 +0000
@@ -1,1532 +0,0 @@
-################################################################################
-#
-# 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
-#
-################################################################################
-"""A user friendly command line interface to access MadGraph features.
-   Uses the cmd package for command interpretation and tab completion.
-"""
-
-import atexit
-import cmd
-import logging
-import os
-import re
-import readline
-import subprocess
-import sys
-import time
-
-import madgraph.iolibs.misc as misc
-import madgraph.iolibs.files as files
-
-import madgraph.iolibs.import_v4 as import_v4
-#import madgraph.iolibs.save_model as save_model
-import madgraph.iolibs.save_load_object as save_load_object
-import madgraph.iolibs.export_v4 as export_v4
-
-import madgraph.core.base_objects as base_objects
-import madgraph.core.diagram_generation as diagram_generation
-
-import madgraph.core.helas_objects as helas_objects
-import madgraph.iolibs.drawing as draw_lib
-import madgraph.iolibs.drawing_eps as draw
-
-#position of MG5
-root_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
-root_path = os.path.split(root_path)[0]
-
-#position of MG_ME
-MGME_dir = None
-MGME_dir_possibility = [os.path.join(root_path, os.path.pardir),
-                os.path.join(os.getcwd(), os.path.pardir),
-                os.getcwd()]
-
-for position in MGME_dir_possibility:
-    if os.path.exists(os.path.join(position, 'MGMEVersion.txt')) and \
-                    os.path.exists(os.path.join(position, 'UpdateNotes.txt')):
-        MGME_dir = os.path.realpath(position)
-        del MGME_dir_possibility
-        break
-#===============================================================================
-# MadGraphCmd
-#===============================================================================
-class MadGraphCmd(cmd.Cmd):
-    """The command line processor of MadGraph"""
-
-    __curr_model = base_objects.Model()
-    __model_dir = None
-    __curr_amps = diagram_generation.AmplitudeList()
-    __curr_matrix_elements = helas_objects.HelasMultiProcess()
-    __curr_fortran_model = export_v4.HelasFortranModel()
-    __multiparticles = {}
-
-    __display_opts = ['particles',
-                      'interactions',
-                      'processes',
-                      'multiparticles']
-    __add_opts = ['process']
-    __save_opts = ['model', 'processes']
-    __import_formats = ['model_v4', 'proc_v4', 'command']
-    __export_formats = ['standalone_v4', 'sa_dirs_v4', 'madevent_v4']
-    
-    class MadGraphCmdError(Exception):
-        """Exception raised if an error occurs in the execution
-        of command."""
-        pass
-    
-    def __init__(self, *arg, **opt):
-        """ add a tracker of the history """
-        
-        self.history = []
-        self.save_line = ''
-        cmd.Cmd.__init__(self, *arg, **opt)
-        self.__generate_info = "" # information line on the generation
-        
-        # detect if we have an a priori location for the output:
-        if 'Cards' in os.listdir('.'):
-            self.__export_dir = os.path.split(os.path.realpath('.'))[-1]
-        elif 'Cards' in os.listdir('..'):
-            self.__export_dir = os.path.split(os.path.realpath('..'))[-1]
-        elif self.stdin != sys.stdin:
-            input_path = os.path.realpath(self.stdin.name).split(os.path.sep)
-            if input_path[-2] == 'Cards':
-                self.__export_dir = os.path.sep.join(input_path[:-2])
-            else:
-                self.__export_dir = None
-        else:
-            self.__export_dir = None 
-        
-    def split_arg(self, line):
-        """Split a line of arguments"""
-        return line.split()
-
-    def list_completion(self, text, list):
-        """Propose completions of text in list"""
-        if not text:
-            completions = list
-        else:
-            completions = [ f
-                            for f in list
-                            if f.startswith(text)
-                            ]
-        return completions
-
-    def path_completion(self, text, base_dir=None):
-        """Propose completions of text to compose a valid path"""
-
-        if base_dir is None:
-            base_dir = os.getcwd()
-
-        completion = [f
-                       for f in os.listdir(base_dir)
-                       if f.startswith(text) and \
-                            os.path.isfile(os.path.join(base_dir, f))
-                       ]
-
-        completion = completion + \
-                     [f + '/'
-                       for f in os.listdir(base_dir)
-                       if f.startswith(text) and \
-                            os.path.isdir(os.path.join(base_dir, f))
-                     ]
-
-        return completion
-
-
-    def preloop(self):
-        """Initializing before starting the main loop"""
-
-        self.prompt = 'mg5>'
-
-        readline.parse_and_bind("tab: complete")
-
-        # initialize command history
-        history_file = os.path.join(os.environ['HOME'], '.mg5history')
-        try:
-            readline.read_history_file(history_file)
-        except IOError:
-            pass
-        atexit.register(readline.write_history_file, history_file)
-
-        # If possible, build an info line with current version number 
-        # and date, from the VERSION text file
-
-        info = misc.get_pkg_info()
-        info_line = ""
-
-        if info.has_key('version') and  info.has_key('date'):
-            len_version = len(info['version'])
-            len_date = len(info['date'])
-            if len_version + len_date < 30:
-                info_line = "*         VERSION %s %s %s         *\n" % \
-                            (info['version'],
-                            (30 - len_version - len_date) * ' ',
-                            info['date'])
-
-        self.intro = \
-        "************************************************************\n" + \
-        "*                                                          *\n" + \
-        "*           W E L C O M E  to  M A D G R A P H  5          *\n" + \
-        "*                                                          *\n" + \
-        "*                                                          *\n" + \
-        "*                 *                       *                *\n" + \
-        "*                   *        * *        *                  *\n" + \
-        "*                     * * * * 5 * * * *                    *\n" + \
-        "*                   *        * *        *                  *\n" + \
-        "*                 *                       *                *\n" + \
-        "*                                                          *\n" + \
-        info_line + \
-        "*                                                          *\n" + \
-        "*    The MadGraph Development Team - Please visit us at    *\n" + \
-        "*    https://server06.fynu.ucl.ac.be/projects/madgraph     *\n" + \
-        "*                                                          *\n" + \
-        "*               Type 'help' for in-line help.              *\n" + \
-        "*                                                          *\n" + \
-        "************************************************************"
-
-    def precmd(self, line):
-        """ force the printing of the line if this is executed with an stdin """
-        # Update the history of this suite of command
-        self.history.append(line)
-        
-        # Print the calling line in the non interactive mode    
-        if not self.use_rawinput:
-            print line
-        
-        #Check if they are a save line:
-        if self.save_line:
-            line = self.save_line + line 
-            self.save_line = ''
-        
-        #Check that the line is complete
-        if line.endswith('\\'):
-            self.save_line = line[:-1]
-            return '' # do nothing   
-        
-        #remove comment
-        if '#' in line:
-            line = line.split('#')[0]
-            
-        # execute the line command
-        return line
-    
-
-    def emptyline(self):
-        """If empty line, do nothing. Default is repeat previous command."""
-
-        pass
-    
-    def default(self, line):
-        """Default action if line is not recognized"""
-
-        if line[0] == "#":
-            # This is a comment - do nothing
-            return
-        else:
-            # Faulty command
-            print "Command \"%s\" not recognized, please try again" % \
-                  line.split()[0]
-
-    # Import files
-    def do_import(self, line):
-        """Import files with external formats"""
-
-        def import_v4file(self, filepath):
-            """Helper function to load a v4 file from file path filepath"""
-            filename = os.path.basename(filepath)
-            if filename.endswith('particles.dat'):
-                self.__curr_model.set('particles',
-                                     files.read_from_file(
-                                            filepath,
-                                            import_v4.read_particles_v4))
-                print "%d particles imported" % \
-                      len(self.__curr_model['particles'])
-                return True
-            elif filename.endswith('interactions.dat'):
-                if len(self.__curr_model['particles']) == 0:
-                    print "No particle list currently active,",
-                    print "please create one first!"
-                    return False
-                self.__curr_model.set('interactions',
-                                     files.read_from_file(
-                                            filepath,
-                                            import_v4.read_interactions_v4,
-                                            self.__curr_model['particles']))
-                print "%d interactions imported" % \
-                      len(self.__curr_model['interactions'])
-                return True
-
-           
-            #not valid File
-            return False
-
-        args = self.split_arg(line)
-        if len(args) != 2 or args[0] not in self.__import_formats:
-            self.help_import()
-            return False
-        
-        if args[0] == 'model_v4':
-            # Check for a file
-            if os.path.isfile(args[1]):
-                suceed = import_v4file(self, args[1])
-                if not suceed:
-                    print "%s is not a valid v4 file name" % \
-                                        os.path.basename(args[1])
-                else:
-                    self.__model_dir = os.path.dirname(args[1])
-                return
-                                           
-            # Check for a valid directory
-            if os.path.isdir(args[1]):
-                self.__model_dir = args[1]
-            elif MGME_dir and os.path.isdir(os.path.join(MGME_dir, 'Models', \
-                                                                      args[1])):
-                self.__model_dir = os.path.join(MGME_dir, 'Models', args[1])
-            elif not MGME_dir:
-                print "Path %s is not a valid pathname" % args[1]
-                print "and no MG_ME installation detected in other to search in Models"
-                return False                
-            else:
-                print "Path %s is not a valid pathname" % args[1]
-                return False
-            
-            #Load the directory
-            if os.path.exists(os.path.join(self.__model_dir, 'model.pkl')):
-                self.do_load('model %s' % os.path.join(self.__model_dir, \
-                                                                   'model.pkl'))
-                return
-            files_to_import = ('particles.dat', 'interactions.dat')
-            for filename in files_to_import:
-                if os.path.isfile(os.path.join(self.__model_dir, filename)):
-                    import_v4file(self, os.path.join(self.__model_dir, \
-                                                                      filename))
-                else:
-                    print "%s files doesn't exist in %s directory" % \
-                                        (filename, os.path.basename(args[1]))
-            #save model for next usage
-            self.do_save('model %s ' % os.path.join(self.__model_dir, \
-                                                                   'model.pkl'))
-        
-        elif args[0] == 'proc_v4':
-            if len(args) == 1 and self.__export_dir:
-                proc_card = os.path.join(self.__export_dir, '')            
-            elif len(args) == 2:
-                proc_card = args[1]
-            else:
-                logging.error('No default directory are setup')
-            
-            self.check_for_export_dir(proc_card)
-            self.import_mg4_proc_card(proc_card)   
-                                     
-        elif args[0] == 'command':
-            if not os.path.isfile(args[1]):
-                print "Path %s is not a valid pathname" % args[1]
-            else:
-                self.check_for_export_dir(args[1])
-                self.import_mg5_proc_card(args[1])
-        else:
-            self.help_import()
-            return False   
-
-    def complete_import(self, text, line, begidx, endidx):
-        "Complete the import command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, self.__import_formats)
-
-        # 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])
-
-    def import_mg4_proc_card(self, filepath):
-        """ read a V4 proc card, convert it and run it in mg5"""
-        
-        # change the status of this line in the history -> pass in comment
-        self.history[-1] = '#%s' % self.history[-1]
-         
-        # read the proc_card.dat
-        reader = files.read_from_file(filepath, import_v4.read_proc_card_v4)
-        
-        if MGME_dir:
-            #model_dir = os.path.join(MGME_dir, 'Models')
-            line = self.onecmd_full('import model_v4 %s' % (reader.model))
-        else:
-            logging.error('No MG_ME installation detected')
-            return    
-
-
-        # Now that we have the model we can split the information
-        lines = reader.extract_command_lines(self.__curr_model)
-        for line in lines:
-            self.onecmd_full(line)
-            
-        return 
-
-    def import_mg5_proc_card(self, filepath):
-        # change the status of this line in the history -> pass in comment
-        self.history[-1] = '#%s' % self.history[-1]
- 
-        # Read the lines of the file and execute them
-        for line in CmdFile(filepath):
-            #remove pointless spaces and \n
-            line = line.replace('\n', '').strip()
-            # execute the line if this one is not empty
-            if line:
-                self.onecmd_full(line)
-        return
-
-
-    def onecmd_full(self, line):
-        """for third party call, call the line with pre and postfix treatment"""
-        print line
-        line = self.precmd(line)
-        stop = self.onecmd(line)
-        stop = self.postcmd(stop, line)
-        return stop      
-        
-        
-    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)
-                if save_load_object.save_to_file(args[1], self.__curr_model):
-                    print 'Saved model to file ', args[1]
-            else:
-                print 'No model to save!'
-        elif args[0] == 'processes':
-            if self.__curr_amps:
-                if save_load_object.save_to_file(args[1], self.__curr_amps):
-                    print 'Saved processes to file ', args[1]
-            else:
-                print 'No processes to save!'
-        else:
-            self.help_save()
-            
-    def do_setup(self, line):
-        """Initialize a new Template or reinitialize one"""
-        
-        args = self.split_arg(line)
-        clean = '-noclean' not in args
-        force = '-f' in args 
-        dir = '-d' in args
-        if dir:
-            mgme_dir = args[args.find('-d') + 1]
-        else:
-            mgme_dir = MGME_dir
-                        
-        if len(args) < 2:
-            self.help_setup()
-            return False
-        
-        if not self.__model_dir:
-            print 'No model found. Please import a model first and then retry'
-            print '  for example do : import model_v4 sm'
-            return False
-        
-        # Check for special directory treatment
-        if args[1] == '.':
-            if self.__export_dir:
-                args[1] = self.__export_dir
-            else:
-                print 'No possible working directory are detected'
-                self.help_setup()    
-                return False
-        elif args[1] == 'auto':
-            name_dir = lambda i: 'PROC_%s_%s' % \
-                                        (os.path.split(self.__model_dir)[-1], i)
-            auto_path = lambda i: os.path.join(mgme_dir, name_dir(i))     
-            
-            for i in range(500):
-                if os.path.isdir(auto_path(i)):
-                    continue
-                else:
-                    args[1] = name_dir(i) 
-                    break
-                
-        dir_path = os.path.join(mgme_dir, args[1])
-        if not force and os.path.isdir(dir_path):
-            print 'INFO: directory %s already exists.' % args[1]
-            if clean:
-                print 'If you continue this directory will be cleaned'
-
-            answer = raw_input('Do you want to continue? [y/n]')
-            if answer != 'y':
-                print 'stop'
-                return False
-
-        export_v4.copy_v4template(mgme_dir, dir_path, self.__model_dir, clean)
-        # Import the model
-        print 'import model files %s in directory %s' % \
-                       (os.path.basename(self.__model_dir), args[1])        
-        export_v4.export_model(self.__model_dir, dir_path)
-        self.__export_dir = dir_path
-        
-        
-    def complete_setup(self, text, line, begidx, endidx):
-        "Complete the setup command"
-
-        possible_option = ['-d ', '-f', '-noclean']
-        possible_option2 = ['d ', 'f', 'noclean']
-        possible_format = ['madevent_v4']
-        #don't propose directory use by MG_ME
-        forbidden_name = ['MadGraphII', 'Template', 'pythia-pgs', 'CVS',
-                            'Calculators', 'MadAnalysis', 'SimpleAnalysis', 
-                            'mg5', 'DECAY', 'EventConverter', 'Models', 
-                            'ExRootAnalysis', 'HELAS', 'Transfer_Fct']
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, possible_format)
-        
-        #name of the run =>proposes old run name
-        if len(self.split_arg(line[0:begidx])) == 2: 
-            content = [name for name in os.listdir(MGME_dir) if \
-                                    name not in forbidden_name and \
-                                    os.path.isdir(os.path.join(MGME_dir, name))]
-            content += ['.', 'auto']
-            return self.list_completion(text, content)
-
-        # Returning options
-        if len(self.split_arg(line[0:begidx])) > 2:
-            if self.split_arg(line[0:begidx])[-1] == '-d':
-                return self.path_completion(text)
-            elif  self.split_arg(line[0:begidx])[-2] == '-d' and line[-1] != ' ':
-                return self.path_completion(text, \
-                                             self.split_arg(line[0:begidx])[-1])
-            elif self.split_arg(line[0:begidx])[-1] == '-':
-                return self.list_completion(text, possible_option2)
-            else:
-                return self.list_completion(text, possible_option)
-
-    def do_load(self, line):
-        """Load information from file"""
-
-        args = self.split_arg(line)
-        if len(args) != 2:
-            self.help_load()
-            return False
-
-        cpu_time1 = time.time()
-        if args[0] == 'model':
-            self.__curr_model = save_load_object.load_from_file(args[1])
-            #save_model.save_model(args[1], self.__curr_model)
-            if isinstance(self.__curr_model, base_objects.Model):
-                cpu_time2 = time.time()
-                print "Loaded model from file in %0.3f s" % \
-                      (cpu_time2 - cpu_time1)
-            else:
-                print 'Error: Could not load model from file ', args[1]
-        elif args[0] == 'processes':
-            self.__curr_amps = save_load_object.load_from_file(args[1])
-            if isinstance(self.__curr_amps, diagram_generation.AmplitudeList):
-                cpu_time2 = time.time()
-                print "Loaded processes from file in %0.3f s" % \
-                      (cpu_time2 - cpu_time1)
-                if self.__curr_amps and not self.__curr_model.get('name'):
-                    self.__curr_model = self.__curr_amps[0].\
-                                        get('process').get('model')
-                    print "Model set from process."
-            else:
-                print 'Error: Could not load processes from file ', args[1]
-        else:
-            self.help_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, self.__save_opts)
-
-        # 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])
-
-    def complete_load(self, text, line, begidx, endidx):
-        "Complete the load command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, self.__save_opts)
-
-        # 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])
-
-    def complete_draw(self, text, line, begidx, endidx):
-        "Complete the import command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.path_completion(text)
-
-
-        #option
-        if len(self.split_arg(line[0:begidx])) >= 2:
-            option = ['external=', 'horizontal=', 'add_gap=', 'max_size=', \
-                                'contract_non_propagating=']
-            return self.list_completion(text, option)
-
-    # Display
-    def do_display(self, line):
-        """Display current internal status"""
-
-        args = self.split_arg(line)
-
-        if len(args) != 1:
-            self.help_display()
-            return False
-
-        if args[0] == 'particles':
-            print "Current model contains %i particles:" % \
-                    len(self.__curr_model['particles'])
-            part_antipart = [part for part in self.__curr_model['particles'] \
-                             if not part['self_antipart']]
-            part_self = [part for part in self.__curr_model['particles'] \
-                             if part['self_antipart']]
-            for part in part_antipart:
-                print part['name'] + '/' + part['antiname'],
-            print ''
-            for part in part_self:
-                print part['name'],
-            print ''
-
-        elif args[0] == 'interactions':
-            print "Current model contains %i interactions" % \
-                    len(self.__curr_model['interactions'])
-            for inter in self.__curr_model['interactions']:
-                print str(inter['id']) + ':',
-                for part in inter['particles']:
-                    if part['is_part']:
-                        print part['name'],
-                    else:
-                        print part['antiname'],
-                print
-
-        elif args[0] == 'processes':
-            for amp in self.__curr_amps:
-                print amp.nice_string()
-        elif args[0] == 'multiparticles':
-            print 'Multiparticle labels:'
-            for key in self.__multiparticles:
-                print key, " = ", self.__multiparticles[key]
-
-        else:
-            self.help_display()
-
-    def complete_display(self, text, line, begidx, endidx):
-        "Complete the display command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, self.__display_opts)
-
-    # Access to shell
-    def do_shell(self, line):
-        "Run a shell command"
-
-        if line.strip() is '':
-            self.help_shell()
-        else:
-            print "running shell command:", line
-            subprocess.call(line, shell=True)
-
-    # Generate a new amplitude
-    def do_generate(self, line):
-        """Generate an amplitude for a given process"""
-
-        if len(line) < 1:
-            self.help_generate()
-            return False
-
-        if len(self.__curr_model['particles']) == 0:
-            print "No particle list currently active, please create one first!"
-            return False
-
-        if len(self.__curr_model['interactions']) == 0:
-            print "No interaction list currently active," + \
-            " please create one first!"
-            return False
-
-        # Reset Helas matrix elements
-        self.__curr_matrix_elements = helas_objects.HelasMultiProcess()
-        self.__generate_info = line
-
-        try:
-            if line.find(',') == -1:
-                myprocdef = self.extract_process(line)
-            else:
-                myprocdef, line = self.extract_decay_chain_process(line)
-        except self.MadGraphCmdError as error:
-            print "Empty or wrong format process, please try again. Error:\n" \
-                  + str(error)
-            myprocdef = None
-            
-        if myprocdef:
-
-            cpu_time1 = time.time()
-
-            myproc = diagram_generation.MultiProcess(myprocdef)
-
-            self.__curr_amps = myproc.get('amplitudes')
-
-            cpu_time2 = time.time()
-
-            nprocs = len(self.__curr_amps)
-            ndiags = sum([amp.get_number_of_diagrams() for \
-                              amp in self.__curr_amps])
-            print "%i processes with %i diagrams generated in %0.3f s" % \
-                  (nprocs, ndiags, (cpu_time2 - cpu_time1))
-
-        else:
-            print "Empty or wrong format process, please try again."
-
-
-    # Helper functions
-    def extract_decay_chain_process(self, line, level_down=False):
-        """Recursively extract a decay chain process definition from a
-        string. Returns a ProcessDefinition."""
-
-        # Start with process number (identified by "@")
-        proc_number_pattern = re.compile("^(.+)@\s*(\d+)\s*(.*)$")
-        proc_number_re = proc_number_pattern.match(line)
-        proc_number = 0
-        if proc_number_re:
-            proc_number = int(proc_number_re.group(2))
-            line = proc_number_re.group(1) + \
-                   proc_number_re.group(3)
-            print line
-            
-        index_comma = line.find(",")
-        index_par = line.find(")")
-        min_index = index_comma
-        if index_par > -1 and (index_par < min_index or min_index == -1):
-            min_index = index_par
-        
-        if min_index > -1:
-            core_process = self.extract_process(line[:min_index], proc_number)
-        else:
-            core_process = self.extract_process(line, proc_number)
-
-        #level_down = False
-
-        while index_comma > -1:
-            line = line[index_comma + 1:]
-            index_par = line.find(')')
-            if line.lstrip()[0] == '(':
-                # Go down one level in process hierarchy
-                #level_down = True
-                line = line.lstrip()[1:]
-                # This is where recursion happens
-                decay_process, line = \
-                            self.extract_decay_chain_process(line,
-                                                             level_down=True)
-                index_comma = line.find(",")
-                index_par = line.find(')')
-            else:
-                index_comma = line.find(",")
-                min_index = index_comma
-                if index_par > -1 and \
-                       (index_par < min_index or min_index == -1):
-                    min_index = index_par
-                if min_index > -1:
-                    decay_process = self.extract_process(line[:min_index])
-                else:
-                    decay_process = self.extract_process(line)
-
-            core_process.get('decay_chains').append(decay_process)
-
-            if level_down:
-                if index_par == -1:
-                    raise self.MadGraphCmdError, \
-                      "Missing ending parenthesis for decay process"
-
-                if index_par < index_comma:
-                    line = line[index_par + 1:]
-                    level_down = False
-                    break
-
-        if level_down:
-            index_par = line.find(')')
-            if index_par == -1:
-                raise self.MadGraphCmdError, \
-                      "Missing ending parenthesis for decay process"
-            line = line[index_par + 1:]
-            
-        # Return the core process (ends recursion when there are no
-        # more decays)
-        return core_process, line
-    
-    def check_for_export_dir(self, filepath):
-        """Check if the files is in a valid export directory and assing it to
-        export path if if is"""
-        
-        # keep previous if a previous one is defined
-        if self.__export_dir:
-            return
-        
-        path_split = filepath.split(os.path.sep)
-        if path_split[-2] == 'Cards':
-            self.__export_dir = os.path.sep.join(path_split[:-2])
-        
-    def extract_process(self, line, proc_number = 0):
-        """Extract a process definition from a string. Returns
-        a ProcessDefinition."""
-
-        # Use regular expressions to extract s-channel propagators,
-        # forbidden s-channel propagators/particles, coupling orders
-        # and process number, starting from the back
-
-        # Start with process number (identified by "@")
-        proc_number_pattern = re.compile("^(.+)@\s*(\d+)\s*(.*)$")
-        proc_number_re = proc_number_pattern.match(line)
-        if proc_number_re:
-            proc_number = int(proc_number_re.group(2))
-            line = proc_number_re.group(1) + \
-                   proc_number_re.group(3)
-
-        # Start with coupling orders (identified by "=")
-        order_pattern = re.compile("^(.+)\s+(\w+)\s*=\s*(\d+)\s*$")
-        order_re = order_pattern.match(line)
-        orders = {}
-        while order_re:
-            orders[order_re.group(2)] = int(order_re.group(3))
-            line = order_re.group(1)
-            order_re = order_pattern.match(line)
-
-        # Particle names always lowercase
-        line = line.lower()
-
-        # Now check for forbidden particles, specified using "/"
-        slash = line.find("/")
-        dollar = line.find("$")
-        forbidden_particles = ""
-        if slash > 0:
-            if dollar > slash:
-                forbidden_particles_re = re.match("^(.+)\s*/\s*(.+\s*)(\$.*)$", line)
-            else:
-                forbidden_particles_re = re.match("^(.+)\s*/\s*(.+\s*)$", line)
-            if forbidden_particles_re:
-                forbidden_particles = forbidden_particles_re.group(2)
-                line = forbidden_particles_re.group(1)
-                if len(forbidden_particles_re.groups()) > 2:
-                    line = line + forbidden_particles_re.group(3)
-
-        # Now check for forbidden schannels, specified using "$"
-        forbidden_schannels_re = re.match("^(.+)\s*\$\s*(.+)\s*$", line)
-        forbidden_schannels = ""
-        if forbidden_schannels_re:
-            forbidden_schannels = forbidden_schannels_re.group(2)
-            line = forbidden_schannels_re.group(1)
-
-        # Now check for required schannels, specified using "> >"
-        required_schannels_re = re.match("^(.+?)>(.+?)>(.+)$", line)
-        required_schannels = ""
-        if required_schannels_re:
-            required_schannels = required_schannels_re.group(2)
-            line = required_schannels_re.group(1) + ">" + \
-                   required_schannels_re.group(3)
-
-        args = self.split_arg(line)
-
-        myleglist = base_objects.MultiLegList()
-        state = False
-
-        # Extract process
-        for part_name in args:
-
-            if part_name == '>':
-                if not myleglist:
-                    raise self.MadGraphCmdError, \
-                          "No final state particles"
-                state = True
-                continue
-
-            mylegids = []
-            if part_name in self.__multiparticles:
-                mylegids.extend(self.__multiparticles[part_name])
-            else:
-                mypart = self.__curr_model['particles'].find_name(part_name)
-                if mypart:
-                    mylegids.append(mypart.get_pdg_code())
-
-            if mylegids:
-                myleglist.append(base_objects.MultiLeg({'ids':mylegids,
-                                                        'state':state}))
-            else:
-                raise self.MadGraphCmdError, \
-                      "No particle %s in model" % part_name
-
-        if filter(lambda leg: leg.get('state') == True, myleglist):
-            # We have a valid process
-
-            # Now extract restrictions
-            forbidden_particle_ids = []
-            forbidden_schannel_ids = []
-            required_schannel_ids = []
-
-            #decay_process = len(filter(lambda leg: \
-            #                           leg.get('state') == False,
-            #                           myleglist)) == 1
-
-            if forbidden_particles:
-                args = self.split_arg(forbidden_particles)
-                for part_name in args:
-                    if part_name in self.__multiparticles:
-                        forbidden_particle_ids.extend( \
-                                               self.__multiparticles[part_name])
-                    else:
-                        mypart = self.__curr_model['particles'].find_name( \
-                                                                      part_name)
-                        if mypart:
-                            forbidden_particle_ids.append(mypart.get_pdg_code())
-
-            if forbidden_schannels:
-                args = self.split_arg(forbidden_schannels)
-                for part_name in args:
-                    if part_name in self.__multiparticles:
-                        forbidden_schannel_ids.extend(\
-                                               self.__multiparticles[part_name])
-                    else:
-                        mypart = self.__curr_model['particles'].find_name(\
-                                                                      part_name)
-                        if mypart:
-                            forbidden_schannel_ids.append(mypart.get_pdg_code())
-
-            if required_schannels:
-                args = self.split_arg(required_schannels)
-                for part_name in args:
-                    if part_name in self.__multiparticles:
-                        required_schannel_ids.extend(\
-                                               self.__multiparticles[part_name])
-                    else:
-                        mypart = self.__curr_model['particles'].find_name(\
-                                                                      part_name)
-                        if mypart:
-                            required_schannel_ids.append(mypart.get_pdg_code())
-
-            return \
-                base_objects.ProcessDefinition({'legs': myleglist,
-                                'model': self.__curr_model,
-                                'id': proc_number,
-                                'orders': orders,
-                                'forbidden_particles': forbidden_particle_ids,
-                                'forbidden_s_channels': forbidden_schannel_ids,
-                                'required_s_channels': required_schannel_ids
-                                 })
-        #                       'is_decay_chain': decay_process\
-        else:
-            return None
-
-    # Add a process to the existing multiprocess definition
-    # Generate a new amplitude
-    def do_add(self, line):
-        """Generate an amplitude for a given process and add to
-        existing amplitudes"""
-
-        if len(line) < 1:
-            self.help_add()
-            return False
-
-        if len(self.__curr_model['particles']) == 0:
-            print "No particle list currently active, please create one first!"
-            return False
-
-        if len(self.__curr_model['interactions']) == 0:
-            print "No interaction list currently active," + \
-            " please create one first!"
-            return False
-
-        args = self.split_arg(line)
-        if len(args) < 2:
-            self.help_import()
-            return False
-
-        if args[0] == 'process':
-            # Rejoin line
-            line = ' '.join(args[1:])
-            
-            # store the first process (for the perl script)
-            if not self.__generate_info:
-                self.__generate_info = line
-                
-            # Reset Helas matrix elements
-            self.__curr_matrix_elements = helas_objects.HelasMultiProcess()
-
-            try:
-                if line.find(',') == -1:
-                    myprocdef = self.extract_process(line)
-                else:
-                    myprocdef, line = self.extract_decay_chain_process(line)
-            except self.MadGraphCmdError as error:
-                print "Empty or wrong format process, please try again. Error:" 
-                print error
-                myprocdef = None
-
-            if myprocdef:
-
-                cpu_time1 = time.time()
-
-                myproc = diagram_generation.MultiProcess(myprocdef)
-
-                for amp in myproc.get('amplitudes'):
-                    if amp not in self.__curr_amps:
-                        self.__curr_amps.append(amp)
-                    else:
-                        print "Warning: Already in processes:"
-                        print amp.nice_string_processes()
-
-                cpu_time2 = time.time()
-
-                nprocs = len(myproc.get('amplitudes'))
-                ndiags = sum([amp.get_number_of_diagrams() for \
-                                  amp in myproc.get('amplitudes')])
-                print "%i processes with %i diagrams generated in %0.3f s" % \
-                      (nprocs, ndiags, (cpu_time2 - cpu_time1))
-                ndiags = sum([amp.get_number_of_diagrams() for \
-                                  amp in self.__curr_amps])
-                print "Total: %i processes with %i diagrams" % \
-                      (len(self.__curr_amps), ndiags)                
-            else:
-                print "Empty or wrong format process, please try again."
-        else:
-            self.help_add()
-            
-
-    def complete_add(self, text, line, begidx, endidx):
-        "Complete the add command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, self.__add_opts)
-        
-    # Write the list of command line use in this session
-    def do_history(self, line):
-        """write in a file the suite of command that was used"""
-        
-        # Start of the actual routine
-
-        args = self.split_arg(line)
-
-        if len(args) > 1:
-            self.help_history()
-            return False
-        
-        if len(args) == 0:
-            print '\n'.join(self.history)
-            return False
-        elif args[0] == 'clean':
-            self.history = []
-            print 'history is cleaned'
-            return False
-        
-        output_file = open(args[0], 'w')
-        # Define a simple header for the file
-        creation_time = time.asctime() 
-        time_info = \
-        '#     automaticaly generated the %s%s*\n' % (creation_time, ' ' * \
-                                                      (26 - len(creation_time)))
-        text = \
-        '#***********************************************************\n' + \
-        '#                         MadGraph 5                       *\n' + \
-        '#                                                          *\n' + \
-        "#                 *                       *                *\n" + \
-        "#                   *        * *        *                  *\n" + \
-        "#                     * * * * 5 * * * *                    *\n" + \
-        "#                   *        * *        *                  *\n" + \
-        "#                 *                       *                *\n" + \
-        "#                                                          *\n" + \
-        "#                                                          *\n" + \
-        "#    The MadGraph Development Team - Please visit us at    *\n" + \
-        "#    https://server06.fynu.ucl.ac.be/projects/madgraph     *\n" + \
-        '#                                                          *\n' + \
-        '#***********************************************************\n' + \
-        '#                                                          *\n' + \
-        '#               Command File for MadGraph 5                *\n' + \
-        '#                                                          *\n' + \
-        '#     run as ./bin/mg5  filename                           *\n' + \
-        time_info + \
-        '#                                                          *\n' + \
-        '#***********************************************************\n'
-        
-        #Avoid repetition of header
-        if self.history[0] == '#'+'*' * 59:
-            text=''
-        # Add the comand used 
-        text += '\n'.join(self.history) + '\n' 
-        
-        #write this information in a file
-        output_file.write(text)
-        output_file.close()
-
-    def complete_history(self, text, line, begidx, endidx):
-        "Complete the add command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.path_completion(text)
-
-    # Export a matrix element
-    def do_export(self, line):
-        """Export a generated amplitude to file"""
-
-        def generate_matrix_elements(self):
-            """Helper function to generate the matrix elements before
-            exporting"""
-
-            cpu_time1 = time.time()
-            if not self.__curr_matrix_elements.get('matrix_elements'):
-                self.__curr_matrix_elements = \
-                             helas_objects.HelasMultiProcess(\
-                                           self.__curr_amps)
-            cpu_time2 = time.time()
-
-            ndiags = sum([len(me.get('diagrams')) for \
-                          me in self.__curr_matrix_elements.\
-                          get('matrix_elements')])
-
-            return ndiags, cpu_time2 - cpu_time1
-
-        # Start of the actual routine
-
-        args = self.split_arg(line)
-
-        if len(args) == 0 or (len(args) == 1 and not self.__export_dir) or \
-                                           args[0] not in self.__export_formats:
-            self.help_export()
-            return False
-
-        if not self.__curr_amps:
-            print "No process generated, please generate a process!"
-            return False
-
-        if len(args) == 1:
-            path = os.path.join(self.__export_dir, 'SubProcesses')
-        else:
-            path = args[1]
-
-        if not os.path.isdir(path):
-            print "%s is not a valid directory for export file" % path
-            return False
-
-        ndiags, cpu_time = generate_matrix_elements(self)
-        calls = 0
-
-        if args[0] == 'standalone_v4':
-            for me in self.__curr_matrix_elements.get('matrix_elements'):
-                filename = os.path.join(path, 'matrix_' + \
-                           me.get('processes')[0].shell_string() + ".f")
-                if os.path.isfile(filename):
-                    print "Overwriting existing file %s" % filename
-                else:
-                    print "Creating new file %s" % filename
-                calls = calls + files.write_to_file(filename,
-                                   export_v4.write_matrix_element_v4_standalone,
-                                   me, self.__curr_fortran_model)
-
-
-        if args[0] == 'sa_dirs_v4':
-            for me in self.__curr_matrix_elements.get('matrix_elements'):
-                calls = calls + \
-                        export_v4.generate_subprocess_directory_v4_standalone(\
-                            me, self.__curr_fortran_model, path)
-
-        if args[0] == 'madevent_v4':
-            for me in self.__curr_matrix_elements.get('matrix_elements'):
-                calls = calls + \
-                        export_v4.generate_subprocess_directory_v4_madevent(\
-                            me, self.__curr_fortran_model, path)
-            
-            card_path = os.path.join(path, os.path.pardir, 'SubProcesses', \
-                                                              'procdef_mg5.dat')
-            if self.__generate_info:
-                export_v4.write_procdef_mg5(card_path,
-                                os.path.split(self.__model_dir)[-1],
-                                self.__generate_info)
-                
-        print ("Generated helas calls for %d subprocesses " + \
-              "(%d diagrams) in %0.3f s") % \
-              (len(self.__curr_matrix_elements.get('matrix_elements')),
-               ndiags, cpu_time)
-
-        print "Wrote %d helas calls" % calls
-
-        # Replace the amplitudes with the actual amplitudes from the
-        # matrix elements, which allows proper diagram drawing also of
-        # decay chain processes
-        self.__curr_amps = diagram_generation.AmplitudeList(\
-               [me.get('base_amplitude') for me in \
-                self.__curr_matrix_elements.get('matrix_elements')])
-
-    def complete_export(self, text, line, begidx, endidx):
-        "Complete the export command"
-
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, self.__export_formats)
-
-        # 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])
-
-    # Define a multiparticle label
-    def do_define(self, line):
-        """Define a multiparticle"""
-
-        # Particle names always lowercase
-        line = line.lower()
-
-        args = self.split_arg(line)
-
-        if len(args) < 1:
-            self.help_define()
-            return False
-
-        if len(self.__curr_model['particles']) == 0:
-            print "No particle list currently active, please create one first!"
-            return False
-
-        label = args[0]
-        pdg_list = []
-
-        for part_name in args[1:]:
-
-            mypart = self.__curr_model['particles'].find_name(part_name)
-
-            if mypart:
-                pdg_list.append(mypart.get_pdg_code())
-            else:
-                print ("Error: No particle %s in model. " % part_name) + \
-                      "No multiparticle created."
-                return False
-                
-        if not pdg_list:
-            print """Empty or wrong format for multiparticle.
-            Please try again."""
-
-        self.__multiparticles[label] = pdg_list
-
-    def do_draw(self, line):
-        """ draw the Feynman diagram for the given process """
-
-        args = self.split_arg(line)
-
-        if len(args) < 1:
-            self.help_draw()
-            return False
-        
-        if not self.__curr_amps:
-            print "No process generated, please generate a process!"
-            return False
-
-        if not os.path.isdir(args[0]):
-            print "%s is not a valid directory for export file" % args[1]
-
-        start = time.time()
-        option = draw_lib.DrawOption()
-        if len(args) > 1:
-            for data in args[1:]:
-                try:
-                    key, value = data.split('=')
-                except:
-                    print "invalid syntax: '%s'. Please try again" % data
-                    self.help_draw()
-                    return False
-                option.set(key, value)
-
-        # Collect amplitudes
-        amplitudes = diagram_generation.AmplitudeList()
-
-        for amp in self.__curr_amps:
-            amplitudes.extend(amp.get_amplitudes())            
-
-        for amp in amplitudes:
-            filename = os.path.join(args[0], 'diagrams_' + \
-                                    amp.get('process').shell_string() + ".eps")
-            plot = draw.MultiEpsDiagramDrawer(amp['diagrams'],
-                                              filename,
-                                              model=self.__curr_model,
-                                              amplitude='')
-
-            logging.info("Drawing " + \
-                         amp.get('process').nice_string())
-            plot.draw(opt=option)
-            print "Wrote file " + filename
-
-        stop = time.time()
-        print 'time to draw', stop - start
-
-    def do_makehtml(self, line):
-        """ make the html output for a MAdevent directory """
-        
-        args = self.split_arg(line)
-        
-        if len(args) < 1:
-            self.help_makehtml()
-            return False
-        
-        if args[0] != 'madevent_v4':
-            self.help_makehtml()
-            return False
-        
-        if (len(args) == 1 and not self.__export_dir) or \
-                        (len(args) > 1 and not os.path.isdir(args[1])):
-            self.help_makehtml()
-            return False            
-        
-        if self.__export_dir:
-            dir_path = self.__export_dir
-        else: 
-            dir_path = args[1]
-            
-        #look if the user ask to bypass the jpeg creation
-        if '--nojpeg' in args:
-            makejpg = False
-        else:
-            makejpg = True
-        
-        export_v4.create_v4_webpage(dir_path, makejpg)
-        os.system('touch %s/done' % os.path.join(dir_path,'SubProcesses'))
-        
-    def complete_makehtml(self, text, line, begidx, endidx):
-        """ format: makehtlm madevent_v4 [PATH] [--nojpeg]"""
-        
-        # Format
-        if len(self.split_arg(line[0:begidx])) == 1:
-            return self.list_completion(text, ['madevent_v4'])
-        
-        if text.startswith('-'):
-            return self.list_completion(text, ['--nojpeg'])
-
-        # 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]) 
-
-
-    # Quit
-    def do_quit(self, line):
-        sys.exit(1)
-
-    # In-line help
-    def help_save(self):
-        print "syntax: save %s FILENAME" % "|".join(self.__save_opts)
-        print "-- save information as file FILENAME"
-
-
-    def help_load(self):
-        print "syntax: load %s FILENAME" % "|".join(self.__save_opts)
-        print "-- load information from file FILENAME"
-
-    def help_import(self):
-        
-        print "syntax: import " + "|".join(self.__import_formats) + \
-              " FILENAME"
-        print "-- imports file(s) in various formats"
-        print
-        print "   import model_v4 MODEL_info :"
-        print "      Import a MG4 Model in MG5 Model"""
-        print "      Model_info could be the name of the model"""
-        print "                 or the path to MG4_Model directory"""
-        print
-        print "   import proc_v4 [PATH] :"  
-        print "      Execute MG5 based on a proc_card.dat in MG4 format."""
-        print "      Path to the proc_card is optional if you have setup a"
-        print "      madevent directory"
-        print 
-        print "   import command PATH :"
-        print "      Execute the list of command in the file at PATH"
-        
-    def help_display(self):
-        print "syntax: display " + "|".join(self.__display_opts)
-        print "-- display a the status of various internal state variables"
-
-    def help_setup(self):
-        print "syntax madevent_v4 name|.|auto [options]"
-        print "-- Create a copy of the V4 Template in the MG_ME directory."
-        print "   name will be the name of the copy the madevent Template that"
-        print "     will be use by default in following steps"
-        print "   If you put '.' instead of a name, the code will try to locate"
-        print "     a valid copy of the Template under focus"
-        print "   If you put 'auto' instead an automatic name will be created"  
-        print "   options:"
-        print "      -f: force the cleaning of the directory if this one exist"
-        print "      -d PATH: specify the directory where to create name"
-        print "      -noclean: no cleaning perform in name"
-        print "   Example:"
-        print "       setup madevent_v4 MYRUN"
-        print "       setup madevent_v4 MYRUN -d ../MG_ME -f"
-        
-    def help_generate(self):
-
-        print "syntax: generate INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2=ORDER2"
-        print "-- generate diagrams for a given process"
-        print "   Example: u d~ > w+ > m+ vm g $ a / z h QED=3 QCD=0 @1"
-        print "Decay chain syntax:"
-        print "   core process, decay1, (decay2, (decay3, ...)), ...  etc"
-        print "   Example: g g > t~ t @2, (t~ > W- b~, W- > e- ve~), t > W+ b"
-        print "   Note that identical particles will all be decayed"
-
-    def help_add(self):
-
-        print "syntax: add process INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2=ORDER2"
-        print "-- generate diagrams for a process and add to existing processes"
-        print "   Syntax example: u d~ > w+ > m+ vm g $ a / z h QED=3 QCD=0 @1"
-        print "Decay chain syntax:"
-        print "   core process, decay1, (decay2, (decay3, ...)), ...  etc"
-        print "   Example: g g > t~ t @2, (t~ > W- b~, W- > e- ve~), t > W+ b"
-        print "   Note that identical particles will all be decayed"
-
-    def help_define(self):
-        print "syntax: define multipart_name [ part_name_list ]"
-        print "-- define a multiparticle"
-        print "   Example: define p u u~ c c~ d d~ s s~"
-
-    def help_export(self):
-        print "syntax: export " + "|".join(self.__export_formats) + \
-              " FILEPATH"
-        print """-- export matrix elements. For standalone_v4, the resulting
-        files will be FILEPATH/matrix_\"process_string\".f. For sa_dirs_v4,
-        the result is a set of complete MG4 Standalone process directories.
-        For madevent_v4, the path needs to be to a MadEvent SubProcesses
-        directory, and the result is the Pxxx directories (including the
-        diagram .ps and .jpg files) for the subprocesses as well as a
-        correctly generated subproc.mg file. Note that if you have run the 
-        'setup', FILEPATH is optional."""
-
-    def help_history(self):
-        print "syntax: history [FILEPATH] [-clean] "
-        print "-- write in the specified files all the call to MG5 that you have"""
-        print "   perform since that you have open this command line applet."""
-        print "   -clean option will remove all the entry of the history"""
-
-    def help_makehtml(self):
-        print "syntax: makehtlm madevent_v4 [PATH]"
-        print "-- create the web page related to the directory PATH"
-        print "   by default PATH is the directory defined with the setup command"
-        
-
-    def help_draw(self):
-        print "syntax: draw FILEPATH [option=value]"
-        print "-- draw the diagrams in eps format"
-        print "   Files will be FILEPATH/diagrams_\"process_string\".eps"
-        print "   Example: draw plot_dir ."
-        print "   Possible option: "
-        print "        horizontal [False]: force S-channel to be horizontal"
-        print "        external [0]: authorizes external particles to end"
-        print "             at top or bottom of diagram. If bigger than zero"
-        print "             this tune the length of those line."
-        print "        max_size [0]: this forbids external line bigger than "
-        print "             max_size."
-        print "        contract_non_propagating [True]:contracts non propagating lines"
-        print "   Example: draw plot_dir external=1 horizontal=1"
-
-    def help_shell(self):
-        print "syntax: shell CMD (or ! CMD)"
-        print "-- run the shell command CMD and catch output"
-
-    def help_quit(self):
-        print "syntax: quit"
-        print "-- terminates the application"
-
-    def help_help(self):
-        print "syntax: help"
-        print "-- access to the in-line help"
-
-    # Aliases
-
-    do_EOF = do_quit
-    help_EOF = help_quit
-
-
-#===============================================================================
-# 
-#===============================================================================
-class CmdFile(file):
-    """ a class for command input file -in order to debug cmd \n problem"""
-    
-    def __init__(self, name, opt):
-        
-        file.__init__(self, name, 'rU')
-        self.text = file.read(self)
-        self.close()
-        self.lines = self.text.split('\n')
-        print self.lines
-    
-    def readline(self, *arg, **opt):
-        """readline method treating correctly a line whithout \n at the end
-           (add it)
-        """
-        if self.lines:
-            line = self.lines.pop(0)
-        else:
-            return ''
-        
-        if line.endswith('\n'):
-            return line
-        else:
-            return line + '\n'
-
-
-#===============================================================================
-# __main__
-#===============================================================================
-
-if __name__ == '__main__':
-    
-    run_option = sys.argv
-    if len(run_option) > 1:
-        # The first argument of sys.argv is the name of the program
-        input_file = open(run_option[1], 'rU')
-        cmd_line = MadGraphCmd(stdin=input_file)
-        cmd_line.use_rawinput = False #put it in non interactive mode
-        cmd_line.cmdloop()
-    else:
-        # Interactive mode
-        MadGraphCmd().cmdloop()

=== modified file 'madgraph/iolibs/drawing.py'
--- madgraph/iolibs/drawing.py	2010-05-11 13:07:02 +0000
+++ madgraph/iolibs/drawing.py	2010-05-19 07:36:39 +0000
@@ -1861,7 +1861,7 @@
     class DrawingOptionError(Exception):
         """Error raising if an invalid entry is set in a option."""
 
-    def __init__(self, opt={}):
+    def __init__(self, opt=''):
         """Fullfill option with standard value."""
         
         #define default
@@ -1871,8 +1871,14 @@
         self.max_size = 1.5
         self.contract_non_propagating = True
 
-        for key, value in opt.items():
-            self.set(key, value)
+        if isinstance(opt, dict):
+            for key, value in opt.items():
+                self.set(key, value)
+        else:    
+            for value in ['external','add_gap','horizontal','max_size',
+                                                    'contract_non_propagating']:
+                if hasattr(opt, value):
+                    self.set(value, getattr(opt, value))
 
     def set(self, key, value):
         """Check and attribute the given value."""

=== modified file 'madgraph/iolibs/drawing_eps.py'
--- madgraph/iolibs/drawing_eps.py	2010-05-11 13:15:30 +0000
+++ madgraph/iolibs/drawing_eps.py	2010-05-19 07:36:39 +0000
@@ -348,6 +348,7 @@
         # Standard method
         super(MultiEpsDiagramDrawer, self).draw_diagram(diagram, self.block_nb)
         # But keep track how many diagrams are already drawn
+        
         self.block_nb += 1
 
 

=== modified file 'madgraph/iolibs/export_v4.py'
--- madgraph/iolibs/export_v4.py	2010-05-07 13:47:25 +0000
+++ madgraph/iolibs/export_v4.py	2010-05-19 07:36:39 +0000
@@ -51,7 +51,10 @@
         print 'remove old information in %s' % os.path.basename(dir_path)
         old_pos = os.getcwd()
         os.chdir(dir_path)
-        subprocess.call([os.path.join('bin', 'clean_template')])
+        if os.environ.has_key('MADGRAPH_BASE'):
+            subprocess.call([os.path.join('bin', 'clean_template'), '--web'])
+        else:
+            subprocess.call([os.path.join('bin', 'clean_template')])
         os.chdir(old_pos)
         
         #Write version info
@@ -77,6 +80,7 @@
     #But first ensure that coupling are define whithout spaces:
     process_str = process_str.replace(' =', '=')
     process_str = process_str.replace('= ', '=')
+    process_str = process_str.replace(',',' , ')
     #now loop on the element and treat all the coupling
     for info in process_str.split():
         if '=' in info:
@@ -105,7 +109,6 @@
     """call the perl script creating the web interface for MadEvent"""
 
     old_pos = os.getcwd()
-    
     os.chdir(os.path.join(dir_path, 'SubProcesses'))
     P_dir_list = [proc for proc in os.listdir('.') if os.path.isdir(proc) and \
                                                                 proc[0] == 'P']
@@ -115,11 +118,13 @@
         logger.info("Generate jpeg diagrams")
         for Pdir in P_dir_list:
             os.chdir(Pdir)
+            print dir_path
             subprocess.call([os.path.join(dir_path, 'bin', 'gen_jpeg-pl')])
             os.chdir(os.path.pardir)
     
     logger.info("Generate web pages")
     # Create the WebPage using perl script
+
     devnull = os.open(os.devnull, os.O_RDWR)
     subprocess.call([os.path.join(dir_path, 'bin', 'gen_cardhtml-pl')], \
                                                             stdout=devnull)
@@ -131,11 +136,13 @@
                         (name.endswith('.html') or name.endswith('.jpg')) and \
                         name != 'index.html']               
     
-    subprocess.call([os.path.join(dir_path, 'bin', 'gen_cardhtml-pl')])
     if os.path.exists(os.path.join('SubProcesses', 'subproc.mg')):
         if os.path.exists('madevent.tar.gz'):
             os.remove('madevent.tar.gz')
-        subprocess.call(['make'])
+        subprocess.call(['make'], stdout=devnull)
+    
+    
+    subprocess.call([os.path.join(dir_path, 'bin', 'gen_cardhtml-pl')])
     
     #return to the initial dir
     os.chdir(old_pos)               

=== modified file 'madgraph/iolibs/import_v4.py'
--- madgraph/iolibs/import_v4.py	2010-05-07 12:26:00 +0000
+++ madgraph/iolibs/import_v4.py	2010-05-19 07:36:39 +0000
@@ -326,9 +326,11 @@
     reader = ProcCardv4Reader(fsock)
     return reader
 
-
-
-class ProcCardv4Reader():
+class ParticleError(Exception): 
+    """ A class to carch the error"""
+    pass
+
+class ProcCardv4Reader(object):
     """read a proc_card.dat in the mg4 format and creates the equivalent routine
     for mg5"""
     
@@ -343,7 +345,7 @@
                 "# End  MULTIPARTICLES # This is TAG. Do not modify this line\n"
         
     # line pattern (remove comment at the end of the line)
-    pat_line = re.compile(r"""^\s*(?P<info>[^\#]*[\S)])\s*(\#|$)""", re.DOTALL)
+    pat_line = re.compile(r"""^\s*(?P<info>[^\#]*[^\s\#])\s*(\#|$)""", re.DOTALL)
     
     def __init__(self, fsock):
         """init the variable"""
@@ -439,8 +441,7 @@
         lines.append('setup madevent_v4 . -f')
         lines.append('export madevent_v4')
         lines.append('makehtml madevent_v4')
-        lines.append('history %s' % os.path.relpath(
-                os.path.join(self.process_path, 'Cards', 'proc_card_mg5.dat')))
+        lines.append('history .')
         
         return lines
         
@@ -480,7 +481,8 @@
             #Check for infinite loop
             if pos == old_pos:
                 logging.error('Invalid characters: %s' % line[pos:pos + 4])
-                return
+                raise ParticleError('Set of character %s not defined' %
+                                     line[pos:pos + 4])
             old_pos = pos
             # check for pointless character
             if line[pos] in [' ', '\n', '\t']:
@@ -496,7 +498,7 @@
                 
         return out
     
-class ProcessInfo():
+class ProcessInfo(object):
     """This is the basic object for storing process information"""
     
     def __init__(self, line):
@@ -530,10 +532,14 @@
             
 
         # check if we have a MG5 format
+        if line.startswith('/mg5/'):
+            self.line = line[5:]
+            self.is_mg5_valid = True
+            return
         if ',' in line or '=' in line:
             self.is_mg5_valid = True
             return
-            
+
         # extract (S-)forbidden particle
         pos_forbid = line.find('/')
         pos_sforbid = line.find('$')
@@ -573,7 +579,8 @@
         level_content = line.split('>')
         for level, data in enumerate(level_content):
             particles = self.separate_particle(data, particles_name)
-            [self.particles.append((level, name)) for name in particles]
+            if particles:
+                [self.particles.append((level, name)) for name in particles]
             
             
     def treat_decay_chain(self, line, particles_name):

=== modified file 'tests/input_files/v4_proc_card.dat'
--- tests/input_files/v4_proc_card.dat	2010-05-07 12:26:00 +0000
+++ tests/input_files/v4_proc_card.dat	2010-05-19 07:36:39 +0000
@@ -32,8 +32,9 @@
 # Process(es) requested : mg2 input                                  *
 #*********************************************************************
 # Begin PROCESS # This is TAG. Do not modify this line
+#
 
-pp>e-ve~  @1       # First Process
+pp>ve~e-  @1       # First Process
 QCD=99             # Max QCD couplings
 QED=2              # Max QED couplings
 end_coup           # End the couplings input

=== modified file 'tests/test_manager.py'
--- tests/test_manager.py	2010-05-06 19:22:46 +0000
+++ tests/test_manager.py	2010-05-19 07:36:39 +0000
@@ -43,8 +43,23 @@
 #sys.path.append(root_path)
 
 root_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
-
 sys.path.append(root_path)
+
+
+#position of MG_ME
+MGME_dir = None
+MGME_dir_possibility = [os.path.join(root_path, os.path.pardir),
+                os.path.join(os.getcwd(), os.path.pardir),
+                os.getcwd()]
+
+for position in MGME_dir_possibility:
+    if os.path.exists(os.path.join(position, 'MGMEVersion.txt')) and \
+                    os.path.exists(os.path.join(position, 'UpdateNotes.txt')):
+        MGME_dir = os.path.realpath(position)
+        break
+del MGME_dir_possibility
+
+
 #===============================================================================
 # run
 #===============================================================================
@@ -122,10 +137,11 @@
             self.go_to_root()
 
 
-        for name in os.listdir(directory):
+        for name in os.listdir(os.path.join(root_path,directory)):
             local_check = checking
 
-            status = self.status_file(directory + '/' + name)
+            status = self.status_file(os.path.join(root_path, directory,name))
+                                      #directory + '/' + name)
             if status is None:
                 continue
 
@@ -228,11 +244,11 @@
     @staticmethod
     def status_file(name):
         """ check if a name is a module/a python file and return the status """
-        if os.path.isfile(name):
+        if os.path.isfile(os.path.join(root_path, name)):
             if name.endswith('.py') and '__init__' not in name:
                 return 'file'
-        elif os.path.isdir(name):
-            if os.path.isfile(name + '/__init__.py'):
+        elif os.path.isdir(os.path.join(root_path, name)):
+            if os.path.isfile(os.path.join(root_path, name , '__init__.py')):
                 return 'module'
 
     @classmethod
@@ -317,7 +333,8 @@
         where is launched
         """
         self.launch_pos = os.path.realpath(os.getcwd())
-        os.chdir(root_path)
+        self.root_path = root_path
+        #os.chdir(root_path)
 
     def go_to_initpos(self):
         """ 

=== added file 'tests/unit_tests/interface/test_cmd.py'
--- tests/unit_tests/interface/test_cmd.py	1970-01-01 00:00:00 +0000
+++ tests/unit_tests/interface/test_cmd.py	2010-05-19 07:36:39 +0000
@@ -0,0 +1,137 @@
+################################################################################
+#
+# 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 unittest
+import os
+import shutil
+
+import madgraph.interface.cmd_interface as Cmd
+_file_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
+
+_pickle_path =os.path.join(_file_path, os.pardir, 'input_files')
+                                    
+
+#===============================================================================
+# TestCmd
+#===============================================================================
+class TestCmdShell1(unittest.TestCase):
+    """this treats all the command not related to MG_ME"""
+
+    def setUp(self):
+        """ basic building of the class to test """
+        
+        self.cmd = Cmd.MadGraphCmdShell()
+           
+    
+    def do(self, line):
+        """ exec a line in the cmd under test """        
+        self.cmd.exec_cmd(line)
+        
+    def test_generate(self):
+        """command 'generate' works"""
+    
+        self.do('load model %s' % os.path.join(_pickle_path, 'sm.pkl'))
+        self.do('generate e+ e- > e+ e-')
+        self.assertTrue(self.cmd._curr_amps)
+        self.do('define P Z u')
+        self.do('add process e+ e- > P')
+        self.assertEqual(len(self.cmd._curr_amps), 2)
+        self.do('add process mu+ mu- > P, Z>mu+mu-')
+        self.assertEqual(len(self.cmd._curr_amps), 3)
+
+    def test_draw(self):
+        """ command 'draw' works """
+        
+        self.do('import model_v4 %s' % os.path.join(_pickle_path, \
+                                                          'v4_sm_particles.dat'))
+        self.do('import model_v4 %s' % os.path.join(_pickle_path, \
+                                                       'v4_sm_interactions.dat'))      
+        self.do('load processes %s' % os.path.join(_pickle_path,'e+e-_e+e-.pkl'))
+        self.do('draw .')
+        self.assertTrue(os.path.exists('diagrams_0_e+e-_e+e-.eps'))
+        os.remove('diagrams_0_e+e-_e+e-.eps')
+        
+        self.do('generate g g > g g')
+        self.do('draw .')
+        self.assertTrue(os.path.exists('diagrams_0_gg_gg.eps'))
+        os.remove('diagrams_0_gg_gg.eps')
+
+
+class TestCmdShell2(unittest.TestCase):
+    """The TestCase class for the test the FeynmanLine"""
+
+    def setUp(self):
+        """ basic building of the class to test """
+        
+        
+        self.cmd = Cmd.MadGraphCmdShell()
+        try:
+            self.out_dir = os.path.join(Cmd.MGME_dir, 'AUTO_TEST_MG5')
+        except:
+            raise Exception, 'NO MG_ME dir for this test'   
+        self.do('import model_v4 sm')
+        
+        
+    def tearDown(self):
+        """ basic destruction after have run """
+        if os.path.exists(self.out_dir):
+            shutil.rmtree(self.out_dir)
+
+    def do(self, line):
+        """ exec a line in the cmd under test """        
+        self.cmd.exec_cmd(line)
+    
+    
+    def test_standard_chain(self):
+        """ command 'setup' works with path"""
+        
+
+        self.do('load processes %s' % os.path.join(_pickle_path,'e+e-_e+e-.pkl'))
+        self.do('setup madevent_v4 %s' % self.out_dir)
+        self.assertTrue(os.path.exists(self.out_dir))
+        self.do('export madevent_v4')
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                               'SubProcesses', 'P0_e+e-_e+e-')))
+        self.do('history .')
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                                 'Cards', 'proc_card_mg5.dat')))
+                
+    def test_chain2(self):
+        """ command 'setup' works with '.' """
+        os.system('cp -rf %s %s' % (os.path.join(Cmd.MGME_dir,'Template'),
+                                    self.out_dir))
+        os.system('cp -rf %s %s' % (
+                            os.path.join(_pickle_path,'simple_v4_proc_card.dat'),
+                            os.path.join(self.out_dir,'Cards','proc_card.dat')))
+        
+        self.do('import proc_v4 %s' % os.path.join(self.out_dir,
+                                                       'Cards','proc_card.dat'))
+
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                              'SubProcesses', 'P1_e-e+_vevex')))
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                                 'Cards', 'proc_card_mg5.dat')))
+
+
+    def test_chain3(self):
+        """ command 'setup' works with '.' """
+
+        self.do('setup madevent_v4 %s' % self.out_dir)
+        self.do('import proc_v4 %s' % os.path.join(_pickle_path, \
+                                                     'simple_v4_proc_card.dat'))
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                              'SubProcesses', 'P1_e-e+_vevex')))        
+        self.assertTrue(os.path.exists(os.path.join(self.out_dir,
+                                                 'Cards', 'proc_card_mg5.dat')))
+

=== modified file 'tests/unit_tests/iolibs/test_drawing.py'
--- tests/unit_tests/iolibs/test_drawing.py	2010-05-11 13:07:02 +0000
+++ tests/unit_tests/iolibs/test_drawing.py	2010-05-19 07:36:39 +0000
@@ -1005,7 +1005,6 @@
         x_position = [1 / 3, 1 / 3, 2 / 3, 1 / 3, 0.0, 2 / 3, 0.0, 2 / 3, 1.0, 1.0]
         y_position = [1 / 6, 5 / 6, 1 / 2, 1 / 2, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0]
 
-
         for i in range(0, 10):
             self.assertEquals(self.mix_drawing.vertexList[i].level, \
                               level[i])

=== modified file 'tests/unit_tests/iolibs/test_import_v4.py'
--- tests/unit_tests/iolibs/test_import_v4.py	2010-05-07 13:47:25 +0000
+++ tests/unit_tests/iolibs/test_import_v4.py	2010-05-19 07:36:39 +0000
@@ -266,7 +266,6 @@
         #the initialization is done in the setUp subroutine
         
         proccard = self.proccard
-        
         self.assertEqual(len(proccard.process), 8)
         self.assertEqual(proccard.model, 'sm')
         self.assertEqual(len(proccard.multipart), 6)
@@ -283,7 +282,7 @@
                    'define l- e- mu-', 
                    'define vl ve vm', 
                    'define vl~ ve~ vm~', 
-                   'generate p p > e- ve~ @1 ', 
+                   'generate p p > ve~ e- @1 ', 
                    'add process p p > z @2 , (z > w+ w- , w- > mu- vm  ) ',
                    'add process p p > t t~ $ a QED=0 @3 ', 
                    'add process p p > t t~ $ g / a QED=0 @2 ', 
@@ -294,7 +293,8 @@
                    'setup madevent_v4 . -f', 
                    'export madevent_v4', 
                    'makehtml madevent_v4', 
-                   'history tests/Cards/proc_card_mg5.dat']    
+                   'history .'] 
+  
         self.assertEqual(len(lines),len(solution))
         for i,command in enumerate(lines):
             self.assertEqual(command,solution[i])