def plot_dos_dict(complete_dos, d, xlim=(-3, 3), **kwargs):
"""
Plot DOS dict with pymatgen. The dict is most likely generated with the methods of the
pymatgen CompleteDos class.
Parameters
----------
complete_dos :
CompleteDos object.
d : TYPE
Dict of DOS.
xlim : (tuple), optional
Limits for x axis. The default is (-3,3).
**kwargs : (dict)
Arguments for DosPlotter in pymatgen.
Returns
-------
plt :
Matplotlib object.
"""
dos_plotter = DosPlotter(**kwargs)
for k in d:
dos_plotter.add_dos(k, d[k])
eg = complete_dos.get_gap()
plt = dos_plotter.get_plot(xlim=(xlim[0], eg + xlim[1]))
return plt
def dos_graph_soc(rawdatadir, savedir):
dosrun = Vasprun("{}/vasprun.xml".format(rawdatadir),
soc=True,
parse_dos=True)
dos = dosrun.complete_dos
orbitals = {
"s": Orbital.s,
"p_y": Orbital.py,
"p_z": Orbital.pz,
"p_x": Orbital.px,
"d_xy": Orbital.dxy,
"d_yz": Orbital.dyz,
"d_z2-r2": Orbital.dz2,
"d_xz": Orbital.dxz,
"d_x2-y2": Orbital.dx2
}
spinor_component = {
"mtot": SpinNonCollinear.mtot,
"mx": SpinNonCollinear.mx,
"my": SpinNonCollinear.my,
"mz": SpinNonCollinear.mz
}
for m in spinor_component:
dosplot = DosPlotter()
if m == "mtot":
dosplot.add_dos("Total DOS with SOC", dos.tdos)
dosplot.add_dos_dict(dos.get_element_dos())
plt = dosplot.get_plot(xlim=[-3, 3],
soc=True,
spinor_component=spinor_component[m],
element_colors=True)
plt.grid()
plt.savefig("{}/DOSGraph_{}_{}".format(savedir, m,
"DOS by Element with SOC"))
plt.close()
for m in spinor_component:
dosplot = DosPlotter()
if m == "mtot":
dosplot.add_dos("Total DOS with SOC", dos.tdos)
dosplot.add_dos_dict(dos.get_orbital_dos())
plt = dosplot.get_plot(xlim=[-3, 3],
soc=True,
spinor_component=spinor_component[m])
plt.grid()
plt.savefig("{}/DOSGraph_{}_{}".format(savedir, m,
"DOS by Orbital with SOC"))
plt.close()
# Get detailed info about band gap (source: vasprun.xml)
dos_graph_soc.e_fermi = float(dosrun.efermi)
dos_graph_soc.electronic_gap = \
dosrun.tdos.get_gap_alt(xlim=[-3,3],e_fermi=dos_graph_soc.e_fermi,
tol=0.001,abs_tol=False,
spin=SpinNonCollinear.mtot)
return
def plot_dos(vasprun_path: str):
try:
v = Vasprun(vasprun_path)
except xml.etree.ElementTree.ParseError:
print("\tskipped due to parse error")
return
tdos = v.tdos
plt = DosPlotter()
plt.add_dos("Total DOS", tdos)
plt.show()
def plot_dos(self, sigma=0.05):
"""
plot dos
Args:
sigma:
a smearing
Returns:
a matplotlib object
"""
plotter = DosPlotter(sigma=sigma)
plotter.add_dos("t", self._bz.dos)
return plotter.get_plot()
def plot_dos(self, sigma=0.05):
"""
plot dos
Args:
sigma: a smearing
Returns:
a matplotlib object
"""
plotter = DosPlotter(sigma=sigma)
plotter.add_dos("t", self._bz.dos)
return plotter.get_plot()
def plot_dos(self, T=None, npoints=10000):
"""
Plot the total Dos using DosPlotter()
"""
if self.bzt_interp is None:
raise BoltztrapError("BztInterpolator not present")
tdos = self.bzt_interp.get_dos(T=T, npts_mu=npoints)
# print(npoints)
dosPlotter = DosPlotter()
dosPlotter.add_dos("Total", tdos)
return dosPlotter
def plot_dos(self, T=None, npoints=10000):
"""
Plot the total Dos using DosPlotter()
"""
if self.bzt_interp is None:
raise BoltztrapError("BztInterpolator not present")
tdos = self.bzt_interp.get_dos(T=T,npts_mu=npoints)
#print(npoints)
dosPlotter = DosPlotter()
dosPlotter.add_dos('Total',tdos)
return dosPlotter
class MyDynamicMplCanvas(MyMplCanvas):
"""A canvas that updates itself every second with a new plot."""
def __init__(self, *args, **kwargs):
MyMplCanvas.__init__(self, *args, **kwargs)
self.dsp = DosPlotter()
def update_figure(self, txt):
# Build a list of 4 random integers between 0 and 10 (both inclusive)
self.axes.clear()
with open(txt) as f:
ef = float(f.readline().split()[-2])
arr = [r.split() for r in f.readlines()]
arr = np.array(arr)
arr = arr.astype(np.float)
self.dos = Dos(ef, arr[:, 0], {Spin.up: arr[:, 1]})
self.dsp.add_dos('tdos', self.dos)
self.dsp.get_plot(plt=self.axes)
self.draw()
def get_mp_banddos():
check_matplotlib()
mpr = check_apikey()
print("input the mp-ID")
wait_sep()
in_str = wait()
mp_id = in_str
step_count = 1
proc_str = "Reading Data From " + web + " ..."
procs(proc_str, step_count, sp='-->>')
data = mpr.get_entry_by_material_id(mp_id)
sepline()
print(data)
sepline()
step_count += 1
proc_str = "Reading Band Data From " + web + " ..."
procs(proc_str, step_count, sp='-->>')
band = mpr.get_bandstructure_by_material_id(mp_id)
if band is None:
print("No data obtained online, stop now!")
os.exit(0)
step_count += 1
filename = mp_id + '_band.png'
proc_str = "Writing Data to " + filename + " File..."
bsp = BSPlotter(band)
procs(proc_str, step_count, sp='-->>')
bsp.save_plot(filename=filename, img_format="png")
step_count += 1
proc_str = "Reading DOS Data From " + web + " ..."
procs(proc_str, step_count, sp='-->>')
dos = mpr.get_dos_by_material_id(mp_id)
if dos is None:
print("No data obtained online, stop now!")
step_count += 1
filename = mp_id + '_dos.png'
proc_str = "Writing Data to " + filename + " File..."
dsp = DosPlotter()
dsp.add_dos('Total', dos)
procs(proc_str, step_count, sp='-->>')
dsp.save_plot(filename=filename, img_format="png")
def pdos(vasprun):
# Load the vasprun.xml file
out = Vasprun(os.path.abspath(vasprun))
# Extract the types of species in the structure
species = out.initial_structure.types_of_specie
# Extract the complete DOS
element_dos = out.complete_dos.get_element_dos()
# Initialize the DosPlotter
plotter = DosPlotter()
# Add the element projected DOS to the DOSplotter
for specie in species:
plotter.add_dos(specie.name, element_dos[specie])
plotter.show()
def get_sdos(self, dos_dict, stack=True, xlim=[-10, 10], ylim=None, sigma=0.15):
dos_vasprun = Vasprun(os.path.join(self.path, "vasprun.xml"), parse_projected_eigen=True)
dos_data = dos_vasprun.complete_dos
plotter = DosPlotter(stack=stack, sigma=sigma)
edos = dos_data.get_element_dos()
for key in dos_dict:
if type(dos_dict[key]) is list:
for index, item in enumerate(dos_dict[key]):
if index == 0:
temp = dos_data.get_site_dos(dos_data.structure[item])
else:
temp = temp + dos_data.get_site_dos(dos_data.structure[item])
plotter.add_dos(key, temp)
elif type(dos_dict[key]) is str:
temp = edos[Element(dos_dict[key])]
plotter.add_dos(key, temp)
elif type(dos_dict[key]) is int:
temp = dos_data.get_site_dos(dos_data.structure[dos_dict[key]])
plotter.add_dos(key, temp)
else:
print('Warning: invalid value')
if ylim is not None:
plotter.save_plot(f'{self.path}-dos.png', img_format=u'png', xlim=xlim, ylim=ylim)
else:
plotter.save_plot(f'{self.path}-dos.png', img_format=u'png', xlim=xlim)
kspacing=1)
Si3.set_calculator(calc3)
en3 = Si2.get_potential_energy()
# ***************************************************************************************************
os.chdir('..')
dosrun = Vasprun("DOS/vasprun.xml", parse_dos=True)
dos = dosrun.complete_dos
print("E_Fermi=%f%3s" % (dosrun.efermi, 'eV'))
# print(dos.efermi)
dosplot1 = DosPlotter(sigma=0.05)
dosplot1.add_dos("Total DOS", dos)
plt = dosplot1.get_plot(xlim=(-18, 15))
plt.grid()
plt.savefig("pymatgen_DOS.eps", format="eps")
plt.show()
plt.close()
# bsrun = BSVasprun("Band/vasprun.xml", parse_projected_eigen=True)
bsrun = BSVasprun("Band/vasprun.xml")
bs = bsrun.get_band_structure("Band/KPOINTS")
bsplot = BSPlotter(bs)
plt = bsplot.get_plot(bs)
bsplot.plot_brillouin()
bsplot.get_plot(ylim=(-18, 15), zero_to_efermi=True)
plt.grid()
tdos = vasp.tdos #Total dos calculated at the end of run
idos = vasp.idos # Integrated dos calculated at the end of run
pdos = vasp.pdos # List of list of PDos objects. Access as pdos[atomindex][orbitalindex]
efermi = vasp.efermi
eigenvalues = vasp.eigenvalues
projected_eigenvalues = vasp.projected_eigenvalues
bs = bsvasp.get_band_structure(line_mode=True)
total_dos = tdos
pdoss = pdos
#CDOS = CompleteDos(structure,total_dos,pdoss)
spd_dos = cdos.get_spd_dos
#print spd_dos
element_dos = cdos.get_element_dos
#element_spd_dos = cdos.get_element_spd_dos(el)
dosplotter = DosPlotter()
Totaldos = dosplotter.add_dos('Total DOS', tdos)
Integrateddos = dosplotter.add_dos('Integrated DOS', idos)
#Pdos = dosplotter.add_dos('Partial DOS',pdos)
#Spd_dos = dosplotter.add_dos('spd DOS',spd_dos)
#Element_dos = dosplotter.add_dos('Element DOS',element_dos)
#Element_spd_dos = dosplotter.add_dos('Element_spd DOS',element_spd_dos)
dos_dict = {
'Total DOS': tdos,
'Integrated DOS': idos
} #'Partial DOS':pdos,'spd DOS':spd_dos,'Element DOS':element_dos}#'Element_spd DOS':element_spd_dos
add_dos_dict = dosplotter.add_dos_dict(dos_dict)
get_dos_dict = dosplotter.get_dos_dict()
dos_plot = dosplotter.get_plot()
##dosplotter.save_plot("MAPbI3_dos",img_format="png")
##dos_plot.show()
bsplotter = BSPlotter(bs)
# 3rd run to obtain Band structure
band = MPNonSCFSet.from_prev_calc(static_dir,
mode="line",
standardize=True,
user_incar_settings=myset)
band.write_input(band_dir)
run_vasp(cmd, band_dir)
os.system('cp ' + band_dir + '/vasprun.xml ./band-vasprun.xml')
os.system('cp ' + band_dir + '/KPOINTS ./')
v = BSVasprun("band-vasprun.xml")
bs = v.get_band_structure(kpoints_filename='KPOINTS', line_mode=True)
plt = BSPlotter(bs)
plt.get_plot(vbm_cbm_marker=True)
plt.save_plot(Name + '-band.png', ylim=[-4, 4], img_format='png')
v = Vasprun('dos-vasprun.xml')
tdos = v.tdos
cdos = v.complete_dos
spd_dos = cdos.get_spd_dos()
plotter = DosPlotter(sigma=0.1)
plotter.add_dos("Total DOS", tdos)
# plotter.add_dos("spd_dos", spd_dos)
plotter.save_plot(Name + '-dos.png', img_format='png', xlim=[-4, 4])
shutil.rmtree(band_dir)
shutil.rmtree(dos_dir)
shutil.rmtree(static_dir)
os.chdir('../')
def total_dos():
check_matplotlib()
filename='vasprun.xml'
check_file(filename)
proc_str="Reading Data From "+ filename +" File ..."
procs(proc_str,1,sp='-->>')
vsr=Vasprun(filename,parse_eigen=False)
tdos=vsr.tdos
idos=vsr.idos
E=tdos.energies-tdos.efermi
if vsr.is_spin:
proc_str="This Is a Spin-polarized Calculation."
procs(proc_str,0,sp='-->>')
proc_str="Writting TDOS.dat File ..."
TDOSUP=tdos.densities[Spin.up]
TDOSDOWN=tdos.densities[Spin.down]
ETDOS=np.vstack((E,TDOSUP,TDOSDOWN))
head_line="#%(key1)+12s%(key2)+12s%(key3)+12s"%{'key1':'Energy(eV)','key2':'SpinUp','key3':'SpinDown'}
write_col_data('TDOS.dat',ETDOS.T,head_line)
proc_str="Writting IDOS.dat File ..."
procs(proc_str,3,sp='-->>')
IDOSUP=idos.densities[Spin.up]
IDOSDOWN=idos.densities[Spin.down]
EIDOS=np.vstack((E,IDOSUP,IDOSDOWN))
head_line="#%(key1)+12s%(key2)+12s%(key3)+12s"%{'key1':'Energy(eV)','key2':'IntSpinUp','key3':'IntSpinDown'}
write_col_data('IDOS.dat',EIDOS.T,head_line)
plt1=DosPlotter()
plt2=DosPlotter()
plt1.add_dos('Total DOS',tdos)
plt2.add_dos('Total DOS',idos)
try:
# plt1.show()
plt1.save_plot('TotalDOS.png', img_format="png")
# plt2.show()
plt2.save_plot('IntegratedDOS.png', img_format="png")
except:
print("pls use gnuplot to plot TDOS.dat and IDOS.dat")
else:
if vsr.parameters['LNONCOLLINEAR']:
proc_str="This Is a Non-Collinear Calculation."
else:
proc_str="This Is a Non-Spin Calculation."
procs(proc_str,0,sp='-->>')
proc_str="Writting TDOS.dat File ..."
procs(proc_str,2,sp='-->>')
TDOS=tdos.densities[Spin.up]
ETDOS=np.vstack((E,TDOS))
head_line="#%(key1)+12s%(key2)+12s"%{'key1':'Energy(eV)','key2':'TotalDOS'}
write_col_data('TDOS.dat',ETDOS.T,head_line)
proc_str="Writting IDOS.dat File ..."
procs(proc_str,3,sp='-->>')
IDOS=idos.densities[Spin.up]
EIDOS=np.vstack((E,IDOS))
head_line="#%(key1)+12s%(key2)+13s"%{'key1':'Energy(eV)','key2':'IntegratedDOS'}
write_col_data('IDOS.dat',EIDOS.T,head_line)
plt1=DosPlotter()
plt2=DosPlotter()
plt1.add_dos('Total DOS',tdos)
plt2.add_dos('Integrated DOS',idos)
filename4="TotalDOS.png IntegratedDOS.png"
proc_str="Saving Plot to "+ filename4 +" File ..."
procs(proc_str,4,sp='-->>')
try:
# plt1.show()
plt1.save_plot('TotalDOS.png', img_format="png")
# plt2.show()
plt2.save_plot('IntegratedDOS.png', img_format="png")
except:
print("pls use gnuplot to plot TDOS.dat and IDOS.dat")
def dos_graph(rawdatadir,
savedir,
total_dos=True,
by_element=False,
by_orbital=False):
dosrun = Vasprun("{}/vasprun.xml".format(rawdatadir), parse_dos=True)
dos = dosrun.complete_dos
# Get basic plot
dos_graph.e_fermi = float(dosrun.efermi)
dos_graph.band_gap = float(dosrun.eigenvalue_band_properties[0])
dosplot = DosPlotter()
#dosplot = DosPlotter(sigma=0.1)
if total_dos == True:
dosplot.add_dos("Total DOS", dos)
if by_element == True:
dosplot.add_dos_dict(dos.get_element_dos())
if by_orbital == True:
dosplot.add_dos_dict(dos.get_spd_dos())
plt = dosplot.get_plot(xlim=[-3, 3], ylim=[-15, 15], element_colors=True)
plt.grid()
plt.savefig("{}/DOSGraph".format(savedir))
plt.close()
# Get plot for comparison with SOC total DOS plot
dosplot = DosPlotter()
dosplot.add_dos("Total DOS without SOC", dos)
dosplot.add_dos_dict(dos.get_element_dos())
plt = dosplot.get_plot_total(xlim=[-3, 3], element_colors=True)
plt.grid()
plt.savefig("{}/DOSGraph_tot_DOS by Element without SOC".format(savedir))
plt.close()
dosplot = DosPlotter()
orbitals = {
"s": Orbital.s,
"p_y": Orbital.py,
"p_z": Orbital.pz,
"p_x": Orbital.px,
"d_xy": Orbital.dxy,
"d_yz": Orbital.dyz,
"d_z2-r2": Orbital.dz2,
"d_xz": Orbital.dxz,
"d_x2-y2": Orbital.dx2
}
dosplot.add_dos("Total DOS without SOC", dos)
dosplot.add_dos_dict(dos.get_orbital_dos())
plt = dosplot.get_plot_total(xlim=[-3, 3])
plt.grid()
plt.savefig("{}/DOSGraph_tot_DOS by Orbital without SOC".format(savedir))
plt.close()
"""
# Get quick info about band gap (source: EIGENVAL)
eigenval = Eigenval("{}/EIGENVAL".format(rawdatadir))
dos_graph.band_properties = eigenval.eigenvalue_band_properties
"""
# Get detailed info about band gap and CB/VB in each spin channel
# (source: vasprun.xml)
dos_graph.majority_vbm = \
dosrun.tdos.get_cbm_vbm_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.up)[1]
dos_graph.majority_cbm = \
dosrun.tdos.get_cbm_vbm_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.up)[0]
dos_graph.minority_vbm = \
dosrun.tdos.get_cbm_vbm_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.down)[1]
dos_graph.minority_cbm = \
dosrun.tdos.get_cbm_vbm_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.down)[0]
dos_graph.majority_gap = \
dosrun.tdos.get_gap_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.up)
dos_graph.minority_gap = \
dosrun.tdos.get_gap_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=Spin.down)
dos_graph.electronic_gap = \
dosrun.tdos.get_gap_alt(xlim=[-3,3],e_fermi=dos_graph.e_fermi,
tol=0.3,abs_tol=True,spin=None)
return
@Filename: pymatgenPlotBSDOS202005091027.py
@IDE : PyCharm
@Time1 : 2020-05-09 10:27:36
@Time2 : 2020/5/9 10:27
@Month1 : 5月
@Month2 : 五月
"""
from pymatgen.electronic_structure.plotter import DosPlotter, BSPlotter, BSDOSPlotter
from pymatgen.io.vasp import Vasprun, BSVasprun
vasprun_file = './AlEuO3_Perovskite_DOS/vasprun.xml'
vasprun = Vasprun(vasprun_file)
tdos = vasprun.tdos
plotter = DosPlotter()
plotter.add_dos('Total DOS', tdos)
# plotter.show(xlim=[-20, 20], ylim=[-6, 6])
plotter.show()
completeDos = vasprun.complete_dos
element_dos = completeDos.get_element_dos()
plotter = DosPlotter()
plotter.add_dos_dict(element_dos)
plotter.add_dos('Total DOS', tdos)
plotter.show()
spd_dos = completeDos.get_spd_dos()
plotter = DosPlotter()
plotter.add_dos_dict(spd_dos)
plotter.add_dos('Total DOS', tdos)
plotter.show()
#!/nfshome/villa/anaconda3/bin/python
from pymatgen.io.vasp.outputs import Vasprun
from pymatgen.electronic_structure.plotter import BSPlotter, DosPlotter
vaspout = Vasprun("./vasprun.xml")
# Initializes plotter with some optional args. Defaults are usually
# fine,
complete_dos = vaspout.complete_dos
plt = DosPlotter()
plt.add_dos_dict(complete_dos.get_spd_dos())
tdos = vaspout.tdos
# Adds a DOS with a label.
plt.add_dos("Total", tdos)
#plt.get_plot()
plt.save_plot('dos_mg.pdf', img_format='pdf', xlim=[-7, 6], ylim=[0, 20])
os.chdir(
'/home/ksrc5/FTJ/1.bfo/111-dir/junction/sto/vasp/vac/conf3/4.node03/dense_k_dos/again'
)
vrun = Vasprun('vasprun.xml')
s: Structure = vrun.final_structure
cdos = vrun.complete_dos
pdos = cdos.pdos
doss = dict()
num = 16
arr = np.linspace(0, 1, num, endpoint=False)
darr = arr[1] - arr[0]
for j in arr:
densities = []
for i in s.sites:
if j + darr > i.c >= j:
densities.append(cdos.get_site_dos(i).get_densities())
densities = np.sum(densities, axis=0)
doss[f'{j:.2f}'] = Dos(cdos.efermi, cdos.energies, {Spin.up: densities})
dsp = DosPlotter(sigma=0.1)
ax_array, fig, plt = get_axarray_fig_plt(None, nrows=num, sharex=True)
plt = pretty_plot(12, 6, plt=plt)
for i in range(num):
dsp.__init__(sigma=0.05)
a = doss.popitem()
dsp.add_dos(*a)
fig.add_subplot(num, 1, i + 1)
subplt = dsp.get_plot(xlim=(-1, 2), plt=plt)
plt.savefig('figure.png')
plt.show()
# read in magentic moment from OUTCAR and print
out = Outcar('./OUTCAR')
print('Total Magnetic Moment:', out.total_mag)
if make_dosplot:
# read in BSDOSPlotter function to plot DOS and BS
from pymatgen.electronic_structure.plotter import DosPlotter
# make and save a plot of the band structure and DOS
dos = vsp.complete_dos
energy_range = (-10, 7) # eV, change if desired to change plotting range
# create DosPlotter object with smearing
edosplot = DosPlotter(sigma=dos_smearing)
# plot Total DOS and element-projected dos
edosplot.add_dos("Total DOS", dos)
edosplot.add_dos_dict(dos.get_element_dos())
plt = edosplot.get_plot(xlim=energy_range)
plt.plot((-20, 20), (0, 0), 'k--')
plt.savefig('Element_DOS_plot.png')
# create DosPlotter object with smearing
odosplot = DosPlotter(sigma=dos_smearing)
# plot Total DOS and orbital-projected dos
odosplot.add_dos("Total DOS", dos)
odosplot.add_dos_dict(dos.get_spd_dos())
plt = odosplot.get_plot(xlim=energy_range)
plt.plot((-20, 20), (0, 0), 'k--')
plt.savefig('Orbital_DOS_plot.png')
print('Generated DOS plots')
from pymatgen.electronic_structure.dos import add_densities
from pymatgen.io.vasp.outputs import Vasprun, Dos
from pymatgen.electronic_structure.plotter import DosPlotter
import six
import os
from VASP.vasprun_related.utiles import write_dos
import numpy as np
os.chdir('/home/jinho93/oxides/cluster/tio2/anatase/dos')
vrun = Vasprun('vasprun.xml')
cdos = vrun.complete_dos
arr = []
arr2 = []
num = 0
num2 = 0
for i in vrun.final_structure.sites:
if 0.425 < i.a < 0.575 and 0.425 < i.b < 0.575 and 0.42 < i.c < 0.58:
arr.append(cdos.get_site_dos(i).densities)
num += 1
else:
arr2.append(cdos.get_site_dos(i).densities)
num2 += 1
dos = Dos(cdos.efermi, cdos.energies, six.moves.reduce(add_densities, arr))
dos2 = Dos(cdos.efermi, cdos.energies, six.moves.reduce(add_densities, arr2))
dos.densities = {k: np.array(d / num) for k, d in dos.densities.items()}
dos2.densities = {k: np.array(d / num2) for k, d in dos2.densities.items()}
dsp = DosPlotter()
dsp.add_dos('core', dos2)
write_dos(dos, filename='core.dat')
write_dos(dos2, filename='shell.dat')
dsp.show()
#!/nfshome/villa/anaconda3/bin/python
"""
Spyder Editor
This is a temporary script file.
"""
import os
from pymatgen.core.periodic_table import Element
from pymatgen.io.vasp.outputs import Vasprun
from pymatgen.io.vasp.inputs import Poscar
from pymatgen.electronic_structure.plotter import DosPlotter
complete_dos = Vasprun('vasprun.xml').complete_dos
partial_dos = complete_dos.get_spd_dos()
dos_plotter = DosPlotter()
dos_plotter.add_dos('Total_dos', complete_dos)
for orbital in partial_dos:
dos_plotter.add_dos(orbital, partial_dos[orbital])
plt = dos_plotter.get_plot(xlim=(-10, 10))
plt.show()
class Compound:
'''
This class is meant to take in a VaspRun object and
make it more accessible to get some of its attributes.
These attributes are listed below.
Typical usage looks like::
var = Compound( VaspRun_object )
compound_mass = var.mass
plot = var.getPlot()
**Attributes**
.. attribute:: vasp
The vasp object itself
.. attribute:: z (lowercase)
The Z component of the compound.
i.e. the greatest common
denominator of the compound.
ex. Ag2Bi2I8 --> AgBiI4 ...... z = 2
.. attribute:: formula
The reduced formula of the compound
.. attribute:: full_formula
The full formula used at the start of the VASP run
.. attribute:: elem_List
A list of all the elements in the compound
ex. Ag2Bi2I8 --> ['Ag', 'Bi', 'I']
.. attribute:: mass
The total mass of the object given in AUs or Daltons
.. attribute:: volume
The volume of the cell containing the compound given in
Angstroms cubed
.. attribute:: density
The density of the compound. This is multiplied by 1.66054
to make the units grams/cm^3
.. attribute:: neighbors
A list of each of the atoms nearest neighbors to one another.
See
.. attribute:: latConst
A list of the 'a b c' lattice constants in the compound
i.e. [a const, b const, c const]
**Methods**
.. method:: getPlot()
Returns a Density of states plot
'''
def __init__(self, vasp):
self.vasp = vasp
self.z = self.getGCD()
self.formula = self.getElem()
self.full_formula = self.getElem(False)
self.elem_List = self.elList()
self.mass = Mass(vasp.atomic_symbols)
self.volume = vasp.final_structure.volume
self.density = self.mass / self.volume * 1.66054
self.neighbors = nearNeighbors(vasp)
self.latConst = self.getLatConst()
self.plot = DosPlotter()
def elList(self):
lis = []
temp = {}
for x in self.vasp.atomic_symbols:
if x in temp:
temp[x] += 1
else:
temp[x] = 1
for x in temp:
lis.append(x)
return lis
def getNeighbor(self, el1, el2):
return self.neighbors[el1 + '-' + el2]
def getGCD(self):
el = {}
for x in self.vasp.atomic_symbols:
if x in el:
el[x] += 1
else:
el[x] = 1
return gcd.reduce([el[x] for x in el])
def getElem(self, pretty=True):
string = ""
el = {}
for x in self.vasp.atomic_symbols:
if x in el:
el[x] += 1
else:
el[x] = 1
for x in el:
if pretty:
num = int(el[x] / self.z)
else:
num = int(el[x])
if num == 1:
string += x
else:
string += x + str(num)
return string
def getPlot(self):
self.plot.add_dos("Total Dos", self.vasp.complete_dos)
return self.plot.get_plot()
def getLatConst(self):
return self.vasp.final_structure.lattice.abc
def plot_dos(self):
plotter = DosPlotter(sigma=0.05)
plotter.add_dos("t", self._bz.dos)
plotter.get_plot().show()
for b in bondings:
if b[0] == 1 and b[1] == 0:
ter += 1
elif b[0] == 2 and b[1] == 0:
brig += 1
print(ter, brig)
# %%
import numpy as np
import macrodensity as md
arr = np.genfromtxt('/home/jinho93/molecule/dems/25/100/temp.dat')
arr = arr[:, 3]
mac = md.macroscopic_average(arr, 1, 0.1)
import matplotlib.pyplot as plt
plt.plot(mac)
np.savetxt('/home/jinho93/mac.dat', mac)
# %%
a = np.genfromtxt('mac.dat')
# %%
print(a)
# %%
from pymatgen.io.vasp import Vasprun
from pymatgen import Element
from pymatgen.electronic_structure.plotter import DosPlotter
dsp = DosPlotter()
vrun = Vasprun('vasprun.xml')
dsp.add_dos('total', vrun.tdos)
dsp.show(xlim=(-1, 1.5))
def plot_dos(self):
plotter = DosPlotter(sigma=0.05)
plotter.add_dos("t", self._bz.dos)
plotter.get_plot().show()
