Merge lp:~maddevelopers/mg5amcnlo/controlswitch into lp:~mg5core1/mg5amcnlo/2.5.6

[Olivier Mattelaer]

Hi,

This branch refactor the code on how to ask to the user which code to run.
The idea is to have dedicated class for that to ease the possibility to edit such crucial
part of the interface via plugin method.
For that reason, this code use highly modular method and factorise the different step in a quite deep way. This makes the new code much longer than the equivalent one that it replaces.

For the user point of view the change are actually quite minimal:
1) Change the description to fit on 80 char shell.
2) Change question presentation @NLO to match the one already present @LO
3) New method for the gestion of conflict:
   - The previous user value is not overwritten directly anymore
   - The conflicted value is now set in red and the "replacement" value is set after an arrow
   - This allows to allow to use the cycle trough options without creating annoying side effects
4) The cycle trough option is now available for all options
5) the user can now set multiple switch with a single line (need to be separated by ";")

This should not be part of 2.5.6/2.6.0 but rather part of 2.6.1, at the same time,
I would like to have it merged in 2.6.1 as soon as possible such that we have plenty of time to discover potential side effects/error in the conflict handling.

[lp:~maddevelopers/mg5amcnlo/controlswitch]

324. By olivier-mattelaer on 2017-08-15

remove print statement

[Rikkert Frederix (frederix)]

Hi Olivier,

Shouldn't the merge target be something different than 2.5.6?

Cheers,
Rik

[Olivier Mattelaer (olivier-mattelaer)]

Hi Rik,

Yes, but since that branch was not yet released, this was the only branch available in order to have a nice diff. As said in my comment, this was not intended to be merged in 2.5.6.

As soon as the branch 2.6.1 will be pushed, I will change the target.

Cheers,

Olivier

[lp:~maddevelopers/mg5amcnlo/controlswitch]

325. By olivier-mattelaer on 2017-08-18

improve question displayed -- adapt to the screen size--

326. By olivier-mattelaer on 2017-08-19

improve the display of the conflict with striketrough instead of yellow color

327. By olivier-mattelaer on 2017-08-19

longer striketrough to increase visibility

328. By olivier-mattelaer on 2017-08-22

fix problem when some program are not installed + allowed 1=PY8

329. By olivier-mattelaer on 2017-08-22

fix some displayed problem pointed by Stefano when some program are not available

330. By olivier-mattelaer on 2017-08-28

fix problem with script and command not accepted due to the missing;

331. By olivier-mattelaer on 2017-08-30

first change related to Valentin review

332. By olivier-mattelaer on 2017-08-31

allow to choose the shower before the edition of the card

333. By olivier-mattelaer on 2017-08-31

improvment associated to the PS choice

334. By olivier-mattelaer on 2017-08-31

improve the handling of scripting method.

335. By olivier-mattelaer on 2017-10-05

merge with latest 2.6.1

336. By olivier-mattelaer on 2017-10-06

fixing problem revealed by test suite

337. By olivier-mattelaer on 2017-10-06

merge with latest 2.6.1

Unmerged revisions

337. By olivier-mattelaer on 2017-10-06

merge with latest 2.6.1

336. By olivier-mattelaer on 2017-10-06

fixing problem revealed by test suite

335. By olivier-mattelaer on 2017-10-05

merge with latest 2.6.1

334. By olivier-mattelaer on 2017-08-31

improve the handling of scripting method.

333. By olivier-mattelaer on 2017-08-31

improvment associated to the PS choice

332. By olivier-mattelaer on 2017-08-31

allow to choose the shower before the edition of the card

331. By olivier-mattelaer on 2017-08-30

first change related to Valentin review

330. By olivier-mattelaer on 2017-08-28

fix problem with script and command not accepted due to the missing;

329. By olivier-mattelaer on 2017-08-22

fix some displayed problem pointed by Stefano when some program are not available

328. By olivier-mattelaer on 2017-08-22

fix problem when some program are not installed + allowed 1=PY8

=== modified file 'madgraph/interface/amcatnlo_run_interface.py'
--- madgraph/interface/amcatnlo_run_interface.py	2017-08-10 13:09:28 +0000
+++ madgraph/interface/amcatnlo_run_interface.py	2017-08-15 12:03:07 +0000
@@ -907,6 +907,274 @@
 class aMCatNLOAlreadyRunning(InvalidCmd):
     pass
 
+class AskRunNLO(cmd.ControlSwitch):
+    
+    to_control = [('order', 'Type of perturbative computation'),
+                  ('fixed_order', 'No MC@[N]LO matching / event generation'),
+                  ('shower', 'Shower the generated events'),
+                  ('madspin', 'Decay onshell particles'),
+                  ('reweight', 'Add weights to events for new hypp.'),
+                   ('madanalysis','Run MadAnalysis5 on the events generated')]
+    
+    quit_on = cmd.ControlSwitch.quit_on + ['onlyshower']
+    
+    def __init__(self, question, line_args=[], mode=None, force=False,
+                                                                  *args, **opt):
+        
+        self.check_available_module(opt['mother_interface'].options)
+        self.me_dir = opt['mother_interface'].me_dir
+        self.last_mode = opt['mother_interface'].last_mode
+        misc.sprint(self.last_mode)
+        self.proc_characteristics = opt['mother_interface'].proc_characteristics
+        super(AskRunNLO,self).__init__(self.to_control, opt['mother_interface'],
+                                     *args, **opt)
+
+    def check_available_module(self, options):
+        
+        self.available_module = set()
+        if options['madanalysis5_path']:
+            self.available_module.add('MA5')
+        if not aMCatNLO or ('mg5_path' in options and options['mg5_path']):
+            self.available_module.add('MadSpin')
+            if misc.has_f2py() or self.mother_interface.options['f2py_compiler']:
+                self.available_module.add('reweight')
+#
+#   shorcut
+#
+    def ans_lo(self, value):
+        
+        if value is None:            
+            self.switch['order'] = 'LO'
+            self.switch['fixed_order'] = 'ON'
+            self.set_switch('shower', 'OFF')
+        else:
+            logger.warning('Invalid command: lo=%s' % value)
+
+    def ans_nlo(self, value):
+        if value is None:
+            self.switch['order'] = 'NLO'
+            self.switch['fixed_order'] = 'ON'
+            self.set_switch('shower', 'OFF')    
+        else:
+            logger.warning('Invalid command: nlo=%s' % value)
+            
+    def ans_amc__at__nlo(self, value):
+        if value is None:
+            self.switch['order'] = 'NLO'
+            self.switch['fixed_order'] = 'OFF'
+            self.set_switch('shower', 'ON')
+        else:
+            logger.warning('Invalid command: aMC@NLO=%s' % value)
+            
+    def ans_amc__at__lo(self, value):
+        if value is None:
+            self.switch['order'] = 'LO'
+            self.switch['fixed_order'] = 'OFF'
+            self.set_switch('shower', 'ON')    
+        else:
+            logger.warning('Invalid command: aMC@LO=%s' % value)  
+                  
+    def ans_noshower(self, value):
+        if value is None:
+            self.switch['order'] = 'NLO'
+            self.switch['fixed_order'] = 'OFF'
+            self.set_switch('shower', 'OFF')
+        else:
+            logger.warning('Invalid command: noshower=%s' % value)  
+        
+    def ans_onlyshower(self, value):
+        if value is None:
+            self.switch['mode'] = 'onlyshower'
+            self.switch['madspin'] = 'OFF'
+            self.switch['reweight'] = 'OFF'
+        else:
+            logger.warning('Invalid command: onlyshower=%s' % value)     
+              
+    def ans_noshowerlo(self, value):
+        if value is None:
+            self.switch['order'] = 'LO'
+            self.switch['fixed_order'] = 'OFF'
+            self.set_switch('shower', 'OFF')
+        else:
+            logger.warning('Invalid command: noshowerlo=%s' % value)    
+            
+    def ans_madanalysis5(self, value):
+        """ shortcut madanalysis5 -> madanalysis """
+        
+        if value is None:
+            return self.onecmd('madanalysis')
+        else:
+            self.set_switch('madanalysis', value)                
+#
+#   ORDER   
+#   
+    def get_allowed_order(self):
+        return ["LO", "NLO"]
+    
+    def set_default_order(self):  
+        
+        if self.last_mode in ['LO', 'aMC@L0', 'noshowerLO']:
+            self.switch['order'] = 'LO'       
+        self.switch['order'] = 'NLO'
+        
+    def set_switch_off_order(self):
+        return
+#
+#   Fix order
+#    
+    def get_allowed_fixed_order(self):
+        """ """
+        if self.proc_characteristics['ninitial'] == 1:
+            return ['ON']
+        else:
+            return ['ON', 'OFF']
+        
+    def set_default_fixed_order(self):  
+        
+        if self.last_mode in ['LO', 'NLO']:
+            self.switch['fixed_order'] = 'ON'
+        self.switch['fixed_order'] = 'OFF'
+
+    def color_for_fixed_order(self, switch_value):
+         
+        if switch_value in ['OFF']:
+            return self.green % switch_value
+        else:
+            return self.red % switch_value
+    
+    def consistency_fixed_order_shower(self, vfix, vshower):
+        """ consistency_XX_YY(val_XX, val_YY)
+           -> XX is the new key set by the user to a new value val_XX
+           -> YY is another key set by the user.
+           -> return value should be None or "replace_YY" 
+        """
+        
+        if vfix == 'ON' and vshower != 'OFF' :
+            return 'OFF'
+        return None
+    
+    consistency_fixed_order_madspin = consistency_fixed_order_shower
+    consistency_fixed_order_reweight = consistency_fixed_order_shower
+
+    def consistency_fixed_order_madanalysis(self, vfix, vma5):
+        
+        if vfix == 'ON' and vma5 == 'ON' :
+            return 'OFF'
+        return None    
+
+
+    def consistency_shower_fixed_order(self, vshower, vfix):
+        """ consistency_XX_YY(val_XX, val_YY)
+           -> XX is the new key set by the user to a new value val_XX
+           -> YY is another key set by the user.
+           -> return value should be None or "replace_YY" 
+        """    
+        
+        if vshower == 'ON' and vfix == 'ON':
+            return 'OFF'
+        return None
+
+    consistency_madspin_fixed_order = consistency_shower_fixed_order
+    consistency_reweight_fixed_order = consistency_shower_fixed_order
+    consistency_madanalysis_fixed_order = consistency_shower_fixed_order
+
+#
+#   Shower
+#
+    def get_allowed_shower(self):
+        """ """
+        if self.proc_characteristics['ninitial'] == 1:
+            return ['OFF']
+        else:
+            return ['ON', 'OFF']
+        
+    def set_default_shower(self): 
+        
+        if self.last_mode in ['LO', 'NLO', 'noshower', 'noshowerLO']:
+            self.switch['shower'] = 'OFF'
+            return 
+         
+        if os.path.exists(pjoin(self.me_dir, 'Cards', 'shower_card.dat')):  
+            self.switch['shower'] = 'ON'
+            self.switch['fixed_order'] = "OFF"
+        else:
+            self.switch['shower'] = 'OFF'
+
+    def consistency_shower_madanalysis(self, vshower, vma5):
+        """ MA5 only possible with (N)LO+PS if shower is run"""
+        
+        if vshower == 'OFF' and vma5 == 'ON':
+            return 'OFF'
+        return None
+    
+    def consistency_madanalysis_sower(self, vma5, vshower):
+        
+        if vma5=='ON' and vshower =='OFF':
+            return 'ON'
+        return None
+    
+#
+#   madspin
+#
+    def get_allowed_madspin(self):
+        """ """
+        if self.proc_characteristics['ninitial'] == 1:
+            return ['OFF']
+        else:
+            return ['ON', 'OFF']
+            
+    def set_default_madspin(self):
+        
+        if 'MadSpin' in self.available_module:
+            if os.path.exists(pjoin(self.me_dir,'Cards','madspin_card.dat')):
+                self.switch['madspin'] = 'ON'
+            else:
+                self.switch['madspin'] = 'OFF'
+        else:
+            self.switch['madspin'] = 'Not Avail.'  
+            
+        
+#
+#   reweight
+#
+    get_allowed_reweight = get_allowed_madspin
+    
+    def set_default_reweight(self):
+        """initialise the switch for reweight"""
+        
+        if 'reweight' in self.available_module:
+            if os.path.exists(pjoin(self.me_dir,'Cards','reweight_card.dat')):
+                self.switch['reweight'] = 'ON'
+            else:
+                self.switch['reweight'] = 'OFF'
+        else:
+            self.switch['reweight'] = 'Not Avail.'      
+#
+#   MadAnalysis5
+#    
+    get_allowed_madanalysis = get_allowed_madspin
+    
+    def set_default_madanalysis(self):
+        """initialise the switch for reweight"""
+        
+        if 'MA5' not in self.available_module: 
+            self.switch['madanalysis'] =  'Not Avail.'
+        elif os.path.exists(pjoin(self.me_dir,'Cards', 'madanalysis5_hadron_card.dat')):
+            self.switch['madanalysis'] = 'ON'
+        else:
+            self.switch['madanalysis'] = 'OFF'
+            
+    def check_value_madanalysis(self, value):
+        """check an entry is valid. return the valid entry in case of shortcut"""
+        
+        if value.upper() in self.get_allowed('madanalysis'):
+            return True
+        value = value.lower()
+        if value == 'hadron':
+            return 'ON' if 'ON' in self.get_allowed_madanalysis5 else False
+        else:
+            return False
+        
 #===============================================================================
 # aMCatNLOCmd
 #===============================================================================
@@ -4826,7 +5094,7 @@
         return model
 
 
-
+    action_switcher = AskRunNLO
     ############################################################################
     def ask_run_configuration(self, mode, options, switch={}):
         """Ask the question when launching generate_events/multi_run"""
@@ -4836,194 +5104,35 @@
         if 'reweightonly' not in options:
             options['reweightonly'] = False
         
-        
-        void = 'Not installed'
-        switch_order = ['order', 'fixed_order', 'shower','madspin', 'reweight','madanalysis5']
-        switch_default = {'order': 'NLO', 'fixed_order': 'OFF', 'shower': void,
-                  'madspin': void,'reweight':'OFF','madanalysis5':void}
-        if not switch:
-            switch = switch_default
-        else:
-            switch.update(dict((k,value) for k,v in switch_default.items() if k not in switch))
-        default_switch = ['ON', 'OFF']
-        
-
-        allowed_switch_value = {'order': ['LO', 'NLO'],
-                                'fixed_order': default_switch,
-                                'shower': default_switch,
-                                'madspin': default_switch,
-                                'reweight': default_switch,
-                                'madanalysis5':['OFF','HADRON']}
-
-        if not os.path.exists(pjoin(self.me_dir, 'Cards', 
-                                       'madanalysis5_hadron_card_default.dat')):
-            allowed_switch_value['madanalysis5']=[]
-
-        description = {'order':  'Perturbative order of the calculation:',
-                       'fixed_order': 'Fixed order (no event generation and no MC@[N]LO matching):',
-                       'shower': 'Shower the generated events:',
-                       'madspin': 'Decay particles with the MadSpin module:',
-                       'reweight': 'Add weights to the events based on changing model parameters:',
-                       'madanalysis5':'Run MadAnalysis5 on the events generated:'}
-
-        force_switch = {('shower', 'ON'): {'fixed_order': 'OFF'},
-                       ('madspin', 'ON'): {'fixed_order':'OFF'},
-                       ('reweight', 'ON'): {'fixed_order':'OFF'},
-                       ('fixed_order', 'ON'): {'shower': 'OFF', 'madspin': 'OFF', 'reweight':'OFF','madanalysis5':'OFF'},
-                       ('madanalysis5','HADRON'): {'shower': 'ON','fixed_order':'OFF'},
-                       ('shower','OFF'): {'madanalysis5': 'OFF'},   
-                       }
-        special_values = ['LO', 'NLO', 'aMC@NLO', 'aMC@LO', 'noshower', 'noshowerLO']
-
-        assign_switch = lambda key, value: switch.__setitem__(key, value if switch[key] != void else void )
-
-        if self.proc_characteristics['ninitial'] == 1:
-            switch['fixed_order'] = 'ON'
-            switch['shower'] = 'Not available for decay'
-            switch['madspin'] = 'Not available for decay'
-            switch['reweight'] = 'Not available for decay'
-            switch['madanalysis5'] = 'Not available for decay'
-            allowed_switch_value['fixed_order'] = ['ON']
-            allowed_switch_value['shower'] = ['OFF']
-            allowed_switch_value['madspin'] = ['OFF']
-            allowed_switch_value['reweight'] = ['OFF']
-            allowed_switch_value['madanalysis5'] = ['OFF']
-            available_mode = ['0','1']
-            special_values = ['LO', 'NLO']
-        else: 
-            # Init the switch value according to the current status
-            available_mode = ['0', '1', '2','3']
-
         if mode == 'auto': 
             mode = None
         if not mode and (options['parton'] or options['reweightonly']):
-            mode = 'noshower'         
-        
-
-        if '3' in available_mode:
-            if os.path.exists(pjoin(self.me_dir, 'Cards', 'shower_card.dat')):
-                switch['shower'] = 'ON'
-            else:
-                switch['shower'] = 'OFF'
-            if os.path.exists(pjoin(self.me_dir, 'Cards', 'madanalysis5_hadron_card_default.dat')):
-                available_mode.append('6')
-                if os.path.exists(pjoin(self.me_dir, 'Cards', 'madanalysis5_hadron_card.dat')):
-                    switch['madanalysis5'] = 'HADRON'
-                else:
-                    switch['madanalysis5'] = 'OFF'                
-                
-        if (not aMCatNLO or self.options['mg5_path']) and '3' in available_mode:
-            available_mode.append('4')
-            if os.path.exists(pjoin(self.me_dir,'Cards','madspin_card.dat')):
-                switch['madspin'] = 'ON'
-            else:
-                switch['madspin'] = 'OFF'
-            if misc.has_f2py() or self.options['f2py_compiler']:
-                available_mode.append('5')
-                if os.path.exists(pjoin(self.me_dir,'Cards','reweight_card.dat')):
-                    switch['reweight'] = 'ON'
-                else:
-                    switch['reweight'] = 'OFF'
-            else:
-                switch['reweight'] = 'Not available (requires NumPy)'
-
-        if 'do_reweight' in options and options['do_reweight'] and '3' in available_mode:
-            if switch['reweight'] == "OFF":
-                switch['reweight'] = "ON"
-            elif switch['reweight'] != "ON":
-                logger.critical("Cannot run REWEIGHT: %s" % switch['reweight'])
+            mode = 'noshower'  
+        
+        passing_cmd = []
+        for key,value in switch.keys():
+            passing_cmd.append('%s=%s' % (key,value))
+        
+        if 'do_reweight' in options and options['do_reweight']:
+            passing_cmd.append('reweight=ON')
         if 'do_madspin' in options and  options['do_madspin']:
-            if switch['madspin'] == "OFF":
-                switch['madspin'] = 'ON'
-            elif switch['madspin'] != "ON":
-                logger.critical("Cannot run MadSpin module: %s" % switch['reweight'])
-                        
-        answers = list(available_mode) + ['auto', 'done']
-        alias = {}
-        for id, key in enumerate(switch_order):
-            if switch[key] != void and switch[key] in allowed_switch_value[key] and \
-                                              len(allowed_switch_value[key])>1:
-                answers += ['%s=%s' % (key, s) for s in allowed_switch_value[key]]
-                #allow lower case for on/off
-                alias.update(dict(('%s=%s' % (key, s.lower()), '%s=%s' % (key, s))
-                                   for s in allowed_switch_value[key]))
-        answers += special_values
-        
-        def create_question(switch):
-            switch_format = " %i %-61s %12s=%s\n"
-            question = "The following switches determine which operations are executed:\n"
-            for id, key in enumerate(switch_order):
-                question += switch_format % (id+1, description[key], key, switch[key])
-            question += '  Either type the switch number (1 to %s) to change its default setting,\n' % (id+1)
-            question += '  or set any switch explicitly (e.g. type \'order=LO\' at the prompt)\n'
-            question += '  Type \'0\', \'auto\', \'done\' or just press enter when you are done.\n'
-            return question
-
-
-        def modify_switch(mode, answer, switch):
-            if '=' in answer:
-                key, status = answer.split('=')
-                switch[key] = status
-                if (key, status) in force_switch:
-                    for key2, status2 in force_switch[(key, status)].items():
-                        if switch[key2] not in  [status2, void]:
-                            logger.info('For coherence \'%s\' is set to \'%s\''
-                                        % (key2, status2), '$MG:color:BLACK')
-                            switch[key2] = status2
-            elif answer in ['0', 'auto', 'done']:
-                return 
-            elif answer in special_values:
-                logger.info('Enter mode value: %s. Go to the related mode' % answer, '$MG:color:BLACK')
-                #assign_switch('reweight', 'OFF')
-                #assign_switch('madspin', 'OFF')
-                if answer == 'LO':
-                    switch['order'] = 'LO'
-                    switch['fixed_order'] = 'ON'
-                    assign_switch('shower', 'OFF')
-                elif answer == 'NLO':
-                    switch['order'] = 'NLO'
-                    switch['fixed_order'] = 'ON'
-                    assign_switch('shower', 'OFF')
-                elif answer == 'aMC@NLO':
-                    switch['order'] = 'NLO'
-                    switch['fixed_order'] = 'OFF'
-                    assign_switch('shower', 'ON')
-                elif answer == 'aMC@LO':
-                    switch['order'] = 'LO'
-                    switch['fixed_order'] = 'OFF'
-                    assign_switch('shower', 'ON')
-                elif answer == 'noshower':
-                    switch['order'] = 'NLO'
-                    switch['fixed_order'] = 'OFF'
-                    assign_switch('shower', 'OFF')                                                  
-                elif answer == 'noshowerLO':
-                    switch['order'] = 'LO'
-                    switch['fixed_order'] = 'OFF'
-                    assign_switch('shower', 'OFF')
-                if mode:
-                    return
-            return switch
-
-        modify_switch(mode, self.last_mode, switch)
-        if switch['madspin'] == 'OFF' and  os.path.exists(pjoin(self.me_dir,'Cards','madspin_card.dat')):
-            assign_switch('madspin', 'ON')
-        
-        if not self.force:
-            answer = ''
-            while answer not in ['0', 'done', 'auto', 'onlyshower']:
-                question = create_question(switch)
-                if mode:
-                    answer = mode
-                else:
-                    answer = self.ask(question, '0', answers, alias=alias)
-                if answer.isdigit() and answer != '0':
-                    key = switch_order[int(answer) - 1]
-                    opt1 = allowed_switch_value[key][0]
-                    opt2 = allowed_switch_value[key][1]
-                    answer = '%s=%s' % (key, opt1 if switch[key] == opt2 else opt2)
-
-                if not modify_switch(mode, answer, switch):
-                    break
+            passing_cmd.append('madspin=ON')
+
+        force = self.force
+        if mode == 'onlyshower':
+            passing_cmd.append('onlyshower')
+            force = True
+        elif mode:
+            passing_cmd.append(mode)
+
+        switch = self.ask('', '0', [], ask_class = self.action_switcher,
+                              mode=mode, force=force,
+                              first_cmd=passing_cmd)
+        
+        misc.sprint(switch)
+
+        if 'mode' in switch:
+            mode = switch['mode']
 
         #assign the mode depending of the switch
         if not mode or mode == 'auto':
@@ -5060,7 +5169,7 @@
                 cards.append('madspin_card.dat')
             if switch['reweight'] == 'ON':
                 cards.append('reweight_card.dat')
-            if switch['madanalysis5'] == 'HADRON':
+            if switch['madanalysis'] == 'HADRON':
                 cards.append('madanalysis5_hadron_card.dat')                
         if 'aMC@' in mode:
             cards.append('shower_card.dat')

=== modified file 'madgraph/interface/extended_cmd.py'
--- madgraph/interface/extended_cmd.py	2017-08-04 20:30:41 +0000
+++ madgraph/interface/extended_cmd.py	2017-08-15 12:03:07 +0000
@@ -1041,7 +1041,7 @@
     #===============================================================================    
     def ask(self, question, default, choices=[], path_msg=None, 
             timeout = True, fct_timeout=None, ask_class=None, alias={},
-            first_cmd=None, text_format='4', **opt):
+            first_cmd=None, text_format='4', force=False, **opt):
         """ ask a question with some pre-define possibility
             path info is
         """
@@ -1082,6 +1082,7 @@
         if alias:
             choices += alias.keys()
         
+
         question_instance = obj(question, allow_arg=choices, default=default, 
                                                    mother_interface=self, **opt)
         
@@ -1095,26 +1096,30 @@
             if hasattr(obj, "haspiping"):
                 obj.haspiping = self.haspiping
         
-
-            
-            
-        answer = self.check_answer_in_input_file(question_instance, default, path_msg)
-        if answer is not None:
-            if answer in alias:
-                answer = alias[answer]
-            if ask_class:
-                line=answer
-                answer = question_instance.default(line)
-                question_instance.postcmd(answer, line)
-                return question_instance.answer 
-            if hasattr(question_instance, 'check_answer_consistency'):
-                question_instance.check_answer_consistency()
-            return answer
+        if not force:
+            answer = default
+        else:
+                
+            answer = self.check_answer_in_input_file(question_instance, default, path_msg)
+            if answer is not None:
+                if answer in alias:
+                    answer = alias[answer]
+                if ask_class:
+                    line=answer
+                    answer = question_instance.default(line)
+                    question_instance.postcmd(answer, line)
+                    return question_instance.answer 
+                if hasattr(question_instance, 'check_answer_consistency'):
+                    question_instance.check_answer_consistency()
+                return answer
         
         question = question_instance.question
-        value =   Cmd.timed_input(question, default, timeout=timeout,
+        if not force:
+            value =   Cmd.timed_input(question, default, timeout=timeout,
                                  fct=question_instance, fct_timeout=fct_timeout)
-        
+        else:
+            value = default
+
         try:
             if value in alias:
                 value = alias[value]
@@ -1123,6 +1128,7 @@
 
         if value == default and ask_class:
             value = question_instance.default(default)
+
         return value
  
     def do_import(self, line):
@@ -2014,7 +2020,7 @@
         try:
             out = {}
             out[' Options'] = Cmd.list_completion(text, self.allow_arg)
-            out[' Recognized command'] = BasicCmd.completenames(self, text)
+            out[' Recognized command'] = super(SmartQuestion, self).completenames(text,line, *ignored)
             
             return self.deal_multiple_categories(out)
         except Exception, error:
@@ -2067,10 +2073,7 @@
         if prev_timer:     
             if pat.search(self.question):
                 timeout = int(pat.search(self.question).groups()[0])
-            else:
-                timeout=20
-            print
-            signal.alarm(timeout)
+                signal.alarm(timeout)
         if reprint_opt:
             if not prev_timer:
                 self.question = pat.sub('',self.question)
@@ -2139,7 +2142,7 @@
                 return True
             elif line and hasattr(self, 'do_%s' % line.split()[0]):
                 return self.reask()
-            elif self.value == 'repeat':
+            elif self.value in ['repeat', 'reask']:
                 return self.reask()
             elif len(self.allow_arg)==0:
                 return True
@@ -2202,7 +2205,7 @@
             out = {}
             out[' Options'] = Cmd.list_completion(text, self.allow_arg)
             out[' Path from ./'] = Cmd.path_completion(text, only_dirs = False)
-            out[' Recognized command'] = BasicCmd.completenames(self, text)
+            out[' Recognized command'] = BasicCmd.completenames(self, text, line, begidx, endidx)
             
             return self.deal_multiple_categories(out, formatting)
         except Exception, error:
@@ -2231,8 +2234,9 @@
 
             return Cmd.path_completion(text,
                                         os.path.join('.',*[a for a in args \
-                                               if a.endswith(os.path.sep)]))
-        self.completenames(line+text)
+                                               if a.endswith(os.path.sep)]),
+                                       begidx, endidx)
+        return self.completenames(text, line, begidx, endidx)
 
 
     def postcmd(self, stop, line):
@@ -2267,6 +2271,456 @@
     obj = OneLinePathCompletion(allow_arg=allow_arg, default=default )
     return obj.cmdloop()
 
+
+
+class ControlSwitch(SmartQuestion):
+    """A class for asking a question on which program to run.
+       This is the abstract class
+       
+       Behavior for each switch can be customize via:
+       set_default_XXXX() -> set default value
+       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 if off (called for special mode)
+       color_for_XXXX(value)   -> return the representation on the screen for value
+
+       consistency_XX_YY(val_XX, val_YY)
+           -> XX is the new key set by the user to a new value val_XX
+           -> YY is another key set by the user.
+           -> return value should be None or "replace_YY" 
+       
+       consistency_XX(val_XX):
+            check the consistency of the other switch given the new status of this one. 
+            return a dict {key:replaced_value} or {} if nothing to do
+            
+       user typing "NAME" will result to a call to self.ans_NAME(None)
+       user typing "NAME=XX" will result to a call to self.ans_NAME('XX')    
+       
+       Note on case sensitivity:
+       -------------------------
+       the XXX is displayed with the case in self.to_control
+           but ALL functions should use the lower case version.
+       for key associated to get_allowed_keys(), 
+           if (user) value not in that list.
+              -> try to find the first entry matching up to the case
+       for ans_XXX, set the value to lower case, but if case_XXX is set to True 
+       """
+       
+    line_length = 80
+    case_sensitive = False
+    quit_on = ['0','done', 'EOF','','auto']
+
+    def __init__(self, to_control, motherinstance, *args, **opts):
+        """to_control is a list of ('KEY': 'Choose the shower/hadronization program')
+        """
+    
+        self.to_control = to_control
+        self.mother_interface = motherinstance
+        self.inconsistent_keys = {} #flag parameter which are currently not consistent
+                                    # and the value by witch they will be replaced if the
+                                    # inconsistency remains.  
+        self.inconsistent_details = {} # flag to list 
+        self.last_changed = []         # keep the order in which the flag have been modified 
+                                       # to choose the resolution order of conflict
+        #initialise the main return value
+        self.switch = {}
+        for key, _ in to_control:
+            self.switch[key.lower()] = 'temporary'
+            
+        self.set_default_switch()
+        question = self.create_question()
+        
+        #check all default for auto-completion
+        allowed_args = [ `i`+';' for i in range(1, 1+len(self.to_control))] 
+        for key in self.switch:
+            allowed_args += ['%s=%s;' % (key,s) for s in self.get_allowed(key)]
+        # adding special mode
+        allowed_args += [key[4:]+';' for key in dir(self) if key.startswith('ans_')]
+        if 'allow_arg' in opts:
+            allowed_args += opts['allow_arg']
+            del opts['allow_arg']
+
+        super(ControlSwitch, self).__init__(question, allowed_args, *args, **opts)
+        self.options = self.mother_interface.options
+
+
+    def set_default_switch(self):
+        
+        for key,_ in self.to_control:
+            key = key.lower()
+            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"""
+        
+        if hasattr(self, 'get_allowed_%s' % key):
+            return getattr(self, 'get_allowed_%s' % key)()[0]
+        else:
+            self.switch[key] = 'OFF'
+    
+    def set_all_off(self):
+        """set all valid parameter to OFF --call before special keyword--
+        """
+        
+        for key in self.switch:
+            if hasattr(self, 'switch_off_%s' % key):
+                getattr(self, 'switch_off_%s' % key)()
+            elif self.check_value(key, self.switch[key]):
+                self.switch[key] = 'OFF'
+        self.inconsistent_details = {}
+        self.inconsistent_keys = {}
+    
+        
+    def check_value(self, key, value):
+        """return True/False if the value is a correct value to be set by the USER.
+           other value than those can be set by the system --like-- Not available.
+           This does not check the full consistency of the switch
+           """
+           
+        if hasattr(self, 'check_value_%s' % key):
+            return getattr(self, 'check_value_%s' % key)(value)
+        elif value in self.get_allowed(key):
+            return True
+        else:
+            return False
+        
+        
+        
+    def get_allowed(self, key):
+        """return the list of possible value for key"""
+
+        if hasattr(self, 'get_allowed_%s' % key):
+            return getattr(self, 'get_allowed_%s' % key)()
+        else:
+            return ['ON', 'OFF']    
+        
+    def default(self, line):
+        """Default action if line is not recognized"""
+        
+        line=line.strip().replace('@', '__at__')
+        if ';' in line:
+            for l in line.split(';'):
+                if l:
+                    out = self.default(l)
+            return out
+        
+        if '=' in line:
+            base, value = line.split('=')
+        elif ' ' in line:
+            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)]:
+            # 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
+        elif line.lower() in self.switch:
+            # go from one valid option to the next in the get_allowed for that option
+            base = line.lower()
+            try:
+                cur = self.get_allowed(base).index(self.switch[base])
+            except:
+                if self.get_allowed(base):
+                    value = self.get_allowed(base)[0]
+                else:                                            
+                    logger.warning('Can not switch "%s" to another value via number', base)
+                    self.value='reask'
+                    return
+            else:
+                try:
+                    value = self.get_allowed(base)[cur+1]
+                except IndexError:
+                    value = self.get_allowed(base)[0]
+        elif line in ['', 'done', 'EOF', 'eof','0']:
+            super(ControlSwitch, self).default(line)
+            return self.answer
+        elif line in 'auto':
+            self.switch['dynamical'] = True
+            return super(ControlSwitch, self).default(line)
+        else:
+            logger.warning('unknow command: %s' % line)
+            self.value = 'reask'
+            return
+        
+        self.value = 'reask'   
+        base = base.lower()
+        if hasattr(self, 'ans_%s' % base):
+            if value and not self.is_case_sensitive(base):
+                value = value.lower()
+            getattr(self, 'ans_%s' % base)(value)
+        elif base in self.switch:
+            self.set_switch(base, value)        
+        else:
+            logger.warning('Not valid command: %s' % line)
+   
+    def is_case_sensitive(self, key):
+        """check if a key is case sensitive"""
+        
+        case = self.case_sensitive 
+        if hasattr(self, 'case_%s' % key):
+            case = getattr(self, 'case_%s' % key)
+        return case
+    
+    def onecmd(self, line, **opt):
+        """ensure to rewrite the function if a call is done directly"""
+        out = super(ControlSwitch, self).onecmd(line, **opt)
+        self.create_question()
+        return out
+
+    @property
+    def answer(self):
+        if not self.inconsistent_keys:
+            return self.switch
+        else:
+            out = dict(self.switch)
+            out.update(self.inconsistent_keys)
+            return out
+
+    def postcmd(self, stop, line):
+        
+        line = line.strip()
+        if ';' in line:
+            line= [l for l in line.split(';') if l][-1] 
+        if line in self.quit_on:
+            return True
+        return self.reask(True)
+        
+
+    def set_switch(self, key, value, user=True):
+        """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):
+                value = value.lower()
+            return getattr(self, 'ans_%s' % key)(value)
+        
+        if not self.is_case_sensitive(key) and value not in self.get_allowed(key):
+            lower = [t.lower() for t in self.get_allowed(key)]
+            try:
+                ind = lower.index(value.lower())
+            except ValueError:
+                pass # keep the current case, in case check_value accepts it anyway.
+            else:
+                value = self.get_allowed(key)[ind]
+        
+        check = self.check_value(key, value) 
+        if not check:
+            logger.warning('"%s" not valid option for "%s"', value, key)
+            return
+        if isinstance(check, str):
+            value = check
+        
+        self.switch[key] = value
+        
+        if user:
+            self.check_consistency(key, value)
+        
+    def remove_inconsistency(self, keys=[]):
+        
+        if not keys:
+            self.inconsistent_keys = {} 
+            self.inconsistent_details = {} 
+        elif isinstance(keys, list):
+            for key in keys:
+                if key in self.inconsistent_keys:
+                    del self.inconsistent_keys[keys]
+                    del self.inconsistent_details[keys]                
+        else:
+            if keys in self.inconsistent_keys:
+                del self.inconsistent_keys[keys]
+                del self.inconsistent_details[keys]
+        
+    def check_consistency(self, key, value):
+        """check the consistency of the new flag with the old ones"""
+        
+        if key in self.last_changed:
+            self.last_changed.remove(key)
+        self.last_changed.append(key)
+        
+        # this is used to update self.consistency_keys which contains:
+        #  {key: replacement value with solved conflict}
+        # it is based on self.consistency_details which is a dict
+        # key:  {'orig_value': 
+        #                'changed_key':
+        #                'new_changed_key_val':
+        #                'replacement': 
+        # which keeps track of all conflict and of their origin.
+        
+        
+        # rules is a dict: {keys:None} if the value for that key is consistent.
+        #                  {keys:value_to_replace} if that key is inconsistent
+        if hasattr(self, 'consistency_%s' % key):
+            rules = dict([(key2, None) for key2 in self.switch])
+            rules.update(getattr(self, 'consistency_%s' % key)(value, self.switch))
+        else:
+            rules = {}
+            for key2,value2 in self.switch.items():
+                if hasattr(self, 'consistency_%s_%s' % (key,key2)):
+                    rules[key2] = getattr(self, 'consistency_%s_%s' % (key,key2))(value, value2)
+                else:
+                    rules[key2] = None
+        
+        #update the self.inconsisten_details adding new conflict
+        # start by removing the inconsistency for the newly set parameter
+        self.remove_inconsistency(key)
+        # then add the new ones
+        for key2 in self.switch:
+            if rules[key2]:
+                info = {'orig_value': self.switch[key2],
+                        'changed_key': key,
+                        'new_changed_key_val': value,
+                        'replacement': rules[key2]}
+                if key2 in self.inconsistent_details:
+                    self.inconsistent_details[key2].append(info)
+                else:
+                    self.inconsistent_details[key2] = [info]
+        
+        if not self.inconsistent_details:
+            return 
+  
+        # review the status of all conflict
+        for key2 in dict(self.inconsistent_details):
+            for conflict in list(self.inconsistent_details[key2]):
+                keep_conflict = True
+                # check that we are still at the current value
+                if conflict['orig_value'] != self.switch[key2]:
+                    keep_conflict = False
+                # check if the reason of the conflict still in place
+                if self.switch[conflict['changed_key']] != conflict['new_changed_key_val']:
+                    keep_conflict = False
+                if not keep_conflict:
+                    self.inconsistent_details[key2].remove(conflict)
+            if not self.inconsistent_details[key2]:
+                del self.inconsistent_details[key2]
+
+
+        # create the valid set of replacement for this current conflict
+        # start by current status to avoid to keep irrelevant conflict
+        tmp_switch = dict(self.switch)
+        
+        # build the order in which we have to check the various conflict reported
+        to_check = [(c['changed_key'], c['new_changed_key_val']) \
+                         for k in self.inconsistent_details.values() for c in k
+                         if c['changed_key'] != key] 
+
+        to_check.sort(lambda x, y: -1 if self.last_changed.index(x[0])>self.last_changed.index(y[0]) else 1)
+
+        # validate tmp_switch.
+        to_check = [(key, value)] + to_check
+
+        i = 0
+        while len(to_check) and i < 50:
+            # check in a iterative way the consistency of the tmp_switch parameter
+            i +=1
+            key2, value2 = to_check.pop(0)
+            if hasattr(self, 'consistency_%s' % key2):
+                rules2 = dict([(key2, None) for key2 in self.switch])
+                rules2.update(getattr(self, 'consistency_%s' % key2)(value, tmp_switch))
+            else:
+                rules = {}
+                for key3,value3 in self.switch.items():
+                    if hasattr(self, 'consistency_%s_%s' % (key2,key3)):
+                        rules[key3] = getattr(self, 'consistency_%s_%s' % (key2,key3))(value2, value3)
+                    else:
+                        rules[key3] = None
+                        
+            for key, replacement in rules.items():
+                if replacement:
+                    tmp_switch[key] = replacement
+                    to_check.append((key, replacement))
+            # avoid situation like
+            # to_check = [('fixed_order', 'ON'), ('fixed_order', 'OFF')]
+            # always keep the last one
+            pos = {}
+            for i, (key,value) in enumerate(to_check):
+                pos[key] = i
+            to_check_new = []
+            for i, (key,value) in enumerate(to_check):
+                if pos[key] == i:
+                    to_check_new.append((key,value))
+            to_check = to_check_new
+            
+        # Now tmp_switch is to a fully consistent setup for sure.
+        # fill self.inconsistent_key
+        self.inconsistent_keys = {}
+        for key2, value2 in tmp_switch.items():
+            if value2 != self.switch[key2]:
+                self.inconsistent_keys[key2] = value2
+            
+    #    
+    # Helper routine for putting questions with correct color 
+    #
+    green = '\x1b[32m%s\x1b[0m' 
+    bold = '\x1b[33m%s\x1b[0m'
+    red   = '\x1b[31m%s\x1b[0m'    
+    def color_for_value(self, key, switch_value):
+        
+        if key in self.inconsistent_keys:
+            return self.red % switch_value + '-> ' + self.bold % self.inconsistent_keys[key]
+        
+        if self.check_value(key, switch_value):
+            if  hasattr(self, 'color_for_%s' % key):
+                return getattr(self, 'color_for_%s' % key)(switch_value)            
+            if switch_value in ['OFF']:
+                # inconsistent key are the list of key which are inconsistent with the last change
+                return self.red % switch_value
+            else:
+                return self.green % switch_value
+        else:
+            if ' ' in switch_value:
+                return self.bold % switch_value 
+            else:
+                return self.red % switch_value
+
+    def create_question(self):
+                
+        text = \
+        ["The following switches determine which programs are run:",
+         "/%s\\" % ("=" * (self.line_length-2))
+         ] 
+        
+        format = '| %2d. %{0}s %11s = %11s'.format(self.line_length-34)
+        
+        for i,(key, descrip) in enumerate(self.to_control):            
+            text.append(format % (i+1, descrip+':', key, self.color_for_value(key,self.switch[key])))
+
+        
+        text.append("\\%s/" % ("=" * (self.line_length-2)))
+        
+        # find a good example of switch to set
+        example = None
+        for key in self.switch:
+            if len(self.get_allowed(key)) > 1:
+                    for val in self.get_allowed(key):
+                        if val != self.switch[key]:
+                            example = (key, val)
+                            break
+                    else:
+                        continue
+                    break
+                
+        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."]
+        
+        self.question =    "\n".join(text)                                                              
+        return self.question
+    
+
+
+
 #===============================================================================
 # 
 #===============================================================================

=== modified file 'madgraph/interface/madevent_interface.py'
--- madgraph/interface/madevent_interface.py	2017-08-10 13:09:28 +0000
+++ madgraph/interface/madevent_interface.py	2017-08-15 12:03:07 +0000
@@ -494,6 +494,321 @@
         logger.info("   The banner can be remove only if all files are removed first.")
 
 
+class AskRun(cmd.ControlSwitch):
+    """a class for the question on what to do on a madevent run"""
+
+    to_control = [('shower', 'Choose the shower/hadronization program'),
+                      ('detector', 'Choose the detector simulation program'),
+                      ('analysis', 'Choose an analysis package (plot/convert)'),
+                      ('madspin', 'Decay onshell particles'),
+                      ('reweight', 'Add weights to events for new hypp.')
+                ]
+    
+    def __init__(self, question, line_args=[], mode=None, force=False,
+                                                                  *args, **opt):
+        
+        self.check_available_module(opt['mother_interface'].options)
+        self.me_dir = opt['mother_interface'].me_dir
+        super(AskRun,self).__init__(self.to_control, opt['mother_interface'],
+                                     *args, **opt)
+        
+        
+    def check_available_module(self, options):
+        
+        self.available_module = set()
+        
+        if options['pythia-pgs_path']:
+            self.available_module.add('PY6')
+            self.available_module.add('PGS')
+        if options['pythia8_path']:
+            self.available_module.add('PY8')
+        if options['madanalysis_path']:
+            self.available_module.add('MA4')
+        if options['madanalysis5_path']:
+            self.available_module.add('MA5')
+        if options['exrootanalysis_path']:
+            self.available_module.add('ExRoot')
+        if options['delphes_path']:
+            if 'PY6' in self.available_module or 'PY8' in self.available_module:
+                self.available_module.add('Delphes')
+        if not MADEVENT or ('mg5_path' in options and options['mg5_path']):
+            self.available_module.add('MadSpin')
+            if misc.has_f2py() or self.mother_interface.options['f2py_compiler']:
+                self.available_module.add('reweight')
+
+#   old mode to activate the shower            
+    def ans_parton(self, value=None):
+        """None: means that the user type 'pythia'
+           value: means that the user type pythia=value"""
+        
+        if value is None:
+            self.set_all_off()
+        else:
+            logger.warning('Invalid command: parton=%s' % value)
+            
+                
+#
+#   HANDLING SHOWER 
+#
+    def get_allowed_shower(self):
+        """return valid entry for the shower switch"""
+        
+        if hasattr(self, 'allowed_shower'):
+            return self.allowed_shower
+        
+        self.allowed_shower = []
+        if 'PY6' in self.available_module:
+            self.allowed_shower.append('Pythia6')
+        if 'PY8' in self.available_module:
+            self.allowed_shower.append('Pythia8')
+        if self.allowed_shower:
+            self.allowed_shower.append('OFF')
+        return self.allowed_shower
+    
+    def set_default_shower(self):
+        
+        if 'PY6' in self.available_module and\
+                   os.path.exists(pjoin(self.me_dir,'Cards','pythia_card.dat')):
+            self.switch['shower'] = 'Pythia6'
+        elif 'PY8' in self.available_module and\
+                  os.path.exists(pjoin(self.me_dir,'Cards','pythia8_card.dat')):
+            self.switch['shower'] = 'Pythia8'
+        elif self.get_allowed_shower():
+            self.switch['shower'] = 'OFF'
+        else:
+            self.switch['shower'] = 'Not Avail'
+
+    def check_shower(self, value):
+        """check an entry is valid. return the valid entry in case of shortcut"""
+        
+        if value in self.get_allowed_shower():
+            return True
+        
+        value =value.lower()
+        if value in ['py6','6','pythia_6']:
+            return 'Pythia6'
+        elif value in ['py8','8','pythia_8']:
+            return 'Pythia8'
+        else:
+            return False
+            
+            
+#   old mode to activate the shower            
+    def ans_pythia(self, value=None):
+        """None: means that the user type 'pythia'
+           value: means that the user type pythia=value"""
+        
+        if 'PY6' not in self.available_module:
+            logger.info('pythia-pgs not available. Ignore commmand')
+            return
+        
+        if value is None:
+            self.set_all_off()
+            self.switch['shower'] = 'Pythia6'
+        elif value == 'on':
+            return self.ans_pythia(None)
+        elif value == 'off':
+            self.set_switch('shower', 'OFF')
+        else:
+            logger.warning('Invalid command: pythia=%s' % value)
+            
+            
+    def consistency_shower_detector(self, vshower, vdetector):
+        """consistency_XX_YY(val_XX, val_YY)
+           -> XX is the new key set by the user to a new value val_XX
+           -> YY is another key
+           -> return value should be None or "replace_YY" 
+        """
+
+        if vshower == 'OFF':
+            if self.check_value('detector', vdetector) and  vdetector!= 'OFF':
+                return 'OFF'
+        if vshower == 'Pythia8' and vdetector == 'PGS':
+            return 'OFF'
+        
+        return None
+#
+#   HANDLING DETECTOR
+#
+    def get_allowed_detector(self):
+        """return valid entry for the switch"""
+ 
+        if hasattr(self, 'allowed_detector'):
+            return self.allowed_detector 
+        
+        self.allowed_detector = []
+        if 'PGS' in self.available_module:
+            self.allowed_detector.append('PGS')
+        if 'Delphes' in self.available_module:
+            self.allowed_detector.append('Delphes')
+
+            
+        if self.allowed_detector:
+            self.allowed_detector.append('OFF')
+        return self.allowed_detector  
+
+    def set_default_detector(self):
+        
+        self.set_default_shower() #ensure that this one is called first!
+        
+        if 'PGS' in self.available_module and self.switch['shower'] == 'Pythia6':
+            self.switch['detector'] = 'PGS'
+        elif 'Delphes' in self.available_module and self.switch['shower'] != 'OFF':
+            self.switch['detector'] = 'Delphes'
+        elif self.get_allowed_detector():
+            self.switch['detector'] = 'OFF'
+        else: 
+            self.switch['detector'] =  'missing'
+                
+#   old mode to activate pgs            
+    def ans_pgs(self, value=None):
+        """None: means that the user type 'pgs'
+           value: means that the user type pgs=value"""        
+        
+        if 'PGS' not in self.available_module:
+            logger.info('pythia-pgs not available. Ignore commmand')
+            return
+        
+        if value is None:
+            self.set_all_off()
+            self.switch['shower'] = 'Pythia6'
+            self.switch['detector'] = 'PGS'
+        elif value == 'on':
+            self.switch['shower'] = 'Pythia6'
+            self.switch['detector'] = 'PGS'
+        elif value == 'off':
+            self.set_switch('detector', 'OFF')
+        else:
+            logger.warning('Invalid command: pgs=%s' % value)
+
+            
+#   old mode to activate Delphes
+    def ans_delphes(self, value=None):
+        """None: means that the user type 'delphes'
+           value: means that the user type delphes=value"""          
+        
+        if 'Delphes' not in self.available_module:
+            logger.warning('Delphes not available. Ignore commmand')
+            return
+        
+        if value is None:
+            self.set_all_off()
+            if 'PY6' in self.available_module:
+                self.switch['shower'] = 'Pythia6'
+            else:
+                self.switch['shower'] = 'Pythia8'
+            self.switch['detector'] = 'Delphes'
+        elif value == 'on':
+            return self.ans_delphes(None)
+        elif value == 'off':
+            self.set_switch('detector', 'OFF')
+        else:
+            logger.warning('Invalid command: pgs=%s' % value)        
+
+    def consistency_detector_shower(self,vdetector, vshower):
+        """consistency_XX_YY(val_XX, val_YY)
+           -> XX is the new key set by the user to a new value val_XX
+           -> YY is another key
+           -> return value should be None or "replace_YY" 
+        """
+        
+        if vdetector == 'PGS' and vshower != 'Pythia6':
+            return 'Pythia6'
+        if vdetector == 'Delphes' and vshower  not in ['Pythia6', 'Pythia8']:
+            if 'PY8' in self.available_module:
+                return 'Pythia8'
+            elif 'PY6' in self.available_module:
+                return 'Pythia6'
+            else:
+                raise Exception
+        return None
+
+
+#
+#   HANDLING ANALYSIS
+#
+    def get_allowed_analysis(self):
+        """return valid entry for the shower switch"""
+        
+        if hasattr(self, 'allowed_analysis'):
+            return self.allowed_analysis
+        
+        self.allowed_analysis = []
+        if 'ExRoot' in self.available_module:
+            self.allowed_analysis.append('ExRoot')
+        if 'MA4' in self.available_module:
+            self.allowed_analysis.append('MadAnalysis4')
+        if 'MA5' in self.available_module:
+            self.allowed_analysis.append('MadAnalysis5')            
+            
+        if self.allowed_analysis:
+            self.allowed_analysis.append('OFF')
+            
+        return self.allowed_analysis
+   
+    def check_analysis(self, value):
+        """check an entry is valid. return the valid entry in case of shortcut"""
+        
+        if value in self.get_allowed_analysis():
+            return True
+        if value.lower() in ['ma4', 'madanalysis4', 'madanalysis_4','4']:
+            return 'MadAnalysis4'
+        if value.lower() in ['ma5', 'madanalysis5', 'madanalysis_5','5']:
+            return 'MadAnalysis5'
+        if value.lower() in ['ma', 'madanalysis']:
+            if 'MA5' in self.available_module:
+                return 'MadAnalysis5'
+            elif 'MA4' in self.available_module:
+                return 'MadAnalysis4'
+            else:
+                return False
+        else:
+            return False
+        
+        
+    def set_default_analysis(self):
+        """initialise the switch for analysis"""
+        
+        if 'MA4' in self.available_module and \
+                     os.path.exists(pjoin(self.me_dir,'Cards','plot_card.dat')):
+            self.switch['analysis'] = 'MadAnalysis4'
+        elif 'MA5' in self.available_module and\
+             (os.path.exists(pjoin(self.me_dir,'Cards','madanalysis5_parton_card.dat'))\
+             or os.path.exists(pjoin(self.me_dir,'Cards', 'madanalysis5_hadron_card.dat'))):
+            self.switch['analysis'] = 'MadAnalysis5'
+        elif 'ExRoot' in self.available_module:
+            self.switch['analysis'] = 'ExRoot'   
+        elif self.get_allowed_analysis(): 
+            self.switch['analysis'] = 'OFF'
+        else:
+            self.switch['analysis'] = 'Not Avail.'
+            
+#
+#   MADSPIN handling
+#
+    def set_default_madspin(self):
+        """initialise the switch for madspin"""
+        
+        if 'MadSpin' in self.available_module:
+            if os.path.exists(pjoin(self.me_dir,'Cards','madspin_card.dat')):
+                self.switch['madspin'] = 'ON'
+            else:
+                self.switch['madspin'] = 'OFF'
+        else:
+            self.switch['madspin'] = 'Not Avail.'
+#
+#   ReWeight handling
+#
+    def set_default_reweight(self):
+        """initialise the switch for reweight"""
+        
+        if 'reweight' in self.available_module:
+            if os.path.exists(pjoin(self.me_dir,'Cards','reweight_card.dat')):
+                self.switch['reweight'] = 'ON'
+            else:
+                self.switch['reweight'] = 'OFF'
+        else:
+            self.switch['reweight'] = 'Not Avail.'        
 
 #===============================================================================
 # CheckValidForCmd
@@ -1724,6 +2039,8 @@
         'delphes' : ['generate_events [OPTIONS]', 'multi_run [OPTIONS]']
     }
     
+    asking_for_run = AskRun
+    
     ############################################################################
     def __init__(self, me_dir = None, options={}, *completekey, **stdin):
         """ add information to the cmd """
@@ -5760,290 +6077,35 @@
         return True   
 
 
-
+    action_switcher = AskRun
     ############################################################################
     def ask_run_configuration(self, mode=None, args=[]):
         """Ask the question when launching generate_events/multi_run"""
-        
-        available_mode = ['0']
-        void = 'Not installed'
-        switch_order = ['shower', 'detector', 'analysis', 'madspin', 'reweight']
-        
-        switch = dict((k, void) for k in switch_order)
-
-        description = {'shower': 'Choose the shower/hadronization program:',
-                       'detector': 'Choose the detector simulation program:',
-                       'madspin': 'Decay particles with the MadSpin module:',
-                       'reweight':'Add weights to events for different model hypothesis:',
-                       'analysis':'Run an analysis package on the events generated:'
-                       }
-
-        force_switch = {('shower', 'OFF'): {'detector': 'OFF'},
-                       ('detector', 'PGS'): {'shower':'PYTHIA6'},
-                       ('detector', 'DELPHES'): {'shower': ['PYTHIA8', 'PYTHIA6']}}
-
-        switch_assign = lambda key, value: switch.__setitem__(key, value if value \
-                                         in valid_options[key] else switch[key])
-
-        valid_options = dict((k, ['OFF']) for k in switch_order) # track of all possible input for an entry
-        options =  ['auto', 'done']
-        options_legacy = []
-                
-        # Init the switch value according to the current status
-        if self.options['pythia-pgs_path']:
-            available_mode.append('1')
-            available_mode.append('2')
-            valid_options['shower'].append('PYTHIA6')
-            valid_options['detector'].append('PGS')
-            options_legacy += ['pythia', 'pgs', 'pythia=ON', 'pythia=OFF', 'pgs=ON', 'pgs=OFF']
-            if os.path.exists(pjoin(self.me_dir,'Cards','pythia_card.dat')):
-                switch['shower'] = 'PYTHIA6'
-            else:
-                switch['shower'] = 'OFF'
-            if os.path.exists(pjoin(self.me_dir,'Cards','pgs_card.dat')):
-                switch['detector'] = 'PGS'
-            else:
-                switch['detector'] = 'OFF'
-        
-        if self.options['pythia8_path']:
-            available_mode.append('1')
-            valid_options['shower'].append('PYTHIA8')
-            if os.path.exists(pjoin(self.me_dir,'Cards','pythia8_card.dat')):
-                switch['shower'] = 'PYTHIA8'
-            elif switch['shower'] == void:
-                switch['shower'] = 'OFF'            
-        
-        # MadAnalysis4 options
-        if self.options['madanalysis_path']:
-            if os.path.exists(pjoin(self.me_dir,'Cards','plot_card_default.dat')):
-                valid_options['analysis'].insert(0,'MADANALYSIS_4')
-
-            if os.path.exists(pjoin(self.me_dir,'Cards','plot_card.dat')):
-                switch['analysis'] = 'MADANALYSIS_4'
-        
-        # MadAnalysis5 options
-        if self.options['madanalysis5_path']:
-            if os.path.exists(pjoin(self.me_dir,'Cards','madanalysis5_parton_card_default.dat')) or \
-               os.path.exists(pjoin(self.me_dir,'Cards','madanalysis5_hadron_card_default.dat')):
-                valid_options['analysis'].append('MADANALYSIS_5')
-
-            parton_card_present = os.path.exists(pjoin(self.me_dir,'Cards',
-                                                'madanalysis5_parton_card.dat'))
-            hadron_card_present = os.path.exists(pjoin(self.me_dir,'Cards',
-                                                'madanalysis5_hadron_card.dat'))
-            if hadron_card_present or parton_card_present:
-                switch['analysis'] = 'MADANALYSIS_5'
-
-        # ExRootanalysis
-        eradir = self.options['exrootanalysis_path']
-        if eradir and misc.is_executable(pjoin(eradir,'ExRootLHEFConverter')):
-            valid_options['analysis'].insert(0,'EXROOTANALYSIS')
-            if switch['analysis'] in ['OFF', void]:
-                switch['analysis'] = 'EXROOTANALYSIS'
-
-                 
-
-        if len(valid_options['analysis'])>1:                
-            available_mode.append('3')
-            if switch['analysis'] == void:
-                switch['analysis'] = 'OFF'
-        else:
-            switch['analysis'] = 'No analysis tool interfaced to MG5aMC.'
-
-        # Need to allow Delphes only if a shower exists                
-        if self.options['delphes_path']:
-            if valid_options['shower'] != ['OFF']:
-                available_mode.append('2')
-                valid_options['detector'].append('DELPHES') 
-                options += ['delphes',   'delphes=ON', 'delphes=OFF']             
-                if os.path.exists(pjoin(self.me_dir,'Cards','delphes_card.dat')):
-                    switch['detector'] = 'DELPHES'
-                elif switch['detector'] not in ['PGS']:
-                    switch['detector'] = 'OFF'
-            elif valid_options['detector'] == ['OFF']:
-                switch['detector'] = "Requires a shower"
-                        
-        # Check switch status for MS/reweight
-        if not MADEVENT or ('mg5_path' in self.options and self.options['mg5_path']):
-            available_mode.append('4')
-            valid_options['madspin'] = ['ON', 'OFF']
-            if os.path.exists(pjoin(self.me_dir,'Cards','madspin_card.dat')):
-                switch['madspin'] = 'ON'
-            else:
-                switch['madspin'] = 'OFF'
-            if misc.has_f2py() or self.options['f2py_compiler']:
-                available_mode.append('5')
-                valid_options['reweight'] = ['ON', 'OFF']
-                if os.path.exists(pjoin(self.me_dir,'Cards','reweight_card.dat')):
-                    switch['reweight'] = 'ON'
-                else:
-                    switch['reweight'] = 'OFF'
-            else: 
-                switch['reweight'] = 'Not available (requires NumPy/f2py)'
-                       
+
+        passing_cmd = []
         if '-R' in args or '--reweight' in args:
-            if switch['reweight'] == 'OFF':
-                switch['reweight'] = 'ON'
-            elif switch['reweight'] != 'ON':
-                logger.critical("Cannot run reweight: %s", switch['reweight'])
+            passing_cmd.append('reweight=ON')
         if '-M' in args or '--madspin' in args:
-            if switch['madspin'] == 'OFF':
-                switch['madspin'] = 'ON'
-            elif switch['madspin'] != 'ON':
-                logger.critical("Cannot run madspin: %s", switch['reweight'])            
-
-        for id, key in enumerate(switch_order):
-            if len(valid_options[key]) >1:
-                options += ['%s=%s' % (key, s) for s in valid_options[key]]
-                options.append(key)
-            else:
-                options.append('%s=OFF' % (key))
-                
-        options += ['parton'] + sorted(list(set(available_mode)))
-        options += options_legacy
-        #options += ['pythia=ON', 'pythia=OFF', 'delphes=ON', 'delphes=OFF', 'pgs=ON', 'pgs=OFF']
-        #ask the question
-        
-        def color(switch_value):
-            green = '\x1b[32m%s\x1b[0m' 
-            bold = '\x1b[33m%s\x1b[0m'
-            red   = '\x1b[31m%s\x1b[0m'
-            if switch_value in ['OFF',void,'Requires a shower',
-                    'Not available (requires NumPy)',
-                    'Not available yet for this output/process']:
-                return red%switch_value
-            elif switch_value in ['ON','MADANALYSIS_4','MADANALYSIS_5',
-                                  'PYTHIA8','PYTHIA6','PGS','DELPHES-ATLAS',
-                                  'DELPHES-CMS','DELPHES', 'EXROOTANALYSIS']:
-                return green%switch_value
-            else:
-                return bold%switch_value                
-
-        if mode or not self.force:
-            answer = ''
-            while answer not in ['0', 'done', 'auto']:
-                if mode:
-                    answer = mode
-                else:      
-                    switch_format = " \x1b[31m%i\x1b[0m. %-60s %12s = %s"
-                    question = "The following switches determine which programs are run:\n"
-                    question += '/'+'-'*98+'\\\n'
-                    for id, key in enumerate(switch_order):
-                        question += '| %-115s|\n'%(switch_format%(id+1, description[key], key, color(switch[key])))
-                    question += '\\'+'-'*98+'/\n'
-                    question += '  Either type the switch number (1 to %s) to change its setting,\n' % (id+1)
-                    question += '  Set any switch explicitly (e.g. type \'madspin=ON\' at the prompt)\n'
-                    question += '  Type \'help\' for the list of all valid option\n' 
-                    question += '  Type \'0\', \'auto\', \'done\' or just press enter when you are done.\n'
-                    answer = self.ask(question, '0', options, casesensitive=False)
-                if (answer.isdigit() and answer != '0') or answer in ['shower', 'detector']:
-                    if answer.isdigit():
-                        key = switch_order[int(answer) - 1]
-                    else:
-                        key = answer
-                    for i, opt in enumerate(valid_options[key]):
-                        if opt == switch[key]:
-                            break
-                    i +=1
-                    if i == len(valid_options[key]):
-                        i=0
-                    answer = '%s=%s' % (key, valid_options[key][i])
-
-                if '=' in answer:
-                    key, status = answer.split('=')
-                    key, status = key.lower().strip(), status.upper().strip()
-                    
-                    if key not in switch:
-                        # this means use use outdated switch. Use converter to new syntax
-                        logger.warning("Using old syntax. Please check that we run what you expect.")
-                        if key == "pythia" and status == "ON":
-                            key, status = "shower", "PYTHIA6"
-                        elif key == "pythia" and status == "OFF":
-                            key, status = "shower", "OFF"
-                        elif key == "pgs" and status == "ON":
-                            if switch["detector"] in ["OFF", "PGS"] :
-                                key, status = "detector", "PGS"
-                            else:
-                                key, status = "detector", "DELPHES+PGS"
-                        elif key == "delphes" and status == "ON":
-                            if switch["detector"] in ["OFF", "DELPHES"] :
-                                key, status = "detector", "DELPHES"
-                            else:
-                                key, status = "detector", "DELPHES+PGS"                                
-                        elif key == "pgs" and status == "OFF":
-                            if switch["detector"] in ["OFF", "PGS"] :
-                                key, status = "detector", "OFF"
-                            elif switch["detector"] == "DELPHES+PGS":
-                                key, status = "detector", "DELPHES"
-                            else:
-                                key, status = "detector", switch['detector']
-                        elif key == "delphes" and status == "OFF":
-                            if switch["detector"] in ["OFF", "DELPHES"] :
-                                key, status = "detector", "OFF"
-                            elif switch["detector"] == "DELPHES+PGS":
-                                key, status = "detector", "PGS"
-                            else:
-                                key, status = "detector", switch['detector']                            
-                                                  
-
-                    switch[key] = status
-                    if (key, status) in force_switch:
-                        for key2, status2 in force_switch[(key, status)].items():
-                            if isinstance(status2, str):
-                                if switch[key2] not in  [status2, void]:
-                                    logger.info('For coherence \'%s\' is set to \'%s\''
-                                                % (key2, status2), '$MG:color:BLACK')
-                                    switch[key2] = status2
-                            else:
-                                if switch[key2] not in  status2 + [void]:
-                                    logger.info('For coherence \'%s\' is set to \'%s\''
-                                                % (key2, status2[0]), '$MG:color:BLACK')
-                                    switch[key2] = status2[0]
-                elif answer in ['0', 'auto', 'done']:
-                    continue
-                elif answer in ['parton', 'pythia','pgs','madspin','reweight', 'delphes']:
-                    logger.info('pass in %s only mode' % answer, '$MG:color:BLACK')
-                    switch_assign('madspin', 'OFF')
-                    switch_assign('reweight', 'OFF')
-                    if answer == 'parton':
-                        switch_assign('shower', 'OFF')
-                        switch_assign('detector', 'OFF')
-                    elif answer == 'pythia':
-                        switch_assign('shower', 'PYTHIA6')
-                        switch_assign('detector', 'OFF')
-                    elif answer == 'pgs':
-                        switch_assign('shower', 'PYTHIA6')
-                        switch_assign('detector', 'PGS')
-                    elif answer == 'delphes':
-                        switch_assign('shower', 'PYTHIA6')
-                        if switch['shower'] == 'OFF':
-                            switch_assign('shower', 'PYTHIA8')
-                        switch_assign('detector', 'DELPHES')
-                    elif answer == 'madspin':
-                        switch_assign('madspin', 'ON')
-                        switch_assign('shower', 'OFF')
-                        switch_assign('detector', 'OFF')
-                    elif answer == 'reweight':
-                        switch_assign('reweight', 'ON')
-                        switch_assign('shower', 'OFF')
-                        switch_assign('detector', 'OFF') 
-                    
-                if mode:
-                    answer =  '0' #mode auto didn't pass here (due to the continue)
-            else:
-                answer = 'auto'                        
-                                                                     
+            passing_cmd.append('madspin=ON')
+        
+        switch = self.ask('', '0', [], ask_class = self.action_switcher,
+                              mode=mode, line_args=args, force=self.force,
+                              first_cmd=passing_cmd)
+        
+        if 'dynamical' in switch:
+            mode = 'auto'
+        
         # Now that we know in which mode we are check that all the card
         #exists (copy default if needed)
     
         cards = ['param_card.dat', 'run_card.dat']
-        if switch['shower'] in ['PY6', 'PYTHIA6']:
+        if switch['shower'] == 'Pythia6':
             cards.append('pythia_card.dat')
-        if switch['shower'] in ['PY8', 'PYTHIA8']:
+        if switch['shower'] == 'Pythia8':
             cards.append('pythia8_card.dat')            
         if switch['detector'] in  ['PGS','DELPHES+PGS']:
             cards.append('pgs_card.dat')
-        if switch['detector'] in ['DELPHES', 'DELPHES+PGS']:
+        if switch['detector'] in ['Delphes', 'DELPHES+PGS']:
             cards.append('delphes_card.dat')
             delphes3 = True
             if os.path.exists(pjoin(self.options['delphes_path'], 'data')):
@@ -6053,11 +6115,11 @@
             cards.append('madspin_card.dat')
         if switch['reweight'] == 'ON':
             cards.append('reweight_card.dat')
-        if switch['analysis'] in ['MADANALYSIS_5']:
+        if switch['analysis'] in ['MADANALYSIS5']:
             cards.append('madanalysis5_parton_card.dat')
-        if switch['analysis'] in ['MADANALYSIS_5'] and not switch['shower']=='OFF':
+        if switch['analysis'] in ['MADANALYSIS5'] and not switch['shower']=='OFF':
             cards.append('madanalysis5_hadron_card.dat')
-        if switch['analysis'] in ['MADANALYSIS_4']:
+        if switch['analysis'] in ['MADANALYSIS4']:
             cards.append('plot_card.dat')
 
         self.keep_cards(cards)
@@ -6069,7 +6131,7 @@
             self.check_param_card(pjoin(self.me_dir,'Cards','param_card.dat' ))
             return switch
 
-        if answer == 'auto':
+        if 'dynamical' in switch and switch['dynamical']:
             self.ask_edit_cards(cards, plot=False, mode='auto')
         else:
             self.ask_edit_cards(cards, plot=False)