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

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

@@ -1,13 +1,12 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: surface_construct
-Version: 0.8.4
+Version: 0.9.1
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren
 Author-email: 0403114076@163.com
 License: GPL
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -25,6 +24,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

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

@@ -1,4 +1,4 @@
-from setuptools import setup
+from setuptools import setup, find_packages
 
 with open("README.md", "r", encoding='utf-8') as f:
     long_description = f.read()
@@ -15,8 +15,8 @@ install_requires = [
 
 setup(
     name='surface_construct',
-    version='0.8.4',
-    packages=['surface_construct'],
+    version='0.9.1',
+    packages=find_packages(),
     url='https://gitee.com/pjren/surface_construct/',
     license='GPL',
     author='ren',
@@ -27,7 +27,6 @@ setup(
     install_requires=install_requires,
     classifiers=[
         "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
         "Operating System :: OS Independent",
     ],
 )

surface_construct-0.9.1/surface_construct/__init__.py

@@ -0,0 +1,12 @@
+from surface_construct.structures.surface import Crystal, Surface, Slab, Termination
+from surface_construct.structures.surface import get_terminations_score
+from surface_construct.structures.surface_grid import SurfaceGrid, GridGenerator
+
+
+__all__ = ['SurfaceGrid',
+           'GridGenerator',
+           'Crystal',
+           'Surface',
+           'Slab',
+           'Termination',
+           ]

{surface_construct-0.8.4 → surface_construct-0.9.1}/surface_construct/db.py

@@ -6,7 +6,7 @@ from ase.db.core import now
 from ase.io.jsonio import write_json, read_json
 import os
 from ase.db.row import AtomsRow, row2dct
-from surface_construct.atoms import get_atoms_topo_id
+from surface_construct.utils.atoms import get_atoms_topo_id
 from surface_construct.utils import calc_hull_vertices, get_calc_info
 
 """

surface_construct-0.8.4/surface_construct/sampling.py → surface_construct-0.9.1/surface_construct/sg_sampler.py

@@ -1,36 +1,12 @@
-"""
-TODO: 关键点采样：top 位置、hollow位，bridge 位等等。
-"""
-import itertools
 import numpy as np
-from ase.geometry import get_distances
-from scipy.spatial import ConvexHull, cKDTree
+from scipy.spatial import 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 name2sampler(name):
+    return globals()[name]
 
 
 def addition_samples(sg_obj, size=None, probability=None, **kwargs):
@@ -58,9 +34,9 @@ def addition_samples(sg_obj, size=None, probability=None, **kwargs):
     for method in method_list:
         method_lower = method.lower()
         if method_lower == 'max_sigma':
-            sampling_obj = MaxSigmaSampling(sg_obj)
+            sampling_obj = MaxSigmaSGSampler(sg_obj)
         elif method_lower == 'max_diversity':
-            sampling_obj = MaxDiversitySampling(sg_obj)
+            sampling_obj = MaxDiversitySGSampler(sg_obj)
         else:
             raise NotImplementedError
         point_idx = np.concatenate([point_idx, sampling_obj.samples(size=1, **kwargs)])  # 每种方法只采一个
@@ -68,10 +44,12 @@ def addition_samples(sg_obj, size=None, probability=None, **kwargs):
     return point_idx
 
 
-class SamplingBase:
+class SGSamplerBase:
     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
+        self.weight = kwargs.get('weight', 1.0)  # 采样的几率，最后进行归一化处理
+        self.kwargs = kwargs
 
     @property
     def _pop_size(self):
@@ -91,29 +69,34 @@ class SamplingBase:
 
         :return:
         """
-        if point_idx is not None:
-            if self.sg_obj.sample_idx is not None:
-                self.sg_obj.sample_idx = np.concatenate([self.sg_obj.sample_idx, point_idx])
-                self.sg_obj._sample_vector = np.concatenate([self.sg_obj._sample_vector, self.sg_obj.vector[point_idx]])
-                self.sg_obj.sample_points = np.concatenate([self.sg_obj.sample_points, self.sg_obj.points[point_idx]])
-            else:
-                self.sg_obj.sample_idx = np.array(point_idx)
-                self.sg_obj._sample_vector = self.sg_obj.vector[point_idx]
-                self.sg_obj.sample_points = self.sg_obj.points[point_idx]
+        if point_idx is None:
+            point_idx = []
+        elif type(point_idx) is int:
+            point_idx = [point_idx]
+
+        for p in point_idx:
+            self.sg_obj.sample_idx = p
 
     def _samples(self, size, **kwargs):
         raise NotImplementedError
 
     def samples(self, size=1, **kwargs):
-        point_idx = self._samples(size=size, **kwargs)
-        self._append_sample_to_sg(point_idx=point_idx)
-
-        return point_idx
+        result = []
+        curr_size = size
+        loop = 0
+        while len(result) < size and loop < 10:
+            point_idx = self._samples(size=curr_size, **kwargs)
+            filtered_idx = self.exclude_too_close_sample(point_idx)
+            self._append_sample_to_sg(point_idx=filtered_idx)
+            result += filtered_idx
+            curr_size = size - len(filtered_idx)
+            loop += 1
+        return result
 
     def exclude_too_close_sample(self, idx_list, threshold=None):
         if threshold is None:
             threshold = self.threshold
-        if self.sg_obj.sample_idx:
+        if self.sg_obj.sample_idx is not None:
             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:
@@ -131,11 +114,11 @@ class SamplingBase:
                 points.append(p)
                 new_idx_list.append(idx)
 
-        if len(new_idx_list) != idx_list:
+        if len(new_idx_list) != len(idx_list):
             print(f"Exclude too close sample {set(idx_list)-set(new_idx_list)}")
         return new_idx_list
 
-class KeyPointSampling(SamplingBase):
+class KeyPointSGSampler(SGSamplerBase):
     """
     关键点采样，使用 vip_id
     """
@@ -145,8 +128,13 @@ class KeyPointSampling(SamplingBase):
         self.sg_obj._clusters = clusters
         return sample_idx
 
+    def samples(self, size=None, **kwargs):
+        point_idx = self._samples(**kwargs)
+        filtered_idx = self.exclude_too_close_sample(point_idx)
+        self._append_sample_to_sg(point_idx=filtered_idx)
+        return filtered_idx
 
-class RandomSampling(SamplingBase):
+class RandomSGSampler(SGSamplerBase):
     """
     完全随机的选择点，仅用于测试，效率太低。
     """
@@ -158,54 +146,71 @@ class RandomSampling(SamplingBase):
             self.seed = None
 
     def _samples(self, size, **kwargs):
-        rng = np.random.default_rng(self.seed)
-        pop_idx = rng.choice(self._population, size=size)
-        return pop_idx
+        idx = random.sample(self._population, size)
+        return idx
 
 
-class MaxSigmaSampling(SamplingBase):
+class MaxSigmaSGSampler(SGSamplerBase):
     """
     对最大误差的点进行采样
     """
     def _samples(self, size, **kwargs):
         if 'energy' in self.sg_obj.grid_property:
             # 如果已经读入了一些能量，则返回误差最大的点
-            idx = self.sg_obj.grid_property_sigma['energy'].argmax()
-            return [idx]
+            sigma_array = self.sg_obj.grid_property['energy']
+            sigma0 = sigma_array.max()
+            idx_list = np.argwhere(sigma_array <= sigma0-0.1).flatten().tolist()
+            idx = random.sample(idx_list, size)
+            return idx
         else:
             raise "No energy for all population, pls do initial sampling first!"
 
 
-class InitialSampling(SamplingBase):
+class MinEnergySGSampler(SGSamplerBase):
     """
-    结合使用 KeyPointSampling 和 MaxDiversitySampling
+    对最大误差的点进行采样
     """
-
     def _samples(self, size, **kwargs):
+        if 'energy' in self.sg_obj.grid_property:
+            E_array = self.sg_obj.grid_property['energy']
+            # 如果已经读入了一些能量，则返回能量最低的点 (<0.1eV 以内，然后随机选一个)
+            E0 = E_array.min()
+            idx_list = np.argwhere(E_array <= E0+0.1).flatten().tolist()
+            idx = random.sample(idx_list, size)
+            return idx
+        else:
+            raise "No energy for all population, pls do initial sampling first!"
+
+
+class InitialSGSampler(SGSamplerBase):
+    """
+    结合使用 KeyPointSampling 和 MaxDiversitySampling
+    """
+    def _samples(self, size=None, **kwargs):
+        # 先进行 KeyPoint sampling，数量不够再进行 Max diversity sampling
         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 is None:
+            size = len(vip_idx)
+
         if size == len(vip_idx):
-            sample_idx = vip_idx
-            self._append_sample_to_sg(point_idx=sample_idx)
+            # 已经排除了距离过近的点，而且已经加入到了sg_obj
+            sample_idx = KeyPointSGSampler(self.sg_obj, **self.kwargs).samples(**kwargs)
         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)
+            print(f"The initial sampling size {size} is smaller than the number of key points {len(vip_idx)}.")
+            sample_idx = random.sample(vip_idx, size)
             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])
+        else:
+            sample_idx = KeyPointSGSampler(self.sg_obj, **self.kwargs).samples(**kwargs)
+            while len(sample_idx) < size:
+                adding_sample = MaxDiversitySGSampler(self.sg_obj).samples(size=size-len(sample_idx),**kwargs)
+                sample_idx = np.concatenate([sample_idx, adding_sample])
         return sample_idx
 
     def samples(self, size=1, **kwargs):
         return self._samples(size=size, **kwargs)
 
-class MaxDiversitySampling(SamplingBase):
+
+class MaxDiversitySGSampler(SGSamplerBase):
     """
     对当前采样结构差异最大的点进行采样
     基本思路是这样的：
@@ -215,14 +220,13 @@ class MaxDiversitySampling(SamplingBase):
     """
     def _samples(self, size, center=True, **kwargs):
         """
-
         :param size:
         :param center: 是否取中心。如果不是，则取能量最小值的点。如果没有能量则报错。
         :param kwargs:
         :return:
         """
         # 判断是否有过往的采样点，如果没有，调用 InitialSampling
-        if self.sg_obj.sample_idx is None:
+        if len(self.sg_obj.sample_idx) == 0:
             clusters = Cluster(n_clusters=size).fit(self.sg_obj.vector)
             virgin = list(set(clusters.labels_))
         else:
@@ -254,9 +258,7 @@ class MaxDiversitySampling(SamplingBase):
                         virgin = larger_virgin
                         break
         # 从 virgin 里面选取 size 个点
-        rng = np.random.default_rng()
-        comb_vip = list(itertools.combinations(list(virgin), size))
-        cluster_idx = rng.choice(comb_vip)
+        cluster_idx = random.sample(list(virgin), size)
         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!")
@@ -278,7 +280,7 @@ class MaxDiversitySampling(SamplingBase):
         return point_idx
 
 
-class NewtonSampling(SamplingBase):
+class NewtonSGSampler(SGSamplerBase):
     """
     沿着受力方向进行采样
     """
@@ -287,7 +289,7 @@ class NewtonSampling(SamplingBase):
         raise NotImplementedError
 
 
-class RandomWalk(SamplingBase):
+class RandomWalk(SGSamplerBase):
     """
     从给定点出发随机行走进行采样
     """
@@ -295,7 +297,7 @@ class RandomWalk(SamplingBase):
         raise NotImplementedError
 
 
-class SystematicSampling(SamplingBase):
+class SystematicSGSampler(SGSamplerBase):
     """
     等距采样。主要用于测试。
     """

surface_construct-0.9.1/surface_construct/structures/__init__.py

@@ -0,0 +1,50 @@
+class AdsGridCombiner:
+    def __init__(self, sg_obj, ads_obj,
+                 **kwargs):
+        """
+        :param sg_obj: 表面格点
+        :param ads_obj: 吸附分子，包含Atoms，主轴，内坐标列表，根据这些参数可以得到分子坐标
+        :param kwargs:
+        """
+        self.atoms = None
+        self.sg_obj = sg_obj
+        self.ads_obj = ads_obj
+        self.kwargs = kwargs
+        if self.sg_obj.atoms.calc is not None:
+            self.calc = self.sg_obj.atoms.calc
+        else:
+            if self.ads_obj.atoms.calc is not None:
+                self.calc = self.ads_obj.atoms.calc
+            else:
+                self.calc = None
+
+    def get_atoms(self, grid_idx=None,**kwargs):
+        """
+        将分子放置于 grid_idx 格点上
+        :param grid_idx: 格点序号。默认是随机idx。
+        :return: 组合后的 Atoms
+        """
+        attitude = kwargs.get('attitude') # 分子姿态，分子主轴的夹角
+        internal_coord = kwargs.get('internal_coord')  # 分子内坐标
+        ads_atoms = self.ads_obj.atoms.copy()
+        # TODO: 先进性 rotate and 改变分子构象
+        site = self.sg_obj.points[grid_idx]
+        # TODO: get_z 去更新 site 的坐标
+        site = self._get_z(site, ads_atoms)
+        ads_atoms.set_positions(ads_atoms.get_positions() +
+                                (site - ads_atoms.get_center_of_mass()))
+
+        atoms = self.sg_obj.atoms.copy()
+        atoms += ads_atoms
+        atoms.calc = self.calc
+        self.atoms = atoms
+        return atoms
+
+    def _get_z(self, xyz0, ads_atoms):
+        """
+        由于分子可能会与表面冲突，调整分子的高度可以避免
+        事实上调整的是沿着格点法向向量的距离 xyz = xyz0 + r×d
+        :return:
+        """
+        xyz = xyz0
+        return xyz

surface_construct-0.9.1/surface_construct/structures/adsorbate.py

@@ -0,0 +1,38 @@
+import numpy as np
+from ase import Atoms
+
+class Adsorbate:
+    """
+    吸附分子的类，包含质心，内坐标，主轴
+    """
+    def __init__(self, atoms, **kwargs):
+        # TODO：加上半径的参数，计算分子半径
+        self.atoms = atoms
+        self.internal_coords = dict()
+        self.kwargs = kwargs
+        self._rads = 0.76 # 默认是碳原子的共价半径
+
+    @property
+    def com(self):
+        return self.atoms.center_of_mass()
+
+    @property
+    def principal_axis(self):
+        # 分子主轴向量
+        evals, evecs = self.atoms.get_moments_of_inertia(vectors=True)
+        return evecs[np.argmin(np.abs(evals))]
+
+    @property
+    def rads(self):
+        # 分子的半径，sg_obj 构造时作为参考
+        # TODO: 计算分子半径
+        return self._rads
+
+    @rads.setter
+    def rads(self, value):
+        self._rads = value
+
+    @property
+    def natoms(self):
+        return len(self.atoms)
+