def setUp(self) -> None:
if ob:
self.energies = [
-271.553636516598, -78.5918513462683, -350.105998350078
]
self.enthalpies = [13.917, 34.596, 49.515]
self.entropies = [67.357, 55.047, 84.265]
self.rct_1 = MoleculeEntry(
mol_placeholder,
self.energies[0],
enthalpy=self.enthalpies[0],
entropy=self.entropies[0],
)
self.rct_2 = MoleculeEntry(
mol_placeholder,
self.energies[1],
enthalpy=self.enthalpies[1],
entropy=self.entropies[1],
)
self.pro = MoleculeEntry(
mol_placeholder,
self.energies[2],
enthalpy=self.enthalpies[2],
entropy=self.entropies[2],
)
self.calc = ExpandedBEPRateCalculator([self.rct_1, self.rct_2],
[self.pro], 1.71, 0.1, -0.05,
1.8, 0.1, 0.05)
def setUp(self) -> None:
if ob:
self.energies = [-349.88738062842, -349.955817900195]
self.enthalpies = [53.623, 51.853]
self.entropies = [82.846, 79.595]
rct_mol = copy.deepcopy(mol_placeholder)
rct_mol.set_charge_and_spin(charge=1)
pro_mol = copy.deepcopy(mol_placeholder)
pro_mol.set_charge_and_spin(charge=0)
self.rct = MoleculeEntry(
rct_mol,
self.energies[0],
enthalpy=self.enthalpies[0],
entropy=self.entropies[0],
)
self.pro = MoleculeEntry(
pro_mol,
self.energies[1],
enthalpy=self.enthalpies[1],
entropy=self.entropies[1],
)
self.calc = RedoxRateCalculator([self.rct], [self.pro],
1.031373321805404, 18.5, 1.415,
-1.897, 7.5, 5)
def test_from_libe():
doc = loadfn(os.path.join(test_dir, "libe_entry.json"))
entry = MoleculeEntry.from_dataset_entry(doc)
assert entry.entry_id == "libe-120825"
assert entry.get_free_energy() == -11366.853316264207
entry_rrho = MoleculeEntry.from_dataset_entry(
doc, use_thermo="rrho_shifted")
assert entry_rrho.get_free_energy() == -11366.84673089201
entry_qrrho = MoleculeEntry.from_dataset_entry(doc, use_thermo="qrrho")
assert entry_qrrho.get_free_energy() == -11366.846521648069
def test_property():
mol_doc = loadfn(os.path.join(test_dir, "mol_doc_C1H1O2.json"))
entry = MoleculeEntry.from_molecule_document(mol_doc)
assert entry.entry_id == 215871
assert entry.formula == "C1 H1 O2"
assert entry.charge == -1
assert entry.energy == -189.256491214986
assert entry.entropy == 59.192
assert entry.enthalpy == 14.812
assert entry.get_free_energy() == -5150.055177181075
assert entry.species == ["O", "C", "O", "H"]
assert entry.num_atoms == 4
assert entry.bonds == [(0, 1), (0, 3), (1, 2)]
assert entry.num_bonds == 3
ref_coords = [
[3.6564233496, -2.7122919826, 0.0],
[3.2388110663, -1.3557709432, 0.0],
[4.1820830042, -0.5664108935, 0.0],
[4.6310495799, -2.6817671807, 0.0],
]
assert np.array_equal(entry.coords, ref_coords)
def make_a_mol_entry():
r"""
Make a symmetric (fake) molecule with ring.
O(0)
/ \
/ \
H(1)--C(2)--C(3)--H(4)
| |
H(5) H(6)
"""
species = ["O", "H", "C", "C", "H", "H", "H"]
coords = [
[0.0, 1.0, 0.0],
[-1.5, 0.0, 0.0],
[-0.5, 0.0, 0.0],
[0.5, 0.0, 0.0],
[1.5, 0.0, 0.0],
[-0.5, -1.0, 0.0],
[0.5, -1.0, 0.0],
]
m = Molecule(species, coords)
entry = MoleculeEntry(m, energy=0.0)
return entry
def setUp(self) -> None:
if ob:
self.energies = [
-271.553636516598, -78.5918513462683, -350.105998350078
]
self.enthalpies = [13.917, 34.596, 49.515]
self.entropies = [67.357, 55.047, 84.265]
self.rct_1 = MoleculeEntry(
mol_placeholder,
self.energies[0],
enthalpy=self.enthalpies[0],
entropy=self.entropies[0],
)
self.rct_2 = MoleculeEntry(
mol_placeholder,
self.energies[1],
enthalpy=self.enthalpies[1],
entropy=self.entropies[1],
)
self.pro = MoleculeEntry(
mol_placeholder,
self.energies[2],
enthalpy=self.enthalpies[2],
entropy=self.entropies[2],
)
self.ts = MoleculeEntry(mol_placeholder,
-350.099875862606,
enthalpy=48.560,
entropy=83.607)
self.reactants = [self.rct_1, self.rct_2]
self.products = [self.pro]
self.calc = ReactionRateCalculator(self.reactants, self.products,
self.ts)
def setUpClass(cls):
if ob:
EC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "EC.xyz")),
OpenBabelNN())
cls.EC_mg = metal_edge_extender(EC_mg)
LiEC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LiEC.xyz")),
OpenBabelNN())
cls.LiEC_mg = metal_edge_extender(LiEC_mg)
LEDC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LEDC.xyz")),
OpenBabelNN())
cls.LEDC_mg = metal_edge_extender(LEDC_mg)
LEMC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LEMC.xyz")),
OpenBabelNN())
cls.LEMC_mg = metal_edge_extender(LEMC_mg)
cls.LiEC_reextended_entries = []
entries = loadfn(
os.path.join(test_dir, "LiEC_reextended_entries.json"))
for entry in entries:
if "optimized_molecule" in entry["output"]:
mol = entry["output"]["optimized_molecule"]
else:
mol = entry["output"]["initial_molecule"]
E = float(entry["output"]["final_energy"])
H = float(entry["output"]["enthalpy"])
S = float(entry["output"]["entropy"])
mol_entry = MoleculeEntry(
molecule=mol,
energy=E,
enthalpy=H,
entropy=S,
entry_id=entry["task_id"],
)
if mol_entry.formula == "Li1":
if mol_entry.charge == 1:
cls.LiEC_reextended_entries.append(mol_entry)
else:
cls.LiEC_reextended_entries.append(mol_entry)
# dumpfn(cls.LiEC_reextended_entries, "unittest_input_molentries.json")
with open(os.path.join(test_dir, "unittest_RN_build.pkl"),
"rb") as input:
cls.RN_build = pickle.load(input)
with open(os.path.join(test_dir, "unittest_RN_pr_solved.pkl"),
"rb") as input:
cls.RN_pr_solved = pickle.load(input)
def _load_reaction():
filename = test_dir.joinpath("rxn_mol_graphs.json")
mol_graphs = loadfn(filename)
mol_entries = [
MoleculeEntry(m.molecule, energy=0, mol_graph=m) for m in mol_graphs
]
reactants = mol_entries[:2]
products = mol_entries[2:]
return reactants, products
def test_bucket_mol_entries():
C2H4_entry = MoleculeEntry(
Molecule.from_file(os.path.join(test_dir, "C2H4.xyz")),
energy=0.0,
enthalpy=0.0,
entropy=0.0,
)
LiEC_RO_entry = MoleculeEntry(
Molecule.from_file(os.path.join(test_dir, "LiEC_RO.xyz")),
energy=0.0,
enthalpy=0.0,
entropy=0.0,
)
C1Li1O3_entry = MoleculeEntry(
Molecule.from_file(os.path.join(test_dir, "C1Li1O3.xyz")),
energy=0.0,
enthalpy=0.0,
entropy=0.0,
)
bucket = bucket_mol_entries([C2H4_entry, LiEC_RO_entry, C1Li1O3_entry])
ref_dict = {
"C2 H4": {
5: {
0: [C2H4_entry]
}
},
"C3 H4 Li1 O3": {
11: {
0: [LiEC_RO_entry]
}
},
"C1 Li1 O3": {
5: {
0: [C1Li1O3_entry]
}
},
}
assert bucket == ref_dict
def setUpClass(cls) -> None:
if ob:
cls.LiEC_reextended_entries = []
entries = loadfn(
os.path.join(test_dir, "LiEC_reextended_entries.json"))
for entry in entries:
if "optimized_molecule" in entry["output"]:
mol = entry["output"]["optimized_molecule"]
else:
mol = entry["output"]["initial_molecule"]
E = float(entry["output"]["final_energy"])
H = float(entry["output"]["enthalpy"])
S = float(entry["output"]["entropy"])
mol_entry = MoleculeEntry(
molecule=mol,
energy=E,
enthalpy=H,
entropy=S,
entry_id=entry["task_id"],
)
if mol_entry.formula == "Li1":
if mol_entry.charge == 1:
cls.LiEC_reextended_entries.append(mol_entry)
else:
cls.LiEC_reextended_entries.append(mol_entry)
EC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "EC.xyz")),
OpenBabelNN())
cls.EC_mg = metal_edge_extender(EC_mg)
cls.EC_0_entry = None
cls.EC_minus_entry = None
cls.EC_1_entry = None
for entry in cls.LiEC_reextended_entries:
if (entry.formula == "C3 H4 O3" and entry.charge == 0
and entry.num_bonds == 10
and cls.EC_mg.isomorphic_to(entry.mol_graph)):
cls.EC_0_entry = entry
elif (entry.formula == "C3 H4 O3" and entry.charge == -1
and entry.num_bonds == 10
and cls.EC_mg.isomorphic_to(entry.mol_graph)):
cls.EC_minus_entry = entry
elif (entry.formula == "C3 H4 O3" and entry.charge == 1
and entry.num_bonds == 10
and cls.EC_mg.isomorphic_to(entry.mol_graph)):
cls.EC_1_entry = entry
if (cls.EC_0_entry is not None
and cls.EC_minus_entry is not None
and cls.EC_1_entry is not None):
break
H_mol1.set_charge_and_spin(charge=1)
H_mol_1.set_charge_and_spin(charge=-1)
O_mol = Molecule.from_file(os.path.join(test_dir, "O.xyz"))
O_mol1 = copy.deepcopy(O_mol)
O_mol_1 = copy.deepcopy(O_mol)
O_mol1.set_charge_and_spin(charge=1)
O_mol_1.set_charge_and_spin(charge=-1)
# Make molecule entries
# H2O 1-3
H2O = MoleculeEntry(
H2O_mol,
energy=-76.4447861695239,
correction=0,
enthalpy=15.702,
entropy=46.474,
parameters=None,
entry_id="h2o",
attribute=None,
)
H2O_1 = MoleculeEntry(
H2O_mol_1,
energy=-76.4634569330715,
correction=0,
enthalpy=13.298,
entropy=46.601,
parameters=None,
entry_id="h2o-",
attribute=None,
)
H2O_1p = MoleculeEntry(
class ReactionRateCalculatorTest(unittest.TestCase):
def setUp(self) -> None:
if ob:
self.energies = [
-271.553636516598, -78.5918513462683, -350.105998350078
]
self.enthalpies = [13.917, 34.596, 49.515]
self.entropies = [67.357, 55.047, 84.265]
self.rct_1 = MoleculeEntry(
mol_placeholder,
self.energies[0],
enthalpy=self.enthalpies[0],
entropy=self.entropies[0],
)
self.rct_2 = MoleculeEntry(
mol_placeholder,
self.energies[1],
enthalpy=self.enthalpies[1],
entropy=self.entropies[1],
)
self.pro = MoleculeEntry(
mol_placeholder,
self.energies[2],
enthalpy=self.enthalpies[2],
entropy=self.entropies[2],
)
self.ts = MoleculeEntry(mol_placeholder,
-350.099875862606,
enthalpy=48.560,
entropy=83.607)
self.reactants = [self.rct_1, self.rct_2]
self.products = [self.pro]
self.calc = ReactionRateCalculator(self.reactants, self.products,
self.ts)
def tearDown(self) -> None:
if ob:
del self.calc
del self.ts
del self.pro
del self.rct_2
del self.rct_1
del self.entropies
del self.enthalpies
del self.energies
@unittest.skipIf(not ob, "OpenBabel not present. Skipping...")
def test_net_properties(self):
self.assertAlmostEqual(
self.calc.net_energy,
(self.energies[2] - (self.energies[0] + self.energies[1])) *
27.2116,
6,
)
self.assertEqual(
self.calc.net_enthalpy,
(self.enthalpies[2] - (self.enthalpies[0] + self.enthalpies[1])) *
0.0433641,
)
self.assertEqual(
self.calc.net_entropy,
(self.entropies[2] - (self.entropies[0] + self.entropies[1])) *
0.0000433641,
)
gibbs_300 = self.pro.get_free_energy(300) - (
self.rct_1.get_free_energy(300) + self.rct_2.get_free_energy(300))
self.assertAlmostEqual(self.calc.calculate_net_gibbs(300), gibbs_300,
10)
gibbs_100 = self.pro.get_free_energy(100) - (
self.rct_1.get_free_energy(100) + self.rct_2.get_free_energy(100))
self.assertAlmostEqual(self.calc.calculate_net_gibbs(100.00),
gibbs_100, 10)
self.assertDictEqual(
self.calc.calculate_net_thermo(),
{
"energy": self.calc.net_energy,
"enthalpy": self.calc.net_enthalpy,
"entropy": self.calc.net_entropy,
"gibbs": self.calc.calculate_net_gibbs(),
},
)
@unittest.skipIf(not ob, "OpenBabel not present. Skipping...")
def test_act_properties(self):
trans_energy = self.ts.energy
trans_enthalpy = self.ts.enthalpy
trans_entropy = self.ts.entropy
pro_energies = [p.energy for p in self.products]
rct_energies = [r.energy for r in self.reactants]
pro_enthalpies = [p.enthalpy for p in self.products]
rct_enthalpies = [r.enthalpy for r in self.reactants]
pro_entropies = [p.entropy for p in self.products]
rct_entropies = [r.entropy for r in self.reactants]
self.assertAlmostEqual(
self.calc.calculate_act_energy(),
(trans_energy - sum(rct_energies)) * 27.2116,
6,
)
self.assertAlmostEqual(
self.calc.calculate_act_energy(reverse=True),
(trans_energy - sum(pro_energies)) * 27.2116,
6,
)
self.assertEqual(
self.calc.calculate_act_enthalpy(),
(trans_enthalpy - sum(rct_enthalpies)) * 0.0433641,
)
self.assertEqual(
self.calc.calculate_act_enthalpy(reverse=True),
(trans_enthalpy - sum(pro_enthalpies)) * 0.0433641,
)
self.assertEqual(
self.calc.calculate_act_entropy(),
(trans_entropy - sum(rct_entropies)) * 0.0000433641,
)
self.assertEqual(
self.calc.calculate_act_entropy(reverse=True),
(trans_entropy - sum(pro_entropies)) * 0.0000433641,
)
gibbs_300 = self.calc.calculate_act_energy() + (
self.calc.calculate_act_enthalpy() -
300 * self.calc.calculate_act_entropy())
gibbs_300_rev = self.calc.calculate_act_energy(reverse=True) + (
self.calc.calculate_act_enthalpy(reverse=True) -
300 * self.calc.calculate_act_entropy(reverse=True))
gibbs_100 = (self.calc.calculate_act_energy() +
self.calc.calculate_act_enthalpy() -
100 * self.calc.calculate_act_entropy())
self.assertEqual(self.calc.calculate_act_gibbs(300), gibbs_300)
self.assertEqual(self.calc.calculate_act_gibbs(300, reverse=True),
gibbs_300_rev)
self.assertEqual(self.calc.calculate_act_gibbs(100), gibbs_100)
self.assertEqual(
self.calc.calculate_act_thermo(temperature=300.00),
{
"energy": self.calc.calculate_act_energy(),
"enthalpy": self.calc.calculate_act_enthalpy(),
"entropy": self.calc.calculate_act_entropy(),
"gibbs": self.calc.calculate_act_gibbs(300),
},
)
self.assertEqual(
self.calc.calculate_act_thermo(temperature=300.00, reverse=True),
{
"energy": self.calc.calculate_act_energy(reverse=True),
"enthalpy": self.calc.calculate_act_enthalpy(reverse=True),
"entropy": self.calc.calculate_act_entropy(reverse=True),
"gibbs": self.calc.calculate_act_gibbs(300, reverse=True),
},
)
@unittest.skipIf(not ob, "OpenBabel not present. Skipping...")
def test_rate_constant(self):
gibbs_300 = self.calc.calculate_act_gibbs(300)
gibbs_300_rev = self.calc.calculate_act_gibbs(300, reverse=True)
gibbs_600 = self.calc.calculate_act_gibbs(600)
# Test normal forwards and reverse behavior
self.assertEqual(
self.calc.calculate_rate_constant(temperature=300.0),
KB * 300 / PLANCK * np.exp(-gibbs_300 / (KB * 300)),
)
self.assertEqual(
self.calc.calculate_rate_constant(temperature=600),
KB * 600 / PLANCK * np.exp(-gibbs_600 / (KB * 600)),
)
self.assertEqual(
self.calc.calculate_rate_constant(temperature=300.0, reverse=True),
KB * 300 / PLANCK * np.exp(-gibbs_300_rev / (KB * 300)),
)
# Test effect of kappa
self.assertEqual(
self.calc.calculate_rate_constant(),
self.calc.calculate_rate_constant(kappa=0.5) * 2,
)
@unittest.skipIf(not ob, "OpenBabel not present. Skipping...")
def test_rates(self):
rate_constant = self.calc.calculate_rate_constant()
rate_constant_600 = self.calc.calculate_rate_constant(temperature=600)
rate_constant_rev = self.calc.calculate_rate_constant(reverse=True)
base_rate = rate_constant
self.assertAlmostEqual(self.calc.calculate_rate([1, 1]), base_rate)
self.assertAlmostEqual(self.calc.calculate_rate([1, 0.5]),
base_rate / 2, 8)
self.assertAlmostEqual(self.calc.calculate_rate([0.5, 1]),
base_rate / 2, 8)
self.assertAlmostEqual(self.calc.calculate_rate([0.5, 0.5]),
base_rate / 4, 8)
self.assertAlmostEqual(self.calc.calculate_rate([1], reverse=True),
rate_constant_rev, 8)
self.assertAlmostEqual(
self.calc.calculate_rate([1, 1], temperature=600),
rate_constant_600, 8)
def setUpClass(cls):
EC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "EC.xyz")),
OpenBabelNN())
EC_mg = metal_edge_extender(EC_mg)
LiEC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LiEC.xyz")),
OpenBabelNN())
LiEC_mg = metal_edge_extender(LiEC_mg)
LEDC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LEDC.xyz")),
OpenBabelNN())
LEDC_mg = metal_edge_extender(LEDC_mg)
LEMC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LEMC.xyz")),
OpenBabelNN())
LEMC_mg = metal_edge_extender(LEMC_mg)
cls.LiEC_reextended_entries = []
entries = loadfn(os.path.join(test_dir,
"LiEC_reextended_entries.json"))
for entry in entries:
if "optimized_molecule" in entry["output"]:
mol = entry["output"]["optimized_molecule"]
else:
mol = entry["output"]["initial_molecule"]
E = float(entry["output"]["final_energy"])
H = float(entry["output"]["enthalpy"])
S = float(entry["output"]["entropy"])
mol_entry = MoleculeEntry(
molecule=mol,
energy=E,
enthalpy=H,
entropy=S,
entry_id=entry["task_id"],
)
if mol_entry.formula == "Li1":
if mol_entry.charge == 1:
cls.LiEC_reextended_entries.append(mol_entry)
else:
cls.LiEC_reextended_entries.append(mol_entry)
cls.entries_box = EntriesBox(cls.LiEC_reextended_entries,
remove_complexes=False)
cls.RI = ReactionIterator(cls.entries_box)
cls.RN = ReactionNetwork(cls.RI, add_concerteds=False)
# set up input variables
cls.LEDC_ind = None
cls.LiEC_ind = None
cls.EC_ind = None
for entry in cls.entries_box.entries_dict["C3 H4 O3"][10][0]:
if EC_mg.isomorphic_to(entry.mol_graph):
cls.EC_ind = entry.parameters["ind"]
break
for entry in cls.entries_box.entries_dict["C4 H4 Li2 O6"][17][0]:
if LEDC_mg.isomorphic_to(entry.mol_graph):
cls.LEDC_ind = entry.parameters["ind"]
break
for entry in cls.entries_box.entries_dict["C3 H4 Li1 O3"][12][1]:
if LiEC_mg.isomorphic_to(entry.mol_graph):
cls.LiEC_ind = entry.parameters["ind"]
break
cls.Li1_ind = cls.entries_box.entries_dict["Li1"][0][1][0].parameters[
"ind"]
print("LEDC_ind:", cls.LEDC_ind)
print("LiEC_ind:", cls.LiEC_ind)
print("EC_ind:", cls.EC_ind)
print("Li1_ind:", cls.Li1_ind)
cls.RN_solved = copy.deepcopy(cls.RN)
cls.RN_solved.solve_prerequisites([cls.EC_ind, cls.Li1_ind],
weight="softplus")
def get_entries():
if ob:
LiEC_reextended_entries = []
entries = loadfn(os.path.join(test_dir,
"LiEC_reextended_entries.json"))
for entry in entries:
if "optimized_molecule" in entry["output"]:
mol = entry["output"]["optimized_molecule"]
else:
mol = entry["output"]["initial_molecule"]
E = float(entry["output"]["final_energy"])
H = float(entry["output"]["enthalpy"])
S = float(entry["output"]["entropy"])
mol_entry = MoleculeEntry(
molecule=mol,
energy=E,
enthalpy=H,
entropy=S,
entry_id=entry["task_id"],
)
if mol_entry.formula == "Li1":
if mol_entry.charge == 1:
LiEC_reextended_entries.append(mol_entry)
else:
LiEC_reextended_entries.append(mol_entry)
RN = ReactionNetwork.from_input_entries(LiEC_reextended_entries)
EC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "EC.xyz")),
OpenBabelNN())
EC_mg = metal_edge_extender(EC_mg)
LiEC_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LiEC.xyz")),
OpenBabelNN())
LiEC_mg = metal_edge_extender(LiEC_mg)
LiEC_RO_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "LiEC_RO.xyz")),
OpenBabelNN())
LiEC_RO_mg = metal_edge_extender(LiEC_RO_mg)
C2H4_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "C2H4.xyz")),
OpenBabelNN())
C2H4_mg = metal_edge_extender(C2H4_mg)
C1Li1O3_mg = MoleculeGraph.with_local_env_strategy(
Molecule.from_file(os.path.join(test_dir, "C1Li1O3.xyz")),
OpenBabelNN())
C1Li1O3_mg = metal_edge_extender(C1Li1O3_mg)
LiEC_entry = None
LiEC_plus_entry = None
EC_minus_entry = None
EC_0_entry = None
EC_1_entry = None
LiEC_RO_entry = None
C2H4_entry = None
C1Li1O3_entry = None
Li_entry = None
for entry in RN.entries_list:
if (entry.formula == "C3 H4 O3" and entry.num_bonds == 10
and EC_mg.isomorphic_to(entry.mol_graph)):
if entry.charge == -1:
if EC_minus_entry is not None:
if EC_minus_entry.get_free_energy(
) >= entry.get_free_energy():
EC_minus_entry = entry
else:
EC_minus_entry = entry
elif entry.charge == 0:
if EC_0_entry is not None:
if EC_0_entry.get_free_energy(
) >= entry.get_free_energy():
EC_0_entry = entry
else:
EC_0_entry = entry
elif entry.charge == 1:
if EC_1_entry is not None:
if EC_1_entry.get_free_energy(
) >= entry.get_free_energy():
EC_1_entry = entry
else:
EC_1_entry = entry
elif (entry.formula == "C3 H4 Li1 O3" and entry.num_bonds == 12
and LiEC_mg.isomorphic_to(entry.mol_graph)):
if entry.charge == 0:
if LiEC_entry is not None:
if LiEC_entry.get_free_energy(
) >= entry.get_free_energy():
LiEC_entry = entry
else:
LiEC_entry = entry
elif entry.charge == 1:
if LiEC_plus_entry is not None:
if LiEC_plus_entry.get_free_energy(
) >= entry.get_free_energy():
LiEC_plus_entry = entry
else:
LiEC_plus_entry = entry
elif (entry.formula == "C3 H4 Li1 O3" and entry.charge == 0
and entry.num_bonds == 11
and LiEC_RO_mg.isomorphic_to(entry.mol_graph)):
if LiEC_RO_entry is not None:
if LiEC_RO_entry.get_free_energy(
) >= entry.get_free_energy():
LiEC_RO_entry = entry
else:
LiEC_RO_entry = entry
elif (entry.formula == "C2 H4" and entry.charge == 0
and entry.num_bonds == 5
and C2H4_mg.isomorphic_to(entry.mol_graph)):
if C2H4_entry is not None:
if C2H4_entry.get_free_energy() >= entry.get_free_energy():
C2H4_entry = entry
else:
C2H4_entry = entry
elif (entry.formula == "C1 Li1 O3" and entry.charge == 0
and entry.num_bonds == 5
and C1Li1O3_mg.isomorphic_to(entry.mol_graph)):
if C1Li1O3_entry is not None:
if C1Li1O3_entry.get_free_energy(
) >= entry.get_free_energy():
C1Li1O3_entry = entry
else:
C1Li1O3_entry = entry
elif entry.formula == "Li1" and entry.charge == 1 and entry.num_bonds == 0:
if Li_entry is not None:
if Li_entry.get_free_energy() >= entry.get_free_energy():
Li_entry = entry
else:
Li_entry = entry
return {
"entries": LiEC_reextended_entries,
"RN": RN,
"LiEC": LiEC_entry,
"LiEC_plus": LiEC_plus_entry,
"EC_1": EC_1_entry,
"EC_0": EC_0_entry,
"EC_-1": EC_minus_entry,
"LiEC_RO": LiEC_RO_entry,
"C2H4": C2H4_entry,
"C1Li1O3": C1Li1O3_entry,
"Li": Li_entry,
}
else:
return None
Molecule.from_file(os.path.join(test_dir, "LEMC.xyz")), OpenBabelNN())
LEMC_mg = metal_edge_extender(LEMC_mg)
LiEC_reextended_entries = []
entries = loadfn(os.path.join(test_dir, "LiEC_reextended_entries.json"))
for entry in entries:
if "optimized_molecule" in entry["output"]:
mol = entry["output"]["optimized_molecule"]
else:
mol = entry["output"]["initial_molecule"]
E = float(entry["output"]["final_energy"])
H = float(entry["output"]["enthalpy"])
S = float(entry["output"]["entropy"])
mol_entry = MoleculeEntry(
molecule=mol,
energy=E,
enthalpy=H,
entropy=S,
entry_id=entry["task_id"],
)
if mol_entry.formula == "Li1":
if mol_entry.charge == 1:
LiEC_reextended_entries.append(mol_entry)
else:
LiEC_reextended_entries.append(mol_entry)
reaction_network = ReactionNetwork.from_input_entries(
LiEC_reextended_entries, electron_free_energy=-2.15)
reaction_network.build()
for entry in reaction_network.entries["C3 H4 Li1 O3"][12][1]:
if LiEC_mg.isomorphic_to(entry.mol_graph):
LiEC_ind = entry.parameters["ind"]
break
