surface-construct 0.8.1__tar.gz → 0.8.4__tar.gz

{surface_construct-0.8.1/surface_construct.egg-info → surface_construct-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: surface_construct
-Version: 0.8.1
+Version: 0.8.4
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren
@@ -13,14 +13,20 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ase
 Requires-Dist: networkx
-Requires-Dist: numpy
 Requires-Dist: spglib
 Requires-Dist: pandas
 Requires-Dist: tqdm
-Requires-Dist: matplotlib
-Requires-Dist: scipy
 Requires-Dist: scikit-learn
 Requires-Dist: scikit-image
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # 基于分层采样策略的催化剂表面位点全局分析
 

{surface_construct-0.8.1 → surface_construct-0.8.4}/setup.py

@@ -6,19 +6,16 @@ with open("README.md", "r", encoding='utf-8') as f:
 install_requires = [
     'ase',
     'networkx',
-    'numpy',
     'spglib',
     'pandas',
     'tqdm',
-    'matplotlib',
-    'scipy',
     'scikit-learn',
     'scikit-image'
 ]
 
 setup(
     name='surface_construct',
-    version='0.8.1',
+    version='0.8.4',
     packages=['surface_construct'],
     url='https://gitee.com/pjren/surface_construct/',
     license='GPL',

{surface_construct-0.8.1 → surface_construct-0.8.4}/surface_construct/sampling.py

@@ -1,17 +1,37 @@
 """
 TODO: 关键点采样：top 位置、hollow位，bridge 位等等。
 """
-from logging import warning
-
+import itertools
 import numpy as np
 from ase.geometry import get_distances
-from scipy.spatial import ConvexHull
+from scipy.spatial import ConvexHull, cKDTree
 from scipy.spatial.distance import cdist
+from scipy.special import comb
 from sklearn.cluster import KMeans as Cluster
 import random
 
 from surface_construct.utils import furthest_sites
 
+MIN_HULL_ANGLE_COS = np.cos(np.pi * 30 / 180)
+
+def hull_vertices(hull):
+    hsimplices = hull.simplices
+    hvertices = hull.vertices
+    hnorms = hull.equations[:,0:-1]
+    ndim = hsimplices.shape[1]
+    vertices = []
+    # 去掉 hull 的 simplices 的角度较大的点
+    for i in hvertices:
+        p0_facets_idx = np.argwhere(hsimplices == i)[:,0]
+        p0_norms = hnorms[p0_facets_idx]
+        cosangle = lambda a,b: a.dot(b) / (np.linalg.norm(a) * np.linalg.norm(b))
+        # 求 i 凸点相邻的超平面的法向向量之间的夹角。如果存在夹角小于30度，即平面之间的夹角大于150度，则排除该点。反之，保留该点。
+        norm_angle_cos = np.absolute([cosangle(a,b) for a,b in itertools.combinations(p0_norms, 2)])
+        if np.sum(norm_angle_cos < MIN_HULL_ANGLE_COS) >= comb(ndim,2):
+            vertices.append(i)
+
+    return vertices
+
 
 def addition_samples(sg_obj, size=None, probability=None, **kwargs):
     if 'seed' in kwargs:
@@ -51,6 +71,7 @@ def addition_samples(sg_obj, size=None, probability=None, **kwargs):
 class SamplingBase:
     def __init__(self, sg_obj, **kwargs):
         self.sg_obj = sg_obj
+        self.threshold = kwargs.get('threshold', 0.37)  # 0.37 is half of H-H bond
 
     @property
     def _pop_size(self):
@@ -89,21 +110,46 @@ class SamplingBase:
 
         return point_idx
 
+    def exclude_too_close_sample(self, idx_list, threshold=None):
+        if threshold is None:
+            threshold = self.threshold
+        if self.sg_obj.sample_idx:
+            unique_idx_list = [i for i in idx_list if i not in self.sg_obj.sample_idx]
+            points = list(self.sg_obj.sample_points)
+        else:
+            unique_idx_list = idx_list[:]
+            points = []
+        new_idx_list = []
+        for idx in unique_idx_list:
+            p = self.sg_obj.points[idx]
+            if len(points) == 0:
+                points.append(p)
+                new_idx_list.append(idx)
+                continue
+            tree = cKDTree(points)
+            if len(tree.query_ball_point(x=p, r=threshold,p=2))==0:
+                points.append(p)
+                new_idx_list.append(idx)
+
+        if len(new_idx_list) != idx_list:
+            print(f"Exclude too close sample {set(idx_list)-set(new_idx_list)}")
+        return new_idx_list
 
 class KeyPointSampling(SamplingBase):
     """
-    基本思路：先定位 hollow位，再根据图论分析定位 bridge 位，最后定位top位。第二步，筛选等价位点。
-    需要一个基础func，从xy坐标，找到对应的格点。
+    关键点采样，使用 vip_id
     """
-    def _samples(self, size, **kwargs):
-        pass
+    def _samples(self, **kwargs):
+        sample_idx = self.sg_obj.unique_vip_id
+        clusters = Cluster(n_clusters=len(sample_idx)).fit(self.sg_obj.vector)
+        self.sg_obj._clusters = clusters
+        return sample_idx
 
 
 class RandomSampling(SamplingBase):
     """
     完全随机的选择点，仅用于测试，效率太低。
     """
-
     def __init__(self, sg_obj, **kwargs):
         super().__init__(sg_obj, **kwargs)
         if 'seed' in kwargs:
@@ -121,7 +167,6 @@ class MaxSigmaSampling(SamplingBase):
     """
     对最大误差的点进行采样
     """
-
     def _samples(self, size, **kwargs):
         if 'energy' in self.sg_obj.grid_property:
             # 如果已经读入了一些能量，则返回误差最大的点
@@ -133,59 +178,32 @@ class MaxSigmaSampling(SamplingBase):
 
 class InitialSampling(SamplingBase):
     """
-    使用聚类-分层采样进行初始采样
+    结合使用 KeyPointSampling 和 MaxDiversitySampling
     """
 
     def _samples(self, size, **kwargs):
-        hull = ConvexHull(self.sg_obj.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.sg_obj._vector_unit *
-                                           self.sg_obj.interval)**self.sg_obj.vector.shape[1]) + 1
-        cluster0 = Cluster(n_clusters=n_vector_mesh)
-        cluster0.fit(self.sg_obj.vector)
-        mesh_centers = cluster0.cluster_centers_
-        self.sg_obj._mesh_centers = mesh_centers
-        cluster = Cluster(n_clusters=size)
-        cluster.fit(mesh_centers)
-        self.sg_obj._clusters = cluster
-        nvert = len(vertices)
-        if nvert >= size:
-            warning("Sample number better be larger than {nvert}!")
-            if size == 1:
-                sample_idx = np.random.choice(vertices,1)
-            else:
-                sample_idx = [vertices[i] for i in
-                              furthest_sites(self.sg_obj.vector[vertices], size)]
-        else:
-            # 聚类
-            cluster2 = Cluster(n_clusters=size-nvert)
-            cluster2.fit(mesh_centers)
-            center_dist = cdist(cluster2.cluster_centers_, self.sg_obj.vector)  # 计算每个点到中心的距离
-            sample_idx = vertices + np.argmin(center_dist, axis=-1).tolist()
+        vip_idx = self.sg_obj.unique_vip_id
+        clusters = Cluster(n_clusters=len(vip_idx)).fit(self.sg_obj.vector)
+        self.sg_obj._clusters = clusters
+        # 如果 size 小于 vip，则从中随机选取部分
+        if size == len(vip_idx):
+            sample_idx = vip_idx
+            self._append_sample_to_sg(point_idx=sample_idx)
+        elif size < len(vip_idx):
+            print("Warning: The initial sampling size is smaller than the number of key points")
+            rng = np.random.default_rng()
+            comb_vip = list(itertools.combinations(vip_idx, size))
+            sample_idx = rng.choice(comb_vip)
+            self._append_sample_to_sg(point_idx=sample_idx)
+        else: # 如果 size 大于 vip，则需要 MaxDiversitySampling 新增一些点
+            self._append_sample_to_sg(point_idx=vip_idx)  # 先增加进去vip 点作为已经采样的点，再进行最大多样性采样
+            adding_sample = MaxDiversitySampling(self.sg_obj).samples(size=size-len(vip_idx), **kwargs)
+            self._append_sample_to_sg(point_idx=adding_sample)
+            sample_idx = np.concatenate([vip_idx, adding_sample])
         return sample_idx
 
-    def _append_sample_to_sg(self, point_idx=None):
-        """
-        将采样点加入到 sg_obj.sample_points 和相应的 vector
-        :return:
-        """
-        if point_idx is not None:
-            self.sg_obj.sample_idx = np.asarray(point_idx)
-            self.sg_obj._sample_vector = self.sg_obj.vector[point_idx]
-            self.sg_obj.sample_points = self.sg_obj.points[point_idx]
-
+    def samples(self, size=1, **kwargs):
+        return self._samples(size=size, **kwargs)
 
 class MaxDiversitySampling(SamplingBase):
     """
@@ -195,8 +213,7 @@ class MaxDiversitySampling(SamplingBase):
         * 判断已经采样点属于的类别，找出没有点的类别，空类
         * 如果空类不止一个，比较这些空类中心与旧点的距离，选择距离最大的点。
     """
-
-    def _samples(self, size, center=False, **kwargs):
+    def _samples(self, size, center=True, **kwargs):
         """
 
         :param size:
@@ -206,37 +223,43 @@ class MaxDiversitySampling(SamplingBase):
         """
         # 判断是否有过往的采样点，如果没有，调用 InitialSampling
         if self.sg_obj.sample_idx is None:
-            raise "Please add initial samples (e.g. InitialSampling) before invoke this method!"
-        cluster_size = len(self.sg_obj.sample_idx) + size
-        nvirgin = 0
-        larger_clusters = None
-        larger_virgin = None
-        virgin = None
-        clusters = None
-        # 如果等于则停止，并保存 cluster
-        while nvirgin != size:
-            # 以 len(sample_idx) + size 作为新的聚类的size
-            clusters = Cluster(n_clusters=cluster_size).fit(self.sg_obj.vector)
-            labels = clusters.labels_[self.sg_obj.sample_idx]
-            labels_set = set(labels)
-            virgin = set(range(cluster_size)) - labels_set
-            nvirgin = len(virgin)
-            # 判断分类以后空类数目与size的大小
-            # 如果大于size，则减小size，并记录空类的数目
-            if nvirgin > size:
-                cluster_size -= 1
-                larger_clusters = clusters
-                larger_virgin = virgin
-            # 如果小于 size 则增大size，检查上一个size是否有记录，如果有记录则使用上个size 的记录。从中随机选择size个点作为采样点。
-            elif nvirgin < size:
-                cluster_size += 1
-                if larger_clusters is not None:
-                    clusters = larger_clusters
-                    virgin = larger_virgin
-                    break
+            clusters = Cluster(n_clusters=size).fit(self.sg_obj.vector)
+            virgin = list(set(clusters.labels_))
+        else:
+            cluster_size = len(self.sg_obj.sample_idx) + size
+            nvirgin = 0
+            larger_clusters = None
+            larger_virgin = None
+            virgin = None
+            clusters = None
+            # 如果等于则停止，并保存 cluster
+            while nvirgin != size:
+                # 以 len(sample_idx) + size 作为新的聚类的size
+                clusters = Cluster(n_clusters=cluster_size).fit(self.sg_obj.vector)
+                labels = clusters.labels_[self.sg_obj.sample_idx]
+                labels_set = set(labels)
+                virgin = set(range(cluster_size)) - labels_set
+                nvirgin = len(virgin)
+                # 判断分类以后空类数目与size的大小
+                # 如果大于size，则减小size，并记录空类的数目
+                if nvirgin > size:
+                    cluster_size -= 1
+                    larger_clusters = clusters
+                    larger_virgin = virgin
+                # 如果小于 size 则增大size，检查上一个size是否有记录，如果有记录则使用上个size 的记录。从中随机选择size个点作为采样点。
+                elif nvirgin < size:
+                    cluster_size += 1
+                    if larger_clusters is not None:
+                        clusters = larger_clusters
+                        virgin = larger_virgin
+                        break
         # 从 virgin 里面选取 size 个点
         rng = np.random.default_rng()
-        cluster_idx = rng.choice(list(virgin), size=size)
+        comb_vip = list(itertools.combinations(list(virgin), size))
+        cluster_idx = rng.choice(comb_vip)
+        if (not center) and 'energy' not in self.sg_obj.grid_property:
+            center = True
+            print("Warning: Can't get cluster minimum energy, use cluster center instead!")
         if center:
             # 取中心位置的格点
             centers = clusters.cluster_centers_[cluster_idx]
@@ -248,11 +271,10 @@ class MaxDiversitySampling(SamplingBase):
             for c_id in cluster_idx:
                 p_idx = np.arange(len(self.sg_obj.points))[clusters.labels_ == c_id]
                 # 求这些点的能量最小值
-                if 'energy' not in self.sg_obj.grid_property:
-                    raise NotImplementedError
                 p_energy = self.sg_obj.grid_energy[p_idx]
                 point_idx.append(p_idx[p_energy.argmin()])
-
+        # assign cluster to sg_obj
+        self.sg_obj._clusters = clusters
         return point_idx
 
 
@@ -269,10 +291,6 @@ class RandomWalk(SamplingBase):
     """
     从给定点出发随机行走进行采样
     """
-
-    def __init__(self, sg_obj=None, probability=1.0, **kwargs):
-        super().__init__(sg_obj, probability, **kwargs)
-
     def _samples(self, size, **kwargs):
         raise NotImplementedError
 
@@ -281,7 +299,6 @@ class SystematicSampling(SamplingBase):
     """
     等距采样。主要用于测试。
     """
-
     def _samples(self, size, **kwargs):
         if 'start' in kwargs:
             start = kwargs['start']