def test_PC_depth_0_vs_depth_10(self):
fragmenter0 = Fragmenter(molecule=self.pc,
edges=self.pc_edges,
depth=0,
open_rings=False)
self.assertEqual(len(fragmenter0.unique_fragments), 295)
fragmenter10 = Fragmenter(molecule=self.pc,
edges=self.pc_edges,
depth=10,
open_rings=False)
self.assertEqual(len(fragmenter10.unique_fragments), 63)
fragments_by_level = fragmenter10.fragments_by_level
num_frags_by_level = [8, 12, 15, 14, 9, 4, 1]
for ii in range(7):
self.assertEqual(len(fragments_by_level[str(ii)]),
num_frags_by_level[ii])
for fragment10 in fragmenter10.unique_fragments:
found = False
for fragment0 in fragmenter0.unique_fragments:
if fragment0.isomorphic_to(fragment10):
found = True
break
self.assertEqual(found, True)
def test_babel_PC_with_RO_depth_0_vs_depth_10(self):
fragmenter0 = Fragmenter(molecule=self.pc,
depth=0,
open_rings=True,
opt_steps=1000)
self.assertEqual(len(fragmenter0.unique_fragments), 509)
fragmenter10 = Fragmenter(molecule=self.pc,
depth=10,
open_rings=True,
opt_steps=1000)
self.assertEqual(len(fragmenter10.unique_fragments), 509)
fragments_by_level = fragmenter10.fragments_by_level
num_frags_by_level = [13, 51, 95, 115, 105, 75, 39, 14, 2, 0]
for ii in range(10):
self.assertEqual(len(fragments_by_level[str(ii)]),
num_frags_by_level[ii])
for fragment10 in fragmenter10.unique_fragments:
found = False
for fragment0 in fragmenter0.unique_fragments:
if fragment0.isomorphic_to(fragment10):
found = True
break
self.assertEqual(found, True)
def test_PC_then_EC_depth_10(self):
fragPC = Fragmenter(molecule=self.pc, depth=10, open_rings=True)
fragEC = Fragmenter(molecule=self.ec,
depth=10,
open_rings=True,
prev_unique_frag_dict=fragPC.unique_frag_dict)
self.assertEqual(fragEC.new_unique_fragments, 11)
self.assertEqual(fragEC.total_unique_fragments, 509 + 11)
def test_PC_frag1_then_PC(self):
frag1 = Fragmenter(molecule=self.pc_frag1, edges=self.pc_frag1_edges, depth=0)
self.assertEqual(frag1.new_unique_fragments, frag1.total_unique_fragments)
frag2 = Fragmenter(
molecule=self.pc,
edges=self.pc_edges,
depth=0,
open_rings=False,
prev_unique_frag_dict=frag1.unique_frag_dict,
)
self.assertEqual(frag2.new_unique_fragments, 295 - 12)
def test_PC_then_EC_depth_10(self):
pytest.importorskip("openbabel", reason="OpenBabel not installed")
fragPC = Fragmenter(molecule=self.pc, depth=10, open_rings=True)
fragEC = Fragmenter(
molecule=self.ec,
depth=10,
open_rings=True,
prev_unique_frag_dict=fragPC.unique_frag_dict,
)
self.assertEqual(fragEC.new_unique_fragments, 11)
self.assertEqual(fragEC.total_unique_fragments, 509 + 11)
def test_PC_depth_0_vs_depth_10(self):
fragmenter0 = Fragmenter(molecule=self.pc, edges=self.pc_edges, depth=0, open_rings=False)
self.assertEqual(fragmenter0.total_unique_fragments, 295)
fragmenter10 = Fragmenter(molecule=self.pc, edges=self.pc_edges, depth=10, open_rings=False)
self.assertEqual(fragmenter10.total_unique_fragments, 63)
fragments_by_level = fragmenter10.fragments_by_level
num_frags_by_level = [8, 12, 15, 14, 9, 4, 1]
for ii in range(7):
num_frags = 0
for key in fragments_by_level[str(ii)]:
num_frags += len(fragments_by_level[str(ii)][key])
self.assertEqual(num_frags, num_frags_by_level[ii])
def test_babel_PC_with_RO_depth_0_vs_depth_10(self):
pytest.importorskip("openbabel", reason="OpenBabel not installed")
fragmenter0 = Fragmenter(molecule=self.pc, depth=0, open_rings=True, opt_steps=1000)
self.assertEqual(fragmenter0.total_unique_fragments, 509)
fragmenter10 = Fragmenter(molecule=self.pc, depth=10, open_rings=True, opt_steps=1000)
self.assertEqual(fragmenter10.total_unique_fragments, 509)
fragments_by_level = fragmenter10.fragments_by_level
num_frags_by_level = [13, 51, 95, 115, 105, 75, 39, 14, 2, 0]
for ii in range(10):
num_frags = 0
for key in fragments_by_level[str(ii)]:
num_frags += len(fragments_by_level[str(ii)][key])
self.assertEqual(num_frags, num_frags_by_level[ii])
def test_babel_PC_old_defaults(self):
fragmenter = Fragmenter(molecule=self.pc, open_rings=True)
self.assertEqual(fragmenter.open_rings, True)
self.assertEqual(fragmenter.opt_steps, 10000)
default_mol_graph = MoleculeGraph.with_local_env_strategy(
self.pc, OpenBabelNN())
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(fragmenter.total_unique_fragments, 13)
def test_babel_PC_defaults(self):
fragmenter = Fragmenter(molecule=self.pc)
self.assertEqual(fragmenter.open_rings, False)
self.assertEqual(fragmenter.opt_steps, 10000)
default_mol_graph = MoleculeGraph.with_local_env_strategy(
self.pc, OpenBabelNN(), reorder=False, extend_structure=False)
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(fragmenter.total_unique_fragments, 8)
def test_babel_PC_defaults(self):
pytest.importorskip("openbabel", reason="OpenBabel not installed")
fragmenter = Fragmenter(molecule=self.pc)
self.assertEqual(fragmenter.open_rings, False)
self.assertEqual(fragmenter.opt_steps, 10000)
default_mol_graph = MoleculeGraph.with_local_env_strategy(self.pc, OpenBabelNN())
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(fragmenter.total_unique_fragments, 8)
def test_babel_PC_defaults(self):
fragmenter = Fragmenter(molecule=self.pc)
self.assertEqual(fragmenter.open_rings, True)
self.assertEqual(fragmenter.opt_steps, 10000)
default_mol_graph = build_MoleculeGraph(self.pc,
strategy=OpenBabelNN,
reorder=False,
extend_structure=False)
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(len(fragmenter.unique_fragments), 13)
self.assertEqual(len(fragmenter.unique_fragments_from_ring_openings),
5)
def test_edges_given_PC_not_defaults(self):
fragmenter = Fragmenter(molecule=self.pc,
edges=self.pc_edges,
depth=2,
open_rings=False,
opt_steps=0)
self.assertEqual(fragmenter.open_rings, False)
self.assertEqual(fragmenter.opt_steps, 0)
edges = {(e[0], e[1]): None for e in self.pc_edges}
default_mol_graph = MoleculeGraph.with_edges(self.pc, edges=edges)
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(fragmenter.total_unique_fragments, 20)
def test_edges_given_PC_not_defaults(self):
fragmenter = Fragmenter(molecule=self.pc,
edges=self.pc_edges,
depth=2,
open_rings=False,
opt_steps=0)
self.assertEqual(fragmenter.open_rings, False)
self.assertEqual(fragmenter.opt_steps, 0)
edges = [(e[0], e[1], {}) for e in self.pc_edges]
default_mol_graph = build_MoleculeGraph(self.pc, edges=edges)
self.assertEqual(fragmenter.mol_graph, default_mol_graph)
self.assertEqual(len(fragmenter.unique_fragments), 20)
self.assertEqual(len(fragmenter.unique_fragments_from_ring_openings),
0)
def test_babel_TFSI(self):
fragmenter = Fragmenter(molecule=self.tfsi, depth=0)
self.assertEqual(len(fragmenter.unique_fragments), 156)
def test_edges_given_TFSI(self):
fragmenter = Fragmenter(molecule=self.tfsi,
edges=self.tfsi_edges,
depth=0)
self.assertEqual(len(fragmenter.unique_fragments), 156)
def test_babel_PC_frag1(self):
fragmenter = Fragmenter(molecule=self.pc_frag1, depth=0)
self.assertEqual(len(fragmenter.unique_fragments), 12)
def test_edges_given_PC_frag1(self):
fragmenter = Fragmenter(molecule=self.pc_frag1,
edges=self.pc_frag1_edges,
depth=0)
self.assertEqual(len(fragmenter.unique_fragments), 12)
def run_task(self, fw_spec):
# if a molecule is being passed through fw_spec
if fw_spec.get("prev_calc_molecule"):
molecule = fw_spec.get("prev_calc_molecule")
# if a molecule is included as an optional parameter
elif self.get("molecule"):
molecule = self.get("molecule")
# if no molecule is present raise an error
else:
raise KeyError(
"No molecule present, add as an optional param or check fw_spec"
)
self.depth = self.get("depth", 1)
additional_charges = self.get("additional_charges", [])
self.do_triplets = self.get("do_triplets", False)
self.linked = self.get("linked", True)
self.qchem_input_params = self.get("qchem_input_params", {})
# Specify charges to consider based on charge of the principle molecule:
if molecule.charge == 0:
self.charges = [-1, 0, 1]
elif molecule.charge > 0:
self.charges = [molecule.charge - 1, molecule.charge]
else:
self.charges = [molecule.charge, molecule.charge + 1]
self.principle_charge = molecule.charge
# Include any additional charges specified by the user:
for additional_charge in additional_charges:
if additional_charge not in self.charges:
print("Adding additional charge " + str(additional_charge))
self.charges.append(additional_charge)
else:
print("Charge " + str(additional_charge) + " already present!")
# Obtain fragments from Pymatgen's fragmenter:
fragmenter = Fragmenter(molecule=molecule,
edges=self.get("edges", None),
depth=self.depth,
open_rings=self.get("open_rings", True),
opt_steps=self.get("opt_steps", 10000))
self.unique_fragments = []
for key in fragmenter.unique_frag_dict:
for frag in fragmenter.unique_frag_dict[key]:
self.unique_fragments.append(frag)
# Convert fragment molecule graphs into molecule objects with charges given in self.charges
self._build_unique_relevant_molecules()
# Then find all unique formulae in our unique molecules to facilitate easier database searching
self.unique_formulae = []
for molecule in self.unique_molecules:
if molecule.composition.reduced_formula not in self.unique_formulae:
self.unique_formulae.append(
molecule.composition.reduced_formula)
# attempt to connect to the database to later check if a fragment has already been calculated
find_dict = {"formula_pretty": {"$in": self.unique_formulae}}
if "pcm_dielectric" in self.qchem_input_params:
find_dict["calcs_reversed.input.solvent.dielectric"] = str(
self.qchem_input_params["pcm_dielectric"])
db_file = env_chk(self.get("db_file"), fw_spec)
self.check_db = self.get("check_db", bool(db_file))
self.all_relevant_docs = []
if db_file and self.check_db:
mmdb = QChemCalcDb.from_db_file(db_file, admin=True)
self.all_relevant_docs = list(
mmdb.collection.find(find_dict, {
"formula_pretty": 1,
"input.initial_molecule": 1
}))
# Return an FWAction which includes a new additional firework for each unique, relevant molecule
# not already present in our database
return FWAction(additions=self._build_new_FWs())
def test_babel_PC_frag1(self):
pytest.importorskip("openbabel", reason="OpenBabel not installed")
fragmenter = Fragmenter(molecule=self.pc_frag1, depth=0)
self.assertEqual(fragmenter.total_unique_fragments, 12)