~maddevelopers/mg5amcnlo/2.5.0

                    param = param_card['decay'].get((part.pdg_code,))

 

                    if  param.value != 0:

                                    % part.name,'$MG:color:BLACK')

                        param.value = 0

 

            param_card.write_inc_file(outfile, ident_card, default)

 

 

    def ask_edit_cards(self, cards, mode='fixed', plot=True, first_cmd=None):

        """ """

        if self.cluster_mode == 1:

            opt = self.options

            cluster_name = opt['cluster_type']

        """

        1) Check that no scan parameter are present

        2) Check that all the width are define in the param_card.

        - If a scan parameter is define. create the iterator and recall this fonction 

          on the first element.

        

        pattern_scan = re.compile(r'''^(decay)?[\s\d]*scan''', re.I+re.M)  

        pattern_width = re.compile(r'''decay\s+(\+?\-?\d+)\s+auto(@NLO|)''',re.I)

            self.param_card_iterator = main_card

            first_card = main_card.next(autostart=True)

            first_card.write(path)

        

        pdg_info = pattern_width.findall(text)

        if pdg_info:

                if not has_nlo:

                    self.do_compute_widths('%s %s' % (' '.join(pdg), path))

                else:

            else:

                logger.info('''Some width are on Auto in the card. 

    Those will be computed as soon as you have finish the edition of the cards.

    If you want to force the computation right now and being able to re-edit

    the cards afterwards, you can type \"compute_wdiths\".''')

 

    def add_error_log_in_html(self, errortype=None):

        """If a ME run is currently running add a link in the html output"""

 

 

 

        "Complete the compute_widths command"

 

        args = self.split_arg(line[0:begidx])

                            ['--path=', '--output=', '--min_br=0.\$', '--nlo',

                             '--precision_channel=0.\$', '--body_decay='])            

        

        

 

    def update_make_opts(self):

            filename = pdf_info[filename]['filename']

        

        if os.path.exists(pjoin(pdfsets_dir, filename)):

            return

             

        logger.info('Trying to download %s' % filename)

                        'fixed_scale': ['run_card fixed_fac_scale T', 'run_card fixed_ren_scale T', 'run_card scale %(0)s', 'run_card dsqrt_q2fact1 %(0)s' ,'run_card dsqrt_q2fact2 %(0)s'],

                        }

    

        # Initiation

        if 'pwd' in opt:

            self.me_dir = opt['pwd']

        if not hasattr(self, 'me_dir') or not self.me_dir:

            self.me_dir = self.mother_interface.me_dir

 

 

        try:

        except (check_param_card.InvalidParamCard, ValueError) as e:

            logger.error('Current param_card is not valid. We are going to use the default one.')

            logger.error('problem detected: %s' % e)

            files.cp(pjoin(self.me_dir,'Cards','param_card_default.dat'),

                     pjoin(self.me_dir,'Cards','param_card.dat'))

        

        

        try:

        except IOError:

            self.run_card = {}

        try:

        except IOError:

            run_card_def = {}

 

            self.do_change_tf = self.mother_interface.do_define_transfer_fct

            self.complete_change_tf = self.mother_interface.complete_define_transfer_fct

            self.help_change_tf = self.mother_interface.help_define_transfer_fct

                logger.warning('No transfer function currently define. Please use the change_tf command to define one.')

            

            

                import madgraph.madweight.Cards as mwcards

            except:

                import internal.madweight.Cards as mwcards

            self.mw_card = self.mw_card.info

            self.mw_vars = []

            for key in self.mw_card:

                    

        #check if MadLoopParams.dat is present:

        self.has_ml = False

            self.has_ml = True

            self.MLcardDefault = banner_mod.MadLoopParam()

            

            self.ml_vars = [k.lower() for k in self.MLcard.keys()]

                import madgraph.various.shower_card as showercards

            except:

                import internal.shower_card as showercards

            self.shower_vars = self.shower_card.keys()

            

            # check for conflict with run_card/param_card

                    self.conflict.append(var)

 

 

        """ Complete the set command"""

 

        prev_timer = signal.alarm(0) # avoid timer if any

                        possibilities['Special value'] = self.list_completion(text, opts)

                possibilities['MadWeight Card id' ] = self.list_completion(text, ids) 

 

 

    def do_set(self, line):

        """ edit the value of one parameter in the card"""

 

        # Special case for the qcut value

        if args[0].lower() == 'qcut':

            if os.path.exists(pythia_path):

                logger.info('add line QCUT = %s in pythia_card.dat' % args[1])

                p_card = open(pythia_path,'r').read()

                return

        # Special case for the showerkt value

        if args[0].lower() == 'showerkt':

            if os.path.exists(pythia_path):

                logger.info('add line SHOWERKT = %s in pythia_card.dat' % args[1].upper())

                p_card = open(pythia_path,'r').read()

        if args[0] in ['run_card', 'param_card', 'MadWeight_card', 'shower_card']:

            if args[1] == 'default':

                logging.info('replace %s by the default card' % args[0])

                if args[0] == 'param_card':

                elif args[0] == 'run_card':

                elif args[0] == 'shower_card':

                return

            else:

                card = args[0]

            if args[1] == 'default':

                logging.info('replace MadLoopParams.dat by the default card')

                self.MLcard = banner_mod.MadLoopParam(self.MLcardDefault)

                                  commentdefault=True)

                return

            else:

        elif args[0] in ['madspin_card']:

            if args[1] == 'default':

                logging.info('replace madspin_card.dat by the default card')

                return

            else:

                logger.warning("""Command set not allowed for modifying the madspin_card. 

                logger.warning(text)

 

            if args[start+1] == 'default':

                if args[start] in default.keys():

                    self.setR(args[start],default[args[start]])

                else:

                    except NameError:

                        val = args[start+1]

                self.setR(args[start], val)

            

        ### PARAM_CARD WITH BLOCK NAME -----------------------------------------

        elif (args[start] in self.param_card or args[start] == 'width') \

                                continue

                            else:

                                self.setP(args[start], key, args[-1])

                        return

                    logger.warning('invalid set command %s (failed to identify LHA information)' % line)

                    return

            else:

                logger.warning('invalid set command %s' % line)

                return

        

        # PARAM_CARD NO BLOCK NAME ---------------------------------------------

        elif args[start] in self.pname2block and card != 'run_card':

            name = args[start+1]

            value = args[start+2:]

            self.setM(block, name, value)

        

        # MadWeight_card NO Block name -----------------------------------------

        elif self.has_mw and args[start] in self.mw_vars \

            name = args[start]

            value = args[start+1:]

            self.setM(block, name, value)

             

        # MadWeight_card New Block ---------------------------------------------

        elif self.has_mw and args[start].startswith('mw_') and len(args[start:]) == 3\

            name = args[start+1]

            value = args[start+2]

            self.setM(block, name, value)

 

        #### SHOWER CARD

        elif self.has_shower and args[start].lower() in [l.lower() for l in \

                return

 

            if args[start+1].lower() == 'default':

                if args[start] in default.keys():

                else:

                    logger.info('remove information %s from the shower_card' % args[start])

                    del self.shower_card[args[start]]

            elif args[start+1].lower() in ['t','.true.','true']:

            elif args[start+1].lower() in ['f','.false.','false']:

            else:

                args_str = ' '.join(str(a) for a in args[start+1:len(args)])

     

        # MadLoop Parameter  ---------------------------------------------------

        elif self.has_ml and args[start] in self.ml_vars \

                value = args[start+1]

                default = False

            self.setML(args[start], value, default=default)

                              commentdefault=True)

                

        #INVALID --------------------------------------------------------------

            logger.info('name %s was not present in the block %s for the current MadWeight card. We are adding it' % (name,block),'$MG:color:BLACK')

        if value == 'default':

            import madgraph.madweight.Cards as mwcards

            try:

                value = mw_default[block][name]

            except KeyError:

        self.mw_card[block][name] = value

    

    def setR(self, name, value):

        self.run_card.set(name, value, user=True)

 

    def setML(self, name, value, default=False):

        except Exception, error:

            logger.warning("Fail to change parameter. Please Retry. Reason: %s." % error)

            return

        if default and name.lower() in self.MLcard.user_set:

            self.MLcard.user_set.remove(name.lower())

 

        if isinstance(value, str):

            value = value.lower()

            if value == 'default':

                value = default[block].param_dict[lhaid].value

 

            elif value in ['auto', 'auto@nlo']:

            not self.run_card['store_rwgt_info']:

            #check if a NLO reweighting is required

                re_pattern = re.compile(r'''^\s*change\s*mode\s* (LO\+NLO|LO|NLO)\s*(?:#|$)''', re.M+re.I)

                options = re_pattern.findall(text)

                if any(o in ['NLO', 'LO+NLO'] for o in options):

                    logger.info('NLO reweighting is on ON. Automatically set store_rwgt_info to True', '$MG:color:BLACK' )

            logger.warning('No transfer function currently define. Please use the change_tf command to define one.')

    

    def postcmd(self, stop, line):

        ending_question = cmd.OneLinePathCompletion.postcmd(self,stop,line)

        if ending_question:

            self.check_card_consistency()

            return ending_question

    

    def check_answer_consistency(self):

        """function called if the code reads a file"""

      

    def help_set(self):

        '''help message for set'''

        elif os.path.isfile(line):

            self.copy_file(line)

            self.value = 'repeat'

            self.copy_file(pjoin(self.me_dir,line))

            self.value = 'repeat'            

        elif line.strip() != '0' and line.strip() != 'done' and \

            self.open_file(line)

            self.value = 'repeat'

        else:

    def do_decay(self, line):

        """edit the madspin_card to define the decay of the associate particle"""

        signal.alarm(0) # avoid timer if any

        

        if 'madspin_card.dat' not in self.cards or not os.path.exists(path):

            logger.warning("Command decay not valid. Since MadSpin is not available.")

 

    def do_compute_widths(self, line):

        signal.alarm(0) # avoid timer if any

        pattern = re.compile(r'''decay\s+(\+?\-?\d+)\s+auto(@NLO|)''',re.I)

        text = open(path).read()

        pdg_info = pattern.findall(text)

        print '   If you specify some names after the command (i.e. asperge m1 m2) then ASperGe will only'

        print '   diagonalize the associate mass matrices (here m1 and m2).'

 

        signal.alarm(0) # avoid timer if any

 

        blockname = self.pname2block.keys()

        output = {'Mixing matrices': self.list_completion(text, valid, line),

                  'Other potential valid input': self.list_completion(text, potential, line)}

 

 

 

    def do_asperge(self, line):

                return

 

        opts = line.split()

        logger.info('running ASperGE')

        returncode = misc.call([pjoin(path,'ASperGe'), card, '%s.new' % card] + opts)

        if returncode:

            logger.warning('Fail to determine the type of the file. Not copied')

        if card_name != 'banner':

            logger.info('copy %s as %s' % (path, card_name))

        elif card_name == 'banner':

            banner_mod.split_banner(path, self.mother_interface.me_dir, proc_card=False)

            logger.info('Splitting the banner in it\'s component')

 

    def open_file(self, answer):

        """open the file"""

        if answer.isdigit():

            if answer == '9':

                answer = 'plot'

            answer = answer.replace('madweight', 'MadWeight')

        

        if 'MadLoopParams' in answer:

        if not '.dat' in answer and not '.lhco' in answer:

            if answer != 'trigger':

            else:

        elif not '.lhco' in answer:

        else:

            path = pjoin(me_dir, self.mw_card['mw_run']['inputfile'])

            if not os.path.exists(path):

                raise

            

        # reload object to have it in sync

            try:

                self.param_card = check_param_card.ParamCard(path) 

            except (check_param_card.InvalidParamCard, ValueError) as e:

                logger.error('problem detected: %s' % e)

                logger.error('Please re-open the file and fix the problem.')

                logger.warning('using the \'set\' command without opening the file will discard all your manual change')

            try:

                import madgraph.madweight.Cards as mwcards

            except:

                import internal.madweight.Cards as mwcards