OVITO 使用

介绍

使用

  • OVITO常用的无需Python代码的后处理技巧

  • 直接导入构型/轨迹文件，下方默认有 Particles 信息；添加 Modification 后，会出现 Global Attributes、Data Tables 另外两种类型的数据（添加 DXA，会多出 Dislocation、Surfaces 数据）

  • Add Modification 选项

    • 无直接计算原子层间距的 Modification
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# Analysis
Coordination analysis             # 配位分析
Dislocation analysis (DXA)        # 位错分析
Histogram                         # 直方图
Voronoi analysis                  # Voronoi 分析
Wigner-Seitz defect analysis      # WS 缺陷分析

# Coloring
Assign color                      # 分配颜色/着色
Color coding

# Modification
Replicate                         # 扩胞
Slice                             # 切片 
Smooth trajectory                 # 
Unwrap trajectories               # 
Wrap at periodic boundaries       # 将 box 外原子移至 box 内

# Selection
Clear selection                   # 清除选择
Expression selection              # 表达式选择
Manual selection                  # 手动选择
Select type                       # 选择（原子）类型

# Python modifiers (pro)
Calculate local entropy           # 计算局域熵

# Structure identification
Ackland-Jones analysis            # 
Centrosymmetry parameter          # CSP
Common neighbor analysis          # CNA；识别原子对应的晶体结构

# Visualization
1
2
3
4
5
6
7
8
Position.X              # x 方向笛卡尔坐标
Position.Y              # y 方向笛卡尔坐标
Position.Z              # z 方向笛卡尔坐标；可用于选中原子层
ReducedPosition.Z       # z 方向分数坐标
StructureType           # 晶体结构类型

# 添加 WS 缺陷分析 Modification 后新增的 Attributes
Occupancy               # 原子占位

OVITO Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from ovito.pipeline import Pipeline
from ovito.modifiers import ...
from ovito.io import import_file

# 导入构型/轨迹文件
pipline = import_file("dump.lammpstrj")
# 可使用通配符
pipline = import_file("dump_*.lammpstrj")
# 参数
sort_particles           # 是否对原子进行排序

modifier = ...

# 添加 modifier（可添加多个，也可不添加）
pipeline.modifiers.append(modifier)

# data 类型 DataCollection（只代表一帧的数据）
data = pipeline.compute()

# 查看 data 相关属性
# 不同 modifier 处理后，particles、attributes、table 会有不同
list(data.particles.keys())                # 原子属性
list(data.attributes.keys()                # 全局属性
list(data.tables.keys())                   # Tabulated data/DataTable


# 处理多帧构型数据
# 方式 1
for frame in range(pipeline.num_frames):
    data = pipeline.compute(frame)
    ...

# 方式 2；该迭代器可直接获取计算的 DataCollection
for data in pipeline.frames:
    ...
  • Pipeline、DataCollection 类相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# DataCollection 相关
list(data.particles.keys())    # 查看原子属性；不同输出文件格式，可能会有不同
# POSCAR
['Position', 'Particle Type']
# dump.lammpstrj / xyz
['Particle Identifier', 'Particle Type', 'Position']

data.particles.positions       # 原子位置
data.particles.count           # 原子数

# 查看原子种类及其 ID
for type in data_init.particles.particle_types.types:
    print(type.id, type.name)


# Pipeline 类
# 属性
num_frames                    # 构型帧数
frames                        # 所有构型（数据）

# 方法
add_to_scene()                # 用于可视化
  • 数据导出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
from ovito.io import export_file

export_file(data, file, format, **params)
# 参数
data                  # 可以是 Pipeline、DataCollection、DataObject、None 类型
file                  # 输出文件
foramt                # 输出文件格式

# **params 参数
multiple_frames       # 是否导出多帧的数据，默认只会导出第一帧的数据
start_frame           # 起始帧
end_frame             # 结束帧
every_nth_frame       # 每第 n 帧数据导出
key                   # 若为 "txt/table" 格式，可添加该参数导出对应 key 的数据

# 支持的 format
"txt/attr"            # 导出 global attributes
"txt/table"           # 导出 DataTable
"xyz"
"vasp"
"lammps/data"
"lammps/dump"
"imd"
"netcdf/amber"


# 导出示例
# 导出 VASP 格式
export_file(
    pipeline,
    "xxx.vasp",
    "vasp",
    reduced=True,           # 分数坐标
)

# 导出 LAMMPS data 格式
export_file(
    pipeline,
    "output.data",
    "lammps/data",
    atom_style="atomic",    # 默认值
)

# 导出 LAMMPS dump 格式
export_file(
    pipeline,
    "output.*.dump",
    "lammps/dump",
    multiple_frames=True,
)

for i in range(pipeline.num_frames):
    export_file(pipeline, f"output.{i}.dump", "lammps/dump", frame=i)

# 对于 "lammps/dump" "xyz" "imd" "netcdf/amber" 格式，需通过 column 指定具体的原子属性
export_file(
    pipeline,
    "output.xyz",
    "xyz",
    columns=["Particle Identifier", "Particle Type", "Position.X", "Position.Y", "Position.Z"],
)

# 导出 "txt/attr"
export_file(
    pipeline,
    "data.txt",
    "txt/attr",
    columns=["Timestep", "CommonNeighborAnalysis.counts.FCC"],
    multiple_frames=True,
)

# 导出 "txt/table"
export_file(
    data=pipeline,
    file=output_fn,
    format="txt/table",
    key="coordination-rdf[average]",
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from ovito.modifiers import ...
from ovito.data import CutoffNeighborFinder, DataCollection


# modifier，对应于 OVITO 软件中的 Modification
VoronoiAnalysisModifier              # Voronoi 分析
ComputePropertyModifier
CoordinationAnalysisModifier         # 配位分析
TimeAveragingModifier                # 时间平均
BondAnalysisModifier                 # 键分析
CreateBondsModifier
CommonNeighborAnalysisModifier
ExpressionSelectionModifier          # 表达式
InvertSelectionModifier
AssignColorModifier                  # 分配颜色/着色
CalculateDisplacementsModifier
DislocationAnalysisModifier          # 位错分析；DXA
SelectTypeModifier
DeleteSelectedModifier
  • Global Attributes 和 Data Tables
1
2
3
4
5
6
7
8
9
10
11
data.attributes[...]            # 获取 Global Attributes 中对应 keyword 的数据
data.tables[...]                # 获取 Data Tables 中对应  keyword 的数据


# CommonNeighborAnalysisModifier
"CommonNeighborAnalysis.counts.FCC"
"CommonNeighborAnalysis.counts.BCC"
"CommonNeighborAnalysis.counts.HCP"
"CommonNeighborAnalysis.counts.Other"

"structures"
  • 格式转换（OVITO Python 中的 DataCollection 可转换成 ASE、pymatgen 的格式）
1
2
3
4
5
6
7
8
from ovito.io.ase import ase_to_ovito, ovito_to_ase
from ovito.io.pymatgen import pymatgen_to_ovito, ovito_to_pymatgen

pipeline = import_file()
data = pipeline.compute()

atoms = ovito_to_ase(data)
structure = ovito_to_pymatgen(data)
  • 计算 RDF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
pipeline.modifiers.append(
    CoordinationAnalysisModifier(
        cutoff=5.0,
        number_of_bins=100,
        partial=False,
    )
)

# 只输出第一帧的数据
print(pipeline.compute().tables["coordination-rdf"].xy())

# 会输出每帧的数据
for data in pipeline.frames:
    print(data.tables["coordination-rdf"].xy())

# 对所有帧的数据做平均
pipeline.modifiers.append(TimeAveragingModifier(operate_on="table:coordination-rdf"))
print(pipeline.compute().tables["coordination-rdf[average]"].xy())