Chimie Théorique » scripts_chimie4psmn » DockOnSurf

    from pycp2k import CP2K

    from modules.utilities import tail

        conf_path = f'{run_type}/{conf_dir}'

            cp2k = CP2K()

                with open(conf_path+"/"+file, "rb") as out_fh:

    positions = np.array([atom.split()[1:] for atom in raw_coords])

def collect_coords(conf_list, code, run_type, spec_atms=tuple()):

    """Directs the reading of coordinates on a set of subdirectories.

    Given a dockonsurf directory hierarchy: project/run_type/conf_X

    (run_type = ['isolated', 'screening' or 'refinement']) with finished

    calculations produced by a given code, stored in every conf_X subdirectory,

    it collects the coordinates of the specified conf_X subdirectories in a

    single run_type by calling the adequate function (depending on the code) and

    returns a list of ase.Atoms objects.

    @param conf_list: List of directories where to read the coords from.

    @param code: the code that produced the calculation results files.

    @param run_type: the type of calculation (and also the name of the folder)

                     containing the calculation subdirectories.

    @param spec_atms: List of tuples containing pairs of new/traditional

        chemical symbols.

    @return: list of ase.Atoms objects.

    """

    from glob import glob

    atoms_list = []

    for conf in conf_list:

        if code == 'cp2k':

            atoms_list.append(read_coords_cp2k(glob(f"{run_type}/{conf}/*-1"

                                                    f".restart")[0], spec_atms))

        elif code == 'vasp':

            atoms_list.append(read_coords_vasp(f"{run_type}/{conf}/OUTCAR",

                                               spec_atms))

        else:

            err_msg = f"Collect coordinates not implemented for '{code}'."

            logger.error(err_msg)

            raise NotImplementedError(err_msg)

    return atoms_list

    """Reads the CP2K out file and returns its final energy.

    @return: The last energy on the out file.

def collect_energies(conf_list, code, run_type):

    """Directs the reading of energies on a set of subdirectories.

    (run_type = ['isolated', 'screening' or 'refinement']) with finished

    calculations produced by a given code, stored in every conf_X subdirectory,

    it collects the energies of the specified conf_X subdirectories in a

    single run_type by calling the adequate function (depending on the code) and

    returns a list of energies.

    @param conf_list: List of directories where to read the energy.

    @param code: The code that produced the calculation output files.

    @param run_type: The type of calculation (and also the name of the folder)

                     containing the calculation subdirectories.

    @return: List of energies

    import numpy as np

    energies = []

    for conf in conf_list:

            energies.append(read_energy_cp2k(

                glob(f"{run_type}/{conf}/*.out")[0]))

            err_msg = f"Collect energies not implemented for '{code}'."

    if len(energies) == 0:

        err = f"No results found on {run_type}"

        logger.error(err)

        raise FileNotFoundError(err)

    return np.array(energies)

        rdkit_mol_to_ase_atoms, collect_confs, collect_energies

    finished_calcs, unfinished_calcs = check_finished_calcs('isolated',

    conf_list = collect_coords(finished_calcs, inp_vars['code'], 'isolated',

                               inp_vars['special_atoms'])

    most_stable_conf = select_confs(conf_list, finished_calcs, 0,

                                    inp_vars['code'])[0]

    logger.info('Finished the procedures for the isolated molecule section. '

                f'Most stable conformers is {most_stable_conf}.')

def select_confs(conf_list, calc_dirs, energy_cutoff, code):

    @param calc_dirs: List of the directories of the finished calculations

    @param energy_cutoff: The maximum energy above the most stable configuration

    @param code: the code used to carry out the screening of structures.

    @return: list of the the most stable configurations within the energy cutoff

    from copy import deepcopy

    from modules.formats import collect_energies

    conf_enrgs = collect_energies(calc_dirs, code, 'screening')

    for i, conf in enumerate(conf_list):

        conf.info['energy'] = conf_enrgs[i]

        conf.info['id'] = calc_dirs[i]

    from modules.formats import collect_coords

    finished_calcs, unfinished_calcs = check_finished_calcs('screening',

                                                            inp_vars['code'])

    if len(unfinished_calcs) != 0:

        logger.warning(f"Found {len(unfinished_calcs)} calculations more that "

                       f"did not finish normally: {unfinished_calcs}. \n"

    conf_list = collect_coords(finished_calcs, inp_vars['code'], 'screening',

                               inp_vars['special_atoms'])

    selected_confs = select_confs(conf_list, finished_calcs,

                                  inp_vars['energy_cutoff'], inp_vars['code'])

    finished_calcs, unfinished_calcs = check_finished_calcs('refinement',

                                                            inp_vars['code'])

    conf_list = collect_coords(finished_calcs, inp_vars['code'], 'refinement',

                               inp_vars['special_atoms'])

    most_stable_conf = select_confs(conf_list, finished_calcs, 0,

                                    inp_vars['code'])[0]

    logger.info('Finished the procedures for the refinement of '

                'adsorbate-surface structures section. Most stable structure '

                f"is {most_stable_conf.info['id']}")

def assign_prop(atoms: ase.Atoms, prop_name: str, prop_val):  # TODO Needed?

    atoms.info[prop_name] = prop_val

def select_confs(orig_conf_list: list, calc_dirs: list, magns: list,

                 num_sel: int, code: str):

    @param orig_conf_list: list of ase.Atoms objects to select among.

    @param calc_dirs: List of directories where to read the energies from.

    @param code: The code that generated the magnitude information.

         Supported codes: See formats.py

    from copy import deepcopy

    from modules.formats import collect_energies

    conf_list = deepcopy(orig_conf_list)

    conf_enrgs, mois, selected_ids = [], [], []

    # Read properties

    if 'energy' in magns:

        if code == 'cp2k':

            conf_enrgs = collect_energies(calc_dirs, code, 'isolated')

        elif code == 'vasp':

            conf_enrgs = np.array([conf.get_total_energy()

                                   for conf in orig_conf_list])

        mois = np.array([conf.get_moments_of_inertia() for conf in conf_list])

    # Assign values

    for i, conf in enumerate(conf_list):

        assign_prop(conf, 'idx', i)

        assign_prop(conf, 'iso', calc_dirs[i])

        if 'energy' in magns:

            assign_prop(conf, 'energy', conf_enrgs[i])

        if 'moi' in magns:

            assign_prop(conf, 'moi', mois[i, 2])

        if sorted_list[-1].info['idx'] not in selected_ids:

            selected_ids.append(sorted_list[-1].info['idx'])

                if sorted_list[i].info['idx'] not in selected_ids:

                    selected_ids.append(sorted_list[i].info['idx'])

    return [conf_list[idx] for idx in selected_ids]

    from modules.formats import collect_coords, adapt_format

        correct_calcs, failed_calcs = check_finished_calcs('isolated',

                                                           inp_vars['code'])

        if not correct_calcs:

        logger.info(f"Found {len(correct_calcs)} structures of isolated "

                f"{correct_calcs}.")

        conformer_atoms_list = collect_coords(correct_calcs, inp_vars['code'],

                                              'isolated',

                                              inp_vars['special_atoms'])

        selected_confs = select_confs(conformer_atoms_list, correct_calcs,

                                      inp_vars['select_magns'],

                                      inp_vars['confs_per_magn'],

                                      inp_vars['code'])