def setUp(self):
with open(os.path.join(test_dir, 'si_dos.json'), 'r') as sDOS:
si_dos = CompleteDos.from_dict(json.load(sDOS))
self.df = pd.DataFrame({'dos': [si_dos], 'site': [0]})
with open(os.path.join(test_dir, 'nb3sn_dos.json'), 'r') as sDOS:
nb3sn_dos = CompleteDos.from_dict(json.load(sDOS))
self.nb3sn_df = pd.DataFrame({'dos': [nb3sn_dos]})
def setUp(self):
with open(os.path.join(test_dir, 'si_dos.json'), 'r') as sDOS:
si_dos = CompleteDos.from_dict(json.load(sDOS))
self.df = pd.DataFrame({'dos': [si_dos], 'site': [0]})
with open(os.path.join(test_dir, 'nb3sn_dos.json'), 'r') as sDOS:
nb3sn_dos = CompleteDos.from_dict(json.load(sDOS))
self.nb3sn_df = pd.DataFrame({'dos': [nb3sn_dos]})
def setUp(self):
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"complete_dos.json")) as f:
self.dos = CompleteDos.from_dict(json.load(f))
with zopen(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"pdag3_complete_dos.json.gz")) as f:
self.dos_pdag3 = CompleteDos.from_dict(json.load(f))
def setUp(self):
with open(os.path.join(test_dir, "complete_dos.json"),
"r",
encoding='utf-8') as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.plotter = DosPlotter(sigma=0.2, stack=True)
warnings.simplefilter("ignore")
def get_dos(self, task_id):
m_task = self.collection.find_one({"task_id": task_id}, {"calcs_reversed": 1})
fs_id = m_task['calcs_reversed'][0]['dos_fs_id']
fs = gridfs.GridFS(self.db, 'dos_fs')
dos_json = zlib.decompress(fs.get(fs_id).read())
dos_dict = json.loads(dos_json.decode())
return CompleteDos.from_dict(dos_dict)
def extract_dos(mat):
dos = None
if "dos" in mat["bandstructure"]:
dos_dict = mat["bandstructure"]["dos"]
dos = CompleteDos.from_dict(dos_dict)
return dos
def setUpClass(cls):
cls.vbm_val = 2.6682
cls.gap = 1.5
cls.entries = list(loadfn(os.path.join(os.path.dirname(__file__), "GaAs_test_defentries.json")).values())
for entry in cls.entries:
entry.parameters.update({"vbm": cls.vbm_val})
cls.pd = DefectPhaseDiagram(cls.entries, cls.vbm_val, cls.gap)
cls.mu_elts = {Element("As"): -4.658070555, Element("Ga"): -3.7317319750000006}
# make Vac_As (q= -2) only defect test single-stable-charge exceptions
cls.extra_entry = DefectEntry(cls.entries[5].defect.copy(), 100.0)
sep_entries = [
ent for ent in cls.entries if not (ent.name == "Vac_As_mult4" and ent.charge in [-2, -1, 0, 1, 2])
]
sep_entries.append(cls.extra_entry.copy())
cls.sep_pd = DefectPhaseDiagram(sep_entries, cls.vbm_val, cls.gap)
# make Vac_As (q= -2) is incompatible for larger supercell
ls_entries = cls.entries[:]
for entry in ls_entries:
if entry.name == "Vac_As_mult4" and entry.charge == -2.0:
entry.parameters["is_compatible"] = False
cls.pd_ls_fcTrue = DefectPhaseDiagram(ls_entries, cls.vbm_val, cls.gap, filter_compatible=True)
cls.pd_ls_fcFalse = DefectPhaseDiagram(ls_entries, cls.vbm_val, cls.gap, filter_compatible=False)
# load complete dos for fermi energy solving
with open(os.path.join(PymatgenTest.TEST_FILES_DIR, "complete_dos.json")) as f:
dos_dict = json.load(f)
cls.dos = CompleteDos.from_dict(dos_dict)
def get_dos(self, task_id):
m_task = self.collection.find_one({"task_id": task_id}, {"calcs_reversed": 1})
fs_id = m_task['calcs_reversed'][0]['dos_fs_id']
fs = gridfs.GridFS(self.db, 'dos_fs')
dos_json = zlib.decompress(fs.get(fs_id).read())
dos_dict = json.loads(dos_json.decode())
return CompleteDos.from_dict(dos_dict)
def setUp(self):
self.vbm_val = 2.6682
self.gap = 1.5
self.entries = list(loadfn(os.path.join(os.path.dirname(__file__), "GaAs_test_defentries.json")).values())
for entry in self.entries:
entry.parameters.update( {'vbm': self.vbm_val})
self.pd = DefectPhaseDiagram(self.entries, self.vbm_val, self.gap)
self.mu_elts = {Element("As"): -4.658070555, Element("Ga"): -3.7317319750000006}
# make Vac_As (q= -2) only defect test single-stable-charge exceptions
self.extra_entry = DefectEntry(self.entries[5].defect.copy(), 100.)
sep_entries = [ent for ent in self.entries if not (ent.name == 'Vac_As_mult4' and
ent.charge in [-2,-1,0,1,2])]
sep_entries.append( self.extra_entry.copy())
self.sep_pd = DefectPhaseDiagram( sep_entries, self.vbm_val, self.gap)
# make Vac_As (q= -2) is incompatible for larger supercell
ls_entries = self.entries[:]
for entry in ls_entries:
if entry.name == 'Vac_As_mult4' and entry.charge == -2.:
entry.parameters['is_compatible'] = False
self.pd_ls_fcTrue = DefectPhaseDiagram(ls_entries, self.vbm_val, self.gap, filter_compatible=True)
self.pd_ls_fcFalse = DefectPhaseDiagram(ls_entries, self.vbm_val, self.gap, filter_compatible=False)
# load complete dos for fermi energy solving
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
dos_dict = json.load(f)
self.dos = CompleteDos.from_dict(dos_dict)
def setUp(self):
with open(os.path.join(PymatgenTest.TEST_FILES_DIR,
"complete_dos.json"),
encoding="utf-8") as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.plotter = DosPlotter(sigma=0.2, stack=True)
warnings.simplefilter("ignore")
def setUp(self):
try:
import scipy
except ImportError:
raise SkipTest("scipy not present. Skipping...")
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.plotter = DosPlotter(sigma=0.2, stack=True)
def get_bs(dos, vasprun_bands, kpts_bands):
## get BandStructureSymmLine object and "save" in hidden div in json format
bands = Vasprun(vasprun_bands, parse_projected_eigen = True)
if dos:
dos = CompleteDos.from_dict(json.loads(dos))
bs = bands.get_band_structure(kpts_bands, line_mode=True, efermi=dos.efermi)
else:
bs = bands.get_band_structure(kpts_bands, line_mode=True)
return json.dumps(bs.as_dict(), cls=MyEncoder)
def from_dict(complete_dos_dict):
"""
Returns FeffLdos object from dict representation.
Args:
complete_dos_dict:
dict representation os complete_dos
"""
complete_dos = CompleteDos.from_dict(complete_dos_dict)
return FeffLdos(complete_dos)
def from_dict(d):
"""
Returns FeffLdos object from dict representation
Args:
complete_dos: dict representation of complete_dos
"""
complete_dos = CompleteDos.from_dict(d['complete_dos'])
charge_transfer = d['charge_transfer']
return FeffLdos(complete_dos, charge_transfer)
def from_dict(d):
"""
Returns FeffLdos object from dict representation
Args:
complete_dos: dict representation of complete_dos
"""
complete_dos = CompleteDos.from_dict(d['complete_dos'])
charge_transfer = d['charge_transfer']
return FeffLdos(complete_dos, charge_transfer)
def update_dosbandsfig(n_clicks, dos, bs, projlist):
## figure updates when the inputs change or the button is clicked
## figure does NOT update when elements or orbitals are selected
## de-serialize dos and bs from json format to pymatgen objects
if dos:
dos = CompleteDos.from_dict(json.loads(dos))
if bs:
bs = BandStructureSymmLine.from_dict(json.loads(bs))
## update the band structure and dos figure
dosbandfig = BandsFig().generate_fig(dos, bs, projlist)
return dosbandfig
def get_dos(self, task_id):
"""
Read the DOS data into a PMG DOS object
Args:
task_id(int or str): the task_id containing the data
Returns:
CompleteDos object
"""
obj_dict = self.get_data_from_maggma_or_gridfs(task_id, key="dos")
return CompleteDos.from_dict(obj_dict)
def featurize(self, dos):
"""
Args:
dos (pymatgen CompleteDos or their dict):
The density of states to featurize. Must be a complete DOS,
(i.e. contains PDOS and structure, in addition to total DOS)
and must contain the structure.
Returns:
xbm_score_i (float): fractions of ith contributor orbital
xbm_location_i (str): fractional coordinate of ith contributor.
For example, '0.0;0.0;0.0' if Gamma
xbm_specie_i: (str) elemental specie of ith contributor (ex: 'Ti')
xbm_character_i: (str) orbital character of ith contributor (s p d or f)
xbm_nsignificant: (int) the number of orbitals with contributions
above the significance_threshold
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_cbm_vbm_scores(dos, self.energy_cutoff,
self.sampling_resolution,
self.gaussian_smear)
self.feat = {}
for ex in ['cbm', 'vbm']:
orbscores.sort(key=lambda x: x['{}_score'.format(ex)],
reverse=True)
scores = np.array([s['{}_score'.format(ex)] for s in orbscores])
self.feat['{}_nsignificant'.format(ex)] = len(
scores[scores > self.significance_threshold])
i = 0
while i < self.contributors:
sd = orbscores[i]
if i < len(orbscores):
for p in ['character', 'specie']:
self.feat['{}_{}_{}'.format(ex, p, i + 1)] = sd[p]
self.feat['{}_location_{}'.format(
ex,
i + 1)] = '{};{};{}'.format(sd['location'][0],
sd['location'][1],
sd['location'][2])
self.feat['{}_score_{}'.format(ex, i + 1)] = float(
sd['{}_score'.format(ex)])
else:
for p in [
'{}_score'.format(ex), 'character', 'specie',
'location'
]:
self.feat['{}_{}_{}'.format(ex, p,
i + 1)] = float('NaN')
i += 1
return list(self.feat.values())
def featurize(self, dos, decay_length=None):
"""
takes in the density of state and return the orbitals contributions
and hybridizations.
Args:
dos (pymatgen CompleteDos): note that dos.structure is required
decay_length (float or None): if set, it overrides the instance
variable self.decay_length.
Returns ([float]): features, see class doc for more info
"""
decay_length = decay_length or self.decay_length
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_cbm_vbm_scores(dos,
decay_length,
self.sampling_resolution,
self.gaussian_smear)
feat = OrderedDict()
for ex in ['cbm', 'vbm']:
for orbital in ['s', 'p', 'd', 'f']:
feat['{}_{}'.format(ex, orbital)] = 0.0
for specie in self.species:
feat['{}_{}_{}'.format(ex, specie, orbital)] = 0.0
for hybrid in ['sp', 'sd', 'sf', 'pd', 'pf', 'df']:
feat['{}_{}'.format(ex, hybrid)] = 0.0
for contrib in orbscores:
character = contrib['character']
feat['cbm_{}'.format(character)] += contrib['cbm_score']
feat['vbm_{}'.format(character)] += contrib['vbm_score']
for specie in self.species:
if contrib['specie'] == specie:
feat['cbm_{}_{}'.format(specie, character)] += contrib[
'cbm_score']
feat['vbm_{}_{}'.format(specie, character)] += contrib[
'vbm_score']
for ex in ['cbm', 'vbm']:
for hybrid in ['sp', 'sd', 'sf', 'pd', 'pf', 'df']:
orb1 = feat['{}_{}'.format(ex, hybrid[0])]
orb2 = feat['{}_{}'.format(ex, hybrid[1])]
feat['{}_{}'.format(ex, hybrid)] = (orb1 * orb2) * 4.0 # 4x so max=1.0
return list(feat.values())
def featurize(self, dos, energy_cutoff=None):
"""
takes in the density of state and return the orbitals contributions
and hybridizations.
Args:
dos (pymatgen CompleteDos): note that dos.structure is required
energy_cutoff (float or None): if set, it overrides the instance
variable self.energy_cutoff.
Returns ([float]): features, see class doc for more info
"""
energy_cutoff = energy_cutoff or self.energy_cutoff
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_cbm_vbm_scores(dos, energy_cutoff,
self.sampling_resolution,
self.gaussian_smear)
feat = OrderedDict()
for ex in ['cbm', 'vbm']:
for orbital in ['s', 'p', 'd', 'f']:
feat['{}_{}'.format(ex, orbital)] = 0.0
for specie in self.species:
feat['{}_{}_{}'.format(ex, specie, orbital)] = 0.0
for hybrid in ['sp', 'sd', 'sf', 'pd', 'pf', 'df']:
feat['{}_{}'.format(ex, hybrid)] = 0.0
for contrib in orbscores:
character = contrib['character']
feat['cbm_{}'.format(character)] += contrib['cbm_score']
feat['vbm_{}'.format(character)] += contrib['vbm_score']
for specie in self.species:
if contrib['specie'] == specie:
feat['cbm_{}_{}'.format(specie,
character)] += contrib['cbm_score']
feat['vbm_{}_{}'.format(specie,
character)] += contrib['vbm_score']
for ex in ['cbm', 'vbm']:
for hybrid in ['sp', 'sd', 'sf', 'pd', 'pf', 'df']:
orb1 = feat['{}_{}'.format(ex, hybrid[0])]
orb2 = feat['{}_{}'.format(ex, hybrid[1])]
feat['{}_{}'.format(
ex, hybrid)] = (orb1 * orb2) * 4.0 # 4x so max=1.0
return list(feat.values())
def test_to_from_dict(self):
d = self.dos.as_dict()
dos = CompleteDos.from_dict(d)
el_dos = dos.get_element_dos()
self.assertEqual(len(el_dos), 4)
spd_dos = dos.get_spd_dos()
sum_spd = spd_dos[OrbitalType.s] + spd_dos[OrbitalType.p] + spd_dos[OrbitalType.d]
sum_element = None
for pdos in el_dos.values():
if sum_element is None:
sum_element = pdos
else:
sum_element += pdos
# The sums of the SPD or the element doses should be the same.
self.assertTrue((abs(sum_spd.energies - sum_element.energies) < 0.0001).all())
def test_to_from_dict(self):
d = self.dos.as_dict()
dos = CompleteDos.from_dict(d)
el_dos = dos.get_element_dos()
self.assertEqual(len(el_dos), 4)
spd_dos = dos.get_spd_dos()
sum_spd = spd_dos[OrbitalType.s] + spd_dos[OrbitalType.p] + spd_dos[OrbitalType.d]
sum_element = None
for pdos in el_dos.values():
if sum_element is None:
sum_element = pdos
else:
sum_element += pdos
# The sums of the SPD or the element doses should be the same.
self.assertTrue((abs(sum_spd.energies - sum_element.energies) < 0.0001).all())
def process_item(self, mat):
"""
Process the tasks and materials into just a list of materials
Args:
mat (dict): material document
Returns:
(dict): electronic_structure document
"""
d = {self.electronic_structure.key: mat[self.materials.key]}
self.logger.info("Processing: {}".format(mat[self.materials.key]))
bs = build_bs(mat["bandstructure"]["bs"], mat)
dos = CompleteDos.from_dict(mat["bandstructure"]["dos"])
if bs and dos:
try:
pdos = get_pdos(dos)
dos_plotter = SDOSPlotter(dos, pdos)
bs_plotter = SBSPlotter(bs)
plt = bs_plotter.get_plot(dos_plotter=dos_plotter,
**self.plot_options)
d["plot"] = image_from_plot(plt)
plt.close()
except Exception:
traceback.print_exc()
self.logger.warning(
"Caught error in bandstructure plotting for {}: {}".format(
mat[self.materials.key], traceback.format_exc()))
# Reduced Band structure plot
try:
gap = bs.get_band_gap()["energy"]
plot_data = bs_plotter.bs_plot_data()
d["bs_plot_small"] = get_small_plot(plot_data, gap)
except Exception:
self.logger.warning(
"Caught error in generating reduced bandstructure plot for {}: {}"
.format(mat[self.materials.key], traceback.format_exc()))
# Store task_ids
for k in ["bs_task", "dos_task", "uniform_task"]:
if k in mat["bandstructure"]:
d[k] = mat["bandstructure"][k]
return d
def _get_bs_dos(data):
data = data or {}
# this component can be loaded either from mpid or
# directly from BandStructureSymmLine or CompleteDos objects
# if mpid is supplied, this is preferred
mpid = data.get("mpid")
bandstructure_symm_line = data.get("bandstructure_symm_line")
density_of_states = data.get("density_of_states")
if not mpid and (bandstructure_symm_line is None
or density_of_states is None):
return None, None
if mpid:
with MPRester() as mpr:
try:
bandstructure_symm_line = mpr.get_bandstructure_by_material_id(
mpid)
except Exception as exc:
print(exc)
bandstructure_symm_line = None
try:
density_of_states = mpr.get_dos_by_material_id(mpid)
except Exception as exc:
print(exc)
density_of_states = None
else:
if bandstructure_symm_line and isinstance(bandstructure_symm_line,
dict):
bandstructure_symm_line = BandStructureSymmLine.from_dict(
bandstructure_symm_line)
if density_of_states and isinstance(density_of_states, dict):
density_of_states = CompleteDos.from_dict(density_of_states)
return bandstructure_symm_line, density_of_states
def featurize(self, dos):
"""
Args:
dos (pymatgen CompleteDos or their dict):
The density of states to featurize. Must be a complete DOS,
(i.e. contains PDOS and structure, in addition to total DOS)
and must contain the structure.
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_cbm_vbm_scores(dos, self.energy_cutoff,
self.sampling_resolution,
self.gaussian_smear)
feat = OrderedDict()
for ex in ['cbm', 'vbm']:
orbscores.sort(key=lambda x: x['{}_score'.format(ex)],
reverse=True)
scores = np.array([s['{}_score'.format(ex)] for s in orbscores])
feat['{}_nsignificant'.format(ex)] = len(
scores[scores > self.significance_threshold])
i = 0
while i < self.contributors:
sd = orbscores[i]
if i < len(orbscores):
for p in ['character', 'specie']:
feat['{}_{}_{}'.format(ex, p, i + 1)] = sd[p]
feat['{}_location_{}'.format(ex,
i + 1)] = '{};{};{}'.format(
sd['location'][0],
sd['location'][1],
sd['location'][2])
feat['{}_score_{}'.format(ex, i + 1)] = float(
sd['{}_score'.format(ex)])
else:
for p in ['character', 'specie', 'location', 'score']:
feat['{}_{}_{}'.format(ex, p, i + 1)] = float('NaN')
i += 1
return list(feat.values())
def setUp(self):
self.vbm_val = 2.6682
self.gap = 1.5
self.entries = list(
loadfn(
os.path.join(os.path.dirname(__file__),
"GaAs_test_defentries.json")).values())
for entry in self.entries:
entry.parameters.update({'vbm': self.vbm_val})
self.pd = DefectPhaseDiagram(self.entries, self.vbm_val, self.gap)
self.mu_elts = {
Element("As"): -4.658070555,
Element("Ga"): -3.7317319750000006
}
# make Vac_As (q= -2) only defect test single-stable-charge exceptions
self.extra_entry = DefectEntry(self.entries[5].defect.copy(), 100.)
sep_entries = [
ent for ent in self.entries if not (
ent.name == 'Vac_As_mult4' and ent.charge in [-2, -1, 0, 1, 2])
]
sep_entries.append(self.extra_entry.copy())
self.sep_pd = DefectPhaseDiagram(sep_entries, self.vbm_val, self.gap)
# make Vac_As (q= -2) is incompatible for larger supercell
ls_entries = self.entries[:]
for entry in ls_entries:
if entry.name == 'Vac_As_mult4' and entry.charge == -2.:
entry.parameters['is_compatible'] = False
self.pd_ls_fcTrue = DefectPhaseDiagram(ls_entries,
self.vbm_val,
self.gap,
filter_compatible=True)
self.pd_ls_fcFalse = DefectPhaseDiagram(ls_entries,
self.vbm_val,
self.gap,
filter_compatible=False)
# load complete dos for fermi energy solving
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
dos_dict = json.load(f)
self.dos = CompleteDos.from_dict(dos_dict)
def featurize(self, dos):
"""
Args:
dos (pymatgen CompleteDos or their dict):
The density of states to featurize. Must be a complete DOS,
(i.e. contains PDOS and structure, in addition to total DOS)
and must contain the structure.
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_cbm_vbm_scores(dos, self.decay_length,
self.sampling_resolution,
self.gaussian_smear)
feat = OrderedDict()
for ex in ['cbm', 'vbm']:
orbscores.sort(key=lambda x: x['{}_score'.format(ex)],
reverse=True)
scores = np.array([s['{}_score'.format(ex)] for s in orbscores])
feat['{}_hybridization'.format(ex)] = - np.sum(
scores * np.log(scores + 1e-10)) # avoid log(0)
i = 0
while i < self.contributors:
sd = orbscores[i]
if i < len(orbscores):
for p in ['character', 'specie']:
feat['{}_{}_{}'.format(ex, p, i + 1)] = sd[p]
feat['{}_location_{}'.format(ex, i + 1)] =\
'{};{};{}'.format(sd['location'][0], sd['location'][1],
sd['location'][2])
feat['{}_score_{}'.format(ex, i + 1)] =\
float(sd['{}_score'.format(ex)])
else:
for p in ['character', 'specie', 'location', 'score']:
feat['{}_{}_{}'.format(ex, p, i + 1)] = float('NaN')
i += 1
return list(feat.values())
def featurize(self, dos, idx):
"""
get dos scores for given site index
Args:
dos (pymatgen CompleteDos or their dict):
dos to featurize, must contain pdos and structure
idx (int): index of target site in structure.
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_site_dos_scores(dos, idx, self.decay_length,
self.sampling_resolution,
self.gaussian_smear)
features = []
for edge in ['cbm', 'vbm']:
for score in ['s', 'p', 'd', 'f', 'total']:
features.append(orbscores[edge][score])
return features
def featurize(self, dos, idx):
"""
get dos scores for given site index
Args:
dos (pymatgen CompleteDos or their dict):
dos to featurize, must contain pdos and structure
idx (int): index of target site in structure.
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
if dos.structure is None:
raise ValueError('The input dos must contain the structure.')
orbscores = get_site_dos_scores(dos, idx, self.fermi_temperature,
self.sampling_resolution,
self.gaussian_smear)
features = []
for edge in ['cbm', 'vbm']:
for score in ['s', 'p', 'd', 'f', 'total']:
features.append(orbscores[edge][score])
return features
def setUp(self):
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
self.dos = CompleteDos.from_dict(json.load(f))
def process_item(self, mat):
"""
Process the tasks and materials into just a list of materials
Args:
mat (dict): material document
Returns:
(dict): electronic_structure document
"""
self.logger.info("Processing: {}".format(mat[self.materials.key]))
d = {self.electronic_structure.key: mat[
self.materials.key], "bandstructure": {}}
bs = None
dos = None
interpolated_dos = None
# Process the bandstructure for information
if "bs" in mat["bandstructure"]:
if "structure" not in mat["bandstructure"]["bs"]:
mat["bandstructure"]["bs"]["structure"] = mat["structure"]
if len(mat["bandstructure"]["bs"].get("labels_dict", {})) == 0:
struc = Structure.from_dict(mat["structure"])
kpath = HighSymmKpath(struc)._kpath["kpoints"]
mat["bandstructure"]["bs"]["labels_dict"] = kpath
# Somethign is wrong with the as_dict / from_dict encoding in the two band structure objects so have to use this hodge podge serialization
# TODO: Fix bandstructure objects in pymatgen
bs = BandStructureSymmLine.from_dict(
BandStructure.from_dict(mat["bandstructure"]["bs"]).as_dict())
d["bandstructure"]["band_gap"] = {"band_gap": bs.get_band_gap()["energy"],
"direct_gap": bs.get_direct_band_gap(),
"is_direct": bs.get_band_gap()["direct"],
"transition": bs.get_band_gap()["transition"]}
if self.small_plot:
d["bandstructure"]["plot_small"] = get_small_plot(bs)
if "dos" in mat["bandstructure"]:
dos = CompleteDos.from_dict(mat["bandstructure"]["dos"])
if self.interpolate_dos and "uniform_bs" in mat["bandstructure"]:
try:
interpolated_dos = self.get_interpolated_dos(mat)
except Exception:
self.logger.warning("Boltztrap interpolation failed for {}. Continuing with regular DOS".format(mat[self.materials.key]))
# Generate static images
if self.static_images:
try:
ylim = None
if bs:
plotter = WebBSPlotter(bs)
fig = plotter.get_plot()
ylim = fig.ylim() # Used by DOS plot
fig.close()
d["bandstructure"]["bs_plot"] = image_from_plotter(plotter)
if dos:
plotter = WebDosVertPlotter()
plotter.add_dos_dict(dos.get_element_dos())
if interpolated_dos:
plotter.add_dos("Total DOS", interpolated_dos)
d["bandstructure"]["dos_plot"] = image_from_plotter(plotter, ylim=ylim)
d["bandstructure"]["dos_plot"] = image_from_plotter(plotter, ylim=ylim)
except Exception:
self.logger.warning(
"Caught error in electronic structure plotting for {}: {}".format(mat[self.materials.key], traceback.format_exc()))
return None
return d
def process_item(self, mat):
"""
Process the tasks and materials into just a list of materials
Args:
mat (dict): material document
Returns:
(dict): electronic_structure document
"""
d = {self.electronic_structure.key: mat[self.materials.key]}
self.logger.info("Processing: {}".format(mat[self.materials.key]))
bs = BandStructureSymmLine.from_dict(mat["bandstructure"]["bs"])
dos = CompleteDos.from_dict(mat["bandstructure"]["dos"])
# Plot Band structure
if bs:
try:
plotter = WebBSPlotter(bs)
plot = plotter.get_plot()
ylim = plot.ylim()
d["bs_plot"] = image_from_plot(plot)
plot.close()
except Exception:
self.logger.warning(
"Caught error in bandstructure plotting for {}: {}".format(
mat[self.materials.key], traceback.format_exc()))
# Reduced Band structure plot
try:
gap = bs.get_band_gap()["energy"]
plot_data = plotter.bs_plot_data()
d["bs_plot_small"] = get_small_plot(plot_data, gap)
except Exception:
self.logger.warning(
"Caught error in generating reduced bandstructure plot for {}: {}"
.format(mat[self.materials.key], traceback.format_exc()))
# Plot DOS
if dos:
try:
plotter = WebDosVertPlotter()
plotter.add_dos_dict(dos.get_element_dos())
plot = plotter.get_plot(ylim=ylim)
d["dos_plot"] = image_from_plot(plot)
plot.close()
except Exception:
self.logger.warning(
"Caught error in dos plotting for {}: {}".format(
mat[self.materials.key], traceback.format_exc()))
# Get basic bandgap properties
if bs:
try:
d["band_gap"] = {
"band_gap": bs.get_band_gap()["energy"],
"direct_gap": bs.get_direct_band_gap(),
"is_direct": bs.get_band_gap()["direct"],
"transition": bs.get_band_gap()["transition"]
}
except Exception:
self.logger.warning(
"Caught error in calculating bandgap {}: {}".format(
mat[self.materials.key], traceback.format_exc()))
return d
def setUp(self):
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"complete_dos.json")) as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.dos = FermiDos(self.dos)
def bs_dos_data(
mpid,
path_convention,
dos_select,
label_select,
bandstructure_symm_line,
density_of_states,
):
if not mpid and (bandstructure_symm_line is None
or density_of_states is None):
raise PreventUpdate
elif bandstructure_symm_line is None or density_of_states is None:
if label_select == "":
raise PreventUpdate
# --
# -- BS and DOS from API or DB
# --
bs_data = {"ticks": {}}
bs_store = GridFSStore(
database="fw_bs_prod",
collection_name="bandstructure_fs",
host="mongodb03.nersc.gov",
port=27017,
username="******",
password="",
)
dos_store = GridFSStore(
database="fw_bs_prod",
collection_name="dos_fs",
host="mongodb03.nersc.gov",
port=27017,
username="******",
password="",
)
es_store = MongoStore(
database="fw_bs_prod",
collection_name="electronic_structure",
host="mongodb03.nersc.gov",
port=27017,
username="******",
password="",
key="task_id",
)
# - BS traces from DB using task_id
es_store.connect()
bs_query = es_store.query_one(
criteria={"task_id": int(mpid)},
properties=[
"bandstructure.{}.task_id".format(path_convention),
"bandstructure.{}.total.equiv_labels".format(
path_convention),
],
)
es_store.close()
bs_store.connect()
bandstructure_symm_line = bs_store.query_one(criteria={
"metadata.task_id":
int(bs_query["bandstructure"][path_convention]["task_id"])
}, )
# If LM convention, get equivalent labels
if path_convention != label_select:
bs_equiv_labels = bs_query["bandstructure"][
path_convention]["total"]["equiv_labels"]
new_labels_dict = {}
for label in bandstructure_symm_line["labels_dict"].keys():
label_formatted = label.replace("$", "")
if "|" in label_formatted:
f_label = label_formatted.split("|")
new_labels.append(
"$" +
bs_equiv_labels[label_select][f_label[0]] +
"|" +
bs_equiv_labels[label_select][f_label[1]] +
"$")
else:
new_labels_dict["$" + bs_equiv_labels[label_select]
[label_formatted] +
"$"] = bandstructure_symm_line[
"labels_dict"][label]
bandstructure_symm_line["labels_dict"] = new_labels_dict
# - DOS traces from DB using task_id
es_store.connect()
dos_query = es_store.query_one(
criteria={"task_id": int(mpid)},
properties=["dos.task_id"],
)
es_store.close()
dos_store.connect()
density_of_states = dos_store.query_one(
criteria={"task_id": int(dos_query["dos"]["task_id"])}, )
# - BS Data
if (type(bandstructure_symm_line) != dict
and bandstructure_symm_line is not None):
bandstructure_symm_line = bandstructure_symm_line.to_dict()
if type(density_of_states
) != dict and density_of_states is not None:
density_of_states = density_of_states.to_dict()
bsml = BSML.from_dict(bandstructure_symm_line)
bs_reg_plot = BSPlotter(bsml)
bs_data = bs_reg_plot.bs_plot_data()
# Make plot continous for lm
if path_convention == "lm":
distance_map, kpath_euler = HSKP(
bsml.structure).get_continuous_path(bsml)
kpath_labels = [pair[0] for pair in kpath_euler]
kpath_labels.append(kpath_euler[-1][1])
else:
distance_map = [(i, False)
for i in range(len(bs_data["distances"]))]
kpath_labels = []
for label_ind in range(len(bs_data["ticks"]["label"]) - 1):
if (bs_data["ticks"]["label"][label_ind] !=
bs_data["ticks"]["label"][label_ind + 1]):
kpath_labels.append(
bs_data["ticks"]["label"][label_ind])
kpath_labels.append(bs_data["ticks"]["label"][-1])
bs_data["ticks"]["label"] = kpath_labels
# Obtain bands to plot over and generate traces for bs data:
energy_window = (-6.0, 10.0)
bands = []
for band_num in range(bs_reg_plot._nb_bands):
if (bs_data["energy"][0][str(Spin.up)][band_num][0] <=
energy_window[1]) and (bs_data["energy"][0][str(
Spin.up)][band_num][0] >= energy_window[0]):
bands.append(band_num)
bstraces = []
pmin = 0.0
tick_vals = [0.0]
cbm = bsml.get_cbm()
vbm = bsml.get_vbm()
cbm_new = bs_data["cbm"]
vbm_new = bs_data["vbm"]
for dnum, (d, rev) in enumerate(distance_map):
x_dat = [
dval - bs_data["distances"][d][0] + pmin
for dval in bs_data["distances"][d]
]
pmin = x_dat[-1]
tick_vals.append(pmin)
if not rev:
traces_for_segment = [{
"x":
x_dat,
"y": [
bs_data["energy"][d][str(Spin.up)][i][j]
for j in range(len(bs_data["distances"][d]))
],
"mode":
"lines",
"line": {
"color": "#1f77b4"
},
"hoverinfo":
"skip",
"name":
"spin ↑"
if bs_reg_plot._bs.is_spin_polarized else "Total",
"hovertemplate":
"%{y:.2f} eV",
"showlegend":
False,
"xaxis":
"x",
"yaxis":
"y",
} for i in bands]
elif rev:
traces_for_segment = [{
"x":
x_dat,
"y": [
bs_data["energy"][d][str(Spin.up)][i][j]
for j in reversed(
range(len(bs_data["distances"][d])))
],
"mode":
"lines",
"line": {
"color": "#1f77b4"
},
"hoverinfo":
"skip",
"name":
"spin ↑"
if bs_reg_plot._bs.is_spin_polarized else "Total",
"hovertemplate":
"%{y:.2f} eV",
"showlegend":
False,
"xaxis":
"x",
"yaxis":
"y",
} for i in bands]
if bs_reg_plot._bs.is_spin_polarized:
if not rev:
traces_for_segment += [{
"x":
x_dat,
"y": [
bs_data["energy"][d][str(Spin.down)][i][j]
for j in range(len(bs_data["distances"][d]))
],
"mode":
"lines",
"line": {
"color": "#ff7f0e",
"dash": "dot"
},
"hoverinfo":
"skip",
"showlegend":
False,
"name":
"spin ↓",
"hovertemplate":
"%{y:.2f} eV",
"xaxis":
"x",
"yaxis":
"y",
} for i in bands]
elif rev:
traces_for_segment += [{
"x":
x_dat,
"y": [
bs_data["energy"][d][str(Spin.down)][i][j]
for j in reversed(
range(len(bs_data["distances"][d])))
],
"mode":
"lines",
"line": {
"color": "#ff7f0e",
"dash": "dot"
},
"hoverinfo":
"skip",
"showlegend":
False,
"name":
"spin ↓",
"hovertemplate":
"%{y:.2f} eV",
"xaxis":
"x",
"yaxis":
"y",
} for i in bands]
bstraces += traces_for_segment
# - Get proper cbm and vbm coords for lm
if path_convention == "lm":
for (x_point, y_point) in bs_data["cbm"]:
if x_point in bs_data["distances"][d]:
xind = bs_data["distances"][d].index(x_point)
if not rev:
x_point_new = x_dat[xind]
else:
x_point_new = x_dat[len(x_dat) - xind - 1]
new_label = bs_data["ticks"]["label"][
tick_vals.index(x_point_new)]
if (cbm["kpoint"].label is None
or cbm["kpoint"].label in new_label):
cbm_new.append((x_point_new, y_point))
for (x_point, y_point) in bs_data["vbm"]:
if x_point in bs_data["distances"][d]:
xind = bs_data["distances"][d].index(x_point)
if not rev:
x_point_new = x_dat[xind]
else:
x_point_new = x_dat[len(x_dat) - xind - 1]
new_label = bs_data["ticks"]["label"][
tick_vals.index(x_point_new)]
if (vbm["kpoint"].label is None
or vbm["kpoint"].label in new_label):
vbm_new.append((x_point_new, y_point))
bs_data["ticks"]["distance"] = tick_vals
# - Strip latex math wrapping for labels
str_replace = {
"$": "",
"\\mid": "|",
"\\Gamma": "Γ",
"\\Sigma": "Σ",
"GAMMA": "Γ",
"_1": "₁",
"_2": "₂",
"_3": "₃",
"_4": "₄",
"_{1}": "₁",
"_{2}": "₂",
"_{3}": "₃",
"_{4}": "₄",
"^{*}": "*",
}
bar_loc = []
for entry_num in range(len(bs_data["ticks"]["label"])):
for key in str_replace.keys():
if key in bs_data["ticks"]["label"][entry_num]:
bs_data["ticks"]["label"][entry_num] = bs_data[
"ticks"]["label"][entry_num].replace(
key, str_replace[key])
if key == "\\mid":
bar_loc.append(
bs_data["ticks"]["distance"][entry_num])
# Vertical lines for disjointed segments
vert_traces = [{
"x": [x_point, x_point],
"y": energy_window,
"mode": "lines",
"marker": {
"color": "white"
},
"hoverinfo": "skip",
"showlegend": False,
"xaxis": "x",
"yaxis": "y",
} for x_point in bar_loc]
bstraces += vert_traces
# Dots for cbm and vbm
dot_traces = [{
"x": [x_point],
"y": [y_point],
"mode":
"markers",
"marker": {
"color": "#7E259B",
"size": 16,
"line": {
"color": "white",
"width": 2
},
},
"showlegend":
False,
"hoverinfo":
"text",
"name":
"",
"hovertemplate":
"CBM: k = {}, {} eV".format(list(cbm["kpoint"].frac_coords),
cbm["energy"]),
"xaxis":
"x",
"yaxis":
"y",
} for (x_point, y_point) in set(cbm_new)] + [{
"x": [x_point],
"y": [y_point],
"mode":
"marker",
"marker": {
"color": "#7E259B",
"size": 16,
"line": {
"color": "white",
"width": 2
},
},
"showlegend":
False,
"hoverinfo":
"text",
"name":
"",
"hovertemplate":
"VBM: k = {}, {} eV".format(list(vbm["kpoint"].frac_coords),
vbm["energy"]),
"xaxis":
"x",
"yaxis":
"y",
} for (x_point, y_point) in set(vbm_new)]
bstraces += dot_traces
# - DOS Data
dostraces = []
dos = CompleteDos.from_dict(density_of_states)
dos_max = np.abs(
(dos.energies - dos.efermi - energy_window[1])).argmin()
dos_min = np.abs(
(dos.energies - dos.efermi - energy_window[0])).argmin()
if bs_reg_plot._bs.is_spin_polarized:
# Add second spin data if available
trace_tdos = {
"x": -1.0 * dos.densities[Spin.down][dos_min:dos_max],
"y": dos.energies[dos_min:dos_max] - dos.efermi,
"mode": "lines",
"name": "Total DOS (spin ↓)",
"line": go.scatter.Line(color="#444444", dash="dot"),
"fill": "tozerox",
"fillcolor": "#C4C4C4",
"xaxis": "x2",
"yaxis": "y2",
}
dostraces.append(trace_tdos)
tdos_label = "Total DOS (spin ↑)"
else:
tdos_label = "Total DOS"
# Total DOS
trace_tdos = {
"x": dos.densities[Spin.up][dos_min:dos_max],
"y": dos.energies[dos_min:dos_max] - dos.efermi,
"mode": "lines",
"name": tdos_label,
"line": go.scatter.Line(color="#444444"),
"fill": "tozerox",
"fillcolor": "#C4C4C4",
"legendgroup": "spinup",
"xaxis": "x2",
"yaxis": "y2",
}
dostraces.append(trace_tdos)
ele_dos = dos.get_element_dos()
elements = [str(entry) for entry in ele_dos.keys()]
if dos_select == "ap":
proj_data = ele_dos
elif dos_select == "op":
proj_data = dos.get_spd_dos()
elif "orb" in dos_select:
proj_data = dos.get_element_spd_dos(
Element(dos_select.replace("orb", "")))
else:
raise PreventUpdate
# Projected DOS
count = 0
colors = [
"#d62728", # brick red
"#2ca02c", # cooked asparagus green
"#17becf", # blue-teal
"#bcbd22", # curry yellow-green
"#9467bd", # muted purple
"#8c564b", # chestnut brown
"#e377c2", # raspberry yogurt pink
]
for label in proj_data.keys():
if bs_reg_plot._bs.is_spin_polarized:
trace = {
"x":
-1.0 *
proj_data[label].densities[Spin.down][dos_min:dos_max],
"y":
dos.energies[dos_min:dos_max] - dos.efermi,
"mode":
"lines",
"name":
str(label) + " (spin ↓)",
"line":
dict(width=3, color=colors[count], dash="dot"),
"xaxis":
"x2",
"yaxis":
"y2",
}
dostraces.append(trace)
spin_up_label = str(label) + " (spin ↑)"
else:
spin_up_label = str(label)
trace = {
"x": proj_data[label].densities[Spin.up][dos_min:dos_max],
"y": dos.energies[dos_min:dos_max] - dos.efermi,
"mode": "lines",
"name": spin_up_label,
"line": dict(width=2, color=colors[count]),
"xaxis": "x2",
"yaxis": "y2",
}
dostraces.append(trace)
count += 1
traces = [bstraces, dostraces, bs_data]
return (traces, elements)
def bs_dos_traces(bandStructureSymmLine, densityOfStates):
if bandStructureSymmLine == "error" or densityOfStates == "error":
return "error"
if bandStructureSymmLine == None or densityOfStates == None:
raise PreventUpdate
# - BS Data
bstraces = []
bs_reg_plot = BSPlotter(BSML.from_dict(bandStructureSymmLine))
bs_data = bs_reg_plot.bs_plot_data()
# -- Strip latex math wrapping
str_replace = {
"$": "",
"\\mid": "|",
"\\Gamma": "Γ",
"\\Sigma": "Σ",
"_1": "₁",
"_2": "₂",
"_3": "₃",
"_4": "₄",
}
for entry_num in range(len(bs_data["ticks"]["label"])):
for key in str_replace.keys():
if key in bs_data["ticks"]["label"][entry_num]:
bs_data["ticks"]["label"][entry_num] = bs_data[
"ticks"]["label"][entry_num].replace(
key, str_replace[key])
for d in range(len(bs_data["distances"])):
for i in range(bs_reg_plot._nb_bands):
bstraces.append(
go.Scatter(
x=bs_data["distances"][d],
y=[
bs_data["energy"][d][str(Spin.up)][i][j]
for j in range(len(bs_data["distances"][d]))
],
mode="lines",
line=dict(color=("#666666"), width=2),
hoverinfo="skip",
showlegend=False,
))
if bs_reg_plot._bs.is_spin_polarized:
bstraces.append(
go.Scatter(
x=bs_data["distances"][d],
y=[
bs_data["energy"][d][str(Spin.down)][i][j]
for j in range(len(bs_data["distances"]
[d]))
],
mode="lines",
line=dict(color=("#666666"),
width=2,
dash="dash"),
hoverinfo="skip",
showlegend=False,
))
# -- DOS Data
dostraces = []
dos = CompleteDos.from_dict(densityOfStates)
if Spin.down in dos.densities:
# Add second spin data if available
trace_tdos = go.Scatter(
x=dos.densities[Spin.down],
y=dos.energies - dos.efermi,
mode="lines",
name="Total DOS (spin ↓)",
line=go.scatter.Line(color="#444444", dash="dash"),
fill="tozeroy",
)
dostraces.append(trace_tdos)
tdos_label = "Total DOS (spin ↑)"
else:
tdos_label = "Total DOS"
# Total DOS
trace_tdos = go.Scatter(
x=dos.densities[Spin.up],
y=dos.energies - dos.efermi,
mode="lines",
name=tdos_label,
line=go.scatter.Line(color="#444444"),
fill="tozeroy",
legendgroup="spinup",
)
dostraces.append(trace_tdos)
p_ele_dos = dos.get_element_dos()
# Projected DOS
count = 0
colors = [
"#1f77b4", # muted blue
"#ff7f0e", # safety orange
"#2ca02c", # cooked asparagus green
"#d62728", # brick red
"#9467bd", # muted purple
"#8c564b", # chestnut brown
"#e377c2", # raspberry yogurt pink
"#bcbd22", # curry yellow-green
"#17becf", # blue-teal
]
for ele in p_ele_dos.keys():
if bs_reg_plot._bs.is_spin_polarized:
trace = go.Scatter(
x=p_ele_dos[ele].densities[Spin.down],
y=dos.energies - dos.efermi,
mode="lines",
name=ele.symbol + " (spin ↓)",
line=dict(width=3, color=colors[count], dash="dash"),
)
dostraces.append(trace)
spin_up_label = ele.symbol + " (spin ↑)"
else:
spin_up_label = ele.symbol
trace = go.Scatter(
x=p_ele_dos[ele].densities[Spin.up],
y=dos.energies - dos.efermi,
mode="lines",
name=spin_up_label,
line=dict(width=3, color=colors[count]),
)
dostraces.append(trace)
count += 1
traces = [bstraces, dostraces, bs_data]
return traces
el: chempots_delta[el] + c.chempots_reference[el]
for el in chempots_delta
}
pressures.append(np.around(partial_pressure, decimals=4))
reservoirs.append(chempots_abs)
print('Reading defect calculation data...\n')
with open('vacancies_NN_HSE.json') as json_file:
data = json.load(json_file)
defects_analysis = DefectsAnalysis.from_dict(data)
print('Reading DOS...\n')
with open('dos_NN_HSE.json') as json_file:
data = json.load(json_file)
bulk_dos = CompleteDos.from_dict(data)
concentrations = []
for r in reservoirs:
fermi_energy = defects_analysis.equilibrium_fermi_level(r, bulk_dos)
cn = defects_analysis.defect_concentrations_stable_charges(
r, temperature=temperature, fermi_level=fermi_energy)
concentrations.append(cn)
data = {
'partial_pressures': pressures,
'defect_concentrations': concentrations
}
with open('defect_concentrations_NN_HSE.json', 'w') as json_file:
def bs_dos_data(
mpid,
path_convention,
dos_select,
label_select,
bandstructure_symm_line,
density_of_states,
):
if (not mpid
or "mpid" not in mpid) and (bandstructure_symm_line is None
or density_of_states is None):
raise PreventUpdate
elif mpid:
raise PreventUpdate
elif bandstructure_symm_line is None or density_of_states is None:
# --
# -- BS and DOS from API
# --
mpid = mpid["mpid"]
bs_data = {"ticks": {}}
# client = MongoClient(
# "mongodb03.nersc.gov", username="******", password="", authSource="fw_bs_prod",
# )
db = client.fw_bs_prod
# - BS traces from DB using task_id
bs_query = list(
db.electronic_structure.find(
{"task_id": int(mpid)},
[
"bandstructure.{}.total.traces".format(
path_convention)
],
))[0]
is_sp = (len(bs_query["bandstructure"][path_convention]
["total"]["traces"]) == 2)
if is_sp:
bstraces = (bs_query["bandstructure"][path_convention]
["total"]["traces"]["1"] +
bs_query["bandstructure"][path_convention]
["total"]["traces"]["-1"])
else:
bstraces = bs_query["bandstructure"][path_convention][
"total"]["traces"]["1"]
bs_data["ticks"]["distance"] = bs_query["bandstructure"][
path_convention]["total"]["traces"]["ticks"]
bs_data["ticks"]["label"] = bs_query["bandstructure"][
path_convention]["total"]["traces"]["labels"]
# If LM convention, get equivalent labels
if path_convention == "lm" and label_select != "lm":
bs_equiv_labels = bs_query["bandstructure"][
path_convention]["total"]["traces"]["equiv_labels"]
alt_choice = label_select
if label_select == "hin":
alt_choice = "h"
new_labels = []
for label in bs_data["ticks"]["label"]:
label_formatted = label.replace("$", "")
if "|" in label_formatted:
f_label = label_formatted.split("|")
new_labels.append(
"$" + bs_equiv_labels[alt_choice][f_label[0]] +
"|" + bs_equiv_labels[alt_choice][f_label[1]] +
"$")
else:
new_labels.append(
"$" +
bs_equiv_labels[alt_choice][label_formatted] +
"$")
bs_data["ticks"]["label"] = new_labels
# Strip latex math wrapping
str_replace = {
"$": "",
"\\mid": "|",
"\\Gamma": "Γ",
"\\Sigma": "Σ",
"GAMMA": "Γ",
"_1": "₁",
"_2": "₂",
"_3": "₃",
"_4": "₄",
}
for entry_num in range(len(bs_data["ticks"]["label"])):
for key in str_replace.keys():
if key in bs_data["ticks"]["label"][entry_num]:
bs_data["ticks"]["label"][entry_num] = bs_data[
"ticks"]["label"][entry_num].replace(
key, str_replace[key])
# - DOS traces from DB using task_id
dostraces = []
dos_tot_ele_traces = list(
db.electronic_structure.find(
{"task_id": int(mpid)},
["dos.total.traces", "dos.elements"]))[0]
dostraces = [
dos_tot_ele_traces["dos"]["total"]["traces"][spin] for spin
in dos_tot_ele_traces["dos"]["total"]["traces"].keys()
]
elements = [
ele
for ele in dos_tot_ele_traces["dos"]["elements"].keys()
]
if dos_select == "ap":
for ele_label in elements:
dostraces += [
dos_tot_ele_traces["dos"]["elements"][ele_label]
["total"]["traces"][spin]
for spin in dos_tot_ele_traces["dos"]["elements"]
[ele_label]["total"]["traces"].keys()
]
elif dos_select == "op":
orb_tot_traces = list(
db.electronic_structure.find({"task_id": int(mpid)},
["dos.orbitals"]))[0]
for orbital in ["s", "p", "d"]:
dostraces += [
orb_tot_traces["dos"]["orbitals"][orbital]
["traces"][spin] for spin in orb_tot_traces["dos"]
["orbitals"]["s"]["traces"].keys()
]
elif "orb" in dos_select:
ele_label = dos_select.replace("orb", "")
for orbital in ["s", "p", "d"]:
dostraces += [
dos_tot_ele_traces["dos"]["elements"][ele_label]
[orbital]["traces"][spin]
for spin in dos_tot_ele_traces["dos"]["elements"]
[ele_label][orbital]["traces"].keys()
]
traces = [bstraces, dostraces, bs_data]
return (traces, elements)
else:
# --
# -- BS and DOS passed manually
# --
# - BS Data
if type(bandstructure_symm_line) != dict:
bandstructure_symm_line = bandstructure_symm_line.to_dict()
if type(density_of_states) != dict:
density_of_states = density_of_states.to_dict()
bs_reg_plot = BSPlotter(
BSML.from_dict(bandstructure_symm_line))
bs_data = bs_reg_plot.bs_plot_data()
# - Strip latex math wrapping
str_replace = {
"$": "",
"\\mid": "|",
"\\Gamma": "Γ",
"\\Sigma": "Σ",
"GAMMA": "Γ",
"_1": "₁",
"_2": "₂",
"_3": "₃",
"_4": "₄",
}
for entry_num in range(len(bs_data["ticks"]["label"])):
for key in str_replace.keys():
if key in bs_data["ticks"]["label"][entry_num]:
bs_data["ticks"]["label"][entry_num] = bs_data[
"ticks"]["label"][entry_num].replace(
key, str_replace[key])
# Obtain bands to plot over:
energy_window = (-6.0, 10.0)
bands = []
for band_num in range(bs_reg_plot._nb_bands):
if (bs_data["energy"][0][str(Spin.up)][band_num][0] <=
energy_window[1]) and (bs_data["energy"][0][str(
Spin.up)][band_num][0] >= energy_window[0]):
bands.append(band_num)
bstraces = []
# Generate traces for total BS data
for d in range(len(bs_data["distances"])):
dist_dat = bs_data["distances"][d]
energy_ind = [
i for i in range(len(bs_data["distances"][d]))
]
traces_for_segment = [{
"x":
dist_dat,
"y":
[bs_data["energy"][d]["1"][i][j] for j in energy_ind],
"mode":
"lines",
"line": {
"color": "#666666"
},
"hoverinfo":
"skip",
"showlegend":
False,
} for i in bands]
if bs_reg_plot._bs.is_spin_polarized:
traces_for_segment += [{
"x":
dist_dat,
"y": [
bs_data["energy"][d]["-1"][i][j]
for j in energy_ind
],
"mode":
"lines",
"line": {
"color": "#666666"
},
"hoverinfo":
"skip",
"showlegend":
False,
} for i in bands]
bstraces += traces_for_segment
# - DOS Data
dostraces = []
dos = CompleteDos.from_dict(density_of_states)
dos_max = np.abs(
(dos.energies - dos.efermi - energy_window[1])).argmin()
dos_min = np.abs(
(dos.energies - dos.efermi - energy_window[0])).argmin()
if bs_reg_plot._bs.is_spin_polarized:
# Add second spin data if available
trace_tdos = go.Scatter(
x=dos.densities[Spin.down][dos_min:dos_max],
y=dos.energies[dos_min:dos_max] - dos.efermi,
mode="lines",
name="Total DOS (spin ↓)",
line=go.scatter.Line(color="#444444", dash="dash"),
fill="tozerox",
)
dostraces.append(trace_tdos)
tdos_label = "Total DOS (spin ↑)"
else:
tdos_label = "Total DOS"
# Total DOS
trace_tdos = go.Scatter(
x=dos.densities[Spin.up][dos_min:dos_max],
y=dos.energies[dos_min:dos_max] - dos.efermi,
mode="lines",
name=tdos_label,
line=go.scatter.Line(color="#444444"),
fill="tozerox",
legendgroup="spinup",
)
dostraces.append(trace_tdos)
ele_dos = dos.get_element_dos()
elements = [str(entry) for entry in ele_dos.keys()]
if dos_select == "ap":
proj_data = ele_dos
elif dos_select == "op":
proj_data = dos.get_spd_dos()
elif "orb" in dos_select:
proj_data = dos.get_element_spd_dos(
Element(dos_select.replace("orb", "")))
else:
raise PreventUpdate
# Projected DOS
count = 0
colors = [
"#1f77b4", # muted blue
"#ff7f0e", # safety orange
"#2ca02c", # cooked asparagus green
"#9467bd", # muted purple
"#e377c2", # raspberry yogurt pink
"#d62728", # brick red
"#8c564b", # chestnut brown
"#bcbd22", # curry yellow-green
"#17becf", # blue-teal
]
for label in proj_data.keys():
if bs_reg_plot._bs.is_spin_polarized:
trace = go.Scatter(
x=proj_data[label].densities[Spin.down]
[dos_min:dos_max],
y=dos.energies[dos_min:dos_max] - dos.efermi,
mode="lines",
name=str(label) + " (spin ↓)",
line=dict(width=3,
color=colors[count],
dash="dash"),
)
dostraces.append(trace)
spin_up_label = str(label) + " (spin ↑)"
else:
spin_up_label = str(label)
trace = go.Scatter(
x=proj_data[label].densities[Spin.up][dos_min:dos_max],
y=dos.energies[dos_min:dos_max] - dos.efermi,
mode="lines",
name=spin_up_label,
line=dict(width=3, color=colors[count]),
)
dostraces.append(trace)
count += 1
traces = [bstraces, dostraces, bs_data]
return (traces, elements)
def setUp(self):
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.plotter = DosPlotter(sigma=0.2, stack=True)
def setUp(self):
with open(os.path.join(test_dir, "complete_dos.json"), "r",
encoding='utf-8') as f:
self.dos = CompleteDos.from_dict(json.load(f))
self.plotter = DosPlotter(sigma=0.2, stack=True)
def setUp(self):
with open(os.path.join(test_dir, "complete_dos.json"), "r") as f:
self.dos = CompleteDos.from_dict(json.load(f))
def featurize(self, dos):
"""
Args:
dos (pymatgen CompleteDos or their dict):
The density of states to featurize. Must be a complete DOS,
(i.e. contains PDOS and structure, in addition to total DOS)
Returns:
([float | string]): a list of band structure features.
List of currently supported features:
.. xbm_percents: [(float)] fractions that orbitals contribute
.. xbm_locations: [[(float)]] cartesian locations of orbitals
.. xbm_species: [(str)] elemental specie of orbitals (ex: 'Ti')
.. xbm_characters: [(str)] orbital characters (s p d or f)
.. xbm_coordinations: [(str)] the coordination geometry that
the orbitals reside in. (the coordination environment
of the site the orbital is associated with)
.. xbm_significant_contributors: (int) the number of orbitals
with contributions above the significance_threshold
"""
if isinstance(dos, dict):
dos = CompleteDos.from_dict(dos)
# preparation
orbital_scores = DOSFeaturizer.get_cbm_vbm_scores(
dos, self.coordination_features, self.energy_cutoff,
self.sampling_resolution, self.gaussian_smear)
orbital_scores.sort(key=lambda x: x['cbm_score'], reverse=True)
cbm_contributors = orbital_scores[0:self.contributors]
cbm_sig_cont = [
orb for orb in orbital_scores
if orb['cbm_score'] > self.significance_threshold
]
orbital_scores.sort(key=lambda x: x['vbm_score'], reverse=True)
vbm_contributors = orbital_scores[0:self.contributors]
vbm_sig_cont = [
orb for orb in orbital_scores
if orb['vbm_score'] > self.significance_threshold
]
features = []
for extremum in ["cbm", "vbm"]:
for feat in [
"{}_score".format(extremum), "location", "specie",
"character", "coordination", "significant_contributors"
]:
contributors = locals()["{}_contributors".format(extremum)]
if feat == "coordination":
if self.coordination_features:
features.append([
contributors[i]['coordination']
for i in range(0, self.contributors)
])
elif feat == "significant_contributors":
features.append(
len(locals()["{}_sig_cont".format(extremum)]))
else:
features.append([
contributors[i][feat]
for i in range(0, self.contributors)
])
return features
from my_functions.phase_diagram.analysis import ChempotAnalysis, Chempots
with open(
'/home/lorenzo/data/NN_cubic/E-form-vacancies-PBE/vacancies_NN_cubic_PBE.json'
) as f:
defects_analysis = DefectsAnalysis.from_dict(json.load(f))
with open(
'/home/lorenzo/data/NN_cubic/phase-diagram-PBE/computed_phases_NN_cubic.json'
) as f:
computed_phases = json.load(f)
with open(
'/home/lorenzo/data/NN_cubic/E-form-vacancies-PBE/dos_NN_cubic_PBE.json'
) as f:
bulk_dos = CompleteDos.from_dict(json.load(f))
with open(
'/home/lorenzo/data/NN_cubic/phase-diagram-PBE/chempots/chempots_boundary_NN_cubic_PBE.json'
) as f:
chempots_boundary_delta = json.load(f)
chempots_boundary_delta = {
res: Chempots.from_dict(chempots_boundary_delta[res]).chempots
for res in chempots_boundary_delta
}
chempots_analysis = ChempotAnalysis(computed_phases)
chempots_boundary = {
res: chempots_analysis.get_chempots_abs(chempots_boundary_delta[res])
for res in chempots_boundary_delta
}