def test_from_dict(self):
d = self.propertied_structure.to_dict
s = Structure.from_dict(d)
self.assertEqual(s[0].magmom, 5)
d = {'lattice': {'a': 3.8401979337, 'volume': 40.044794644251596,
'c': 3.8401979337177736, 'b': 3.840198994344244,
'matrix': [[3.8401979337, 0.0, 0.0],
[1.9200989668, 3.3257101909, 0.0],
[0.0, -2.2171384943, 3.1355090603]],
'alpha': 119.9999908639842, 'beta': 90.0,
'gamma': 60.000009137322195},
'sites': [{'properties': {'magmom': 5}, 'abc': [0.0, 0.0, 0.0],
'occu': 1.0, 'species': [{'occu': 1.0,
'oxidation_state':-2,
'properties': {'spin': 3},
'element': 'O'}],
'label': 'O2-', 'xyz': [0.0, 0.0, 0.0]},
{'properties': {'magmom':-5}, 'abc': [0.75, 0.5, 0.75],
'occu': 0.8, 'species': [{'occu': 0.8,
'oxidation_state': 2,
'properties': {'spin': 2},
'element': 'Mg'}],
'label': 'Mg2+:0.800',
'xyz': [3.8401979336749994, 1.2247250003039056e-06,
2.351631795225]}]}
s = Structure.from_dict(d)
self.assertEqual(s[0].magmom, 5)
self.assertEqual(s[0].specie.spin, 3)
def get_basic_analysis_and_error_checks(d, max_force_threshold=0.5,
volume_change_threshold=0.2):
initial_vol = d["input"]["crystal"]["lattice"]["volume"]
final_vol = d["output"]["crystal"]["lattice"]["volume"]
delta_vol = final_vol - initial_vol
percent_delta_vol = delta_vol / initial_vol
coord_num = get_coordination_numbers(d)
calc = d["calculations"][-1]
gap = calc["output"]["bandgap"]
cbm = calc["output"]["cbm"]
vbm = calc["output"]["vbm"]
is_direct = calc["output"]["is_gap_direct"]
warning_msgs = []
error_msgs = []
if abs(percent_delta_vol) > volume_change_threshold:
warning_msgs.append("Volume change > {}%"
.format(volume_change_threshold * 100))
bv_struct = Structure.from_dict(d["output"]["crystal"])
try:
bva = BVAnalyzer()
bv_struct = bva.get_oxi_state_decorated_structure(bv_struct)
except ValueError as e:
logger.error("Valence cannot be determined due to {e}."
.format(e=e))
except Exception as ex:
logger.error("BVAnalyzer error {e}.".format(e=str(ex)))
max_force = None
if d["state"] == "successful" and \
d["calculations"][0]["input"]["parameters"].get("NSW", 0) > 0:
# handle the max force and max force error
max_force = max([np.linalg.norm(a)
for a in d["calculations"][-1]["output"]
["ionic_steps"][-1]["forces"]])
if max_force > max_force_threshold:
error_msgs.append("Final max force exceeds {} eV"
.format(max_force_threshold))
d["state"] = "error"
s = Structure.from_dict(d["output"]["crystal"])
if not s.is_valid():
error_msgs.append("Bad structure (atoms are too close!)")
d["state"] = "error"
return {"delta_volume": delta_vol,
"max_force": max_force,
"percent_delta_volume": percent_delta_vol,
"warnings": warning_msgs,
"errors": error_msgs,
"coordination_numbers": coord_num,
"bandgap": gap, "cbm": cbm, "vbm": vbm,
"is_gap_direct": is_direct,
"bv_structure": bv_struct.as_dict()}
def from_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 = {
Spin(int(spin)): [
[{Orbital[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(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_basic_analysis_and_error_checks(d):
initial_vol = d["input"]["crystal"]["lattice"]["volume"]
final_vol = d["output"]["crystal"]["lattice"]["volume"]
delta_vol = final_vol - initial_vol
percent_delta_vol = delta_vol / initial_vol
coord_num = get_coordination_numbers(d)
calc = d["calculations"][-1]
gap = calc["output"]["bandgap"]
cbm = calc["output"]["cbm"]
vbm = calc["output"]["vbm"]
is_direct = calc["output"]["is_gap_direct"]
if abs(percent_delta_vol) > 0.20:
warning_msgs = ["Volume change > 20%"]
else:
warning_msgs = []
bv_struct = Structure.from_dict(d["output"]["crystal"])
try:
bva = BVAnalyzer()
bv_struct = bva.get_oxi_state_decorated_structure(bv_struct)
except ValueError as e:
logger.error("Valence cannot be determined due to {e}."
.format(e=e))
except Exception as ex:
logger.error("BVAnalyzer error {e}.".format(e=str(ex)))
return {"delta_volume": delta_vol,
"percent_delta_volume": percent_delta_vol,
"warnings": warning_msgs, "coordination_numbers": coord_num,
"bandgap": gap, "cbm": cbm, "vbm": vbm,
"is_gap_direct": is_direct,
"bv_structure": bv_struct.to_dict}
def from_dict(cls, d):
structure = Structure.from_dict(d["structure"])
return MPINTLammps(structure, parameters=d["parameters"],
label=d["label"],
specorder=d["specorder"],
always_triclinic=d["always_triclinic"],
no_data_file=d["no_data_file"])
def from_dict(cls, d):
"""
Args:
d (dict): A dict with all data for a band structure symm line
object.
Returns:
A BandStructureSymmLine object
"""
try:
# 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 d.get('projections'):
if isinstance(d["projections"]['1'][0][0], dict):
raise ValueError("Old band structure dict format detected!")
structure = Structure.from_dict(d['structure'])
projections = {Spin(int(spin)): np.array(v)
for spin, v in d["projections"].items()}
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)
except:
warnings.warn("Trying from_dict failed. Now we are trying the old "
"format. Please convert your BS dicts to the new "
"format. The old format will be retired in pymatgen "
"5.0.")
return BandStructureSymmLine.from_old_dict(d)
def from_dict(cls, d):
"""
Creates a TransformedStructure from a dict.
"""
s = Structure.from_dict(d)
return cls(s, history=d["history"],
other_parameters=d.get("other_parameters", None))
def setUp(self):
structure_dict = {
"lattice": {"a": 4.754150115,
"volume": 302.935463898643,
"c": 10.462573348,
"b": 6.090300362,
"matrix": [[4.754150115, 0.0, 0.0],
[0.0, 6.090300362, 0.0],
[0.0, 0.0, 10.462573348]],
"alpha": 90.0,
"beta": 90.0,
"gamma": 90.0},
"sites": [{"occu": 1, "abc": [0.0, 0.0, 0.0],
"xyz": [0.0, 0.0, 0.0],
"species": [{"occu": 1, "element": "Li"}],
"label": "Li"}, {"occu": 1,
"abc": [0.5000010396179928, 0.0,
0.5000003178950235],
"xyz": [2.37708, 0.0, 5.23129],
"species": [{"occu": 1,
"element": "Li"}],
"label": "Li"},
{"occu": 1, "abc": [0.0,
0.49999997028061194,
0.0],
"xyz": [0.0, 3.04515, 0.0],
"species": [{"occu": 1, "element": "Li"}], "label": "Li"}, {"occu": 1, "abc": [0.5000010396179928, 0.49999997028061194, 0.5000003178950235], "xyz": [2.37708, 3.04515, 5.23129], "species": [{"occu": 1, "element": "Li"}], "label": "Li"}, {"occu": 1, "abc": [0.7885825876997996, 0.5473161916279229, 0.3339168944194627], "xyz": [3.74904, 3.33332, 3.4936300000000005], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.2114173881108085, 0.452683748933301, 0.6660827855827808], "xyz": [1.00511, 2.75698, 6.968940000000001], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7114184277288014, 0.5473161916279229, 0.8339172123144861], "xyz": [3.38219, 3.33332, 8.72492], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7885825876997996, 0.9526820772587701, 0.3339168944194627], "xyz": [3.74904, 5.8021199999999995, 3.4936300000000005], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.28858365150718424, 0.047317863302453654, 0.16608342347556082], "xyz": [1.37197, 0.28818, 1.73766], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7440972443925447, 0.25000080611787734, 0.09613791622232937], "xyz": [3.537549999999999, 1.52258, 1.00585], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.28858365150718424, 0.452683748933301, 0.16608342347556082], "xyz": [1.37197, 2.75698, 1.73766], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.2114173881108085, 0.047317863302453654, 0.6660827855827808], "xyz": [1.00511, 0.28818, 6.968940000000001], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.2559006279926859, 0.7499991344433464, 0.9038627195677177], "xyz": [1.21659, 4.56772, 9.45673], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7559016676106785, 0.25000080611787734, 0.5961372783295493], "xyz": [3.5936699999999986, 1.52258, 6.2371300000000005], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7939989080466804, 0.7499991344433464, 0.5421304884886912], "xyz": [3.77479, 4.56772, 5.67208], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.24409830819992942, 0.7499991344433464, 0.40386240167269416], "xyz": [1.16048, 4.56772, 4.22544], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7060021073819206, 0.7499991344433464, 0.04213017059366761], "xyz": [3.35644, 4.56772, 0.44079000000000007], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.2939978684286875, 0.25000080611787734, 0.9578695094085758], "xyz": [1.3977099999999996, 1.52258, 10.02178], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.20600106776392774, 0.25000080611787734, 0.4578701473013559], "xyz": [0.9793599999999998, 1.52258, 4.7905], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.7114184277288014, 0.9526820772587701, 0.8339172123144861], "xyz": [3.38219, 5.8021199999999995, 8.72492], "species": [{"occu": 1, "element": "O"}], "label": "O"}, {"occu": 1, "abc": [0.5793611756830275, 0.7499991344433464, 0.9051119342269868], "xyz": [2.75437, 4.56772, 9.4698], "species": [{"occu": 1, "element": "P"}], "label": "P"}, {"occu": 1, "abc": [0.9206377363201961, 0.7499991344433464, 0.40511161633196324], "xyz": [4.37685, 4.56772, 4.23851], "species": [{"occu": 1, "element": "P"}], "label": "P"}, {"occu": 1, "abc": [0.42063880012758065, 0.25000080611787734, 0.09488774577525667], "xyz": [1.9997799999999994, 1.52258, 0.99277], "species": [{"occu": 1, "element": "P"}], "label": "P"}, {"occu": 1, "abc": [0.07936223949041206, 0.25000080611787734, 0.5948880636702801], "xyz": [0.3773, 1.52258, 6.22406], "species": [{"occu": 1, "element": "P"}], "label": "P"}, {"occu": 1, "abc": [0.021860899947623972, 0.7499991344433464, 0.7185507570598875], "xyz": [0.10393, 4.56772, 7.517890000000001], "species": [{"occu": 1, "element": "Fe"}], "label": "Fe"}, {"occu": 1, "abc": [0.478135932819614, 0.7499991344433464, 0.21855043916486389], "xyz": [2.27313, 4.56772, 2.2866], "species": [{"occu": 1, "element": "Fe"}], "label": "Fe"}, {"occu": 1, "abc": [0.9781369724376069, 0.25000080611787734, 0.2814489229423561], "xyz": [4.65021, 1.52258, 2.9446800000000004], "species": [{"occu": 1, "element": "Fe"}], "label": "Fe"}, {"occu": 1, "abc": [0.5218619395656168, 0.25000080611787734, 0.7814492408373795], "xyz": [2.48101, 1.52258, 8.17597], "species": [{"occu": 1, "element": "Fe"}], "label": "Fe"}]}
structure = Structure.from_dict(structure_dict)
self.structure = structure
trans = [SubstitutionTransformation({"Li": "Na"})]
self.trans = TransformedStructure(structure, trans)
def set_analysis(self, d, max_force_threshold=0.5, volume_change_threshold=0.2):
"""
Adapted from matgendb.creator
set the 'analysis' key
"""
initial_vol = d["input"]["structure"]["lattice"]["volume"]
final_vol = d["output"]["structure"]["lattice"]["volume"]
delta_vol = final_vol - initial_vol
percent_delta_vol = delta_vol / initial_vol
warning_msgs = []
error_msgs = []
if abs(percent_delta_vol) > volume_change_threshold:
warning_msgs.append("Volume change > {}%".format(volume_change_threshold * 100))
max_force = None
calc = d["calcs_reversed"][0]
if d["state"] == "successful" and calc["input"]["parameters"].get("NSW", 0) > 0:
# handle the max force and max force error
max_force = max([np.linalg.norm(a) for a in calc["output"]["ionic_steps"][-1]["forces"]])
if max_force > max_force_threshold:
error_msgs.append("Final max force exceeds {} eV".format(max_force_threshold))
d["state"] = "error"
s = Structure.from_dict(d["output"]["structure"])
if not s.is_valid():
error_msgs.append("Bad structure (atoms are too close!)")
d["state"] = "error"
d["analysis"] = {"delta_volume": delta_vol,
"delta_volume_percent": percent_delta_vol,
"max_force": max_force,
"warnings": warning_msgs,
"errors": error_msgs}
def from_dict(cls, d):
"""
Create from dict.
Args:
A dict with all data for a band structure object.
Returns:
A BandStructure object
"""
labels_dict = d['labels_dict']
projections = {}
structure = None
if isinstance(list(d['bands'].values())[0], dict):
eigenvals = {Spin(int(k)): np.array(d['bands'][k]['data'])
for k in d['bands']}
else:
eigenvals = {Spin(int(k)): d['bands'][k] for k in d['bands']}
if 'structure' in d:
structure = Structure.from_dict(d['structure'])
if d.get('projections'):
projections = {Spin(int(spin)): np.array(v)
for spin, v in d["projections"].items()}
return BandStructure(
d['kpoints'], eigenvals,
Lattice(d['lattice_rec']['matrix']), d['efermi'],
labels_dict, structure=structure, projections=projections)
def from_dict(cls, d):
structure = Structure.from_dict(d["structure"])
return cls(structure, np.array(d["displacements"]), specie=d["specie"],
temperature=d["temperature"], time_step=d["time_step"],
step_skip=d["step_skip"], min_obs=d["min_obs"],
smoothed=d.get("smoothed", "max"),
avg_nsteps=d.get("avg_nsteps", 1000))
def from_dict(d):
"""
Creates a TransformedStructure from a dict.
"""
s = Structure.from_dict(d)
return TransformedStructure(s, [], d["history"],
d.get("other_parameters", None))
def from_dict(d):
"""
Returns feffAtoms object from dictionary
"""
return FeffAtoms(Structure.from_dict(d['structure']),
d['central_atom'],
d['comment'])
def from_dict(d):
return Poscar(Structure.from_dict(d["structure"]),
comment=d["comment"],
selective_dynamics=d["selective_dynamics"],
true_names=d["true_names"],
velocities=d.get("velocities", None),
predictor_corrector=d.get("predictor_corrector", None))
def __call__(self, params, query_engine):
# Assign prototypes to all the structures at this parameter point that do not have a prototype
total_prototypes = 0
new_prototypes = 0
structures_coll = query_engine.collection
stoichs = structures_coll.find({"potential.params_id": params["_id"]}, {"pretty_formula": 1}).\
distinct("pretty_formula")
for stoich in stoichs:
cur = structures_coll.find({"potential.params_id": params["_id"], "prototype_id": {"$exists": False},
"pretty_formula": stoich}, fields={"structure": 1, "energy_per_site": 1})
if self.limit:
cur.sort('energy_per_site', pymongo.ASCENDING).limit(self.limit)
for doc in cur:
# Either get the prototype or insert this structure as a new one
structure = Structure.from_dict(doc["structure"])
if not splpy.util.is_structure_bad(structure):
proto_id, is_new = prototype.insert_prototype(structure, query_engine.db)
if proto_id is None:
logger.warn("Failed to create find or create prototype for structure {}".format(doc["_id"]))
continue
query_engine.collection.update({'_id': doc['_id']}, {"$set": {'prototype_id': proto_id}})
total_prototypes += 1
if is_new:
new_prototypes += 1
else:
logger.info("Skipping structure {} because there is something wrong with it.".format(doc["_id"]))
logger.info("Assigned {} prototypes, {} new.".format(total_prototypes, new_prototypes))
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 test_as_dict(self):
self.trans.set_parameter('author', 'will')
d = self.trans.as_dict()
self.assertIn('last_modified', d)
self.assertIn('history', d)
self.assertIn('version', d)
self.assertIn('author', d['other_parameters'])
self.assertEqual(Structure.from_dict(d).formula, 'Na4 Fe4 P4 O16')
def test_as_dict(self):
self.trans.set_parameter("author", "will")
d = self.trans.as_dict()
self.assertIn("last_modified", d)
self.assertIn("history", d)
self.assertIn("version", d)
self.assertIn("author", d["other_parameters"])
self.assertEqual(Structure.from_dict(d).formula, "Na4 Fe4 P4 O16")
def from_dict(hdict):
"""
Returns header object from a dictionary representation
"""
comment = hdict['comment']
source = hdict['source']
structure = Structure.from_dict(hdict['structure'])
return Header(structure, source, comment)
def structures(self):
"""
Copy of all structures in the TransformedStructure. A
structure is stored after every single transformation.
"""
hstructs = [Structure.from_dict(s['input_structure'])
for s in self.history if 'input_structure' in s]
return hstructs + [self.final_structure]
def from_dict(d):
"""
Returns FeffPot object from dictionary
Args:
d:
dictionary of FeffPot input parameters
"""
return FeffPot(Structure.from_dict(d['structure']), d['central_atom'])
def render_graph(batt_id):
query_path = {'battid': batt_id}
result = list(mongo_coll_path.find(query_path))
if result and result[0]['intercalating_paths']:
intercalating_paths = result[0]['intercalating_paths']
hops = result[0]['hops']
fss = Structure.from_dict(result[0]['full_sites_struct'])
bs = Structure.from_dict(result[0]['base_structure'])
graph_result = migration_graph(intercalating_paths, hops, fss, bs)
else:
print('No intercalating path available')
id_discharge = int(
list(mongo_coll.find(query_path))[0]['id_discharge'])
struct_dict = list(mongo_coll_mat.find({'task_id':
id_discharge}))[0]['structure']
graph_result = ctc.StructureMoleculeComponent(
Structure.from_dict(struct_dict), static=True)
return graph_result.struct_layout
def from_dict(cls, d):
lattice_rec = Lattice(d['lattice_rec']['matrix'])
eigendisplacements = np.array(d['eigendisplacements']['real']) + np.array(d['eigendisplacements']['imag'])*1j
nac_eigendisplacements = [(direction, np.array(e['real']) + np.array(e['imag'])*1j)
for direction, e in d['nac_eigendisplacements']]
nac_frequencies = [(direction, np.array(f)) for direction, f in d['nac_frequencies']]
structure = Structure.from_dict(d['structure']) if 'structure' in d else None
return cls(d['qpoints'], np.array(d['bands']), lattice_rec, nac_frequencies, eigendisplacements,
nac_eigendisplacements, d['labels_dict'], structure=structure)
def from_dict(d):
"""
Returns FeffPot object from dictionary
Args:
d: dictionary of FeffPot input parameters
"""
return FeffPot(Structure.from_dict(d['structure']),
d['central_atom'])
def from_dict(cls, d):
"""
Returns IRDielectricTensor from dict representation
"""
structure = Structure.from_dict(d["structure"])
oscillator_strength = d["oscillator_strength"]
ph_freqs_gamma = d["ph_freqs_gamma"]
epsilon_infinity = d["epsilon_infinity"]
return cls(oscillator_strength, ph_freqs_gamma, epsilon_infinity, structure)
def from_dict(cls, d):
structure = Structure.from_dict(d["structure"])
return cls(structure, np.array(d["displacements"]), specie=d["specie"],
temperature=d["temperature"], time_step=d["time_step"],
step_skip=d["step_skip"], min_obs=d["min_obs"],
smoothed=d.get("smoothed", "max"),
avg_nsteps=d.get("avg_nsteps", 1000),
lattices=np.array(d.get("lattices",
[d["structure"]["lattice"][
"matrix"]])))
def structures(self):
"""
Copy of all structures in the TransformedStructure. A
structure is stored after every single transformation.
"""
hstructs = [
Structure.from_dict(s["input_structure"]) for s in self.history
if "input_structure" in s
]
return hstructs + [self.final_structure]
def from_dict(cls, d):
structure = Structure.from_dict(d["structure"])
return cls(structure,
np.array(d["displacements"]),
specie=d["specie"],
temperature=d["temperature"],
time_step=d["time_step"],
step_skip=d["step_skip"],
time_intervals_number=d["time_intervals_number"],
spec_dict=d['spec_dict'])
def from_dict(cls, d) -> "FermiDos":
"""
Returns Dos object from dict representation of Dos.
"""
dos = Dos(
d["efermi"],
d["energies"],
{Spin(int(k)): v for k, v in d["densities"].items()},
)
return FermiDos(dos, structure=Structure.from_dict(d["structure"]), nelecs=d["nelecs"])
def set_analysis(d, max_force_threshold=0.5, volume_change_threshold=0.2):
"""
Adapted from matgendb.creator
set the 'analysis' key
"""
initial_vol = d["input"]["structure"]["lattice"]["volume"]
final_vol = d["output"]["structure"]["lattice"]["volume"]
delta_vol = final_vol - initial_vol
percent_delta_vol = 100 * delta_vol / initial_vol
warning_msgs = []
error_msgs = []
# delta volume checks
if abs(percent_delta_vol) > volume_change_threshold:
warning_msgs.append("Volume change > {}%".format(volume_change_threshold * 100))
# max force and valid structure checks
max_force = None
calc = d["calcs_reversed"][0]
if d["state"] == "successful" and calc["input"]["parameters"].get("NSW", 0) > 0:
# handle the max force and max force error
forces = np.array(calc['output']['ionic_steps'][-1]['forces'])
# account for selective dynamics
final_structure = Structure.from_dict(calc['output']['structure'])
sdyn = final_structure.site_properties.get('selective_dynamics')
if sdyn:
forces[np.logical_not(sdyn)] = 0
max_force = max(np.linalg.norm(forces, axis=1))
if max_force > max_force_threshold:
error_msgs.append("Final max force exceeds {} eV".format(max_force_threshold))
d["state"] = "error"
s = Structure.from_dict(d["output"]["structure"])
if not s.is_valid():
error_msgs.append("Bad structure (atoms are too close!)")
d["state"] = "error"
d["analysis"] = {"delta_volume": delta_vol,
"delta_volume_as_percent": percent_delta_vol,
"max_force": max_force,
"warnings": warning_msgs,
"errors": error_msgs}
def from_dict(cls, d):
"""
Returns IRDielectricTensor from dict representation
"""
structure = Structure.from_dict(d['structure'])
oscillator_strength = d['oscillator_strength']
ph_freqs_gamma = d['ph_freqs_gamma']
epsilon_infinity = d['epsilon_infinity']
return cls(oscillator_strength, ph_freqs_gamma, epsilon_infinity,
structure)
def from_dict(cls, d):
"""
Returns CompleteDos object from dict representation.
"""
tdos = PhononDos.from_dict(d)
struct = Structure.from_dict(d["structure"])
pdoss = {}
for at, pdos in zip(struct, d["pdos"]):
pdoss[at] = pdos
return cls(struct, tdos, pdoss)
def __init__(self, parameters):
self.update(parameters)
structure = Structure.from_dict(parameters['structure'])
structure.vbm_l = parameters['band_structure']['vbm_l']
structure.cbm_l = parameters['band_structure']['cbm_l']
structure.vbm = (parameters['band_structure']['vbm_a'], parameters['band_structure']['vbm_b'], parameters['band_structure']['vbm_c'])
structure.cbm = (parameters['band_structure']['cbm_a'], parameters['band_structure']['cbm_b'], parameters['band_structure']['cbm_c'])
self.structure = structure
self.job = parameters['job']
self.spec = parameters['spec']
self.option = parameters['option']
def from_dict(cls, d: dict) -> "ComplexDefects":
# orderedDict disables MSONable.
structure = d["structure"]
if isinstance(structure, dict):
structure = Structure.from_dict(structure)
complex_defects = OrderedDict()
for k, v in d["complex_defects"].items():
complex_defects[k] = ComplexDefect.from_dict(v)
return cls(structure=structure, complex_defects=complex_defects)
def from_dict(cls, d):
"""
Returns CompleteCohp object from dict representation.
"""
cohp_dict = {}
efermi = d["efermi"]
energies = d["energies"]
structure = Structure.from_dict(d["structure"])
if "bonds" in d.keys():
bonds = {
bond: {
"length":
d["bonds"][bond]["length"],
"sites":
tuple(
PeriodicSite.from_dict(site)
for site in d["bonds"][bond]["sites"])
}
for bond in d["bonds"]
}
else:
bonds = None
for label in d["COHP"]:
cohp = {
Spin(int(spin)): np.array(d["COHP"][label][spin])
for spin in d["COHP"][label]
}
try:
icohp = {
Spin(int(spin)): np.array(d["ICOHP"][label][spin])
for spin in d["ICOHP"][label]
}
except KeyError:
icohp = None
if label == "average":
avg_cohp = Cohp(efermi, energies, cohp, icohp=icohp)
else:
cohp_dict[label] = Cohp(efermi, energies, cohp, icohp=icohp)
if "average" not in d["COHP"].keys():
# calculate average
cohp = np.array([np.array(c)
for c in d["COHP"].values()]).mean(axis=0)
try:
icohp = np.array([np.array(c)
for c in d["ICOHP"].values()]).mean(axis=0)
except KeyError:
icohp = None
avg_cohp = Cohp(efermi, energies, cohp, icohp=icohp)
return CompleteCohp(structure,
avg_cohp,
cohp_dict,
bonds=bonds,
are_coops=d["are_coops"])
def from_dict(cls, d):
"""
Returns CompleteDos object from dict representation.
"""
tdos = PhononDos.from_dict(d)
struct = Structure.from_dict(d["structure"])
pdoss = {}
for at, pdos in zip(struct, d["pdos"]):
pdoss[at] = pdos
return cls(struct, tdos, pdoss)
def from_dict(cls, d):
"""
:param d: Dict representation
:return: SymmetrizedStructure
"""
return SymmetrizedStructure(
Structure.from_dict(d["structure"]),
spacegroup=d["spacegroup"],
equivalent_positions=d["equivalent_positions"],
wyckoff_letters=d["wyckoff_letters"],
)
def example_maker():
struct=Structure.from_dict(json.loads(open("PbTiO3.json",'r').read()))
make_vasp_dielectric_files(struct, user_settings=loadfn('vasp_settings.yaml'))
make_vasp_defect_files(ChargedDefectsStructures(struct,
max_min_oxi={'Pb':(0,2),'Ti':(0,4),'O':(-2,0),'Al':(3,4),'V':(3,4),
"Cr":(3,4),'Ga':(3,4),'Fe':(3,4),'Co':(3,4),'Ni':(3,4),
'K':(1,2),'Na':(1,2),"N":(-3,-2)},
substitutions={'Pb':['Na','K'],
'Ti':['Al','V','Cr','Ga','Fe','Co','Ni'],'O':['N']},
oxi_states={'Pb':2,'Ti':4,'O':-2}).defects,
struct.composition.reduced_formula,
user_settings=loadfn('vasp_settings.yaml'))
def from_dict(cls, d):
struct = d['entry_bulk']['structure']
struct = struct if isinstance(struct, Structure) \
else Structure.from_dict(struct)
entry_bulk = ComputedStructureEntry(struct, d['entry_bulk']['energy'])
analyzer = DefectsAnalyzer(
entry_bulk, d['e_vbm'],
{Element(el): d['mu_elts'][el]
for el in d['mu_elts']}, d['band_gap'])
for ddict in d['defects']:
analyzer.add_computed_defect(ComputedDefect.from_dict(ddict))
return analyzer
def from_dict(cls, d):
"""
keys are
pymatgen_structure
"""
pstructure = Structure.from_dict(d['clean_unwrap_structure'])
try:
occu = d['occu']
except KeyError:
occu = 1.0
return cls.from_pstructure(pstructure, occu)
def from_dict(cls, d):
"""
Create from dict.
Args:
A dict with all data for a band structure object.
Returns:
A BandStructure 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 isinstance(list(d["bands"].values())[0], dict):
eigenvals = {
Spin(int(k)): np.array(d["bands"][k]["data"])
for k in d["bands"]
}
else:
eigenvals = {Spin(int(k)): d["bands"][k] for k in d["bands"]}
if "structure" in d:
structure = Structure.from_dict(d["structure"])
try:
if d.get("projections"):
if isinstance(d["projections"]["1"][0][0], dict):
raise ValueError(
"Old band structure dict format detected!")
projections = {
Spin(int(spin)): np.array(v)
for spin, v in d["projections"].items()
}
return cls(
d["kpoints"],
eigenvals,
Lattice(d["lattice_rec"]["matrix"]),
d["efermi"],
labels_dict,
structure=structure,
projections=projections,
)
except Exception:
warnings.warn("Trying from_dict failed. Now we are trying the old "
"format. Please convert your BS dicts to the new "
"format. The old format will be retired in pymatgen "
"5.0.")
return cls.from_old_dict(d)
def from_dict(cls, d):
lattice = Lattice.from_dict(d["lattice"])
sites = [PeriodicSite.from_dict(sd, lattice) for sd in d["sites"]]
s = Structure.from_sites(sites)
return Slab(
lattice=lattice,
species=s.species_and_occu, coords=s.frac_coords,
miller_index=d["miller_index"],
oriented_unit_cell=Structure.from_dict(d["oriented_unit_cell"]),
shift=d["shift"], scale_factor=d["scale_factor"],
site_properties=s.site_properties, energy=d["energy"]
)
def setUpClass(cls):
cls.Mn3Al = pd.read_json(os.path.join(test_dir, "Mn3Al.json"))
cls.db_file = ""
cls.uuid = 1
cls.structures = [Structure.from_dict(s) for s in cls.Mn3Al.structure]
cls.parent_structure = cls.structures[0]
cls.energies = [
e * len(cls.parent_structure) for e in cls.Mn3Al.energy_per_atom
]
cls.heisenberg_settings = {"cutoff": 3.0, "tol": 0.04}
cls.db_file = os.path.join(db_dir, "db.json")
new_fw_spec = {"_fw_env": {"db_file": os.path.join(db_dir, "db.json")}}
def from_dict(cls, d):
lattice = Lattice.from_dict(d["lattice"])
sites = [PeriodicSite.from_dict(sd, lattice) for sd in d["sites"]]
s = Structure.from_sites(sites)
return Slab(
lattice=lattice,
species=s.species_and_occu, coords=s.frac_coords,
miller_index=d["miller_index"],
oriented_unit_cell=Structure.from_dict(d["oriented_unit_cell"]),
shift=d["shift"], scale_factor=d["scale_factor"],
site_properties=s.site_properties, energy=d["energy"]
)
def setUp(self):
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"LobsterCompleteDos_spin.json")) as f:
data_spin = json.load(f)
self.LobsterCompleteDOS_spin = LobsterCompleteDos.from_dict(data_spin)
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"LobsterCompleteDos_nonspin.json")) as f:
data_nonspin = json.load(f)
self.LobsterCompleteDOS_nonspin = LobsterCompleteDos.from_dict(
data_nonspin)
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"structure_KF.json")) as f:
data_structure = json.load(f)
self.structure = Structure.from_dict(data_structure)
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"LobsterCompleteDos_MnO.json")) as f:
data_MnO = json.load(f)
self.LobsterCompleteDOS_MnO = LobsterCompleteDos.from_dict(data_MnO)
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"LobsterCompleteDos_MnO_nonspin.json")) as f:
data_MnO_nonspin = json.load(f)
self.LobsterCompleteDOS_MnO_nonspin = LobsterCompleteDos.from_dict(
data_MnO_nonspin)
with open(
os.path.join(PymatgenTest.TEST_FILES_DIR,
"structure_MnO.json")) as f:
data_MnO = json.load(f)
self.structure_MnO = Structure.from_dict(data_MnO)
def post_process(self, docs):
s1 = Structure.from_dict(self.structure)
m = StructureMatcher(
ltol=self.ltol,
stol=self.stol,
angle_tol=self.angle_tol,
primitive_cell=True,
scale=True,
attempt_supercell=False,
comparator=ElementComparator(),
)
matches = []
for doc in docs:
s2 = Structure.from_dict(doc["structure"])
matched = m.fit(s1, s2)
if matched:
rms = m.get_rms_dist(s1, s2)
matches.append({
"material_id": doc["material_id"],
"normalized_rms_displacement": rms[0],
"max_distance_paired_sites": rms[1],
})
response = sorted(
matches[:self.limit],
key=lambda x: (
x["normalized_rms_displacement"],
x["max_distance_paired_sites"],
),
)
return response
def from_dict(cls, d):
lattice_rec = Lattice(d['lattice_rec']['matrix'])
eigendisplacements = np.array(
d['eigendisplacements']['real']) + np.array(
d['eigendisplacements']['imag']) * 1j
structure = Structure.from_dict(
d['structure']) if 'structure' in d else None
return cls(d['qpoints'],
np.array(d['bands']),
lattice_rec,
d['has_nac'],
eigendisplacements,
d['labels_dict'],
structure=structure)
def test_propertied_structure_mod(self):
prop_structure = Structure(
self.structure.lattice, ["Si"] * 2, self.structure.frac_coords, site_properties={"magmom": [5, -5]}
)
prop_structure.append("C", [0.25, 0.25, 0.25])
d = prop_structure.to_dict
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
s2 = Structure.from_dict(d)
self.assertEqual(len(w), 1)
self.assertEqual(
str(w[0].message), "Not all sites have property magmom. Missing values are set " "to None."
)
def from_dict(cls, d):
# Programmatic access to enumeration members in Enum class.
structure = d["structure"]
if isinstance(structure, dict):
structure = Structure.from_dict(structure)
return cls(structure=structure,
xc=Xc.from_string(d["xc"]),
task=Task.from_string(d["task"]),
kpoints=d["kpoints"],
potcar=Potcar.from_dict(d["potcar"]),
incar_settings=d["incar_settings"],
files_to_transfer=d["files_to_transfer"],
**d["kwargs"])
def from_dict(cls, d):
"""
Args:
d (dict): Dict representation
Returns: DiffusionAnalyzer
"""
structure = Structure.from_dict(d["structure"])
return cls(structure, np.array(d["displacements"]), specie=d["specie"],
temperature=d["temperature"], time_step=d["time_step"],
step_skip=d["step_skip"], min_obs=d["min_obs"],
smoothed=d.get("smoothed", "max"),
avg_nsteps=d.get("avg_nsteps", 1000),
lattices=np.array(d.get("lattices", [d["structure"]["lattice"]["matrix"]])))
def set_output_data(self, d_calc, d):
"""
set the 'output' key
"""
d["output"] = {
"structure": d_calc["output"]["structure"],
"density": d_calc.pop("density"),
"energy": d_calc["output"]["energy"],
"energy_per_atom": d_calc["output"]["energy_per_atom"]}
d["output"].update(self.get_basic_processed_data(d))
sg = SpacegroupAnalyzer(Structure.from_dict(d_calc["output"]["structure"]), 0.1)
if not sg.get_symmetry_dataset():
sg = SpacegroupAnalyzer(Structure.from_dict(d_calc["output"]["structure"]), 1e-3, 1)
d["output"]["spacegroup"] = {
"source": "spglib",
"symbol": sg.get_space_group_symbol(),
"number": sg.get_space_group_number(),
"point_group": sg.get_point_group_symbol(),
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()}
if d["input"]["parameters"].get("LEPSILON"):
for k in ['epsilon_static', 'epsilon_static_wolfe', 'epsilon_ionic']:
d["output"][k] = d_calc["output"][k]
def from_dict(cls, d):
a = d["about"]
dec = PMGJSONDecoder()
created_at = dec.process_decoded(a.get("created_at"))
data = {k: v for k, v in d["about"].items()
if k.startswith("_")}
data = dec.process_decoded(data)
structure = Structure.from_dict(d) if "lattice" in d \
else Molecule.from_dict(d)
return cls(structure, a["authors"], projects=a.get("projects", None),
references=a.get("references", ""),
remarks=a.get("remarks", None), data=data,
history=a.get("history", None), created_at=created_at)
def load_flla():
# ref: F. Faber, A. Lindmaa, O.A. von Lilienfeld, R. Armiento,
# Crystal structure representations for machine learning models
# of formation energies, Int. J. Quantum Chem. 115 (2015) 1094–1101.
# doi:10.1002/qua.24917.
df = pandas.read_csv(os.path.join(module_dir, "flla_2015.csv"),
comment="#")
column_headers = [
'material_id', 'e_above_hull', 'formula', 'nsites', 'structure',
'formation_energy', 'formation_energy_per_atom'
]
df['structure'] = pandas.Series(
[Structure.from_dict(ast.literal_eval(s)) for s in df['structure']],
df.index)
return df[column_headers]
def from_dict(cls, d) -> "LobsterCompleteDos":
"""
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 = orb_str
orb_dos[orb] = {Spin(int(k)): v for k, v in odos["densities"].items()}
pdoss[at] = orb_dos
return LobsterCompleteDos(struct, tdos, pdoss)
def from_dict(cls, d):
a = d["about"]
dec = MontyDecoder()
created_at = dec.process_decoded(a.get("created_at"))
data = {k: v for k, v in d["about"].items()
if k.startswith("_")}
data = dec.process_decoded(data)
structure = Structure.from_dict(d) if "lattice" in d \
else Molecule.from_dict(d)
return cls(structure, a["authors"], projects=a.get("projects", None),
references=a.get("references", ""),
remarks=a.get("remarks", None), data=data,
history=a.get("history", None), created_at=created_at)
def calc(self, item):
"""
Calculates diffraction patterns for the structures
Args:
item (dict): a dict with a material_id and a structure
Returns:
dict: a diffraction dict
"""
self.logger.debug("Calculating diffraction for {}".format(item[self.materials.key]))
struct = Structure.from_dict(item['structure'])
xrd_doc = {"xrd": self.get_xrd_from_struct(struct)}
return xrd_doc
def test_propertied_structure_mod(self):
prop_structure = Structure(self.structure.lattice, ["Si"] * 2,
self.structure.frac_coords,
site_properties={'magmom': [5, -5]})
prop_structure.append("C", [0.25, 0.25, 0.25])
d = prop_structure.to_dict
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
s2 = Structure.from_dict(d)
self.assertEqual(len(w), 1)
self.assertEqual(
str(w[0].message),
'Not all sites have property magmom. Missing values are set '
'to None.')
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 undo_last_change(self):
"""
Undo the last change in the TransformedStructure.
Raises:
IndexError if already at the oldest change.
"""
if len(self.history) == 0:
raise IndexError("Can't undo. Already at oldest change.")
if 'input_structure' not in self.history[-1]:
raise IndexError("Can't undo. Latest history has no input_structure")
h = self.history.pop()
self._undone.append((h, self.final_structure))
s = h["input_structure"]
if isinstance(s, dict):
s = Structure.from_dict(s)
self.final_structure = s
