Merge lp:~maddm/mg5amcnlo/maddm_dev2 into lp:~mg5core1/mg5amcnlo/2.6.2

[Olivier Mattelaer]

Change to increase plugin flexibility
this include
1) improve the tutorial capabilities
2) refactor the question about the card edition to have it more manageable
3) more possiblity for help message
4) possibility to control an entry of the cards to check that they are in an allowed range
5) allow --loop_filter for loop-induced [should have done that directly in 2.6.2 but ok]
6) New possibility for handling the RunWeb file (both via context manager or decorator)
   -> before crashing it checks if the associated pid is still running.
   -> use context manager for LO but NOT for gridpack/NLO.
7) fix some issue with add model (for some NLO model)
8) add "update to_full" to display all hidden options of the run_card

[Olivier Mattelaer (olivier-mattelaer)]

made a quick look and found three stuff to change (see below)

[lp:~maddm/mg5amcnlo/maddm_dev2]

380. By olivier-mattelaer on 2018-03-28

allow plugin to have control on detect_card + better handling of the edit/add functionality

381. By olivier-mattelaer on 2018-03-28

refactoring to allow the plugin to define itself how the pdg of the <init> block should be written

382. By olivier-mattelaer on 2018-03-28

add hidden syntax import model --last: loading last modified model

383. By olivier-mattelaer on 2018-03-29

add a clean_process function to ease the job of plugin function

384. By olivier-mattelaer on 2018-03-29

fixing issue with re-weighting when doing rewgt from two different process directory

385. By olivier-mattelaer on 2018-03-30

1) set new runweb handling for file ./bin/madevent
2) better fix for t-channel
3) fix issue for set lep 1.2 (avoid the crash)

386. By olivier-mattelaer on 2018-03-30

forbids install maddm for the temporary release

387. By olivier-mattelaer on 2018-03-30

correct date

388. By olivier-mattelaer on 2018-03-30

fixing issue with version

389. By olivier-mattelaer on 2018-04-02

fix an issue with NLO model

390. By olivier-mattelaer on 2018-04-02

remove pointless printout

391. By olivier-mattelaer on 2018-04-02

UPdate note

392. By olivier-mattelaer on 2018-04-13

small change for the installer

393. By olivier-mattelaer on 2018-04-13

revert release creation script + improve install

394. By olivier-mattelaer on 2018-04-20

comment from the review

395. By olivier-mattelaer on 2018-04-20

improve UpdateNotes and merge with lastest 2.6.2

=== modified file 'MadSpin/decay.py'
--- MadSpin/decay.py	2018-02-05 12:41:25 +0000
+++ MadSpin/decay.py	2018-04-20 08:32:43 +0000
@@ -3848,7 +3848,7 @@
                     min_br = min([m['total_br'] for m in self.all_ME.values()])
                     logger.info('''All production process does not have the same total Branching Ratio.
                     Therefore the total number of events after decay will be lower than the original file.
-                    [max_br = %s, min_br = %s]''' % (max_br, min_br),'$MG:color:BLACK')
+                    [max_br = %s, min_br = %s]''' % (max_br, min_br),'$MG:BOLD')
                 fake_decay = {'br': max_br - production['total_br'], 
                               'path': None, 'matrix_element': None, 
                               'finals': None, 'base_order': None,

=== modified file 'MadSpin/interface_madspin.py'
--- MadSpin/interface_madspin.py	2018-02-21 17:03:42 +0000
+++ MadSpin/interface_madspin.py	2018-04-20 08:32:43 +0000
@@ -1022,6 +1022,7 @@
                     
                     run_card["iseed"] = self.seed
                     run_card['gridpack'] = True
+                    run_card['systematics_program'] = 'False'
                     run_card['use_syst'] = False
                     run_card.write(pjoin(decay_dir, "Cards", "run_card.dat"))
                     param_card = self.banner['slha']

=== modified file 'Template/LO/Cards/run_card.dat'
--- Template/LO/Cards/run_card.dat	2017-11-18 00:45:31 +0000
+++ Template/LO/Cards/run_card.dat	2018-04-20 08:32:43 +0000
@@ -10,6 +10,9 @@
 #   Lines starting with a '# ' are info or comments                  *
 #                                                                    *
 #   mind the format:   value    = variable     ! comment             *
+#                                                                    *
+#   To display more options, you can type the command:               *
+*      update full_run_card                                          *
 #*********************************************************************
 #
 #*******************                                                 

=== modified file 'Template/LO/SubProcesses/genps.f'
--- Template/LO/SubProcesses/genps.f	2017-08-09 12:56:57 +0000
+++ Template/LO/SubProcesses/genps.f	2018-04-20 08:32:43 +0000
@@ -863,21 +863,20 @@
 
 c         write(*,*) 'tmin, tmax',tmin,tmax
 
-         tmax = max(tmax,0d0) !This line if want really t freedom
+      if (tmax.gt.-0.01.and.tmin.lt.-0.02)then
+c         set tmax to 0. The idea is to be sure to be able to hit zero
+c         and not to be block by numerical inacuracy
+c         tmax = max(tmax,0d0) !This line if want really t freedom
+         call sample_get_x(wgt,x(-ibranch),-ibranch,iconfig,
+     $        0, -tmin/stot)
+         t = stot*(-x(-ibranch))
 
+      else
          call sample_get_x(wgt,x(-ibranch),-ibranch,iconfig,
      $        -tmax/stot, -tmin/stot)
          t = stot*(-x(-ibranch))
-c
-c     now reset tmax if messed it up for t freedom 3 lines above
-c
-         call yminmax(s1,t,m12,ma2,mb2,mn2,tmin,tmax) 
+      endif
 
-c         write(*,*) tmin,t,tmax
-c         if (t .eq. 0d0) then
-c            jac = -3
-c            return
-c         endif
          if (t .lt. tmin .or. t .gt. tmax) then
             jac=-3d0
             return

=== modified file 'Template/LO/SubProcesses/setcuts.f'
--- Template/LO/SubProcesses/setcuts.f	2018-02-23 15:30:14 +0000
+++ Template/LO/SubProcesses/setcuts.f	2018-04-20 08:32:43 +0000
@@ -138,8 +138,10 @@
             lpp(2)=0
             ebeam(1)=pmass(1)/2d0
             ebeam(2)=pmass(1)/2d0
-            scale=pmass(1)
-            fixed_ren_scale=.true.
+            if (.not.fixed_ren_scale)then
+               scale=pmass(1)
+               fixed_ren_scale=.true.
+            endif
             fixed_fac_scale=.true.
             use_syst=.false.
          endif

=== modified file 'Template/LO/bin/generate_events'
--- Template/LO/bin/generate_events	2015-10-24 19:53:10 +0000
+++ Template/LO/bin/generate_events	2018-04-20 08:32:43 +0000
@@ -33,7 +33,6 @@
 
 # Check if optimize mode is (and should be) activated
 if __debug__ and (not os.path.exists(pjoin(root_path,'../..', 'bin','create_release.py'))):
-    print 'launch in debug mode'
     subprocess.call([sys.executable] + ['-O'] + sys.argv)
     sys.exit()
 
@@ -146,18 +145,22 @@
     # Check that python version is valid
 
     set_configuration()
-    argument = sys.argv
+    argument = sys.argv    
     try:
         if '-h' in argument or '--help' in argument:
-            launch = ME.MadEventCmdShell(me_dir=root_path)
+            launch = ME.MadEventCmdShell(me_dir=root_path, force_run=True)
             launch.exec_cmd('help generate_events')
             sys.exit()
         elif len(argument) > 1 and argument[1] in ['0', '1', '2']:
             argument = treat_old_argument(argument)
         
-        launch = ME.MadEventCmdShell(me_dir=root_path)
-        launch.run_cmd('generate_events %s' % ' '.join(argument[1:]))
-        launch.run_cmd('quit')
+        with ME.MadEventCmdShell.RunWebHandling(root_path, ):
+            launch = ME.MadEventCmdShell(me_dir=root_path, force_run=True)
+            launch.run_cmd('generate_events %s' % ' '.join(argument[1:]))
+            launch.run_cmd('quit')
+    except ME.MadEventAlreadyRunning, message:
+        logging.getLogger('madgraph').log(40, str(message))
+        sys.exit(1)
     except KeyboardInterrupt:
         try:
             launch.run_cmd('quit')
@@ -166,9 +169,6 @@
     except Exception, error:
         logging.error(str(error))
         sys.exit()
-                          
-    if os.path.exists(pjoin(root_path, 'RunWeb')):  
-        os.remove(pjoin(root_path, 'RunWeb'))      
             
     # reconfigure path for the web 
     #if len(argument) == 5:

=== modified file 'Template/LO/bin/madevent'
--- Template/LO/bin/madevent	2016-04-25 14:02:24 +0000
+++ Template/LO/bin/madevent	2018-04-20 08:32:43 +0000
@@ -146,53 +146,58 @@
 
 # Call the cmd interface main loop
 try:
-    if (args and os.path.isfile(args[0])):
-        # They are an input file 
-        input_file = args[0]
-        if options.web:
-            cmd_line = cmd_interface.MadEventCmd()
-            cmd_line.debug_output = os.path.join(os.path.dirname(input_file),'generation.log')
-            cmd_line.use_rawinput = False
-            cmd_line.haspiping = False
-            cmd_line.run_cmd('import command ' + input_file)
-            cmd_line.run_cmd('quit')      
-        else:
-            cmd_line = cmd_interface.MadEventCmdShell()
-            cmd_line.use_rawinput = False
-            cmd_line.haspiping = False
-            cmd_line.run_cmd('import command ' + input_file)
-            cmd_line.run_cmd('quit')
-    elif args:
-        # a single command is provided
-        if options.web:
-            cmd_line = cmd_interface.MadEventCmd()
-        else:
-            cmd_line = cmd_interface.MadEventCmdShell()
-        if not hasattr(cmd_line, 'do_%s' % args[0]):
-            if parser_error:
-                print parser_error
-                print 'and %s  can not be interpreted as a valid command.' % args[0]
-            else:
-                print 'ERROR: %s  not a valid command. Please retry' % args[0]
-        else:
-            cmd_line.use_rawinput = False    
-            cmd_line.run_cmd(' '.join(args))
-            cmd_line.run_cmd('quit')
-    else:
-        # Interactive mode
-        if options.web:
-            cmd_line = cmd_interface.MadEventCmd()
-            cmd_line.cmdloop()
-        else:
-            cmd_line = cmd_interface.MadEventCmdShell()
-            cmd_line.cmdloop()
-            
+    if '-h' in args or '--help' in args:
+        launch = ME.MadEventCmdShell(me_dir=os.path.dirname(root_path), force_run=True)
+        launch.exec_cmd('help generate_events')
+        sys.exit(0)
+    with cmd_interface.MadEventCmdShell.RunWebHandling(os.path.dirname(root_path), ):
+        if (args and os.path.isfile(args[0])):
+            # They are an input file 
+            input_file = args[0]
+            if options.web:
+                cmd_line = cmd_interface.MadEventCmd(force_run=True)
+                cmd_line.debug_output = os.path.join(os.path.dirname(input_file),'generation.log')
+                cmd_line.use_rawinput = False
+                cmd_line.haspiping = False
+                cmd_line.run_cmd('import command ' + input_file)
+                cmd_line.run_cmd('quit')      
+            else:
+                cmd_line = cmd_interface.MadEventCmdShell(force_run=True)
+                cmd_line.use_rawinput = False
+                cmd_line.haspiping = False
+                cmd_line.run_cmd('import command ' + input_file)
+                cmd_line.run_cmd('quit')
+        elif args:
+            # a single command is provided
+            if options.web:
+                cmd_line = cmd_interface.MadEventCmd(force_run=True)
+            else:
+                cmd_line = cmd_interface.MadEventCmdShell(force_run=True)
+            if not hasattr(cmd_line, 'do_%s' % args[0]):
+                if parser_error:
+                    print parser_error
+                    print 'and %s  can not be interpreted as a valid command.' % args[0]
+                else:
+                    print 'ERROR: %s  not a valid command. Please retry' % args[0]
+            else:
+                cmd_line.use_rawinput = False    
+                cmd_line.run_cmd(' '.join(args))
+                cmd_line.run_cmd('quit')
+        else:
+            # Interactive mode
+            if options.web:
+                cmd_line = cmd_interface.MadEventCmd(force_run=True)
+                cmd_line.cmdloop()
+            else:
+                cmd_line = cmd_interface.MadEventCmdShell(force_run=True)
+                cmd_line.cmdloop()
 except KeyboardInterrupt:
     print 'writting history and directory and quit on KeyboardInterrupt' 
     pass
 except cmd_interface.MadEventAlreadyRunning, error:
     logging.error(str(error))
-    sys.exit()
+    sys.exit(1)
+
 try: 
     readline.set_history_length(100)
     if not os.path.exists(os.path.join(os.environ['HOME'], '.mg5')):
@@ -208,8 +213,8 @@
     pass
 
 
-try:
-    # Remove lock file
-    os.remove(os.path.join(root_path,os.pardir, 'RunWeb'))
-except:
-    pass
+#try:
+#    # Remove lock file
+#    os.remove(os.path.join(root_path,os.pardir, 'RunWeb'))
+#except:
+#    pass

=== modified file 'Template/NLO/Cards/run_card.dat'
--- Template/NLO/Cards/run_card.dat	2017-11-17 16:07:39 +0000
+++ Template/NLO/Cards/run_card.dat	2018-04-20 08:32:43 +0000
@@ -13,6 +13,9 @@
 #                                                                      *
 #   Some of the values of variables can be list. These can either be   *
 #   comma or space separated.                                          *
+#                                                                      *
+#   To display additional parameter, you can use the command:          *
+#      update to_full                                                  *
 #***********************************************************************
 #
 #*******************                                                 

=== modified file 'UpdateNotes.txt'
--- UpdateNotes.txt	2018-04-03 15:01:12 +0000
+++ UpdateNotes.txt	2018-04-20 08:32:43 +0000
@@ -1,10 +1,18 @@
 Update notes for MadGraph5_aMC@NLO (in reverse time order)
 
-2.6.2 ()
+
+2.6.2.beta (30-04-02)
       OM: Fix issue with madspin introduced in 2.6.1 (failing to generate correct diagram for NLO process)
+      OM: introduce "update to_full" command to display all the hidden parameter
+      OM: improve handling of (some) run_card parameter:
+            - add comment that can be displayed via "help NAME"
+            - add autocompletion for some parameter
+            - add direct rejection of parameter edition if not in some allowed list/range
       OM: add the value of all the widths in Auto-width in the scan summary file
       OM: fix crash in 1>N reweighting
       RF: Fixed an issue where too many files were opened for fNLO runs in rare cases
+      OM: For 1>N, if the user set fixed_run_scale to True, then the scale is choose accordingly
+          and not following the mass of the inital state anymore
       RF: For the HwU histograms, if no gnuplot installation is found, write the gnuplot scripts in v5
           format (instead of the very old v4 format).
       RF+MZ: Fixed a problem with (f)NLO(+PS) runs in case the Born has identical QCD-charged
@@ -18,8 +26,13 @@
       RF: Fixed a bug for ApplGrid: in rare cases the ApplGrid tables were filled twice for the same event
       OM: Fixed a bug for fixed target experiment when the energy of the beam was set to 0.
       RF: Fixed an issue with the computation of (partial) decay width processes at NLO.
+      OM: loop-filter commands are now working for loop-induced processes
+      OM: New  method avoiding that two process are running inside the same output directory.
+          This is implemented only for Gridpack and LO run so far. 
+          The new method should be more robust in case of crash (i.e. not wrongly trigger as before)
 
 2.6.1 (12/12/17)
+
       RF+MZ: It is now possible to add LO matrix elements (with [LOonly]) 
              to Fx-Fx merged samples. Thanks to Josh Bendavid for testing.
       OM: Re-factoring the code asking which program to use (both at LO and NLO)

=== modified file 'VERSION'
--- VERSION	2017-12-12 21:11:08 +0000
+++ VERSION	2018-04-20 08:32:43 +0000
@@ -1,5 +1,5 @@
-version = 2.6.1
-date = 2017-12-12
+version = 2.6.2.beta
+date = 2018-04-02
 
 
 

=== modified file 'madgraph/core/base_objects.py'
--- madgraph/core/base_objects.py	2018-02-28 14:10:19 +0000
+++ madgraph/core/base_objects.py	2018-04-20 08:32:43 +0000
@@ -2972,8 +2972,10 @@
         the user-defined list of orders, it can be ommitted for some info
         displays."""
 
-        if prefix:
+        if isinstance(prefix, bool):
             mystr = " " * indent + "Process: "
+        elif isinstance(prefix, str):
+            mystr = prefix
         else:
             mystr = ""
         prevleg = None
@@ -3354,10 +3356,14 @@
     def get_initial_pdg(self, number):
         """Return the pdg codes for initial state particles for beam number"""
 
-        return filter(lambda leg: leg.get('state') == False and\
+        legs = filter(lambda leg: leg.get('state') == False and\
                        leg.get('number') == number,
-                       self.get('legs'))[0].get('id')
-
+                       self.get('legs'))
+        if not legs:
+            return None
+        else:
+            return legs[0].get('id')
+        
     def get_initial_final_ids(self):
         """return a tuple of two tuple containing the id of the initial/final
            state particles. Each list is ordered"""

=== modified file 'madgraph/interface/.mg5_logging.conf'
--- madgraph/interface/.mg5_logging.conf	2013-11-27 17:25:48 +0000
+++ madgraph/interface/.mg5_logging.conf	2018-04-20 08:32:43 +0000
@@ -1,11 +1,11 @@
 [formatters]
-keys: cmdprint,simple,madgraph
+keys: cmdprint,simple,madgraph,tutorial
 
 [handlers]
 keys: cmdprint,root,madgraph,fatalerror,tutorial,tutorial_aMCatNLO,tutorial_MadLoop,decay,cmdprint2
 
 [loggers]
-keys: root,cmdprint,madgraph,fatalerror,tutorial,tutorial,tutorial_aMCatNLO,tutorial_MadLoop,madevent,amcatnlo,decay,cmdprint2
+keys: root,cmdprint,madgraph,fatalerror,tutorial,tutorial,tutorial_aMCatNLO,tutorial_MadLoop,madevent,amcatnlo,decay,cmdprint2,tutorial_plugin
 
 
 [formatter_cmdprint]
@@ -20,6 +20,10 @@
 class: logging.ColorFormatter
 format: $COLOR%(levelname)s: %(message)s $RESET
 
+[formatter_tutorial]
+class: logging.ColorFormatter
+format:  $_BOLD========== Tutorial ==========$_RESET$BR$COLOR%(message)s $RESET$BR$_BOLD========== Tutorial ==========$_RESET
+
 [handler_cmdprint]
 class: StreamHandler
 args: [sys.stdout]
@@ -38,7 +42,7 @@
 [handler_tutorial]
 class: StreamHandler
 args: [sys.stdout]
-formatter: simple
+formatter: tutorial
 
 [handler_tutorial_aMCatNLO]
 class: StreamHandler
@@ -122,6 +126,12 @@
 qualname=tutorial
 propagate=0
 
+[logger_tutorial_plugin]
+level : ERROR
+handlers: tutorial
+qualname=tutorial_plugin
+propagate=0
+
 [logger_tutorial_MadLoop]
 level : ERROR
 handlers: tutorial_MadLoop

=== modified file 'madgraph/interface/amcatnlo_run_interface.py'
--- madgraph/interface/amcatnlo_run_interface.py	2018-02-07 21:30:27 +0000
+++ madgraph/interface/amcatnlo_run_interface.py	2018-04-20 08:32:43 +0000
@@ -1729,7 +1729,7 @@
             param_card_iterator.write(pjoin(self.me_dir,'Cards','param_card.dat'))
             name = misc.get_scan_name(orig_name, self.run_name)
             path = pjoin(self.me_dir, 'Events','scan_%s.txt' % name)
-            logger.info("write all cross-section results in %s" % path, '$MG:color:BLACK')
+            logger.info("write all cross-section results in %s" % path, '$MG:BOLD')
             param_card_iterator.write_summary(path)
             
         if self.allow_notification_center:    
@@ -5187,7 +5187,7 @@
         """read and parse the test_ME/MC.log file"""
         content = open(log).read()
         if 'FAILED' in content:
-            logger.info('Output of the failing test:\n'+content[:-1],'$MG:color:BLACK')
+            logger.info('Output of the failing test:\n'+content[:-1],'$MG:BOLD')
             raise aMCatNLOError('Some tests failed, run cannot continue.\n' + \
                 'Please check that widths of final state particles (e.g. top) have been' + \
                 ' set to 0 in the param_card.dat.')
@@ -5310,7 +5310,7 @@
             else:
                 logger.info("""Your Parton-shower choice is not available for running.
     The events will be generated for the  associated Parton-Shower.
-    Remember that NLO events without showering are NOT physical.""", '$MG:color:BLACK')           
+    Remember that NLO events without showering are NOT physical.""", '$MG:BOLD')           
 
         
         # specify the cards which are needed for this run.

=== modified file 'madgraph/interface/coloring_logging.py'
--- madgraph/interface/coloring_logging.py	2016-02-19 13:21:31 +0000
+++ madgraph/interface/coloring_logging.py	2018-04-20 08:32:43 +0000
@@ -1,6 +1,7 @@
 import logging
 # method to add color to a logging.info add a second argument:
-# '$MG:color:BLACK'
+# '$MG:BOLD'
+# '$MG:color:RED'
 
 
 BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
@@ -31,7 +32,7 @@
 class ColorFormatter(logging.Formatter):
 
     def __init__(self, *args, **kwargs):
-        # can't do super(...) here because Formatter is an old school class
+        # can't do super(...) here because Formatter is an old school class)
         logging.Formatter.__init__(self, *args, **kwargs)
 
     def format(self, record):
@@ -44,6 +45,7 @@
         # A not-so-nice but working way of passing arguments to this formatter
         # from MadGraph.
         color_specified = False
+        bold_specified = False
         for arg in record.args:
             if isinstance(arg,str) and arg.startswith('$MG'):
                 elems=arg.split(':')
@@ -53,12 +55,26 @@
                         color_choice = COLORS[elems[2]]
                     if color_choice == 0:
                         color_choice = 30
+                if len(elems)==2 and elems[1].lower()=='bold':
+                    bold_specified = True
             else:
                 new_args.append(arg)
+        
+
         record.args = tuple(new_args)
-        color     = COLOR_SEQ % (30 + color_choice)
+        if bold_specified:
+            color = BOLD_SEQ
+            color_specified = True
+        else:
+            color     = COLOR_SEQ % (30 + color_choice)
         message   = logging.Formatter.format(self, record)
-        if not message.endswith('$RESET'):
+        if not message:
+            return message
+        # if some need to be applied no matter what:
+        message = message.replace('$_BOLD', BOLD_SEQ).replace('$_RESET', RESET_SEQ).replace('$BR','\n')
+        
+        # for the conditional one
+        if '$RESET' not in message:
             message +=  '$RESET'
         for k,v in COLORS.items():
             color_flag = COLOR_SEQ % (v+30)

=== modified file 'madgraph/interface/common_run_interface.py'
--- madgraph/interface/common_run_interface.py	2018-03-28 20:42:08 +0000
+++ madgraph/interface/common_run_interface.py	2018-04-20 08:32:43 +0000
@@ -21,6 +21,7 @@
 
 import ast
 import logging
+import math
 import os
 import re
 import shutil
@@ -485,6 +486,12 @@
             args.remove('-from_cards')
             opts.append('-from_cards')
 
+        if any(t.startswith('--plugin=') for t in args):
+            plugin = [t  for t in args if t.startswith('--plugin')][0]
+            args.remove(plugin)
+            opts.append(plugin)
+            
+
         if len(args) == 0:
             if self.run_name:
                 args.insert(0, self.run_name)
@@ -501,6 +508,7 @@
 
         args += opts
 
+
     def check_check_events(self,args):
         """Check the argument for decay_events command
         syntax is "decay_events [NAME]"
@@ -611,6 +619,7 @@
         """common"""
 
         self.force_run = False # this flag force the run even if RunWeb is present
+        self.stop_for_runweb = False # this flag indicates if we stop this run because of RunWeb. 
         if 'force_run' in opts and opts['force_run']:
             self.force_run = True
             del opts['force_run']
@@ -641,6 +650,7 @@
                 (for this exact same directory) Please wait that this is instance is 
                 closed. If no instance is running, you can delete the file
                 %s and try again.''' % pjoin(me_dir,'RunWeb')
+                self.stop_for_runweb = True
                 raise AlreadyRunning, message
             else:
                 self.write_RunWeb(me_dir)
@@ -677,12 +687,82 @@
 
 
     def write_RunWeb(self, me_dir):
+        self.writeRunWeb(me_dir)
+        self.gen_card_html()
+
+    @staticmethod
+    def writeRunWeb(me_dir):
         pid = os.getpid()
         fsock = open(pjoin(me_dir,'RunWeb'),'w')
         fsock.write(`pid`)
-        fsock.close()
-        self.gen_card_html()
-
+        fsock.close()        
+        
+    class RunWebHandling(object):
+        
+        def __init__(self, me_dir, crashifpresent=True, warnifpresent=True):
+            """raise error if RunWeb already exists
+            me_dir is the directory where the write RunWeb"""
+            
+            self.remove_run_web = True
+            self.me_dir = me_dir
+            
+            if crashifpresent or warnifpresent:
+                if os.path.exists(pjoin(me_dir, 'RunWeb')):
+                    pid = open(pjoin(me_dir, 'RunWeb')).read()
+                    try:
+                        pid = int(pid)
+                    except Exception:
+                        pid = "unknown"
+                    
+                    if pid == 'unknown' or misc.pid_exists(pid):
+                        # bad situation 
+                        if crashifpresent:
+                            if isinstance(crashifpresent, Exception):
+                                raise crashifpresent
+                            else:
+                                message = '''Another instance of the program is currently running (pid = %s).
+                (for this exact same directory). Please wait that this is instance is 
+                closed. If no instance is running, you can delete the file
+                %s and try again.''' % (pid, pjoin(me_dir, 'RunWeb'))
+                                raise AlreadyRunning, message
+                        elif warnifpresent:
+                            if isinstance( warnifpresent, bool):
+                                logger.warning("%s/RunWeb is present. Please check that only one run is running in that directory.")
+                            else:
+                                logger.log(warnifpresent, "%s/RunWeb is present. Please check that only one run is running in that directory.")
+                            self.remove_run_web = False
+                    else:
+                        logger.debug('RunWeb exists but no associated process. Will Ignore it!')
+                    return
+            
+            # write RunWeb
+            
+            CommonRunCmd.writeRunWeb(me_dir)
+            
+        def __enter__(self):
+            return
+        
+        def __exit__(self,exc_type, exc_value, traceback):
+            
+            if self.remove_run_web:
+                try:
+                    os.remove(pjoin(self.me_dir,'RunWeb'))
+                except Exception:
+                    if os.path.exists(pjoin(self.me_dir,'RunWeb')):
+                        logger.warning('fail to remove: %s' % pjoin(self.me_dir,'RunWeb'))
+            return
+
+        def __call__(self, f):
+            """allow to use this as decorator as well"""
+            def wrapper(*args, **kw):
+                with self:
+                    return f(*args, **kw)
+            return wrapper        
+
+        
+            
+            
+            
     ############################################################################
     def split_arg(self, line, error=False):
         """split argument and remove run_options"""
@@ -887,6 +967,16 @@
 
         self.ask_edit_card_static(cards, mode, plot, self.options['timeout'],
                                   self.ask, first_cmd=first_cmd)
+        
+        for c in cards:
+            if not os.path.isabs(c):
+                c = pjoin(self.me_dir, c) 
+            if not os.path.exists(c):
+                default = c.replace('dat', '_default.dat')
+                if os.path.exists(default):
+                    files.cp(default, c)
+            
+                
 
     @staticmethod
     def ask_edit_card_static(cards, mode='fixed', plot=True,
@@ -950,6 +1040,7 @@
                               path_msg='enter path', ask_class = AskforEditCard,
                               cards=cards, mode=mode, **opt)
 
+
     @staticmethod
     def detect_card_type(path):
         """detect the type of the card. Return value are
@@ -1212,7 +1303,7 @@
         else:
             PY8_plots_root_path = pjoin(self.me_dir,'HTML',
                                                self.run_name,'%s_PY8_plots'%tag)
-            
+        
         if 'ickkw' in self.run_card:
             if int(self.run_card['ickkw']) and mode == 'Pythia':
                 self.update_status('Create matching plots for Pythia', level='pythia')
@@ -1473,12 +1564,12 @@
     ############################################################################
     def help_systematics(self):
         """help for systematics command"""
-        logger.info("syntax: systematics RUN_NAME [OUTPUT] [options]",'$MG:color:BLACK')
+        logger.info("syntax: systematics RUN_NAME [OUTPUT] [options]",'$MG:BOLD')
         logger.info("-- Run the systematics run on the RUN_NAME run.")
         logger.info("   RUN_NAME can be a path to a lhef file.")
         logger.info("   OUTPUT can be the path to the output lhe file, otherwise the input file will be overwritten") 
         logger.info("")
-        logger.info("options: (values written are the default)", '$MG:color:BLACK')
+        logger.info("options: (values written are the default)", '$MG:BOLD')
         logger.info("")
         logger.info("   --mur=0.5,1,2     # specify the values for renormalisation scale variation")
         logger.info("   --muf=0.5,1,2     # specify the values for factorisation scale variation")
@@ -1494,7 +1585,7 @@
         logger.info("   --keep_weights=   # force to keep the weight even if in the list of remove_weights")
         logger.info("   --start_id=       # define the starting digit for the additial weight. If not specify it is determine automatically")
         logger.info("")
-        logger.info("   Allowed value for the pdf options:", '$MG:color:BLACK')
+        logger.info("   Allowed value for the pdf options:", '$MG:BOLD')
         logger.info("       central  : Do not perform any pdf variation"    )
         logger.info("       errorset : runs over the all the members of the PDF set used to generate the events")
         logger.info("       244800   : runs over the associated set and all its members")
@@ -1505,7 +1596,7 @@
         logger.info("       CT10@X   : runs over the Xth member of the associated PDF set")
         logger.info("       XX,YY,ZZ : runs over the sets for XX,YY,ZZ (those three follows above syntax)")
         logger.info("")
-        logger.info("   Allowed value for the keep/remove_wgts options:", '$MG:color:BLACK')
+        logger.info("   Allowed value for the keep/remove_wgts options:", '$MG:BOLD')
         logger.info("       all      : keep/remove all weights")
         logger.info("       name     : keep/remove that particular weight")
         logger.info("       id1,id2  : keep/remove all the weights between those two values --included--")
@@ -1792,6 +1883,7 @@
             cp3.irmp.ucl.ac.be/projects/madgraph/wiki/Reweight
         """
         
+
         #### Utility function
         def check_multicore(self):
             """ determine if the cards are save for multicore use"""
@@ -1843,7 +1935,7 @@
         elif hasattr(self, 'switch') and self.switch['reweight'] not in ['ON','OFF']:
             plugin=self.switch['reweight']
             
-            
+
             
         # Check that MG5 directory is present .
         if MADEVENT and not self.options['mg5_path']:
@@ -1865,6 +1957,9 @@
 
         # load the name of the event file
         args = self.split_arg(line) 
+        if plugin and '--plugin=' not in line:
+            args.append('--plugin=%s' % plugin)
+        
 
         if not self.force_run:
             # forbid this function to create an empty item in results.
@@ -1884,8 +1979,6 @@
             if not isinstance(self, cmd.CmdShell):
                 command.append('--web')
             command.append('reweight')
-            if plugin:
-                command.append('--plugin=%s' % plugin)
             
             #########   START SINGLE CORE MODE ############
             if self.options['nb_core']==1 or self.run_card['nevents'] < 101 or not check_multicore(self):
@@ -1971,6 +2064,8 @@
                     
                     if '-from_cards' not in command:
                         new_command.append('-from_cards')
+                    if plugin:
+                        new_command.append('--plugin=%s' % plugin)
                     if i==0:
                         if __debug__:
                             stdout = None
@@ -3214,7 +3309,10 @@
             #Force class default
             self.debug_output = CommonRunCmd.debug_output
         if os.path.exists('ME5_debug') and not 'ME5_debug' in self.debug_output:
-            os.remove('ME5_debug')
+            try:
+                os.remove('ME5_debug')
+            except Exception:
+                pass
         if not 'ME5_debug' in self.debug_output:
             os.system('ln -s %s ME5_debug &> /dev/null' % self.debug_output)
 
@@ -3245,6 +3343,15 @@
     do_EOF = do_quit
     do_exit = do_quit
 
+    def __del__(self):
+        """try to remove RunWeb?"""
+        
+        if not self.stop_for_runweb and not self.force_run:
+            try:
+                os.remove(pjoin(self.me_dir,'RunWeb'))
+            except Exception:
+                pass
+            
 
     def update_status(self, status, level, makehtml=True, force=True,
                       error=False, starttime = None, update_results=True,
@@ -4084,56 +4191,31 @@
 
 class AskforEditCard(cmd.OneLinePathCompletion):
     """A class for asking a question where in addition you can have the
-    set command define and modifying the param_card/run_card correctly"""
+    set command define and modifying the param_card/run_card correctly
+    
+    special action can be trigger via trigger_XXXX when the user start a line
+    with XXXX. the output of such function should be new line that can be handle.
+    (return False to repeat the question)
+    """
 
     all_card_name = ['param_card', 'run_card', 'pythia_card', 'pythia8_card', 
                      'madweight_card', 'MadLoopParams', 'shower_card']
-
-    special_shortcut = {'ebeam':([float],['run_card ebeam1 %(0)s', 'run_card ebeam2 %(0)s']),
-                        'lpp': ([int],['run_card lpp1 %(0)s', 'run_card lpp2 %(0)s' ]),
-                        'lhc': ([int],['run_card lpp1 1', 'run_card lpp2 1', 'run_card ebeam1 %(0)s*1000/2', 'run_card ebeam2 %(0)s*1000/2']),
-                        'lep': ([int],['run_card lpp1 0', 'run_card lpp2 0', 'run_card ebeam1 %(0)s/2', 'run_card ebeam2 %(0)s/2']),
-                        'ilc': ([int],['run_card lpp1 0', 'run_card lpp2 0', 'run_card ebeam1 %(0)s/2', 'run_card ebeam2 %(0)s/2']),
-                        'lcc': ([int],['run_card lpp1 1', 'run_card lpp2 1', 'run_card ebeam1 %(0)s*1000/2', 'run_card ebeam2 %(0)s*1000/2']),
-                        'fixed_scale': ([float],['run_card fixed_fac_scale T', 'run_card fixed_ren_scale T', 'run_card scale %(0)s', 'run_card dsqrt_q2fact1 %(0)s' ,'run_card dsqrt_q2fact2 %(0)s']),
-                        'simplepy8':([],['pythia8_card hadronlevel:all False',
-                                     'pythia8_card partonlevel:mpi False',
-                                     'pythia8_card BeamRemnants:primordialKT False',
-                                     'pythia8_card PartonLevel:Remnants False',
-                                     'pythia8_card Check:event False',
-                                     'pythia8_card TimeShower:QEDshowerByQ False',
-                                     'pythia8_card TimeShower:QEDshowerByL False',
-                                     'pythia8_card SpaceShower:QEDshowerByQ False',
-                                     'pythia8_card SpaceShower:QEDshowerByL False',
-                                     'pythia8_card PartonLevel:FSRinResonances False',
-                                     'pythia8_card ProcessLevel:resonanceDecays False',
-                                     ]),
-                        'mpi':([bool],['pythia8_card partonlevel:mpi %(0)s']),
-                        'no_parton_cut':([],['run_card nocut T'])
-                        }
-
-    special_shortcut_help = {              
-    'ebeam' : 'syntax: set ebeam VALUE:\n      This parameter sets the energy to both beam to the value in GeV',
-    'lpp'   : 'syntax: set ebeam  VALUE:\n'+\
-              '   Set the type of beam to a given value for both beam\n'+\
-              '   0 : means no PDF\n'+\
-              '   1 : means proton PDF\n'+\
-              '  -1 : means antiproton PDF\n'+\
-              '   2 : means PDF for elastic photon emited from a proton\n'+\
-              '   3 : means PDF for elastic photon emited from an electron',
-    'lhc'   : 'syntax: set lhc VALUE:\n      Set for a proton-proton collision with that given center of mass energy (in TeV)',
-    'lep'   : 'syntax: set lep VALUE:\n      Set for a electron-positron collision with that given center of mass energy (in GeV)',
-    'fixed_scale' : 'syntax: set fixed_scale VALUE:\n      Set all scales to the give value (in GeV)',
-    'simplepy8' : 'Turn off non-perturbative slow features of Pythia8.',
-    'mpi' : 'syntax: set mpi value: allow to turn mpi in Pythia8 on/off'         
-    }
+    to_init_card = ['param', 'run', 'madweight', 'madloop', 
+                    'shower', 'pythia8','delphes','madspin']
+    special_shortcut = {}
+    special_shortcut_help = {}
+    
+    integer_bias = 1 # integer corresponding to the first entry in self.cards
+    
+    PY8Card_class = banner_mod.PY8Card
     
     def load_default(self):
         """ define all default variable. No load of card here.
             This allow to subclass this class and just change init and still have
             all variables defined."""
     
-        self.me_dir = None
+        if not hasattr(self, 'me_dir'):
+            self.me_dir = None
         self.param_card = None
         self.run_card = {}
         self.pname2block = {}
@@ -4146,6 +4228,7 @@
         self.has_ml = False   
         self.has_shower = False
         self.has_PY8 = False
+        self.has_delphes = False
         self.paths = {}
 
     
@@ -4186,22 +4269,110 @@
         self.paths['madanalysis5_hadron_default'] = pjoin(self.me_dir,'Cards','madanalysis5_hadron_card_default.dat')
         self.paths['FO_analyse'] = pjoin(self.me_dir,'Cards', 'FO_analyse_card.dat')
 
+
+     
+    
     def __init__(self, question, cards=[], mode='auto', *args, **opt):
 
+
         self.load_default()        
         self.define_paths(**opt)
+        self.last_editline_pos = 0
+
+        if 'allow_arg' not in opt or not opt['allow_arg']:
+            # add some mininal content for this:
+            opt['allow_arg'] = range(self.integer_bias, self.integer_bias+len(cards))
+
+        self.param_consistency = True
+        if 'param_consistency' in opt:
+            self.param_consistency = opt['param_consistency']
+
         cmd.OneLinePathCompletion.__init__(self, question, *args, **opt)
 
-
+        self.conflict = set()
+        self.mode = mode
+        self.cards = cards
+        self.all_vars = set()
+
+        #update default path by custom one if specify in cards
+        for card in cards:
+            if os.path.exists(card):
+                card_name = CommonRunCmd.detect_card_type(card)
+                card_name = card_name.split('_',1)[0] 
+                self.paths[card_name] = card
+                
+        # go trough the initialisation of each card and detect conflict
+        for name in self.to_init_card:
+            new_vars = set(getattr(self, 'init_%s' % name)(cards))
+            new_conflict = self.all_vars.intersection(new_vars)
+            self.conflict.union(new_conflict)
+            self.all_vars.union(new_vars)
+
+    def get_path(self, name, cards):
+        """initialise the path if requested"""
+
+        defname = '%s_default' % name
+        if isinstance(cards, list):
+            if name in cards:
+                return True
+            elif '%s_card.dat' % name in cards:
+                return True
+            elif name in self.paths and self.paths[name] in cards:
+                return True
+            else:
+                cardnames = [os.path.basename(p) for p in cards]
+                if '%s_card.dat' % name in cardnames:
+                    return True
+                else:       
+                    return False
+            
+        elif isinstance(cards, dict) and name in cards:
+            self.paths[name]= cards[name]
+            if defname in cards:
+                self.paths[defname] = cards[defname]
+            elif os.path.isfile(cards[name].replace('.dat', '_default.dat')):
+                    self.paths[defname] = cards[name].replace('.dat', '_default.dat')            
+            else:
+                self.paths[defname] = self.paths[name]
+                
+            return True
+        else:
+            return False
+
+    def init_param(self, cards):
+        """check if we need to load the param_card"""
+        
+        self.pname2block = {}
+        self.restricted_value = {}
+        self.param_card = {}
+        if not self.get_path('param', cards):
+            self.param_consistency = False
+            return []
+        
         try:
             self.param_card = check_param_card.ParamCard(self.paths['param'])
         except (check_param_card.InvalidParamCard, ValueError) as e:
             logger.error('Current param_card is not valid. We are going to use the default one.')
             logger.error('problem detected: %s' % e)
             files.cp(self.paths['param_default'], self.paths['param'])
-            self.param_card = check_param_card.ParamCard(self.paths['param'])
-        default_param = check_param_card.ParamCard(self.paths['param_default'])
+            self.param_card = check_param_card.ParamCard(self.paths['param'])   
+         
+        # Read the comment of the param_card_default to find name variable for
+        # the param_card also check which value seems to be constrained in the
+        # model.   
+        if os.path.exists(self.paths['param_default']):
+            default_param = check_param_card.ParamCard(self.paths['param_default'])
+        else:
+            default_param =  check_param_card.ParamCard(self.param_card)
+        self.pname2block, self.restricted_value = default_param.analyze_param_card()
         self.param_card_default = default_param
+        return self.pname2block.keys()
+        
+    def init_run(self, cards):
+        
+        self.run_set = []
+        if not self.get_path('run', cards):
+            return []
         
         try:
             self.run_card = banner_mod.RunCard(self.paths['run'], consistency='warning')
@@ -4212,124 +4383,186 @@
         except IOError:
             run_card_def = {}
 
-        self.pname2block = {}
-        self.conflict = []
-        self.restricted_value = {}
-        self.mode = mode
-        self.cards = cards
-        self.last_editline_pos=0
-
-        # Read the comment of the param_card_default to find name variable for
-        # the param_card also check which value seems to be constrained in the
-        # model.
-        self.pname2block, self.restricted_value = \
-                                              default_param.analyze_param_card()
-
         if run_card_def:
-            self.run_set = run_card_def.keys() + self.run_card.hidden_param
+            if self.run_card:
+                self.run_set = run_card_def.keys() + self.run_card.hidden_param
+            else:
+                self.run_set = run_card_def.keys() + run_card_def.hidden_param
         elif self.run_card:
             self.run_set = self.run_card.keys()
         else:
             self.run_set = []
-        # check for conflict with run_card
-        for var in self.pname2block:
-            if var in self.run_set:
-                self.conflict.append(var)        
-                
-
-        self.has_delphes = False        
-        if 'delphes_card.dat' in cards:
-            self.has_delphes = True
-
-        #check if Madweight_card is present:
+        
+        if self.run_set:
+            self.special_shortcut.update(
+                {'ebeam':([float],['run_card ebeam1 %(0)s', 'run_card ebeam2 %(0)s']),
+                'lpp': ([int],['run_card lpp1 %(0)s', 'run_card lpp2 %(0)s' ]),
+                'lhc': ([int],['run_card lpp1 1', 'run_card lpp2 1', 'run_card ebeam1 %(0)s*1000/2', 'run_card ebeam2 %(0)s*1000/2']),
+                'lep': ([int],['run_card lpp1 0', 'run_card lpp2 0', 'run_card ebeam1 %(0)s/2', 'run_card ebeam2 %(0)s/2']),
+                'ilc': ([int],['run_card lpp1 0', 'run_card lpp2 0', 'run_card ebeam1 %(0)s/2', 'run_card ebeam2 %(0)s/2']),
+                'lcc': ([int],['run_card lpp1 1', 'run_card lpp2 1', 'run_card ebeam1 %(0)s*1000/2', 'run_card ebeam2 %(0)s*1000/2']),
+                'fixed_scale': ([float],['run_card fixed_fac_scale T', 'run_card fixed_ren_scale T', 'run_card scale %(0)s', 'run_card dsqrt_q2fact1 %(0)s' ,'run_card dsqrt_q2fact2 %(0)s']),
+                'no_parton_cut':([],['run_card nocut T']),
+                'cm_velocity':([float], [lambda self :self.set_CM_velocity])
+                })
+            
+            self.special_shortcut_help.update({              
+    'ebeam' : 'syntax: set ebeam VALUE:\n      This parameter sets the energy to both beam to the value in GeV',
+    'lpp'   : 'syntax: set ebeam  VALUE:\n'+\
+              '   Set the type of beam to a given value for both beam\n'+\
+              '   0 : means no PDF\n'+\
+              '   1 : means proton PDF\n'+\
+              '  -1 : means antiproton PDF\n'+\
+              '   2 : means PDF for elastic photon emited from a proton\n'+\
+              '   3 : means PDF for elastic photon emited from an electron',
+    'lhc'   : 'syntax: set lhc VALUE:\n      Set for a proton-proton collision with that given center of mass energy (in TeV)',
+    'lep'   : 'syntax: set lep VALUE:\n      Set for a electron-positron collision with that given center of mass energy (in GeV)',
+    'fixed_scale' : 'syntax: set fixed_scale VALUE:\n      Set all scales to the give value (in GeV)',
+    'no_parton_cut': 'remove all cut (but BW_cutoff)',
+    'cm_velocity': 'set sqrts to have the above velocity for the incoming particles', 
+    })
+        
+        return self.run_set
+    
+    def init_madweight(self, cards):
+        
         self.has_mw = False
-        if 'madweight_card.dat' in cards:
-            
-            self.do_change_tf = self.mother_interface.do_define_transfer_fct
-            self.complete_change_tf = self.mother_interface.complete_define_transfer_fct
-            self.help_change_tf = self.mother_interface.help_define_transfer_fct
-            if not os.path.exists(self.paths['transfer']):
-                logger.warning('No transfer function currently define. Please use the change_tf command to define one.')
-            
-            
-            self.has_mw = True
-            try:
-                import madgraph.madweight.Cards as mwcards
-            except:
-                import internal.madweight.Cards as mwcards
-            self.mw_card = mwcards.Card(self.paths['MadWeight'])
-            self.mw_card = self.mw_card.info
-            self.mw_vars = []
-            for key in self.mw_card:
-                if key == 'comment': 
-                    continue
-                for key2 in self.mw_card.info[key]:
-                    if isinstance(key2, str) and not key2.isdigit():
-                        self.mw_vars.append(key2)
-            
-            # check for conflict with run_card/param_card
-            for var in self.pname2block:                
-                if var in self.mw_vars:
-                    self.conflict.append(var)           
-            for var in self.mw_vars:
-                if var in self.run_card:
-                    self.conflict.append(var)
-                    
-        #check if MadLoopParams.dat is present:
+        if not self.get_path('madweight', cards):
+            return []
+        
+        #add special function associated to MW
+        self.do_change_tf = self.mother_interface.do_define_transfer_fct
+        self.complete_change_tf = self.mother_interface.complete_define_transfer_fct
+        self.help_change_tf = self.mother_interface.help_define_transfer_fct
+        if not os.path.exists(self.paths['transfer']):
+            logger.warning('No transfer function currently define. Please use the change_tf command to define one.')
+        
+        self.has_mw = True
+        try:
+            import madgraph.madweight.Cards as mwcards
+        except:
+            import internal.madweight.Cards as mwcards
+        self.mw_card = mwcards.Card(self.paths['MadWeight'])
+        self.mw_card = self.mw_card.info
+        self.mw_vars = []
+        for key in self.mw_card:
+            if key == 'comment': 
+                continue
+            for key2 in self.mw_card.info[key]:
+                if isinstance(key2, str) and not key2.isdigit():
+                    self.mw_vars.append(key2)
+        return self.mw_vars
+
+    def init_madloop(self, cards):
+        
+        if isinstance(cards, dict):
+            for key in ['ML', 'madloop','MadLoop']:
+                if key in cards:
+                    self.paths['ML'] = cards[key]
+        
         self.has_ml = False
         if os.path.isfile(self.paths['ML']):
             self.has_ml = True
             self.MLcard = banner_mod.MadLoopParam(self.paths['ML'])
             self.MLcardDefault = banner_mod.MadLoopParam()
-            
             self.ml_vars = [k.lower() for k in self.MLcard.keys()]
-            # check for conflict
-            for var in self.ml_vars:
-                if var in self.run_card:
-                    self.conflict.append(var)
-                if var in self.pname2block:
-                    self.conflict.append(var)
-                if self.has_mw and var in self.mw_vars:
-                    self.conflict.append(var)
-
-        #check if shower_card is present:
+            return self.ml_vars
+        return []
+        
+    def init_shower(self, cards):
+        
         self.has_shower = False
-        if 'shower_card.dat' in cards:
-            self.has_shower = True
-            self.shower_card = shower_card_mod.ShowerCard(self.paths['shower'])
-            self.shower_vars = self.shower_card.keys()
-            
-            # check for conflict with run_card/param_card
-            for var in self.pname2block:                
-                if var in self.shower_vars:
-                    self.conflict.append(var)           
-            for var in self.shower_vars:
-                if var in self.run_card:
-                    self.conflict.append(var)
-
-        #check if pythia8_card.dat is present:
+        if not self.get_path('shower', cards):
+            return []
+        self.has_shower = True
+        self.shower_card = shower_card_mod.ShowerCard(self.paths['shower'])
+        self.shower_vars = self.shower_card.keys()
+        return self.shower_vars
+    
+    def init_pythia8(self, cards):
+        
         self.has_PY8 = False
-        if 'pythia8_card.dat' in cards:
-            self.has_PY8 = True
-            self.PY8Card = banner_mod.PY8Card(self.paths['pythia8'])
-            self.PY8CardDefault = banner_mod.PY8Card()
-            
-            self.py8_vars = [k.lower() for k in self.PY8Card.keys()]
-            # check for conflict
-            for var in self.py8_vars:
-                if var in self.run_card:
-                    self.conflict.append(var)
-                if var in self.pname2block:
-                    self.conflict.append(var)
-                if self.has_mw and var in self.mw_vars:
-                    self.conflict.append(var)
-                if self.has_ml and var in self.ml_vars:
-                    self.conflict.append(var)
-
-    def do_help(self, line, conflict_raise=False, banner=True):    
+        if not self.get_path('pythia8', cards):
+            return []
+            
+        self.has_PY8 = True
+        self.PY8Card = self.PY8Card_class(self.paths['pythia8'])
+        self.PY8CardDefault = self.PY8Card_class()
+            
+        self.py8_vars = [k.lower() for k in self.PY8Card.keys()] 
+        
+        self.special_shortcut.update({                       
+            'simplepy8':([],['pythia8_card hadronlevel:all False',
+                             'pythia8_card partonlevel:mpi False',
+                             'pythia8_card BeamRemnants:primordialKT False',
+                             'pythia8_card PartonLevel:Remnants False',
+                             'pythia8_card Check:event False',
+                             'pythia8_card TimeShower:QEDshowerByQ False',
+                             'pythia8_card TimeShower:QEDshowerByL False',
+                             'pythia8_card SpaceShower:QEDshowerByQ False',
+                             'pythia8_card SpaceShower:QEDshowerByL False',
+                             'pythia8_card PartonLevel:FSRinResonances False',
+                             'pythia8_card ProcessLevel:resonanceDecays False',
+                             ]),
+            'mpi':([bool],['pythia8_card partonlevel:mpi %(0)s']),
+            })
+        self.special_shortcut_help.update({
+            'simplepy8' : 'Turn off non-perturbative slow features of Pythia8.',
+            'mpi' : 'syntax: set mpi value: allow to turn mpi in Pythia8 on/off',
+             })
+        return []
+        
+    def init_madspin(self, cards):
+        
+        if not self.get_path('madspin', cards):
+            return []
+        
+        self.special_shortcut.update({
+            'spinmode':([str], ['add madspin_card --before_line="launch" set spinmode %(0)s'])
+            })
+        self.special_shortcut_help.update({
+            'spinmode' : 'full|none|onshell. Choose the mode of madspin.\n   - full: spin-correlation and off-shell effect\n  - onshell: only spin-correlation,]\n  - none: no spin-correlation and not offshell effects.'
+             })
+        return []
+    
+    def init_delphes(self, cards):
+        
+        self.has_delphes = False  
+        if not self.get_path('pythia8', cards):
+            return []
+        self.has_delphes = True
+        return []
+
+
+    def set_CM_velocity(self, line):
+        """compute sqrts from the velocity in the center of mass frame"""
+        
+        v = banner_mod.ConfigFile.format_variable(line, float, 'velocity')
+                # Define self.proc_characteristics
+        self.mother_interface.get_characteristics()
+        proc_info = self.mother_interface.proc_characteristics
+        if 'pdg_initial1' not in proc_info:
+            logger.warning('command not supported')
+            
+        if len(proc_info['pdg_initial1']) == 1 == len(proc_info['pdg_initial2']) and\
+           abs(proc_info['pdg_initial1'][0]) == abs(proc_info['pdg_initial2'][0]):
+        
+            m = self.param_card.get_value('mass', abs(proc_info['pdg_initial1'][0]))
+            sqrts = 2*m/ math.sqrt(1-v**2)
+            self.do_set('run_card ebeam1 %s' % (sqrts/2.0))
+            self.do_set('run_card ebeam2 %s' % (sqrts/2.0))
+            self.do_set('run_card lpp 0')
+        else:
+            logger.warning('This is only possible for a single particle in the initial state')
+             
+
+
+    def do_help(self, line, conflict_raise=False, banner=True):  
+        # TODO nicer factorization !
+          
 #     try:                
         if banner:                      
-            logger.info('*** HELP MESSAGE ***', '$MG:color:BLACK')
+            logger.info('*** HELP MESSAGE ***', '$MG:BOLD')
          
         args = self.split_arg(line)
         # handle comand related help
@@ -4346,7 +4579,7 @@
                 print '\t'.join(self.special_shortcut)
                 print
             if banner:
-                logger.info('*** END HELP ***', '$MG:color:BLACK')  
+                logger.info('*** END HELP ***', '$MG:BOLD')  
             return out      
         # check for special shortcut.
         # special shortcut:
@@ -4354,7 +4587,7 @@
             if args[0] in self.special_shortcut_help:
                 print self.special_shortcut_help[args[0]]
             if banner:
-                logger.info('*** END HELP ***', '$MG:color:BLACK')  
+                logger.info('*** END HELP ***', '$MG:BOLD')  
             return       
         
         start = 0
@@ -4391,8 +4624,8 @@
                     logger.info("List of parameter associated", '$MG:color:BLUE')
                     print "\t".join(eval('self.%s' % args[0]).keys())
                 if banner:
-                    logger.info('*** END HELP ***', '$MG:color:BLACK')  
-                return 
+                    logger.info('*** END HELP ***', '$MG:BOLD')  
+                return card
                     
         #### RUN CARD
         if args[start] in [l.lower() for l in self.run_card.keys()] and card in ['', 'run_card']:
@@ -4401,9 +4634,9 @@
 
             if args[start] in self.conflict and not conflict_raise:
                 conflict_raise = True
-                logger.info('**   AMBIGUOUS NAME: %s **', args[start], '$MG:color:BLACK')
+                logger.info('**   AMBIGUOUS NAME: %s **', args[start], '$MG:BOLD')
                 if card == '':
-                    logger.info('**   If not explicitely speficy this parameter  will modif the run_card file', '$MG:color:BLACK')
+                    logger.info('**   If not explicitely speficy this parameter  will modif the run_card file', '$MG:BOLD')
 
             self.run_card.do_help(args[start])
         ### PARAM_CARD WITH BLOCK NAME -----------------------------------------
@@ -4436,7 +4669,7 @@
                     key = tuple([int(i) for i in args[start+1:]])
                 except ValueError:
                     logger.warning('Failed to identify LHA information')
-                    return            
+                    return card           
             
             if key in self.param_card[args[start]].param_dict:
                 self.param_card.do_help(args[start], key, default=self.param_card_default)
@@ -4481,13 +4714,13 @@
             print 'MA5'
             
             
-        else:
+        elif banner:
             print "no help available" 
           
         if banner:                      
             logger.info('*** END HELP ***', '$MG:color:BLACK')    
         #raw_input('press enter to quit the help')
-        return        
+        return card       
 #     except Exception, error:
 #         if __debug__:
 #             import traceback
@@ -4522,8 +4755,9 @@
         
         arg = line[:begidx].split()
         if len(arg) <=1:
-            return self.list_completion(text, ['dependent', 'missing', 'to_slha1', 'to_slha2'], line)
-
+            return self.list_completion(text, ['dependent', 'missing', 'to_slha1', 'to_slha2', 'to_full'], line)
+        elif arg[0] == 'to_full':
+            return self.list_completion(text, self.cards , line)
 
     def complete_set(self, text, line, begidx, endidx, formatting=True):
         """ Complete the set command"""
@@ -4560,7 +4794,7 @@
                 allowed = {'run_card':'default'}
             elif args[1] == 'param_card':
                 allowed = {'block':'all', 'param_card':'default'}
-            elif args[1] in self.param_card.keys():
+            elif self.param_card and args[1] in self.param_card.keys():
                 allowed = {'block':args[1]}
             elif args[1] == 'width':
                 allowed = {'block': 'decay'}
@@ -4689,12 +4923,13 @@
 
             possibilities['Special Value'] = self.list_completion(text, opts)
 
-        if 'block' in allowed.keys():
-            if allowed['block'] == 'all':
+        if 'block' in allowed.keys() and self.param_card:
+            if allowed['block'] == 'all' and self.param_card:
                 allowed_block = [i for i in self.param_card.keys() if 'qnumbers' not in i]
                 allowed_block.append('width')
                 possibilities['Param Card Block' ] = \
                                        self.list_completion(text, allowed_block)
+                
             elif isinstance(allowed['block'], basestring):
                 block = self.param_card[allowed['block']].param_dict
                 ids = [str(i[0]) for i in block
@@ -4750,6 +4985,8 @@
         
         
         args = self.split_arg(line)
+        
+        
         if len(args) == 0:
             logger.warning("No argument. For help type 'help set'.")
         # fix some formatting problem
@@ -4776,20 +5013,35 @@
                 except ValueError as e:
                     logger.warning("Wrong argument: The entry #%s should be of type %s.", i+1, argtype)
                     return
+                except InvalidCmd as e:
+                    logger.warning(str(e))
+                    return
             #else:
             #    logger.warning("too many argument for this command")
             #    return
             for arg in cmd:
-                try:
-                    text = arg % values
-                except KeyError:
-                    logger.warning("This command requires one argument")
-                    return
-                except Exception as e:
-                    logger.warning(str(e))
-                    return
+                if isinstance(arg, str):
+                    try:
+                        text = arg % values
+                    except KeyError:
+                        logger.warning("This command requires one argument")
+                        return
+                    except Exception as e:
+                        logger.warning(str(e))
+                        return
+                    else:
+                        split = text.split()
+                        if hasattr(self, 'do_%s' % split[0]):
+                            getattr(self, 'do_%s' % split[0])(' '.join(split[1:]))
+                        else:
+                            self.do_set(text)
+                #need to call a function
                 else:
-                    self.do_set(arg % values)
+                    val = [values[str(i)] for i in range(len(values))]
+                    try:
+                        arg(self)(*val)
+                    except Exception, e:
+                        logger.warning(str(e))
             return
 
         
@@ -4902,7 +5154,7 @@
         elif args[0] in ['pythia8_card']:
             if args[1] == 'default':
                 logger.info('replace pythia8_card.dat by the default card','$MG:color:BLACK')
-                self.PY8Card = banner_mod.PY8Card(self.PY8CardDefault)
+                self.PY8Card = self.PY8Card_class(self.PY8CardDefault)
                 self.PY8Card.write(pjoin(self.me_dir,'Cards','pythia8_card.dat'),
                           pjoin(self.me_dir,'Cards','pythia8_card_default.dat'),
                           print_only_visible=True)
@@ -5308,7 +5560,7 @@
             self.do_set('run_card store_rwgt_info True')
         
         # @LO if PY6 shower => event_norm on sum
-        if 'pythia_card.dat' in self.cards:
+        if 'pythia_card.dat' in self.cards and 'run' in self.allow_arg:
             if self.run_card['event_norm'] != 'sum':
                 logger.info('Pythia6 needs a specific normalisation of the events. We will change it accordingly.', '$MG:color:BLACK' )
                 self.do_set('run_card event_norm sum') 
@@ -5391,19 +5643,20 @@
 
         if ending_question:
             self.check_card_consistency()
-            try:
-                self.do_update('dependent', timer=20)
-            except MadGraph5Error, error:
-                if 'Missing block:' in str(error):
-                    self.fail_due_to_format +=1
-                    if self.fail_due_to_format == 10:
-                        missing, unknow = str(error).split('\n')[-2:]
-                        logger.warning("Invalid param_card:\n%s\n%s\n" % (missing, unknow))
-                        logger.info("Type \"update missing\" to use default value.\n ", '$MG:color:BLACK')
-                        self.value = False # to avoid that entering a command stop the question
-                        return self.reask(True)
-                    else:
-                        raise
+            if self.param_consistency:
+                try:
+                    self.do_update('dependent', timer=20)
+                except MadGraph5Error, error:
+                    if 'Missing block:' in str(error):
+                        self.fail_due_to_format +=1
+                        if self.fail_due_to_format == 10:
+                            missing, unknow = str(error).split('\n')[-2:]
+                            logger.warning("Invalid param_card:\n%s\n%s\n" % (missing, unknow))
+                            logger.info("Type \"update missing\" to use default value.\n ", '$MG:color:BLACK')
+                            self.value = False # to avoid that entering a command stop the question
+                            return self.reask(True)
+                        else:
+                            raise
             
             return ending_question
     
@@ -5415,8 +5668,9 @@
         """ syntax: update dependent: Change the mass/width of particles which are not free parameter for the model.
                     update missing:   add to the current param_card missing blocks/parameters.
                     update to_slha1: pass SLHA2 card to SLHA1 convention. (beta)
-                    update to_slha2: pass SLHA1 card to SLHA2 convention. (beta)"""
-        
+                    update to_slha2: pass SLHA1 card to SLHA2 convention. (beta)
+                    update to_full [run_card]
+        """
         args = self.split_arg(line)
         if len(args)==0:
             logger.warning('miss an argument (dependent or missing). Please retry')
@@ -5461,7 +5715,16 @@
             except Exception, error:
                 logger.warning('failed to update to slha1 due to %s' % error)
             self.param_card = check_param_card.ParamCard(self.paths['param'])            
-            
+        elif args[0] == 'to_full':
+            return self.update_to_full(args[1:])
+
+
+    def update_to_full(self, line):
+        """ trigger via update to_full LINE"""
+        
+        logger.info("update the run_card by including all the hidden parameter")
+        self.run_card.write(self.paths['run'], self.paths['run_default'], write_hidden=True)
+
     @staticmethod
     def update_dependent(mecmd, me_dir, param_card, path ,timer=0):
         """static method which can also be called from outside the class
@@ -5471,6 +5734,7 @@
         
         if not param_card:
             return False
+
         logger.info('Update the dependent parameter of the param_card.dat')
         modify = True
         class TimeOutError(Exception): 
@@ -5638,12 +5902,34 @@
         logger.info('     set run_card default')
         logger.info('********************* HELP SET ***************************')
 
+    def trigger(self, line):
+        
+        line = line.strip()
+        args = line.split()
+
+        if not args:
+            return line
+        if not hasattr(self, 'trigger_%s' % args[0]):
+            return line
+
+        triggerfct = getattr(self, 'trigger_%s' % args[0])
+        
+        # run the trigger function
+        outline = triggerfct(' '.join(args[1:]))
+        if not outline:
+            return 'repeat'
+        return outline
 
     def default(self, line):
         """Default action if line is not recognized"""
 
+        # check if the line need to be modified by a trigger
+        line = self.trigger(line)
+        
+        # splitting the line
         line = line.strip()
         args = line.split()
+            
         if line == '' and self.default_value is not None:
             self.value = self.default_value
         # check if input is a file
@@ -5681,6 +5967,7 @@
 
         return line
 
+
     def do_decay(self, line):
         """edit the madspin_card to define the decay of the associate particle"""
         signal.alarm(0) # avoid timer if any
@@ -5841,7 +6128,7 @@
                           pjoin(self.me_dir,'Cards','pythia8_card_default.dat'),
                           print_only_visible=True)
             logger.info("add in the pythia8_card the parameter \"%s\" with value \"%s\"" % (name, value), '$MG:color:BLACK')
-        elif len(args) > 0: 
+        elif len(args) > 0:
             if args[0] in self.cards:
                 card = args[0]
             elif "%s.dat" % args[0] in self.cards:
@@ -5853,46 +6140,56 @@
             else:
                 logger.error("unknow card %s. Please retry." % args[0])
                 return
+            
+            if card in self.paths:
+                path = self.paths[card]
+            elif os.path.exists(card):
+                path = card
+            elif os.path.exists(pjoin(self.me_dir,'Cards',card)):
+                path = pjoin(self.me_dir,'Cards',card)
+            else:
+                raise Exception, 'unknow path'
+            
             # handling the various option on where to write the line            
             if args[1] == '--clean':
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write("# %s \n" % card)
                 ff.write("%s \n" %  line.split(None,2)[2])
                 ff.close()
                 logger.info("writing the line in %s (empty file) the line: \"%s\"" %(card, line.split(None,2)[2] ),'$MG:color:BLACK')
             elif args[1].startswith('--line_position=afterlast'):
                 #position in file determined by user
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 if self.last_editline_pos > 0:
                     pos = self.last_editline_pos +1
                 newline = line.split(None,2)[2]
                 split.insert(pos, newline)
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
                 logger.info("writting at line %d of the file %s the line: \"%s\"" %(pos, card, line.split(None,2)[2] ),'$MG:color:BLACK')
                 self.last_editline_pos = pos
             elif args[1].startswith('--line_position='):
                 #position in file determined by user
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 pos = int(args[1].split('=',1)[1])
                 newline = line.split(None,2)[2]
                 split.insert(pos, newline)
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
                 logger.info("writting at line %d of the file %s the line: \"%s\"" %(pos, card, line.split(None,2)[2] ),'$MG:color:BLACK')
                 self.last_editline_pos = pos
                 
             elif args[1].startswith('--after_line=banner'):
                 # write the line at the first not commented line
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 for posline,l in  enumerate(split):
                     if not l.startswith('#'):
                         break
                 split.insert(posline, line.split(None,2)[2])
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
                 logger.info("writting at line %d of the file %s the line: \"%s\"" %(posline, card, line.split(None,2)[2] ),'$MG:color:BLACK')
                 self.last_editline_pos = posline
@@ -5900,7 +6197,7 @@
             elif args[1].startswith('--replace_line='):
                 # catch the line/regular expression and replace the associate line
                 # if no line match go to check if args[2] has other instruction starting with --
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 search_pattern=r'''replace_line=(?P<quote>["'])(?:(?=(\\?))\2.)*?\1'''
                 pattern = '^\s*' + re.search(search_pattern, line).group()[14:-1]
@@ -5921,7 +6218,7 @@
                 # overwrite the previous line
                 old_line = split[posline]
                 split[posline] = new_line
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
                 logger.info("Replacing the line \"%s\" [line %d of %s] by \"%s\"" %
                          (old_line, posline, card, new_line ),'$MG:color:BLACK') 
@@ -5930,7 +6227,7 @@
             
             elif args[1].startswith('--before_line='):
                 # catch the line/regular expression and write before that line
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 search_pattern=r'''before_line=(?P<quote>["'])(?:(?=(\\?))\2.)*?\1'''
                 pattern = '^\s*' + re.search(search_pattern, line).group()[13:-1]
@@ -5940,14 +6237,14 @@
                 else:
                     raise Exception, 'invalid regular expression: not found in file'
                 split.insert(posline, re.split(search_pattern,line)[-1])
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
                 logger.info("writting at line %d of the file %s the line: \"%s\"" %(posline, card, line.split(None,2)[2] ),'$MG:color:BLACK')                
                 self.last_editline_pos = posline
                                 
             elif args[1].startswith('--after_line='):
                 # catch the line/regular expression and write after that line
-                text = open(pjoin(self.me_dir,'Cards',card)).read()
+                text = open(path).read()
                 split = text.split('\n')
                 search_pattern = r'''after_line=(?P<quote>["'])(?:(?=(\\?))\2.)*?\1'''
                 pattern = '^\s*' + re.search(search_pattern, line).group()[12:-1]
@@ -5957,19 +6254,20 @@
                 else:
                     posline=len(split)
                 split.insert(posline+1, re.split(search_pattern,line)[-1])
-                ff = open(pjoin(self.me_dir,'Cards',card),'w')
+                ff = open(path,'w')
                 ff.write('\n'.join(split))
-                logger.info("writting at line %d o the file %s the line: \"%s\"" %(posline, card, line.split(None,1)[1] ),'$MG:color:BLACK')
+
+                logger.info("writting at line %d of the file %s the line: \"%s\"" %(posline, card, line.split(None,2)[2] ),'$MG:color:BLACK')                                 
                 self.last_editline_pos = posline
                                                  
             else:
-                ff = open(pjoin(self.me_dir,'Cards',card),'a')
+                ff = open(path,'a')
                 ff.write("%s \n" % line.split(None,1)[1])
                 ff.close()
                 logger.info("adding at the end of the file %s the line: \"%s\"" %(card, line.split(None,1)[1] ),'$MG:color:BLACK')
                 self.last_editline_pos = -1
 
-            self.reload_card(pjoin(self.me_dir,'Cards',card))
+            self.reload_card(path)
             
     do_edit = do_add
     complete_edit = complete_add
@@ -6052,7 +6350,7 @@
             self.do_set('mw_run inputfile %s' % os.path.relpath(path, self.mother_interface.me_dir))     
             return             
         else:
-            card_name = CommonRunCmd.detect_card_type(path)
+            card_name = self.detect_card_type(path)
 
         if card_name == 'unknown':
             logger.warning('Fail to determine the type of the file. Not copied')
@@ -6068,6 +6366,11 @@
             for card_name in self.cards:
                 self.reload_card(pjoin(self.me_dir, 'Cards', card_name))
 
+    def detect_card_type(self, path):
+        """detect card type"""
+        
+        return CommonRunCmd.detect_card_type(path)
+
     def open_file(self, answer):
         """open the file"""
         try:
@@ -6079,7 +6382,7 @@
             if answer == '9':
                 answer = 'plot'
             else:
-                answer = self.cards[int(answer)-1]
+                answer = self.cards[int(answer)-self.integer_bias]
 
         if 'madweight' in answer:
             answer = answer.replace('madweight', 'MadWeight')
@@ -6147,7 +6450,7 @@
             # Use the read function so that modified/new parameters are correctly
             # set as 'user_set'
             if not self.PY8Card:
-                self.PY8Card = banner_mod.PY8Card(self.paths['pythia8_default'])
+                self.PY8Card = self.PY8Card_class(self.paths['pythia8_default'])
 
             self.PY8Card.read(self.paths['pythia8'], setter='user')
             self.py8_vars = [k.lower() for k in self.PY8Card.keys()]
@@ -6161,29 +6464,3 @@
             logger.debug('not keep in sync: %s', path)
         return path
 
-class EditParamCard(AskforEditCard):
-    """a dedicated module for the param"""
-    
-    special_shortcut ={}
-    
-    def __init__(self, question, card=[], mode='auto', *args, **opt):
-                 
-        self.load_default()
-        cmd.OneLinePathCompletion.__init__(self, question, *args, **opt)
-        if os.path.isfile(card[0]):
-            self.param_card = check_param_card.ParamCard(card[0])
-            self.paths['param'] = card[0]
-            if os.path.isfile(card[0].replace('.dat', '_default.dat')):
-                self.paths['param_default'] = card[0].replace('.dat', '_default.dat')
-            else:
-                self.paths['param_default'] = card[0]
-        else:
-            raise Exception, 'path %s do not exists' % card[0]
-        
-        self.pname2block, self.restricted_value = self.param_card.analyze_param_card()
-        self.cards=['param']
-        
-    def do_asperge(self, *args, **opts):
-        "Not available"
-        logger.warning("asperge not available in this mode")
-

=== modified file 'madgraph/interface/extended_cmd.py'
--- madgraph/interface/extended_cmd.py	2018-02-21 22:35:09 +0000
+++ madgraph/interface/extended_cmd.py	2018-04-20 08:32:43 +0000
@@ -12,7 +12,6 @@
 # For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch
 #
 ################################################################################
-from __builtin__ import True
 """  A file containing different extension of the cmd basic python library"""
 
 
@@ -35,6 +34,8 @@
 
 logger = logging.getLogger('cmdprint') # for stdout
 logger_stderr = logging.getLogger('fatalerror') # for stderr
+logger_tuto = logging.getLogger('tutorial') # for stdout
+logger_plugin = logging.getLogger('tutorial_plugin') # for stdout
 
 try:
     import madgraph.various.misc as misc
@@ -468,7 +469,7 @@
             out = []
             for name, opt in dico.items():
                 out += opt
-            return out
+            return list(set(out))
 
         # check if more than one categories but only one value:
         if not forceCategory and all(len(s) <= 1 for s in dico.values() ):
@@ -768,13 +769,13 @@
 
     def help_quit(self):
         logger.info("-- terminates the application",'$MG:color:BLUE')
-        logger.info("syntax: quit",'$MG:color:BLACK')
+        logger.info("syntax: quit",'$MG:BOLD')
     
     help_EOF = help_quit
 
     def help_history(self):
         logger.info("-- interact with the command history.",'$MG:color:BLUE')
-        logger.info("syntax: history [FILEPATH|clean|.] ",'$MG:color:BLACK')
+        logger.info("syntax: history [FILEPATH|clean|.] ",'$MG:BOLD')
         logger.info(" > If FILEPATH is \'.\' and \'output\' is done,")
         logger.info("   Cards/proc_card_mg5.dat will be used.")
         logger.info(" > If FILEPATH is omitted, the history will be output to stdout.")
@@ -782,17 +783,17 @@
         
     def help_help(self):
         logger.info("-- access to the in-line help",'$MG:color:BLUE')
-        logger.info("syntax: help",'$MG:color:BLACK')
+        logger.info("syntax: help",'$MG:BOLD')
 
     def help_save(self):
         """help text for save"""
         logger.info("-- save options configuration to filepath.",'$MG:color:BLUE')
-        logger.info("syntax: save [options]  [FILEPATH]",'$MG:color:BLACK') 
+        logger.info("syntax: save [options]  [FILEPATH]",'$MG:BOLD') 
         
     def help_display(self):
         """help for display command"""
         logger.info("-- display a the status of various internal state variables",'$MG:color:BLUE')          
-        logger.info("syntax: display " + "|".join(self._display_opts),'$MG:color:BLACK')
+        logger.info("syntax: display " + "|".join(self._display_opts),'$MG:BOLD')
         
 class CompleteCmd(object):
     """Extension of the cmd object for only the complete command"""
@@ -1187,8 +1188,8 @@
                     self.store_line(line)
                     return None # print the question and use the pipe
                 logger.info(question_instance.question)
-                logger.info('The answer to the previous question is not set in your input file', '$MG:color:BLACK')
-                logger.info('Use %s value' % default, '$MG:color:BLACK')
+                logger.info('The answer to the previous question is not set in your input file', '$MG:BOLD')
+                logger.info('Use %s value' % default, '$MG:BOLD')
                 return str(default)
             
         line = line.replace('\n','').strip()
@@ -1455,7 +1456,7 @@
             me_dir = os.path.basename(me_dir) + ' '
         
         misc.EasterEgg('error')
-        stop=True
+        stop=False
         try:
             raise 
         except self.InvalidCmd as error:
@@ -1486,6 +1487,7 @@
             if __debug__:
                 self.nice_config_error(error, line)
             logger.error(self.keyboard_stop_msg)
+
         
         if stop:
             self.do_quit('all')
@@ -2018,11 +2020,11 @@
     def help_shell(self):
         """help for the shell"""
         logger.info("-- run the shell command CMD and catch output",'$MG:color:BLUE')        
-        logger.info("syntax: shell CMD (or ! CMD)",'$MG:color:BLACK')
-
-
-
-
+        logger.info("syntax: shell CMD (or ! CMD)",'$MG:BOLD')
+
+
+
+class NotValidInput(Exception): pass
 #===============================================================================
 # Question with auto-completion
 #===============================================================================
@@ -2042,6 +2044,7 @@
 
     def __init__(self, question, allow_arg=[], default=None, 
                                             mother_interface=None, *arg, **opt):
+
         self.question = question
         self.wrong_answer = 0 # forbids infinite loop
         self.allow_arg = [str(a) for a in allow_arg]
@@ -2066,6 +2069,8 @@
             setattr(self, key, value)
         if reprint_opt:
             print question
+            logger_tuto.info("Need help here? type 'help'", '$MG:BOLD')
+            logger_plugin.info("Need help here? type 'help'" , '$MG:BOLD')
         return self.cmdloop()
         
 
@@ -2157,21 +2162,21 @@
         
         if not text:
             if out['Options']:
-                logger.info( "Here is the list of all valid options:", '$MG:color:BLACK')
+                logger.info( "Here is the list of all valid options:", '$MG:BOLD')
                 logger.info( "  "+  "\n  ".join(out['Options']))
             if out['command']: 
-                logger.info( "Here is the list of command available:", '$MG:color:BLACK')
+                logger.info( "Here is the list of command available:", '$MG:BOLD')
                 logger.info( "  "+  "\n  ".join(out['command']))
         else:
             if out['Options']:
-                logger.info( "Here is the list of all valid options starting with \'%s\'" % text, '$MG:color:BLACK')
+                logger.info( "Here is the list of all valid options starting with \'%s\'" % text, '$MG:BOLD')
                 logger.info( "  "+  "\n  ".join(out['Options']))
             if out['command']: 
-                logger.info( "Here is the list of command available starting with \'%s\':" % text, '$MG:color:BLACK')
+                logger.info( "Here is the list of command available starting with \'%s\':" % text, '$MG:BOLD')
                 logger.info( "  "+  "\n  ".join(out['command']))
             elif not  out['Options']:
-                logger.info( "No possibility starting with \'%s\'" % text, '$MG:color:BLACK')           
-        logger.info( "You can type help XXX, to see all command starting with XXX", '$MG:color:BLACK')
+                logger.info( "No possibility starting with \'%s\'" % text, '$MG:BOLD')           
+        logger.info( "You can type help XXX, to see all command starting with XXX", '$MG:BOLD')
     def complete_help(self, text, line, begidx, endidx):
         """ """
         return self.completenames(text, line)
@@ -2338,6 +2343,7 @@
        
        Behavior for each switch can be customize via:
        set_default_XXXX() -> set default value
+           This is super-seeded by self.default_switch if that attribute is defined (and has a key for XXXX)
        get_allowed_XXXX() -> return list of possible value
        check_value_XXXX(value) -> return True/False if the user can set such value
        switch_off_XXXXX()      -> set it off (called for special mode)
@@ -2399,9 +2405,9 @@
         if 'allow_arg' in opts:
             allowed_args += opts['allow_arg']
             del opts['allow_arg']
-            
+
         allowed_args +=["0", "done"]
-        super(ControlSwitch, self).__init__(question, allowed_args, *args, **opts)
+        SmartQuestion.__init__(self, question, allowed_args, *args, **opts)
         self.options = self.mother_interface.options
 
     def special_check_answer_in_input_file(self, line, default):
@@ -2439,11 +2445,14 @@
         
         for key,_ in self.to_control:
             key = key.lower()
+            if hasattr(self, 'default_switch') and key in self.default_switch:
+                self.switch[key] = self.default_switch[key]
+                continue
             if hasattr(self, 'set_default_%s' % key):
                 getattr(self, 'set_default_%s' % key)()
             else:
                 self.default_switch_for(key)
-    
+        
     def default_switch_for(self, key):
         """use this if they are no dedicated function for such key"""
         
@@ -2498,8 +2507,8 @@
             return getattr(self, 'get_allowed_%s' % key)()
         else:
             return ['ON', 'OFF']    
-        
-    def default(self, line):
+            
+    def default(self, line, raise_error=False):
         """Default action if line is not recognized"""
         
         line=line.strip().replace('@', '__at__')
@@ -2511,6 +2520,8 @@
         
         if '=' in line:
             base, value = line.split('=',1)
+            base = base.strip()
+            value = value.strip()
             # allow 1=OFF
             if base.isdigit() :
                 try:
@@ -2521,7 +2532,7 @@
             base, value = line.split(' ', 1)
         elif hasattr(self, 'ans_%s' % line.lower()):
             base, value = line.lower(), None
-        elif line.isdigit() and line in [`i` for i in range(1, len(self.switch)+1)]:
+        elif line.isdigit() and line in [`i` for i in range(1, len(self.to_control)+1)]:
             # go from one valid option to the next in the get_allowed for that option
             base = self.to_control[int(line)-1][0].lower()
             return self.default(base) # just recall this function with the associate name
@@ -2533,7 +2544,7 @@
             except:
                 if self.get_allowed(base):
                     value = self.get_allowed(base)[0]
-                else:                                            
+                else:                      
                     logger.warning('Can not switch "%s" to another value via number', base)
                     self.value='reask'
                     return
@@ -2548,6 +2559,8 @@
         elif line in 'auto':
             self.switch['dynamical'] = True
             return super(ControlSwitch, self).default(line)
+        elif raise_error:
+            raise NotValidInput('unknow command: %s' % line)
         else:
             logger.warning('unknow command: %s' % line)
             self.value = 'reask'
@@ -2560,7 +2573,9 @@
                 value = value.lower()
             getattr(self, 'ans_%s' % base)(value)
         elif base in self.switch:
-            self.set_switch(base, value)        
+            self.set_switch(base, value)
+        elif raise_error:
+            raise NotValidInput('Not valid command: %s' % line)                
         else:
             logger.warning('Not valid command: %s' % line)
    
@@ -2608,8 +2623,6 @@
         """change a switch to a given value"""
 
         assert key in self.switch
-
-        
         
         if hasattr(self, 'ans_%s' % key):
             if not self.is_case_sensitive(key):
@@ -2827,6 +2840,52 @@
         if info == '':
             info = 'Please install module'
         return info
+    
+    def do_help(self, line, list_command=False):
+        """dedicated help for the control switch"""
+        
+        if line:
+            return self.print_help_for_switch(line)
+        
+        # here for simple "help"
+        logger.info(" ")
+        logger.info("  In order to change a switch you can:")
+        logger.info("   - type 'NAME = VALUE'  to set the switch NAME to a given value.")
+        logger.info("   - type 'ID = VALUE'  to set the switch correspond to the line ID to a given value.")
+        logger.info("   - type 'ID' where ID is the value of the line to pass from one value to the next.")
+        logger.info("   - type 'NAME' to set the switch NAME to the next value.")
+        logger.info("")
+        logger.info("   You can type 'help NAME' for more help on a given switch")
+        logger.info("")
+        logger.info("  Special keyword:", '$MG:BOLD')
+        logger.info("    %s" % '\t'.join([p[4:] for p in dir(self) if p.startswith('ans_')]) )
+        logger.info("    type 'help  XXX' for more information")
+        if list_command:
+            super(ControlSwitch, self).do_help(line)
+
+        
+    def print_help_for_switch(self, line):
+        """ """
+        
+        arg = line.split()[0]
+        
+        if hasattr(self, 'help_%s' % arg):
+            return getattr(self, 'help_%s' % arg)('')
+        
+        if hasattr(self, 'ans_%s' % arg):
+            return getattr(self, 'help_%s' % arg).__doc__
+        
+        if arg in self.switch:
+            logger.info("   information for switch %s: ", arg, '$MG:BOLD')
+            logger.info("   allowed value:")
+            logger.info("      %s", '\t'.join(self.get_allowed(arg)))
+            if hasattr(self, 'help_text_%s' % arg):
+                logger.info("")
+                for line in getattr(self, 'help_text_%s' % arg):
+                    logger.info(line)
+                      
+        
+    
 
     def question_formatting(self, nb_col = 80,
                                   ldescription=0,
@@ -3000,7 +3059,7 @@
         
         return upper, lower, f1, f2
                 
-    def create_question(self):
+    def create_question(self, help_text=True):
         """ create the question  with correct formatting"""
         
         # geth the number of line and column of the shell to adapt the printing
@@ -3090,31 +3149,30 @@
                 
         if not example:
             example = ('KEY', 'VALUE')
-            
-        text += \
-          ["Either type the switch number (1 to %s) to change its setting," % len(self.to_control),
-           "Set any switch explicitly (e.g. type '%s=%s' at the prompt)" % example,
-           "Type 'help' for the list of all valid option",
-           "Type '0', 'auto', 'done' or just press enter when you are done."]
-        
-        # check on the number of row:
-        if len(text) > nb_rows:
-            # too many lines. Remove some
-            to_remove = [ -2, #Type 'help' for the list of all valid option
-                          -5,  # \====/
-                          -4, #Either type the switch number (1 to %s) to change its setting,
-                          -3, # Set any switch explicitly
-                          -1, # Type '0', 'auto', 'done' or just press enter when you are done.
-                         ] 
-            to_remove = to_remove[:min(len(to_remove), len(text)-nb_rows)]
-            text = [t for i,t in enumerate(text) if i-len(text) not in to_remove]
-        
+        
+        if help_text:
+            text += \
+              ["Either type the switch number (1 to %s) to change its setting," % len(self.to_control),
+               "Set any switch explicitly (e.g. type '%s=%s' at the prompt)" % example,
+               "Type 'help' for the list of all valid option",
+               "Type '0', 'auto', 'done' or just press enter when you are done."]
+            
+            # check on the number of row:
+            if len(text) > nb_rows:
+                # too many lines. Remove some
+                to_remove = [ -2, #Type 'help' for the list of all valid option
+                              -5,  # \====/
+                              -4, #Either type the switch number (1 to %s) to change its setting,
+                              -3, # Set any switch explicitly
+                              -1, # Type '0', 'auto', 'done' or just press enter when you are done.
+                             ] 
+                to_remove = to_remove[:min(len(to_remove), len(text)-nb_rows)]
+                text = [t for i,t in enumerate(text) if i-len(text) not in to_remove]
+            
         self.question =    "\n".join(text)                                                              
         return self.question
     
 
-
-
 #===============================================================================
 # 
 #===============================================================================

=== modified file 'madgraph/interface/launch_ext_program.py'
--- madgraph/interface/launch_ext_program.py	2018-02-21 22:35:09 +0000
+++ madgraph/interface/launch_ext_program.py	2018-04-20 08:32:43 +0000
@@ -625,73 +625,75 @@
         import madgraph.interface.madevent_interface as ME
         
         stdout_level = self.cmd_int.options['stdout_level']
-        if self.shell:
-            usecmd = ME.MadEventCmdShell(me_dir=self.running_dir, options=self.options)
-        else:
-            usecmd = ME.MadEventCmd(me_dir=self.running_dir, options=self.options)
-            usecmd.pass_in_web_mode()
-        #Check if some configuration were overwritten by a command. If so use it    
-        set_cmd = [l for l in self.cmd_int.history if l.strip().startswith('set')]
-        all_options = usecmd.options_configuration.keys() +  usecmd.options_madgraph.keys() + usecmd.options_madevent.keys()
-        for line in set_cmd:
-            arg = line.split()
-            if arg[1] not in all_options:
-                continue
+        
+        with ME.MadEventCmd.RunWebHandling(self.running_dir):
+            if self.shell:
+                usecmd = ME.MadEventCmdShell(me_dir=self.running_dir, options=self.options, force_run=True)
+            else:
+                usecmd = ME.MadEventCmd(me_dir=self.running_dir, options=self.options, force_run=True)
+                usecmd.pass_in_web_mode()
+            #Check if some configuration were overwritten by a command. If so use it    
+            set_cmd = [l for l in self.cmd_int.history if l.strip().startswith('set')]
+            all_options = usecmd.options_configuration.keys() +  usecmd.options_madgraph.keys() + usecmd.options_madevent.keys()
+            for line in set_cmd:
+                arg = line.split()
+                if arg[1] not in all_options:
+                    continue
+                try:
+                    usecmd.do_set(line[3:], log=False)
+                except usecmd.InvalidCmd:
+                    pass
+            usecmd.do_set('stdout_level %s'  % stdout_level,log=False)
+            #ensure that the logger level 
+            launch = self.cmd_int.define_child_cmd_interface(
+                         usecmd, interface=False)
+            #launch.me_dir = self.running_dir
+            if self.unit == 'pb':
+                command = 'generate_events %s' % self.name
+            else:
+                warning_text = '''\
+                Note that since 2.3. The launch for 1>N pass in event generation
+                For efficient width computation see arXiv:1402.1178.'''
+                logger.warning(warning_text)
+                command = 'generate_events %s' % self.name
+            if mode == "1":
+                command += " --cluster"
+            elif mode == "2":
+                command += " --nb_core=%s" % nb_node
+            
+            if self.force:
+                command+= " -f"
+            
+            if self.laststep:
+                command += ' --laststep=%s' % self.laststep
+            if self.reweight:
+                command += ' -R '
+            if self.madspin:
+                command += ' -M '
+            
+            
             try:
-                usecmd.do_set(line[3:], log=False)
-            except usecmd.InvalidCmd:
+                os.remove('ME5_debug')
+            except:
                 pass
-        usecmd.do_set('stdout_level %s'  % stdout_level,log=False)
-        #ensure that the logger level 
-        launch = self.cmd_int.define_child_cmd_interface(
-                     usecmd, interface=False)
-        #launch.me_dir = self.running_dir
-        if self.unit == 'pb':
-            command = 'generate_events %s' % self.name
-        else:
-            warning_text = '''\
-            Note that since 2.3. The launch for 1>N pass in event generation
-            For efficient width computation see arXiv:1402.1178.'''
-            logger.warning(warning_text)
-            command = 'generate_events %s' % self.name
-        if mode == "1":
-            command += " --cluster"
-        elif mode == "2":
-            command += " --nb_core=%s" % nb_node
-        
-        if self.force:
-            command+= " -f"
-        
-        if self.laststep:
-            command += ' --laststep=%s' % self.laststep
-        if self.reweight:
-            command += ' -R '
-        if self.madspin:
-            command += ' -M '
-        
-        
-        try:
-            os.remove('ME5_debug')
-        except:
-            pass
-
-        launch.run_cmd(command)
-        launch.run_cmd('quit')
-        
-        if os.path.exists('ME5_debug'):
-            return True
-        
-        # Display the cross-section to the screen
-        path = os.path.join(self.running_dir, 'SubProcesses', 'results.dat') 
-        if not os.path.exists(path):
-            logger.error('Generation failed (no results.dat file found)')
-            return
-        fsock = open(path)
-        line = fsock.readline()
-        cross, error = line.split()[0:2]
-        
-        logger.info('more information in %s' 
-                                 % os.path.join(self.running_dir, 'index.html'))
+    
+            launch.run_cmd(command)
+            launch.run_cmd('quit')
+            
+            if os.path.exists('ME5_debug'):
+                return True
+            
+            # Display the cross-section to the screen
+            path = os.path.join(self.running_dir, 'SubProcesses', 'results.dat') 
+            if not os.path.exists(path):
+                logger.error('Generation failed (no results.dat file found)')
+                return
+            fsock = open(path)
+            line = fsock.readline()
+            cross, error = line.split()[0:2]
+            
+            logger.info('more information in %s' 
+                                     % os.path.join(self.running_dir, 'index.html'))
                 
 
 class Pythia8Launcher(ExtLauncher):

=== modified file 'madgraph/interface/loop_interface.py'
--- madgraph/interface/loop_interface.py	2017-08-04 15:48:15 +0000
+++ madgraph/interface/loop_interface.py	2018-04-20 08:32:43 +0000
@@ -503,7 +503,7 @@
         if (opt['ninja'] is None) or (os.path.isfile(pjoin(MG5DIR, opt['ninja'],'libninja.a'))): 
             return
         
-        logger.info("First output using loop matrix-elements has been detected. Now asking for loop reduction:", '$MG:color:BLACK')
+        logger.info("First output using loop matrix-elements has been detected. Now asking for loop reduction:", '$MG:BOLD')
         to_install = self.ask('install', '0',  ask_class=AskLoopInstaller, timeout=300, 
                               path_msg=' ')
         

=== modified file 'madgraph/interface/madevent_interface.py'
--- madgraph/interface/madevent_interface.py	2018-04-06 09:56:08 +0000
+++ madgraph/interface/madevent_interface.py	2018-04-20 08:32:43 +0000
@@ -2590,7 +2590,7 @@
                     param_card_iterator.write(path)
                     name = misc.get_scan_name(orig_name, self.run_name)
                     path = pjoin(self.me_dir, 'Events','scan_%s.txt' % name)
-                    logger.info("write all cross-section results in %s" % path ,'$MG:color:BLACK')
+                    logger.info("write all cross-section results in %s" % path ,'$MG:BOLD')
                     param_card_iterator.write_summary(path)
 
             
@@ -2988,7 +2988,7 @@
             param_card_iterator.write(pjoin(self.me_dir,'Cards','param_card.dat'))
             scan_name = misc.get_scan_name(orig_name, self.run_name)
             path = pjoin(self.me_dir, 'Events','scan_%s.txt' % scan_name)
-            logger.info("write all cross-section results in %s" % path, '$MG:color:BLACK')
+            logger.info("write all cross-section results in %s" % path, '$MG:BOLD')
             param_card_iterator.write_summary(path)
     
 

=== modified file 'madgraph/interface/madgraph_interface.py'
--- madgraph/interface/madgraph_interface.py	2018-03-27 19:11:45 +0000
+++ madgraph/interface/madgraph_interface.py	2018-04-20 08:32:43 +0000
@@ -297,7 +297,7 @@
 
     def help_save(self):
         logger.info("syntax: save %s FILENAME" % "|".join(self._save_opts),'$MG:color:BLUE')
-        logger.info("-- save information as file FILENAME",'$MG:color:BLACK')
+        logger.info("-- save information as file FILENAME",'$MG:BOLD')
         logger.info("   FILENAME is optional for saving 'options'.")
         logger.info('   By default it uses ./input/mg5_configuration.txt')
         logger.info('   If you put "global" for FILENAME it will use ~/.mg5/mg5_configuration.txt')
@@ -306,14 +306,14 @@
 
     def help_load(self):
         logger.info("syntax: load %s FILENAME" % "|".join(self._save_opts),'$MG:color:BLUE')
-        logger.info("-- load information from file FILENAME",'$MG:color:BLACK')
+        logger.info("-- load information from file FILENAME",'$MG:BOLD')
 
     def help_import(self):
         logger.info("syntax: import " + "|".join(self._import_formats) + \
               " FILENAME",'$MG:color:BLUE')
         logger.info("-- imports file(s) in various formats",'$MG:color:GREEN')
         logger.info("")
-        logger.info("   import model MODEL[-RESTRICTION] [OPTIONS]:",'$MG:color:BLACK')
+        logger.info("   import model MODEL[-RESTRICTION] [OPTIONS]:",'$MG:BOLD')
         logger.info("      Import a UFO model.")
         logger.info("      MODEL should be a valid UFO model name")
         logger.info("      Model restrictions are specified by MODEL-RESTRICTION")
@@ -324,21 +324,21 @@
         logger.info("")
         logger.info("      Type 'display modellist' to have the list of all model available.",'$MG:color:GREEN')
         logger.info("")
-        logger.info("   import model_v4 MODEL [--modelname] :",'$MG:color:BLACK')
+        logger.info("   import model_v4 MODEL [--modelname] :",'$MG:BOLD')
         logger.info("      Import an MG4 model.")
         logger.info("      Model should be the name of the model")
         logger.info("      or the path to theMG4 model directory")
         logger.info("      '--modelname' keeps the original particle names for the model")
         logger.info("")
-        logger.info("   import proc_v4 [PATH] :",'$MG:color:BLACK')
+        logger.info("   import proc_v4 [PATH] :",'$MG:BOLD')
         logger.info("      Execute MG5 based on a proc_card.dat in MG4 format.")
         logger.info("      Path to the proc_card is optional if you are in a")
         logger.info("      madevent directory")
         logger.info("")
-        logger.info("   import command PATH :",'$MG:color:BLACK')
+        logger.info("   import command PATH :",'$MG:BOLD')
         logger.info("      Execute the list of command in the file at PATH")
         logger.info("")
-        logger.info("   import banner PATH  [--no_launch]:",'$MG:color:BLACK')
+        logger.info("   import banner PATH  [--no_launch]:",'$MG:BOLD')
         logger.info("      Rerun the exact same run define in the valid banner.")
 
     def help_install(self):
@@ -354,7 +354,7 @@
         logger.info("     --force        Overwrite without asking any existing installation.")
         logger.info("     --keep_source  Keep a local copy of the sources of the tools MG5_aMC installed from.")         
         logger.info(" ")
-        logger.info("   \"install update\"",'$MG:color:BLACK')
+        logger.info("   \"install update\"",'$MG:BOLD')
         logger.info("   check if your MG5 installation is the latest one.")
         logger.info("   If not it load the difference between your current version and the latest one,")
         logger.info("   and apply it to the code. Two options are available for this command:")
@@ -378,11 +378,11 @@
         # color schemes.
         #_launch_parser.print_help()
         logger.info("syntax: launch <dir_path> <options>",'$MG:color:BLUE')
-        logger.info("-- execute the aMC@NLO/madevent/standalone/pythia8 output present in dir_path",'$MG:color:BLACK')
+        logger.info("-- execute the aMC@NLO/madevent/standalone/pythia8 output present in dir_path",'$MG:BOLD')
         logger.info("By default, dir_path points to the last created directory.")
         logger.info("(for pythia8, it should be the Pythia 8 main directory)")
         logger.info("")
-        logger.info("Launch on madevent/pythia8/standalone outputs:",'$MG:color:BLACK')
+        logger.info("Launch on madevent/pythia8/standalone outputs:",'$MG:BOLD')
         logger.info(" o Example: launch PROC_sm_1 --name=run2",'$MG:color:GREEN')
         logger.info(" o Example: launch ../pythia8",'$MG:color:GREEN')
         logger.info(" > Options:")
@@ -397,7 +397,7 @@
         logger.info("                           last program run in MadEvent run.")
         logger.info("                           [auto|parton|pythia|pgs|delphes]")
         logger.info("")
-        logger.info("Launch on MadLoop standalone output:",'$MG:color:BLACK')
+        logger.info("Launch on MadLoop standalone output:",'$MG:BOLD')
         logger.info(" o Example: launch PROC_loop_sm_1 -f",'$MG:color:GREEN')
         logger.info(" > Simple check of a single Phase-space points.")
         logger.info(" > You will be asked whether you want to edit the MadLoop ")
@@ -405,7 +405,7 @@
         logger.info("   the -f option is specified. All other options are ")
         logger.info("   irrelevant for this kind of launch.")
         logger.info("")
-        logger.info("Launch on aMC@NLO output:",'$MG:color:BLACK')
+        logger.info("Launch on aMC@NLO output:",'$MG:BOLD')
         logger.info(" > launch <dir_path> <mode> <options>",'$MG:color:BLUE')
         logger.info(" o Example: launch MyProc aMC@NLO -f -p",'$MG:color:GREEN')
 
@@ -417,7 +417,7 @@
 
     def help_open(self):
         logger.info("syntax: open FILE  ",'$MG:color:BLUE')
-        logger.info("-- open a file with the appropriate editor.",'$MG:color:BLACK')
+        logger.info("-- open a file with the appropriate editor.",'$MG:BOLD')
         logger.info('   If FILE belongs to index.html, param_card.dat, run_card.dat')
         logger.info('   the path to the last created/used directory is used')
         logger.info('   The program used to open those files can be chosen in the')
@@ -425,16 +425,16 @@
 
     def help_customize_model(self):
         logger.info("syntax: customize_model --save=NAME",'$MG:color:BLUE')
-        logger.info("--  Open an invite where you options to tweak the model.",'$MG:color:BLACK')
+        logger.info("--  Open an invite where you options to tweak the model.",'$MG:BOLD')
         logger.info("    If you specify the option --save=NAME, this tweak will be")
         logger.info("    available for future import with the command 'import model XXXX-NAME'")
 
     def help_output(self):
         logger.info("syntax: output [" + "|".join(self._export_formats) + \
                     "] [path|.|auto] [options]",'$MG:color:BLUE')
-        logger.info("-- Output any generated process(es) to file.",'$MG:color:BLACK')
+        logger.info("-- Output any generated process(es) to file.",'$MG:BOLD')
         logger.info("   Default mode is madevent. Default path is \'.\' or auto.")
-        logger.info("   mode:",'$MG:color:BLACK')
+        logger.info("   mode:",'$MG:BOLD')
         logger.info("   - For MadLoop and aMC@NLO runs, there is only one mode and")
         logger.info("     it is set by default.")
         logger.info("   - If mode is madevent, create a MadEvent process directory.")
@@ -452,10 +452,10 @@
         logger.info("     valid options for aloha output are:")
         logger.info("      --format=Fortran|Python|Cpp : defining the output language")
         logger.info("      --output= : defining output directory")
-        logger.info("   path: The path of the process directory.",'$MG:color:BLACK')
+        logger.info("   path: The path of the process directory.",'$MG:BOLD')
         logger.info("     If you put '.' as path, your pwd will be used.")
         logger.info("     If you put 'auto', an automatic directory PROC_XX_n will be created.")
-        logger.info("   options:",'$MG:color:BLACK')
+        logger.info("   options:",'$MG:BOLD')
         logger.info("      -f: force cleaning of the directory if it already exists")
         logger.info("      -d: specify other MG/ME directory")
         logger.info("      -noclean: no cleaning performed in \"path\".")
@@ -468,8 +468,8 @@
 
     def help_check(self):
         logger.info("syntax: check [" + "|".join(self._check_opts) + "] [param_card] process_definition [--energy=] [--split_orders=] [--reduction=]",'$MG:color:BLUE')
-        logger.info("-- check a process or set of processes.",'$MG:color:BLACK')
-        logger.info("General options:",'$MG:color:BLACK')
+        logger.info("-- check a process or set of processes.",'$MG:BOLD')
+        logger.info("General options:",'$MG:BOLD')
         logger.info("o full:",'$MG:color:GREEN')
         logger.info("   Perform all four checks described below:")
         logger.info("   permutation, brs, gauge and lorentz_invariance.")
@@ -530,7 +530,7 @@
         logger.info(" > Except for the 'gauge' test, all checks above are also")
         logger.info("   available for loop processes with ML5 ('virt=' mode)")
         logger.info("Example: check full p p > j j",'$MG:color:GREEN')
-        logger.info("Options for loop processes only:",'$MG:color:BLACK')
+        logger.info("Options for loop processes only:",'$MG:BOLD')
         logger.info("o timing:",'$MG:color:GREEN')
         logger.info("   Generate and output a process and returns detailed")
         logger.info("   information about the code and a timing benchmark.")
@@ -560,7 +560,7 @@
     def help_generate(self):
 
         logger.info("-- generate diagrams for a given process",'$MG:color:BLUE')
-        logger.info("General leading-order syntax:",'$MG:color:BLACK')
+        logger.info("General leading-order syntax:",'$MG:BOLD')
         logger.info(" o generate INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2^2=ORDER2 @N")
         logger.info(" o Example: generate l+ vl > w+ > l+ vl a $ z / a h QED<=3 QCD=0 @1",'$MG:color:GREEN')
         logger.info(" > Alternative required s-channels can be separated by \"|\":")
@@ -576,11 +576,11 @@
         logger.info(" > allowed coupling operator are: \"==\", \"=\", \"<=\" and \">\".")
         logger.info("    \"==\" request exactly that number of coupling while \"=\" is interpreted as \"<=\".")
         logger.info(" > To generate a second process use the \"add process\" command")
-        logger.info("Decay chain syntax:",'$MG:color:BLACK')
+        logger.info("Decay chain syntax:",'$MG:BOLD')
         logger.info(" o core process, decay1, (decay2, (decay2', ...)), ...  etc")
         logger.info(" o Example: generate p p > t~ t QED=0, (t~ > W- b~, W- > l- vl~), t > j j b @2",'$MG:color:GREEN')
         logger.info(" > Note that identical particles will all be decayed.")
-        logger.info("Loop processes syntax:",'$MG:color:BLACK')
+        logger.info("Loop processes syntax:",'$MG:BOLD')
         logger.info(" o core process [ <NLO_mode=> LoopOrder1 LoopOrder2 ... ] SQUAREDCOUPi=ORDERi")
         logger.info(" o Example: generate p p > t~ t QED=0 QCD=2 [ all= QCD ] QCD=6",'$MG:color:GREEN')
         logger.info(" > Notice that in this format, decay chains are not allowed.")
@@ -604,7 +604,7 @@
         logger.info("   OR merge two model",'$MG:color:BLUE')
         logger.info('')
         logger.info("-- generate diagrams for a process and add to existing processes",'$MG:color:BLUE')
-        logger.info("General leading-order syntax:",'$MG:color:BLACK')
+        logger.info("General leading-order syntax:",'$MG:BOLD')
         logger.info(" o add process INITIAL STATE > REQ S-CHANNEL > FINAL STATE $ EXCL S-CHANNEL / FORBIDDEN PARTICLES COUP1=ORDER1 COUP2=ORDER2 @N")
         logger.info(" o Example: add process l+ vl > w+ > l+ vl a $ z / a h QED=3 QCD=0 @1",'$MG:color:GREEN')
         logger.info(" > Alternative required s-channels can be separated by \"|\":")
@@ -613,11 +613,11 @@
         logger.info("   orders to ensure maximum number of QCD vertices.")
         logger.info(" > Note that if there are more than one non-QCD coupling type,")
         logger.info("   coupling orders need to be specified by hand.")
-        logger.info("Decay chain syntax:",'$MG:color:BLACK')
+        logger.info("Decay chain syntax:",'$MG:BOLD')
         logger.info(" o core process, decay1, (decay2, (decay2', ...)), ...  etc")
         logger.info(" o Example: add process p p > t~ t QED=0, (t~ > W- b~, W- > l- vl~), t > j j b @2",'$MG:color:GREEN')
         logger.info(" > Note that identical particles will all be decayed.")
-        logger.info("Loop processes syntax:",'$MG:color:BLACK')
+        logger.info("Loop processes syntax:",'$MG:BOLD')
         logger.info(" o core process [ <NLO_mode=> LoopOrder1 LoopOrder2 ... ] SQUAREDCOUPi=ORDERi")
         logger.info(" o Example: add process p p > t~ t QED=0 QCD=2 [ all= QCD ] QCD=6",'$MG:color:GREEN')
         logger.info(" > Notice that in this format, decay chains are not allowed.")
@@ -637,7 +637,7 @@
         logger.info("   can still handle these.")
 
         logger.info("--  merge two model to create a new one", '$MG:color:BLUE')
-        logger.info("syntax:",'$MG:color:BLACK')
+        logger.info("syntax:",'$MG:BOLD')
         logger.info(" o add model MODELNAME [OPTIONS]")
         logger.info(" o Example: add model taudecay",'$MG:color:GREEN')
         logger.info(" > Merge the two model in a single one. If that same merge was done before.")
@@ -706,7 +706,7 @@
 
     def help_set(self):
         logger.info("-- set options for generation or output.",'$MG:color:BLUE')
-        logger.info("syntax: set <option_name> <option_value>",'$MG:color:BLACK')
+        logger.info("syntax: set <option_name> <option_value>",'$MG:BOLD')
         logger.info("Possible options are: ")
         for opts in [self._set_options[i*3:(i+1)*3] for i in \
                                           range((len(self._set_options)//4)+1)]:
@@ -716,8 +716,8 @@
         logger.info(" > (default Auto) Smart grouping of subprocesses into ")
         logger.info("   directories, mirroring of initial states, and ")
         logger.info("   combination of integration channels.")
-        logger.info(" > Example: p p > j j j w+ gives 5 directories and 184 channels",'$MG:color:BLACK')
-        logger.info("   (cf. 65 directories and 1048 channels for regular output)",'$MG:color:BLACK')
+        logger.info(" > Example: p p > j j j w+ gives 5 directories and 184 channels",'$MG:BOLD')
+        logger.info("   (cf. 65 directories and 1048 channels for regular output)",'$MG:BOLD')
         logger.info(" > Auto means False for decay computation and True for collisions.")
         logger.info("ignore_six_quark_processes multi_part_label",'$MG:color:GREEN')
         logger.info(" > (default none) ignore processes with at least 6 of any")
@@ -1081,7 +1081,7 @@
 
     def check_import(self, args):
         """check the validity of line"""
-
+        
         modelname = False
         prefix = True
         if '-modelname' in args:
@@ -1095,6 +1095,26 @@
             args.remove('--noprefix')
             prefix = False  
 
+        if args and args[0] == 'model' and '--last' in args:
+            # finding last created directory
+            args.remove('--last')
+            last_change =  0
+            to_search = [pjoin(MG5DIR,'models')]
+            if 'PYTHONPATH' in os.environ:
+                to_search += os.environ['PYTHONPATH'].split(':')
+                to_search = [d for d in to_search if os.path.exists(d)]
+            
+            models = []
+            for d in to_search:
+                for p in misc.glob('*/particles.py', path=d ):
+                    if p.endswith(('__REAL/particles.py','__COMPLEX/particles.py')):
+                        continue
+                    models.append(os.path.dirname(p))
+                
+            lastmodel = max(models, key=os.path.getmtime)
+            logger.info('last model found is %s', lastmodel)
+            args.insert(1, lastmodel)
+
         if not args:
             self.help_import()
             raise self.InvalidCmd('wrong \"import\" format')
@@ -1160,7 +1180,7 @@
             # to install as argument.   
             args = args[:1]
 
-        if args[0] not in self._install_opts + hidden_prog:
+        if args[0] not in self._install_opts + hidden_prog + self._advanced_install_opts: 
             if not args[0].startswith('td'):
                 self.help_install()
                 raise self.InvalidCmd('Not recognize program %s ' % args[0])
@@ -1499,7 +1519,6 @@
     def check_output(self, args, default='madevent'):
         """ check the validity of the line"""
 
-
         if args and args[0] in self._export_formats:
             self._export_format = args.pop(0)
         elif args:
@@ -2717,7 +2736,7 @@
         args = self.split_arg(line[0:begidx])
         # Format
         if len(args) == 1:
-            return self.list_completion(text, self._install_opts)
+            return self.list_completion(text, self._install_opts + self._advanced_install_opts)
         elif len(args) and args[0] == 'update':
             return self.list_completion(text, ['-f','--timeout='])
         elif len(args)>=2 and args[1] in self._advanced_install_opts:           
@@ -2763,7 +2782,7 @@
                    'gauge','lorentz', 'brs', 'cms']
     _import_formats = ['model_v4', 'model', 'proc_v4', 'command', 'banner']
     _install_opts = ['Delphes', 'MadAnalysis4', 'ExRootAnalysis',
-                     'update', 'SysCalc', 'Golem95', 'PJFry', 'QCDLoop', 'maddm']
+                     'update', 'SysCalc', 'Golem95', 'PJFry', 'QCDLoop']
     
     # The targets below are installed using the HEPToolsInstaller.py script
     _advanced_install_opts = ['pythia8','zlib','boost','lhapdf6','lhapdf5','collier',
@@ -4422,23 +4441,32 @@
         if not options['reuse']:
             process_checks.clean_up(self._mgme_dir)
 
+
+    def clean_process(self):
+        """ensure that all processes are cleaned from memory.
+        typically called from import model and generate XXX command
+        """
+
+        aloha_lib.KERNEL.clean()
+        # Reset amplitudes
+        self._curr_amps = diagram_generation.AmplitudeList()
+        # Reset Process definition
+        self._curr_proc_defs = base_objects.ProcessDefinitionList()
+        # Reset Helas matrix elements
+        self._curr_matrix_elements = helas_objects.HelasMultiProcess()
+        self._generate_info = ""
+        # Reset _done_export, since we have new process
+        self._done_export = False
+        # Also reset _export_format and _export_dir
+        self._export_format = None        
+        
+            
     # Generate a new amplitude
     def do_generate(self, line):
         """Main commands: Generate an amplitude for a given process"""
 
-        aloha_lib.KERNEL.clean()
-        # Reset amplitudes
-        self._curr_amps = diagram_generation.AmplitudeList()
-        # Reset Process definition
-        self._curr_proc_defs = base_objects.ProcessDefinitionList()
-        # Reset Helas matrix elements
-        self._curr_matrix_elements = helas_objects.HelasMultiProcess()
+        self.clean_process()
         self._generate_info = line
-        # Reset _done_export, since we have new process
-        self._done_export = False
-        # Also reset _export_format and _export_dir
-        self._export_format = None
-
 
         # Call add process
         args = self.split_arg(line)
@@ -4563,7 +4591,7 @@
                           if name not in orders and name not in squared_orders]
                 if to_set:
                     logger.info('the following coupling will be allowed up to the maximal value of %s: %s' % 
-                            (self.options['default_unset_couplings'], ', '.join(to_set)), '$MG:color:BLACK')
+                            (self.options['default_unset_couplings'], ', '.join(to_set)), '$MG:BOLD')
                 for name in to_set:
                     orders[name] = self.options['default_unset_couplings']
         
@@ -4791,7 +4819,15 @@
         else:
             optimize = False
 
-    
+        # Extract potential loop_filter  
+        loop_filter=None        
+        for arg in args:
+            if arg.startswith('--loop_filter='):
+                loop_filter = arg[14:]
+            #if not isinstance(self, extended_cmd.CmdShell):
+            #    raise self.InvalidCmd, "loop_filter is not allowed in web mode"
+        args = [a for a in args if not a.startswith('--loop_filter=')]
+        
         if not myprocdef:
             myprocdef = self.extract_process(' '.join(args))
         
@@ -4840,7 +4876,8 @@
         myproc = loop_diagram_generation.LoopInducedMultiProcess(myprocdef,
                                  collect_mirror_procs = collect_mirror_procs,
                                  ignore_six_quark_processes = ignore_six_quark_processes,
-                                 optimize=optimize)
+                                 optimize=optimize,
+                                 loop_filter=loop_filter)
 
         for amp in myproc.get('amplitudes'):
             if amp not in self._curr_amps:
@@ -5149,10 +5186,7 @@
         if args[0].startswith('model'):
             self._model_v4_path = None
             # Reset amplitudes and matrix elements
-            self._curr_amps = diagram_generation.AmplitudeList()
-            # Reset proc defs
-            self._curr_proc_defs = base_objects.ProcessDefinitionList()
-            self._curr_matrix_elements = helas_objects.HelasMultiProcess()
+            self.clean_process()
             # Import model
             if args[0].endswith('_v4'):
                 self._curr_model, self._model_v4_path = \
@@ -5638,9 +5672,9 @@
             
             if tool=='madanalysis5':
                 if not any(o.startswith(('--with_','--veto_','--update')) for o in add_options):
-                    logger.info('    To install recasting capabilities of madanalysis5 and/or', '$MG:color:BLACK')
-                    logger.info('    to allow delphes analysis at parton level.','$MG:color:BLACK')
-                    logger.info('    Please run \'install MadAnalysis5 --with_delphes --update\':', '$MG:color:BLACK')
+                    logger.info('    To install recasting capabilities of madanalysis5 and/or', '$MG:BOLD')
+                    logger.info('    to allow delphes analysis at parton level.','$MG:BOLD')
+                    logger.info('    Please run \'install MadAnalysis5 --with_delphes --update\':', '$MG:BOLD')
             
         elif return_code == 66:
             answer = self.ask(question=
@@ -5712,6 +5746,9 @@
 MG5aMC that supports quadruple precision (typically g++ based on gcc 4.6+).""")
             self.options['ninja'] = pjoin(prefix,'lib')
             self.exec_cmd('save options %s ninja' % config_file, printcmd=False, log=False)      
+        elif '%s_path' % tool in self.options:
+            self.options['%s_path' % tool] = pjoin(prefix, tool)
+            self.exec_cmd('save options %s %s_path'  % (config_file,tool), printcmd=False, log=False)      
             
         # Now warn the user if he didn't add HEPTools first in his environment
         # variables.
@@ -5761,34 +5798,8 @@
          # Return true for successful installation
         return True
 
-    def do_install(self, line, paths=None, additional_options=[]):
-        """Install optional package from the MG suite.
-        The argument 'additional_options' will be passed to the advanced_install
-        functions. If it contains the option '--force', then the advanced_install
-        function will overwrite any existing installation of the tool without 
-        warnings.
-        """
-        
-        # Make sure to avoid any border effect on custom_additional_options
-        add_options = list(additional_options)
-        
-        args = self.split_arg(line)
-        #check the validity of the arguments
-        install_options = self.check_install(args)
-
-        if sys.platform == "darwin":
-            program = "curl"
-        else:
-            program = "wget"
-
-        # special command for auto-update
-        if args[0] == 'update':
-            self.install_update(['update']+install_options['update_options'],wget=program)
-            return
-
-        plugin = ['maddm']
-        
-        advertisements = {'pythia-pgs':['arXiv:0603175'],
+    install_plugin = ['maddm']
+    install_ad = {'pythia-pgs':['arXiv:0603175'],
                           'Delphes':['arXiv:1307.6346'],
                           'Delphes2':['arXiv:0903.2225'],
                           'SysCalc':['arXiv:1801.08401'],
@@ -5806,15 +5817,54 @@
                           'collier':['arXiv:1604.06792'],
                           'oneloop':['arXiv:1007.4716'],
                           'maddm':['arXiv:1505.04190']}
+    install_server = ['http://madgraph.phys.ucl.ac.be/package_info.dat',
+                         'http://madgraph.physics.illinois.edu/package_info.dat']
+    install_name = {'td_mac': 'td', 'td_linux':'td', 'Delphes2':'Delphes',
+                'Delphes3':'Delphes', 'pythia-pgs':'pythia-pgs',
+                'ExRootAnalysis': 'ExRootAnalysis','MadAnalysis':'madanalysis5',
+                'MadAnalysis4':'MadAnalysis',
+                'SysCalc':'SysCalc', 'Golem95': 'golem95',
+                'PJFry':'PJFry','QCDLoop':'QCDLoop','MadAnalysis5':'madanalysis5',
+                'maddm':'maddm'
+                }
+
+    def do_install(self, line, paths=None, additional_options=[]):
+        """Install optional package from the MG suite.
+        The argument 'additional_options' will be passed to the advanced_install
+        functions. If it contains the option '--force', then the advanced_install
+        function will overwrite any existing installation of the tool without 
+        warnings.
+        """
+        
+        # Make sure to avoid any border effect on custom_additional_options
+        add_options = list(additional_options)
+        
+        args = self.split_arg(line)
+        #check the validity of the arguments
+        install_options = self.check_install(args)
+
+        if sys.platform == "darwin":
+            program = "curl"
+        else:
+            program = "wget"
+
+        # special command for auto-update
+        if args[0] == 'update':
+            self.install_update(['update']+install_options['update_options'],wget=program)
+            return
+
+        plugin = self.install_plugin
+        
+        advertisements = self.install_ad
 
 
         if args[0] in advertisements:
-#            logger.info('{:^80}'.format("-"*70), '$MG:color:BLACK')
-#            logger.info('{:^80}'.format("You are installing '%s', please cite ref(s):"%args[0]), '$MG:color:BLACK')
+#            logger.info('{:^80}'.format("-"*70), '$MG:BOLD')
+#            logger.info('{:^80}'.format("You are installing '%s', please cite ref(s):"%args[0]), '$MG:BOLD')
 #            logger.info('{:^80}'.format(', '.join(advertisements[args[0]])), '$MG:color:GREEN')
-#            logger.info('{:^80}'.format("when using results produced with this tool."), '$MG:color:BLACK')
-#            logger.info('{:^80}'.format("-"*70), '$MG:color:BLACK')
-            logger.info("   You are installing '%s', please cite ref(s): \033[92m%s\033[0m. " % (args[0], ', '.join(advertisements[args[0]])), '$MG:color:BLACK')
+#            logger.info('{:^80}'.format("when using results produced with this tool."), '$MG:BOLD')
+#            logger.info('{:^80}'.format("-"*70), '$MG:BOLD')
+            logger.info("   You are installing '%s', please cite ref(s): \033[92m%s\033[0m. " % (args[0], ', '.join(advertisements[args[0]])), '$MG:BOLD')
 
         # Load file with path of the different program:
         import urllib
@@ -5823,8 +5873,7 @@
         else:
             path = {}
     
-            data_path = ['http://madgraph.phys.ucl.ac.be/package_info.dat',
-                         'http://madgraph.physics.illinois.edu/package_info.dat']
+            data_path = self.install_server
 
 #           Force here to choose one particular server
             if any(a.startswith('--source=') for a in args):
@@ -5864,15 +5913,11 @@
 
         if args[0] == 'Delphes':
             args[0] = 'Delphes3'
+        if args[0] == 'MadAnalysis4':
+            args[0] = 'MadAnalysis'
 
         try:
-            name = {'td_mac': 'td', 'td_linux':'td', 'Delphes2':'Delphes',
-                'Delphes3':'Delphes', 'pythia-pgs':'pythia-pgs',
-                'ExRootAnalysis': 'ExRootAnalysis','MadAnalysis':'madanalysis5',
-                'MadAnalysis4':'MadAnalysis',
-                'SysCalc':'SysCalc', 'Golem95': 'golem95',
-                'PJFry':'PJFry','QCDLoop':'QCDLoop','MadAnalysis5':'madanalysis5'
-                }
+            name = self.install_name
             name = name[args[0]]
         except KeyError:
             name = args[0]
@@ -5900,19 +5945,7 @@
 
         if args[0] == 'Delphes':
             args[0] = 'Delphes3'        
-        if args[0] == 'MadAnalysis4':
-            args[0] = 'MadAnalysis'
-        try:
-            name = {'td_mac': 'td', 'td_linux':'td', 'Delphes2':'Delphes',
-                'Delphes3':'Delphes', 'pythia-pgs':'pythia-pgs',
-                'ExRootAnalysis': 'ExRootAnalysis','MadAnalysis':'MadAnalysis',
-                'SysCalc':'SysCalc', 'Golem95': 'golem95',
-                'PJFry':'PJFry','QCDLoop':'QCDLoop',
-                'maddm':'maddm'
-                }
-            name = name[args[0]]
-        except:
-            pass
+
 
         #check outdated install
         substitution={'Delphes2':'Delphes','pythia-pgs':'pythia8'}
@@ -5948,6 +5981,8 @@
                 created_name = created_name[0]
             files.mv(pjoin(MG5DIR, created_name), pjoin(MG5DIR, name))
 
+        if hasattr(self, 'post_install_%s' %name):
+            return getattr(self, 'post_install_%s' %name)()
 
         logger.info('compile %s. This might take a while.' % name)
 
@@ -7402,7 +7437,6 @@
         # Check Argument validity
         self.check_output(args)
 
-
         noclean = '-noclean' in args
         force = '-f' in args
         nojpeg = '-nojpeg' in args
@@ -8182,7 +8216,7 @@
         #compile the code
         if not os.path.exists(pjoin(model_path, 'SMWidth','smwidth')):
             logger.info('Compiling SMWidth. This has to be done only once and'+\
-                            ' can take a couple of minutes.','$MG:color:BLACK')
+                            ' can take a couple of minutes.','$MG:BOLD')
             current = misc.detect_current_compiler(pjoin(model_path, 'SMWidth',
                                                          'makefile_MW5'))
             new = 'gfortran' if self.options_configuration['fortran_compiler'] is None else \

=== modified file 'madgraph/interface/madweight_interface.py'
--- madgraph/interface/madweight_interface.py	2017-07-13 15:12:05 +0000
+++ madgraph/interface/madweight_interface.py	2018-04-20 08:32:43 +0000
@@ -275,7 +275,7 @@
         if not self.options['cluster_temp_path']:
             if self.options['run_mode'] == 2:
                 logger.info('Options cluster_temp_path is required for MW run. Trying to run with /tmp',
-                                '$MG:color:BLACK')
+                                '$MG:BOLD')
                 self.exec_cmd('set cluster_temp_path /tmp --no_save')
             elif self.options['cluster_type'] != 'condor':
                 raise Exception, 'cluster_temp_path needs to be define for MW. Please retry.'

=== modified file 'madgraph/interface/master_interface.py'
--- madgraph/interface/master_interface.py	2017-11-30 23:06:17 +0000
+++ madgraph/interface/master_interface.py	2018-04-20 08:32:43 +0000
@@ -216,13 +216,15 @@
                                                             coupling_type=orders)
                     self.change_principal_cmd('MadGraph')
                     return self.cmd.create_loop_induced(self, line, *args, **opts)
+            else:
+                self.change_principal_cmd('MadGraph') 
         try:
             return  self.cmd.do_add(self, line, *args, **opts)
         except fks_base.NoBornException:
-            logger.info("------------------------------------------------------------------------", '$MG:color:BLACK')
-            logger.info(" No Born diagrams found. Now switching to the loop-induced mode.        ", '$MG:color:BLACK')
-            logger.info(" Please cite ref. 'arXiv:1507.00020' when using results from this mode. ", '$MG:color:BLACK')
-            logger.info("------------------------------------------------------------------------", '$MG:color:BLACK')            
+            logger.info("------------------------------------------------------------------------", '$MG:BOLD')
+            logger.info(" No Born diagrams found. Now switching to the loop-induced mode.        ", '$MG:BOLD')
+            logger.info(" Please cite ref. 'arXiv:1507.00020' when using results from this mode. ", '$MG:BOLD')
+            logger.info("------------------------------------------------------------------------", '$MG:BOLD')            
             self.change_principal_cmd('MadGraph')
             return self.cmd.create_loop_induced(self, line, *args, **opts)
 
@@ -607,6 +609,7 @@
                             %','.join(interface_quick_name.keys()))
         
     def change_principal_cmd(self, name):
+
         old_cmd=self.current_interface
         if name in self.interface_names.keys():
             self.prompt= self.interface_names[name][0]+'>'

=== modified file 'madgraph/interface/reweight_interface.py'
--- madgraph/interface/reweight_interface.py	2018-03-28 08:21:22 +0000
+++ madgraph/interface/reweight_interface.py	2018-04-20 08:32:43 +0000
@@ -915,6 +915,33 @@
     def do_compute_widths(self, line):
         return self.mother.do_compute_widths(line)
     
+    
+    dynamical_scale_warning=True
+    def change_kinematics(self, event):
+ 
+
+        if isinstance(self.run_card, banner.RunCardLO):
+            jac = event.change_ext_mass(self.new_param_card)
+            new_event = event
+        else:
+            jac =1
+            new_event = event
+
+        if jac != 1:
+            if self.output_type == 'default':
+                logger.critical('mass reweighting requires dedicated lhe output!. Please include "change output 2.0" in your reweight_card')
+                raise Exception
+            mode = self.run_card['dynamical_scale_choice']
+            if mode == -1:
+                if self.dynamical_scale_warning:
+                    logger.warning('dynamical_scale is set to -1. New sample will be with HT/2 dynamical scale for renormalisation scale')
+                mode = 3
+            new_event.scale = event.get_scale(mode)
+            new_event.aqcd = self.lhe_input.get_alphas(new_event.scale, lhapdf_config=self.mother.options['lhapdf'])
+         
+        return jac, new_event
+    
+    
     def calculate_weight(self, event):
         """space defines where to find the calculator (in multicore)"""
         
@@ -927,27 +954,15 @@
         orig_wgt = event.wgt
         # LO reweighting    
         w_orig = self.calculate_matrix_element(event, 0)
+        
         # reshuffle event for mass effect # external mass only
-        if isinstance(self.run_card, banner.RunCardLO):
-            jac = event.change_ext_mass(self.new_param_card)
-        else:
-            jac =1
-
-        if jac != 1:
-            if self.output_type == 'default':
-                logger.critical('mass reweighting requires dedicated lhe output!. Please include "change output 2.0" in your reweight_card')
-                raise Exception
-            mode = self.run_card['dynamical_scale_choice']
-            if mode == -1:
-                logger.warning('dynamical_scale is set to -1. New sample will be with HT/2 dynamical scale for renormalisation scale')
-                mode = 3
-            event.scale = event.get_scale(mode)
-            event.aqcd = self.lhe_input.get_alphas(event.scale, lhapdf_config=self.mother.options['lhapdf'])
- 
+        # carefull that new_event can sometimes be = to event 
+        # (i.e. change can be in place)
+        jac, new_event = self.change_kinematics(event)
         
         
         if event.wgt != 0: # impossible reshuffling
-            w_new =  self.calculate_matrix_element(event, 1)
+            w_new =  self.calculate_matrix_element(new_event, 1)
         else:
             w_new = 0
 
@@ -1697,9 +1712,19 @@
                 continue 
             pdir = pjoin(path_me, onedir, 'SubProcesses')
             for tag in [2*metag,2*metag+1]:
-                with misc.TMP_variable(sys, 'path', [pjoin(path_me)]+sys.path):
-                    mymod = __import__('%s.SubProcesses.allmatrix%spy' % (onedir, tag), globals(), locals(), [],-1)
-                    reload(mymod)
+                with misc.TMP_variable(sys, 'path', [pjoin(path_me)]+sys.path):      
+                    mod_name = '%s.SubProcesses.allmatrix%spy' % (onedir, tag)
+                    #mymod = __import__('%s.SubProcesses.allmatrix%spy' % (onedir, tag), globals(), locals(), [],-1)
+                    if mod_name in sys.modules.keys():
+                        del sys.modules[mod_name]
+                        tmp_mod_name = mod_name
+                        while '.' in tmp_mod_name:
+                            tmp_mod_name = tmp_mod_name.rsplit('.',1)[0]
+                            del sys.modules[tmp_mod_name]
+                        mymod = __import__(mod_name, globals(), locals(), [],-1)  
+                    else:
+                        mymod = __import__(mod_name, globals(), locals(), [],-1)    
+                    
                     S = mymod.SubProcesses
                     mymod = getattr(S, 'allmatrix%spy' % tag)
                 
@@ -1713,7 +1738,7 @@
             data = self.id_to_path
             if '_second' in onedir:
                 data = self.id_to_path_second
-                
+
             # get all the information
             all_pdgs = mymod.get_pdg_order()
             all_pdgs = [[pdg for pdg in pdgs if pdg!=0] for pdgs in  mymod.get_pdg_order()]
@@ -1746,7 +1771,6 @@
                 else:
                     incoming = pdg[0:2]
                     outgoing = pdg[2:]
-                misc.sprint(incoming, outgoing)
                 order = (list(incoming), list(outgoing))
                 incoming.sort()
                 outgoing.sort()
@@ -1774,7 +1798,7 @@
                         misc.sprint(data[tag][:-1])
                         misc.sprint(order, pdir,)
                         raise Exception
-                
+
                 data[tag] = order, pdir, hel
              
              

=== modified file 'madgraph/interface/tutorial_text.py'
--- madgraph/interface/tutorial_text.py	2015-10-01 16:00:08 +0000
+++ madgraph/interface/tutorial_text.py	2018-04-20 08:32:43 +0000
@@ -1,6 +1,6 @@
 ################################################################################
 #
-# Copyright (c) 2009 The MadGraph5_aMC@NLO Development team and Contributors
+# Copyright (c) 2018 The MadGraph5_aMC@NLO Development team and Contributors
 #
 # This file is a part of the MadGraph5_aMC@NLO project, an application which 
 # automatically generates Feynman diagrams and matrix elements for arbitrary
@@ -77,11 +77,10 @@
 """
 output = """
 If you are following the tutorial, a directory MY_FIRST_MG5_RUN has
-been created which can be used in order to run MadEvent exactly as if
-it was coming from MG4.
+been created which can be used in order to generate LO events/compute cross-section.
 
-Additionally to the MG4 command (see MY_FIRST_MG5_RUN/README), you can also 
-generate your events/compute the cross-section from this interface:
+From that directory you can run the command './bin/generate_events'
+You can also  generate your events/compute the cross-section from this interface:
 Please Enter:
 MG5_aMC> launch MY_FIRST_MG5_RUN
 (you can interrupt the computation to continue the tutorial by pressing Ctrl-C)
@@ -110,13 +109,17 @@
    MadEvent output
 
 To import a model, write:
-MG5_aMC>import model mssm
+MG5_aMC>import model MSSM_SLHA2
 """
 
 import_model ="""
 You have successfully imported a model. If you followed the tutorial
 this is the MSSM.
 
+MadGraph can auto-download a large class of model (and more can be used). 
+To see the full list of model, write:
+MG5_aMC>display modellist 
+
 If you want to know more information about this model you can use the
 following commands:
 MG5_aMC>display particles
@@ -194,9 +197,9 @@
 different command in a single line: 
 MG5_aMC>generate p p > go go; display diagrams
 
-Note that when you run output [madevent_v4], the diagrams are
+Note that when you run output [madevent], the diagrams are
 automatically written to the matrix.ps files in subprocess
-directory, just like with MadGraph 4.
+directory.
 """
 
 display_diagrams = """

=== modified file 'madgraph/iolibs/export_v4.py'
--- madgraph/iolibs/export_v4.py	2018-02-20 18:09:19 +0000
+++ madgraph/iolibs/export_v4.py	2018-04-20 08:32:43 +0000
@@ -3784,7 +3784,17 @@
         if  not isinstance(self, ProcessExporterFortranMEGroup):
             self.proc_characteristic['grouped_matrix'] = False
         self.proc_characteristic['complex_mass_scheme'] = mg5options['complex_mass_scheme']
-
+        # indicate the PDG of all initial particle
+        try:
+            pdgs1 = [p.get_initial_pdg(1) for me in matrix_elements for m in me.get('matrix_elements') for p in m.get('processes') if p.get_initial_pdg(1)]
+            pdgs2 = [p.get_initial_pdg(2) for me in matrix_elements for m in me.get('matrix_elements') for p in m.get('processes') if p.get_initial_pdg(2)]
+        except AttributeError:
+            pdgs1 = [p.get_initial_pdg(1) for m in matrix_elements.get('matrix_elements') for p in m.get('processes') if p.get_initial_pdg(1)]
+            pdgs2 = [p.get_initial_pdg(2) for m in matrix_elements.get('matrix_elements') for p in m.get('processes') if p.get_initial_pdg(2)]
+        self.proc_characteristic['pdg_initial1'] = pdgs1
+        self.proc_characteristic['pdg_initial2'] = pdgs2
+        
+        
         modelname = self.opt['model']
         if modelname == 'mssm' or modelname.startswith('mssm-'):
             param_card = pjoin(self.dir_path, 'Cards','param_card.dat')

=== modified file 'madgraph/iolibs/file_writers.py'
--- madgraph/iolibs/file_writers.py	2016-12-01 22:06:31 +0000
+++ madgraph/iolibs/file_writers.py	2018-04-20 08:32:43 +0000
@@ -86,7 +86,7 @@
 
         pass
 
-    def writelines(self, lines, context={}):
+    def writelines(self, lines, context={}, formatting=True):
         """Extends the regular file.writeline() function to write out
         nicely formatted code. When defining a context, then the lines
         will be preprocessed to apply possible conditional statements on the
@@ -107,7 +107,10 @@
             splitlines = self.preprocess_template(splitlines,context=context)
 
         for line in splitlines:
-            res_lines = self.write_line(line)
+            if formatting:
+                res_lines = self.write_line(line)
+            else:
+                res_lines = [line+'\n']
             for line_to_write in res_lines:
                 self.write(line_to_write)
                 
@@ -200,6 +203,7 @@
     __indent = 0
     __keyword_list = []
     __comment_pattern = re.compile(r"^(\s*#|c$|(c\s+([^=]|$))|cf2py|c\-\-|c\*\*)", re.IGNORECASE)
+    __continuation_line = re.compile(r"(?:     )[$&]")
 
     def write_line(self, line):
         """Write a fortran line, with correct indent and line splits"""
@@ -220,7 +224,8 @@
             # This is a comment
             res_lines = self.write_comment_line(line.lstrip()[1:])
             return res_lines
-
+        elif self.__continuation_line.search(line):
+            return line+'\n'
         else:
             # This is a regular Fortran line
 

=== modified file 'madgraph/iolibs/files.py'
--- madgraph/iolibs/files.py	2017-09-24 21:24:55 +0000
+++ madgraph/iolibs/files.py	2018-04-20 08:32:43 +0000
@@ -227,6 +227,7 @@
         os.symlink(target, os.path.join(starting_dir, name))
     except Exception, error:
         if log:
+            logger.debug(error)
             logger.warning('Could not link %s at position: %s' % (file_pos, \
                                                 os.path.realpath(starting_dir)))
 

=== modified file 'madgraph/loop/loop_exporters.py'
--- madgraph/loop/loop_exporters.py	2017-07-31 12:50:36 +0000
+++ madgraph/loop/loop_exporters.py	2018-04-20 08:32:43 +0000
@@ -155,7 +155,7 @@
         elif self.dependencies=='external':
             if not os.path.exists(os.path.join(self.cuttools_dir,'includects','libcts.a')):
                 logger.info('Compiling CutTools. This has to be done only once and'+\
-                                  ' can take a couple of minutes.','$MG:color:BLACK')
+                                  ' can take a couple of minutes.','$MG:BOLD')
                 current = misc.detect_current_compiler(os.path.join(\
                                                   self.cuttools_dir,'makefile'))
                 new = 'gfortran' if self.fortran_compiler is None else \
@@ -1978,7 +1978,7 @@
                 
                 
                 logger.info('Compiling IREGI. This has to be done only once and'+\
-                             ' can take a couple of minutes.','$MG:color:BLACK')
+                             ' can take a couple of minutes.','$MG:BOLD')
                 
                 current = misc.detect_current_compiler(os.path.join(\
                                                     libpath,'makefile_ML5_lib'))

=== modified file 'madgraph/various/banner.py'
--- madgraph/various/banner.py	2018-03-09 15:38:21 +0000
+++ madgraph/various/banner.py	2018-04-20 08:32:43 +0000
@@ -1086,7 +1086,7 @@
                         val = val.lower()
                         allowed = allowed.lower()
                         if value in allowed:
-                            i = allowed.find(value)
+                            i = allowed.index(value)
                             new_values.append(self.allowed_value[i])
                             continue
                     # no continue -> bad input
@@ -1186,10 +1186,10 @@
                 valid=True     
             elif isinstance(value, str):
                 value = value.lower()
-                allowed = allowed.lower()
+                allowed = [v.lower() for v in allowed]
                 if value in allowed:
-                    i = allowed.find(value)
-                    value = self.allowed_value[i]
+                    i = allowed.index(value)
+                    value = self.allowed_value[lower_name][i]
                     valid=True
                     
             if not valid:
@@ -1288,10 +1288,10 @@
                 if new_value == value:
                     value = new_value
                 else:
-                    raise Exception, "Wrong input type for %s found %s and expecting %s for value %s" %\
+                    raise InvalidCmd, "Wrong input type for %s found %s and expecting %s for value %s" %\
                         (name, type(value), targettype, value)
             else:
-                raise Exception, "Wrong input type for %s found %s and expecting %s for value %s" %\
+                raise InvalidCmd, "Wrong input type for %s found %s and expecting %s for value %s" %\
                         (name, type(value), targettype, value)                
         else:
             # We have a string we have to format the attribute from the string
@@ -1305,7 +1305,7 @@
                 elif value.lower() in ['1', '.true.', 't', 'true', 'on']:
                     value = True
                 else:
-                    raise Exception, "%s can not be mapped to True/False for %s" % (repr(value),name)
+                    raise InvalidCmd, "%s can not be mapped to True/False for %s" % (repr(value),name)
             elif targettype == str:
                 value = value.strip()
                 if value.startswith('\'') and value.endswith('\''):
@@ -1324,16 +1324,16 @@
                     try:
                         value = float(value.replace('d','e'))
                     except ValueError:
-                        raise Exception, "%s can not be mapped to an integer" % value                    
+                        raise InvalidCmd, "%s can not be mapped to an integer" % value                    
                     try:
                         new_value = int(value)
                     except ValueError:
-                        raise Exception, "%s can not be mapped to an integer" % value
+                        raise InvalidCmd, "%s can not be mapped to an integer" % value
                     else:
                         if value == new_value:
                             value = new_value
                         else:
-                            raise Exception, "incorect input: %s need an integer for %s" % (value,name)
+                            raise InvalidCmd, "incorect input: %s need an integer for %s" % (value,name)
             elif targettype == float:
                 value = value.replace('d','e') # pass from Fortran formatting
                 try:
@@ -1349,11 +1349,11 @@
                                 v /=  float(split[2*i+2])
                     except:
                         v=0
-                        raise Exception, "%s can not be mapped to a float" % value
+                        raise InvalidCmd, "%s can not be mapped to a float" % value
                     finally:
                         value = v
             else:
-                raise Exception, "type %s is not handle by the card" % targettype
+                raise InvalidCmd, "type %s is not handle by the card" % targettype
             
         return value
             
@@ -1409,7 +1409,9 @@
         self.add_param('bias_module','None')
         self.add_param('max_n_matched_jets', 0)
         self.add_param('colored_pdgs', [1,2,3,4,5])
-        self.add_param('complex_mass_scheme', False)        
+        self.add_param('complex_mass_scheme', False)
+        self.add_param('pdg_initial1', [0])
+        self.add_param('pdg_initial2', [0])        
 
     def read(self, finput):
         """Read the input file, this can be a path to a file, 
@@ -1883,7 +1885,9 @@
         started_subrun_reading = False
         while line!='':
             # Skip comments
-            if line.strip().startswith('!') or line.strip().startswith('\n'):
+            if line.strip().startswith('!') or \
+               line.strip().startswith('\n') or\
+               line.strip() == '':
                 output.write(line)
                 # Proceed to next line
                 last_pos = tmpl.tell()
@@ -2033,8 +2037,8 @@
         # If 'LHEFInputs:nSubruns' is not user_set, then make sure it is
         # updated at least larger or equal to the maximum SubRunID
         if 'LHEFInputs:nSubruns'.lower() not in self.user_set and \
-             len(subruns_to_write)>0 and self['LHEFInputs:nSubruns']<\
-                                                   max(subruns_to_write.keys()):
+             len(subruns_to_write)>0 and 'LHEFInputs:nSubruns' in self\
+             and self['LHEFInputs:nSubruns']<max(subruns_to_write.keys()):
             logger.info("Updating PY8 parameter 'LHEFInputs:nSubruns' to "+
           "%d so as to cover all defined subruns."%max(subruns_to_write.keys()))
             self['LHEFInputs:nSubruns'] = max(subruns_to_write.keys())
@@ -2206,6 +2210,8 @@
         self.cuts_parameter = []
         # parameter added where legacy requires an older value.
         self.system_default = {}
+        
+        self.warned=False
 
 
         
@@ -2238,10 +2244,7 @@
         if legacy:
             self.legacy_parameter[name] = value
             include = False
-        if include is True:
-            self.includepath[True].append(name)
-        elif include:
-            self.includepath[include].append(name)
+        self.includepath[include].append(name)
         if hidden or system:
             self.hidden_param.append(name)
         if cut:
@@ -2287,11 +2290,13 @@
                         raise
                     
                 
-    def write(self, output_file, template=None, python_template=False):
+    def write(self, output_file, template=None, python_template=False,
+                    write_hidden=False):
         """Write the run_card in output_file according to template 
            (a path to a valid run_card)"""
 
         to_write = set(self.user_set) 
+        written = set()
         if not template:
             raise Exception
 
@@ -2324,23 +2329,37 @@
                             endline = '\n'
                         else:
                             endline = ''
-                        text += '  %s\t= %s %s%s' % (value, name, comment, endline)                        
+                        text += '  %s\t= %s %s%s' % (value, name, comment, endline)
+                        written.add(name)                        
 
                     if name.lower() in to_write:
                         to_write.remove(nline[1].strip().lower())
                 else:
                     logger.info('Adding missing parameter %s to current %s (with default value)',
                                  (name, self.filename))
+                    written.add(name) 
                     text += line 
 
-        if to_write:
+        if to_write or write_hidden:
             text+="""#********************************************************************* 
-#  Additional parameter
+#  Additional hidden parameters
 #*********************************************************************
-"""
-            
+"""            
+            if write_hidden:
+                #
+                # do not write hidden parameter not hidden for this template 
+                #
+                if python_template:
+                    written = written.union(set(re.findall('\%\((\w*)\)s', file(template,'r').read(), re.M)))
+                to_write = to_write.union(set(self.hidden_param))
+                to_write = to_write.difference(written)
+
             for key in to_write:
-                text += '  %s\t= %s # %s\n' % (self[key], key, 'hidden parameter')
+                if key in self.system_only:
+                    continue
+
+                comment = self.comments.get(key,'hidden_parameter').replace('\n','\n#')
+                text += '  %s\t= %s # %s\n' % (self[key], key, comment)
 
         if isinstance(output_file, str):
             fsock = open(output_file,'w')
@@ -2367,6 +2386,7 @@
                     log_level = 20
             if not default:
                 default = dict.__getitem__(self, name.lower())
+ 
             logger.log(log_level, '%s missed argument %s. Takes default: %s'
                                    % (self.filename, name, default))
             self[name] = default
@@ -2426,11 +2446,18 @@
                 return "'%s'" % value
         
 
-    def check_validity(self):
+    
+    def check_validity(self, log_level=30):
         """check that parameter missing in the card are set to the expected value"""
 
         for name, value in self.system_default.items():
                 self.set(name, value, changeifuserset=False)
+        
+
+        for name in self.includepath[False]:
+            to_bypass = self.hidden_param + self.legacy_parameter.keys()
+            if name not in to_bypass:
+                self.get_default(name, log_level=log_level) 
 
         for name in self.legacy_parameter:
             if self[name] != self.legacy_parameter[name]:
@@ -2457,6 +2484,8 @@
         for incname in self.includepath:
             if incname is True:
                 pathinc = self.default_include_file
+            elif incname is False:
+                continue
             else:
                 pathinc = incname
                 
@@ -2498,28 +2527,26 @@
                     fsock.writelines(line)
             fsock.close()   
 
+    @staticmethod
+    def get_idbmup(lpp):
+        """return the particle colliding pdg code"""
+        if lpp in (1,2, -1,-2):
+            return math.copysign(2212, lpp)
+        elif lpp in (3,-3):
+            return math.copysign(11, lpp)
+        elif lpp == 0:
+            #logger.critical("Fail to write correct idbmup in the lhe file. Please correct those by hand")
+            return 0
+        else:
+            return lpp
 
     def get_banner_init_information(self):
         """return a dictionary with the information needed to write
         the first line of the <init> block of the lhe file."""
         
         output = {}
-        
-        def get_idbmup(lpp):
-            """return the particle colliding pdg code"""
-            if lpp in (1,2, -1,-2):
-                return math.copysign(2212, lpp)
-            elif lpp in (3,-3):
-                return math.copysign(11, lpp)
-            elif lpp == 0:
-                #logger.critical("Fail to write correct idbmup in the lhe file. Please correct those by hand")
-                return 0
-            else:
-                return lpp
-        
-            
-        output["idbmup1"] = get_idbmup(self['lpp1'])
-        output["idbmup2"] = get_idbmup(self['lpp2'])
+        output["idbmup1"] = self.get_idbmup(self['lpp1'])
+        output["idbmup2"] = self.get_idbmup(self['lpp2'])
         output["ebmup1"] = self["ebeam1"]
         output["ebmup2"] = self["ebeam2"]
         output["pdfgup1"] = 0
@@ -2570,7 +2597,7 @@
         
         self.add_param("run_tag", "tag_1", include=False)
         self.add_param("gridpack", False)
-        self.add_param("time_of_flight", -1.0, include=False, hidden=True)
+        self.add_param("time_of_flight", -1.0, include=False)
         self.add_param("nevents", 10000)        
         self.add_param("iseed", 0)
         self.add_param("lpp1", 1, fortran_name="lpp(1)", allowed=[-1,1,0,2,3,9, -2,-3],
@@ -2738,7 +2765,7 @@
         self.add_param("sys_alpsfact", "None", include=False)
         self.add_param("sys_matchscale", "auto", include=False)
         self.add_param("sys_pdf", "NNPDF23_lo_as_0130_qed", include=False)
-        self.add_param("sys_scalecorrelation", -1, include=False)
+        self.add_param("sys_scalecorrelation", -1, include=False, hidden=True)
 
         #parameter not in the run_card by default
         self.add_param('gridrun', False, hidden=True)
@@ -2763,17 +2790,17 @@
         self.add_param('eta_min_pdg',{'__type__':0.}, include=False)
         self.add_param('eta_max_pdg',{'__type__':0.}, include=False)
         self.add_param('mxx_min_pdg',{'__type__':0.}, include=False)
-        self.add_param('mxx_only_part_antipart', {'default':False}, include=False, hidden=True)
+        self.add_param('mxx_only_part_antipart', {'default':False}, include=False)
         
-        self.add_param('pdg_cut',[0], hidden=True, system=True) # store which PDG are tracked
-        self.add_param('ptmin4pdg',[0.], hidden=True, system=True) # store pt min
-        self.add_param('ptmax4pdg',[-1.], hidden=True, system=True)
-        self.add_param('Emin4pdg',[0.], hidden=True, system=True) # store pt min
-        self.add_param('Emax4pdg',[-1.], hidden=True, system=True)  
-        self.add_param('etamin4pdg',[0.], hidden=True, system=True) # store pt min
-        self.add_param('etamax4pdg',[-1.], hidden=True, system=True)   
-        self.add_param('mxxmin4pdg',[-1.], hidden=True, system=True)
-        self.add_param('mxxpart_antipart', [False], hidden=True, system=True)
+        self.add_param('pdg_cut',[0],  system=True) # store which PDG are tracked
+        self.add_param('ptmin4pdg',[0.], system=True) # store pt min
+        self.add_param('ptmax4pdg',[-1.], system=True)
+        self.add_param('Emin4pdg',[0.], system=True) # store pt min
+        self.add_param('Emax4pdg',[-1.], system=True)  
+        self.add_param('etamin4pdg',[0.], system=True) # store pt min
+        self.add_param('etamax4pdg',[-1.], system=True)   
+        self.add_param('mxxmin4pdg',[-1.], system=True)
+        self.add_param('mxxpart_antipart', [False], system=True)
         # Not implemetented right now (double particle cut)
         #self.add_param('pdg_cut_2',[0], hidden=True, system=True)
         # self.add_param('M_min_pdg',[0.], hidden=True, system=True) # store pt min
@@ -3031,7 +3058,8 @@
             self['use_syst'] = False
             self['systematics_program'] = 'none'
             
-    def write(self, output_file, template=None, python_template=False):
+    def write(self, output_file, template=None, python_template=False,
+              **opt):
         """Write the run_card in output_file according to template 
            (a path to a valid run_card)"""
 
@@ -3045,7 +3073,7 @@
                 python_template = False
        
         super(RunCardLO, self).write(output_file, template=template,
-                                    python_template=python_template)            
+                                    python_template=python_template, **opt)            
 
 
 class InvalidMadAnalysis5Card(InvalidCmd):
@@ -3598,28 +3626,28 @@
             for scale in scales:
                 if self[scale]:
                     logger.warning('''For consistency in the FxFx merging, \'%s\' has been set to false'''
-                                % scale,'$MG:color:BLACK')
+                                % scale,'$MG:BOLD')
                     self[scale]= False
             #and left to default dynamical scale
             if len(self["dynamical_scale_choice"]) > 1 or self["dynamical_scale_choice"][0] != -1:
                 self["dynamical_scale_choice"] = [-1]
                 self["reweight_scale"]=[self["reweight_scale"][0]]
                 logger.warning('''For consistency in the FxFx merging, dynamical_scale_choice has been set to -1 (default)'''
-                                ,'$MG:color:BLACK')
+                                ,'$MG:BOLD')
                 
             # 2. Use kT algorithm for jets with pseudo-code size R=1.0
             jetparams=['jetradius','jetalgo']
             for jetparam in jetparams:
                 if float(self[jetparam]) != 1.0:
                     logger.info('''For consistency in the FxFx merging, \'%s\' has been set to 1.0'''
-                                % jetparam ,'$MG:color:BLACK')
+                                % jetparam ,'$MG:BOLD')
                     self[jetparam] = 1.0
         elif self['ickkw'] == -1 and (self["dynamical_scale_choice"][0] != -1 or
                                       len(self["dynamical_scale_choice"]) > 1):
                 self["dynamical_scale_choice"] = [-1]
                 self["reweight_scale"]=[self["reweight_scale"][0]]
                 logger.warning('''For consistency with the jet veto, the scale which will be used is ptj. dynamical_scale_choice will be set at -1.'''
-                                ,'$MG:color:BLACK')            
+                                ,'$MG:BOLD')            
                                 
         # For interface to APPLGRID, need to use LHAPDF and reweighting to get scale uncertainties
         if self['iappl'] != 0 and self['pdlabel'].lower() != 'lhapdf':
@@ -3773,7 +3801,7 @@
             self['mxxmin4pdg'] = [0.]
             self['mxxpart_antipart'] = [False]
 
-    def write(self, output_file, template=None, python_template=False):
+    def write(self, output_file, template=None, python_template=False, **opt):
         """Write the run_card in output_file according to template 
            (a path to a valid run_card)"""
 
@@ -3787,7 +3815,7 @@
                 python_template = False
        
         super(RunCardNLO, self).write(output_file, template=template,
-                                    python_template=python_template)
+                                    python_template=python_template, **opt)
 
 
     def create_default_for_process(self, proc_characteristic, history, proc_def):

=== modified file 'madgraph/various/misc.py'
--- madgraph/various/misc.py	2018-03-27 17:23:29 +0000
+++ madgraph/various/misc.py	2018-04-20 08:32:43 +0000
@@ -575,6 +575,37 @@
             # reset it to change the next file
             mod = False
 
+def pid_exists(pid):
+    """Check whether pid exists in the current process table.
+    UNIX only.
+    https://stackoverflow.com/questions/568271/how-to-check-if-there-exists-a-process-with-a-given-pid-in-python
+    """
+    import errno
+    
+    if pid < 0:
+        return False
+    if pid == 0:
+        # According to "man 2 kill" PID 0 refers to every process
+        # in the process group of the calling process.
+        # On certain systems 0 is a valid PID but we have no way
+        # to know that in a portable fashion.
+        raise ValueError('invalid PID 0')
+    try:
+        os.kill(pid, 0)
+    except OSError as err:
+        if err.errno == errno.ESRCH:
+            # ESRCH == No such process
+            return False
+        elif err.errno == errno.EPERM:
+            # EPERM clearly means there's a process to deny access to
+            return True
+        else:
+            # According to "man 2 kill" possible error values are
+            # (EINVAL, EPERM, ESRCH)
+            raise
+    else:
+        return True
+
 #===============================================================================
 # mute_logger (designed to work as with statement)
 #===============================================================================
@@ -874,6 +905,19 @@
     """nice way to call an external program with nice error treatment"""
     return subprocess.Popen(arg, *args, **opt)
 
+@check_system_error()
+def call_stdout(arg, *args, **opt):
+    """nice way to call an external program with nice error treatment"""
+    try:
+        out = subprocess.Popen(arg, *args, stdout=subprocess.PIPE, **opt)
+    except OSError:
+        arg[0] = './%s' % arg[0]
+        out = subprocess.call(arg, *args,  stdout=subprocess.PIPE, **opt)
+        
+    str_out = out.stdout.read().strip()
+    return str_out
+    
+
 @multiple_try()
 def mult_try_open(filepath, *args, **opt):
     """try to open a file with multiple try to ensure that filesystem is sync"""  
@@ -1397,6 +1441,8 @@
 
     if wait:
         raw_input('press_enter to continue')
+    elif opt.has_key('sleep'):
+        time.sleep(int(opt['sleep']))
 
     return 
 
@@ -1901,9 +1947,9 @@
                     else:
                         if keyname in getattr(plugin, target_type):
                             if not info:
-                                logger.info('Using from plugin %s mode %s' % (plug, keyname), '$MG:color:BLACK')
+                                logger.info('Using from plugin %s mode %s' % (plug, keyname), '$MG:BOLD')
                             else:
-                                logger.info(info % {'plug': plug, 'key':keyname}, '$MG:color:BLACK')
+                                logger.info(info % {'plug': plug, 'key':keyname}, '$MG:BOLD')
                             return getattr(plugin, target_type)[keyname]
                         
     if not keyname:

=== modified file 'models/__init__.py'
--- models/__init__.py	2017-02-16 14:49:57 +0000
+++ models/__init__.py	2018-04-20 08:32:43 +0000
@@ -16,6 +16,7 @@
 
 import os
 import sys
+import madgraph.various.misc as misc
 
 def load_model(name, decay=False):
     
@@ -24,6 +25,7 @@
         name = name[:-1]
     
 
+
     path_split = name.split(os.sep)
     if len(path_split) == 1:
         model_pos = 'models.%s' % name
@@ -36,8 +38,8 @@
             raise Exception, 'name %s already consider as a python library cann\'t be reassigned(%s!=%s)' % \
                 (path_split[-1], model_path, sys_path) 
 
-    sys.path.insert(0, os.sep.join(path_split[:-1]))
-    __import__(path_split[-1])
+    with misc.TMP_variable(sys, 'path', [os.sep.join(path_split[:-1])]):
+        __import__(path_split[-1])
     output = sys.modules[path_split[-1]]
     if decay:
         dec_name = '%s.decays' % path_split[-1]
@@ -47,9 +49,5 @@
             pass
         else:
             output.all_decays = sys.modules[dec_name].all_decays
-    
-    sys.path.pop(0)
-    
-    
-    
+        
     return sys.modules[path_split[-1]]

=== modified file 'models/check_param_card.py'
--- models/check_param_card.py	2018-02-20 18:09:19 +0000
+++ models/check_param_card.py	2018-04-20 08:32:43 +0000
@@ -488,7 +488,7 @@
                 if not misc.equal(model_value, param_value, 4):
                     modify = True
                     if loglevel == 20:
-                        logger.info('For consistency, the mass of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value), '$MG:color:BLACK')
+                        logger.info('For consistency, the mass of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value), '$MG:BOLD')
                     else:
                         logger.log(loglevel, 'For consistency, the mass of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value))
                     #logger.debug('was %s', param_value)
@@ -511,7 +511,7 @@
                 if not misc.equal(model_value, param_value, 4):
                     modify = True
                     if loglevel == 20:
-                        logger.info('For consistency, the width of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value), '$MG:color:BLACK')
+                        logger.info('For consistency, the width of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value), '$MG:BOLD')
                     else:
                         logger.log(loglevel,'For consistency, the width of particle %s (%s) is changed to %s.' % (lhacode, particle.get('name'), model_value))
                     #logger.debug('was %s', param_value)
@@ -955,7 +955,7 @@
         for positions in itertools.product(*lengths):
             self.itertag = []
             if self.logging:
-                logger.info("Create the next param_card in the scan definition", '$MG:color:BLACK')
+                logger.info("Create the next param_card in the scan definition", '$MG:BOLD')
             for i, pos in enumerate(positions):
                 key = keys[i]
                 for param, values in all_iterators[key]:
@@ -988,6 +988,7 @@
         for param in self.autowidth:
             self.cross[-1]['width#%s' % param.lhacode[0]] = paramcard.get_value(param.lhablock, param.lhacode)
             
+
     def write_summary(self, path, order=None, lastline=False, nbcol=20):
         """ """
         
@@ -1016,11 +1017,13 @@
             ff.write(formatting % tuple(['run_name'] + self.param_order + keys))
         formatting = "%s%s%s\n" %('%%-%is ' % (nbcol), ('%%-%ie ' % (nbcol))* len(self.param_order),
                                              ('%%-%ie ' % (nbcol))* len(keys))
-        
+      
+
         if not lastline:
             to_print = self.cross
         else:
             to_print = self.cross[-1:]
+
         for info in to_print:
             name = info['run_name']
             bench = info['bench']
@@ -1268,7 +1271,7 @@
                         is_modified = True
                         if log ==20:
                             logger.log(log,'For model consistency, update %s with id %s to value %s',
-                                        block, id, 0.0, '$MG:color:BLACK')                            
+                                        block, id, 0.0, '$MG:BOLD')                            
                         elif log:
                             logger.log(log,'For model consistency, update %s with id %s to value %s',
                                         block, id, 0.0)
@@ -1299,7 +1302,7 @@
                         is_modified = True
                         if log ==20:
                             logger.log(log,'For model consistency, update %s with id %s to value %s',
-                                        (block, id, 1.0), '$MG:color:BLACK')                            
+                                        (block, id, 1.0), '$MG:BOLD')                            
                         elif log:
                             logger.log(log,'For model consistency, update %s with id %s to value %s',
                                         (block, id, 1.0))
@@ -1336,7 +1339,7 @@
                         is_modified = True
                         if log ==20:
                             logger.log(log,'For model consistency, update %s with id %s to value %s since it should be equal to parameter with id %s',
-                                        block, id1, value2, id2, '$MG:color:BLACK')
+                                        block, id1, value2, id2, '$MG:BOLD')
                         elif log:
                             logger.log(log,'For model consistency, update %s with id %s to value %s since it should be equal to parameter with id %s',
                                         block, id1, value2, id2)
@@ -1365,7 +1368,7 @@
                         is_modified = True
                         if log ==20:
                             logger.log(log,'For model consistency, update %s with id %s to value %s since it should be equal to the opposite of the parameter with id %s',
-                                        block, id1, -value2, id2, '$MG:color:BLACK')
+                                        block, id1, -value2, id2, '$MG:BOLD')
                         elif log:
                             logger.log(log,'For model consistency, update %s with id %s to value %s since it should be equal to the opposite of the parameter with id %s',
                                         block, id1, -value2, id2)

=== modified file 'models/usermod.py'
--- models/usermod.py	2017-11-30 23:09:49 +0000
+++ models/usermod.py	2018-04-20 08:32:43 +0000
@@ -96,6 +96,12 @@
             self.CTvertices = list(model.all_CTvertices)
         else:
             self.CTvertices = []
+        # UFO NLO extension
+        if hasattr(model, 'all_CTparameters'):
+            self.CTparameters = list(model.all_CTparameters)
+        else:
+            self.CTparameters = []
+
         
         #translate for how to write the python file
         if 'self.expr = expression' in open(pjoin(self.modelpath, 'object_library.py')).read():
@@ -132,6 +138,7 @@
         self.write_functions(outputdir)
         self.write_propagators(outputdir)
         self.write_ctvertices(outputdir)
+        self.write_ctparameters(outputdir)
         
         self.write_external_files(outputdir)
         self.write_restrict_card(outputdir)
@@ -144,10 +151,7 @@
         to_change = {}
         to_change.update(self.translate)
         to_change.update(self.old_new)
-        for particle in self.particles:
-            if hasattr(particle, 'replace') and particle.replace:
-                misc.sprint(particle.get('name'), particle.replace.get('name'))
-        
+
         pattern = re.compile(r'\b(%s)\b' % ('|'.join(to_change)))
         
         #need to check that all particle are written correctly <- Fix potential issue
@@ -204,19 +208,12 @@
                 # all added -> write it
                 param_card.write(pjoin(outputdir, p), precision=7)
 
-                        
-                    
-                    
-                    
-                
-        
-
     def format_param(self, param):
         """convert param to string in order to have it written correctly for the 
         UFO file"""
 
         if isinstance(param, basestring): 
-            return "'%s'" % param.replace('\'', '\\\'').replace('\"', '\\\"')
+            return "'%s'" % param.replace("\\", "\\\\").replace('\'', '\\\'').replace('\"', '\\\"')
         elif isinstance(param, int) or isinstance(param, float) or \
                                                        isinstance(param, complex):
             return "%s" % param
@@ -271,6 +268,9 @@
                 add_space = len(text)
             else:
                 add_space = 0
+                
+            if ',' in data:
+                continue 
             
             try:
                 expr = getattr(obj, data)
@@ -294,6 +294,10 @@
         else:
             other_attr = obj.__dict__.keys()
         
+        if str(obj.__class__.__name__) == 'CTParameter' and 'nature' in other_attr:
+            logger.critical('UFO model is outdated (including some bugs). Please update object_library.py to latest version')
+            other_attr.remove('nature')
+        
         other_attr.sort()
         if other_attr == ['GhostNumber', 'LeptonNumber', 'Y', 'partial_widths', 'selfconjugate']:
             other_attr=['GhostNumber', 'LeptonNumber', 'Y','selfconjugate']
@@ -417,6 +421,26 @@
         ff.close()
         return
 
+    def write_ctparameters(self, outputdir):
+        """ """
+        if not self.CTparameters:
+            return
+        
+        text = """
+# This file was automatically created by The UFO_usermod        
+
+from object_library import all_CTparameters, CTParameter
+
+from function_library import complexconjugate, re, im, csc, sec, acsc, asec, cot
+"""
+
+        text += self.create_file_content(self.CTparameters)
+        ff = open(os.path.join(outputdir, 'CT_parameters.py'), 'w')
+        ff.writelines(text)
+        ff.close()
+        return
+
+
     def write_orders(self, outputdir):
         """ """
         text = """
@@ -588,6 +612,9 @@
             elif  p_plugin.mass.name.lower() == 'zero':
                 pass
             else:
+                misc.sprint(p_base.mass.value, p_plugin.mass.value, dir(p_base.mass))
+                misc.sprint(p_base.mass.nature, p_plugin.mass.nature)
+                misc.sprint(self.old_new)
                 raise USRMODERROR, 'Some inconsistency in the mass assignment in the model\n' + \
              '     Mass: %s and %s\n' %(p_base.mass.name, p_plugin.mass.name) + \
              '     conflict name %s\n' % self.old_new + \
@@ -657,6 +684,29 @@
                 self.old_new[parameter.name] = old_param.name
             #            self.add_internal_parameter(iden_param)
         
+        elif parameter.lhablock.lower() in ['mass', 'decay'] and int(parameter.lhacode[0]) in identify_pid:
+            # this means that the parameter is an internal parameter in the original model...
+            #find it via the particle name
+            orig_particle = self.particle_dict[lhacode[0]]
+            if parameter.lhablock.lower() == 'mass':
+                old_param = orig_particle.mass
+            else:
+                old_param = orig_particle.width
+            if old_param.name.lower() == 'zero':
+                #Just add the new parameter to the current list
+                self.parameters.append(parameter) 
+                self.new_external.append(parameter)                
+            else:
+                logger.info('The two model defines the parameter for  block \'%s\' with id \'%s\' with different parameter name \'%s\', \'%s\'\n'\
+                      %  (parameter.lhablock.lower(), lhacode[0], parameter.name, old_param.name) + \
+                '     We will merge those two parameters in a single one')
+                if parameter.name in self.old_new.values():
+                    key = [k for k in self.old_new if self.old_new[k] == parameter.name][0]
+                    self.old_new[key] = old_param.name
+                    self.old_new[parameter.name] = old_param.name
+                else:
+                    self.old_new[parameter.name] = old_param.name
+                    #            self.add_internal_parameter(iden_param)                            
         else:
             #Just add the new parameter to the current list
             self.parameters.append(parameter) 

=== modified file 'tests/acceptance_tests/test_cmd_madevent.py'
--- tests/acceptance_tests/test_cmd_madevent.py	2017-05-22 09:11:33 +0000
+++ tests/acceptance_tests/test_cmd_madevent.py	2018-04-20 08:32:43 +0000
@@ -634,6 +634,7 @@
 
         if not self.debuging:
             shutil.rmtree(self.path)
+        self.assertFalse(self.debuging)
 
     def test_add_time_of_flight(self):
         """checking time of flight is working fine"""