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