class ComputedReactionTest(unittest.TestCase):
def setUp(self):
d = [{"correction": 0.0, "data": {}, "energy": -108.56492362,
"parameters": {}, "composition": {"Li": 54}},
{"correction": 0.0, "data": {}, "energy": -577.94689128,
"parameters": {}, "composition": {"O": 32, "Li": 64}},
{"correction": 0.0, "data": {}, "energy": -17.02844794,
"parameters": {}, "composition": {"O": 2}},
{"correction": 0.0, "data": {}, "energy": -959.64693323,
"parameters": {}, "composition": {"O": 72, "Li": 72}}]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(filter(lambda e: e.composition.reduced_formula in ["Li", "O2"],
entries))
prods = list(filter(lambda e: e.composition.reduced_formula == "Li2O2",
entries))
self.rxn = ComputedReaction(rcts, prods)
def test_calculated_reaction_energy(self):
self.assertAlmostEqual(self.rxn.calculated_reaction_energy,
- 5.60748821935)
def test_init(self):
self.assertEqual(str(self.rxn), "1.000 O2 + 2.000 Li -> 1.000 Li2O2")
def test_to_from_dict(self):
d = self.rxn.as_dict()
new_rxn = ComputedReaction.from_dict(d)
self.assertEqual(str(new_rxn), "1.000 O2 + 2.000 Li -> 1.000 Li2O2")
class ComputedReactionTest(unittest.TestCase):
def setUp(self):
d = [{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {
"Li": 54
}
}, {
"correction": 0.0,
"data": {},
"energy": -577.94689128,
"parameters": {},
"composition": {
"O": 32,
"Li": 64
}
}, {
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {
"O": 2
}
}, {
"correction": 0.0,
"data": {},
"energy": -959.64693323,
"parameters": {},
"composition": {
"O": 72,
"Li": 72
}
}]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"],
entries))
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2",
entries))
self.rxn = ComputedReaction(rcts, prods)
def test_calculated_reaction_energy(self):
self.assertAlmostEqual(self.rxn.calculated_reaction_energy,
-5.60748821935)
def test_init(self):
self.assertEqual(str(self.rxn), "1.000 O2 + 2.000 Li -> 1.000 Li2O2")
def test_to_from_dict(self):
d = self.rxn.as_dict()
new_rxn = ComputedReaction.from_dict(d)
self.assertEqual(str(new_rxn), "1.000 O2 + 2.000 Li -> 1.000 Li2O2")
class ComputedReactionTest(unittest.TestCase):
def setUp(self):
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {
"Li": 54
},
},
{
"correction": 0.0,
"data": {},
"energy": -577.94689128,
"parameters": {},
"composition": {
"O": 32,
"Li": 64
},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {
"O": 2
},
},
{
"correction": 0.0,
"data": {},
"energy": -959.64693323,
"parameters": {},
"composition": {
"O": 72,
"Li": 72
},
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"],
entries))
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2",
entries))
self.rxn = ComputedReaction(rcts, prods)
def test_calculated_reaction_energy(self):
self.assertAlmostEqual(self.rxn.calculated_reaction_energy,
-5.60748821935)
def test_calculated_reaction_energy_uncertainty(self):
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {
"Li": 54
},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {
"O": 2
},
},
{
'@module':
'pymatgen.entries.computed_entries',
'@class':
'ComputedEntry',
'energy':
-38.76889738,
'composition':
defaultdict(float, {
'Li': 4.0,
'O': 4.0
}),
'energy_adjustments': [{
'@module':
'pymatgen.entries.computed_entries',
'@class':
'ConstantEnergyAdjustment',
'@version':
'2020.6.8',
'value':
-1.864,
'uncertainty':
0.0744,
'name':
'MP2020 Composition Correction',
'cls': {
'@module': 'pymatgen.entries.compatibility',
'@class': 'MaterialsProject2020Compatibility',
'@version': '2020.6.8',
'compat_type': 'Advanced',
'correct_peroxide': True,
'check_potcar_hash': False
},
'description':
'Constant energy adjustment (-1.864 eV)'
}],
'parameters': {
'run_type': 'GGA',
'is_hubbard': False,
'pseudo_potential': {
'functional': 'PBE',
'labels': ['Li_sv', 'O'],
'pot_type': 'paw'
},
'hubbards': {},
'potcar_symbols': ['PBE Li_sv', 'PBE O'],
'oxide_type': 'peroxide'
},
'data': {
'oxide_type': 'peroxide'
},
'entry_id':
'mp-841',
'correction':
-1.864
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"],
entries))
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2",
entries))
rxn_with_uncertainty = ComputedReaction(rcts, prods)
self.assertAlmostEqual(
rxn_with_uncertainty.calculated_reaction_energy_uncertainty,
0.5 * 0.0744)
def test_calculated_reaction_energy_uncertainty_for_no_uncertainty(self):
# test that reaction_energy_uncertainty property doesn't cause errors
# when products/reactants have no uncertainties
self.assertAlmostEqual(self.rxn.calculated_reaction_energy_uncertainty,
0)
def test_calculated_reaction_energy_uncertainty_for_nan(self):
# test that reaction_energy_uncertainty property is nan when the uncertainty
# for any product/reactant is nan
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {
"Li": 54
},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {
"O": 2
},
},
{
'@module':
'pymatgen.entries.computed_entries',
'@class':
'ComputedEntry',
'energy':
-38.76889738,
'composition':
defaultdict(float, {
'Li': 4.0,
'O': 4.0
}),
'energy_adjustments': [{
'@module':
'pymatgen.entries.computed_entries',
'@class':
'ConstantEnergyAdjustment',
'@version':
'2020.6.8',
'value':
-1.864,
'uncertainty':
np.nan,
'name':
'MP2020 Composition Correction',
'cls': {
'@module': 'pymatgen.entries.compatibility',
'@class': 'MaterialsProject2020Compatibility',
'@version': '2020.6.8',
'compat_type': 'Advanced',
'correct_peroxide': True,
'check_potcar_hash': False
},
'description':
'Constant energy adjustment (-1.864 eV)'
}],
'parameters': {
'run_type': 'GGA',
'is_hubbard': False,
'pseudo_potential': {
'functional': 'PBE',
'labels': ['Li_sv', 'O'],
'pot_type': 'paw'
},
'hubbards': {},
'potcar_symbols': ['PBE Li_sv', 'PBE O'],
'oxide_type': 'peroxide'
},
'data': {
'oxide_type': 'peroxide'
},
'entry_id':
'mp-841',
'correction':
-1.864
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"],
entries))
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2",
entries))
rxn_with_uncertainty = ComputedReaction(rcts, prods)
self.assertTrue(
isnan(rxn_with_uncertainty.calculated_reaction_energy_uncertainty))
def test_init(self):
self.assertEqual(str(self.rxn), "2 Li + O2 -> Li2O2")
def test_to_from_dict(self):
d = self.rxn.as_dict()
new_rxn = ComputedReaction.from_dict(d)
self.assertEqual(str(new_rxn), "2 Li + O2 -> Li2O2")
def test_all_entries(self):
for c, e in zip(self.rxn.coeffs, self.rxn.all_entries):
if c > 0:
self.assertEqual(e.composition.reduced_formula, "Li2O2")
self.assertAlmostEqual(e.energy, -959.64693323)
class ComputedReactionTest(unittest.TestCase):
def setUp(self):
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {"Li": 54},
},
{
"correction": 0.0,
"data": {},
"energy": -577.94689128,
"parameters": {},
"composition": {"O": 32, "Li": 64},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {"O": 2},
},
{
"correction": 0.0,
"data": {},
"energy": -959.64693323,
"parameters": {},
"composition": {"O": 72, "Li": 72},
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"], entries)
)
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2", entries)
)
self.rxn = ComputedReaction(rcts, prods)
def test_calculated_reaction_energy(self):
self.assertAlmostEqual(self.rxn.calculated_reaction_energy, -5.60748821935)
def test_calculated_reaction_energy_uncertainty(self):
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {"Li": 54},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {"O": 2},
},
{
"@module": "pymatgen.entries.computed_entries",
"@class": "ComputedEntry",
"energy": -38.76889738,
"composition": defaultdict(float, {"Li": 4.0, "O": 4.0}),
"energy_adjustments": [
{
"@module": "pymatgen.entries.computed_entries",
"@class": "ConstantEnergyAdjustment",
"@version": "2020.6.8",
"value": -1.864,
"uncertainty": 0.0744,
"name": "MP2020 Composition Correction",
"cls": {
"@module": "pymatgen.entries.compatibility",
"@class": "MaterialsProject2020Compatibility",
"@version": "2020.6.8",
"compat_type": "Advanced",
"correct_peroxide": True,
"check_potcar_hash": False,
},
"description": "Constant energy adjustment (-1.864 eV)",
}
],
"parameters": {
"run_type": "GGA",
"is_hubbard": False,
"pseudo_potential": {
"functional": "PBE",
"labels": ["Li_sv", "O"],
"pot_type": "paw",
},
"hubbards": {},
"potcar_symbols": ["PBE Li_sv", "PBE O"],
"oxide_type": "peroxide",
},
"data": {"oxide_type": "peroxide"},
"entry_id": "mp-841",
"correction": -1.864,
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"], entries)
)
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2", entries)
)
rxn_with_uncertainty = ComputedReaction(rcts, prods)
self.assertAlmostEqual(
rxn_with_uncertainty.calculated_reaction_energy_uncertainty, 0.5 * 0.0744
)
def test_calculated_reaction_energy_uncertainty_for_no_uncertainty(self):
# test that reaction_energy_uncertainty property doesn't cause errors
# when products/reactants have no uncertainties
self.assertAlmostEqual(self.rxn.calculated_reaction_energy_uncertainty, 0)
def test_calculated_reaction_energy_uncertainty_for_nan(self):
# test that reaction_energy_uncertainty property is nan when the uncertainty
# for any product/reactant is nan
d = [
{
"correction": 0.0,
"data": {},
"energy": -108.56492362,
"parameters": {},
"composition": {"Li": 54},
},
{
"correction": 0.0,
"data": {},
"energy": -17.02844794,
"parameters": {},
"composition": {"O": 2},
},
{
"@module": "pymatgen.entries.computed_entries",
"@class": "ComputedEntry",
"energy": -38.76889738,
"composition": defaultdict(float, {"Li": 4.0, "O": 4.0}),
"energy_adjustments": [
{
"@module": "pymatgen.entries.computed_entries",
"@class": "ConstantEnergyAdjustment",
"@version": "2020.6.8",
"value": -1.864,
"uncertainty": np.nan,
"name": "MP2020 Composition Correction",
"cls": {
"@module": "pymatgen.entries.compatibility",
"@class": "MaterialsProject2020Compatibility",
"@version": "2020.6.8",
"compat_type": "Advanced",
"correct_peroxide": True,
"check_potcar_hash": False,
},
"description": "Constant energy adjustment (-1.864 eV)",
}
],
"parameters": {
"run_type": "GGA",
"is_hubbard": False,
"pseudo_potential": {
"functional": "PBE",
"labels": ["Li_sv", "O"],
"pot_type": "paw",
},
"hubbards": {},
"potcar_symbols": ["PBE Li_sv", "PBE O"],
"oxide_type": "peroxide",
},
"data": {"oxide_type": "peroxide"},
"entry_id": "mp-841",
"correction": -1.864,
},
]
entries = []
for e in d:
entries.append(ComputedEntry.from_dict(e))
rcts = list(
filter(lambda e: e.composition.reduced_formula in ["Li", "O2"], entries)
)
prods = list(
filter(lambda e: e.composition.reduced_formula == "Li2O2", entries)
)
rxn_with_uncertainty = ComputedReaction(rcts, prods)
self.assertTrue(
isnan(rxn_with_uncertainty.calculated_reaction_energy_uncertainty)
)
def test_init(self):
self.assertEqual(str(self.rxn), "2 Li + O2 -> Li2O2")
def test_to_from_dict(self):
d = self.rxn.as_dict()
new_rxn = ComputedReaction.from_dict(d)
self.assertEqual(str(new_rxn), "2 Li + O2 -> Li2O2")
def test_all_entries(self):
for c, e in zip(self.rxn.coeffs, self.rxn.all_entries):
if c > 0:
self.assertEqual(e.composition.reduced_formula, "Li2O2")
self.assertAlmostEqual(e.energy, -959.64693323)