Chimie Théorique » QMX

        super(Embed, self).__init__()

        # define the atom map

        self.atom_map_sys_cl = []

        self.linkatoms = []

        # cluster dimensions

        self.xyz_cl_min = None

        self.xyz_cl_max = None

        # set the search radius for link atoms

        # define the systems for calculations

        self.set_system(system)

        self.set_cluster(cluster)

        #

        self.set_cell([10, 10, 10])

        return

    def set_cluster(self, atoms):

        import copy

        # set the min/max cluster dimensions

                    self.xyz_cl_min[i] = xyz[i]

                if xyz[i] > self.xyz_cl_max[i]:

                    self.xyz_cl_max[i] = xyz[i]

        # add self.d around min/max cluster dimensions

        self.xyz_cl_min -= [self.d, self.d, self.d]

        # set the cluster for low and high level calculation

        self.atoms_cluster = atoms

        return

    #--- set the system ---

    def set_system(self, atoms):

        # assign the label "Cluster (10)" in atom.TAG

        for atom in atoms:

            atom.set_tag(0)

                dx = r

        self.d = dx * 2.1

        return

    #--- return cluster ---

    def get_cluster(self):

        return self.atoms_cluster

    def get_system(self):

        return self.atoms_system

    #--- Embedding ---

    def embed(self):

        # is the cluster and the host system definied ?

        xyzs_sys=[]

        for atom_sys in self.atoms_system:

            xyzs_sys.append(atom_sys.get_position())

        for iat_sys in xrange(len(self.atoms_system)):

            # get the coordinates of the system atom atom_sys

            xyz_sys = xyzs_sys[iat_sys]

                    # set tag (CLUSTER+HOST: 10) to atom_sys

                    self.atoms_system[iat_sys].set_tag(10)

                    # map the atom in the atom list

                    # atom has been identified

                    bSysOnly = False

                    break

            xyzs_cl.append(atom_cl.get_position())

        xyzs_sys=[]

        for atom_sys in self.atoms_system:

        # FIXME: mapping does not work when cluster atoms are outside of the box

        # set the standard link atom

        if linkAtom is None:

        nat_cl=len(self.atoms_cluster)

        nat_sys=len(self.atoms_system)

        # system has pbc?

        # set the bond table

        bonds = []

        # set the 27 cell_vec, starting with the (0,0,0) vector for the unit cell

            # xyz coordinates and covalent radius of the cluster atom iat_cl

            xyz_cl = xyzs_cl[iat_cl]

            r_cl = covalent_radii[atom_cl.get_atomic_number()]

            # sum over system atoms (iat_sys)

            for iat_sys in xrange(nat_sys):

                # avoid cluster atoms

                    # go only in distance self.d around the cluster

                    lcont = True

                    for i in xrange(3):

                            xyz_sys[i] > self.xyz_cl_max[i]):

                            lcont = False

                            break

                        print "Distance ", f

                        print "tol = ",(1+tol/100.),(1-tol/100.),(1-2*tol/100.)

                    if f <= (1+tol/100.) and f >= (1-2*tol/100.):

                        bonds.append(s)

                        break

                    if f <= (1-2*tol/100.):

                        raise RuntimeError("QMX: The cluster atom", iat_cl, " and the system atom", iat_sys, "came too close")

        r_h = covalent_radii[atomic_numbers[linkAtom]]

        for bond in bonds:

            # assign the tags for the border atoms

            atom_sys.set_tag(1)

            atom_cl.set_tag(11)

            #difference vector for the link atom, scaling

            r = (r_cl + r_h)

            xyz_diff *=  r / np.sqrt(np.dot(xyz_diff, xyz_diff))

            # determine position of the link atom

            # create link atom

            atom = Atom(symbol=linkAtom, position=xyz_diff, tag=50)

            # add atom to cluster

            self.atoms_cluster.append(atom)

            # add atom to the linkatoms

            self.linkatoms.append(s)

        return

    def set_positions(self, positions_new):

        # number of atoms

        nat_sys=len(self.atoms_system)

            self.atoms_system[iat_sys].set_position(xyz)

            if iat_cl > -1:

                self.atoms_cluster[iat_cl].set_position(xyz)

            # determine position of the link atom

            xyz = self.atoms_system[iat_sys].get_position() - xyz_cl + cell_L

            xyz *= r / np.sqrt(np.dot(xyz, xyz))

            xyz += xyz_cl

            # update xyz coordinates of the cluster

            self.atoms_cluster[iat].set_position(xyz)

    def __getitem__(self, i):

        return self.atoms_system.__getitem__(i)

    def get_positions(self):

        return self.atoms_system.get_positions()

    def __add__(self, other):

        return self.atoms_system.__add__(other)

    def __delitem__(self, i):

        return self.atoms_system.__delitem__(i)

    def __len__(self):

        return self.atoms_system.__len__()