def _get_cdos(pdos_file, site_file):
if not (pdos_file and site_file):
raise ValueError('Both dos.ext and site.ext are needed for PDOS')
energies, data, efermi, nsp = _read_dos_data(pdos_file)
if nsp == 1:
fake_tdos = Dos(efermi, energies, {Spin.up: 0 * energies})
spins = (Spin.up, )
elif nsp == 2:
fake_tdos = Dos(efermi, energies, {
Spin.up: 0 * energies,
Spin.down: 0 * energies
})
spins = (Spin.up, Spin.down)
else:
raise ValueError('There can\'t be {} spin channels, that makes '
'no sense!'.format(nsp))
site_data = QuestaalSite.from_file(site_file)
structure = site_data.structure
pdoss = {}
for site, orbital, spin in product(
range(len(site_data.sites)),
range(16), # forget about g orbs
range(len(spins))):
if structure.sites[site] not in pdoss:
pdoss.update({structure.sites[site]: {}})
if Orbital(orbital) not in pdoss[structure.sites[site]]:
pdoss[structure.sites[site]].update({Orbital(orbital): {}})
pdoss[structure.sites[site]][Orbital(orbital)].update(
{spins[spin]: data[site * (25 * nsp) + orbital * nsp + spin]})
return CompleteDos(structure, fake_tdos, pdoss)
def test_orbital_resolved_cohp(self):
orbitals = [
tuple((Orbital(i), Orbital(j))) for j in range(4) for i in range(4)
]
self.assertIsNone(self.cohp_bise.orb_res_cohp)
self.assertIsNone(self.coop_bise.orb_res_cohp)
self.assertIsNone(self.cohp_fe.orb_res_cohp)
self.assertIsNone(self.coop_fe.orb_res_cohp)
self.assertIsNone(self.orb_notot.cohp_data["Ga1-As2"]["COHP"])
self.assertIsNone(self.orb_notot.cohp_data["Ga1-As2"]["ICOHP"])
for o, orbs in enumerate(self.orb.orb_res_cohp["Ga1-As2"]):
orb_set = self.orb.orb_res_cohp["Ga1-As2"][orbs]["orbitals"]
self.assertEqual(orb_set[0][0], 4)
self.assertEqual(orb_set[1][0], 4)
self.assertIn(tuple((orb_set[0][1], orb_set[1][1])), orbitals)
# The sum of the orbital-resolved COHPs should be approximately
# the total COHP. Due to small deviations in the LOBSTER calculation,
# the precision is not very high though.
cohp = self.orb.cohp_data["Ga1-As2"]["COHP"][Spin.up]
icohp = self.orb.cohp_data["Ga1-As2"]["ICOHP"][Spin.up]
tot = np.sum([
self.orb.orb_res_cohp["Ga1-As2"][orbs]["COHP"][Spin.up]
for orbs in self.orb.orb_res_cohp["Ga1-As2"]
],
axis=0)
self.assertArrayAlmostEqual(tot, cohp, decimal=3)
tot = np.sum([
self.orb.orb_res_cohp["Ga1-As2"][orbs]["ICOHP"][Spin.up]
for orbs in self.orb.orb_res_cohp["Ga1-As2"]
],
axis=0)
self.assertArrayAlmostEqual(tot, icohp, decimal=3)
def from_dict(d):
"""
Args:
A dict with all data for a band structure symm line object.
Returns:
A BandStructureSymmLine object
"""
labels_dict = d['labels_dict']
projections = {}
structure = None
if 'projections' in d and len(d['projections']) != 0:
structure = Structure.from_dict(d['structure'])
projections = {
Spin.from_int(int(spin)): [
[{Orbital.from_string(orb): [
d['projections'][spin][i][j][orb][k]
for k in range(len(d['projections'][spin][i][j][orb]))]
for orb in d['projections'][spin][i][j]}
for j in range(len(d['projections'][spin][i]))]
for i in range(len(d['projections'][spin]))]
for spin in d['projections']}
return BandStructureSymmLine(
d['kpoints'], {Spin.from_int(int(k)): d['bands'][k]
for k in d['bands']},
Lattice(d['lattice_rec']['matrix']), d['efermi'],
labels_dict, structure=structure, projections=projections)
def _get_orb_lobster(orb):
"""
Args:
orb: string representation of orbital
Returns:
Orbital
"""
orb_labs = [
"s",
"p_y",
"p_z",
"p_x",
"d_xy",
"d_yz",
"d_z^2",
"d_xz",
"d_x^2-y^2",
"f_y(3x^2-y^2)",
"f_xyz",
"f_yz^2",
"f_z^3",
"f_xz^2",
"f_z(x^2-y^2)",
"f_x(x^2-3y^2)",
]
try:
orbital = Orbital(orb_labs.index(orb[1:]))
return orbital
except AttributeError:
print("Orb not in list")
return None
def from_dict(cls, d):
"""
Args:
A dict with all data for a band structure symm line object.
Returns:
A BandStructureSymmLine object
"""
# Strip the label to recover initial string (see trick used in as_dict to handle $ chars)
labels_dict = {k.strip(): v for k, v in d['labels_dict'].items()}
projections = {}
structure = None
if 'projections' in d and len(d['projections']) != 0:
structure = Structure.from_dict(d['structure'])
projections = {
Spin.from_int(int(spin)): [
[{Orbital.from_string(orb): [
d['projections'][spin][i][j][orb][k]
for k in range(len(d['projections'][spin][i][j][orb]))]
for orb in d['projections'][spin][i][j]}
for j in range(len(d['projections'][spin][i]))]
for i in range(len(d['projections'][spin]))]
for spin in d['projections']}
return BandStructureSymmLine(
d['kpoints'], {Spin.from_int(int(k)): d['bands'][k]
for k in d['bands']},
Lattice(d['lattice_rec']['matrix']), d['efermi'],
labels_dict, structure=structure, projections=projections)
def get_dos_from_id(self, task_id):
"""
Overrides the get_dos_from_id for the MIT gridfs format.
"""
args = {'task_id': task_id}
fields = ['calculations']
structure = self.get_structure_from_id(task_id)
dosid = None
for r in self.query(fields, args):
dosid = r['calculations'][-1]['dos_fs_id']
if dosid != None:
self._fs = gridfs.GridFS(self.db, 'dos_fs')
with self._fs.get(dosid) as dosfile:
s = dosfile.read()
try:
d = json.loads(s)
except:
s = zlib.decompress(s)
d = json.loads(s)
tdos = Dos.from_dict(d)
pdoss = {}
for i in range(len(d['pdos'])):
ados = d['pdos'][i]
all_ados = {}
for j in range(len(ados)):
orb = Orbital.from_vasp_index(j)
odos = ados[str(orb)]
all_ados[orb] = {Spin.from_int(int(k)): v
for k, v
in odos['densities'].items()}
pdoss[structure[i]] = all_ados
return CompleteDos(structure, tdos, pdoss)
return None
def from_dict(cls, d):
"""
Args:
A dict with all data for a band structure symm line object.
Returns:
A BandStructureSymmLine object
"""
labels_dict = d['labels_dict']
projections = {}
structure = None
if 'projections' in d and len(d['projections']) != 0:
structure = Structure.from_dict(d['structure'])
projections = {
Spin.from_int(int(spin)):
[[{
Orbital.from_string(orb): [
d['projections'][spin][i][j][orb][k]
for k in range(len(d['projections'][spin][i][j][orb]))
]
for orb in d['projections'][spin][i][j]
} for j in range(len(d['projections'][spin][i]))]
for i in range(len(d['projections'][spin]))]
for spin in d['projections']
}
return BandStructureSymmLine(
d['kpoints'],
{Spin.from_int(int(k)): d['bands'][k]
for k in d['bands']},
Lattice(d['lattice_rec']['matrix']),
d['efermi'],
labels_dict,
structure=structure,
projections=projections)
def get_dos_from_id(self, task_id):
"""
Overrides the get_dos_from_id for the MIT gridfs format.
"""
args = {'task_id': task_id}
fields = ['calculations']
structure = self.get_structure_from_id(task_id)
dosid = None
for r in self.query(fields, args):
dosid = r['calculations'][-1]['dos_fs_id']
if dosid is not None:
self._fs = gridfs.GridFS(self.db, 'dos_fs')
with self._fs.get(dosid) as dosfile:
s = dosfile.read()
try:
d = json.loads(s)
except:
s = zlib.decompress(s)
d = json.loads(s.decode("utf-8"))
tdos = Dos.from_dict(d)
pdoss = {}
for i in range(len(d['pdos'])):
ados = d['pdos'][i]
all_ados = {}
for j in range(len(ados)):
orb = Orbital(j)
odos = ados[str(orb)]
all_ados[orb] = {Spin(int(k)): v
for k, v
in odos['densities'].items()}
pdoss[structure[i]] = all_ados
return CompleteDos(structure, tdos, pdoss)
return None
def _get_bond_data(line):
"""
Subroutine to extract bond label, site indices, and length from
a LOBSTER header line. The site indices are zero-based, so they
can be easily used with a Structure object.
Example header line: No.4:Fe1->Fe9(2.4524893531900283)
Example header line for orbtial-resolved COHP:
No.1:Fe1[3p_x]->Fe2[3d_x^2-y^2](2.456180552772262)
Args:
line: line in the COHPCAR header describing the bond.
Returns:
Dict with the bond label, the bond length, a tuple of the site
indices, a tuple containing the orbitals (if orbital-resolved),
and a label for the orbitals (if orbital-resolved).
"""
orb_labs = [
"s", "p_y", "p_z", "p_x", "d_xy", "d_yz", "d_z^2", "d_xz",
"d_x^2-y^2", "f_y(3x^2-y^2)", "f_xyz", "f_yz^2", "f_z^3", "f_xz^2",
"f_z(x^2-y^2)", "f_x(x^2-3y^2)"
]
line = line.rsplit("(", 1)
# bondnumber = line[0].replace("->", ":").replace(".", ":").split(':')[1]
length = float(line[-1][:-1])
sites = line[0].replace("->", ":").split(":")[1:3]
site_indices = tuple(
int(re.split(r"\D+", site)[1]) - 1 for site in sites)
# species = tuple(re.split(r"\d+", site)[0] for site in sites)
if "[" in sites[0]:
orbs = [re.findall(r"\[(.*)\]", site)[0] for site in sites]
orbitals = [
tuple((int(orb[0]), Orbital(orb_labs.index(orb[1:]))))
for orb in orbs
]
orb_label = "%d%s-%d%s" % (orbitals[0][0], orbitals[0][1].name,
orbitals[1][0], orbitals[1][1].name)
else:
orbitals = None
orb_label = None
# a label based on the species alone is not feasible, there can be more than one bond for each atom combination
# label = "%s" % (bondnumber)
bond_data = {
"length": length,
"sites": site_indices,
"orbitals": orbitals,
"orb_label": orb_label
}
return bond_data
def get_complete_dos(self, structure):
"""
Gives a CompleteDos object with the DOS from the interpolated projected band structure
Args:
the structure (necessary to identify sites for projection)
Returns:
a CompleteDos object
"""
pdoss = {}
for s in self._dos_partial:
if structure.sites[int(s)] not in pdoss:
pdoss[structure.sites[int(s)]] = {}
for o in self._dos_partial[s]:
if Orbital.from_string(o) not in pdoss[structure.sites[int(s)]]:
pdoss[structure.sites[int(s)]][Orbital.from_string(o)] = {}
pdoss[structure.sites[int(s)]][Orbital.from_string(o)][Spin.up] = self._dos_partial[s][o]
return CompleteDos(structure, total_dos=self.dos, pdoss=pdoss)
def get_complete_dos(self, structure):
"""
Gives a CompleteDos object with the DOS from the interpolated projected band structure
Args:
the structure (necessary to identify sites for projection)
Returns:
a CompleteDos object
"""
pdoss = {}
for s in self._dos_partial:
if structure.sites[int(s)] not in pdoss:
pdoss[structure.sites[int(s)]] = {}
for o in self._dos_partial[s]:
if Orbital.from_string(o) not in pdoss[structure.sites[int(s)]]:
pdoss[structure.sites[int(s)]][Orbital.from_string(o)] = {}
pdoss[structure.sites[int(s)]][Orbital.from_string(o)][Spin.up] = self._dos_partial[s][o]
return CompleteDos(structure, total_dos=self.dos, pdoss=pdoss)
def from_dict(d):
"""
Returns PDos object from dict representation.
"""
return PDos(
d["efermi"],
d["energies"],
{Spin.from_int(int(k)): v for k, v in d["densities"].items()},
Orbital.from_string(d["orbital"]),
)
def get_orbital_resolved_cohp(self, label, orbitals):
"""
Get orbital-resolved COHP.
Args:
label: bond label (Lobster: labels as in ICOHPLIST/ICOOPLIST.lobster).
orbitals: The orbitals as a label, or list or tuple of the form
[(n1, orbital1), (n2, orbital2)]. Orbitals can either be str,
int, or Orbital.
Returns:
A Cohp object if CompleteCohp contains orbital-resolved cohp,
or None if it doesn't.
Note: It currently assumes that orbitals are str if they aren't the
other valid types. This is not ideal, but the easiest way to
avoid unicode issues between python 2 and python 3.
"""
if self.orb_res_cohp is None:
return None
if isinstance(orbitals, (list, tuple)):
cohp_orbs = [
d["orbitals"] for d in self.orb_res_cohp[label].values()
]
orbs = []
for orbital in orbitals:
if isinstance(orbital[1], int):
orbs.append(tuple((orbital[0], Orbital(orbital[1]))))
elif isinstance(orbital[1], Orbital):
orbs.append(tuple((orbital[0], orbital[1])))
elif isinstance(orbital[1], str):
orbs.append(tuple((orbital[0], Orbital[orbital[1]])))
else:
raise TypeError("Orbital must be str, int, or Orbital.")
orb_index = cohp_orbs.index(orbs)
orb_label = list(self.orb_res_cohp[label].keys())[orb_index]
elif isinstance(orbitals, str):
orb_label = orbitals
else:
raise TypeError("Orbitals must be str, list, or tuple.")
try:
icohp = self.orb_res_cohp[label][orb_label]["ICOHP"]
except KeyError:
icohp = None
return Cohp(
self.efermi,
self.energies,
self.orb_res_cohp[label][orb_label]["COHP"],
icohp=icohp,
are_coops=self.are_coops,
)
def from_dict(cls, d):
"""
Returns CompleteDos object from dict representation.
"""
tdos = Dos.from_dict(d)
struct = Structure.from_dict(d["structure"])
pdoss = {}
for i in range(len(d["pdos"])):
at = struct[i]
orb_dos = {}
for orb_str, odos in d["pdos"][i].items():
orb = Orbital.from_string(orb_str)
orb_dos[orb] = {Spin.from_int(int(k)): v
for k, v in odos["densities"].items()}
pdoss[at] = orb_dos
return CompleteDos(struct, tdos, pdoss)
def from_dict(cls, d):
"""
Returns CompleteDos object from dict representation.
"""
tdos = Dos.from_dict(d)
struct = Structure.from_dict(d["structure"])
pdoss = {}
for i in range(len(d["pdos"])):
at = struct[i]
orb_dos = {}
for orb_str, odos in d["pdos"][i].items():
orb = Orbital.from_string(orb_str)
orb_dos[orb] = {Spin.from_int(int(k)): v
for k, v in odos["densities"].items()}
pdoss[at] = orb_dos
return CompleteDos(struct, tdos, pdoss)
def from_old_dict(cls, d):
"""
Args:
d (dict): A dict with all data for a band structure symm line
object.
Returns:
A BandStructureSymmLine object
"""
# Strip the label to recover initial string (see trick used in as_dict to handle $ chars)
labels_dict = {k.strip(): v for k, v in d["labels_dict"].items()}
projections = {}
structure = None
if "projections" in d and len(d["projections"]) != 0:
structure = Structure.from_dict(d["structure"])
projections = {}
for spin in d["projections"]:
dd = []
for i in range(len(d["projections"][spin])):
ddd = []
for j in range(len(d["projections"][spin][i])):
dddd = []
for k in range(len(d["projections"][spin][i][j])):
ddddd = []
orb = Orbital(k).name
for l in range(
len(d["projections"][spin][i][j][orb])):
ddddd.append(
d["projections"][spin][i][j][orb][l])
dddd.append(np.array(ddddd))
ddd.append(np.array(dddd))
dd.append(np.array(ddd))
projections[Spin(int(spin))] = np.array(dd)
return BandStructure(
d["kpoints"],
{Spin(int(k)): d["bands"][k]
for k in d["bands"]},
Lattice(d["lattice_rec"]["matrix"]),
d["efermi"],
labels_dict,
structure=structure,
projections=projections,
)
def get_projections_on_elements_and_orbitals(self, el_orb_spec):
"""
Method returning a dictionary of projections on elements and specific
orbitals
Args:
el_orb_spec: A dictionary of Elements and Orbitals for which we want
to have projections on. It is given as: {Element:[orbitals]},
e.g., {'Cu':['d','s']}
Returns:
A dictionary of projections on elements in the
{Spin.up:[][{Element:{orb:values}}],
Spin.down:[][{Element:{orb:values}}]} format
if there is no projections in the band structure returns an empty
dict.
"""
result = {}
structure = self.structure
el_orb_spec = {get_el_sp(el): orbs for el, orbs in el_orb_spec.items()}
for spin, v in self.projections.items():
result[spin] = [
[
{str(e): collections.defaultdict(float) for e in el_orb_spec}
for i in range(len(self.kpoints))
]
for j in range(self.nb_bands)
]
for i, j, k in itertools.product(
range(self.nb_bands),
range(len(self.kpoints)),
range(structure.num_sites),
):
sp = structure[k].specie
for orb_i in range(len(v[i][j])):
o = Orbital(orb_i).name[0]
if sp in el_orb_spec:
if o in el_orb_spec[sp]:
result[spin][i][j][str(sp)][o] += v[i][j][orb_i][k]
return result
def from_old_dict(cls, d):
"""
Args:
d (dict): A dict with all data for a band structure symm line
object.
Returns:
A BandStructureSymmLine object
"""
# Strip the label to recover initial string (see trick used in as_dict to handle $ chars)
labels_dict = {k.strip(): v for k, v in d['labels_dict'].items()}
projections = {}
structure = None
if 'projections' in d and len(d['projections']) != 0:
structure = Structure.from_dict(d['structure'])
projections = {}
for spin in d['projections']:
dd = []
for i in range(len(d['projections'][spin])):
ddd = []
for j in range(len(d['projections'][spin][i])):
dddd = []
for k in range(len(d['projections'][spin][i][j])):
ddddd = []
orb = Orbital(k).name
for l in range(
len(d['projections'][spin][i][j][orb])):
ddddd.append(
d['projections'][spin][i][j][orb][l])
dddd.append(ddddd)
ddd.append(dddd)
dd.append(ddd)
projections[spin] = dd
return BandStructureSymmLine(
d['kpoints'], {Spin(int(k)): d['bands'][k]
for k in d['bands']},
Lattice(d['lattice_rec']['matrix']),
d['efermi'],
labels_dict,
structure=structure,
projections=projections)
def from_dict(cls, d):
"""
Args:
A dict with all data for a band structure symm line object.
Returns:
A BandStructureSymmLine object
"""
labels_dict = d["labels_dict"]
projections = {}
structure = None
if "projections" in d and len(d["projections"]) != 0:
structure = Structure.from_dict(d["structure"])
projections = {
Spin.from_int(int(spin)): [
[
{
Orbital.from_string(orb): [
d["projections"][spin][i][j][orb][k]
for k in range(len(d["projections"][spin][i][j][orb]))
]
for orb in d["projections"][spin][i][j]
}
for j in range(len(d["projections"][spin][i]))
]
for i in range(len(d["projections"][spin]))
]
for spin in d["projections"]
}
return BandStructureSymmLine(
d["kpoints"],
{Spin.from_int(int(k)): d["bands"][k] for k in d["bands"]},
Lattice(d["lattice_rec"]["matrix"]),
d["efermi"],
labels_dict,
structure=structure,
projections=projections,
)
def from_dict(cls, d):
"""
Args:
A dict with all data for a band structure symm line object.
Returns:
A BandStructureSymmLine object
"""
# Strip the label to recover initial string (see trick used in as_dict to handle $ chars)
labels_dict = {k.strip(): v for k, v in d['labels_dict'].items()}
projections = {}
structure = None
if 'projections' in d and len(d['projections']) != 0:
structure = Structure.from_dict(d['structure'])
projections = {
Spin.from_int(int(spin)):
[[{
Orbital.from_string(orb): [
d['projections'][spin][i][j][orb][k]
for k in range(len(d['projections'][spin][i][j][orb]))
]
for orb in d['projections'][spin][i][j]
} for j in range(len(d['projections'][spin][i]))]
for i in range(len(d['projections'][spin]))]
for spin in d['projections']
}
return BandStructureSymmLine(
d['kpoints'],
{Spin.from_int(int(k)): d['bands'][k]
for k in d['bands']},
Lattice(d['lattice_rec']['matrix']),
d['efermi'],
labels_dict,
structure=structure,
projections=projections)
def test_init(self):
for i, orb in enumerate(Orbital.all_orbitals):
self.assertEqual(Orbital.from_vasp_index(i), orb)
self.assertRaises(IndexError, Orbital.from_vasp_index, 100)
def test_init(self):
for i, orb in enumerate(Orbital.all_orbitals):
self.assertEqual(Orbital.from_vasp_index(i), orb)
self.assertRaises(IndexError, Orbital.from_vasp_index, 100)
def test_cached(self):
self.assertEquals(id(Orbital.from_vasp_index(0)), id(Orbital.s))
def test_cached(self):
self.assertEqual(id(Orbital(0)), id(Orbital.s))
def test_init(self):
for orb in Orbital:
self.assertEqual(Orbital(orb.value), orb)
self.assertRaises(ValueError, Orbital, 100)
def test_cached(self):
self.assertEqual(id(Orbital.from_vasp_index(0)), id(Orbital.s))
def test_orbital_resolved_cohp(self):
orbitals = [
tuple((Orbital(i), Orbital(j))) for j in range(4) for i in range(4)
]
self.assertIsNone(self.cohp_bise.orb_res_cohp)
self.assertIsNone(self.coop_bise.orb_res_cohp)
self.assertIsNone(self.cohp_fe.orb_res_cohp)
self.assertIsNone(self.coop_fe.orb_res_cohp)
self.assertIsNone(self.orb_notot.cohp_data["1"]["COHP"])
self.assertIsNone(self.orb_notot.cohp_data["1"]["ICOHP"])
for orbs in self.orb.orb_res_cohp["1"]:
orb_set = self.orb.orb_res_cohp["1"][orbs]["orbitals"]
# print(orb_set[0][0])
self.assertEqual(orb_set[0][0], 4)
self.assertEqual(orb_set[1][0], 4)
self.assertIn(tuple((orb_set[0][1], orb_set[1][1])), orbitals)
# test d and f orbitals
comparelist = [
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,
7, 7
]
comparelist2 = [
"f0", "f0", "f0", "f0", "f1", "f1", "f1", "f1", "f2", "f2", "f2",
"f2", "f3", "f3", "f3", "f3", "f_1", "f_1", "f_1", "f_1", "f_2",
"f_2", "f_2", "f_2", "f_3", "f_3", "f_3", "f_3", "dx2", "dx2",
"dx2", "dx2", "dxy", "dxy", "dxy", "dxy", "dxz", "dxz", "dxz",
"dxz", "dyz", "dyz", "dyz", "dyz", "dz2", "dz2", "dz2", "dz2",
"px", "px", "px", "px", "py", "py", "py", "py", "pz", "pz", "pz",
"pz", "s", "s", "s", "s", "s", "s", "s", "s"
]
for iorb, orbs in enumerate(sorted(
self.cohp_Na2UO4.orb_res_cohp["49"])):
orb_set = self.cohp_Na2UO4.orb_res_cohp["49"][orbs]["orbitals"]
self.assertEqual(orb_set[0][0], comparelist[iorb])
self.assertEqual(str(orb_set[0][1]), comparelist2[iorb])
# The sum of the orbital-resolved COHPs should be approximately
# the total COHP. Due to small deviations in the LOBSTER calculation,
# the precision is not very high though.
cohp = self.orb.cohp_data["1"]["COHP"][Spin.up]
icohp = self.orb.cohp_data["1"]["ICOHP"][Spin.up]
tot = np.sum([
self.orb.orb_res_cohp["1"][orbs]["COHP"][Spin.up]
for orbs in self.orb.orb_res_cohp["1"]
],
axis=0)
self.assertArrayAlmostEqual(tot, cohp, decimal=3)
tot = np.sum([
self.orb.orb_res_cohp["1"][orbs]["ICOHP"][Spin.up]
for orbs in self.orb.orb_res_cohp["1"]
],
axis=0)
self.assertArrayAlmostEqual(tot, icohp, decimal=3)
# Lobster 3.1
cohp_KF = self.cohp_KF.cohp_data["1"]["COHP"][Spin.up]
icohp_KF = self.cohp_KF.cohp_data["1"]["ICOHP"][Spin.up]
tot_KF = np.sum([
self.cohp_KF.orb_res_cohp["1"][orbs]["COHP"][Spin.up]
for orbs in self.cohp_KF.orb_res_cohp["1"]
],
axis=0)
self.assertArrayAlmostEqual(tot_KF, cohp_KF, decimal=3)
tot_KF = np.sum([
self.cohp_KF.orb_res_cohp["1"][orbs]["ICOHP"][Spin.up]
for orbs in self.cohp_KF.orb_res_cohp["1"]
],
axis=0)
self.assertArrayAlmostEqual(tot_KF, icohp_KF, decimal=3)
# d and f orbitals
cohp_Na2UO4 = self.cohp_Na2UO4.cohp_data["49"]["COHP"][Spin.up]
icohp_Na2UO4 = self.cohp_Na2UO4.cohp_data["49"]["ICOHP"][Spin.up]
tot_Na2UO4 = np.sum([
self.cohp_Na2UO4.orb_res_cohp["49"][orbs]["COHP"][Spin.up]
for orbs in self.cohp_Na2UO4.orb_res_cohp["49"]
],
axis=0)
self.assertArrayAlmostEqual(tot_Na2UO4, cohp_Na2UO4, decimal=3)
tot_Na2UO4 = np.sum([
self.cohp_Na2UO4.orb_res_cohp["49"][orbs]["ICOHP"][Spin.up]
for orbs in self.cohp_Na2UO4.orb_res_cohp["49"]
],
axis=0)
self.assertArrayAlmostEqual(tot_Na2UO4, icohp_Na2UO4, decimal=3)
def projected_dos():
step_count=1
filename='vasprun.xml'
check_file(filename)
proc_str="Reading Data From "+ filename +" File ..."
procs(proc_str,step_count,sp='-->>')
vsr=Vasprun(filename)
nedos=vsr.parameters['NEDOS']
struct=vsr.final_structure
pdos=vsr.pdos
filename='PROCAR'
check_file(filename)
step_count+=1
proc_str="Reading Data From "+ filename +" File ..."
procs(proc_str,step_count,sp='-->>')
procar=Procar(filename)
nbands=procar.nbands
nions=procar.nions
norbitals=len(procar.orbitals)
nkpoints=procar.nkpoints
(atom_index,in_str)=atom_selection(struct)
if len(atom_index)==0:
print("No atoms selected!")
return
# print(atom_index)
if vsr.is_spin:
proc_str="This Is a Spin-polarized Calculation."
procs(proc_str,0,sp='-->>')
contrib=np.zeros((nedos,norbitals+1,2))
energies=vsr.tdos.energies-vsr.efermi
for ispin in [0,1]:
if ispin==0:
spin=Spin.up
s_name='Up'
else:
spin=Spin.down
s_name='Down'
contrib[:,0,ispin]=energies
for i in atom_index:
for j in range(norbitals):
contrib[:,j+1,ispin]=contrib[:,j+1,ispin]+pdos[i][Orbital(j)][spin]
step_count+=1
filename="PDOS_"+s_name+".dat"
proc_str="Writting Projected DOS Data to "+ filename +" File ..."
procs(proc_str,step_count,sp='-->>')
tmp1_str="#%%(key1)+12s"
tmp2_dic={'key1':'Energy(ev)'}
for i in range(norbitals):
tmp1_str+="%(key"+str(i+2)+")+12s"
tmp2_dic["key"+str(i+2)]=procar.orbitals[i]
# print(tmp1_str)
atom_index_str=[str(x+1) for x in atom_index]
head_line1="#String: "+in_str+'\n#Selected atom: ' +' '.join(atom_index_str)+'\n'
head_line2=tmp1_str % tmp2_dic
head_line=head_line1+head_line2
write_col_data(filename,contrib[:,:,ispin],head_line)
else:
if vsr.parameters['LNONCOLLINEAR']:
proc_str="This Is a Non-Collinear Calculation."
procs(proc_str,0,sp='-->>')
else:
proc_str="This Is a Non-Spin Calculation."
procs(proc_str,0,sp='-->>')
contrib=np.zeros((nedos,norbitals+1))
energies=vsr.tdos.energies-vsr.efermi
contrib[:,0]=energies
for i in atom_index:
for j in range(norbitals):
contrib[:,j+1]=contrib[:,j+1]+pdos[i][Orbital(j)][Spin.up]
step_count+=1
filename="PDOS.dat"
proc_str="Writting Projected DOS Data to "+ filename +" File ..."
procs(proc_str,step_count,sp='-->>')
tmp1_str="#%(key1)+12s%(key2)+12s"
tmp2_dic={'key1':'K-Distance','key2':'Energy(ev)'}
for i in range(norbitals):
tmp1_str+="%(key"+str(i+3)+")+12s"
tmp2_dic["key"+str(i+3)]=procar.orbitals[i]
# print(tmp1_str)
atom_index_str=[str(x+1) for x in atom_index]
head_line1="#String: "+in_str+'\n#Selected atom: ' +' '.join(atom_index_str)+'\n'
head_line2=tmp1_str % tmp2_dic
head_line=head_line1+head_line2
write_col_data(filename,contrib,head_line)
