Chimie Théorique » scripts_chimie4psmn » DockOnSurf

"""Methods to deal with dockonsurf input files

"""

def str2lst(cmplx_str):

    """ Converts a string composed of integers and groups of integers to a

    list of lists of integers.

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

        separators: ',' ';' and ' '

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

    """

    assert type(cmplx_str) == str, 'parameter should be a string'

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

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

    try:

        list(map(int, cmplx_str.replace(')','').replace('(','').split()))

    except:

        raise ValueError("Method parameter should be composed of integer numbers"

                         "\nseparated by ',' ';' or ' ' "

                         "grouped in parentheses-like separators")

    #TODO: enable superior level of nested lists (eg. '3 ((6 7) 8) 4')

    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(int, 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 read_input(in_file):

    """Reads the parameters in the input file (.INI file type) and

    sets up the corresponding global variables accordingly. Sections should be

    capitalized ('Global' is ok but 'global' or 'GLOBAL' are not)

    @param in_file: str: 

    @return:

    """

    from configparser import ConfigParser, NoSectionError, NoOptionError

    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

    dos_inp.read(in_file)

    turn_false_answers = [opt for opt in dos_inp.BOOLEAN_STATES

                          if dos_inp.BOOLEAN_STATES[opt] == False]

    return_vars = {}

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

    ### Global ###

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

    ### Mandatory options ###

    if not dos_inp.has_section('Global'): raise NoSectionError('Global')

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

    # present in the Global section and ensures they have an adequate

    # value

    mand_opts = ['run_type', 'code', 'batch_q_sys']

    for opt in mand_opts:

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

            raise NoOptionError(opt, 'Global')

    # run_type

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

                     'adsorption', 'full']

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

    if dos_inp.get('Global', 'run_type').lower() not in run_type_vals:

        raise ValueError('\'run_type\' does not have a adequate value.\n \

            Adequate values: \'' + '\', \''.join(run_type_vals) + '\'.')

    else:

        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_vars['isolated'] = isolated

    return_vars['screening'] = screening

    return_vars['refinement'] = refinement

    # end run_type 

    # code

    code_vals = ['cp2k']

    if dos_inp.get('Global', 'code').lower() not in code_vals:

        raise ValueError('\'code\' does not have an adequate value.\n \

            Adequate values: \'' + '\', \''.join(code_vals) + '\'.')

    else:

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

    return_vars['code'] = code

    # end code

    # batch_q_sys

    batch_q_sys_vals = ['sge']

    if dos_inp.get('Global', 'batch_q_sys').lower() not in batch_q_sys_vals:

        raise ValueError('\'batch_q_sys_vals\' does not have an adequate \

          value.\n Adequate values: \'' + '\', \''.join(batch_q_sys_vals) + '\'.')

    else:

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

    return_vars['batch_q_sys'] = batch_q_sys

    # end batch_q_sys

    ### run_type-dependent options ###

    # isol_inp_file

    if isolated:

        if not 'isol_inp_file' in dos_inp.options('Global'):

            raise NoOptionError('isol_inp_file', 'Global')

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

        return_vars['isol_inp_file'] = isol_inp_file

    # end isol_inp_file

    # screen_inp_file

    if screening:

        if not 'screen_inp_file' in dos_inp.options('Global'):

            raise NoOptionError('screen_inp_file', 'Global')

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

        return_vars['screen_inp_file'] = screen_inp_file

    # end screen_inp_file

    # refine_inp_file

    if refinement:

        if not 'refine_inp_file' in dos_inp.options('Global'):

            raise NoOptionError('refine_inp_file', 'Global')

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

        return_vars['refine_inp_file'] = refine_inp_file

    # end refine_inp_file

    ### Facultative options (Default value present) ###

    # relaunch_err

    relaunch_err_vals = ['geo_not_conv', 'false']

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

                               fallback="False")

    if relaunch_err.lower() in turn_false_answers:

        relaunch_err = False

    elif relaunch_err.lower() not in relaunch_err_vals:

        raise ValueError('\'relaunch_err\' does not have an adequate value.\n \

            Adequate values: \'' + '\', \''.join(relaunch_err_vals) + '\'.')

    return_vars['relaunch_err'] = relaunch_err

    # end relaunch_err

    # max_qw

    max_qw = dos_inp.getint('Global', 'max_qw', fallback=3)

    return_vars['max_qw'] = max_qw

    # end max_qw

    # special_atoms

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

                                fallback="False")

    if special_atoms.lower() in turn_false_answers:

        special_atoms = False

    else:

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

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

        if len(lst_tple) == 0 or not all(type(tup) is tuple and len(tup) == 2

                                         for tup in lst_tple):

            raise ValueError('\'special_atoms\' does not have an adequate '

                             + 'format.\n'

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

        special_atoms = lst_tple

    return_vars['special_atoms'] = special_atoms

    # end special_atoms

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

    ### Isolated ###

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

    if isolated:

        ### Facultative options (Default value present) ###

        # cluster_magns

        cluster_magns_vals = ['energy', 'moi']

        cluster_magns = dos_inp.get('Isolated', 'cluster_magns',

                                    fallback='energy').split(' ')

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

        if not all(magn in cluster_magns_vals for magn in cluster_magns):

            raise ValueError('\'cluster_magns\' does not have an adequate '

                             + 'value.\n'

                               'Adequate values: \'' + '\', \''.join(cluster_magns_vals) + '\'.')

        return_vars['cluster_magns'] = cluster_magns

        # end cluster_magns

        # num_conformers

        num_conformers = dos_inp.getint('Isolated',

                                        'num_conformers', fallback=1000)

        return_vars['num_conformers'] = num_conformers

        # end num_conformers

        # num_prom_cand

        num_prom_cand = dos_inp.getint('Isolated', 'num_prom_cand', fallback=3)

        return_vars['num_prom_cand'] = num_prom_cand

        # end num_prom_cand

        # iso_rmsd_threshold

        iso_rmsd_threshold = dos_inp.getfloat('Isolated',

                                              'rmsd_threshold', fallback=0.05)

        return_vars['iso_rmsd_threshold'] = iso_rmsd_threshold

        # end iso_rmsd_threshold

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

    ### Screening ###

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

    if screening:

        ### Mandatory options ###

        if not dos_inp.has_section('Screening'):

            raise NoSectionError('Screening')

        # Checks whether the mandatory options 'sites', 'molec_ads_ctrs',

        # etc. are present in the Screening section 

        mand_opts = ['sites', 'molec_ads_ctrs']

        for opt in mand_opts:

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

                raise NoOptionError(opt, 'Screening')

        # sites

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

        return_vars['sites'] = sites

        # end sites

        # molec_ads_ctrs

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

        return_vars['molec_ads_ctrs'] = molec_ads_ctrs

        # end molec_ads_ctrs

        ### Facultative options (Default value present) ###

        # try_disso

        try_disso = dos_inp.getboolean('Screening', 'try_disso',

                                       fallback=False)

        return_vars['try_disso'] = try_disso

        # end try_disso

        # sample_points_per_angle

        sample_points_per_angle = dos_inp.getint('Screening',

                                                 'sample_points_per_angle', fallback=3)

        return_vars['sample_points_per_angle'] = sample_points_per_angle

        # end sample_points_per_angle

        # collision_threshold

        collision_threshold = dos_inp.getfloat('Screening',

                                               'collision_threshold', fallback=1.2)

        return_vars['collision_threshold'] = collision_threshold

        # end collision_threshold

        # screen_rmsd_threshold

        screen_rmsd_threshold = dos_inp.getfloat('Screening',

                                                 'rmsd_threshold', fallback=0.05)

        return_vars['screen_rmsd_threshold'] = screen_rmsd_threshold

        # end screen_rmsd_threshold

        # collision_bottom_z

        collision_bottom_z = dos_inp.get('Screening',

                                         'collision_bottom_z', fallback="False")

        if collision_bottom_z.lower() in turn_false_answers:

            collision_bottom_z = False

        else:

            collision_bottom_z = float(

                collision_bottom_z)

        return_vars['collision_bottom_z'] = collision_bottom_z

        # end collision_bottom_z

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

    ### Refinement ###

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

    if refinement:

        ### Facultative options (Default value present) ###

        # energy_cutoff

        energy_cutoff = dos_inp.getfloat('Refinement',

                                         'energy_cutoff', fallback=0.5)

        return_vars['energy_cutoff'] = energy_cutoff

        # end energy_cutoff

    return return_vars