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_ads_ctrs: Gets 'molec_ads_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 integer " \

                "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):

    """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.

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

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

    """

    adeq_val_err = "'%s' is not an adequate value.\n" \

                   "Adequate values: %s"

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

        logger.error(adeq_val_err % (value, expect_vals))

        raise ValueError(adeq_val_err % (value, expect_vals))

    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']

    check_expect_val(dos_inp.get('Global', 'run_type').lower(), run_type_vals)

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

    if 'isolated' in run_type:

        isolated = True

    if 'screening' in run_type:

        screening = True

    if 'refinement' in run_type:

        refinement = True

    if 'adsorption' in run_type:

        screening, refinement = (True, True)

    if 'full' in run_type:

        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():

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

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

                           'Global', 'max_jobs', fallback=3)

    if max_jobs < 1:

        logger.error(num_error % ('max_jobs', 'positive integer'))

        raise ValueError(num_error % ('max_jobs', 'positive integer'))

    return max_jobs

def get_type_max():

    running = ['r', 'run', 'running']

    pending = ['p', 'pending', 'q', 'qw', 'queued']

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

    if type_max.lower() in turn_false_answers:

        return False

    elif type_max.lower() in running:

        return 'r'

    elif type_max.lower() in pending:

        return 'p'

    else:

        err = f"Value for 'type_max' is not acceoted. Accepted values: " \

              f"{running + pending + turn_false_answers}."

        logger.error(err)

        raise ValueError(err)

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_num_prom_cand():

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

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

                                'Isolated', 'num_prom_cand', fallback=3)

    if num_prom_cand < 1:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return num_prom_cand

def get_iso_rmsd():

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

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

                           'Isolated', 'iso_rmsd', fallback=0.05)

    if iso_rmsd <= 0.0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return iso_rmsd

def get_pre_opt():

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

    err_msg = "'pre_opt' should be UFF, MMFF or False"

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

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

    if pre_opt.lower() 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_molec_ads_ctrs():

    err_msg = 'The value of molec_ads_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_ads_ctrs = try_command(str2lst,

                                 [(ValueError, err_msg),

                                  (AttributeError, err_msg)],

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

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

    for ctr in molec_ads_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_ads_ctrs

def get_molec_neigh_ctrs():

    err_msg = 'The value of molec_neigh_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_neigh_ctrs = try_command(str2lst, [(ValueError, err_msg),

                                             (AttributeError, err_msg)],

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

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

    for ctr in molec_neigh_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_neigh_ctrs

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_surf_norm_vect():

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

          "or 'z'"

    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="z")

    if surf_norm_vect_str in cart_axes:

        surf_norm_vect = cart_axes[surf_norm_vect_str]

    else:

        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)

def get_ads_algo():

    algo_vals = ['euler', 'chemcat']

    check_expect_val(dos_inp.get('Screening', 'ads_algo').lower(), algo_vals)

    ads_algo = dos_inp.get('Screening', 'ads_algo', fallback='euler').lower()

    return ads_algo

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_structures = try_command(dos_inp.getint, [(ValueError, err_msg)],

                                 'Screening', 'max_structures', fallback=np.inf)

    if max_structures <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return max_structures

def get_coll_thrsld():

    err_msg = num_error % ('collision_threshold',

                           'positive decimal number')

    coll_thrsld = try_command(dos_inp.getfloat,

                              [(ValueError, err_msg)],

                              'Screening', 'collision_threshold', fallback=1.2)

    if coll_thrsld <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return coll_thrsld

def get_screen_rmsd():

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

    screen_rmsd = try_command(dos_inp.getfloat,

                              [(ValueError, err_msg)],

                              'Screening', 'screen_rmsd', fallback=0.05)

    if screen_rmsd <= 0:

        logger.error(err_msg)

        raise ValueError(err_msg)

    return screen_rmsd

def get_min_coll_height():

    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:

        min_coll_height = False

    else:

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

                                      min_coll_height)

    return min_coll_height

def get_disso_atoms():

    err_msg = "try_disso should be have a boolean value (True or False)"

    disso_atoms_str = dos_inp.get('Screening', 'disso_atoms', fallback="False")

    disso_atoms = []

    if disso_atoms_str.lower() in turn_false_answers:

        pass

    else:

        for el in disso_atoms_str.split():

            try:

                disso_atoms.append(int(el))

            except ValueError:

                disso_atoms.append(el)

    return disso_atoms

# 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

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

    return_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.

    glob_mand_opts = ['run_type', 'batch_q_sys']

    for opt in glob_mand_opts:

        if not dos_inp.has_option('Global', opt):

            logger.error(no_opt_err % (opt, 'Global'))

            raise NoOptionError(opt, 'Global')

    # Gets which sections are to be carried out

    isolated, screening, refinement = get_run_type()

    return_vars['isolated'] = isolated

    return_vars['screening'] = screening

    return_vars['refinement'] = refinement

    return_vars['batch_q_sys'] = get_batch_q_sys()

    # Dependent options:

    return_vars['code'] = get_code()

    if return_vars['batch_q_sys']:

        return_vars['type_max'] = get_type_max()

        return_vars['max_jobs'] = get_max_jobs()

        if return_vars['batch_q_sys'] != 'local':

            if not dos_inp.has_option('Global', 'subm_script'):

                logger.error(no_opt_err % ('subm_script', 'Global'))

                raise NoOptionError('subm_script', 'Global')

            return_vars['subm_script'] = get_subm_script()

        elif return_vars['type_max'] == "p":

            err = "'type_max' cannot be set to 'pending'/'queued' when " \

                  "'batch_q_sys' is set to 'local' "

            logger.error(err)

            raise ValueError(err)

    # Facultative options (Default/Fallback value present)

    return_vars['project_name'] = get_project_name()

    return_vars['relaunch_err'] = get_relaunch_err()

    return_vars['special_atoms'] = get_special_atoms()

    # Isolated

    if isolated:

        if not dos_inp.has_section('Isolated'):

            logger.error(no_sect_err % 'Isolated')

            raise NoSectionError('Isolated')

        # Mandatory options

        # Checks whether the mandatory options are present.

        iso_mand_opts = ['isol_inp_file', 'molec_file']

        for opt in iso_mand_opts:

            if not dos_inp.has_option('Isolated', opt):

                logger.error(no_opt_err % (opt, 'Isolated'))

                raise NoOptionError(opt, 'Isolated')

        return_vars['isol_inp_file'] = get_isol_inp_file()

        if 'code ' in return_vars:

            check_inp_file(return_vars['isol_inp_file'], return_vars['code'])

        return_vars['molec_file'] = get_molec_file()

        # Facultative options (Default/Fallback value present)

        return_vars['num_conformers'] = get_num_conformers()

        # return_vars['num_prom_cand'] = get_num_prom_cand()

        # return_vars['iso_rmsd'] = get_iso_rmsd()

        return_vars['pre_opt'] = get_pre_opt()

    # Screening

    if screening:

        if not dos_inp.has_section('Screening'):

            logger.error(no_sect_err % 'Screening')

            raise NoSectionError('Screening')

        # Mandatory options:

        # Checks whether the mandatory options are present.

        screen_mand_opts = ['screen_inp_file', 'surf_file', 'sites',

                            'molec_ads_ctrs', 'molec_neigh_ctrs']

        for opt in screen_mand_opts:

            if not dos_inp.has_option('Screening', opt):

                logger.error(no_opt_err % (opt, 'Screening'))

                raise NoOptionError(opt, 'Screening')

        return_vars['screen_inp_file'] = get_screen_inp_file()

        return_vars['surf_file'] = get_surf_file()

        return_vars['sites'] = get_sites()

        return_vars['molec_ads_ctrs'] = get_molec_ads_ctrs()

        return_vars['molec_neigh_ctrs'] = get_molec_neigh_ctrs()

        if len(return_vars['molec_ads_ctrs']) != \

                len(return_vars['molec_neigh_ctrs']):

            err = "'molec_ads_ctrs' and 'molec_neigh_ctrs' must have the same" \

                  "number of indides"

            logger.error(err)

            raise ValueError(err)

        # Facultative options (Default value present)

        return_vars['select_magns'] = get_select_magns()

        return_vars['confs_per_magn'] = get_confs_per_magn()

        return_vars['surf_norm_vect'] = get_surf_norm_vect()

        return_vars['disso_atoms'] = get_disso_atoms()

        return_vars['ads_algo'] = get_ads_algo()

        return_vars['sample_points_per_angle'] = get_pts_per_angle()

        return_vars['max_structures'] = get_max_structures()

        return_vars['collision_threshold'] = get_coll_thrsld()

        return_vars['min_coll_height'] = get_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]]

        if return_vars['min_coll_height'] is not False and \

                return_vars['surf_norm_vect'].tolist() not in cart_axes:

            logger.warning("'min_coll_height' option is only implemented for "

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

    # Refinement

    if refinement:

        if not dos_inp.has_section('Refinement'):

            logger.error(no_sect_err % 'Refinement')

            raise NoSectionError('Refinement')

        # Mandatory options

        # Checks whether the mandatory options are present.

        ref_mand_opts = ['refine_inp_file']

        for opt in ref_mand_opts:

            if not dos_inp.has_option('Refinement', opt):

                logger.error(no_opt_err % (opt, 'Refinement'))

                raise NoOptionError(opt, 'Refinement')

        return_vars['refine_inp_file'] = get_refine_inp_file()

        # Facultative options (Default value present)

        return_vars['energy_cutoff'] = get_energy_cutoff()

        # end energy_cutoff

    return_vars_str = "\n\t".join([str(key) + ": " + str(value)

                                   for key, value in return_vars.items()])

    logger.info(

        f'Correctly read {in_file} parameters: \n\n\t{return_vars_str}\n')

    return return_vars

if __name__ == "__main__":

    import sys

    print(read_input(sys.argv[1]))