~maddevelopers/mg5amcnlo/aMCatNLO

        

        self.history = banner_module.ProcCard()

    _v4_export_formats = ['madevent', 'standalone', 'standalone_ms', 'matrix'] 

        self.history.clean(remove_bef_last='import')

        self._v4_export_formats = ['madevent', 'standalone','standalone_ms', 'matrix'] 

        old_levels = [logger.level for logger in loggers]

        #                       'is_decay_chain': decay_process\

 

    @staticmethod

    def split_process_line(procline):

        """Takes a valid process and return

           a tuple (core_process, options). This removes 

             - any NLO specifications.

             - any options

           [Used by MadSpin]

        """

         

        # remove the tag "[*]": this tag is used in aMC@LNO , 

        # but it is not a valid syntax for LO

        line=procline

        pos1=line.find("[")

        if pos1>0:

            pos2=line.find("]")

            if pos2 >pos1:

                line=line[:pos1]+line[pos2+1:]

        #

        # Extract the options:

        #

        # A. Remove process number (identified by "@")

        proc_number_pattern = re.compile("^(.+)@\s*(\d+)\s*(.*)$")

        proc_number_re = proc_number_pattern.match(line)

        if proc_number_re:

            line = proc_number_re.group(1) + proc_number_re.group(3)

 

        # B. search for the beginning of the option string

        pos=1000

        # start with order

        order_pattern = re.compile("^(.+)\s+(\w+)\s*=\s*(\d+)\s*$")

        order_re = order_pattern.match(line)

        if (order_re):

            pos_order=line.find(order_re.group(2))

            if pos_order>0 and pos_order < pos : pos=pos_order

 

        # then look for slash or dollar

        slash = line.find("/")

        if slash > 0 and slash < pos: pos=slash

        dollar = line.find("$")

        if dollar > 0 and dollar < pos: pos=dollar

 

        if pos<1000:

            proc_option=line[pos:]

            line=line[:pos]

        else:

            proc_option=""

 

        return line, proc_option

 

    def get_final_part(self, procline):

        """Takes a valid process and return

           a set of id of final states particles. [Used by MadSpin]

        """

                

        if self._use_lower_part_names:

            procline = procline.lower()

        pids = self._curr_model.get('name2pdg')

            

        # method.

        # 1) look for decay.

        #     in presence of decay call this routine recursively and veto 

        #     the particles which are decayed

        

        # Deal with decay chain

        if ',' in procline:

            core, decay = procline.split(',', 1)

            core_final = self.get_final_part(core)

            

            #split the decay 

            all_decays = decay.split(',')

            nb_level,  tmp_decay = 0, ''

            decays = []

            # deal with ()

            for one_decay in all_decays:

                if '(' in one_decay:

                    nb_level += 1

                if ')' in one_decay:

                    nb_level -= 1

                    

                if nb_level:

                    if tmp_decay:

                        tmp_decay += ', %s' % one_decay

                    else: 

                        tmp_decay = one_decay

                elif tmp_decay:

                    final = '%s,%s' % (tmp_decay, one_decay)

                    final = final.strip()

                    assert final[0] == '(' and final[-1] == ')'

                    final = final[1:-1]

                    decays.append(final)

                    tmp_decay = ''

                else:

                    decays.append(one_decay)

            # remove from the final states all particles which are decayed

            for one_decay in decays:

                first = one_decay.split('>',1)[0].strip()

                if first in pids:

                    pid = set([pids[first]])

                elif first in self._multiparticles:

                    pid = set(self._multiparticles[first])

                else:

                    raise Exception, 'invalid particle name: %s. ' % first

                core_final.difference_update(pid)

                core_final.update(self.get_final_part(one_decay))

                

            return core_final

                

        # NO DECAY CHAIN

        final = set()

        final_states = re.search(r'> ([^\/\$\=\@>]*)(\s\S+\=|\$|\/|\@|$)', procline)

        particles = final_states.groups()[0]

        for particle in particles.split():

            if particle in pids:

                final.add(pids[particle])

            elif particle in self._multiparticles:

                final.update(set(self._multiparticles[particle]))

        return final

            

            

            

        

        

        

        

        

 

        

        

        if args[0] == 'MCatNLO-utilities':

            logger.warning('For internal testings, please use the MCatNLO-utilities provided in this distribution. Remember to update them when releasing beta2.MZ')

            return

        if self._export_format in ['madevent', 'standalone','standalone_ms', 'matrix']:

        if self._export_format in ['madevent', 'standalone', 'standalone_ms']:

        if self._export_format in ['standalone_cpp', 'madevent', 'standalone', 'standalone_ms']:

                    misc.sprint('command history fails.', 10)

        if self._export_format in ['standalone', 'standalone_ms']:

        if self._export_format in ['madevent', 'standalone', 'standalone_ms', 'NLO']:

        if self._export_format in ['madevent', 'standalone', 'standalone_ms']: