Chimie Théorique » scripts_chimie4psmn » DockOnSurf

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

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

for answer, val in new_answers.items():

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

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

                and inp_vars['collision_threshold'] is False:

            logger.warning("Collisions are deactivated: Overlapping of "

                           "adsorbate and surface is possible")

        inp_vars['h_donor'] = get_H_donor(inp_vars['special_atoms'])

        inp_vars['max_structures'] = get_max_structures()

        inp_vars['use_molec_file'] = get_use_molec_file()

def check_collision(slab_molec, slab_num_atoms, min_height, vect, nn_slab=0,

    """Checks whether a slab and a molecule collide or not.

    @param slab_molec: The system of adsorbate-slab for which to detect if there

    @param min_height: The minimum height atoms can have to not be considered as

        colliding.

    @param vect: The vector perpendicular to the slab.

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

    """

    from ase.neighborlist import natural_cutoffs, neighbor_list

    # Check structure overlap by height

            logger.error(err_msg)

            raise ValueError(err_msg)

        for atom in slab_molec[slab_num_atoms:]:

            for i, coord in enumerate(vect):

                if coord == 0:

                    continue

    # Check structure overlap by sphere collision

    if coll_coeff is not False:

        if slab_molec_nghbs > nn_slab + nn_molec:

            return True

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

                 min_coll_height, norm_vect, slab_nghbs, molec_nghbs,

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

    small rotations.

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

        considered as atomic collision.

    @param height: Height on which to try adsorption.

    @return collision: bool, whether the structure generated has collisions

        between slab and adsorbate.

    """

                      norm_vect=norm_vect)

        collision = check_collision(slab_molec, slab_num_atoms, min_coll_height,

                                    norm_vect, slab_nghbs, molec_nghbs,

        num_corr += 1

    return slab_molec, collision

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

              min_coll_height, coll_coeff, norm_vect, slab_nghbs, molec_nghbs,

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

    This function generates a number of adsorbate-surface structures at

    @param h_donor: List of atom types or atom numbers that are H-donors.

    @param h_acceptor: List of atom types or atom numbers that are H-acceptors.

    @param height: Height on which to try adsorption.

    @return: list of ase.Atoms object conatining all the orientations of a given

        conformer.

    """

                    continue

                molec = deepcopy(prealigned_molec)

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

                                                     slab_nghbs, molec_nghbs,

                if not collision and not any([np.allclose(slab_molec.positions,

                                                          conf.positions)

                                              for conf in slab_ads_list]):

def ads_internal(orig_molec, slab, ctr1_mol, ctr2_mol, ctr3_mol, ctr1_surf,

                 ctr2_surf, num_pts, min_coll_height, coll_coeff, norm_vect,

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

    @param orig_molec: ase.Atoms object of the molecule to adsorb (adsorbate).

    @param max_hel: Maximum value for sampling the helicopter

        (surf-adsorbate dihedral) angle.

    @param height: Height on which to try adsorption.

    @return: list of ase.Atoms object conatining all the orientations of a given

        conformer.

    """

                                                     num_pts, min_coll_height,

                                                     norm_vect, slab_nghbs,

                                                     molec_nghbs, coll_coeff,

                if not collision and \

                        not any([np.allclose(slab_molec.positions,

                                             conf.positions)

    @param inp_vars: Calculation parameters from input file.

    @return: list of ase.Atoms for the adsorbate-surface structures

    """

    from ase.neighborlist import natural_cutoffs, neighbor_list

    molec_ctrs = inp_vars['molec_ctrs']

    sites = inp_vars['sites']

    inp_norm_vect = inp_vars['surf_norm_vect']

    min_coll_height = inp_vars['min_coll_height']

    coll_coeff = inp_vars['collision_threshold']

    h_donor = inp_vars['h_donor']

    h_acceptor = inp_vars['h_acceptor']

    height = inp_vars['adsorption_height']

        if inp_vars['pbc_cell'] is not False:

            conf.set_pbc(True)

            conf.set_cell(inp_vars['pbc_cell'])

        for s, site in enumerate(sites_coords):

            if isinstance(inp_norm_vect, str) and inp_norm_vect == 'auto':

                norm_vect = compute_norm_vect(surf, sites[s],

            else:

                norm_vect = inp_norm_vect

            for c, ctr in enumerate(molec_ctr_coords):

                if angles == 'euler':

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

                                                   num_pts, min_coll_height,

                                                   coll_coeff, norm_vect,

                                                   surf_nghbs, molec_nghbs,

                elif angles == 'internal':

                    mol_ctr1 = molec_ctrs[c]

                    mol_ctr2 = inp_vars["molec_ctrs2"][c]

                                                      coll_coeff, norm_vect,

                                                      surf_nghbs, molec_nghbs,

                                                      h_donor, h_acceptor,

    return surf_ads_list