surface-construct 0.10.2__tar.gz → 0.11__tar.gz

{surface_construct-0.10.2/surface_construct.egg-info → surface_construct-0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: surface_construct
-Version: 0.10.2
+Version: 0.11
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren
@@ -34,6 +34,21 @@ Dynamic: summary
 
 本软件同时进行表面位点的构建、采样、计算、分析，和反应过程的分析采样，即过渡态和分子构象，由此可以实现分子在表面反应的全过程采样。其中的技术关键是采样的效率，我们针对性地使用综合使用了多样化的采样策略，保证表面各类型位点和关键位点的充分采样。
 
+### 应用场景
+* 催化剂表面最可能反应位点采样
+  * 适用于催化剂活性快速评价
+  * VIP 采样：位点（S，site），二面角构象（C，conformation），旋转姿态（R，rotation）
+  * 优化 C、R、Z （z方向，距离表面的距离）空间，固定COM
+  * 返回所采结构中最低能量和对应的结构和能量
+  
+* 催化剂表面全势能面采样
+  * 适用于催化剂位点全局考察
+  * 适用于表面分子全局的构象和姿态
+  * 适用于反应全过程采样
+  * 不优化，或者仅优化Z空间
+  * 返回全部能量和结构，以及全局的fitting结果
+  * 使用能量截断（dEmax<2eV）
+
 <img src="docs/birds_view.png" alt="表面位点全局分析" style="zoom:50%;" />
 
 ## 程序流程图  Program Workflow
@@ -157,6 +172,7 @@ $$
 * 计算位点 SALI （Structure-Activity Landscape Index），量化 activity cliffs，SALI = |ΔActivity| / (1 − Similarity)
 * 新增 PathSampler，用于在相邻的关键格点之间的扩散路径进行采样，使用 ase.neb.idpp 方法进行采样，使用 Delaunay 剖分找到相邻位点的路径。
 * Low-Energy Region Explorer 方法借鉴[^LoreX]: 划分能量区域， 进行 Delaunay 划分，合并较小的区域为较大的区域。然后针对低能的区域进行额外采样。也可以适用不同的方法，低精度进行低能高能区域识别，然后高精度方法加强。
+* 表面格点使用对称性进行降维。在最初期就引入对称性。参考 adsorbate rotation 思路
 * 表面位点数据库
 * 多原子体系（内坐标受限体系）
 * 完善用户界面、例子、教程

{surface_construct-0.10.2 → surface_construct-0.11}/README.md

@@ -4,6 +4,21 @@
 
 本软件同时进行表面位点的构建、采样、计算、分析，和反应过程的分析采样，即过渡态和分子构象，由此可以实现分子在表面反应的全过程采样。其中的技术关键是采样的效率，我们针对性地使用综合使用了多样化的采样策略，保证表面各类型位点和关键位点的充分采样。
 
+### 应用场景
+* 催化剂表面最可能反应位点采样
+  * 适用于催化剂活性快速评价
+  * VIP 采样：位点（S，site），二面角构象（C，conformation），旋转姿态（R，rotation）
+  * 优化 C、R、Z （z方向，距离表面的距离）空间，固定COM
+  * 返回所采结构中最低能量和对应的结构和能量
+  
+* 催化剂表面全势能面采样
+  * 适用于催化剂位点全局考察
+  * 适用于表面分子全局的构象和姿态
+  * 适用于反应全过程采样
+  * 不优化，或者仅优化Z空间
+  * 返回全部能量和结构，以及全局的fitting结果
+  * 使用能量截断（dEmax<2eV）
+
 <img src="docs/birds_view.png" alt="表面位点全局分析" style="zoom:50%;" />
 
 ## 程序流程图  Program Workflow
@@ -127,6 +142,7 @@ $$
 * 计算位点 SALI （Structure-Activity Landscape Index），量化 activity cliffs，SALI = |ΔActivity| / (1 − Similarity)
 * 新增 PathSampler，用于在相邻的关键格点之间的扩散路径进行采样，使用 ase.neb.idpp 方法进行采样，使用 Delaunay 剖分找到相邻位点的路径。
 * Low-Energy Region Explorer 方法借鉴[^LoreX]: 划分能量区域， 进行 Delaunay 划分，合并较小的区域为较大的区域。然后针对低能的区域进行额外采样。也可以适用不同的方法，低精度进行低能高能区域识别，然后高精度方法加强。
+* 表面格点使用对称性进行降维。在最初期就引入对称性。参考 adsorbate rotation 思路
 * 表面位点数据库
 * 多原子体系（内坐标受限体系）
 * 完善用户界面、例子、教程

{surface_construct-0.10.2 → surface_construct-0.11}/setup.py

@@ -15,7 +15,7 @@ install_requires = [
 
 setup(
     name='surface_construct',
-    version='0.10.2',
+    version='0.11',
     packages=find_packages(),
     url='https://gitee.com/pjren/surface_construct/',
     license='GPL',

{surface_construct-0.10.2 → surface_construct-0.11}/surface_construct/__init__.py

@@ -1,7 +1,8 @@
 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
-
+from surface_construct.structures.adsorbate import Adsorbate
+from surface_construct.structures.combiner import AdsGridCombiner
 
 __all__ = ['SurfaceGrid',
            'GridGenerator',
@@ -9,4 +10,6 @@ __all__ = ['SurfaceGrid',
            'Surface',
            'Slab',
            'Termination',
+           'Adsorbate',
+           'AdsGridCombiner',
            ]

surface_construct-0.11/surface_construct/structures/adsorbate.py

@@ -0,0 +1,384 @@
+import ase
+import numpy as np
+from typing import Tuple, Sequence, Dict, Union
+from ase.geometry.analysis import Analysis as ase_Analysis
+from ase.geometry.distance import distance as ase_distance
+from scipy.spatial import cKDTree
+
+from surface_construct.utils.atoms import atoms2graph, atoms_regulate, set_dihedrals
+from surface_construct.utils.geometry import dih_grid, sample_rotations_with_symmetry, view_samples, \
+    estimate_rotation_samples
+from surface_construct.utils.pymsym_wrapper import get_pure_rotations, get_point_group, get_Cn
+
+
+def get_dock_point_idx(atoms_pos, x_pos):
+    if len(x_pos) == 0:
+        return []
+    tree = cKDTree(atoms_pos)
+    x_tree = cKDTree(x_pos)
+    dd = tree.sparse_distance_matrix(x_tree, max_distance=2.0, p=2).toarray()
+    idx = dd.argmin(axis=0).reshape(1,-1)
+    return idx
+
+class Adsorbate:
+    """
+    吸附分子的类，类似与表面格点类，它包含了所有可能的姿态和二面角构象的离散化空间。
+    还可以计算分子的质心，内坐标，主轴。
+    """
+    def __init__(self, atoms:ase.Atoms, **kwargs):
+        # TODO：加上半径的参数，计算分子半径
+        self.atoms = atoms.copy()
+        del self.atoms[atoms.numbers == 0]
+        self.dock_point_indices = get_dock_point_idx(self.atoms.positions,
+                                                     atoms.positions[atoms.numbers == 0])
+        self._atoms_graph = None
+        self.nl = kwargs.get('nl', None)
+        self.analysis = ase_Analysis(self.atoms, nl=self.nl)
+        if self.nl is None:
+            self.nl = self.analysis.nl
+        self._adj_matrix = self.analysis.adjacency_matrix[0].toarray()
+        self.internal_coords = dict()
+        self.kwargs = kwargs
+        self.is_regulated = False
+        self.rtype = kwargs.get('rtype', 'covalent_radii')
+        self._rads = None
+        self._all_dihedrals = None
+        self._dihedral_grid = None
+        if len(self.atoms) < 4:
+            self._all_dihedrals = []
+            self._dihedral_grid = []
+        self._dihedral_mask_dct = dict()
+        self._dihedral_delta = None
+        self._rotation_delta = None
+        self._symmetry_rotations = None
+        self._symmetry_rotation_operations = None
+        self._rotation_grid = None
+        self._rotation_grid_points = None  # 旋转角的空间点
+        if len(self.atoms) == 1:
+            self._rotation_grid = []
+
+    @property
+    def info(self):
+        px, py, pz = self.principal_axis
+        info = [f"Adsorbate molecule info: {self.atoms.get_chemical_formula()}",
+                f"    Point Group: {self.point_group}",
+                f"    Radius: {self.rads}",
+                f"    Principal axis: [{px:8.3f}, {py:8.3f}, {pz:8.3f}] ",
+                f"    Number of dihedral: {len(self.all_dihedrals)}"]
+        if self.dihedral_delta:
+            info.append(f"    Number of dihedral grid: {len(self.dihedral_grid)}",)
+        info += [f"    Number of symmetry rotation operations: {len(self.symmetry_rotation_operations)}",
+                f"    Number of symmetry rotations: {len(self._symmetry_rotations)}",]
+        if self.rotation_delta:
+            info.append(f"    Number of rotation grid: {len(self.rotation_grid)}")
+        if len(self.dock_points)>0:
+            info.append(f"    Number of dock points: {len(self.dock_points)}")
+        return '\n'.join(info)
+
+    @property
+    def dock_points(self):
+        pos = self.atoms.positions
+        dp = [pos[i].mean(axis=0) for i in self.dock_point_indices]
+        return np.asarray(dp)
+
+    @property
+    def point_group(self):
+        return get_point_group(self.atoms)
+
+    def regulate(self) -> None:
+        """
+        将分子旋转到主轴 = z, 次主轴=x, 第三轴 = y
+        """
+        # com to 0,0,0
+        if len(self.atoms) > 1:
+            atoms_regulate(self.atoms)
+        else:
+            self.atoms.set_center_of_mass([0.,0.,0.])
+        self.is_regulated = True
+
+    @property
+    def com(self):
+        if self.is_regulated:
+            return np.array([0., 0., 0.])
+        else:
+            return self.atoms.center_of_mass()
+
+    @property
+    def principal_axis(self):
+        # 分子主轴向量
+        if not self.is_regulated:
+            self.regulate()
+        evals, evecs = self.atoms.get_moments_of_inertia(vectors=True)
+        return evecs[np.argmin(np.abs(evals))]
+
+    @property
+    def rads(self):
+        # 分子的半径，sg_obj 构造时作为参考
+        # 思考：这是为了生成格点的半径，格点的位置是一种参考的位置，可以尽量接近真实的吸附结构。
+        # 因而使用吸附原子的半径作为半径比较好，而不是分子的质心。当然，这是对于比较平整的slab 模型而言，对于团簇而言，也是如此吗？
+        # 可以认为是的，到时候分子的质心沿着法向向量移动就可以了。
+        if self._rads is not None:
+            return self._rads
+
+        from ase.data import covalent_radii, vdw_radii
+        if self.rtype in ['covalent_radii', 'natural_cutoff']:
+            radii = covalent_radii
+        elif self.rtype == 'vdw_radii':
+            radii = vdw_radii
+        else:
+            radii = covalent_radii
+
+        if len(self.dock_point_indices) != 0: # 使用吸附原子的半径作为半径, 返回一个列表
+            self._rads = np.mean([radii[self.atoms.numbers[i]]
+                                  for ids in self.dock_point_indices for i in ids])
+            return self._rads
+
+        if not self.is_regulated:
+            self.regulate()
+        positions = self.atoms.positions
+        dim_length = np.array([
+            max(positions[:,0]) - min(positions[:,0]),
+            max(positions[:,1]) - min(positions[:,1]),
+            max(positions[:,2]) - min(positions[:,2])
+        ])
+        shortest_dim = np.argmin(dim_length)
+        idx0 =np.argmin(positions[:,shortest_dim])
+        idx1 =np.argmax(positions[:,shortest_dim])
+        num0 = self.atoms.numbers[idx0]
+        num1 = self.atoms.numbers[idx1]
+        self._rads = (dim_length[shortest_dim] + radii[num0] + radii[num1]) / 2
+        return self._rads
+
+    @rads.setter
+    def rads(self, value:float) -> None:
+        self._rads = value
+
+    @property
+    def natoms(self) -> int:
+        return len(self.atoms)
+
+    @property
+    def all_dihedrals(self)->Sequence:  # 只包含可以活动的二面角
+        if self._all_dihedrals is None:
+            print("Analysis all unique dihedrals by ase.geometry.analysis.Analysis")
+            all_dihedrals = []
+            for i, lst in enumerate(self.analysis.unique_dihedrals[0]):
+                for jkl in lst:
+                    j,k,l = jkl
+                    all_dihedrals.append((i, j, k, l))
+            self._all_dihedrals = self._filter_dihedral(all_dihedrals)
+        return self._all_dihedrals
+
+    @all_dihedrals.setter
+    def all_dihedrals(self, value:Sequence[Tuple]) -> None:
+        self._all_dihedrals = value
+
+    def rm_dihedral(self, value) -> Tuple:
+        d = self._all_dihedrals.pop(value)
+        return d
+
+    def add_dihedral(self, value:Tuple[int]) -> None:
+        if self._all_dihedrals is None:
+            self._all_dihedrals = [value]
+        else:
+            self._all_dihedrals.append(value)
+
+    def _filter_dihedral(self, dihedrals: Sequence[Tuple[int]]) -> Sequence[Tuple]:
+        # (i,j,k,l) 只保留 j,k 不同的二面角，且 i,l 尽可能是非H元素, 优先级 C > 其他重元素 > H
+        filtered_dihedrals = {}
+        # 构造 dict = {(j,k): (i,l)}
+        for i,j,k,l in dihedrals:
+            if j > k:  # 翻转 j,k 和 i,l
+                key = (k, j)
+                v = (l, i)
+            else:
+                key = (j, k)
+                v = (i, l)
+            if key in filtered_dihedrals:
+                v_old = filtered_dihedrals[key]
+                for idx, xx in enumerate(zip(v, v_old)):
+                    ii, iio = xx
+                    inum = self.atoms.numbers[ii]
+                    ionum = self.atoms.numbers[iio]
+                    if ionum != 6:
+                        if inum == 6 or (inum > ionum):
+                            filtered_dihedrals[key][idx] = ii
+            else:
+                filtered_dihedrals[key] = v
+
+        filtered_dihedrals = [(val[0], key[0], key[1], val[1]) for key,val in filtered_dihedrals.items()]
+        return filtered_dihedrals
+
+    @property
+    def atoms_graph(self):
+        if self._atoms_graph is None:
+            self._atoms_graph = atoms2graph(self.atoms, adj=self._adj_matrix)
+
+        return self._atoms_graph
+
+    def get_dihedral_mask(self, dihedral: Tuple[int, int, int, int]) -> set:
+        """
+        为二面角生成移动的 mask indices
+        :param dihedral:
+        :return:
+        """
+        dm = self._dihedral_mask_dct.get(dihedral, None)
+        if dm is None:
+            import networkx as nx
+            new_graph = self.atoms_graph.copy()
+            i,j,k,l = dihedral
+            if not new_graph.has_edge(j,k):
+                raise ValueError(f"{j}-{k} is not connected, please check the dihedral.")
+            # 删除 j-k 生成新的图
+            new_graph.remove_edge(j,k)
+            components = list(nx.connected_components(new_graph))
+            ncomponent = len(components)
+            if ncomponent == 1:
+                raise NotImplementedError(f"{j}-{k} is in a ring, this is not supported yet.")
+            elif ncomponent > 2:
+                raise ValueError(f"Break {j}-{k} bond produces {ncomponent} parts.")
+            comp1, comp2 = components[0], components[1]
+            if len(comp1) > len(comp2):
+                dm = comp1
+            else:
+                dm = comp2
+            self._dihedral_mask_dct[dihedral] = dm
+        return dm
+
+    @property
+    def dihedral_delta(self):
+        return self._dihedral_delta
+
+    @dihedral_delta.setter
+    def dihedral_delta(self, value):
+        if self._dihedral_delta !=value:
+            self._dihedral_delta = value
+            self._dihedral_grid = None
+            n = int(360/self.dihedral_delta) ** len(self.all_dihedrals)
+            print(f"Number of dihedrals before refine: {n}")
+
+    @property
+    def dihedral_grid(self):
+        if self.dihedral_delta is None:
+            print("Please set dihedral_delta first!")
+            return None
+
+        if self._dihedral_grid is None:
+            self._dihedral_grid = dih_grid(len(self.all_dihedrals), int(360/self.dihedral_delta))
+        return self._dihedral_grid
+
+    def refine_dihedral_grid(self, tolerance=0.5) -> None:
+        atoms_list = []
+        for dih_values in self.dihedral_grid:
+            dih_dict = {i: {'value': dih_values[idx], 'mask': self.get_dihedral_mask(i)}
+                        for idx, i in enumerate(self.all_dihedrals)}
+            # 设置 二面角
+            atoms = set_dihedrals(self.atoms, dih_dict)
+            # regularize
+            atoms_regulate(atoms)
+            atoms_list.append(atoms)
+        # 计算分子之间的距离
+        n_structures = len(atoms_list)
+        dist_matrix = np.zeros((n_structures, n_structures))
+        for i in range(n_structures):
+            for j in range(i + 1, n_structures):
+                dist = ase_distance(atoms_list[i], atoms_list[j], permute=True)
+                # TODO: 使用 CDTree 计算相似性
+                #       比如，先对 H 原子求dist，然后再对其他原子分别求相似性。
+                #       或者分别对不同类型原子用 cdist
+                dist_matrix[i, j] = dist
+                dist_matrix[j, i] = dist
+
+        ## 排除相似的分子
+        selected_indices = []
+        selected_mask = np.zeros(n_structures, dtype=bool)
+        for i in range(n_structures):
+            if not selected_mask[i]:
+                selected_indices.append(i)
+                # 标记所有相似的结构
+                similar_indices = np.where(dist_matrix[i] < tolerance)[0]
+                selected_mask[similar_indices] = True
+        self._dihedral_grid = self.dihedral_grid[selected_indices]
+
+    def get_vip_dih(self)->Sequence:
+        # TODO: 对气相分子C空间进行采样，得到势能面，然后进行关键点识别（critical point）（盆分析），得到极小值点的集合
+        return []
+
+    def get_dihedrals(self, dih_value=None)->dict:
+        if dih_value is None: # 返回当前结构的二面角
+            dih_value = [self.atoms.get_dihedral(*d)  for d in self.all_dihedrals]
+
+        dihedrals = {d: {'value': dih_value[i], 'mask': self.get_dihedral_mask(d)}
+                           for i, d in enumerate(self.all_dihedrals)}
+        return dihedrals
+
+    @property
+    def symmetry_rotation_operations(self) -> Dict:
+        if len(self.atoms) == 1:
+            self._symmetry_rotations = []
+            return dict()
+        if self._symmetry_rotations is None:
+            self._symmetry_rotations = get_pure_rotations(self.atoms)
+            self._symmetry_rotation_operations = get_Cn(self.atoms)
+        return self._symmetry_rotation_operations
+
+    @property
+    def rotation_delta(self) -> float:
+        return self._rotation_delta
+
+    @rotation_delta.setter
+    def rotation_delta(self, value) -> None:
+        if len(self.atoms) == 1:
+            print("No rotation for monatomic molecule.")
+            self._rotation_grid = []
+        else:
+            self._rotation_delta = value
+            n = estimate_rotation_samples(value, self.point_group)
+            print(f"Number of rotation samples: {n}")
+            self._rotation_grid = None
+
+    @property
+    def rotation_grid(self):
+        """
+        :return: rotation quaternions grid
+        """
+        if len(self.atoms) == 1:
+            return None
+
+        if self.rotation_delta is None:
+            print("Please set rotation_delta first!")
+            return None
+
+        if self._rotation_grid is None:
+            _ = self.symmetry_rotation_operations
+            self._rotation_grid = sample_rotations_with_symmetry(avg_deg=self.rotation_delta,
+                                                   point_group=self.point_group,
+                                                   sym_quats=[i.as_quat(scalar_first=True)
+                                                              for i in self._symmetry_rotations]
+                                                   )
+        return self._rotation_grid
+
+    @rotation_grid.setter
+    def rotation_grid(self, values:Sequence) -> None: # define your own grid, or modify them.
+        self._rotation_grid = values
+
+    def view_rotation_grid(self, save_path=None) -> None:
+        view_samples(self.rotation_grid, save_path=save_path)
+
+    def view_rotation_atoms(self):
+        from scipy.spatial.transform import Rotation
+        from ase.visualize import view
+
+        if self.rotation_grid is None:
+            print("Please set rotation_grid first!")
+            return None
+
+        euler = Rotation.from_quat(self.rotation_grid, scalar_first=True).as_euler('zxz', degrees=True)
+        atoms_list = []
+        for eu in euler:
+            A = self.atoms.copy()
+            A.euler_rotate(*eu)
+            atoms_list.append(A)
+        view(atoms_list)
+        return None
+

surface_construct-0.11/surface_construct/structures/combiner.py

@@ -0,0 +1,143 @@
+import ase
+import numpy as np
+from typing import Union, Sequence
+
+from scipy.spatial import cKDTree
+
+from surface_construct.utils import extended_points
+from surface_construct.utils.atoms import set_dihedrals, atoms_regulate
+from surface_construct import Adsorbate, SurfaceGrid
+
+
+class AdsGridCombiner:
+    def __init__(self, sg_obj:SurfaceGrid, ads_obj:Adsorbate, **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
+
+    @property
+    def info(self):
+        info = [self.sg_obj.info, self.ads_obj.info]
+        return '\n'.join(info)
+
+    def get_atoms(self, sidx:int, cidx:Union[int, None]=None,
+                  ridx:Union[int, None]=None, dp_idx:int=None, **kwargs) -> Union[ase.Atoms, None]:
+        """
+        将分子设置 dihedrals（C空间）、rotation （R空间）然后将分子的结合点（dock_point）
+            放置于site（S空间）上，根据需要调整 z （Z空间）。
+        分子内坐标 dihedrals = {indice:{value:v, mask:[i,j,k]}}
+        若不用调整 z，则设置 zmax=site[-1]，放入 kwargs
+        :param sidx: 格点序号
+        :param cidx:
+        :param ridx:
+        :param dp_idx:
+        :return: 组合后的 Atoms
+        """
+        xyz = self.sg_obj.points[sidx]
+        dih_value, rotation, dock_point = None, None, None
+        if cidx is not None:
+            dih_value = self.ads_obj.dihedral_grid[cidx]
+        if ridx is not None:
+            rotation = self.ads_obj.rotation_grid[ridx]
+        if dp_idx is None and len(self.ads_obj.dock_points) > 0:
+            dp_idx = 0
+        if dp_idx is not None:
+            dock_point = self.ads_obj.dock_points[dp_idx]
+        # 改变分子构象 and then rotate
+        ads_atoms = self.docking(
+            dih_value=dih_value,
+            rotation=rotation,
+            xyz=xyz,
+            dock_point=dock_point,
+        )
+        if kwargs.get('opt_z', False):
+            # get_z 去更新 ads_atoms 的坐标
+            ads_atoms = self._opt_z(ads_atoms, dock_point=dock_point, zmax=kwargs.get('zmax', None))
+            if not ads_atoms:
+                return None
+
+        atoms = self.sg_obj.atoms.copy()
+        atoms += ads_atoms
+        atoms.calc = self.calc
+        self.atoms = atoms
+        return atoms
+
+    def _opt_z(self, ads_atoms:ase.Atoms,
+               dock_point:int=None,
+               conflict:float=None,
+               zmax:float=None,
+               ):
+        """
+        由于分子可能会与表面冲突，调整分子的高度可以避免
+        TODO： 事实上调整的是沿着格点法向向量的距离 xyz = xyz0 + r×d
+        :return:
+        """
+        # 该方法仅仅适用于 slab 体系，不适合 cluster 体系
+        # 先找到grid 的最大值点，分子的最小值点，然后把分子的COM 移动到距离5A以上的点
+        # 根据 ads 不同的原子类型，计算每个原子需要移动的z值，取最小的值。-> 应该不需要，用最简单的办法解决就行
+        max_rsub = max(self.sg_obj.rsub)
+        if conflict is None:
+            conflict = max_rsub + 0.5  # 分子与表面距离宁肯稍微大一些，不要太小。TODO: 使用距离矩阵判断，考虑元素影响
+        if zmax is None:
+            if dock_point is None:  # 默认是范德华作用，单原子不需要调整（也无需dock point）
+                posz = ads_atoms.positions[:,2]
+                zmax = self.sg_obj.rads + max_rsub + (max(posz)-min(posz))/2.0 #
+            else:
+                zmax = (self.sg_obj.rads+max_rsub) * 0.5  # 键长的1.5倍
+        surf_atoms = self.sg_obj.atoms
+        surf_tree = cKDTree(extended_points(surf_atoms.positions, (1, 1, 0), surf_atoms.cell))
+        test_atoms = ads_atoms.copy()
+        delta_z = 0.05 # 每次递增 0.05
+        n_delta = 1
+        while delta_z*n_delta <= zmax:
+            test_atoms.positions[:,2] += delta_z
+            overlap = surf_tree.query_ball_point(test_atoms.positions, conflict, p=2).tolist()
+            len_overlap = sum(list(map(len, overlap)))
+            if len_overlap != 0:
+                n_delta += 1
+            else:
+                print(f"Update adsorbate by adding z {delta_z*n_delta} to avoid conflict to surface.")
+                return test_atoms
+
+        print("Cannot find z value for adsorbate without conflict!")
+        return False
+
+    def docking(self, xyz:np.ndarray=np.array([0.,0.,0.]),
+                dih_value:Sequence=None,
+                rotation:Sequence=None,
+                dock_point:int=None) -> ase.Atoms:
+        from scipy.spatial.transform import Rotation as R
+        if dih_value is not None:
+            dih_dict = self.ads_obj.get_dihedrals(dih_value=dih_value)
+            atoms = set_dihedrals(self.ads_obj.atoms,dih_dict)
+            atoms_regulate(atoms)
+        else:
+            atoms = self.ads_obj.atoms.copy()
+
+        if dock_point is not None:  # move atoms dock point to 0
+            atoms.positions -= dock_point
+
+        if rotation is not None:  # rotate atoms at dock point
+            atoms.positions = R.from_quat(rotation, scalar_first=True).apply(atoms.positions)
+
+        atoms.positions += xyz # move atoms
+        return atoms
+
+    def get_vip_rot(self)->Sequence:
+        # TODO: 根据各种不同位点的采样结果，进行能量分析，排除截断以上的旋转，得到较优的旋转空间
+        return []
+
+

surface_construct-0.11/surface_construct/structures/pymsym_test.py

@@ -0,0 +1,30 @@
+import pymsym
+import ase
+from ase.build import molecule
+
+def get_symmetry(atoms: ase.Atoms) -> str:
+    msym_elements = list()
+    for i in atoms:
+        msym_elements.append(pymsym.Element(name=i.symbol, coordinates=i.position.tolist()))
+
+    msym_basis_functions = list()
+    for element in msym_elements:
+        bfs = [pymsym.RealSphericalHarmonic(element=element, n=2, l=1, m=m, name=f"p{m+1}") for m in (-1, 0, 1)]
+        element.basis_functions = bfs
+        msym_basis_functions += bfs
+
+#    try:
+    with pymsym.Context(elements=msym_elements, basis_functions=msym_basis_functions) as ctx:
+        return ctx.find_symmetry()
+#    except Exception as e:
+#        print(e)
+#        # diff versions throw libmsym.main.Error or libmsym.libmsym.Error, so I'll drop a blanket Exception
+#        # incredibly, this is the desired behavior of libmsym!
+#        return "C1"
+
+mol = molecule("C6H6")
+
+print(get_symmetry(mol))
+
+print(pymsym.get_point_group(mol.numbers.tolist(), mol.positions.tolist()))
+print(pymsym.get_symmetry_number(mol.numbers.tolist(), mol.positions.tolist()))