Chimie Théorique » scripts_chimie4psmn » DockOnSurf

"""Functions to deal with DockOnSurf input files.

Functions

try_command:Tries to run a command and logs its exceptions (expected and not).

str2lst: Converts a string of integers, and groups of them, to a list of lists.

check_expect_val: Checks whether the value of an option has an adequate value.

read_input: Sets up the calculation by reading the parameters from input file.

get_run_type: Gets 'run_type' value and checks that its value is acceptable.

get_code: Gets 'code' value and checks that its value is acceptable.

get_batch_q_sys: Gets 'batch_q_sys' value and checks that its value is

acceptable.

get_relaunch_err: Gets 'relaunch_err' value and checks that its value is

acceptable.

get_max_jobs: Gets 'max_jobs' value and checks that its value is acceptable.

get_special_atoms: Gets 'special_atoms' value and checks that its value is

acceptable.

get_isol_inp_file: Gets 'isol_inp_file' value and checks that its value is

acceptable.

get_cluster_magns: Gets 'cluster_magns' value and checks that its value is

acceptable.

get_num_conformers: Gets 'num_conformers' value and checks that its value is

acceptable.

get_num_prom_cand: Gets 'num_prom_cand' value and checks that its value is

acceptable.

get_iso_rmsd: Gets 'iso_rmsd' value and checks that its value is acceptable.

get_pre_opt: Gets 'pre_opt' value and checks that its value is acceptable.

get_screen_inp_file: Gets 'screen_inp_file' value and checks that its value is

acceptable.

get_sites: Gets 'sites' value and checks that its value is acceptable.

get_molec_ctrs: Gets 'molec_ctrs' value and checks that its value is

acceptable.

get_try_disso: Gets 'try_disso' value and checks that its value is acceptable.

get_pts_per_angle: Gets 'pts_per_angle' value and checks that its value is

acceptable.

get_coll_thrsld: Gets 'coll_thrsld' value and checks that its value is

acceptable.

get_screen_rmsd: Gets 'screen_rmsd' value and checks that its value is

acceptable.

get_coll_bottom_z: Gets 'coll_bottom_z' value and checks that its value is

acceptable.

get_refine_inp_file: Gets 'refine_inp_file' value and checks that its value is

acceptable.

get_energy_cutoff: Gets 'energy_cutoff' value and checks that its value is

acceptable.

"""

import os.path

import logging

from configparser import ConfigParser, NoSectionError, NoOptionError, \

    MissingSectionHeaderError, DuplicateOptionError

import numpy as np

from modules.utilities import try_command

logger = logging.getLogger('DockOnSurf')

dos_inp = ConfigParser(inline_comment_prefixes='#',

                       empty_lines_in_values=False)

new_answers = {'n': False, 'none': False, 'nay': False,

               'y': True, 'sí': True, 'aye': True, 'sure': True}

for answer, val in new_answers.items():

    dos_inp.BOOLEAN_STATES[answer] = val

turn_false_answers = [answer for answer in dos_inp.BOOLEAN_STATES

                      if dos_inp.BOOLEAN_STATES[answer] is False]

no_sect_err = "Section '%s' not found on input file"

no_opt_err = "Option '%s' not found on section '%s'"

num_error = "'%s' value must be a %s"

def str2lst(cmplx_str, func=int):  # TODO: enable deeper level of nested lists

    # TODO Treat all-enclosing parenthesis as a list instead of list of lists.

    """Converts a string of integers, and groups of them, to a list.

    Keyword arguments:

    @param cmplx_str: str, string of integers (or floats) and groups of them

    enclosed by parentheses-like characters.

    - Group enclosers: '()' '[]' and '{}'.

    - Separators: ',' ';' and ' '.

    - Nested groups are not allowed: '3 ((6 7) 8) 4'.

    @param func: either to use int or float

    @return list, list of integers (or floats), or list of integers (or floats)

    in the case they were grouped. First, the singlets are placed, and then the

    groups in input order.

    eg. '128,(135 138;141] 87 {45, 68}' -> [128, 87, [135, 138, 141], [45, 68]]

    """

    # Checks

    error_msg = "Function argument should be a str, sequence of " \

                "numbers separated by ',' ';' or ' '." \

                "\nThey can be grouped in parentheses-like enclosers: '()', " \

                "'[]' or {}. Nested groups are not allowed. \n" \

                "eg. 128,(135 138;141) 87 {45, 68}"

    cmplx_str = try_command(cmplx_str.replace, [(AttributeError, error_msg)],

                            ',', ' ')

    cmplx_str = cmplx_str.replace(';', ' ').replace('[', '(').replace(

        ']', ')').replace('{', '(').replace('}', ')')

    try_command(list, [(ValueError, error_msg)], map(func, cmplx_str.replace(

        ')', '').replace('(', '').split()))

    deepness = 0

    for el in cmplx_str.split():

        if '(' in el:

            deepness += 1

        if ')' in el:

            deepness += -1

        if deepness > 1 or deepness < 0:

            logger.error(error_msg)

            raise ValueError(error_msg)

    init_list = cmplx_str.split()

    start_group = []

    end_group = []

    for i, element in enumerate(init_list):

        if '(' in element:

            start_group.append(i)

            init_list[i] = element.replace('(', '')

        if ')' in element:

            end_group.append(i)

            init_list[i] = element.replace(')', '')

    init_list = list(map(func, init_list))

    new_list = []

    for start_el, end_el in zip(start_group, end_group):

        new_list.append(init_list[start_el:end_el + 1])

    for v in new_list:

        for el in v:

            init_list.remove(el)

    return init_list + new_list

def check_expect_val(value, expect_vals, err_msg=None):

    """Checks whether an option lies within its expected values.

    Keyword arguments:

    @param value: The variable to check if its value lies within the expected

    ones

    @param expect_vals: list, list of values allowed for the present option.

    @param err_msg: The error message to be prompted in both log and screen.

    @raise ValueError: if the value is not among the expected ones.

    @return True if the value is among the expected ones.

    """

    if err_msg is None:

        err_msg = f"'{value}' is not an adequate value.\n" \

                  f"Adequate values: {expect_vals}"

    if not any([exp_val == value for exp_val in expect_vals]):

        logger.error(err_msg)

        raise ValueError(err_msg)

    return True

def check_inp_file(inp_file, code):

    if code == 'cp2k':

        from pycp2k import CP2K

        cp2k = CP2K()

        try_command(cp2k.parse,

                    [(UnboundLocalError, "Invalid CP2K input file")], inp_file)

# Global

def get_run_type():

    isolated, screening, refinement = (False, False, False)

    run_type_vals = ['isolated', 'screening', 'refinement', 'adsorption',

                     'full']

    run_types = dos_inp.get('Global', 'run_type').split()

    for run_type in run_types:

        check_expect_val(run_type.lower(), run_type_vals)

        if 'isol' in run_type.lower():

            isolated = True

        if 'screen' in run_type.lower():

            screening = True

        if 'refine' in run_type.lower():

            refinement = True

        if 'adsor' in run_type.lower():

            screening, refinement = (True, True)

        if 'full' in run_type.lower():

            isolated, screening, refinement = (True, True, True)

    return isolated, screening, refinement

def get_code():

    code_vals = ['cp2k']

    check_expect_val(dos_inp.get('Global', 'code').lower(), code_vals)

    code = dos_inp.get('Global', 'code').lower()

    return code

def get_batch_q_sys():

    batch_q_sys_vals = ['sge', 'lsf', 'irene', 'local'] + turn_false_answers

    check_expect_val(dos_inp.get('Global', 'batch_q_sys').lower(),

                     batch_q_sys_vals)

    batch_q_sys = dos_inp.get('Global', 'batch_q_sys').lower()

    if batch_q_sys.lower() in turn_false_answers:

        return False

    else:

        return batch_q_sys

def get_subm_script():

    subm_script = dos_inp.get('Global', 'subm_script', fallback=False)

    if subm_script and not os.path.isfile(subm_script):

        logger.error(f'File {subm_script} not found.')

        raise FileNotFoundError(f'File {subm_script} not found')

    return subm_script

def get_project_name():

    project_name = dos_inp.get('Global', 'project_name', fallback='')

    return project_name

def get_relaunch_err():

    relaunch_err_vals = ['geo_not_conv']

    relaunch_err = dos_inp.get('Global', 'relaunch_err',

                               fallback="False")

    if relaunch_err.lower() in turn_false_answers:

        return False

    else:

        check_expect_val(relaunch_err.lower(), relaunch_err_vals)

    return relaunch_err

def get_max_jobs():

    import re

    err_msg = "'max_jobs' must be a list of, number plus 'p', 'q' or 'r', or " \

              "a combination of them without repeating letters.\n" \

              "eg: '2r 3p 4pr', '5q' or '3r 3p'"

    max_jobs_str = dos_inp.get('Global', 'max_jobs', fallback="inf").lower()

    str_vals = ["r", "p", "q", "rp", "rq", "pr", "qr"]

    max_jobs = {"r": np.inf, "p": np.inf, "rp": np.inf}

    if "inf" == max_jobs_str:

        return {"r": np.inf, "p": np.inf, "rp": np.inf}

    # Iterate over the number of requirements:

    for req in max_jobs_str.split():

        # Split numbers from letters into a list

        req_parts = re.findall(r'[a-z]+|\d+', req)

        if len(req_parts) != 2:

            logger.error(err_msg)

            raise ValueError(err_msg)

        if req_parts[0].isdecimal():

            req_parts[1] = req_parts[1].replace('q', 'p').replace('pr', 'rp')

            if req_parts[1] in str_vals and max_jobs[req_parts[1]] == np.inf:

                max_jobs[req_parts[1]] = int(req_parts[0])

        elif req_parts[1].isdecimal():

            req_parts[0] = req_parts[0].replace('q', 'p').replace('pr', 'rp')

            if req_parts[0] in str_vals and max_jobs[req_parts[0]] == np.inf:

                max_jobs[req_parts[0]] = int(req_parts[1])

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return max_jobs

def get_special_atoms():

    from ase.data import chemical_symbols

    spec_at_err = '\'special_atoms\' does not have an adequate format.\n' \

                  'Adequate format: (Fe1 Fe) (O1 O)'

    special_atoms = dos_inp.get('Global', 'special_atoms', fallback="False")

    if special_atoms.lower() in turn_false_answers:

        special_atoms = []

    else:

        # Converts the string into a list of tuples

        lst_tple = [tuple(pair.replace("(", "").split()) for pair in

                    special_atoms.split(")")[:-1]]

        if len(lst_tple) == 0:

            logger.error(spec_at_err)

            raise ValueError(spec_at_err)

        for i, tup in enumerate(lst_tple):

            if not isinstance(tup, tuple) or len(tup) != 2:

                logger.error(spec_at_err)

                raise ValueError(spec_at_err)

            if tup[1].capitalize() not in chemical_symbols:

                elem_err = "The second element of the couple should be an " \

                           "actual element of the periodic table"

                logger.error(elem_err)

                raise ValueError(elem_err)

            if tup[0].capitalize() in chemical_symbols:

                elem_err = "The first element of the couple is already an " \

                           "actual element of the periodic table, "

                logger.error(elem_err)

                raise ValueError(elem_err)

            for j, tup2 in enumerate(lst_tple):

                if j <= i:

                    continue

                if tup2[0] == tup[0]:

                    label_err = f'You have specified the label {tup[0]} to ' \

                                f'more than one special atom'

                    logger.error(label_err)

                    raise ValueError(label_err)

        special_atoms = lst_tple

    return special_atoms

# Isolated

def get_isol_inp_file():

    isol_inp_file = dos_inp.get('Isolated', 'isol_inp_file')

    if not os.path.isfile(isol_inp_file):

        logger.error(f'File {isol_inp_file} not found.')

        raise FileNotFoundError(f'File {isol_inp_file} not found')

    return isol_inp_file

def get_molec_file():

    molec_file = dos_inp.get('Isolated', 'molec_file')

    if not os.path.isfile(molec_file):

        logger.error(f'File {molec_file} not found.')

        raise FileNotFoundError(f'File {molec_file} not found')

    return molec_file

def get_num_conformers():

    err_msg = num_error % ('num_conformers', 'positive integer')

    num_conformers = try_command(dos_inp.getint, [(ValueError, err_msg)],

                                 'Isolated', 'num_conformers', fallback=100)

    if num_conformers < 1:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return num_conformers

def get_pre_opt():

    pre_opt_vals = ['uff', 'mmff'] + turn_false_answers

    check_expect_val(dos_inp.get('Isolated', 'pre_opt').lower(), pre_opt_vals)

    pre_opt = dos_inp.get('Isolated', 'pre_opt').lower()

    if pre_opt in turn_false_answers:

        return False

    else:

        return pre_opt

# Screening

def get_screen_inp_file():

    screen_inp_file = dos_inp.get('Screening', 'screen_inp_file')

    if not os.path.isfile(screen_inp_file):

        logger.error(f'File {screen_inp_file} not found.')

        raise FileNotFoundError(f'File {screen_inp_file} not found')

    return screen_inp_file

def get_surf_file():

    surf_file = dos_inp.get('Screening', 'surf_file')

    if not os.path.isfile(surf_file):

        logger.error(f'File {surf_file} not found.')

        raise FileNotFoundError(f'File {surf_file} not found')

    return surf_file

def get_sites():

    err_msg = 'The value of sites should be a list of atom numbers ' \

              '(ie. positive integers) or groups of atom numbers ' \

              'grouped by parentheses-like enclosers. \n' \

              'eg. 128,(135 138;141) 87 {45, 68}'

    # Convert the string into a list of lists

    sites = try_command(str2lst,

                        [(ValueError, err_msg), (AttributeError, err_msg)],

                        dos_inp.get('Screening', 'sites'))

    # Check all elements of the list (of lists) are positive integers

    for site in sites:

        if type(site) is list:

            for atom in site:

                if atom < 0:

                    logger.error(err_msg)

                    raise ValueError(err_msg)

        elif type(site) is int:

            if site < 0:

                logger.error(err_msg)

                raise ValueError(err_msg)

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return sites

def get_surf_ctrs2():

    err_msg = 'The value of surf_ctrs2 should be a list of atom numbers ' \

              '(ie. positive integers) or groups of atom numbers ' \

              'grouped by parentheses-like enclosers. \n' \

              'eg. 128,(135 138;141) 87 {45, 68}'

    # Convert the string into a list of lists

    surf_ctrs2 = try_command(str2lst,

                             [(ValueError, err_msg), (AttributeError, err_msg)],

                             dos_inp.get('Screening', 'surf_ctrs2'))

    # Check all elements of the list (of lists) are positive integers

    for ctr in surf_ctrs2:

        if type(ctr) is list:

            for atom in ctr:

                if atom < 0:

                    logger.error(err_msg)

                    raise ValueError(err_msg)

        elif type(ctr) is int:

            if ctr < 0:

                logger.error(err_msg)

                raise ValueError(err_msg)

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return surf_ctrs2

def get_molec_ctrs():

    err_msg = 'The value of molec_ctrs should be a list of atom' \

              ' numbers (ie. positive integers) or groups of atom ' \

              'numbers enclosed by parentheses-like characters. \n' \

              'eg. 128,(135 138;141) 87 {45, 68}'

    # Convert the string into a list of lists

    molec_ctrs = try_command(str2lst,

                             [(ValueError, err_msg),

                              (AttributeError, err_msg)],

                             dos_inp.get('Screening', 'molec_ctrs'))

    # Check all elements of the list (of lists) are positive integers

    for ctr in molec_ctrs:

        if isinstance(ctr, list):

            for atom in ctr:

                if atom < 0:

                    logger.error(err_msg)

                    raise ValueError(err_msg)

        elif isinstance(ctr, int):

            if ctr < 0:

                logger.error(err_msg)

                raise ValueError(err_msg)

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return molec_ctrs

def get_molec_ctrs2():

    err_msg = 'The value of molec_ctrs2 should be a list of atom ' \

              'numbers (ie. positive integers) or groups of atom ' \

              'numbers enclosed by parentheses-like characters. \n' \

              'eg. 128,(135 138;141) 87 {45, 68}'

    # Convert the string into a list of lists

    molec_ctrs2 = try_command(str2lst, [(ValueError, err_msg),

                                        (AttributeError, err_msg)],

                              dos_inp.get('Screening', 'molec_ctrs2'))

    # Check all elements of the list (of lists) are positive integers

    for ctr in molec_ctrs2:

        if isinstance(ctr, list):

            for atom in ctr:

                if atom < 0:

                    logger.error(err_msg)

                    raise ValueError(err_msg)

        elif isinstance(ctr, int):

            if ctr < 0:

                logger.error(err_msg)

                raise ValueError(err_msg)

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return molec_ctrs2

def get_molec_ctrs3():

    err_msg = 'The value of molec_ctrs3 should be a list of atom ' \

              'numbers (ie. positive integers) or groups of atom ' \

              'numbers enclosed by parentheses-like characters. \n' \

              'eg. 128,(135 138;141) 87 {45, 68}'

    # Convert the string into a list of lists

    molec_ctrs3 = try_command(str2lst, [(ValueError, err_msg),

                                        (AttributeError, err_msg)],

                              dos_inp.get('Screening', 'molec_ctrs3'))

    # Check all elements of the list (of lists) are positive integers

    for ctr in molec_ctrs3:

        if isinstance(ctr, list):

            for atom in ctr:

                if atom < 0:

                    logger.error(err_msg)

                    raise ValueError(err_msg)

        elif isinstance(ctr, int):

            if ctr < 0:

                logger.error(err_msg)

                raise ValueError(err_msg)

        else:

            logger.error(err_msg)

            raise ValueError(err_msg)

    return molec_ctrs3

def get_max_helic_angle():

    err_msg = "'max_helic_angle' must be a positive number in degrees"

    max_helic_angle = try_command(dos_inp.getfloat, [(ValueError, err_msg)],

                                  'Screening', 'max_helic_angle',

                                  fallback=180.0)

    if max_helic_angle < 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return max_helic_angle

def get_select_magns():

    select_magns_vals = ['energy', 'moi']

    select_magns_str = dos_inp.get('Screening', 'select_magns',

                                   fallback='energy')

    select_magns_str.replace(',', ' ').replace(';', ' ')

    select_magns = select_magns_str.split(' ')

    select_magns = [m.lower() for m in select_magns]

    for m in select_magns:

        check_expect_val(m, select_magns_vals)

    return select_magns

def get_confs_per_magn():

    err_msg = num_error % ('confs_per_magn', 'positive integer')

    confs_per_magn = try_command(dos_inp.getint, [(ValueError, err_msg)],

                                 'Screening', 'confs_per_magn', fallback=2)

    if confs_per_magn <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return confs_per_magn

def get_pbc_cell():

    err = "'pbc_cell' must be either 3 vectors of size 3 or False"

    pbc_cell_str = dos_inp.get('Screening', 'pbc_cell', fallback="False")

    if pbc_cell_str.lower() in turn_false_answers:

        return False

    else:

        pbc_cell = np.array(try_command(str2lst, [(ValueError, err)],

                                        pbc_cell_str, float))

        if pbc_cell.shape != (3, 3):

            logger.error(err)

            raise ValueError(err)

        return pbc_cell

def get_surf_norm_vect():

    err = "'surf_norm_vect' must be a 3 component vector, 'x', 'y' or 'z', " \

          "'auto' or 'asann'."

    cart_axes = {'x': [1.0, 0.0, 0.0], '-x': [-1.0, 0.0, 0.0],

                 'y': [0.0, 1.0, 0.0], '-y': [0.0, -1.0, 0.0],

                 'z': [0.0, 0.0, 1.0], '-z': [0.0, 0.0, -1.0]}

    surf_norm_vect_str = dos_inp.get('Screening', 'surf_norm_vect',

                                     fallback="auto").lower()

    if surf_norm_vect_str == "asann" or surf_norm_vect_str == "auto":

        return 'auto'

    if surf_norm_vect_str in cart_axes:

        return np.array(cart_axes[surf_norm_vect_str])

    surf_norm_vect = try_command(str2lst, [(ValueError, err)],

                                 surf_norm_vect_str, float)

    if len(surf_norm_vect) != 3:

        logger.error(err)

        raise ValueError(err)

    return np.array(surf_norm_vect) / np.linalg.norm(surf_norm_vect)

def get_set_angles():

    set_vals = ['euler', 'chemcat']

    check_expect_val(dos_inp.get('Screening', 'set_angles').lower(), set_vals)

    set_angles = dos_inp.get('Screening', 'set_angles',

                             fallback='euler').lower()

    return set_angles

def get_pts_per_angle():

    err_msg = num_error % ('sample_points_per_angle', 'positive integer')

    pts_per_angle = try_command(dos_inp.getint,

                                [(ValueError, err_msg)],

                                'Screening', 'sample_points_per_angle',

                                fallback=3)

    if pts_per_angle <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return pts_per_angle

def get_max_structures():

    err_msg = num_error % ('max_structures', 'positive integer')

    max_structs = dos_inp.get('Screening', 'max_structures', fallback="False")

    if max_structs.lower() in turn_false_answers:

        return np.inf

    if try_command(int, [(ValueError, err_msg)], max_structs) <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return int(max_structs)

def get_coll_thrsld():

    err_msg = num_error % ('collision_threshold',

                           'positive number')

    coll_thrsld_str = dos_inp.get('Screening', 'collision_threshold',

                                  fallback="1.3")

    if coll_thrsld_str.lower() in turn_false_answers:

        return False

    coll_thrsld = try_command(float, [(ValueError, err_msg)], coll_thrsld_str)

    if coll_thrsld <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return coll_thrsld

def get_min_coll_height(norm_vect):

    err_msg = num_error % ('min_coll_height', 'decimal number')

    min_coll_height = dos_inp.get('Screening', 'min_coll_height',

                                  fallback="False")

    if min_coll_height.lower() in turn_false_answers:

        return False

    min_coll_height = try_command(float, [(ValueError, err_msg)],

                                  min_coll_height)

    cart_axes = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0],

                 [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]]

    err_msg = "'min_coll_height' option is only implemented for " \

              "'surf_norm_vect' to be one of the x, y or z axes. "

    if not isinstance(norm_vect, str) or norm_vect != 'auto':

        check_expect_val(norm_vect.tolist(), cart_axes, err_msg)

    return min_coll_height

def get_H_donor(spec_atoms):

    from ase.data import chemical_symbols

    err_msg = "The value of 'h_donor' must be either False, a chemical symbol " \

              "or an atom index"

    h_donor_str = dos_inp.get('Screening', 'h_donor', fallback="False")

    h_donor = []

    if h_donor_str.lower() in turn_false_answers:

        return False

    err = False

    for el in h_donor_str.split():

        try:

            h_donor.append(int(el))

        except ValueError:

            if el not in chemical_symbols + [nw_sym for pairs in spec_atoms

                                             for nw_sym in pairs]:

                err = True

            else:

                h_donor.append(el)

        finally:

            if err:

                logger.error(err_msg)

                ValueError(err_msg)

    return h_donor

def get_H_acceptor(spec_atoms):

    from ase.data import chemical_symbols

    err_msg = "The value of 'h_acceptor' must be either 'all', a chemical " \

              "symbol or an atom index"

    h_acceptor_str = dos_inp.get('Screening', 'h_acceptor', fallback="all")

    if h_acceptor_str.lower() == "all":

        return "all"

    h_acceptor = []

    err = False

    for el in h_acceptor_str.split():

        try:

            h_acceptor.append(int(el))

        except ValueError:

            if el not in chemical_symbols + [nw_sym for pairs in spec_atoms

                                             for nw_sym in pairs]:

                err = True

            else:

                h_acceptor.append(el)

        finally:

            if err:

                logger.error(err_msg)

                ValueError(err_msg)

    return h_acceptor

# Refinement

def get_refine_inp_file():  # TODO if not specified try isol_inp_file.

    refine_inp_file = dos_inp.get('Refinement', 'refine_inp_file')

    if not os.path.isfile(refine_inp_file):

        logger.error(f'File {refine_inp_file} not found.')

        raise FileNotFoundError(f'File {refine_inp_file} not found')

    return refine_inp_file

def get_energy_cutoff():

    err_msg = num_error % ('energy_cutoff', 'positive decimal number')

    energy_cutoff = try_command(dos_inp.getfloat,

                                [(ValueError, err_msg)],

                                'Refinement', 'energy_cutoff', fallback=0.5)

    if energy_cutoff < 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return energy_cutoff

# Read input parameters

def read_input(in_file):

    err = False

    try:

        dos_inp.read(in_file)

    except MissingSectionHeaderError as e:

        logger.error('There are options in the input file without a Section '

                     'header.')

        err = e

    except DuplicateOptionError as e:

        logger.error('There is an option in the input file that has been '

                     'specified more than once.')

        err = e

    except Exception as e:

        err = e

    else:

        err = False

    finally:

        if isinstance(err, BaseException):

            raise err

    inp_vars = {}

    # Global

    if not dos_inp.has_section('Global'):

        logger.error(no_sect_err % 'Global')

        raise NoSectionError('Global')

    # Mandatory options

    # Checks whether the mandatory options 'run_type', 'code', etc. are present.