~madteam/mg5amcnlo/series2.0

        

        self.allowed_madspin = []

        if 'MadSpin'  in self.available_module:

        return self.allowed_madspin

    

    def check_value_madspin(self, value):

        if value == 'onshell':

            return ["edit madspin_card --replace_line='set spinmode' --before_line='decay' set spinmode onshell"]

        elif value in ['full', 'madspin']:

        elif value == 'none':

            return ["edit madspin_card --replace_line='set spinmode' --before_line='decay' set spinmode none"]

        else:

                raise self.InvalidCmd('No run_name currently define. Unable to run refine')

 

        if len(args) > 2:

            raise self.InvalidCmd('Too many argument for refine command')

        else:

            try:

                          postcmd=False)

            self.exec_cmd('combine_events', postcmd=False)

            self.exec_cmd('store_events', postcmd=False)

            self.exec_cmd('create_gridpack', postcmd=False)

        else:

            # Regular run mode

            

            #we can bypass the following if scan and first result is zero

            if not bypass_run:

            

                self.exec_cmd('combine_events', postcmd=False,printcmd=False)

                self.print_results_in_shell(self.results.current)

                        particle = 0

                # Read BRs for this decay

                line = param_card[line_number]

                    line = param_card.pop(line_number)

                    if not particle or line.startswith('#'):

                        line=param_card[line_number]

        if float(self.run_card['mmjj']) > 0.01 * (float(self.run_card['ebeam1'])+float(self.run_card['ebeam2'])):

            self.pass_in_difficult_integration_mode()

        elif self.run_card['hard_survey']:

            

        jobs, P_zero_result = ajobcreator.launch()

        # Check if all or only some fails

        self.update_status('End survey', 'parton', makehtml=False)

 

    ############################################################################

        """be more secure for the integration to not miss it due to strong cut"""

        

        # improve survey options if default

        if self.opts['points'] == self._survey_options['points'][1]:

        if self.opts['iterations'] == self._survey_options['iterations'][1]:

        if self.opts['accuracy'] == self._survey_options['accuracy'][1]:

        

        # Modify run_config.inc in order to improve the refine

        conf_path = pjoin(self.me_dir, 'Source','run_config.inc')

        files.cp(conf_path, conf_path + '.bk')

        #

        text = open(conf_path).read()

        fsock = open(conf_path, 'w')

        fsock.write(text)

        fsock.close()

        devnull = open(os.devnull, 'w')  

        self.nb_refine += 1

        args = self.split_arg(line)

        # Check argument's validity

        self.check_refine(args)

        

            cross, error = x_improve.update_html() #update html results for survey

            if  cross == 0:

                return

        if isinstance(x_improve, gen_ximprove.gen_ximprove_v4):

            # Non splitted mode is based on writting ajob so need to track them

            # Splitted mode handle the cluster submition internally.

        self.update_status('Creating gridpack', level='parton')

        # compile gen_ximprove

        misc.compile(['../bin/internal/gen_ximprove'], cwd=pjoin(self.me_dir, "Source"))

        args = self.split_arg(line)

        self.check_combine_events(args)

        if not self.run_tag: self.run_tag = 'tag_1'

                            devnull.close()

                            if pid == 0:

                                misc.call('head -n -1 %s | tail -n +%d > %s/tmpfile' %

                                misc.call(['mv', 'tmpfile', os.path.basename(hepmc_file)], cwd=os.path.dirname(hepmc_file))

                            elif sys.platform == 'darwin':

                                # sed on MAC has slightly different synthax than on

 

        eradir = self.options['exrootanalysis_path']

        totar = False

        if input.endswith('.gz'):

            

        try:

            misc.call(['%s/ExRootLHEFConverter' % eradir, 

        if totar:

            if os.path.exists('%s.gz' % input):

                try:

                except:

                    pass

            else:

                misc.gzip(input)

    

    def run_syscalc(self, mode='parton', event_path=None, output=None):

        """create the syscalc output""" 

            os.chdir(self.me_dir)

        else:

            for line in open(pjoin(self.me_dir,'SubProcesses','subproc.mg')):

            

 

    def launch(self, nb_event, seed):

            misc.call([pjoin(self.me_dir,'bin','internal','restore_data'),

                         'default'], cwd=self.me_dir)

 

        # 2) Run the refine for the grid

        self.update_status('Generating Events', level=None)

        #misc.call([pjoin(self.me_dir,'bin','refine4grid'),

                sum_axsec += result.get('axsec')*gscalefact[Gdir]

                

                if len(AllEvent) >= 80: #perform a partial unweighting

                          get_wgt, log_level=5,  trunc_error=1e-2, event_target=self.nb_event)

                    AllEvent = lhe_parser.MultiEventFile()

                    AllEvent.banner = self.banner

                                 sum_xsec,

                                 math.sqrt(sum(x**2 for x in sum_xerru)),

                                 sum_axsec)