Source Code for Module madgraph.interface.master_interface

  1  ################################################################################ 
  2  # 
  3  # Copyright (c) 2009 The MadGraph5_aMC@NLO Development team and Contributors 
  4  # 
  5  # This file is a part of the MadGraph5_aMC@NLO project, an application which  
  6  # automatically generates Feynman diagrams and matrix elements for arbitrary 
  7  # high-energy processes in the Standard Model and beyond. 
  8  # 
  9  # It is subject to the MadGraph5_aMC@NLO license which should accompany this  
 10  # distribution. 
 11  # 
 12  # For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch 
 13  # 
 14  ################################################################################ 
 15  """A user friendly command line interface to access all MadGraph5_aMC@NLO features. 
 16     Uses the cmd package for command interpretation and tab completion. 
 17  """ 
 18   
 19   
 20  import atexit 
 21  import logging 
 22  import optparse 
 23  import os 
 24  import pydoc 
 25  import re 
 26  import subprocess 
 27  import sys 
 28  import traceback 
 29  import time 
 30   
 31  root_path = os.path.split(os.path.dirname(os.path.realpath( __file__ )))[0] 
 32  root_path = os.path.split(root_path)[0] 
 33  sys.path.insert(0, root_path) 
 34   
 35  #usefull shortcut 
 36  pjoin = os.path.join 
 37   
 38  import madgraph 
 39  import madgraph.core.diagram_generation as diagram_generation 
 40  import madgraph.core.helas_objects as helas_objects 
 41  import madgraph.loop.loop_base_objects as loop_base_objects 
 42  import madgraph.interface.extended_cmd as cmd 
 43  import madgraph.interface.madgraph_interface as MGcmd 
 44  import madgraph.interface.loop_interface as LoopCmd 
 45  import madgraph.interface.amcatnlo_interface as amcatnloCmd 
 46  import madgraph.fks.fks_base as fks_base 
 47  import madgraph.iolibs.files as files 
 48  import madgraph.various.misc as misc 
 49   
 50  from madgraph import MG4DIR, MG5DIR, MadGraph5Error 
 51   
 52  logger = logging.getLogger('cmdprint') # -> stdout 
 53   
 54   
 55 -class Switcher(object): 
 56      """ Helping class containing all the switching routine """ 
 57   
 58 -    def __init__(self, main='MadGraph', *args, **opt): 
 59               
 60          # define the interface 
 61          self.change_principal_cmd(main) 
 62          self.cmd.__init__(self, *args, **opt)        
 63   
 64      interface_names= {'MadGraph':('MG5_aMC',MGcmd.MadGraphCmd), 
 65                        'MadLoop':('MG5_aMC',LoopCmd.LoopInterface), 
 66                        'aMC@NLO':('MG5_aMC',amcatnloCmd.aMCatNLOInterface)} 
 67   
 68      _switch_opts = interface_names.keys() 
 69      current_interface = None 
 70      
 71      # Helper functions 
 72      
 73 -    def setup(self, *args, **opts): 
 74          """ Function to initialize the interface when switched to it. It is not 
 75          the same as __init__ as this latter functions would call its mother 
 76          from madgraph_interface and this is only desirable for the first 
 77          initialization when launching MG5 """ 
 78          return self.cmd.setup(self, *args, **opts) 
 79      
 80 -    def debug_link_to_command(self): 
 81          """redefine all the command to call directly the appropriate child""" 
 82           
 83          correct = True 
 84          # function which should be self.cmd dependent but which doesn't start 
 85          # by do_xxxx, help_xxx, check_xxxx or complete_xxx  
 86          overwritable = []         
 87          # list of item overwritten by the MasterClass 
 88          self.to_preserve = [key for key,method in Switcher.__dict__.items() if 
 89                         hasattr(method, '__call__') ] 
 90          self.to_preserve += ['do_shell', 'help_shell', 'complete_shell'] 
 91   
 92          ff = open(pjoin(os.getcwd(), 'additional_command'), 'w') 
 93           
 94          for key in dir(self): 
 95              # by pass all not over-writable command 
 96              if key in self.to_preserve: 
 97                  continue 
 98              if not (key.startswith('do_') or key.startswith('complete_') or \ 
 99                 key.startswith('help_') or key.startswith('check_') or \ 
100                 key in overwritable): 
101                  continue 
102              text = """\ 
103      def %(key)s(self, *args, **opts): 
104          return self.cmd.%(key)s(self, *args, **opts) 
105           
106  """ % {'key': key} 
107              logger.warning("""Command %s not define in the Master.  
108              The line to add to the master_interface.py are written in 'additional_command' file""" % key) 
109              ff.write(text) 
110              correct = False 
111                  
112               
113          # Check that all function define in more than one subclass is define 
114          # in the Switcher or in one of the MasterClass 
115          define = {} 
116          for mother in MasterCmd.__mro__: 
117              if mother.__name__ in ['Cmd', 'BasicCmd', 'ExtendedCmd']: 
118                  continue 
119               
120               
121              for data in mother.__dict__: 
122                  #check if  define in Switcher 
123                  if data in Switcher.__dict__ or data.startswith('__'): 
124                      continue 
125                  if data in MasterCmd.__dict__: 
126                      #always overwritten in the  main class 
127                      continue  
128                  if data not in define: 
129                      define[data] = mother.__name__ 
130                  else: 
131                      logger.warning('%s define in %s and in %s but not in Switcher.' % (data, define[data], mother.__name__)) 
132                      correct = False 
133                       
134          # Do the same for the WEb MasterClass 
135          define = {} 
136          for mother in MasterCmdWeb.__mro__: 
137              if mother.__name__ in ['Cmd', 'BasicCmd', 'ExtendedCmd']: 
138                  continue 
139               
140              for data in mother.__dict__: 
141                  #check if  define in Switcher 
142                  if data in Switcher.__dict__ or data.startswith('__'): 
143                      continue 
144                  if data in MasterCmdWeb.__dict__: 
145                      #always overwritten in the  main class 
146                      continue                 
147                  if data not in define: 
148                      define[data] = mother.__name__ 
149                  else: 
150                      logger.warning('%s define in %s and in %s but not in Switcher.' % (data, define[data], mother.__name__)) 
151                      correct = False                     
152                       
153          if not correct: 
154              raise Exception, 'The Cmd interface has dangerous features. Please see previous warnings and correct those.'  
155   
156       
157   
158      @staticmethod 
159 -    def extract_process_type(line): 
160          """Extract from a string what is the type of the computation. This  
161          returns a tuple (mode, option, pert_orders) where mode can be either 'NLO' or 'tree' 
162          and option 'all', 'real' or 'virt'.""" 
163   
164          # Perform sanity modifications on the lines: 
165          # Add a space before and after any > , $ / | [ ] 
166          space_before = re.compile(r"(?P<carac>\S)(?P<tag>[\\[\\]/\,\\$\\>|])(?P<carac2>\S)") 
167          line2 = space_before.sub(r'\g<carac> \g<tag> \g<carac2>', line)        
168           
169          # Use regular expressions to extract the loop mode (if present) and its 
170          # option, specified in the line with format [ option = loop_orders ] or 
171          # [ loop_orders ] which implicitly select the 'all' option. 
172          loopRE = re.compile(r"^(.*)(?P<loop>\[(\s*(?P<option>\w+)\s*=)?(?P<orders>.+)?\])(.*)$") 
173          res=loopRE.search(line) 
174          if res: 
175              orders=res.group('orders').split() if res.group('orders') else [] 
176              if res.group('option') and len(res.group('option').split())==1: 
177                  if res.group('option').split()[0]=='tree': 
178                      return ('tree',res.group('option').split()[0],orders) 
179                  else: 
180                      return ('NLO',res.group('option').split()[0],orders) 
181              else: 
182                  # If not option is set the convention is that the mode is 'all' 
183                  # unless no perturbation orders is defined. 
184                  if len(orders)>0: 
185                      return ('NLO','all',orders) 
186                  else: 
187                      return ('tree',None,[])                
188          else: 
189              return ('tree',None,[])     
190       
191      # Wrapping functions possibly switching to new interfaces 
192   
193 -    def do_add(self, line, *args, **opts): 
194           
195          argss = cmd.Cmd.split_arg(line) 
196          if len(argss)>=1 and argss[0] in ['process','timing','profile']: 
197              proc_line = ' '.join(argss[1:]) 
198              (type,nlo_mode,orders)=self.extract_process_type(proc_line) 
199              if type=='NLO': 
200                  if not nlo_mode in self._valid_nlo_modes: raise self.InvalidCMD( \ 
201                      'The NLO mode %s is not valid. Please choose one among: %s' \ 
202                      % (nlo_mode, ' '.join(self._valid_nlo_modes))) 
203                  elif nlo_mode in ['all', 'real', 'LOonly']: 
204                      self.change_principal_cmd('aMC@NLO') 
205                  elif nlo_mode in ['virt', 'sqrvirt']: 
206                      self.change_principal_cmd('MadLoop') 
207                  elif nlo_mode == 'noborn':  
208                      self.change_principal_cmd('MadLoop') 
209                      self.cmd.validate_model(self, loop_type=nlo_mode, 
210                                                              coupling_type=orders) 
211                      self.change_principal_cmd('MadGraph') 
212                      return self.cmd.create_loop_induced(self, line, *args, **opts) 
213          try: 
214              return  self.cmd.do_add(self, line, *args, **opts) 
215          except fks_base.NoBornException: 
216              logger.info("------------------------------------------------------------------------", '$MG:color:BLACK') 
217              logger.info(" No Born diagrams found. Now switching to the loop-induced mode.        ", '$MG:color:BLACK') 
218              logger.info(" Please cite ref. 'arXiv:1507.00020' when using results from this mode. ", '$MG:color:BLACK') 
219              logger.info("------------------------------------------------------------------------", '$MG:color:BLACK')             
220              self.change_principal_cmd('MadGraph') 
221              return self.cmd.create_loop_induced(self, line, *args, **opts) 
222   
223           
224 -    def do_check(self, line, *args, **opts): 
225   
226          argss = self.split_arg(line) 
227          proc_line = " ".join(argss[1:]) 
228          (type,nlo_mode,orders)=self.extract_process_type(proc_line) 
229          if type=='NLO': 
230              if not nlo_mode in self._valid_nlo_modes: raise self.InvalidCMD(\ 
231                  'The NLO mode %s is not valid. Please chose one among: %s' \ 
232                  % (nlo_mode, ' '.join(self._valid_nlo_modes))) 
233              elif nlo_mode == 'all': 
234                  self.change_principal_cmd('aMC@NLO') 
235              elif nlo_mode == 'real': 
236                  self.change_principal_cmd('aMC@NLO') 
237              elif nlo_mode == 'virt' or nlo_mode == 'sqrvirt': 
238                  self.change_principal_cmd('MadLoop') 
239          else: 
240              self.change_principal_cmd('MadGraph') 
241           
242          return self.cmd.do_check(self, line, *args, **opts) 
243   
244 -    def do_generate(self, line, *args, **opts): 
245   
246          argss = cmd.Cmd.split_arg(line) 
247          # Make sure to switch to the right interface. 
248          if len(argss)>=1:             
249              proc_line = ' '.join(argss[1:]) 
250              (type,nlo_mode,orders)=self.extract_process_type(proc_line) 
251              if type=='NLO': 
252                  if not nlo_mode in self._valid_nlo_modes: raise self.InvalidCmd( \ 
253                      'The NLO mode %s is not valid. Please chose one among: %s' \ 
254                      % (nlo_mode, ' '.join(self._valid_nlo_modes))) 
255                  elif nlo_mode in ['all', 'real', 'LOonly']: 
256                      self._fks_multi_proc = fks_base.FKSMultiProcess() 
257                      self.change_principal_cmd('aMC@NLO') 
258                  elif nlo_mode == 'virt' or nlo_mode == 'virtsqr': 
259                      self.change_principal_cmd('MadLoop') 
260              else: 
261                  self.change_principal_cmd('MadGraph')         
262          return self.cmd.do_generate(self, line, *args, **opts) 
263   
264 -    def do_import(self, *args, **opts): 
265          self.cmd.do_import(self, *args, **opts) 
266          if self._curr_model: 
267              if isinstance(self._curr_model, loop_base_objects.LoopModel) and \ 
268                 self._curr_model['perturbation_couplings']!=[] and \ 
269                              self.current_interface not in ['aMC@NLO','MadLoop']: 
270                  self.change_principal_cmd('aMC@NLO') 
271              if (not isinstance(self._curr_model, loop_base_objects.LoopModel) or \ 
272                 self._curr_model['perturbation_couplings']==[]) and \ 
273                                            self.current_interface in ['MadLoop']: 
274                  self.change_principal_cmd('MadGraph') 
275          import madgraph.various.misc as misc 
276          return 
277       
278 -    def do_output(self, line, *args, **opts): 
279          """ treat output aloha in order to use always the one in MG5 """ 
280          if line.strip().startswith('aloha'): 
281              MGcmd.MadGraphCmd.do_output(self, line, *args, **opts) 
282          else: 
283              self.cmd.do_output(self, line, *args, **opts) 
284       
285 -    def check_output(self, arg, *args, **opts): 
286          if arg and arg[0] == 'aloha': 
287              MGcmd.MadGraphCmd.check_output(self, arg, *args, **opts) 
288          else: 
289              self.cmd.check_output(self, arg, *args, **opts) 
290               
291       
292           
293   
294      # Dummy functions, not triggering any switch of interfaces 
295               
296 -    def export(self, *args, **opts): 
297          return self.cmd.export(self, *args, **opts) 
298       
299 -    def check_add(self, *args, **opts): 
300          return self.cmd.check_add(self, *args, **opts) 
301           
302 -    def check_answer_in_input_file(self, *args, **opts): 
303          return self.cmd.check_answer_in_input_file(self, *args, **opts)   
304       
305 -    def check_check(self, *args, **opts): 
306          return self.cmd.check_check(self, *args, **opts) 
307           
308 -    def check_define(self, *args, **opts): 
309          return self.cmd.check_define(self, *args, **opts) 
310   
311 -    def check_decay_diagram(self, *args, **opts): 
312          return self.cmd.check_decay_diagram(self, *args, **opts) 
313   
314 -    def complete_decay_diagram(self, *args, **opts): 
315          return self.cmd.complete_decay_diagram(self, *args, **opts) 
316   
317 -    def do_decay_diagram(self, *args, **opts): 
318          return self.cmd.do_decay_diagram(self, *args, **opts) 
319   
320 -    def help_decay_diagram(self, *args, **opts): 
321          return self.cmd.help_decay_diagram(self, *args, **opts) 
322   
323 -    def check_compute_widths(self, *args, **opts): 
324          return self.cmd.check_compute_widths(self, *args, **opts) 
325       
326 -    def complete_compute_widths(self, *args, **opts): 
327          return self.cmd.complete_compute_widths(self, *args, **opts) 
328   
329 -    def do_compute_widths(self, *args, **opts): 
330          return self.cmd.do_compute_widths(self, *args, **opts) 
331   
332 -    def help_compute_widths(self, *args, **opts): 
333          return self.cmd.help_compute_widths(self, *args, **opts) 
334   
335 -    def check_display(self, *args, **opts): 
336          return self.cmd.check_display(self, *args, **opts) 
337           
338 -    def check_draw(self, *args, **opts): 
339          return self.cmd.check_draw(self, *args, **opts) 
340           
341 -    def check_for_export_dir(self, *args, **opts): 
342          return self.cmd.check_for_export_dir(self, *args, **opts) 
343           
344 -    def check_generate(self, *args, **opts): 
345          return self.cmd.check_generate(self, *args, **opts) 
346   
347 -    def check_tutorial(self, *args, **opts): 
348          return self.cmd.check_tutorial(self, *args, **opts) 
349           
350 -    def check_history(self, *args, **opts): 
351          return self.cmd.check_history(self, *args, **opts) 
352           
353 -    def check_import(self, *args, **opts): 
354          return self.cmd.check_import(self, *args, **opts) 
355           
356 -    def check_install(self, *args, **opts): 
357          return self.cmd.check_install(self, *args, **opts) 
358           
359 -    def check_launch(self, *args, **opts): 
360          return self.cmd.check_launch(self, *args, **opts) 
361           
362 -    def check_load(self, *args, **opts): 
363          return self.cmd.check_load(self, *args, **opts) 
364           
365 -    def check_open(self, *args, **opts): 
366          return self.cmd.check_open(self, *args, **opts) 
367           
368 -    def check_process_format(self, *args, **opts): 
369          return self.cmd.check_process_format(self, *args, **opts) 
370       
371 -    def check_save(self, *args, **opts): 
372          return self.cmd.check_save(self, *args, **opts) 
373           
374 -    def check_set(self, *args, **opts): 
375          return self.cmd.check_set(self, *args, **opts) 
376           
377 -    def get_stored_line(self, *args, **opts): 
378          return self.cmd.get_stored_line(self, *args, **opts) 
379           
380 -    def complete_add(self, *args, **opts): 
381          return self.cmd.complete_add(self, *args, **opts) 
382   
383 -    def complete_switch(self, *args, **opts): 
384          return self.cmd.complete_switch(self, *args, **opts) 
385   
386 -    def complete_check(self, *args, **opts): 
387          return self.cmd.complete_check(self, *args, **opts) 
388           
389 -    def complete_define(self, *args, **opts): 
390          return self.cmd.complete_define(self, *args, **opts) 
391           
392 -    def complete_display(self, *args, **opts): 
393          return self.cmd.complete_display(self, *args, **opts) 
394           
395 -    def complete_draw(self, *args, **opts): 
396          return self.cmd.complete_draw(self, *args, **opts) 
397           
398 -    def complete_generate(self, *args, **opts): 
399          return self.cmd.complete_generate(self, *args, **opts) 
400           
401 -    def complete_help(self, *args, **opts): 
402          return self.cmd.complete_help(self, *args, **opts) 
403           
404 -    def complete_history(self, *args, **opts): 
405          return self.cmd.complete_history(self, *args, **opts) 
406           
407 -    def complete_import(self, *args, **opts): 
408          return self.cmd.complete_import(self, *args, **opts) 
409           
410 -    def complete_install(self, *args, **opts): 
411          return self.cmd.complete_install(self, *args, **opts) 
412           
413 -    def complete_launch(self, *args, **opts): 
414          return self.cmd.complete_launch(self, *args, **opts) 
415           
416 -    def complete_load(self, *args, **opts): 
417          return self.cmd.complete_load(self, *args, **opts) 
418           
419 -    def complete_open(self, *args, **opts): 
420          return self.cmd.complete_open(self, *args, **opts) 
421           
422 -    def complete_output(self, *args, **opts): 
423          return self.cmd.complete_output(self, *args, **opts) 
424           
425 -    def complete_save(self, *args, **opts): 
426          return self.cmd.complete_save(self, *args, **opts) 
427           
428 -    def complete_set(self, *args, **opts): 
429          return self.cmd.complete_set(self, *args, **opts) 
430           
431 -    def complete_tutorial(self, *args, **opts): 
432          return self.cmd.complete_tutorial(self, *args, **opts) 
433   
434 -    def do_switch(self, *args, **opts): 
435          """Not in help """ 
436          return self.cmd.do_switch(self, *args, **opts) 
437         
438 -    def do_EOF(self, *args, **opts): 
439          return self.cmd.do_EOF(self, *args, **opts) 
440           
441 -    def do_define(self, *args, **opts): 
442          return self.cmd.do_define(self, *args, **opts) 
443           
444 -    def do_display(self, *args, **opts): 
445          return self.cmd.do_display(self, *args, **opts) 
446           
447 -    def do_exit(self, *args, **opts): 
448          return self.cmd.do_exit(self, *args, **opts) 
449           
450 -    def do_help(self, *args, **opts): 
451          return self.cmd.do_help(self, *args, **opts) 
452           
453 -    def do_history(self, *args, **opts): 
454          return self.cmd.do_history(self, *args, **opts)  
455           
456 -    def do_install(self, *args, **opts): 
457          self.cmd.do_install(self, *args, **opts) 
458           
459 -    def do_launch(self, line, *argss, **opts): 
460          args = cmd.Cmd.split_arg(line) 
461          # check if a path is given 
462          if len(args) >=1: 
463              if os.path.isdir(args[0]): 
464                  path = os.path.realpath(args[0]) 
465              elif os.path.isdir(pjoin(MG5DIR,args[0])): 
466                  path = pjoin(MG5DIR,args[0]) 
467              elif  MG4DIR and os.path.isdir(pjoin(MG4DIR,args[0])): 
468                  path = pjoin(MG4DIR,args[0]) 
469              else: 
470                  path=None 
471          # if there is a path, find what output has been done 
472              if path: 
473                  type = self.cmd.find_output_type(self, path)  
474                  if type in ['standalone', 'standalone_cpp', 'pythia8', 'madevent']: 
475                      self.change_principal_cmd('MadGraph') 
476                  elif type == 'aMC@NLO': 
477                      self.change_principal_cmd('aMC@NLO') 
478                  elif type == 'MadLoop': 
479                      self.change_principal_cmd('MadLoop') 
480   
481          return self.cmd.do_launch(self, line, *argss, **opts) 
482           
483 -    def do_load(self, *args, **opts): 
484          return self.cmd.do_load(self, *args, **opts) 
485           
486 -    def do_open(self, *args, **opts): 
487          return self.cmd.do_open(self, *args, **opts) 
488           
489 -    def do_quit(self, *args, **opts): 
490          return self.cmd.do_quit(self, *args, **opts) 
491           
492 -    def do_save(self, *args, **opts): 
493          return self.cmd.do_save(self, *args, **opts) 
494           
495 -    def do_set(self, *args, **opts): 
496          return self.cmd.do_set(self, *args, **opts) 
497       
498 -    def do_tutorial(self, *args, **opts): 
499          return self.cmd.do_tutorial(self, *args, **opts) 
500   
501 -    def help_EOF(self, *args, **opts): 
502          return self.cmd.help_EOF(self, *args, **opts) 
503           
504 -    def help_add(self, *args, **opts): 
505          return self.cmd.help_add(self, *args, **opts) 
506           
507 -    def help_check(self, *args, **opts): 
508          return self.cmd.help_check(self, *args, **opts) 
509           
510 -    def help_define(self, *args, **opts): 
511          return self.cmd.help_define(self, *args, **opts) 
512           
513 -    def help_display(self, *args, **opts): 
514          return self.cmd.help_display(self, *args, **opts) 
515           
516 -    def help_generate(self, *args, **opts): 
517          return self.cmd.help_generate(self, *args, **opts) 
518           
519 -    def help_help(self, *args, **opts): 
520          return self.cmd.help_help(self, *args, **opts) 
521           
522 -    def help_history(self, *args, **opts): 
523          return self.cmd.help_history(self, *args, **opts) 
524           
525 -    def help_import(self, *args, **opts): 
526          return self.cmd.help_import(self, *args, **opts) 
527           
528 -    def help_install(self, *args, **opts): 
529          return self.cmd.help_install(self, *args, **opts) 
530           
531 -    def help_launch(self, *args, **opts): 
532          return self.cmd.help_launch(self, *args, **opts) 
533           
534 -    def help_load(self, *args, **opts): 
535          return self.cmd.help_load(self, *args, **opts) 
536           
537 -    def help_open(self, *args, **opts): 
538          return self.cmd.help_open(self, *args, **opts) 
539           
540 -    def help_output(self, *args, **opts): 
541          return self.cmd.help_output(self, *args, **opts) 
542           
543 -    def help_quit(self, *args, **opts): 
544          return self.cmd.help_quit(self, *args, **opts) 
545           
546 -    def help_save(self, *args, **opts): 
547          return self.cmd.help_save(self, *args, **opts) 
548           
549 -    def help_set(self, *args, **opts): 
550          return self.cmd.help_set(self, *args, **opts) 
551           
552 -    def help_tutorial(self, *args, **opts): 
553          return self.cmd.help_tutorial(self, *args, **opts) 
554           
555 -    def test_interface(self, *args, **opts): 
556          return self.cmd.test_interface(self, *args, **opts) 
557   
558 -    def set_configuration(self, *args, **opts): 
559          return self.cmd.set_configuration(self, *args, **opts) 
560   
561 -    def check_customize_model(self, *args, **opts): 
562          return self.cmd.check_customize_model(self, *args, **opts) 
563   
564 -    def complete_customize_model(self, *args, **opts): 
565          return self.cmd.complete_customize_model(self, *args, **opts) 
566   
567 -    def do_customize_model(self, *args, **opts): 
568          return self.cmd.do_customize_model(self, *args, **opts) 
569   
570 -    def help_customize_model(self, *args, **opts): 
571          return self.cmd.help_customize_model(self, *args, **opts) 
572   
573 -class MasterCmd(Switcher, LoopCmd.LoopInterface, amcatnloCmd.aMCatNLOInterface, cmd.CmdShell): 
574   
575 -    def __init__(self, main='MadGraph', *args, **opt): 
576               
577          # define the interface 
578          if main in self.interface_names.keys(): 
579              self.prompt= self.interface_names[main][0]+'>' 
580              self.cmd= self.interface_names[main][1] 
581              self.current_interface=main 
582          else: 
583              raise MadGraph5Error, 'Type of interface not valid: %s' % main   
584          self.cmd.__init__(self, *args, **opt)      
585          self.current_interface = main   
586       
587 -    def complete_switch(self, text, line, begidx, endidx): 
588          """Complete the switch command""" 
589          return self.list_completion(text,self._switch_opts) 
590           
591 -    def do_switch(self, line): 
592          """Not in help: Allow to switch to any given interface from command line """ 
593   
594          args = cmd.Cmd.split_arg(line) 
595          if len(args)==1 and args[0] in self.interface_names.keys(): 
596              self.change_principal_cmd(args[0]) 
597          else: 
598              raise self.InvalidCmd("Invalid switch command or non existing interface %s."\ 
599                              %args[0]+" Valid interfaces are %s"\ 
600                              %','.join(interface_quick_name.keys())) 
601   
602 -    def change_principal_cmd(self, name): 
603          old_cmd=self.current_interface 
604          if name in self.interface_names.keys(): 
605              self.prompt= self.interface_names[name][0]+'>' 
606              self.cmd= self.interface_names[name][1] 
607              self.current_interface=name 
608          else: 
609              raise MadGraph5Error, 'Type of interface not valid: %s' % name   
610           
611          if self.interface_names[old_cmd][0]!=self.interface_names[name][0]: 
612              logger.info("Switching from interface %s to %s"\ 
613                          %(self.interface_names[old_cmd][0],\ 
614                            self.interface_names[name][0])) 
615              # Setup the interface 
616              self.cmd.setup(self) 
617           
618          if __debug__: 
619              self.debug_link_to_command()       
620           
621   
622 -class MasterCmdWeb(MGcmd.MadGraphCmdWeb, Switcher, LoopCmd.LoopInterfaceWeb): 
623      
624 -    def __init__(self, *arg, **opt): 
625       
626          if os.environ.has_key('_CONDOR_SCRATCH_DIR'): 
627              self.writing_dir = pjoin(os.environ['_CONDOR_SCRATCH_DIR'], \ 
628                                                                   os.path.pardir) 
629          else: 
630              self.writing_dir = pjoin(os.environ['MADGRAPH_DATA'], 
631                                 os.environ['REMOTE_USER']) 
632               
633           
634          #standard initialization 
635          Switcher.__init__(self, mgme_dir = '', *arg, **opt) 
636           
637          self.options['timeout'] = 1 # time authorize to answer question [0 is no time limit] 
638           
639 -    def change_principal_cmd(self, name): 
640          if name == 'MadGraph': 
641              self.cmd = MGcmd.MadGraphCmdWeb 
642          elif name == 'Loop': 
643              self.cmd = LoopCmd.LoopInterfaceWeb 
644          else: 
645              raise MadGraph5Error, 'Type of interface not valid'   
646           
647          if __debug__: 
648              self.debug_link_to_command()  
649       
650 -    def do_shell(self, *args): 
651          raise Exception 
652       
653 -    def finalize(self, nojpeg, flaglist=[]): 
654          """Finalize web generation""" 
655   
656          if flaglist != []: 
657              raise Exception 
658          self.cmd.finalize(self, nojpeg, online = True) 
659       
660 -    def finalize(self, nojpeg, **opts): 
661          """Finalize web generation"""  
662           
663          opts['online'] = True 
664          self.cmd.finalize(self, nojpeg, opts) 
665   
666      # Generate a new amplitude 
667 -    def do_generate(self, line): 
668          """Generate an amplitude for a given process""" 
669   
670          try: 
671              Switcher.do_generate(self, line) 
672          except: 
673              # put the stop logo on the web 
674              files.cp(self._export_dir+'/HTML/stop.jpg',self._export_dir+'/HTML/card.jpg') 
675              raise 
676       
677      # Add a process to the existing multiprocess definition 
678 -    def do_add(self, line): 
679          """Generate an amplitude for a given process and add to 
680          existing amplitudes 
681          syntax: 
682          """ 
683          try: 
684             Switcher.do_add(self, line) 
685          except: 
686              # put the stop logo on the web 
687              files.cp(self._export_dir+'/HTML/stop.jpg',self._export_dir+'/HTML/card.jpg') 
688              raise 
689           
690      # Use the cluster file for the configuration 
691 -    def set_configuration(self, config_path=None, final=False): 
692           
693          """Force to use the web configuration file only""" 
694          config_path = pjoin(os.environ['MADGRAPH_BASE'], 'mg5_configuration.txt') 
695          return Switcher.set_configuration(self, config_path=config_path, final=final) 
696       
697 -    def do_save(self, line, check=True, **opt): 
698          """Save information to file""" 
699           
700          if check: 
701              self.check_save([]) 
702              raise #useless but full security 
703           
704          args = self.split_arg(line) 
705          if args[0] != 'options': 
706              Switcher.do_save(self, line,check, opt) 
707          else: 
708              # put default options since  
709              # in the web the local file is not used 
710              # in download the default file is more usefull 
711              files.cp(pjoin(MG5DIR,'input','mg5_configuration.txt'), args[1]) 
712               
713 -    def do_install(self, line): 
714          """block all install""" 
715          return 
716