id
int64 187
569k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 3.48
4.02M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 94
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 455
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2,290,166 |
pos2xyz.py
|
aboys-cb_VaspTool/script/tool/pos2xyz.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/13 20:18
# @Author : å…µ
# @email : [email protected]
import sys
from ase.io import read, write
pos_path = sys.argv[1]
write("model.xyz", read(pos_path), format="extxyz")
| 244 |
Python
|
.py
| 9 | 25.777778 | 51 | 0.652361 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,167 |
split_train.py
|
aboys-cb_VaspTool/script/tool/split_train.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/14 12:00
# @Author : 兵
# @email : [email protected]
import sys
from pathlib import Path
import numpy as np
from ase.io import read, write
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from tqdm import tqdm
if Path("train-0.9.xyz").exists():
print("当前目录下已经有train-0.9.xyz文件，将追加到文件，而不是覆盖写入。")
if Path("test-0.1.xyz").exists():
print("当前目录下已经有train-0.9.xyz文件，将追加到文件，而不是覆盖写入。")
path = Path(sys.argv[1])
if path.is_file():
files = [path]
else:
files = []
for file in path.glob("*.xyz"):
files.append(file)
count = 0
trains = []
tests = []
for file in tqdm(files, "文件分割"):
atoms_list = read(file, ":", format="extxyz")
screen_list = []
for atoms in atoms_list:
if (np.any(abs(atoms.calc.results["forces"]) > 100)):
continue
screen_list.append(atoms)
count += len(screen_list)
train, test = train_test_split(screen_list, test_size=0.1, random_state=88, shuffle=True)
# 这里append=True 考虑可以将多个体系合并下
trains.extend(train)
tests.extend(test)
trains = shuffle(trains)
tests = shuffle(tests)
write("./train-0.9.xyz", trains, format='extxyz', append=True)
write("./test-0.1.xyz", tests, format='extxyz', append=True)
print(f"数据集一共有{count}条")
| 1,486 |
Python
|
.py
| 43 | 27.744186 | 93 | 0.677067 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,168 |
split_xyz.py
|
aboys-cb_VaspTool/script/tool/split_xyz.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/8/28 15:14
# @Author : 兵
# @email : [email protected]
# 按照间隔分割xyz 分散任务 多节点提交
# python split_xyz.py new.xyz 10
import sys
from ase.io import read, write
job_num = int(sys.argv[2])
atoms_list = read(sys.argv[1], index=":", format="extxyz", do_not_split_by_at_sign=True)
def split_list(lst, n):
k, m = divmod(len(lst), n)
return [lst[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n)]
result = split_list(atoms_list, job_num)
for i, sublist in enumerate(result):
write(f"split-{i}-num-{len(sublist)}.xyz", sublist)
| 648 |
Python
|
.py
| 17 | 34 | 88 | 0.642978 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,169 |
generate_perturb_structure.py
|
aboys-cb_VaspTool/script/tool/generate_perturb_structure.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/12 11:07
# @Author : 兵
# @email : [email protected]
"""
脚本执行方式：python generate_perturb_structure.py some_structure_path num
some_structure_path 可以是POSCAR、CONTCAR、.vasp、 文件
num是生成微扰结构的个数
"""
import sys
from pathlib import Path
import dpdata
from ase.io import write
from hiphive.structure_generation import generate_mc_rattled_structures
from tqdm import tqdm
path = Path(sys.argv[1])
if path.is_file():
files = [path]
else:
files = []
for file in path.glob("POSCAR"):
files.append(file)
for file in path.glob("*/POSCAR"):
files.append(file)
num = int(sys.argv[2])
for file in tqdm(files):
system = dpdata.System(file, "vasp/poscar")
perturbed_system = system.perturb(pert_num=int(num * 0.4),
cell_pert_fraction=0.05,
atom_pert_distance=0.1,
atom_pert_style='uniform')
structures = perturbed_system.to('ase/structure')
for structure in structures:
structure.info['Config_type'] = "dpdata perturb 0.05 0.1"
# append=True是追加写入 怕缓存影响 直接覆盖写入 如果有需要自己改成True
write(f"./perturb_{system.formula}.xyz", structures, format='extxyz', append=True)
rattle_std = 0.04
min_distance = 0.1
structures_mc_rattle = generate_mc_rattled_structures(
system.to('ase/structure')[0], int(num * 0.6), rattle_std, min_distance, n_iter=20)
for structure in structures_mc_rattle:
structure.info['Config_type'] = "hiphive mc perturb 0.04 0.1"
write(f"./perturb_{system.formula}.xyz", structures_mc_rattle, format='extxyz', append=True)
| 1,801 |
Python
|
.py
| 44 | 32.545455 | 96 | 0.656345 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,170 |
plot_optic.py
|
aboys-cb_VaspTool/script/plot/plot_optic.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/5/22 13:07
# @Author : 兵
# @email : [email protected]
"""
绘制光吸收曲线的图
"""
import matplotlib.pyplot as plt
from pymatgen.analysis.solar.slme import absorption_coefficient, optics, slme
from pymatgen.io.vasp.outputs import Vasprun
plt.style.use("./science.mplstyle")
fig=plt.figure()
sort_name=[
("$Cs_2AgBiI_6$", "./Cs1Ag0.5Bi0.5I3.xml", 0.85),
("$Cs_2Cu_{0.25}Ag_{0.75}BiI_6$", "./Cs1Cu0.125Ag0.375Bi0.5I3.xml", 0.4618),
("$Cs_2AgBi_{0.75}Sb_{0.25}I_6$", "./Cs2AgBi0.75Sb0.25I6.xml", 0.5952)
]
for label, path, gap in sort_name:
vasp=Vasprun(path)
new_en, new_abs =absorption_coefficient(vasp.dielectric)
new_en += gap
plt.plot(new_en, new_abs,label=label)
data = optics(path)
print(data[2], data[3], slme(*data, thickness=5e-6))
plt.legend(ncol=2)
# plt.ylim(0,7)
# plt.ticklabel_format(style='sci', scilimits=(0,0))
plt.xlim(0, 5)
plt.xlabel("Photon energy (eV)")
plt.ylabel("Absorption ($cm^{-1}$)")
plt.yscale('log')
plt.savefig("./absorption_coefficient.png")
| 1,095 |
Python
|
.py
| 33 | 30.272727 | 80 | 0.675676 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,171 |
plot_energy_force.py
|
aboys-cb_VaspTool/script/plot/plot_energy_force.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/24 19:44
# @Author : 兵
# @email : [email protected]
"""
使用方式 python plot_sr_energy_force.py OUTCAR
"""
import os.path
import sys
import matplotlib.pyplot as plt
import numpy as np
from pymatgen.io.vasp.outputs import Outcar
try:
path = sys.argv[1]
except:
if os.path.exists("OUTCAR"):
print("没有传入文件路径，检测到当前目录下有OUTCAR")
path = "OUTCAR"
else:
print("没有传入文件路径，请使用python plot_energy_force.py OUTCAR ")
exit()
print("正在载入文件。。。")
out = Outcar(path)
print("开始解析能量。。。")
out.read_pattern({
"e_fr_energy": r"free energy TOTEN\s+=\s+([\d\-\.]+)",
}, postprocess=float)
energy = np.array(out.data["e_fr_energy"])
energy = energy.flatten()
print("开始解析力。。。")
a = out.read_table_pattern(r"TOTAL-FORCE \(eV/Angst\)\n\s*\-+\n", r"\s+".join([r"(\-*[\.\d]+)"] * 6), r"-*\n",
last_one_only=False, postprocess=float)
force = np.array(a)[:, :, 3:]
force = force.reshape((force.shape[0], -1))
max_froce = np.max(force, 1)
result = np.vstack([np.arange(energy.shape[0]), energy, max_froce]).T
print("正在画图。。。")
fig, axes = plt.subplots(2, 1, sharex=True)
axes1, axes2 = axes
axes1.plot(result[:, 0], result[:, 1], label="energy", color="red")
axes1.set_ylabel("energy(eV)")
axes1.legend()
axes2.plot(result[:, 0], result[:, 2], label="max force", color="green")
axes2.set_ylabel("max force")
axes2.legend()
axes2.set_xlabel("steps")
plt.tight_layout()
plt.savefig("energy_forces.png", dpi=150)
np.savetxt("energy_forces.csv", result, header="step,energy,force", fmt='%.8f', comments="")
print("导出成功！./energy_forces.csv")
| 1,805 |
Python
|
.py
| 51 | 29.764706 | 110 | 0.651819 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,172 |
plot_soc.py
|
aboys-cb_VaspTool/script/plot/plot_soc.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/5/9 22:40
# @Author : 兵
# @email : [email protected]
import itertools
import re
from collections import defaultdict
import numpy as np
from matplotlib import pyplot as plt
from monty.io import zopen
plt.rc('font', family='Times New Roman')
# 修改公式中默认字体
from matplotlib import rcParams
rcParams['mathtext.default'] = 'regular'
import matplotlib as mpl
from pymatgen.electronic_structure.core import Spin
from pymatgen.io.vasp import BSVasprun
class Procar:
def __init__(self, filename):
"""
Args:
filename: Name of file containing PROCAR.
"""
headers = None
with zopen(filename, "rt") as file_handle:
preambleexpr = re.compile(r"# of k-points:\s*(\d+)\s+# of bands:\s*(\d+)\s+# of " r"ions:\s*(\d+)")
kpointexpr = re.compile(r"^k-point\s+(\d+).*weight = ([0-9\.]+)")
bandexpr = re.compile(r"^band\s+(\d+)")
ionexpr = re.compile(r"^ion.*")
expr = re.compile(r"^([0-9]+)\s+")
current_kpoint = 0
current_band = 0
done = False
spin = Spin.down
weights = None
# pylint: disable=E1137
for line in file_handle:
# print(line)
line = line.strip()
if bandexpr.match(line):
m = bandexpr.match(line)
# print(m.group())
current_band = int(m.group(1)) - 1
current_direction = -1
done = False
elif kpointexpr.match(line):
m = kpointexpr.match(line)
# print(m.groups())
current_kpoint = int(m.group(1)) - 1
weights[current_kpoint] = float(m.group(2))
if current_kpoint == 0:
spin = Spin.up if spin == Spin.down else Spin.down
done = False
elif headers is None and ionexpr.match(line):
headers = line.split()
headers.pop(0)
# headers.pop(-1)
data = defaultdict(lambda: np.zeros((nkpoints, nbands, nions, len(headers))))
phase_factors = defaultdict(
lambda: np.full(
(nkpoints, nbands, nions, 3, len(headers)),
np.NaN,
dtype=np.float32,
)
)
elif expr.match(line):
# print(line)
toks = line.split()
index = int(toks.pop(0)) - 1
# toks.pop(-1)
num_data = np.array([float(t) for t in toks[: len(headers)]])
# print(done)
if not done:
data[spin][current_kpoint, current_band, index, :] = num_data
else:
# for orb in range(len(["x","y","z"])):
phase_factors[spin][current_kpoint, current_band, index, current_direction, :] = num_data
elif line.startswith("tot"):
# print("tot")
current_direction += 1
done = True
elif preambleexpr.match(line):
m = preambleexpr.match(line)
nkpoints = int(m.group(1))
nbands = int(m.group(2))
nions = int(m.group(3))
weights = np.zeros(nkpoints)
self.nkpoints = nkpoints
self.nbands = nbands
self.nions = nions
self.weights = weights
self.orbitals = headers
self.data = data
self.phase_factors = phase_factors
def get_projection_on_elements(self, structure):
"""
Method returning a dictionary of projections on elements.
Args:
structure (Structure): Input structure.
Returns:
a dictionary in the {Spin.up:[k index][b index][{Element:values}]]
"""
dico = {}
for spin in self.data:
dico[spin] = [[defaultdict(float) for i in range(self.nkpoints)] for j in range(self.nbands)]
for iat in range(self.nions):
name = structure.species[iat].symbol
for spin, d in self.data.items():
# print(d.shape)
for k, b in itertools.product(range(self.nkpoints), range(self.nbands)):
dico[spin][b][k][name] = np.sum(d[k, b, iat, :])
# return
return dico
def get_spin_component_by_direction(self, direction="z"):
directions = ["x", "y", "z"]
if direction not in directions:
print("只支持x y z三个方向")
return
direction_index = directions.index(direction)
dico = {}
for spin in self.data:
dico[spin] = [[defaultdict(float) for i in range(self.nkpoints)] for j in range(self.nbands)]
for k, b in itertools.product(range(self.nkpoints), range(self.nbands)):
dico[spin][b][k] = np.sum(self.phase_factors[spin][k, b, :, direction_index, :], 0)[-1]
# print(self.phase_factors[spin][k, b, :, direction_index, :])
# print( (np.sum(self.phase_factors[spin][k, b, :, direction_index, :],0) ))
return dico
def get_occupation(self, atom_index, orbital):
"""
Returns the occupation for a particular orbital of a particular atom.
Args:
atom_num (int): Index of atom in the PROCAR. It should be noted
that VASP uses 1-based indexing for atoms, but this is
converted to 0-based indexing in this parser to be
consistent with representation of structures in pymatgen.
orbital (str): An orbital. If it is a single character, e.g., s,
p, d or f, the sum of all s-type, p-type, d-type or f-type
orbitals occupations are returned respectively. If it is a
specific orbital, e.g., px, dxy, etc., only the occupation
of that orbital is returned.
Returns:
Sum occupation of orbital of atom.
"""
orbital_index = self.orbitals.index(orbital)
return {
spin: np.sum(d[:, :, atom_index, orbital_index] * self.weights[:, None]) for spin, d in self.data.items()
}
def get_ticks(bs):
"""
Get all ticks and labels for a band structure plot.
Returns:
dict: A dictionary with 'distance': a list of distance at which
ticks should be set and 'label': a list of label for each of those
ticks.
"""
ticks, distance = [], []
for br in bs.branches:
start, end = br["start_index"], br["end_index"]
# print(br["name"])
labels = br["name"].split("-")
labels=[i for i in labels if i.strip()]
# skip those branches with only one point
if labels[0] == labels[1]:
continue
# add latex $$
for idx, label in enumerate(labels):
if label.startswith("\\") or "_" in label:
labels[idx] = "$" + label + "$"
if ticks and labels[0] != ticks[-1]:
ticks[-1] += "$\\mid$" + labels[0]
ticks.append(labels[1])
distance.append(bs.distance[end])
else:
ticks.extend(labels)
distance.extend([bs.distance[start], bs.distance[end]])
return {"distance": distance, "label": ticks}
def plot_spin_by_direction(path_dir,direction,
energy_min: float = -1,
energy_max: float = 1,):
bs_vasprun = BSVasprun(path_dir+"/vasprun.xml", parse_projected_eigen=True)
pro = Procar(path_dir+"/PROCAR")
projection_on_elements = pro.get_spin_component_by_direction(direction)
band_structure = bs_vasprun.get_band_structure(line_mode=True)
ware1,enery1,spin1 = [],[],[]
ware2,enery2,spin2 = [],[],[]
for band, projection in zip(band_structure.bands[Spin.up], projection_on_elements[Spin.up]):
for distance, energy, tot in zip(band_structure.distance, band, projection):
if tot >0:
ware1.append(distance)
enery1.append(energy - band_structure.efermi)
spin1.append(tot)
else:
ware2.append(distance)
enery2.append(energy - band_structure.efermi)
spin2.append(tot)
fig = plt.figure(figsize=(8,5))
norm = mpl.colors.Normalize(-1,1)
plt.plot([0, max(band_structure.distance)], [0, 0], 'k-.', linewidth=1)
xticks = get_ticks(band_structure)
for dis in xticks["distance"]:
plt.plot([dis,dis],[energy_min, energy_max],'k-.', linewidth=1)
plt.xticks(xticks["distance"],xticks["label"])
plt.xlim(0, max(xticks["distance"]))
a = plt.scatter(ware1, enery1,c=spin1,s=30,lw=0, alpha=0.5 ,cmap=mpl.cm.coolwarm,norm=norm, marker="o")
b = plt.scatter(ware2, enery2,c=spin2,s=20,lw=0, alpha=0.5,cmap=mpl.cm.coolwarm, norm=norm,marker="*")
plt.ylim(energy_min, energy_max)
plt.tick_params(axis='y', direction='in')
plt.colorbar( fraction=0.2, pad=0.1)
# plt.legend((a,b),("spin-up","spin-down"),fontsize=16 , frameon=False )
plt.tight_layout()
ax = plt.gca()
#处理刻度
ax.tick_params(labelsize=16,bottom=False, top=False, left=True, right=False)
plt.subplots_adjust(left=0.2, right=0.85, top=0.9, bottom=0.15, wspace=0.01, hspace=0.1)
plt.xlabel("Wavevector $k$", fontsize=16 )
plt.ylabel("$E-E_F$ / eV", fontsize=16 )
# plt.title("title",x=0.5,y=1.02)
# plt.savefig("bnd.eps",format='eps', transparent=True,bbox_inches='tight', dpi=600)
plt.savefig("band.jpg",bbox_inches='tight', dpi=1200)
if __name__ == '__main__':
#这里传入的是vasprun.xml所在的路径
plot_spin_by_direction("./danzi/vasprun/",
"z",
-2,2)
| 10,164 |
Python
|
.py
| 225 | 32.915556 | 117 | 0.545649 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,173 |
plot_nep.py
|
aboys-cb_VaspTool/script/plot/plot_nep.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/21 16:40
# @Author : å…µ
# @email : [email protected]
import glob
import os
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import r2_score, mean_squared_error
Config = [
{"name": "energy", "unit": "eV/atom"},
{"name": "force", "unit": "eV/A"},
{"name": "virial", "unit": "eV/atom"},
{"name": "stress", "unit": "GPa"},
]
def plot_loss_result(axes: plt.Axes):
loss = np.loadtxt("loss.out")
axes.loglog(loss[:, 1:7],
label=['Total', 'L1-regularization',
'L2-regularization', 'Energy-train',
'Force-train', 'Virial-train'])
axes.set_xlabel('Generation/100')
axes.set_ylabel('Loss')
if np.any(loss[7:10] != 0):
axes.loglog(loss[:, 7:10], label=['Energy-test', 'Force-test', 'Virial-test'])
axes.legend(ncol=2, frameon=False)
def plot_train_result(axes: plt.Axes, config: dict):
types = ["train", "test"]
colors = ['deepskyblue', 'orange']
xys = [(0.1, 0.7), (0.4, 0.1)]
for i in range(2):
data_type = types[i]
color = colors[i]
xy = xys[i]
if not os.path.exists(f"{config['name']}_{data_type}.out"):
continue
data = np.loadtxt(f"{config['name']}_{data_type}.out")
min_value = np.min(data)
max_value = np.max(data)
index = data.shape[1] // 2
axes.plot(data[:, index:], data[:, :index], '.', color=color, label=data_type)
axes.plot(np.linspace(min_value, max_value, num=10), np.linspace(min_value, max_value, num=10), '-', color="k")
rmse = np.sqrt(mean_squared_error(data[:, :index], data[:, index:]))
r2 = r2_score(data[:, :index], data[:, index:])
axes.text(xy[0], xy[1],
f'{data_type} RMSE={1000 * rmse:.3f}({"m" + config["unit"] if config["name"] != "stress" else "MPa"} )\n{data_type} $R^2$={r2:.3f}',
transform=axes.transAxes, fontsize=13)
handles, labels = axes.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
axes.legend(label_dict.values(), label_dict, frameon=False, ncol=2, columnspacing=1)
axes.set_xlabel(f'DFT {config["name"]} ({config["unit"]})')
axes.set_ylabel(f'NEP {config["name"]} ({config["unit"]})')
if __name__ == '__main__':
out_num = len(glob.glob("*.out"))
test_out_num = len(glob.glob("*test.out"))
rows = 2 if out_num >= 4 else 1
cols = (out_num - test_out_num) // rows + (out_num - test_out_num) % rows
fig = plt.figure(figsize=(6 * cols, 5 * rows))
grids = fig.add_gridspec(rows, cols)
if os.path.exists("loss.out"):
axes_index = 0
axes = fig.add_subplot(grids[axes_index])
axes_index += 1
plot_loss_result(axes)
else:
axes_index = 0
for config in Config:
if not os.path.exists(f"{config['name']}_train.out"):
continue
axes = fig.add_subplot(grids[axes_index])
plot_train_result(axes, config)
axes_index += 1
plt.subplots_adjust(left=0.1, right=0.95, bottom=0.1, top=0.95)
plt.savefig("nep_result.png", dpi=150)
| 3,234 |
Python
|
.py
| 77 | 35.246753 | 150 | 0.581662 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,174 |
plot_bond.py
|
aboys-cb_VaspTool/script/plot/plot_bond.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/8/10 22:51
# @Author : 兵
# @email : [email protected]
"""
画原子键长变化的 临时写的
"""
# path=sys.argv[1]
import matplotlib.pyplot as plt
from ase.io import read as ase_read
path = "dump.xyz"
frames = ase_read(path, ":", format="extxyz")
bonds = []
for atoms in frames:
# print(atoms[16])
dis = atoms.get_distance(27, 55)
bonds.append(dis)
plt.plot(list(range(len(bonds))), bonds)
plt.show()
| 491 |
Python
|
.py
| 20 | 21.45 | 45 | 0.660633 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,175 |
plot_dos.py
|
aboys-cb_VaspTool/script/plot/plot_dos.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/5/9 22:40
# @Author : å…µ
# @email : [email protected]
import matplotlib
import numpy as np
matplotlib.use("Agg")
import palettable
from matplotlib import pyplot as plt
from pymatgen.electronic_structure.core import OrbitalType, Spin
from pymatgen.electronic_structure.plotter import DosPlotter
from pymatgen.io.vasp import Vasprun
plt.style.use("./science.mplstyle")
class MyDosPlotter(DosPlotter):
def get_plot(
self,
xlim=None,
ylim=None,
ax=None,
invert_axes=False,
beta_dashed=False,
):
n_colors = min(9, max(3, len(self._doses)))
colors = palettable.colorbrewer.qualitative.Set1_9.mpl_colors
ys = None
all_densities = []
all_energies = []
for dos in self._doses.values():
energies = dos["energies"]
densities = dos["densities"]
if not ys:
ys = {
Spin.up: np.zeros(energies.shape),
Spin.down: np.zeros(energies.shape),
}
new_dens = {}
for spin in [Spin.up, Spin.down]:
if spin in densities:
if self.stack:
ys[spin] += densities[spin]
new_dens[spin] = ys[spin].copy()
else:
new_dens[spin] = densities[spin]
all_energies.append(energies)
all_densities.append(new_dens)
keys = list((self._doses))
# all_densities.reverse()
# all_energies.reverse()
all_pts = []
for idx, key in enumerate(keys):
for spin in [Spin.up, Spin.down]:
if spin in all_densities[idx]:
energy = all_energies[idx]
densities = list(int(spin) * all_densities[idx][spin])
if invert_axes:
x = densities
y = energy
else:
x = energy
y = densities
all_pts.extend(list(zip(x, y)))
if self.stack:
ax.fill(x, y, color=colors[idx % n_colors], label=str(key))
elif spin == Spin.down and beta_dashed:
ax.plot(x, y, color=colors[idx % n_colors], label=str(key), linestyle="--" )
else:
ax.plot(x, y, color=colors[idx % n_colors], label=str(key) )
if xlim:
ax.set_xlim(xlim)
if ylim:
ax.set_ylim(ylim)
elif not invert_axes:
xlim = ax.get_xlim()
relevant_y = [p[1] for p in all_pts if xlim[0] < p[0] < xlim[1]]
ax.set_ylim((min(relevant_y), max(relevant_y)))
if not xlim and invert_axes:
ylim = ax.get_ylim()
relevant_y = [p[0] for p in all_pts if ylim[0] < p[1] < ylim[1]]
ax.set_xlim((min(relevant_y), max(relevant_y)))
if self.zero_at_efermi:
xlim = ax.get_xlim()
ylim = ax.get_ylim()
ax.plot(xlim, [0, 0], "k--" ) if invert_axes else ax.plot([0, 0], ylim, "k--" )
if invert_axes:
ax.axvline(x=0, color="k", linestyle="-" )
# ax.xaxis.set_major_locator(ticker.MaxNLocator(nbins=2, integer=True))
# ax.yaxis.set_major_locator(ticker.MaxNLocator( integer=True))
# ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
# ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())
else:
# ax.xaxis.set_major_locator(ticker.MaxNLocator( integer=True))
# ax.yaxis.set_major_locator(ticker.MaxNLocator(nbins=2, integer=True))
# ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
# ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())
ax.axhline(y=0, color="k", linestyle="-" )
# ax.tick_params(axis='both', which='both', direction='in')
# ax.tick_params(axis='both', which='both', direction='in')
# plt.xticks(fontsize=16)
# plt.yticks(fontsize=16)
# plt.tick_params(labelsize=16)
# Remove duplicate labels with a dictionary
handles, labels = ax.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
ax.legend(label_dict.values(), label_dict, frameon=False, ncol=2, columnspacing=1 )
def plot_all(self, dos_conf, invert_axes=True, energy_lim=None, density_lim=None):
orb_map = ["s", "p", "d", "f"]
if invert_axes:
xlim, ylim = density_lim, energy_lim
fig, axes = plt.subplots(1, len(dos_conf), sharex=True, sharey=True)
else:
xlim, ylim = energy_lim, density_lim
fig, axes = plt.subplots(len(dos_conf), 1, sharex=True, sharey=True)
if len(dos_conf)==1:
axes=[axes]
axes:list[plt.Axes]
for col, conf in enumerate(dos_conf):
vasprun = Vasprun(conf["path"], parse_potcar_file=False)
# self.add_dos("total", vasprun.tdos)
for elem, orbits in conf["projected"].items():
if isinstance(elem,int):
site=vasprun.final_structure[elem-1]
elem=site.label
elem_dos = vasprun.complete_dos.get_site_spd_dos(site)
else:
elem_dos = vasprun.complete_dos.get_element_spd_dos(elem)
for orb in orbits:
orb_type = OrbitalType(orb_map.index(orb))
self.add_dos(f"{elem}-{orb}", elem_dos[orb_type])
self.get_plot(xlim, ylim, ax=axes[col], invert_axes=invert_axes)
if invert_axes:
if col == 0:
axes[0].set_ylabel("Energy (eV)")
axes[col].set_xlabel("DOS (states/eV)" )
else:
if col == len(dos_conf) - 1:
axes[col].set_xlabel("Energy (eV)")
axes[col].set_ylabel("DOS (states/eV)" )
self._doses.clear()
plt.tight_layout(h_pad=0)
if __name__ == '__main__':
plotter = MyDosPlotter()
dos_conf = [
{"path": "./vasprun.xml",
"projected": {"I": ["p"], "Ag": ["d"], "Bi": ["p"]},
},
]
plotter.plot_all(dos_conf, energy_lim=(-2, 2), density_lim=(-10, 10), invert_axes=False)
plt.savefig("./dos.png", dpi=300)
| 6,571 |
Python
|
.py
| 149 | 31.302013 | 100 | 0.527298 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,176 |
msd.py
|
aboys-cb_VaspTool/script/plot/msd.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/18 19:18
# @Author : 兵
# @email : [email protected]
from pymatgen.analysis.diffusion.analyzer import DiffusionAnalyzer
from pymatgen.core.trajectory import Trajectory
from pymatgen.io.vasp.outputs import Vasprun
# 这一步是读取 XDATCAR，得到一系列结构信息
traj = Vasprun("./vasprun.xml").get_trajectory()
traj: Trajectory
# 这一步是实例化 DiffusionAnalyzer 的类
# 并用 from_structures 方法初始化这个类； 900 是温度，2 是POTIM 的值，1是间隔步数
# 间隔步数（step_skip）不太容易理解，但是根据官方教程:
# dt = timesteps * self.time_step * self.step_skip
diff = DiffusionAnalyzer.from_structures(traj, 'Ag', 300, 1, 10)
# 可以用内置的 plot_msd 方法画出 MSD 图像
# 有些终端不能显示图像，这时候可以调用 export_msdt() 方法，得到数据后再自己作图
# diff.plot_msd()
# plt.show()
| 957 |
Python
|
.py
| 20 | 35.2 | 66 | 0.758865 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,177 |
plt.py
|
aboys-cb_VaspTool/script/plot/plt.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/13 22:37
# @Author : å…µ
# @email : [email protected]
from gpyumd.load import load_thermo
from pylab import *
matplotlib.use('Agg')
data = load_thermo()
plot(list(range(data["U"].shape[0])), data["U"])
savefig("./en.png", dpi=150)
| 304 |
Python
|
.py
| 11 | 26.363636 | 48 | 0.652921 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,178 |
plot_aimd.py
|
aboys-cb_VaspTool/script/plot/plot_aimd.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/13 12:09
# @Author : 兵
# @email : [email protected]
"""
绘制分子动力学的
"""
import sys
import matplotlib.pyplot as plt
from pymatgen.io.vasp.outputs import Vasprun
plt.style.use("./science.mplstyle")
# vasp_path=sys.argv[1]
plt.figure(figsize=(3.5, 2.625))
# vasp_path = "./vasprun.xml"
vasp_path = sys.argv[1]
vasprun = Vasprun(vasp_path, parse_potcar_file=False)
name = vasprun.final_structure.composition.to_pretty_string()
energies = [step["e_0_energy"] for step in vasprun.ionic_steps]
steps = list(range(1, len(energies) + 1))
plt.plot(steps, energies, label=name)
plt.ylabel("E0 Energy(eV)")
plt.xlabel("time(fs)")
plt.legend()
plt.tight_layout()
plt.savefig(f"./aimd-{name}.png", dpi=300)
| 784 |
Python
|
.py
| 26 | 28.230769 | 63 | 0.715646 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,179 |
plot_dos_cohp.py
|
aboys-cb_VaspTool/script/plot/plot_dos_cohp.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/5/18 19:19
# @Author : 兵
# @email : [email protected]
from itertools import product
from typing import Literal
import matplotlib.pyplot as plt
import numpy as np
import palettable
from matplotlib.patches import ConnectionPatch
from numpy._typing import ArrayLike
from pymatgen.electronic_structure.cohp import Cohp, CompleteCohp
from pymatgen.electronic_structure.core import Spin, Orbital, OrbitalType
from pymatgen.electronic_structure.dos import Dos
from pymatgen.io.vasp import Vasprun
plt.style.use("./science.mplstyle")
class DosCohpPlotter:
def __init__(self, zero_at_efermi=True):
self.figure = plt.figure( )
self.stack=False
self.zero_at_efermi = zero_at_efermi
self._doses: dict[
str, dict[Literal["energies", "densities", "efermi"], float | ArrayLike | dict[Spin, ArrayLike]]
] = {}
self._cohps: dict[str, dict[str, np.ndarray | dict[Spin, np.ndarray] | float]] = {}
def add_dos(self, label, dos:Dos):
"""Add a dos for plotting.
从其他地方粘贴的
Args:
label: label for the DOS. Must be unique.
dos: Dos object
"""
if dos.norm_vol is None:
self._norm_val = False
energies = dos.energies - dos.efermi if self.zero_at_efermi else dos.energies
densities = dos.densities
efermi = dos.efermi
self._doses[label] = {
"energies": energies,
"densities": densities,
"efermi": efermi,
}
def add_cohp(self, label, cohp:Cohp):
"""Add a COHP for plotting.
从其他地方粘贴的
Args:
label: Label for the COHP. Must be unique.
cohp: COHP object.
"""
energies = cohp.energies - cohp.efermi if self.zero_at_efermi else cohp.energies
populations = cohp.get_cohp()
int_populations = cohp.get_icohp()
self._cohps[label] = {
"energies": energies,
"COHP": populations,
"ICOHP": int_populations,
"efermi": cohp.efermi,
}
@staticmethod
def get_orb_list(orb: str):
"""
:param orb: str 4d or 5p
:return:
"""
result = []
for i in Orbital:
if str(i.orbital_type) == orb[1:]:
result.append(orb[:1] + i.name)
return result
def compose_orbit(self,orb):
"""
对传入的轨道进行拆分组合
:param orb: 4d-5p or 4d-5px or 4dx2-5p
:return:
"""
a, b = orb.split("-")
a_orb = [a] if a[-1] not in ["s", "p", "d", "f"] else self.get_orb_list(a)
b_orb = [b] if b[-1] not in ["s", "p", "d", "f"] else self.get_orb_list(b)
result = []
for a, b in product(a_orb, b_orb):
result.append(f"{a}-{b}")
return result
def parse_config(self,dos_config:dict, cohp_config:dict):
"""
解析下投影配置文件 将需要画图的放在字典里
:param dos_config: dict
:param cohp_config: dict
:return:
Examples
-----
dos_conf = {"vasprun_path": "../cache/Cs1Ag0.5Bi0.5I3/vasprun.xml",
"projected": {"I": ["p"],"Ag": [ "d"],"Bi": ["p" ] },
}
cohp_conf={
"cohpcar_path":"../cache/Cs1Ag0.5Bi0.5I3/COHPCAR.lobster",
"poscar_path":"../cache/Cs1Ag0.5Bi0.5I3/POSCAR",
"projected": {"I": ["p"], "Ag": ["d"], "Bi": ["p"]}
}
plotter=DosCohpPlotter()
plotter.parse_config(dos_conf,cohp_conf)
"""
#解析dos的
orb_map = ["s", "p", "d", "f"]
vasprun = Vasprun(dos_config["vasprun_path"], parse_potcar_file=False)
#加入总的dos 先不加入 主要看投影
# self.add_dos("total", vasprun.tdos)
for elem, orbits in dos_config["projected"].items():
if isinstance(elem, int):
site = vasprun.final_structure[elem - 1]
elem = site.label
elem_dos = vasprun.complete_dos.get_site_spd_dos(site)
else:
elem_dos = vasprun.complete_dos.get_element_spd_dos(elem)
for orb in orbits:
orb_type = OrbitalType(orb_map.index(orb))
self.add_dos(f"{elem}-{orb}", elem_dos[orb_type])
#解析cohp
complete_cohp = CompleteCohp.from_file(filename=cohp_config["cohpcar_path"], fmt='LOBSTER',
structure_file=cohp_config["poscar_path"])
for elem_label, config in cohp_config["projected"].items():
if isinstance(config["label"], tuple):
label = [str(i) for i in range(config["label"][0], config["label"][1] + 1)]
else:
label = config["label"]
cohp=None
for orb in config["orb"]:
for _orb in self.compose_orbit(orb):
# complete_cohp.get_summed_cohp_by_label_list()
_cohp = complete_cohp.get_summed_cohp_by_label_and_orbital_list(label,[_orb] * len(label))
if cohp is None:
cohp=_cohp
else:
#对轨道进行加和
if Spin.up in cohp.cohp.keys():
cohp.cohp[Spin.up]+=_cohp.cohp[Spin.up]
if Spin.down in cohp.cohp.keys():
cohp.cohp[Spin.down] += _cohp.cohp[Spin.down]
if cohp:
self.add_cohp(elem_label, cohp)
def get_plot(self, energy_lim=(-2, 2), density_lim=(-10, 10), cohp_lim=(-5,5), invert_axes=False):
if invert_axes:
#反转 竖排模式 左边为Dos 右边为Cohp
pass
gridspec = self.figure.add_gridspec(1, 2,
wspace=0.1 ,
width_ratios=[1,1],
)
else:
#上下堆叠 上面为Dos 下面为Cohp
gridspec = self.figure.add_gridspec(2, 1,
hspace=0.1 ,
height_ratios=[1,1],
)
#先画Dos
dos_axes=self.figure.add_subplot(gridspec[0])
n_colors = min(9, max(3, len(self._doses)))
colors = palettable.colorbrewer.qualitative.Set1_9.mpl_colors
all_pts = []
idx=0
for idx, key in enumerate(self._doses.keys()):
for spin in [Spin.up, Spin.down]:
if spin in self._doses[key]["densities"]:
energy = self._doses[key]["energies"]
densities = list(int(spin) * self._doses[key]["densities"][spin])
if invert_axes:
x = densities
y = energy
else:
x = energy
y = densities
all_pts.extend(list(zip(x, y)))
if self.stack:
dos_axes.fill(x, y, color=colors[idx % n_colors], label=str(key))
else:
dos_axes.plot(x, y, color=colors[idx % n_colors], label=str(key) )
# 画cohp
cohp_axes = self.figure.add_subplot(gridspec[1])
n_colors = min(9, max(3, len(self._cohps)))
for idx, key in enumerate(self._cohps.keys()):
energies = self._cohps[key]["energies"]
populations = self._cohps[key]["COHP"]
for spin in [Spin.up, Spin.down]:
if spin in populations:
if invert_axes:
x = -populations[spin]
y = energies
else:
x = energies
y = -populations[spin]
if spin == Spin.up:
cohp_axes.plot(
x,
y,
color=colors[idx % n_colors],
linestyle="-",
label=str(key),
)
else:
cohp_axes.plot(x, y, color=colors[idx % n_colors], linestyle="--", linewidth=3)
cohp_axes.tick_params(axis='both', which='both', direction='in')
dos_axes.tick_params(axis='both', which='both', direction='in')
energy_label = "$E - E_f$ (eV)" if self.zero_at_efermi else "Energy (eV)"
energy_label="Energy (eV)"
if invert_axes:
#画一个水平线
con = ConnectionPatch(xyA=(density_lim[0],0), xyB=(cohp_lim[1],0), coordsA="data", coordsB="data",
axesA=dos_axes, axesB=cohp_axes, color="k",linestyle="--", linewidth=0.5)
cohp_axes.add_artist(con)
cohp_axes.text(0.1 , 0.1, 'Antibonding', transform=cohp_axes.transAxes,rotation="vertical" , color='k')
cohp_axes.text(0.8, 0.16, 'Bonding', transform=cohp_axes.transAxes,rotation="vertical" , color='k')
# cohp_axes.set_xticklabels([])
cohp_axes.set_yticklabels([])
cohp_axes.set_xlim(cohp_lim)
cohp_axes.set_ylim(energy_lim)
cohp_axes.axvline(x=0, color="k", linestyle="-", linewidth=0.5)
handles, labels = cohp_axes.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
cohp_axes.legend(label_dict.values(), label_dict, loc="upper right" )
cohp_axes.set_xlabel("-COHP")
# dos_axes.set_xticklabels([])
dos_axes.axvline(x=0, color="k", linestyle="-", linewidth=0.5 )
dos_axes.set_xlim(density_lim)
dos_axes.set_ylim(energy_lim)
dos_axes.set_ylabel(energy_label)
dos_axes.set_xlabel("DOS (states/eV)")
handles, labels = dos_axes.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
dos_axes.legend(label_dict.values(), label_dict, loc="upper right" )
else:
con = ConnectionPatch(xyA=( 0,density_lim[1]), xyB=(0,cohp_lim[0]), coordsA="data", coordsB="data",
axesA=dos_axes, axesB=cohp_axes, color="k",linestyle="--")
cohp_axes.add_artist(con)
cohp_axes.text(0.2 , 0.1, 'Antibonding', transform=cohp_axes.transAxes, color='k')
cohp_axes.text(0.2 , 0.7, 'Bonding', transform=cohp_axes.transAxes, color='k')
# cohp_axes.set_yticklabels([])
cohp_axes.axhline(y=0, color="k", linestyle="-" )
cohp_axes.set_ylim(cohp_lim)
cohp_axes.set_xlim(energy_lim)
cohp_axes.set_ylabel("-COHP")
cohp_axes.set_xlabel(energy_label)
dos_axes.set_xticklabels([])
# dos_axes.set_yticklabels([])
dos_axes.set_xlim(energy_lim)
dos_axes.set_ylim(density_lim)
dos_axes.axhline(y=0, color="k", linestyle="-" )
dos_axes.set_ylabel("DOS (states/eV)")
handles, labels = dos_axes.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
dos_axes.legend(label_dict.values(), label_dict,ncols=2, loc="upper right" )
handles, labels = cohp_axes.get_legend_handles_labels()
label_dict = dict(zip(labels, handles))
cohp_axes.legend(label_dict.values(), label_dict,ncols=2, loc="upper right" )
#如果边框太多空白 调整这里
plt.subplots_adjust(left=0.1, right=0.9 ,bottom=0.1, top=0.9 )
if __name__ == '__main__':
# dos_conf = {"vasprun_path": "../cache/Cs1Ag0.5Bi0.5I3/vasprun.xml",
# "projected": {"I": ["p"],"Ag": [ "d"],"Bi": ["s","p" ] },
# }
#
# cohp_conf={
# "cohpcar_path":"../cache/Cs1Ag0.5Bi0.5I3/COHPCAR.lobster",
# "poscar_path":"../cache/Cs1Ag0.5Bi0.5I3/POSCAR",
# "projected": {"Bi(6s)-I(5p)":{
# "label":(185,190),
# "orb":["6s-5p"]
# },
# "Bi(6p)-I(5p)": {
# "label": (185, 190),
# "orb": ["6p-5p"]
# },
# "Ag(4d)-I(5p)": {
# "label": (161, 166),
# "orb": ["4d-5p"]
# }
# }
#
# }
sb_dos_conf = {"vasprun_path": "../cache/Cs8Ag4Bi3Sb1I24/vasprun.xml",
"projected": {"I": ["p"],"Ag": [ "d"],"Bi": ["s","p" ] , "Sb": ["s","p" ] },
}
sb_cohp_conf={
"cohpcar_path":"../cache/Cs8Ag4Bi3Sb1I24/COHPCAR.lobster",
"poscar_path":"../cache/Cs8Ag4Bi3Sb1I24/POSCAR",
"projected": {"Bi(6s)-I(5p)":{
"label":(185,190),
"orb":["6s-5p"]
},
"Bi(6p)-I(5p)": {
"label": (185, 190),
"orb": ["6p-5p"]
},
"Sb(5s)-I(5p)": {
"label": (203, 208),
"orb": ["5s-5p"]
},
"Sb(5p)-I(5p)": {
"label": (203, 208),
"orb": ["5p-5p"]
},
"Ag(4d)-I(5p)": {
"label": (161, 166),
"orb": ["4d-5p"]
}
}
}
# cu_dos_conf = {"vasprun_path": "../cache/Cu/vasprun.xml",
# "projected": {"I": ["p"], "Ag": ["d"], "Bi": ["s", "p"], "Cu": ["d"]},
# }
#
# cu_cohp_conf = {
# "cohpcar_path": "../cache/Cu/COHPCAR.lobster",
# "poscar_path": "../cache/Cu/POSCAR",
# "projected": {"Bi(6s)-I(5p)": {
# "label": (185, 190),
# "orb": ["6s-5p"]
# },
# "Bi(6p)-I(5p)": {
# "label": (185, 190),
# "orb": ["6p-5p"]
# },
#
# "Cu(4d)-I(5p)": {
# "label": (161, 166),
# "orb": ["3d-5p"]
# },
# "Ag(4d)-I(5p)": {
# "label": (167, 172),
# "orb": ["4d-5p"]
# }
# }
#
# }
# 这里可以是分轨道 比如"6px-5px" 如果不是分轨道 会把所有的加和
plotter=DosCohpPlotter()
plotter.parse_config(sb_dos_conf,sb_cohp_conf)
plotter.get_plot(invert_axes=True,cohp_lim=(-10,20),energy_lim=(-2,2),density_lim=(0,10))
plt.savefig("dos_and_cohp_sb.png")
| 14,961 |
Python
|
.py
| 338 | 30.653846 | 117 | 0.477212 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,180 |
plot_gpumd_result.py
|
aboys-cb_VaspTool/script/plot/plot_gpumd_result.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2024/6/13 22:23
# @Author : 兵
# @email : [email protected]
import os.path
import matplotlib
matplotlib.use('Agg')
from gpyumd.load import load_thermo
import matplotlib.pyplot as plt
if os.path.exists("thermo.out"):
data = load_thermo()
plt.plot(list(range(data["U"].shape[0])), data["U"])
plt.savefig("./energy.png", dpi=150)
else:
print("没有找到画图文件，请完善逻辑！")
| 473 |
Python
|
.py
| 16 | 25.25 | 56 | 0.674584 |
aboys-cb/VaspTool
| 8 | 0 | 0 |
GPL-2.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
2,290,181 |
main.py
|
chitang233_KeyboxChecker/main.py
|
import subprocess
import tempfile
import re
import requests
import telebot
from os import getenv
def verify_certificate_chain(keybox):
keybox = keybox.replace("\r\n", "\n")
keybox = keybox.split("</CertificateChain>")[0]
pattern = r"-----BEGIN CERTIFICATE-----\n.*?\n-----END CERTIFICATE-----"
certificates = re.findall(pattern, keybox, re.DOTALL)
if len(certificates) < 2:
return "❓ Invalid certificate chain"
elif len(certificates) == 2:
certificates = {"end_entity": certificates[0], "root": certificates[1]}
elif len(certificates) == 3:
certificates = {"end_entity": certificates[0], "intermediate": certificates[1], "root": certificates[2]}
else:
return "❓ Invalid certificate chain"
with tempfile.NamedTemporaryFile(delete=True) as root_cert_file:
root_cert_file.write(certificates['root'].encode())
root_cert_file.flush()
root_pubkey = subprocess.run(
['openssl', 'x509', '-in', root_cert_file.name, '-pubkey', '-noout'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
if root_pubkey.returncode != 0:
return f"OpenSSL error: {root_pubkey.stderr}"
if root_pubkey.returncode == 0:
with open("google_ca_pubkey.key", "r") as google_pubkey_file:
google_pubkey = google_pubkey_file.read()
if root_pubkey.stdout.encode() != google_pubkey.encode():
message = "❌ Root certificate is not signed by Google"
else:
message = "✅ Root certificate is signed by Google"
with tempfile.NamedTemporaryFile(delete=True) as end_entity_cert_file:
end_entity_cert_file.write(certificates['end_entity'].encode())
end_entity_cert_file.flush()
if "intermediate" in certificates:
with tempfile.NamedTemporaryFile(delete=True) as intermediate_cert_file:
intermediate_cert_file.write(certificates['intermediate'].encode())
intermediate_cert_file.flush()
result = subprocess.run(
['openssl', 'verify', '-CAfile', root_cert_file.name, '-untrusted', intermediate_cert_file.name, end_entity_cert_file.name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
else:
result = subprocess.run(
['openssl', 'verify', '-CAfile', root_cert_file.name, end_entity_cert_file.name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
if result.returncode != 0:
message += f"\n❌ Invalid certificate chain: {result.stderr}"
else:
message += "\n✅ Certificate chain is valid"
return message
def extract_certificate_information(cert_pem):
with tempfile.NamedTemporaryFile(delete=True) as temp_cert_file:
temp_cert_file.write(cert_pem.encode())
temp_cert_file.flush()
result = subprocess.run(
['openssl', 'x509', '-text', '-noout', '-in', temp_cert_file.name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
if result.returncode != 0:
raise RuntimeError(f"OpenSSL error: {result.stderr}")
cert_text = result.stdout
pattern = r"Serial Number:\s*([\da-f:]+)"
match = re.search(pattern, cert_text, re.IGNORECASE)
if match:
serial_number = hex(int(match.group(1).replace(":", ""), 16)).split("0x")[1]
else:
return "❌ Cannot find serial number"
pattern = r"Subject: "
match = re.search(pattern, cert_text, re.IGNORECASE)
if match:
subject = cert_text[match.end():].split("\n")[0]
else:
return "❌ Cannot find subject"
return [serial_number, subject]
def common_handler(message):
if message.reply_to_message and message.reply_to_message.document:
document = message.reply_to_message.document
elif message.document:
document = message.document
else:
bot.reply_to(message, "Please reply to a message with a keybox file or send a keybox file")
return None
file_info = bot.get_file(document.file_id)
file = requests.get('https://api.telegram.org/file/bot{0}/{1}'.format(API_TOKEN, file_info.file_path))
certificate = extract_certificate_information(file.text.split("<Certificate format=\"pem\">")[1].split("</Certificate>")[0])
reply = f"ℹ️ Serial Number: `{certificate[0]}`\nℹ️ Subject: `{certificate[1]}`"
reply += f"\n{verify_certificate_chain(file.text)}"
try:
status = get_google_sn_list()['entries'][certificate[0]]
reply += f"\n❌ Serial number found in Google's revoked keybox list\nReason: `{status['reason']}`"
except KeyError:
if certificate[0] == "4097":
reply += "\n❌ AOSP keybox found, this keybox is untrusted"
else:
reply += "\n✅ Serial number not found in Google's revoked keybox list"
bot.reply_to(message, reply, parse_mode='Markdown')
def get_google_sn_list():
url = "https://android.googleapis.com/attestation/status"
response = requests.get(
url,
headers={
"Cache-Control": "max-age=0, no-cache, no-store, must-revalidate",
"Pragma": "no-cache",
"Expires": "0",
}
).json()
return response
API_TOKEN = getenv('API_TOKEN')
bot = telebot.TeleBot(API_TOKEN)
@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
bot.reply_to(message, "Send me keybox file and I will check if it's revoked")
@bot.message_handler(content_types=['document'])
def handle_document(message):
common_handler(message)
@bot.message_handler(commands=['keybox'])
def handle_keybox(message):
common_handler(message)
bot.infinity_polling()
| 5,253 |
Python
|
.py
| 133 | 36.12782 | 130 | 0.716088 |
chitang233/KeyboxChecker
| 8 | 0 | 0 |
AGPL-3.0
|
9/5/2024, 10:49:00 PM (Europe/Amsterdam)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.