Chimie Théorique » scripts_chimie4psmn » DockOnSurf

import logging

from configparser import ConfigParser, NoSectionError, NoOptionError, \

    MissingSectionHeaderError, DuplicateOptionError

from modules.utilities import try_command

logger = logging.getLogger('DockOnSurf')

def get_surf_norm_vect():

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

          "or 'z'"

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

    else:

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

        if len(surf_norm_vect) != 3:

            logger.error(err)

            raise ValueError(err)

    return screen_rmsd

    else:

def get_try_disso():

        return_vars['ads_algo'] = get_ads_algo()

        return_vars['sample_points_per_angle'] = get_pts_per_angle()

        return_vars['collision_threshold'] = get_coll_thrsld()

    # Refinement

    if refinement:

    @return: bool, whether the surface and the molecule collide.

    """

    from ase.neighborlist import natural_cutoffs, neighbor_list

    else:

def correct_coll(molec, slab, ctr_coord, site_coord, num_pts,

    # TODO Rethink this function

    """Tries to adsorb a molecule on a slab trying to avoid collisions by doing

    small rotations.

    @param site_coord: The coordinates of the surface on which to adsorb the

        molecule

    @param num_pts: Number on which to sample Euler angles.

    @param norm_vect: The vector perpendicular to the surface.

    @param slab_nghbs: Number of neigbors in the surface.

    @param molec_nghbs: Number of neighbors in the molecule.

                           center=ctr_coord)

        add_adsorbate(slab_molec, molec, site_coord, ctr_coord, 2.5,

                      norm_vect=norm_vect)

                                    norm_vect, slab_nghbs, molec_nghbs,

                                    coll_coeff)

        num_corr += 1

def ads_euler(orig_molec, slab, ctr_coord, site_coord, num_pts,

    """Generates adsorbate-surface structures by sampling over Euler angles.

    This function generates a number of adsorbate-surface structures at

    @param site_coord: The coordinates of the surface on which to adsorb the

        molecule

    @param num_pts: Number on which to sample Euler angles.

    @param coll_coeff: The coefficient that multiplies the covalent radius of

        atoms resulting in a distance that two atoms being closer to that is

        considered as atomic collision.

                molec = deepcopy(orig_molec)

                molec.euler_rotate(alpha, beta, gamma, center=ctr_coord)

                slab_molec, collision = correct_coll(molec, slab,

                if not collision:

                    slab_ads_list.append(slab_molec)

def adsorb_confs(conf_list, surf, molec_ctrs, sites, algo, num_pts, neigh_ctrs,

    """Generates a number of adsorbate-surface structure coordinates.

    Given a list of conformers, a surface, a list of atom indices (or list of

    @param neigh_ctrs: the indices of the neighboring atoms to the adsorption

        atoms.

    @param norm_vect: The vector perpendicular to the surface.

    @param coll_coeff: The coefficient that multiplies the covalent radius of

        atoms resulting in a distance that two atoms being closer to that is

        considered as atomic collision.

    from ase.neighborlist import natural_cutoffs, neighbor_list

    surf_ads_list = []

    sites_coords = get_atom_coords(surf, sites)

    for conf in conf_list:

        molec_ctr_coords = get_atom_coords(conf, molec_ctrs)

        molec_neigh_coords = get_atom_coords(conf, neigh_ctrs)

        for site in sites_coords:

            for ctr in molec_ctr_coords:

                if algo == 'euler':

                    surf_ads_list.extend(ads_euler(conf, surf, ctr, site,

                                                   coll_coeff, norm_vect,

                                                   surf_nghbs, molec_nghbs))

                elif algo == 'chemcat':

                                 inp_vars['sample_points_per_angle'],

                                 inp_vars['molec_neigh_ctrs'],

                                 inp_vars['surf_norm_vect'],

                                 inp_vars['collision_threshold'])

    run_calc('screening', inp_vars, surf_ads_list)

                    'try_disso': True,

                    'sample_points_per_angle': 4,

                    'collision_threshold': 0.9,

                    'refine_inp_file': 'refine.inp',

                    'energy_cutoff': 1.0

                    }

        self.assertEqual(get_coll_thrsld(), 0.9)

    def test_coll_bottom(self):

    def test_refine_inp_file(self):

        self.assertEqual(get_refine_inp_file(), 'refine.inp')

        self.assertRaises(ValueError, get_coll_thrsld)

    def test_coll_bottom(self):

    def test_refine_inp_file(self):

        self.assertRaises(FileNotFoundError, get_refine_inp_file)