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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: surface_construct
-Version: 0.5.14
+Version: 0.6
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren

{surface_construct-0.5.14 → surface_construct-0.6}/README.md

@@ -1,259 +1,259 @@
-# 基于分层采样策略的催化剂表面位点全局分析
-
-A Method with Stratified Sampling Strategy for Comprehensive Analysis of Catalyst Surface Composed of Multiple Sites
-
-
-
-![表面位点全局分析](docs/surface_distribution_3d.jpg)
-
-
-
-## 程序流程图  Program Workflow
-
-
-
-![flowchart](docs/flowchart2.jpg)
-
-## 重要的概念 Glossary
-
-* 表面格点 Grid：以范德华或者共价键长等值面进行离散化得到，表现为 (xi, yi, zi) 三维坐标。
-
-  ![Ru Grid](docs/Ru0001_grid.jpg)
-
-* 表面向量 Vector：用来表征格点局部化学环境的向量表示方法，表现形式为 N 维的向量。
-
-  * 本方法中我们使用正则化的距离向量表达，其中距离是与N个最近邻原子之间的距离。
-  * 正则化是为了保证不同化学环境格点的区分度尽量大。我们这里使用距离的倒数作为正则化方法，即距离越远对化学环境的描述贡献越小。
-  * 为了减小计算量，在进行向量操作之前要对向量进行降维。降维的标准是保证保留尽可能多的信息，默认信息丢失不超过 5%。
-
-* 向量化 Vectorization:  将格点转化为向量的过程
-
-  * 当前我们使用多点定位 Multilateration 进行向量化
-
-    ![multilateration](docs/multilateration.jpg)
-
-* 分层采样 Stratified sampling。根据“相似结构具有相似性质”的原理采样分层采样的策略对表面位点进行采样，降低计算量。
-
-  ![stratified sampling](docs/stratified_sampling.jpg)
-
-* 吸附结构
-
-  ![adsorption structure](docs/adsorption_structure.jpg)
-
-## 安装
-
-`pip install -U surface-construct`
-
-## 发布新版本 （only for 管理员）
-
-python -m build
-twine upload --verbose dist/*
-
-## 使用方法 Manual
-
-### 所需文件 Required Files
-
-* `surface_reaction_sample.py`: 主流程文件
-
-* `parameter.py`: 参数定义文件
-
-* `POSCAR.0`: 表面结构文件
-
-  * 注意：名字可以修改，与 `parameter.py` 设置一致
-  * 设置需要固定的原子
-
-* bsub 文件。在公司集群上提交，以下面的为例
-
-  ```Bash
-  #/bin/bash
-  #BSUB -J Sampling
-  #BSUB -q short
-  #BSUB -n 28
-  #BSUB -o out.%J.txt
-  #BSUB -e error.%J.txt
-  #BSUB -R span[ptile=28]
-  module load old/intel18u4
-  export OMP_NUM_THREADS=1
-  export I_MPI_ADJUST_REDUCE=3
-  workdir=`pwd`
-  date
-  
-  export PATH="/export/home/renpengju/miniconda3/bin:$PATH"
-  export VASP_PP_PATH=$HOME/vasp/mypps
-  export VASP_SCRIPT=$workdir/run_vasp.py
-  
-  cat > run_vasp.py << EOF
-  import os
-  exitcode = os.system('mpirun -PSM2 /export/soft_old/vasp541/vasp.5.4.1/bin/vasp_gam')
-  EOF
-  
-  python surface_reaction_sample.py > surface_reaction_sample.py.log
-  
-  date
-  ```
-
-### 参数设置 
-
-注意：所有的参数均在 `parameter.py` 进行设置
-
-```python
-from ase.calculators.vasp import Vasp
-import numpy as np
-
-# 用户参数，以下参数必须设定，没有默认值
-poscar = 'ru_0001_POSCAR'
-atomnum = [7, 7]  # 吸附的原子序号， 第一个原子靠近表面
-bondlength = 1.65  # 初始的键长
-angle = [np.pi / 2, 0.0]  # 分子吸附的角度，[theta, phi_x]: [与 z 轴的角度，绕 z 轴的旋转角度(相对于x)]
-
-# 以下参数可选，具有默认值
-calc = Vasp(
-    xc='PBE',
-    gga='PE',
-    kpts=(1, 1, 1),
-    encut=400,
-    setups='recommended',
-    ncore=4,
-    gamma=True,
-    nelm=200,
-    algo='fast',
-    ismear=0,
-    sigma=0.05,
-    ibrion=-1,  # 不使用 vasp 自身的优化，必须是 -1
-    ediff=1e-4,
-    prec='normal',
-    nsw=0,  # 不使用 vasp 优化，必须是 0
-    lreal='Auto',
-    lwave=True,  # 保存 WAVECAR 可以加速
-    lcharg=False,
-    ispin=1)
-
-scan_type = 'transition_state'  # 扫描类型：'optimization'，'transition_state'
-grid_interval = 0.1  # angstrom, 格点的间距
-Nsample = 5  # 第一次采样的点
-Niter = 3  # 最大迭代次数
-fmax = 0.1  # 结构优化 force 的收敛标准
-max_error = 0.01  # 表面采样的收敛标准
-radii_type = 'covalent_radii'  # 半径选项：'vdw_radii'，'covalent_radii'
-radii_factor = 1.1  # 原子半径系数
-sampleproperty = {'phi_x': np.linspace(0, np.pi/3, 2, endpoint=False)}
-```
-
-### 手动添加格点能量信息
-
-通过脚本 `append_sample.py`实现，打开之后，修改以下信息
-
-```python
-pkl_filename = 'surface_grid.pkl'
-keep_old_sample = True  # 判断是否保留原有的采样的点
-results = [
-    '0_opt.traj',  # 支持 ase.traj, vasprun.xml 文件，仅读取最后优化后的结果
-    '1_opt.traj',
-    '2_opt.traj',
-    '3_opt.traj',
-    '4_opt.traj',
-    '5_opt.traj',
-    '6_opt.traj',
-    '7_opt.traj',
-    '8_opt.traj',
-    '9_opt.traj',
-]
-```
-
-运行: `python append_sample.py`
-
-注意：文件夹下必须有 `parameter.py` 和相应的表面结构文件
-
-注意：为了避免失误，再运行前对 `surface_grid.pkl` 进行备份
-
-
-
-### [其他 ASE 优化算法](https://wiki.fysik.dtu.dk/ase/ase/optimize.html)
-
-* BFGS, BFGSLineSearch, LBFGS, LBFGSLineSearch
-* GPMin
-* MDMin
-* FIRE
-
-各种优化算法的对比，参考[链接](https://wiki.fysik.dtu.dk/gpaw/devel/ase_optimize/ase_optimize.html)
-
-**使用方法**
-
-修改 `surface_reaction_sample.py` 其中的一行 
-
-```
-from ase.optimize import BFGS
-```
-
-改为
-
-```
-from ase.optimize import XXX as BFGS
-```
-
-注意：目前这只是权宜之计，后面会把相应的设置加入到 `parameter.py`
-
-### Gaussian Process Regression 方法
-
-高斯过程回归 GPR 的优点：
-
-* 不仅可以返回回归函数，可以给出拟合的置信度。根据置信度，可以进行进一步差点，迭代进行可以系统地降低整个拟合误差。
-* 可以灵活地选择 kernel 函数来适用于不同的场景。
-
-GPR 最重要的参数是kernel的选择。根据格点向量的特点，我们使用添加噪音的 (RBF) (aka Gassian kernel, Squared Exponetial Kernel) kernel 函数：
-$$
-k(x_i,x_j)=\sigma^2 \exp(-{d(x_i,x_j)^2\over 2l^2}) + {noise\_level}
-$$
-
-
-其中 $l$ 代表 length scale, $\sigma ^2$ 是 output variance。 使用 scikit-learn 中的类进行构造，
-$$
-\text{Kernel = ConstantKernel}\times \text{RBF} + \text{WhiteKernel}
-$$
-其中 ConstantKernel 代表 output variance  $\sigma^2$, 因为 scikit-learn 内置的 RBF kernel 不包含这一项，WhiteKernel 将 noise_level 考虑进去，RBF 是 Radial Basis Function kernel。
-
-**重要的参数**
-
-* RBF kernel
-  * Length Scale $l$：determines the length of the 'wiggles' in your function.  In general, you won't be able to extrapolate more than ℓ units away from your data. [^Duvenaud] 
-  
-    参考 [^BASC] 文献，此处我们设置实空间的 $l_{grid}=1 \text{\AA}$ ，变化范围[0.5, 2.0]，转化为向量空间的长度[^向量空间转化]。根据实际情况，我们使用非对称 anisotropic 的 RBF。
-* Constant kernel
-
-  * GPR 在训练之前将 y 数值进行正则化，因而此处设置为 1.0，且训练过程中不变化。
-
-* White kernel
-
-  * noise level 是一个经验的参数。根据 DFT 吸附和过渡态的常见误差的量级为 0.1 eV，将此数值绝对值定为 0.1。设置时需要根据 y 正则化的系数进行缩放。在拟合过程中，keep fixed。
-
-* GPR
-
-  * $\alpha$：参数用于防止过拟合，根据经验设置为 $10^{-5}$。 
-  * n_restarts_optimizer：9，经验选择。
-  * 其他数值使用默认值。
-
-
-
-
-## 路线图 Roadmap
-
-* v 0.4.1: 单原子和双原子分子表面吸附
-* v 0.4.2: 双原子过渡态计算，扫描 phi 角度
-* v 0.5: 多种表面采样方法
-* v 0.6: 表面位点数据库
-* v 0.7: 颗粒体系表面格点构造
-* v 0.8: 多原子体系（内坐标受限体系）
-* v 0.9: 完善用户界面、例子、教程
-* v 1.0: 发布第一个正式版
-* v 1.1: 孔材料体系格点构造
-* v 1.2: 多原子体系（复杂内坐标体系）
-* v 1.3: 团簇体系
-
-
-
-## Reference
-
-[^Duvenaud]: [The Kernel Cookbook: Advice on Covariance functions](https://www.cs.toronto.edu/~duvenaud/)]
-[^BASC]: Shane Carr, Roman Garnett, Cynthia LoBASC: Applying Bayesian Optimization to the Search for Global Minima on Potential Energy Surfaces.
-[^向量空间转化]: 计算实空间和向量空间的相邻格点距离的映射系数，根据此系数将实空间的距离转化为向量空间距离。
-
+# 基于分层采样策略的催化剂表面位点全局分析
+
+A Method with Stratified Sampling Strategy for Comprehensive Analysis of Catalyst Surface Composed of Multiple Sites
+
+
+
+![表面位点全局分析](docs/surface_distribution_3d.jpg)
+
+
+
+## 程序流程图  Program Workflow
+
+
+
+![flowchart](docs/flowchart2.jpg)
+
+## 重要的概念 Glossary
+
+* 表面格点 Grid：以范德华或者共价键长等值面进行离散化得到，表现为 (xi, yi, zi) 三维坐标。
+
+  ![Ru Grid](docs/Ru0001_grid.jpg)
+
+* 表面向量 Vector：用来表征格点局部化学环境的向量表示方法，表现形式为 N 维的向量。
+
+  * 本方法中我们使用正则化的距离向量表达，其中距离是与N个最近邻原子之间的距离。
+  * 正则化是为了保证不同化学环境格点的区分度尽量大。我们这里使用距离的倒数作为正则化方法，即距离越远对化学环境的描述贡献越小。
+  * 为了减小计算量，在进行向量操作之前要对向量进行降维。降维的标准是保证保留尽可能多的信息，默认信息丢失不超过 5%。
+
+* 向量化 Vectorization:  将格点转化为向量的过程
+
+  * 当前我们使用多点定位 Multilateration 进行向量化
+
+    ![multilateration](docs/multilateration.jpg)
+
+* 分层采样 Stratified sampling。根据“相似结构具有相似性质”的原理采样分层采样的策略对表面位点进行采样，降低计算量。
+
+  ![stratified sampling](docs/stratified_sampling.jpg)
+
+* 吸附结构
+
+  ![adsorption structure](docs/adsorption_structure.jpg)
+
+## 安装
+
+`pip install -U surface-construct`
+
+## 发布新版本 （only for 管理员）
+
+python -m build
+twine upload --verbose dist/*
+
+## 使用方法 Manual
+
+### 所需文件 Required Files
+
+* `surface_reaction_sample.py`: 主流程文件
+
+* `parameter.py`: 参数定义文件
+
+* `POSCAR.0`: 表面结构文件
+
+  * 注意：名字可以修改，与 `parameter.py` 设置一致
+  * 设置需要固定的原子
+
+* bsub 文件。在公司集群上提交，以下面的为例
+
+  ```Bash
+  #/bin/bash
+  #BSUB -J Sampling
+  #BSUB -q short
+  #BSUB -n 28
+  #BSUB -o out.%J.txt
+  #BSUB -e error.%J.txt
+  #BSUB -R span[ptile=28]
+  module load old/intel18u4
+  export OMP_NUM_THREADS=1
+  export I_MPI_ADJUST_REDUCE=3
+  workdir=`pwd`
+  date
+  
+  export PATH="/export/home/renpengju/miniconda3/bin:$PATH"
+  export VASP_PP_PATH=$HOME/vasp/mypps
+  export VASP_SCRIPT=$workdir/run_vasp.py
+  
+  cat > run_vasp.py << EOF
+  import os
+  exitcode = os.system('mpirun -PSM2 /export/soft_old/vasp541/vasp.5.4.1/bin/vasp_gam')
+  EOF
+  
+  python surface_reaction_sample.py > surface_reaction_sample.py.log
+  
+  date
+  ```
+
+### 参数设置 
+
+注意：所有的参数均在 `parameter.py` 进行设置
+
+```python
+from ase.calculators.vasp import Vasp
+import numpy as np
+
+# 用户参数，以下参数必须设定，没有默认值
+poscar = 'ru_0001_POSCAR'
+atomnum = [7, 7]  # 吸附的原子序号， 第一个原子靠近表面
+bondlength = 1.65  # 初始的键长
+angle = [np.pi / 2, 0.0]  # 分子吸附的角度，[theta, phi_x]: [与 z 轴的角度，绕 z 轴的旋转角度(相对于x)]
+
+# 以下参数可选，具有默认值
+calc = Vasp(
+    xc='PBE',
+    gga='PE',
+    kpts=(1, 1, 1),
+    encut=400,
+    setups='recommended',
+    ncore=4,
+    gamma=True,
+    nelm=200,
+    algo='fast',
+    ismear=0,
+    sigma=0.05,
+    ibrion=-1,  # 不使用 vasp 自身的优化，必须是 -1
+    ediff=1e-4,
+    prec='normal',
+    nsw=0,  # 不使用 vasp 优化，必须是 0
+    lreal='Auto',
+    lwave=True,  # 保存 WAVECAR 可以加速
+    lcharg=False,
+    ispin=1)
+
+scan_type = 'transition_state'  # 扫描类型：'optimization'，'transition_state'
+grid_interval = 0.1  # angstrom, 格点的间距
+Nsample = 5  # 第一次采样的点
+Niter = 3  # 最大迭代次数
+fmax = 0.1  # 结构优化 force 的收敛标准
+max_error = 0.01  # 表面采样的收敛标准
+radii_type = 'covalent_radii'  # 半径选项：'vdw_radii'，'covalent_radii'
+radii_factor = 1.1  # 原子半径系数
+sampleproperty = {'phi_x': np.linspace(0, np.pi/3, 2, endpoint=False)}
+```
+
+### 手动添加格点能量信息
+
+通过脚本 `append_sample.py`实现，打开之后，修改以下信息
+
+```python
+pkl_filename = 'surface_grid.pkl'
+keep_old_sample = True  # 判断是否保留原有的采样的点
+results = [
+    '0_opt.traj',  # 支持 ase.traj, vasprun.xml 文件，仅读取最后优化后的结果
+    '1_opt.traj',
+    '2_opt.traj',
+    '3_opt.traj',
+    '4_opt.traj',
+    '5_opt.traj',
+    '6_opt.traj',
+    '7_opt.traj',
+    '8_opt.traj',
+    '9_opt.traj',
+]
+```
+
+运行: `python append_sample.py`
+
+注意：文件夹下必须有 `parameter.py` 和相应的表面结构文件
+
+注意：为了避免失误，再运行前对 `surface_grid.pkl` 进行备份
+
+
+
+### [其他 ASE 优化算法](https://wiki.fysik.dtu.dk/ase/ase/optimize.html)
+
+* BFGS, BFGSLineSearch, LBFGS, LBFGSLineSearch
+* GPMin
+* MDMin
+* FIRE
+
+各种优化算法的对比，参考[链接](https://wiki.fysik.dtu.dk/gpaw/devel/ase_optimize/ase_optimize.html)
+
+**使用方法**
+
+修改 `surface_reaction_sample.py` 其中的一行 
+
+```
+from ase.optimize import BFGS
+```
+
+改为
+
+```
+from ase.optimize import XXX as BFGS
+```
+
+注意：目前这只是权宜之计，后面会把相应的设置加入到 `parameter.py`
+
+### Gaussian Process Regression 方法
+
+高斯过程回归 GPR 的优点：
+
+* 不仅可以返回回归函数，可以给出拟合的置信度。根据置信度，可以进行进一步差点，迭代进行可以系统地降低整个拟合误差。
+* 可以灵活地选择 kernel 函数来适用于不同的场景。
+
+GPR 最重要的参数是kernel的选择。根据格点向量的特点，我们使用添加噪音的 (RBF) (aka Gassian kernel, Squared Exponetial Kernel) kernel 函数：
+$$
+k(x_i,x_j)=\sigma^2 \exp(-{d(x_i,x_j)^2\over 2l^2}) + {noise\_level}
+$$
+
+
+其中 $l$ 代表 length scale, $\sigma ^2$ 是 output variance。 使用 scikit-learn 中的类进行构造，
+$$
+\text{Kernel = ConstantKernel}\times \text{RBF} + \text{WhiteKernel}
+$$
+其中 ConstantKernel 代表 output variance  $\sigma^2$, 因为 scikit-learn 内置的 RBF kernel 不包含这一项，WhiteKernel 将 noise_level 考虑进去，RBF 是 Radial Basis Function kernel。
+
+**重要的参数**
+
+* RBF kernel
+  * Length Scale $l$：determines the length of the 'wiggles' in your function.  In general, you won't be able to extrapolate more than ℓ units away from your data. [^Duvenaud] 
+  
+    参考 [^BASC] 文献，此处我们设置实空间的 $l_{grid}=1 \text{\AA}$ ，变化范围[0.5, 2.0]，转化为向量空间的长度[^向量空间转化]。根据实际情况，我们使用非对称 anisotropic 的 RBF。
+* Constant kernel
+
+  * GPR 在训练之前将 y 数值进行正则化，因而此处设置为 1.0，且训练过程中不变化。
+
+* White kernel
+
+  * noise level 是一个经验的参数。根据 DFT 吸附和过渡态的常见误差的量级为 0.1 eV，将此数值绝对值定为 0.1。设置时需要根据 y 正则化的系数进行缩放。在拟合过程中，keep fixed。
+
+* GPR
+
+  * $\alpha$：参数用于防止过拟合，根据经验设置为 $10^{-5}$。 
+  * n_restarts_optimizer：9，经验选择。
+  * 其他数值使用默认值。
+
+
+
+
+## 路线图 Roadmap
+
+* v 0.4.1: 单原子和双原子分子表面吸附
+* v 0.4.2: 双原子过渡态计算，扫描 phi 角度
+* v 0.5: 多种表面采样方法
+* v 0.6: 表面位点数据库
+* v 0.7: 颗粒体系表面格点构造
+* v 0.8: 多原子体系（内坐标受限体系）
+* v 0.9: 完善用户界面、例子、教程
+* v 1.0: 发布第一个正式版
+* v 1.1: 孔材料体系格点构造
+* v 1.2: 多原子体系（复杂内坐标体系）
+* v 1.3: 团簇体系
+
+
+
+## Reference
+
+[^Duvenaud]: [The Kernel Cookbook: Advice on Covariance functions](https://www.cs.toronto.edu/~duvenaud/)]
+[^BASC]: Shane Carr, Roman Garnett, Cynthia LoBASC: Applying Bayesian Optimization to the Search for Global Minima on Potential Energy Surfaces.
+[^向量空间转化]: 计算实空间和向量空间的相邻格点距离的映射系数，根据此系数将实空间的距离转化为向量空间距离。
+

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

@@ -1,35 +1,35 @@
-from setuptools import setup
-
-with open("README.md", "r", encoding='utf-8') as f:
-    long_description = f.read()
-
-install_requires = [
-    'ase',
-    'networkx',
-    'numpy',
-    'spglib',
-    'pandas',
-    'tqdm',
-    'matplotlib',
-    'scipy',
-    'scikit-learn',
-]
-
-setup(
-    name='surface_construct',
-    version='0.5.14',
-    packages=['surface_construct'],
-    url='https://gitee.com/pjren/surface_construct/',
-    license='GPL',
-    author='ren',
-    author_email='0403114076@163.com',
-    description='Surface termination construction especially for complex model, such as oxides or carbides.',
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    install_requires=install_requires,
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
-        "Operating System :: OS Independent",
-    ],
-)
+from setuptools import setup
+
+with open("README.md", "r", encoding='utf-8') as f:
+    long_description = f.read()
+
+install_requires = [
+    'ase',
+    'networkx',
+    'numpy',
+    'spglib',
+    'pandas',
+    'tqdm',
+    'matplotlib',
+    'scipy',
+    'scikit-learn',
+]
+
+setup(
+    name='surface_construct',
+    version='0.6',
+    packages=['surface_construct'],
+    url='https://gitee.com/pjren/surface_construct/',
+    license='GPL',
+    author='ren',
+    author_email='0403114076@163.com',
+    description='Surface termination construction especially for complex model, such as oxides or carbides.',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    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.5.14 → surface_construct-0.6}/surface_construct/surface_grid.py

@@ -16,19 +16,21 @@ import ase
 import numpy as np
 import pickle
 from ase.data import covalent_radii, vdw_radii
-from ase.geometry import get_distances
+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 sklearn.cluster import KMeans as Cluster
 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
+from surface_construct.utils import get_calc_info, GridGenerator, get_distances
 
 
 def no_weight(v, **kwargs):
@@ -52,19 +54,19 @@ def linear_weight(v, **kwargs):
 def vb_r_weight(v, **kwargs):
     r0 = kwargs['r0']
     if 'b' not in kwargs:
-        b = 0.37
+        b = 0.618 # 较大的数值衰减较慢，能够将更远的原子作用考虑进来。不建议大于此数
     else:
         b = kwargs['b']
     weight = np.exp((r0 - v) / b)
     weight[weight > 1.0] = 1.0
-    v_w = v * weight
+    v_w = v / r0 * weight
     return v_w
 
 
 def vb_weight(v, **kwargs):
     r0 = kwargs['r0']
     if 'b' not in kwargs:
-        b = 0.37
+        b = 1.0  # 较大的数值衰减较慢，能够将更远的原子作用考虑进来
     else:
         b = kwargs['b']
     weight = np.exp((r0 - v) / b)
@@ -119,7 +121,7 @@ class SurfaceGrid:
 
         self.points = None  # 格点 xyz 坐标
         self._Dga = None  # grid_atoms 距离矩阵
-        self._DAga = None  # grid_atoms 距离向量矩阵，保存是为了求角度
+        # self._DAga = None  # grid_atoms 距离向量矩阵，保存是为了求角度
         self.vector = None
         self.lpca = lpca
         self._pca = None
@@ -165,7 +167,7 @@ class SurfaceGrid:
                 result[dim, int((sign+1)/2)] = v
         return np.concatenate(result)  # [xmin, xmax, ymin, ymax, zmin, zmax]
 
-    def gridize(self, surface_index=None, gridxy=None):
+    def gridize(self, **kwargs):
         """
         格点化。
         这种方法仅仅适用于无孔的材料，表面为z方向，且方向向上。
@@ -173,6 +175,8 @@ class SurfaceGrid:
         * surface_index: 表面原子的序号
         :return:
         """
+
+        """ ### Old code
         if gridxy is None:
             nx, ny = self.grid_nx, self.grid_ny
 
@@ -225,9 +229,25 @@ class SurfaceGrid:
         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)
+        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._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,
+                               use_ase=False, cell=self.atoms.cell)
+        self._Dga = Dga
 
-        self._Dga = grid_dist
-        self._DAga = grid_dist_array
 
     def grid_NN_array(self, grid_idx):
         """
@@ -235,46 +255,30 @@ class SurfaceGrid:
         :param grid_idx:
         :return:
         """
-        if self._DAga 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
-
-    def grid_force(self, grid_idx):
-        """
-        返回格点的受力向量，r^-4形式计算. 以此方式求格点的reference 向量，效果不太好。放弃。
-        :param grid_idx:
-        :return:
-        """
-        if self._DAga is not None:
-            order = np.argsort(self._Dga[grid_idx])
-            weight = self._Dga[grid_idx, order] ** (-4)
-            force_array = np.atleast_2d(weight).T * self._DAga[grid_idx, order]
-            force = force_array.sum(axis=0)
-            return force
-        else:
-            raise NotImplementedError
+        #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])
+        p1, p2 = self.atoms.positions[order[0:2]]
+        v, _ = find_mic(p2-p1, cell=self.atoms.cell, pbc=self.atoms.pbc)
+        return v
 
     def view_grid(self):
-        points = self.points
-        view(self.atoms + ase.Atoms(symbols=['X'] * len(points), positions=points))
-
-    def set_grid(self, points):
-        """
-        TODO: 手动设置格点
-        :param points:
-        :return:
-        """
-        pass
+        if self._gridgen is None:
+            self.gridize()
+        self._gridgen.view()
 
     @property
     def grid_energy(self):
@@ -285,39 +289,46 @@ class SurfaceGrid:
 
     def filter_grid_z(self, z=None):
         """
-        过滤 z 方向不合理的格点，默认原子坐标 zmax
+        过滤 z 方向不合理的格点，默认原子坐标 zmax.  对于孔材料和cluster 已经不合时宜了
         :param z:
         :return:
         """
-        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, wf=reciprocal_weight, pca=True, pca_ratio=0.90, **kwargs):
+        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 来进行向量化，并进行测试。如何测试？测试什么内容？
         使用 distance matrix 来进行向量化
         使用衰减函数对 vector 加权重。备选函数：S型，指数型（键价），1/sqrt，1/x，线性。倾向使用指数型，键价理论支持。 1/x，或者 1/sqrt，衰减更慢。
-        这种方法类似于多点地位方法（Multilateration），因而暂时称其为 Multilateration vectorization. 
+        这种方法类似于多点地位方法（Multilateration），因而暂时称其为 Multilateration vectorization.
+        :param wf:
+        :param Dga: grid-atoms distance matrix
+        :param return_vector: 是否返回 vector 向量
         """
         if Dga is None:
+            if self._Dga is None:
+                self._calc_Dga()
             Dga = self._Dga
-            return_vector = False
-        else:
-            return_vector = True  # 返回 vector 说明是为新的Dga生成的vector
+
+        Natoms = Dga.shape[1] / len(self.atoms)  # Dga is multiple of atoms
+        assert Natoms == int(Natoms)  # Natoms should be int
+        numbers = np.concatenate([self.atoms.numbers]*int(Natoms))  # multiply atoms.number
 
         vector = []
         for atomnum, atomcount in self.species:
-            grid_dist = Dga[:, self.atoms.numbers == atomnum]
+            grid_dist = Dga[:, numbers == atomnum]
             # 排序，返回排序后的序号
             index_array = grid_dist.argsort(axis=-1)
             grid_dist = np.take_along_axis(grid_dist, index_array, axis=-1)
             # grid_dist_array = np.take_along_axis(grid_dist_array, index_array, axis=-1)
             # 设定距离向量长度
-            vlen = min(self.vlen, atomcount)
+            vlen = self.vlen
             r0 = self.rads + self.radii[atomnum]
             v = grid_dist[:, :vlen]
             kwargs.update({'r0': r0})
@@ -374,6 +385,7 @@ class SurfaceGrid:
     def grid_sample(self, N=10, include_vertex=False):
         """
         Warning: Obsoleted, replaced by Sampling class
+        TODO: 使用vertex 点作为分类的中心点
         :param include_vertex: 是否对边界额外采样
         :param N:
         :return:
@@ -572,20 +584,24 @@ class SurfaceGrid:
         :return:
         """
         assert key in self.grid_property
-
-        print("Plot {} ...".format(key))
-        X = self.points[:, 0].reshape((self.grid_ny, self.grid_nx))
-        Y = self.points[:, 1].reshape((self.grid_ny, self.grid_nx))
-        Z = self.grid_property[key].reshape((self.grid_ny, self.grid_nx))
-
         fig, ax = plt.subplots()
         ax.set_aspect('equal')
 
-        if vmax is None:
-            vmax = Z.max() + (Z.max() - Z.min()) * 0.2
-        if vmin is None:
-            vmin = Z.min() - (Z.max() - Z.min()) * 0.2
-        contourf0 = ax.contourf(X, Y, Z, levels=50, cmap="jet", vmin=vmin, vmax=vmax)
+        print("Plot {} ...".format(key))
+        #X = self.points[:, 0].reshape((self.grid_ny, self.grid_nx))
+        #Y = self.points[:, 1].reshape((self.grid_ny, self.grid_nx))
+        #Z = self.grid_property[key].reshape((self.grid_ny, self.grid_nx))
+        #if vmax is None:
+        #    vmax = Z.max() + (Z.max() - Z.min()) * 0.2
+        #if vmin is None:
+        #    vmin = Z.min() - (Z.max() - Z.min()) * 0.2
+        #contourf0 = ax.contourf(X, Y, Z, levels=50, cmap="jet", vmin=vmin, vmax=vmax)
+        x = self.points[:, 0]
+        y = self.points[:, 1]
+        z = self.grid_property[key]
+        triang = mtri.Triangulation(x, y)
+        contourf0 = ax.tricontourf(triang, z, levels=50, cmap="jet", vmin=vmin, vmax=vmax)
+
         # 画上 sample 点，采过的点用黑色，下一步采的点用白色
         if sample:
             sample_points = self.sample_points
@@ -664,15 +680,20 @@ class SurfaceGrid:
     def plot_sigma(self, key='energy', figname=None, vmax=None, vmin=None):
         # TODO: 支持 cluster 作图。保存原始 meshgrid 和 id？或者重新插值？
         assert key in self.grid_property_sigma
-
-        X = self.points[:, 0].reshape((self.grid_ny, self.grid_nx))
-        Y = self.points[:, 1].reshape((self.grid_ny, self.grid_nx))
-        Z = self.grid_property_sigma[key].reshape((self.grid_ny, self.grid_nx))
-
         fig, ax = plt.subplots()
         ax.set_aspect('equal')
 
-        contourf0 = ax.contourf(X, Y, Z, levels=50, cmap="RdPu", vmax=vmax, vmin=vmin)
+        #X = self.points[:, 0].reshape((self.grid_ny, self.grid_nx))
+        #Y = self.points[:, 1].reshape((self.grid_ny, self.grid_nx))
+        #Z = self.grid_property_sigma[key].reshape((self.grid_ny, self.grid_nx))
+        #contourf0 = ax.contourf(X, Y, Z, levels=50, cmap="RdPu", vmax=vmax, vmin=vmin)
+
+        x = self.points[:, 0]
+        y = self.points[:, 1]
+        z = self.grid_property_sigma[key]
+        triang = mtri.Triangulation(x, y)
+        contourf0 = ax.tricontourf(triang, z, levels=50, cmap="RdPu", vmin=vmin, vmax=vmax)
+
         # sigma 最大值标注
         max_sigma_point = self.points[self.grid_property_sigma[key].argmax()]
         ax.scatter(max_sigma_point[0], max_sigma_point[1], marker="+", s=100, linewidths=2,

surface_construct-0.6/surface_construct/utils.py

@@ -0,0 +1,255 @@
+import itertools
+from distutils.command.sdist import sdist
+from enum import unique
+
+import numpy as np
+from ase.data import covalent_radii, 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
+
+
+def calc_hull_vertices(v):
+    shape = v.shape
+    if len(shape) != 2:
+        print("Warning: The vector should be 2D, however {}D vector was provided!)".format(len(shape)))
+        print("The Convex Hull Vertices won't be calculated.")
+        return None
+    if shape[1] > 5:
+        print("Warning: The vector.shape[1]={} is too large to be calculated!)".format(shape[1]))
+        print("The Convex Hull Vertices won't be calculated.")
+        return None
+    try:
+        print("Calculate Convex Hull Vertices ...")
+        hull = ConvexHull(v)
+        vertices = hull.vertices
+        return vertices
+    except ValueError:
+        return None
+
+
+def get_calc_info(calc=None):
+    if calc is None:
+        return {}
+    calc_name = calc.name
+    calc_para = dict()
+    if calc_name in ('vasp',):
+        calc_para['xc'] = calc.parameters['xc']
+        calc_para['encut'] = calc.parameters['encut']
+
+    calc_info = {
+        'name': calc_name,
+        'para': calc_para,
+    }
+    return calc_info
+
+def get_distances(p1, p2=None, cutoff=10, cell=None, use_ase=False):
+    """
+    计算位点周围原子的距离，参考 ase.geometry.get_distances. 对于更大的体系使用 cDTree 来计算。
+    :param p1: grid positions
+    :param p2: atoms.positions
+    :param cutoff: 截断半径，只考虑距离之内的距离，超过该距离的定为 np.inf
+    :param cell:
+    :param use_ase: 如果 use_ase is True，则使用 ase.geometry.get_distances，即周期性条件等价的原子只考虑一次
+    :return:
+    """
+    pbc = cell.lengths() < (cutoff * 2)
+    if not np.any(pbc):
+        use_ase = True
+
+    if use_ase:
+        return ase.geometry.get_distances(p1, p2, cell, pbc)
+
+    if p2 is None:
+        p2 = p1.copy()
+
+    ranges = [np.arange(-1 * p, p + 1) for p in pbc]
+    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
+    p2 = np.concatenate(p2 + vrvecs[:, None], axis=0)
+    tree1 = cKDTree(p1, copy_data=True)
+    tree2 = cKDTree(p2, copy_data=True)
+    sdm = tree1.sparse_distance_matrix(tree2, max_distance=cutoff)
+    # 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
+    return None, dist
+
+class GridGenerator:
+    def __init__(self, atoms,
+                 rads=0.76,
+                 rsub='natural_cutoff',
+                 subtype=None,
+                 interval=0.1,
+                 scale=None,
+                 ):
+        """
+        :param atoms: 基底结构 ase.Atoms
+        :param rads: 吸附原子的半径, 默认是 C 的共价半径
+        :param rsub: 基底的原子半径
+            type: str, 'covalent_radii' or 'vdw_radii'
+            type: list or tuple or numpy.array, [r1, r2, ... rN], N=len(atoms)
+        :param subtype: 基底的类型，slab, cluster, bulk (porous material)
+        :param interval:
+        :param scale: scale factor of rsub and rads. For covalent_radii, the default is 1.1, otherwise it is 1.0
+        """
+        self.atoms = atoms
+        self._grid = None
+        self.atoms_num_type = set(atoms.numbers)
+        self.interval = interval
+
+        if subtype is None:
+            if not np.all(atoms.pbc):
+                self.subtype = 'cluster'
+            else:
+                self.subtype = 'bulk'
+        elif subtype.lower() in ['slab', 'bulk', 'cluster']:
+            self.subtype = subtype.lower()
+        else:
+            raise NotImplementedError('Only slab, cluster, bulk and slab are implemented.')
+        self._generator = getattr(self, self.subtype+'_grid')
+
+        if type(rsub) in (list, tuple, np.ndarray):
+            assert len(rsub) == len(atoms)
+            self.rsub = rsub
+        elif type(rsub) == dict:
+            self.rsub = [rsub.get(n) or rsub.get(chemical_symbols(n)) for n in atoms.numbers]
+        elif type(rsub) == str:
+            if rsub == 'covalent_radii' or rsub == 'natural_cutoff':
+                self.rsub = natural_cutoffs(atoms)
+                if scale is None:
+                    scale = 1.1
+            elif rsub == 'vdw_radii':
+                self.rsub = [vdw_radii[n] for n in atoms.numbers]
+        else:
+            raise ValueError("rsub must be 'covalent_radii', 'natural_cutoff' or 'vdw_radii' or a list.")
+
+        if scale is None:
+            scale = 1.0
+        self.scale = scale
+        self.rsub = np.asarray(self.rsub) * scale
+        self.rads = rads * scale
+
+    def cluster_grid(self):
+        atoms = self.atoms
+        if np.all(atoms.pbc):
+            atoms.center()
+        interval = self.interval
+        pos = atoms.positions
+        # 找到团簇格点的边界
+        posx, posy, posz = pos[:,0], pos[:,1], pos[:,2]
+        xmin = (posx - self.rsub).min() - interval * 2 - self.rads
+        xmax = (posx + self.rsub).max() + interval * 2 + self.rads
+        ymin = (posy - self.rsub).min() - interval * 2 - self.rads
+        ymax = (posy + self.rsub).max() + interval * 2 + self.rads
+        zmin = (posz - self.rsub).min() - interval * 2 - self.rads
+        zmax = (posz + self.rsub).max() + interval * 2 + self.rads
+        xarray = np.arange(xmin, xmax, interval)
+        yarray = np.arange(ymin, ymax, interval)
+        zarray = np.arange(zmin, zmax, interval)
+        nx,ny,nz = map(len, [xarray, yarray, zarray])
+        # 格点生成
+        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
+        grid_tree = cKDTree(xyz, copy_data=True)
+
+        dist_sum = 0
+        atoms_num_type = set(atoms.numbers)
+        # 对于不同的原子类型取不同的半径
+        for num_type in atoms_num_type:
+            pos = atoms.positions[atoms.numbers == num_type]
+            atoms_tree = cKDTree(pos, copy_data=True)
+            max_distance = self.rads + self.rsub[atoms.numbers == num_type][0]
+            sdm = atoms_tree.sparse_distance_matrix(grid_tree, max_distance=max_distance)
+            # TODO: 此处可以加上 mask 参数，过滤掉一部分格点，从而加速计算
+            # 保证没有格点的坐标跟grid 完全重合，如果有的话，需要标识出来，赋予它们另外的值，保证在后面识别中不为0。
+            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)
+        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[:]])  # 校验数值
+        points = np.asarray([grid_x[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]],
+                             grid_y[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]],
+                             grid_z[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]]]).T
+        self._grid = points
+
+    def slab_grid(self):
+        # TODO: exclude the grid inside bulk
+        atoms = self.atoms
+        pos = atoms.positions
+        interval = self.interval
+        posz = pos[:,2]
+        zmax = (posz + np.asarray(self.rsub)).max() + self.rads + interval * 2
+        zmin = (posz.max() + posz.min())/2  # 从层中心开始
+        lenx, leny, lenz = atoms.cell.lengths()
+        ifx, ify, ifz = interval / lenx, interval / leny, interval / lenz
+        fx_list = np.arange(0, 1, ifx)
+        fy_list = np.arange(0, 1, ify)
+        fz_list = np.arange(zmin/lenz, zmax/lenz, ifz)
+        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)
+        grid_tree = cKDTree(xyz, copy_data=True)
+
+        # 对atoms 在 xy 方向超胞. Adapt from ase.geometry.geometry.general_find_mic
+        ranges = [np.arange(-1 * p, p + 1) for p in atoms.pbc[:2]]
+        hkls = np.concatenate([np.array(list(itertools.product(*ranges))),
+                               np.zeros([9, 1], dtype=int)], axis=1)
+        vrvecs = hkls @ atoms.cell
+        super_pos = np.concatenate(atoms.positions + vrvecs[:,None], axis=0)
+        super_num = np.concatenate([atoms.numbers] * 9)
+        rsub = np.concatenate([self.rsub] * 9)
+
+        dist_sum = 0
+        atoms_num_type = set(atoms.numbers)
+        # 对于不同的原子类型取不同的半径
+        for num_type in atoms_num_type:
+            pos = super_pos[super_num == num_type]
+            atoms_tree = cKDTree(pos, copy_data=True)
+            max_distance = self.rads + rsub[super_num == num_type][0]
+            sdm = atoms_tree.sparse_distance_matrix(grid_tree, max_distance=max_distance)
+            # TODO: 此处可以加上 mask 参数，过滤掉一部分格点，从而加速计算
+            # 保证没有格点的坐标跟grid 完全重合，如果有的话，需要标识出来，赋予它们另外的值，保证在后面识别中不为0。
+            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)
+        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]],
+                              fgrid_y[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]],
+                              fgrid_z[unique_verts[:,0], unique_verts[:,1], unique_verts[:,2]]]).T
+        points = atoms.cell.cartesian_positions(fpoints)
+        self._grid = points
+
+    def bulk_grid(self):
+        raise NotImplementedError
+
+    @property
+    def grid(self):
+        if self._grid is None:
+            self._generator()
+
+        return self._grid
+
+    def view(self):
+        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))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: surface_construct
-Version: 0.5.14
+Version: 0.6
 Summary: Surface termination construction especially for complex model, such as oxides or carbides.
 Home-page: https://gitee.com/pjren/surface_construct/
 Author: ren

{surface_construct-0.5.14 → surface_construct-0.6}/surface_construct.egg-info/SOURCES.txt

@@ -14,6 +14,4 @@ surface_construct.egg-info/PKG-INFO
 surface_construct.egg-info/SOURCES.txt
 surface_construct.egg-info/dependency_links.txt
 surface_construct.egg-info/requires.txt
-surface_construct.egg-info/top_level.txt
-tests/test_surface_grid.py
-tests/test_systematic_opt.py
+surface_construct.egg-info/top_level.txt

surface_construct-0.5.14/surface_construct/utils.py

@@ -1,37 +0,0 @@
-from scipy.spatial import ConvexHull
-
-
-def calc_hull_vertices(v):
-    shape = v.shape
-    if len(shape) != 2:
-        print("Warning: The vector should be 2D, however {}D vector was provided!)".format(len(shape)))
-        print("The Convex Hull Vertices won't be calculated.")
-        return None
-    if shape[1] > 5:
-        print("Warning: The vector.shape[1]={} is too large to be calculated!)".format(shape[1]))
-        print("The Convex Hull Vertices won't be calculated.")
-        return None
-    try:
-        print("Calculate Convex Hull Vertices ...")
-        hull = ConvexHull(v)
-        vertices = hull.vertices
-        return vertices
-    except ValueError:
-        return None
-
-
-def get_calc_info(calc=None):
-    if calc is None:
-        return {}
-    calc_name = calc.name
-    calc_para = dict()
-    if calc_name in ('vasp',):
-        calc_para['xc'] = calc.parameters['xc']
-        calc_para['encut'] = calc.parameters['encut']
-
-    calc_info = {
-        'name': calc_name,
-        'para': calc_para,
-    }
-    return calc_info
-

surface_construct-0.5.14/tests/test_surface_grid.py

@@ -1,35 +0,0 @@
-import ase.io
-import matplotlib.pyplot as plt
-import numpy as np
-from ase.visualize import view
-from sklearn.decomposition import PCA
-
-from surface_construct.surface_grid import SurfaceGrid
-
-atoms = ase.io.read('ru_0001_POSCAR')
-# atoms = ase.io.read('In2O3_011.cif')
-sg = SurfaceGrid(atoms, interval=0.2)
-sg.gridize()
-sg.vectorize()
-
-energy_file = 'energy.dat'
-with open(energy_file, 'r+') as f:
-    content = f.readlines()
-
-points = []
-values = []
-for l in content[1:]:
-    x1, y1, z1, x2, y2, z2, e = list(map(float, l.split()[1:]))
-    values.append(e)
-    points.append([(x1 + x2) / 2.0, (y1 + y2) / 2.0, (z1 + z2) / 2.0])
-points = np.asarray(points)
-values = np.asarray(values)
-
-sg.set_energy(points, values, ignore_z=True)
-
-sg.plot_energy()
-sg.plot_sigma()
-
-points_sample = sg.grid_sample()
-
-view(sg.atoms + ase.Atoms(symbols=['X'] * len(points_sample), positions=points_sample))

surface_construct-0.5.14/tests/test_systematic_opt.py

@@ -1,16 +0,0 @@
-import ase
-import numpy as np
-from ase.visualize import view
-from surface_construct.systematic_opt import SystematicOpt
-
-atoms = ase.Atoms('CO', positions=[[0, 0, 0], [0, 0, 1.4]])
-coordinate = {
-    'phi_x': {'indices': [0, 1], 'values': [0, 90]},
-    'theta': {'indices': [0, 1], 'values': [0, 90]},
-}
-
-sysopt = SystematicOpt(atoms, coordinate)
-A = sysopt.rotate_theta(0, 1, 0)
-A1 = sysopt.rotate_phi_x(0, 1, 90)
-atomslst = sysopt.get_initial_atomslst()
-pass