Example #1
0
def main():
    try:
        args = docopt(__doc__, version=__version__)
        output_dir = None
        input_dir, output_dir = get_dirs(args)
        filenames = [
            # every tuple below == (filename, is_optional)
            ('alternatives.xml', False),
            ('classes_profiles.xml', True),
            ('credibility.xml', False),
            ('method_parameters.xml', False),
        ]
        params = [
            'alternatives',
            'categories_profiles',
            'comparison_with',
            'credibility',
            'cut_threshold',
        ]
        d = get_input_data(input_dir, filenames, params)

        # getting the elements to compare
        comparables_a = d.alternatives
        if d.comparison_with in ('boundary_profiles', 'central_profiles'):
            comparables_b = d.categories_profiles
        else:
            comparables_b = d.alternatives

        outranking = get_outranking(comparables_a, comparables_b,
                                    d.credibility, d.cut_threshold)

        # serialization etc.
        if d.comparison_with in ('boundary_profiles', 'central_profiles'):
            mcda_concept = 'alternativesProfilesComparisons'
        else:
            mcda_concept = None
        comparables = (comparables_a, comparables_b)
        xmcda = outranking_to_xmcda(outranking, mcda_concept=mcda_concept)
        write_xmcda(xmcda, os.path.join(output_dir, 'outranking.xml'))
        create_messages_file(None, ('Everything OK.',), output_dir)
        return 0
    except Exception, err:
        err_msg = get_error_message(err)
        log_msg = traceback.format_exc()
        print(log_msg.strip())
        create_messages_file((err_msg, ), (log_msg, ), output_dir)
        return 1
def main():
    try:
        args = docopt(__doc__, version=__version__)
        output_dir = None
        input_dir, output_dir = get_dirs(args)
        
        filenames = [
            ('alternatives.xml', False),
            ('downwards.xml', False),
            ('upwards.xml', False),
        ]
        params = [
            'alternatives',
            'downwards',
            'upwards',
        ]
        
        d = get_input_data(input_dir, filenames, params)
    
        alternativesId = d.alternatives
        downwards = d.downwards
        upwards = d.upwards

        alg = algorithm(alternativesId, downwards, upwards)
        result = alg.Run()
        
        comparables = (alternativesId, alternativesId)
        #xmcda = comparisons_to_xmcda(result[0], comparables)
        xmcda = outranking_to_xmcda(result[0])
        write_xmcda(xmcda, os.path.join(output_dir, 'intersection.xml'))
        xmcda = ranks_to_xmcda(result[1], 'integer', None)
        write_xmcda(xmcda, os.path.join(output_dir, 'rank.xml'))
        xmcda = ranks_to_xmcda(result[2], 'integer', None)
        write_xmcda(xmcda, os.path.join(output_dir, 'median.xml'))
        
        create_messages_file(None, ('Everything OK.',), output_dir)    
        return 0
    
    except Exception, err:
        err_msg = get_error_message(err)
        log_msg = traceback.format_exc()
        print(log_msg.strip())
        create_messages_file((err_msg, ), (log_msg, ), output_dir)
        return 1            
def main():
    try:
        args = docopt(__doc__, version=__version__)
        output_dir = None
        input_dir, output_dir = get_dirs(args)
        
        filenames = [
            ('method_parameters.xml', False)
        ]
        params = [
            'comparison_with'
        ]
        
        d = get_input_data(input_dir, filenames, params)
        comparison_with = d.comparison_with
        
        profilesId = None
        
        if  comparison_with == "profiles":
            filenames = [
                ('alternatives.xml', False),
                ('profiles.xml', False),
                ('concordance.xml', False),
                ('discordance.xml', False),
            ]
            params = [
                'alternatives',
                'profiles',
                'crisp_concordance',
                'crisp_discordance',
            ]
            kwargs = {'use_partials': False, 'comparison_with': comparison_with}        
            d = get_input_data(input_dir, filenames, params, **kwargs)
                
            profilesId = d.profiles
            alternativesId = d.alternatives
            concordance = d.concordance
            discordance = d.discordance
        else:
            filenames = [
                ('alternatives.xml', False),
                ('concordance.xml', False),
                ('discordance.xml', False),
            ]
            params = [
                'alternatives',
                'crisp_concordance',
                'crisp_discordance',
            ] 
            kwargs = {'use_partials': False}              
            d = get_input_data(input_dir, filenames, params, **kwargs)
            
            alternativesId = d.alternatives
            concordance = d.concordance
            discordance = d.discordance
        
        alg = algorithm(alternativesId, profilesId, concordance, discordance)
        result = alg.Run()
        
        if profilesId == None:
            comparables = (alternativesId, alternativesId)
            xmcda =  outranking_to_xmcda(result)
            write_xmcda(xmcda, os.path.join(output_dir, 'outranking.xml'))
            create_messages_file(None, ('Everything OK.',), output_dir)
        else:
            comparables = (alternativesId, profilesId)
            xmcda =  outranking_to_xmcda(result)
            write_xmcda(xmcda, os.path.join(output_dir, 'outranking.xml'))
            create_messages_file(None, ('Everything OK.',), output_dir)
 
        return 0
    
    except Exception, err:
        err_msg = get_error_message(err)
        log_msg = traceback.format_exc()
        print(log_msg.strip())
        create_messages_file((err_msg, ), (log_msg, ), output_dir)
        return 1