def make_band_edge_states(orbital_infos: BandEdgeOrbitalInfos,
p_edge_state: PerfectBandEdgeState,
defect_charge_info: DefectChargeInfo = None
) -> BandEdgeStates:
vbm_k_idx = orbital_infos.kpt_idx(p_edge_state.vbm_info.kpt_coord)
cbm_k_idx = orbital_infos.kpt_idx(p_edge_state.cbm_info.kpt_coord)
vbm_info = p_edge_state.vbm_info
cbm_info = p_edge_state.cbm_info
states = []
lowest_idx = orbital_infos.lowest_band_index
for spin_idx, orb_info_by_spin in enumerate(orbital_infos.orbital_infos):
if defect_charge_info:
localized_orbs = defect_charge_info.localized_orbitals()[spin_idx]
localized_orbs = [i - lowest_idx for i in localized_orbs]
else:
localized_orbs = None
vbm_idx, vbm_diff = get_similar_orb_idx(orb_info_by_spin[vbm_k_idx],
vbm_info, localized_orbs,
_reversed=True)
vbm_info = EdgeInfo(band_idx=vbm_idx + lowest_idx,
kpt_coord=vbm_info.kpt_coord,
orbital_info=orb_info_by_spin[vbm_k_idx][vbm_idx])
cbm_idx, cbm_diff = get_similar_orb_idx(orb_info_by_spin[cbm_k_idx],
cbm_info, localized_orbs)
cbm_info = EdgeInfo(band_idx=cbm_idx + lowest_idx,
kpt_coord=cbm_info.kpt_coord,
orbital_info=orb_info_by_spin[cbm_k_idx][cbm_idx])
loc_idx_range = [vbm_info.band_idx + 1, cbm_info.band_idx - 1]
localized_orbs = get_localized_orbs(orb_info_by_spin,
loc_idx_range,
orbital_infos.lowest_band_index,
orbital_infos.kpt_weights)
vbm_hole = num_hole_in_vbm(orb_info_by_spin,
vbm_idx=vbm_idx,
weights=orbital_infos.kpt_weights)
cbm_electron = num_electron_in_cbm(orb_info_by_spin,
cbm_idx=cbm_idx,
weights=orbital_infos.kpt_weights)
states.append(BandEdgeState(vbm_info=vbm_info,
cbm_info=cbm_info,
vbm_orbital_diff=vbm_diff,
cbm_orbital_diff=cbm_diff,
localized_orbitals=localized_orbs,
vbm_hole_occupation=vbm_hole,
cbm_electron_occupation=cbm_electron))
return BandEdgeStates(states=states)
def make_edge_states(args):
for d in args.dirs:
print(f"-- {d}")
edge_states = []
edge_characters = loadfn(d / "edge_characters.json")
for spin, edge_character, ref in zip(["spin up ", "spin down"],
edge_characters,
args.perfect_edge_characters):
edge_state = make_band_edge_state(edge_character, ref)
edge_states.append(edge_state)
print(spin, edge_state)
BandEdgeStates(edge_states).to_json_file(d / "band_edge_states.json")
def test_make_band_edge_state(p_edge_state, orb_infos):
actual = make_band_edge_states(orb_infos, p_edge_state)
vbm_info = EdgeInfo(band_idx=9,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=OrbitalInfo(energy=-0.9,
orbitals={
"Mn":
[0.5, 0.7, 0.0, 0.0],
"O": [0.0, 0.0, 0.0, 0.0]
},
occupation=1.0,
participation_ratio=0.1))
cbm_info = EdgeInfo(band_idx=12,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=OrbitalInfo(energy=1.2,
orbitals={
"Mn":
[0.0, 0.0, 0.0, 0.0],
"O": [0.1, 0.3, 0.0, 0.0]
},
occupation=0.02,
participation_ratio=0.1))
localized_orb_1 = LocalizedOrbital(band_idx=10,
ave_energy=0.0,
occupation=1.0,
orbitals={
"Mn": [0.1, 0.2, 0.0, 0.0],
"O": [0.3, 0.4, 0.0, 0.0]
},
participation_ratio=0.1)
localized_orb_2 = LocalizedOrbital(band_idx=11,
ave_energy=1.0,
occupation=0.05,
orbitals={
"Mn": [0.5, 0.8, 0.0, 0.0],
"O": [0.0, 0.0, 0.0, 0.0]
},
participation_ratio=0.1)
expected = BandEdgeStates(states=[
BandEdgeState(vbm_info=vbm_info,
cbm_info=cbm_info,
vbm_orbital_diff=0.09999999999999998,
cbm_orbital_diff=0.09999999999999998,
localized_orbitals=[localized_orb_1, localized_orb_2],
vbm_hole_occupation=0.0,
cbm_electron_occupation=0.03)
])
assert actual == expected
def band_edge_states(orbital_info):
vbm_info = EdgeInfo(band_idx=10,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=orbital_info)
cbm_info = EdgeInfo(band_idx=12,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=orbital_info)
localized_orbital = LocalizedOrbital(band_idx=11,
ave_energy=1.9,
occupation=1.0,
orbitals={"H": [1.0, 0.0, 0.0, 0.0]})
band_edge_state = BandEdgeState(vbm_info=vbm_info,
cbm_info=cbm_info,
vbm_orbital_diff=0.5,
cbm_orbital_diff=0.5,
localized_orbitals=[localized_orbital])
return BandEdgeStates(states=[band_edge_state])
def band_edge_states(orbital_info):
vbm_info = EdgeInfo(band_idx=10,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=orbital_info)
cbm_info = EdgeInfo(band_idx=12,
kpt_coord=(0.0, 0.0, 0.0),
orbital_info=orbital_info)
localized_orbital = LocalizedOrbital(band_idx=11,
ave_energy=1.9,
occupation=1.0,
orbitals={"H": [1.0, 0.0, 0.0, 0.0]})
band_edge_state = BandEdgeState(
vbm_info=vbm_info,
cbm_info=cbm_info,
vbm_orbital_diff=0.5,
cbm_orbital_diff=0.5,
localized_orbitals=[localized_orbital],
vbm_hole_occupation=defaults.state_occupied_threshold - 1e-5,
cbm_electron_occupation=defaults.state_occupied_threshold + 1e-5,
)
return BandEdgeStates(states=[band_edge_state])
def test_band_edge_states_is_shallow(band_edge_states):
assert band_edge_states.is_shallow is True
actual = BandEdgeStates([EdgeState.in_gap_state, EdgeState.no_in_gap])
assert actual.is_shallow is False
def band_edge_states():
return BandEdgeStates([EdgeState.donor_phs, EdgeState.no_in_gap])
def make_defect_formation_energy(args):
formula = args.perfect_calc_results.structure.composition.reduced_formula
chem_pot_diag = ChemPotDiag.from_yaml(args.cpd_yaml)
pcr = args.perfect_calc_results
defects, defect_entries, corrections, edge_states = [], [], [], []
for d in args.dirs:
if args.skip_shallow:
edge_states = BandEdgeStates.from_yaml(d / "band_edge_states.yaml")
if edge_states.is_shallow:
continue
defects.append(loadfn(d / "calc_results.json"))
defect_entries.append(loadfn(d / "defect_entry.json"))
corrections.append(loadfn(d / "correction.json"))
if args.web_gui:
from crystal_toolkit.settings import SETTINGS
import dash_html_components as html
from crystal_toolkit.helpers.layouts import Column
import crystal_toolkit.components as ctc
import dash
edge_states = []
for d in args.dirs:
edge_states.append(
BandEdgeStates.from_yaml(d / "band_edge_states.yaml"))
app = dash.Dash(__name__,
suppress_callback_exceptions=True,
assets_folder=SETTINGS.ASSETS_PATH,
external_stylesheets=[
'https://codepen.io/chriddyp/pen/bWLwgP.css'
])
cpd_plot_info = CpdPlotInfo(chem_pot_diag)
cpd_e_component = CpdEnergyComponent(cpd_plot_info, pcr, defects,
defect_entries, corrections,
args.unitcell.vbm,
args.unitcell.cbm, edge_states)
my_layout = html.Div([Column(cpd_e_component.layout)])
ctc.register_crystal_toolkit(app=app, layout=my_layout, cache=None)
app.run_server(port=args.port)
return
abs_chem_pot = chem_pot_diag.abs_chem_pot_dict(args.label)
title = " ".join([latexify(formula), "point", args.label])
defect_energies = make_energies(pcr, defects, defect_entries, corrections,
abs_chem_pot)
if args.print:
defect_energies = slide_energy(defect_energies, args.unitcell.vbm)
print(" charge E_f correction ")
for e in defect_energies:
print(e)
print("")
print("-- cross points -- ")
for e in defect_energies:
print(e.name)
print(
e.cross_points(ef_min=args.unitcell.vbm,
ef_max=args.unitcell.cbm,
base_ef=args.unitcell.vbm))
print("")
return
plotter = DefectEnergyMplPlotter(title=title,
defect_energies=defect_energies,
vbm=args.unitcell.vbm,
cbm=args.unitcell.cbm,
supercell_vbm=pcr.vbm,
supercell_cbm=pcr.cbm,
y_range=args.y_range,
supercell_edge=args.supercell_edge,
label_line=args.label_line,
add_charges=args.add_charges)
plotter.construct_plot()
plotter.plt.savefig(f"energy_{args.label}.pdf")