surface-construct 0.6__tar.gz → 0.7__tar.gz

{surface_construct-0.6/surface_construct.egg-info → surface_construct-0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: surface_construct
-Version: 0.6
+Version: 0.7
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren
@@ -20,6 +20,7 @@ Requires-Dist: tqdm
 Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: scikit-learn
+Requires-Dist: scikit-image
 
 # 基于分层采样策略的催化剂表面位点全局分析
 

{surface_construct-0.6 → surface_construct-0.7}/setup.py

@@ -13,11 +13,12 @@ install_requires = [
     'matplotlib',
     'scipy',
     'scikit-learn',
+    'scikit-image'
 ]
 
 setup(
     name='surface_construct',
-    version='0.6',
+    version='0.7',
     packages=['surface_construct'],
     url='https://gitee.com/pjren/surface_construct/',
     license='GPL',

{surface_construct-0.6 → surface_construct-0.7}/surface_construct/surface_grid.py

@@ -12,25 +12,25 @@ TODO: 双结合位点情况。表面位点采样[(x1, y1, z1), (x2, y2, z2)]。
 TODO: 构效关系建立。将不同的位点向量合并，然后进行性能分布的关联，投影到二维平面（PCA）。
 """
 
-import ase
-import numpy as np
 import pickle
+from logging import warning
+
+import matplotlib.tri as mtri
+import numpy as np
 from ase.data import covalent_radii, vdw_radii
 from ase.geometry import find_mic
-from ase.visualize import view
 from matplotlib import pyplot as plt
-import matplotlib.tri as mtri
 from scipy.interpolate import griddata
 from scipy.spatial import ConvexHull
-from scipy.spatial.distance import cdist, euclidean
-from scipy.stats import triang
+from scipy.spatial.distance import euclidean, cdist
 from sklearn.cluster import KMeans as Cluster
+from sklearn.cluster import kmeans_plusplus
 from sklearn.decomposition import PCA
 from sklearn.gaussian_process import GaussianProcessRegressor
 from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel
 from sklearn.preprocessing import StandardScaler
 
-from surface_construct.utils import get_calc_info, GridGenerator, get_distances
+from surface_construct.utils import get_calc_info, GridGenerator, get_distances, furthest_sites
 
 
 def no_weight(v, **kwargs):
@@ -76,10 +76,21 @@ def vb_weight(v, **kwargs):
 
 
 def reciprocal_weight(v, **kwargs):
+    """Relate to Coulumb interaction
+    Need charge for each atom.
+    TODO: add charge option.
+    Calculate each pairs between q and q_ads.
+    q = kwargs.get('charge',0.1)
+    q_ads = kwargs.get('charge_ads',1)
+    q 可以使用 CHELG 方法快速计算。
+    """
     r0 = kwargs['r0']
     v_w = r0 / v
     return v_w
 
+# TODO: vdw 相互作用项
+
+# TODO: 总的加和是 valent + coulumb + vdw，或者三者的合并
 
 def reciprocal_square_weight(v, **kwargs):
     return reciprocal_weight(v, **kwargs) ** 2
@@ -94,6 +105,7 @@ class SurfaceGrid:
                  radii_type='covalent_radii',
                  radii_factor=1.0,
                  lpca=True,
+                 cutoff=10,
                  ):
         self.atoms = atoms
         num_set = set(self.atoms.numbers)
@@ -110,7 +122,7 @@ class SurfaceGrid:
             else:
                 raise NotImplementedError
         self.radii = radii
-
+        self.cutoff = cutoff
         if rads is not None:
             self.rads = rads
         else:
@@ -175,76 +187,26 @@ class SurfaceGrid:
         * surface_index: 表面原子的序号
         :return:
         """
-
-        """ ### Old code
-        if gridxy is None:
-            nx, ny = self.grid_nx, self.grid_ny
-
-            fx_list = np.linspace(0, 1, nx, endpoint=False)  # endpoint=false指的是不包括右侧端点
-            fy_list = np.linspace(0, 1, ny, endpoint=False)
-            # 格点生成
-            fgrid_x, fgrid_y = np.meshgrid(fx_list, fy_list)
-            fxyz = np.zeros((nx * ny, 3))
-            fxyz[:, 0] = fgrid_x.reshape(nx * ny)
-            fxyz[:, 1] = fgrid_y.reshape(nx * ny)
-            xyz = self.atoms.cell.cartesian_positions(fxyz)
-        else:
-            Xgrid, Ygrid = gridxy
-            x = Xgrid.reshape(-1)
-            y = Ygrid.reshape(-1)
-            z = np.zeros(x.shape)
-            xyz = np.asarray([x, y, z]).T
-
-        xmin, xmax, ymin, ymax, zmin, zmax = self.structure_boundary()
-        condition = (xyz[:, 0] > xmin) * (xyz[:, 0] < xmax) * (xyz[:, 1] > ymin) * (xyz[:, 1] < ymax)
-        xyz = xyz[condition]
-
-        xyz[:, 2] = zmax
-        z = zmax
-        nonbond_index = np.ones(len(xyz), bool)
-        atoms_pos = self.atoms.positions
-        atoms_num = self.atoms.numbers
-        if surface_index is not None:
-            atoms_pos = atoms_pos[surface_index]
-            atoms_num = atoms_num[surface_index]
-        grid_dist_array = np.zeros((len(xyz), len(atoms_pos), 3))
-        grid_dist = np.zeros((len(xyz), len(atoms_pos)))
-        while np.any(nonbond_index):
-            z -= self.interval / 10.0
-            xyz[nonbond_index, 2] = z
-            grid_dist_array[nonbond_index], grid_dist[nonbond_index] = get_distances(
-                xyz[nonbond_index], atoms_pos, cell=self.atoms.cell, pbc=self.atoms.pbc)
-            R0 = np.asarray([self.radii[i] for i in atoms_num]) + self.rads
-            # 判断最小距离是否小于共价半径之和
-            nonbond_index = nonbond_index & (~np.any(grid_dist - R0 <= 0, axis=1))
-
-            if z < zmin:
-                z_index = xyz[:, 2] > z
-                xyz = xyz[z_index]  # exclude the points that lower than zmin
-                grid_dist_array = grid_dist_array[z_index]
-                grid_dist = grid_dist[z_index]
-                break
-        self.points = xyz
-
-        if surface_index is not None:  # grid_dist should contain all atoms
-            grid_dist_array, grid_dist = get_distances(
-                self.points, self.atoms.positions, cell=self.atoms.cell, pbc=self.atoms.pbc)
-        """
-        subtype = kwargs.get('subtype', None)
+        subtype = kwargs.get('subtype', 'slab')  # default is slab
+        self._subtype = subtype
         rsub = [self.radii[atomnum] for atomnum in self.atoms.numbers]
         gridgen = GridGenerator(self.atoms, interval=self.interval, subtype=subtype, rads=self.rads, rsub=rsub)
-        self.points = gridgen.grid.copy()
+        self.points = gridgen.grid
         self._gridgen = gridgen
 
         #self._Dga = grid_dist
         #self._DAga = grid_dist_array
 
     def _calc_Dga(self):
-        # TODO: add cutoff to kwargs or as self attr
-        cutoff = 10
         if self.points is None:
             self.gridize()
-        _, Dga = get_distances(self.points, self.atoms.positions, cutoff=cutoff,
+        if self._subtype == 'slab':
+            pbc = [True, True, False]
+        elif self._subtype == 'cluster':
+            pbc = [False, False, False]
+        else:
+            pbc = self.atoms.pbc
+        _, Dga = get_distances(self.points, self.atoms.positions, cutoff=self.cutoff, pbc=pbc,
                                use_ase=False, cell=self.atoms.cell)
         self._Dga = Dga
 
@@ -255,19 +217,7 @@ class SurfaceGrid:
         :param grid_idx:
         :return:
         """
-        #if self._Dga is not None:
-        #    # 一般使用表面格点与最近邻原子的向量， 效果不好，在顶位会出现混乱。放弃
-        #    # v = self._DAga[grid_idx][self._Dga[grid_idx].argmin()]
-        #    # if v[0] < 0.1 and v[1] < 0.1:
-        #    if True:
-        #        # 对于顶位，即向量x，y为0，0 的情况，使用最近邻原子和次紧邻原子的向量
-        #        order = np.argsort(self._Dga[grid_idx])
-        #        p1, p2 = self.atoms.positions[order[0:2]]
-        #        v, vlen = get_distances(p1, p2, cell=self.atoms.cell, pbc=self.atoms.pbc)
-        #        v = v[0, 0]
-        #    return v
-        #else:
-        #    raise NotImplementedError
+
         if self._Dga is None:
             self._calc_Dga()
         order = np.argsort(self._Dga[grid_idx])
@@ -287,26 +237,15 @@ class SurfaceGrid:
         else:
             return None
 
-    def filter_grid_z(self, z=None):
-        """
-        过滤 z 方向不合理的格点，默认原子坐标 zmax.  对于孔材料和cluster 已经不合时宜了
-        :param z:
-        :return:
-        """
-        pass
-        # if z is None:
-        #     z = self.atoms.positions[:, 2].max()
-        # index = self.points[:, 2] > z
-        # self.points = self.points[index]
-        # self._Dga = self._Dga[index]
-        # self._DAga = self._DAga[index]
-
     def vectorize(self, Dga=None, return_vector=False, wf=vb_weight, pca=True, pca_ratio=0.90, **kwargs):
         """
         TODO: 使用 DScribe 来进行向量化，并进行测试。如何测试？测试什么内容？
+        TODO: 产生 cluster_mesh, 生成 cluster_mesh_id 与 point_id 之间的正反向 dict
         使用 distance matrix 来进行向量化
         使用衰减函数对 vector 加权重。备选函数：S型，指数型（键价），1/sqrt，1/x，线性。倾向使用指数型，键价理论支持。 1/x，或者 1/sqrt，衰减更慢。
         这种方法类似于多点地位方法（Multilateration），因而暂时称其为 Multilateration vectorization.
+        :param pca_ratio:
+        :param pca:
         :param wf:
         :param Dga: grid-atoms distance matrix
         :param return_vector: 是否返回 vector 向量
@@ -371,22 +310,20 @@ class SurfaceGrid:
         计算实空间和向量空间的距离转化系数。随机取十个点，求平均值。
         :return:
         """
-        nsample = 10
+        nsample = 100
         rng = np.random.default_rng()
-        idx = rng.choice(range(len(self.points)), size=nsample)
-        d_grid = [get_distances(self.points[i], self.points[i+1], cell=self.atoms.cell, pbc=self.atoms.pbc)[1][0, 0]
-                  for i in idx]
-        idx_filtered = [i for i, d in zip(idx, d_grid) if d < 1.2 * self.interval]  # 去掉不相邻的格点对
-        assert len(idx_filtered) > 0
-        d_vector = np.asarray([euclidean(self.vector[i], self.vector[i+1]) for i in idx_filtered])
+        idx_0 = rng.choice(range(len(self.points)-1), size=nsample)
+        idx_1 = idx_0+1
+        idx = np.asarray([[i,j] for i,j in zip(idx_0, idx_1) if (i not in idx_1 and j not in idx_0)])
+        d_grid = np.linalg.norm(self.points[idx[:, 0]] - self.points[idx[:, 1]], axis=1)
+        idx = idx[d_grid<1.2 * self.interval]
+        d_vector = np.linalg.norm(self.vector[idx[:,0]]-self.vector[idx[:,1]], axis=1).mean()
         k = d_vector / self.interval
-        return np.mean(k)
+        return np.min(k)
 
-    def grid_sample(self, N=10, include_vertex=False):
+    def grid_sample(self, N=10):
         """
         Warning: Obsoleted, replaced by Sampling class
-        TODO: 使用vertex 点作为分类的中心点
-        :param include_vertex: 是否对边界额外采样
         :param N:
         :return:
         """
@@ -398,57 +335,76 @@ class SurfaceGrid:
             self.sample_idx = np.concatenate([self.sample_idx, [idx]])
             self._sample_vector = np.concatenate([self._sample_vector, [self.vector[idx]]])
             self.sample_points = np.concatenate([self.sample_points, max_sigma_point])
-
             return [idx]
 
-        # 进行分类，然后采样。这里使用 Kmeans 方法进行聚类
-        clusters = Cluster(n_clusters=N, random_state=0).fit(self.vector)
-        self._clusters = clusters  # 保存用于作图
-        # 对于每一类取距离 cluster 中心最小的点的 idx
-        centers = clusters.cluster_centers_
-        center_dist = cdist(centers, self.vector)  # 计算每个点到中心的距离
-        index = np.argmin(center_dist, axis=-1)
-
-        points_cluster_sample = self.points[index]
-        if include_vertex:
-            # 找到 Hull 点，加入采样
-            hull = ConvexHull(self.vector)
-            vertices = hull.vertices
-            vector_hull_sample = self.vector[vertices]
-            points_hull_sample = self.points[vertices]
-
-            # 计算 hull 点与 cluster_sample 的距离, 排除太近的 cluster 采样点
-            hull_cluster_dist_array, hull_cluster_dist = get_distances(points_hull_sample, points_cluster_sample,
-                                                                       cell=self.atoms.cell, pbc=self.atoms.pbc)
-            cluster_index = np.all(hull_cluster_dist > self.interval * 2, axis=0)
-            index = np.concatenate([index, cluster_index])  # 读入能量的时候再保存
-
-        self.sample_idx = index
-        self.sample_points = self.points[index]
-        self._sample_vector = self.vector[index]  # 保存用于作图
-
-        return index
+        assert N > 1
+        hull = ConvexHull(self.vector)
+        vertices = []
+        # 去掉 hull 的 simplices 的角度较大的点
+        for i in hull.vertices:
+            p1_idx, p2_idx = np.argwhere(hull.simplices == i)
+            p0 = hull.points[i]
+            p1 = hull.points[hull.simplices[p1_idx[0],1-p1_idx[1]]]
+            p2 = hull.points[hull.simplices[p2_idx[0],1-p2_idx[1]]]
+            a = p1 - p0
+            b = p2 - p0
+            cosangle = a.dot(b)/(np.linalg.norm(a) * np.linalg.norm(b))
+            if cosangle > np.cos(np.pi*150/180):
+                vertices.append(i)
+        # 聚类，vector_mesh
+        n_vector_mesh = int(hull.volume / (self._vector_unit * self.interval)**self.vector.shape[1]) + 1
+        cluster0 = Cluster(n_clusters=n_vector_mesh)
+        cluster0.fit(self.vector)
+        mesh_centers = cluster0.cluster_centers_
+        self._mesh_centers = mesh_centers
+        nvert = len(vertices)
+        cluster = Cluster(n_clusters=N)
+        cluster.fit(mesh_centers)
+        if nvert >= N:
+            warning("Sample number should be larger than {nvert}")
+            sample_idx = [vertices[i] for i in furthest_sites(self.vector[vertices], N)]
+        else:
+            # 聚类
+            cluster2 = Cluster(n_clusters=N-nvert)
+            cluster2.fit(mesh_centers)
+            center_dist = cdist(cluster2.cluster_centers_, self.vector)  # 计算每个点到中心的距离
+            sample_idx = vertices + np.argmin(center_dist, axis=-1).tolist()
+
+        self._clusters = cluster
+        self.sample_idx = sample_idx
+        self.sample_points = self.points[sample_idx]
+        self._sample_vector = self.vector[sample_idx]  # 保存用于作图
+        return self.sample_idx
+
+    # TODO: 将中心重新映射回到Cartesian坐标 ：
+        # 找到向量空间最紧邻的N个点，判断其实空间的距离是否小于 interval × 2，直到有三个点满足
+        # 然后进行空间变换 A x M = B，M = B / A = B x A-1, R = V x M
+        # 或者直接使用最近邻点的坐标
 
     def plot_cluster(self, figname=None):
         """
-        TODO: plot cluster in real space and vector space.
         :param figname:
         :return:
         """
         if figname is None:
             figname = 'site_cluster.png'
         print("Plot the site verctor and cluster ...")
-        reduced_vector = PCA(n_components=2).fit_transform(self._raw_vector)
-        self._reduced_vector = reduced_vector
-
+        if self._pca:
+            reduced_vector = self._mesh_centers[:,:2]
+            sample_vector = self._sample_vector
+        else:
+            pca = PCA(n_components=2)
+            pca.fit(self.vector)
+            reduced_vector = pca.transform(self._mesh_centers)
+            sample_vector = pca.transform(self._sample_vector)
         # Obtain labels for each point
-        labels = self._clusters.labels_
-
         # plot in vector space
         fig, ax = plt.subplots()
         ax.set_aspect('equal')
-        ax.scatter(reduced_vector[:, 0], reduced_vector[:, 1], c=labels, cmap=plt.cm.Paired)
-        title = "The site vector colored in {} clusters".format(self._clusters.n_clusters)
+        ax.scatter(reduced_vector[:, 0], reduced_vector[:, 1], c=self._clusters.labels_, cmap=plt.cm.Paired)
+        ax.scatter(sample_vector[:, 0],sample_vector[:, 1], marker="+", s=100, linewidths=2,
+                   color="black", zorder=10)
+        title = f"The site vector colored in {self._clusters.n_clusters} clusters"
         ax.set_title(title)
         fig.set_dpi(300)
         fig.set_size_inches(10, 10)
@@ -457,11 +413,14 @@ class SurfaceGrid:
         plt.cla()
         plt.close("all")
 
-        # plot in real space
+        # plot grid
+        labels = self._clusters.predict(self.vector)
         fig, ax = plt.subplots()
         ax.set_aspect('equal')
         ax.scatter(self.points[:, 0], self.points[:, 1], c=labels, s=1, cmap=plt.cm.Paired)
-        title = "The site grid colored in {} clusters".format(self._clusters.n_clusters)
+        ax.scatter(self.sample_points[:, 0],self.sample_points[:, 1], marker="+", s=100, linewidths=2,
+                   color="black", zorder=10)
+        title = f"The site grid colored in {self._clusters.n_clusters} clusters"
         ax.set_title(title)
         fig.set_dpi(300)
         fig.set_size_inches(10, 10)
@@ -470,6 +429,7 @@ class SurfaceGrid:
         plt.cla()
         plt.close("all")
 
+
     def set_sample(self, sample_points, keep_old_sample=True):
         """
         手动设置采样格点，计算 self._sample_vector。z 坐标自动被忽略。
@@ -482,7 +442,15 @@ class SurfaceGrid:
         new_sample_points = sample_points.copy()
         new_sample_points[:, 2] = z
         # 计算 vector
-        DAga, Dga = get_distances(new_sample_points, self.atoms.positions, cell=self.atoms.cell, pbc=self.atoms.pbc)
+        if self._subtype == 'slab':
+            pbc = [True, True, False]
+        elif self._subtype == 'cluster':
+            pbc = [False, False, False]
+        else:
+            pbc = self.atoms.pbc
+        DAga, Dga = get_distances(new_sample_points, self.atoms.positions,
+                                  cutoff=self.cutoff,
+                                  cell=self.atoms.cell, pbc=pbc)
         # 计算 points 的 vector
         vector = self.vectorize(Dga=Dga, pca=self.lpca)
         if keep_old_sample and self.sample_points is not None:

{surface_construct-0.6 → surface_construct-0.7}/surface_construct/utils.py

@@ -1,17 +1,15 @@
 import itertools
-from distutils.command.sdist import sdist
-from enum import unique
 
+import ase
+import ase.geometry
 import numpy as np
-from ase.data import covalent_radii, vdw_radii, chemical_symbols
+from ase.data import vdw_radii, chemical_symbols
 from ase.neighborlist import natural_cutoffs
-from numpy import dtype
-from numpy.ma.core import nonzero
-from scipy.spatial import ConvexHull, cKDTree
-from skimage.measure import marching_cubes
-import ase
 from ase.visualize import view
-import ase.geometry
+from networkx.algorithms.cuts import volume
+from scipy.sparse import coo_matrix
+from scipy.spatial import ConvexHull, cKDTree, Delaunay
+from skimage.measure import marching_cubes
 
 
 def calc_hull_vertices(v):
@@ -48,9 +46,10 @@ def get_calc_info(calc=None):
     }
     return calc_info
 
-def get_distances(p1, p2=None, cutoff=10, cell=None, use_ase=False):
+def get_distances(p1, p2=None, cutoff=10, cell=None, pbc=None, use_ase=False):
     """
     计算位点周围原子的距离，参考 ase.geometry.get_distances. 对于更大的体系使用 cDTree 来计算。
+    :param pbc:
     :param p1: grid positions
     :param p2: atoms.positions
     :param cutoff: 截断半径，只考虑距离之内的距离，超过该距离的定为 np.inf
@@ -58,8 +57,11 @@ def get_distances(p1, p2=None, cutoff=10, cell=None, use_ase=False):
     :param use_ase: 如果 use_ase is True，则使用 ase.geometry.get_distances，即周期性条件等价的原子只考虑一次
     :return:
     """
-    pbc = cell.lengths() < (cutoff * 2)
-    if not np.any(pbc):
+    ncell = np.floor((cutoff * 2) / cell.lengths())
+    for ip,p in enumerate(pbc):
+        if not p:  # 如果不是周期性的，则不要重复
+            ncell[ip] = 0
+    if np.all(ncell==1):
         use_ase = True
 
     if use_ase:
@@ -68,7 +70,7 @@ def get_distances(p1, p2=None, cutoff=10, cell=None, use_ase=False):
     if p2 is None:
         p2 = p1.copy()
 
-    ranges = [np.arange(-1 * p, p + 1) for p in pbc]
+    ranges = [np.arange(-1 * p, p + 1) for p in ncell]
     hkls = np.array(list(itertools.product(*ranges)))
     hkls = np.concatenate([hkls, np.zeros([hkls.shape[0], 3-hkls.shape[1]], dtype=int)], axis=1)
     vrvecs = hkls @ cell
@@ -76,13 +78,14 @@ def get_distances(p1, p2=None, cutoff=10, cell=None, use_ase=False):
     tree1 = cKDTree(p1, copy_data=True)
     tree2 = cKDTree(p2, copy_data=True)
     sdm = tree1.sparse_distance_matrix(tree2, max_distance=cutoff)
+    dist = sdm.toarray()
     # set 0 to np.inf
-    s = sdm.copy()
-    for k in s.keys():
-        s[k] = np.inf
-    np.seterr(divide='ignore')
-    s = np.divide(1, s.toarray())
-    dist = sdm.toarray() + s
+    mask = dist==0
+    #for k in sdm.keys():
+    #    sdm[k] = np.inf
+    #np.seterr(divide='ignore')
+    #s = np.divide(1, sdm.toarray())
+    dist[mask] = np.inf
     return None, dist
 
 class GridGenerator:
@@ -109,10 +112,18 @@ class GridGenerator:
         self.interval = interval
 
         if subtype is None:
-            if not np.all(atoms.pbc):
+            npbc = sum(atoms.pbc)
+            if npbc == 0:
                 self.subtype = 'cluster'
-            else:
+            elif npbc == 2:
+                if atoms.pbc[-1]:
+                    raise "Error: Slab should in xy direction!"
+                self.subtype = 'slab'
+            elif npbc == 3:
                 self.subtype = 'bulk'
+            else:
+                raise NotImplementedError("Subtype not implemented yet!")
+
         elif subtype.lower() in ['slab', 'bulk', 'cluster']:
             self.subtype = subtype.lower()
         else:
@@ -161,9 +172,10 @@ class GridGenerator:
         # 格点生成
         grid_x, grid_y, grid_z = np.meshgrid(xarray, yarray, zarray, indexing='ij')
         xyz = np.asarray([grid_x.ravel(), grid_y.ravel(), grid_z.ravel()]).T
+        xyz = rattle(xyz, stdev=self.interval/3)
         grid_tree = cKDTree(xyz, copy_data=True)
 
-        dist_sum = 0
+        dist_max = coo_matrix((1,nx*ny*nz))
         atoms_num_type = set(atoms.numbers)
         # 对于不同的原子类型取不同的半径
         for num_type in atoms_num_type:
@@ -176,9 +188,9 @@ class GridGenerator:
             sdm0 = atoms_tree.sparse_distance_matrix(grid_tree, max_distance=0)
             for k in sdm0.keys():
                 sdm[k] = 1
-            dist_sum = sdm.toarray().sum(axis=0).reshape((nx, ny, nz)) + dist_sum
-
-        verts, faces, normals, values = marching_cubes(dist_sum, 0, allow_degenerate=False)
+            dist_max = sdm.tocoo().nanmax(axis=0).maximum(dist_max)
+        dist_max = dist_max.transpose().toarray()
+        verts, faces, normals, values = marching_cubes(dist_max.reshape((nx, ny, nz)), 0, allow_degenerate=False)
         verts = np.asarray(verts, dtype=int)
         unique_verts = np.unique(verts,axis=0)  # exclude some repeat points
         # _points = np.asarray([[grid_x[i,j,k],grid_y[i,j,k],grid_z[i,j,k]] for i, j, k in unique_verts[:]])  # 校验数值
@@ -203,7 +215,7 @@ class GridGenerator:
         nx, ny, nz = map(len, [fx_list, fy_list, fz_list])
         fgrid_x, fgrid_y, fgrid_z = np.meshgrid(fx_list, fy_list, fz_list, indexing='ij')
         fxyz = np.asarray([fgrid_x.ravel(), fgrid_y.ravel(), fgrid_z.ravel()]).T
-        xyz = atoms.cell.cartesian_positions(fxyz)
+        xyz = rattle(atoms.cell.cartesian_positions(fxyz), stdev=self.interval/3)
         grid_tree = cKDTree(xyz, copy_data=True)
 
         # 对atoms 在 xy 方向超胞. Adapt from ase.geometry.geometry.general_find_mic
@@ -215,7 +227,7 @@ class GridGenerator:
         super_num = np.concatenate([atoms.numbers] * 9)
         rsub = np.concatenate([self.rsub] * 9)
 
-        dist_sum = 0
+        dist_max = coo_matrix((1,nx*ny*nz))
         atoms_num_type = set(atoms.numbers)
         # 对于不同的原子类型取不同的半径
         for num_type in atoms_num_type:
@@ -228,9 +240,9 @@ class GridGenerator:
             sdm0 = atoms_tree.sparse_distance_matrix(grid_tree, max_distance=0)
             for k in sdm0.keys():
                 sdm[k] = 1
-            dist_sum = sdm.toarray().sum(axis=0).reshape((nx, ny, nz)) + dist_sum
-
-        verts, faces, normals, values = marching_cubes(dist_sum, 0, allow_degenerate=False)
+            dist_max = sdm.tocoo().nanmax(axis=0).maximum(dist_max)
+        dist_max = dist_max.transpose().toarray()
+        verts, faces, normals, values = marching_cubes(dist_max.reshape((nx, ny, nz)), 0, allow_degenerate=False)
         verts = np.asarray(verts, dtype=int)
         unique_verts = np.unique(verts,axis=0)  # exclude some repeat points
         fpoints = np.asarray([fgrid_x[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]],
@@ -253,3 +265,32 @@ class GridGenerator:
         if len(self.grid) > 10000:
             print("Too much grid number, it will be very slow.")
         view(self.atoms + ase.Atoms(symbols=['X'] * len(self.grid), positions=self.grid))
+
+
+def rattle(positions, stdev=0.001, rng=None, seed=None):
+    """Rattle the grid to make the vector distribution more smooth.
+    Adapt from ase.Atoms.rattle
+    """
+    if seed is not None and rng is not None:
+        raise ValueError('Please do not provide both seed and rng.')
+    if rng is None:
+        if seed is None:
+            seed = 42
+        rng = np.random.RandomState(seed)
+    return positions + rng.normal(scale=stdev, size=positions.shape)
+
+
+def furthest_sites(points, n):
+    # return the n sites that covers the max volume
+    assert n < len(points)
+    combs = list(itertools.combinations(range(len(points)), n))
+    volumes = []
+    if n==2:
+        for c in combs:
+            volumes.append(np.linalg.norm(points[c[0]] - points[c[1]]))
+    elif n>2:
+        for c in combs:
+            pp = [points[i] for i in c]
+            volumes.append(ConvexHull(pp).volume)
+    idx = combs[np.argmax(volumes)]
+    return idx

{surface_construct-0.6 → surface_construct-0.7/surface_construct.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: surface_construct
-Version: 0.6
+Version: 0.7
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren
@@ -20,6 +20,7 @@ Requires-Dist: tqdm
 Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: scikit-learn
+Requires-Dist: scikit-image
 
 # 基于分层采样策略的催化剂表面位点全局分析
 

{surface_construct-0.6 → surface_construct-0.7}/surface_construct.egg-info/requires.txt

@@ -7,3 +7,4 @@ tqdm
 matplotlib
 scipy
 scikit-learn
+scikit-image