runPKP

#!/usr/bin/env python
"""Script to run PKP session."""

from __future__ import division, absolute_import
from __future__ import print_function, unicode_literals
from builtins import dict

import logging
import argparse
import shutil
import sys
import numpy as np

import pkp.runner
from termcolor import colored
from pkp._exceptions import *

# logging.basicConfig(format='')

ascii_pkp = """
.______    __  ___ .______
|   _  \  |  |/  / |   _  \  
|  |_)  | |  '  /  |  |_)  |
|   ___/  |    <   |   ___/
|  |      |  .  \  |  |
| _|      |__|\__\ | _|
\n
"""


def parse_args():
    """
    Define arguments of the script
    """
    parser = argparse.ArgumentParser(
        description="PKP Runner"
    )
    parser.add_argument('yml_file', action="store",
                        help="YAML input file")
    parser.add_argument('-n', action="store", dest="np", type=int,
                        default=1,
                        help="Number of processor")
    parser.add_argument('-o', action="store", dest="results_dir",
                        type=str,
                        default="Results", help="Results directory")
    parser.add_argument('-d', action="store_true", dest="debug",
                        help="Print debug messages")
    parser.add_argument('--run-only', action="store_true",
                        dest="run_only",
                        help=("Run only detailed models"
                              " without calibration"))
    return parser.parse_args()


def create_main_logger():
    """
    Create the main logger for runPKP
    """
    logger = logging.getLogger('runPKP')
    logger.setLevel(logging.WARNING)
    logger.addHandler(logging.StreamHandler(stream=sys.stdout))
    return logger


def catch_error(logger, msg):
    logger.critical(
        colored(msg, 'red'))
    sys.exit(1)


def create_pkp_logger(argument):
    """
    Define the logger for the pkp module
    """
    # define a logger for pkp module
    # define a stream handler for runPKP logger
    handler = logging.StreamHandler(stream=sys.stdout)
    handler.setFormatter(logging.Formatter(
        '%(name)s:%(funcName)s:%(message)s'))
    handler.setLevel(logging.INFO)
    #
    log_pkp = logging.getLogger('pkp.runner')
    log_pkp.setLevel(logging.DEBUG)
    log_pkp.addHandler(handler)

    if argument.debug:
        formatter = logging.Formatter(
            "%(levelname)s:%(name)s:%(funcName)s:%(message)s")
        file_handler = logging.FileHandler('runpkp.log', 'w')
        file_handler.setLevel(logging.DEBUG)
        file_handler.setFormatter(formatter)
        log_pkp.addHandler(file_handler)
        log_pkp.setLevel(logging.DEBUG)

        log_cpd = logging.getLogger('pkp.cpd')
        file_handler_cpd = logging.FileHandler('cpd.log', 'w')
        file_handler_cpd.setLevel(logging.INFO)
        file_handler_cpd.setFormatter(formatter)
        log_cpd.addHandler(file_handler_cpd)
        log_cpd.setLevel(logging.INFO)

        # np.seterr(all='warning')
    else:
        np.seterr(all='ignore')
        log_pkp.setLevel(logging.INFO)

    # force evolution to INFO
    logging.getLogger('pkp.evolution').setLevel(logging.INFO)


if __name__ == '__main__':
    argument = parse_args()
    run_only = argument.run_only

    # set loggers
    logger = create_main_logger()
    create_pkp_logger(argument)

    # Execute Runner
    logger.warning('-----------------------------------------')
    logger.warning(ascii_pkp)
    logger.warning('-----------------------------------------')
    logger.warning('    Pyrolysis Kinetic Preprocessor (PKP) ')
    logger.warning('-----------------------------------------')
    logger.warning('(c) Numerical Thermo Fluid-Dynamics      ')
    logger.warning('    TU Bergakademie Freiberg             ')
    logger.warning('    Michele Vascellari                   ')
    logger.warning('    Michele.Vascellari@vtc.tu-freiberg.de')
    logger.warning('-----------------------------------------')
    logger.warning('Run PKP version %s', pkp.__version__)
    logger.warning('-----------------------------------------')
    logger.info('Create runner and read settings')
    try:
        runner = pkp.runner.PKPRunner(argument.yml_file)
    except PKPCompositionError as e:
        catch_error(logger, '{}'.format(e))
    except PKPConvertNumber as e:
        catch_error(logger, '{}'.format(e))
    except KeyError as e:
        catch_error(logger, 'Key {} missing in the input file'.format(e))
    logger.info('Start run')
    try:
        results = runner.run(results_dir=argument.results_dir,
                             n_p=argument.np, run_only=run_only)
    except (PKPModelError, PKPKeyError) as e:
        catch_error(logger, e.args[0])
    except PKPParametersError as e:
        catch_error(logger, e.args[0])

    logger.info('End running')
    shutil.copy(argument.yml_file, argument.results_dir)