def test_double_FF_opt(self):
# location of test files
test_double_FF_files = os.path.join(module_dir, "..", "..",
"test_files", "double_FF_wf")
# define starting molecule and workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_double_FF_files, "block", "launcher_first",
"mol.qin.opt_0"))
initial_mol = initial_qcin.molecule
real_wf = get_wf_double_FF_opt(
molecule=initial_mol,
pcm_dielectric=10.0,
max_cores=32,
qchem_input_params={
"basis_set": "6-311++g**",
"overwrite_inputs": {
"rem": {
"sym_ignore": "true"
}
}
})
# use powerup to replace run with fake run
ref_dirs = {
"first_FF_no_pcm":
os.path.join(test_double_FF_files, "block", "launcher_first"),
"second_FF_with_pcm":
os.path.join(test_double_FF_files, "block", "launcher_second")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(
self.lp,
fworker=FWorker(env={"db_file": os.path.join(db_dir, "db.json")}))
wf_test = self.lp.get_wf_by_fw_id(1)
self.assertTrue(
all([s == "COMPLETED" for s in wf_test.fw_states.values()]))
first_FF = self.get_task_collection().find_one({
"task_label":
"first_FF_no_pcm"
})
self.assertEqual(first_FF["calcs_reversed"][0]["input"]["solvent"],
None)
self.assertEqual(first_FF["num_frequencies_flattened"], 1)
first_FF_final_mol = Molecule.from_dict(
first_FF["output"]["optimized_molecule"])
second_FF = self.get_task_collection().find_one({
"task_label":
"second_FF_with_pcm"
})
self.assertEqual(second_FF["calcs_reversed"][0]["input"]["solvent"],
{"dielectric": "10.0"})
self.assertEqual(second_FF["num_frequencies_flattened"], 1)
second_FF_initial_mol = Molecule.from_dict(
second_FF["input"]["initial_molecule"])
self.assertEqual(first_FF_final_mol, second_FF_initial_mol)
def test_use_fake_qchem(self):
input_file = "test.qin.opt_1"
output_file = "test.qout.opt_1"
calc_dir = os.path.join(module_dir, "..", "test_files", "FF_working")
run_task = RunQChemDirect(
qchem_cmd="should not need this going to be replaced with fake run"
)
p_task = QChemToDb(calc_dir=calc_dir,
input_file=input_file,
output_file=output_file)
fw1 = Firework([run_task, p_task], name="test_fake_run")
w_task = WriteInputFromIOSet(qchem_input_set="OptSet",
write_to_dir=module_dir)
fw2 = Firework([w_task], parents=fw1, name="test_write")
wf = Workflow([fw1, fw2])
ref_dirs = {"test_fake_run": os.path.join(calc_dir, output_file)}
fake_run_wf = use_fake_qchem(wf, ref_dirs)
test_fake_run = False
for fw in fake_run_wf.fws:
if fw.name == "test_fake_run":
for t in fw.tasks:
if "RunQChemFake" in str(t):
test_fake_run = True
self.assertTrue(test_fake_run)
def test_use_fake_qchem(self):
input_file = "test.qin.opt_1"
output_file = "test.qout.opt_1"
calc_dir = os.path.join(module_dir, "..", "test_files", "FF_working")
run_task = RunQChemDirect(
qchem_cmd="should not need this going to be replaced with fake run"
)
p_task = QChemToDb(
calc_dir=calc_dir, input_file=input_file, output_file=output_file)
fw1 = Firework([run_task, p_task], name="test_fake_run")
w_task = WriteInputFromIOSet(
qchem_input_set="OptSet", write_to_dir=module_dir)
fw2 = Firework([w_task], parents=fw1, name="test_write")
wf = Workflow([fw1, fw2])
ref_dirs = {"test_fake_run": os.path.join(calc_dir, output_file)}
fake_run_wf = use_fake_qchem(wf, ref_dirs)
test_fake_run = False
for fw in fake_run_wf.fws:
if fw.name == "test_fake_run":
for t in fw.tasks:
if "RunQChemFake" in str(t):
test_fake_run = True
self.assertTrue(test_fake_run)
def test_double_FF_opt(self):
# location of test files
test_double_FF_files = os.path.join(module_dir, "..", "..",
"test_files", "double_FF_wf")
# define starting molecule and workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_double_FF_files, "block", "launcher_first",
"mol.qin.opt_0"))
initial_mol = initial_qcin.molecule
real_wf = get_wf_double_FF_opt(
molecule=initial_mol,
pcm_dielectric=10.0,
qchem_input_params={
"basis_set": "6-311++g**",
"scf_algorithm": "diis",
"overwrite_inputs": {
"rem": {
"sym_ignore": "true"
}
}
})
# use powerup to replace run with fake run
ref_dirs = {
"first_FF_no_pcm":
os.path.join(test_double_FF_files, "block", "launcher_first"),
"second_FF_with_pcm":
os.path.join(test_double_FF_files, "block", "launcher_second")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(
self.lp,
fworker=FWorker(env={"max_cores": 32, "db_file": os.path.join(db_dir, "db.json")}))
wf_test = self.lp.get_wf_by_fw_id(1)
self.assertTrue(
all([s == "COMPLETED" for s in wf_test.fw_states.values()]))
first_FF = self.get_task_collection().find_one({
"task_label":
"first_FF_no_pcm"
})
self.assertEqual(first_FF["calcs_reversed"][0]["input"]["solvent"],
None)
self.assertEqual(first_FF["num_frequencies_flattened"], 1)
first_FF_final_mol = Molecule.from_dict(
first_FF["output"]["optimized_molecule"])
second_FF = self.get_task_collection().find_one({
"task_label":
"second_FF_with_pcm"
})
self.assertEqual(second_FF["calcs_reversed"][0]["input"]["solvent"],
{"dielectric": "10.0"})
self.assertEqual(second_FF["num_frequencies_flattened"], 1)
second_FF_initial_mol = Molecule.from_dict(
second_FF["input"]["initial_molecule"])
self.assertEqual(first_FF_final_mol, second_FF_initial_mol)
def test_Fragmentation(self):
with patch("atomate.qchem.firetasks.fragmenter.FWAction") as FWAction_patch:
mock_FWAction = MagicMock()
FWAction_patch.return_value = mock_FWAction
mock_FWAction.as_dict.return_value = {'stored_data': {}, 'exit': False, 'update_spec': {}, 'mod_spec': [], 'additions': [], 'detours': [], 'defuse_children': False, 'defuse_workflow': False}
# location of test files
test_FF_then_fragment_files = os.path.join(module_dir, "..", "..",
"test_files", "FF_then_fragment_wf")
# define starting molecule and workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_FF_then_fragment_files, "block", "launcher_first",
"mol.qin.opt_0"))
initial_mol = initial_qcin.molecule
real_wf = get_fragmentation_wf(molecule=initial_mol, depth=0, do_triplets=False)
# use powerup to replace run with fake run
ref_dirs = {
"first FF":
os.path.join(test_FF_then_fragment_files, "block", "launcher_first"),
"fragment and FF_opt":
os.path.join(test_FF_then_fragment_files, "block", "launcher_second")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(
self.lp,
fworker=FWorker(env={"max_cores": 32, "db_file": os.path.join(db_dir, "db.json")}), pdb_on_exception=True)
first_FF = self.get_task_collection().find_one({
"task_label":
"first FF"
})
self.assertEqual(first_FF["calcs_reversed"][0]["input"]["solvent"],
None)
self.assertEqual(first_FF["num_frequencies_flattened"], 0)
self.assertEqual(len(FWAction_patch.call_args[1]["additions"]), 5 * 3)
def test_torsion_potential(self):
# location of test files
test_tor_files = os.path.join(module_dir, "..", "..", "test_files",
"torsion_wf")
# define starting molecule and torsion potential workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_tor_files, "initial_opt", "mol.qin"))
initial_mol = initial_qcin.molecule
atom_indexes = [6, 8, 9, 10]
angles = [0.0, 90.0, 180.0]
rem = []
# add the first rem section
rem.append({
"jobtype": "opt",
"method": "wb97m-v",
"basis": "def2-tzvppd",
"gen_scfman": "true",
"geom_opt_max_cycles": 75,
"max_scf_cycles": 300,
"scf_algorithm": "diis",
"scf_guess": "sad",
"sym_ignore": "true",
"symmetry": "false",
"thresh": 14
})
# the second rem section
rem.append({
"jobtype": "opt",
"method": "wb97m-v",
"basis": "def2-tzvppd",
"geom_opt_max_cycles": 75,
"max_scf_cycles": 300,
"scf_algorithm": "diis",
"scf_guess": "sad",
"sym_ignore": "true",
"symmetry": "false",
"thresh": 14
})
real_wf = get_wf_torsion_potential(molecule=initial_mol,
atom_indexes=atom_indexes,
angles=angles,
rem=rem,
db_file=">>db_file<<")
# use powerup to replace run with fake run
# def ref_dirs
ref_dirs = {
"initial_opt": os.path.join(test_tor_files, "initial_opt"),
"opt_0": os.path.join(test_tor_files, "opt_0"),
"opt_90": os.path.join(test_tor_files, "opt_90"),
"opt_180": os.path.join(test_tor_files, "opt_180")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(
self.lp,
fworker=FWorker(env={"db_file": os.path.join(db_dir, "db.json")}))
wf_test = self.lp.get_wf_by_fw_id(1)
self.assertTrue(
all([s == "COMPLETED" for s in wf_test.fw_states.values()]))
# Checking of the inputs happens in fake_run_qchem so there is no point to retest the inputs
# Check the output info that gets inserted in the DB
init_opt = self.get_task_collection().find_one(
{"task_label": "initial_opt"})
init_opt_final_mol = Molecule.from_dict(
init_opt["output"]["optimized_molecule"])
init_opt_final_e = init_opt["output"]["final_energy"]
# parse output file
act_init_opt_out = QCOutput(
os.path.join(test_tor_files, "initial_opt", "mol.qout"))
act_init_opt_mol = act_init_opt_out.data[
"molecule_from_optimized_geometry"]
act_init_opt_final_e = act_init_opt_out.data["final_energy"]
np.testing.assert_equal(act_init_opt_mol.species,
init_opt_final_mol.species)
np.testing.assert_allclose(act_init_opt_mol.cart_coords,
init_opt_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_init_opt_final_e, init_opt_final_e)
# Optimization of 0 torsion
opt_0 = self.get_task_collection().find_one({"task_label": "opt_0"})
opt_0_final_mol = Molecule.from_dict(
opt_0["output"]["optimized_molecule"])
opt_0_final_e = opt_0["output"]["final_energy"]
# parse output file
act_opt_0_out = QCOutput(
os.path.join(test_tor_files, "opt_0", "mol.qout"))
act_opt_0_mol = act_opt_0_out.data["molecule_from_optimized_geometry"]
act_opt_0_final_e = act_opt_0_out.data["final_energy"]
np.testing.assert_equal(act_opt_0_mol.species, opt_0_final_mol.species)
np.testing.assert_allclose(act_opt_0_mol.cart_coords,
opt_0_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_0_final_e, opt_0_final_e)
# Optimization of 90 torsion
opt_90 = self.get_task_collection().find_one({"task_label": "opt_90"})
opt_90_final_mol = Molecule.from_dict(
opt_90["output"]["optimized_molecule"])
opt_90_final_e = opt_90["output"]["final_energy"]
# parse output file
act_opt_90_out = QCOutput(
os.path.join(test_tor_files, "opt_90", "mol.qout"))
act_opt_90_mol = act_opt_90_out.data[
"molecule_from_optimized_geometry"]
act_opt_90_final_e = act_opt_90_out.data["final_energy"]
np.testing.assert_equal(act_opt_90_mol.species,
opt_90_final_mol.species)
np.testing.assert_allclose(act_opt_90_mol.cart_coords,
opt_90_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_90_final_e, opt_90_final_e)
# Optimization of 180 torsion
opt_180 = self.get_task_collection().find_one(
{"task_label": "opt_180"})
opt_180_final_mol = Molecule.from_dict(
opt_180["output"]["optimized_molecule"])
opt_180_final_e = opt_180["output"]["final_energy"]
# parse output file
act_opt_180_out = QCOutput(
os.path.join(test_tor_files, "opt_180", "mol.qout"))
act_opt_180_mol = act_opt_180_out.data[
"molecule_from_optimized_geometry"]
act_opt_180_final_e = act_opt_180_out.data["final_energy"]
np.testing.assert_equal(act_opt_180_mol.species,
opt_180_final_mol.species)
np.testing.assert_allclose(act_opt_180_mol.cart_coords,
opt_180_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_180_final_e, opt_180_final_e)
def test_FFopt_and_critic(self):
# location of test files
test_files = os.path.join(module_dir, "..", "..", "test_files",
"critic_test_files")
# define starting molecule and workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_files, "FFopt", "mol.qin.orig"))
initial_mol = initial_qcin.molecule
real_wf = get_wf_FFopt_and_critic(
molecule=initial_mol,
suffix="testing",
qchem_input_params={
"dft_rung": 4,
"smd_solvent": "custom",
"custom_smd": "18.5,1.415,0.00,0.735,20.2,0.00,0.00",
"overwrite_inputs": {
"rem": {
"thresh": "14",
"scf_guess_always": "True"
}
}
})
# use powerup to replace run with fake run
ref_dirs = {
"{}:{}".format(initial_mol.composition.alphabetical_formula, "FFopt_testing"):
os.path.join(test_files, "FFopt"),
"{}:{}".format(initial_mol.composition.alphabetical_formula, "CC2_testing"):
os.path.join(test_files, "critic_example")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(self.lp,
fworker=FWorker(env={
"max_cores": 32,
"db_file": os.path.join(db_dir, "db.json")
}))
wf_test = self.lp.get_wf_by_fw_id(1)
self.assertTrue(
all([s == "COMPLETED" for s in wf_test.fw_states.values()]))
FFopt = self.get_task_collection().find_one({
"task_label":
"{}:{}".format(initial_mol.composition.alphabetical_formula,
"FFopt_testing")
})
self.assertEqual(FFopt["calcs_reversed"][0]["input"]["smx"]["solvent"],
"other")
self.assertEqual(FFopt["num_frequencies_flattened"], 0)
FFopt_final_mol = Molecule.from_dict(
FFopt["output"]["optimized_molecule"])
CC2 = self.get_task_collection().find_one({
"task_label":
"{}:{}".format(initial_mol.composition.alphabetical_formula,
"CC2_testing")
})
CC2_initial_mol = Molecule.from_dict(CC2["input"]["initial_molecule"])
self.assertEqual(FFopt_final_mol, CC2_initial_mol)
self.assertEqual(CC2["output"]["job_type"], "sp")
self.assertEqual(CC2["output"]["final_energy"], -343.4820411597)
critic2_drone_ref = loadfn(
os.path.join(test_files, "critic_example",
"critic2_drone_ref.json"))
self.assertEqual(CC2["critic2"], critic2_drone_ref)
def test_torsion_potential(self):
# location of test files
test_tor_files = os.path.join(module_dir, "..", "..", "test_files",
"torsion_wf")
# define starting molecule and torsion potential workflow object
initial_qcin = QCInput.from_file(
os.path.join(test_tor_files, "initial_opt", "mol.qin"))
initial_mol = initial_qcin.molecule
atom_indexes = [6, 8, 9, 10]
angles = [0.0, 90.0, 180.0]
rem = []
# add the first rem section
rem.append({
"jobtype": "opt",
"method": "wb97m-v",
"basis": "def2-tzvppd",
"gen_scfman": "true",
"geom_opt_max_cycles": 75,
"max_scf_cycles": 300,
"scf_algorithm": "diis",
"scf_guess": "sad",
"sym_ignore": "true",
"symmetry": "false",
"thresh": 14
})
# the second rem section
rem.append({
"jobtype": "opt",
"method": "wb97m-v",
"basis": "def2-tzvppd",
"geom_opt_max_cycles": 75,
"max_scf_cycles": 300,
"scf_algorithm": "diis",
"scf_guess": "sad",
"sym_ignore": "true",
"symmetry": "false",
"thresh": 14
})
real_wf = get_wf_torsion_potential(
molecule=initial_mol,
atom_indexes=atom_indexes,
angles=angles,
rem=rem,
db_file=">>db_file<<")
# use powerup to replace run with fake run
# def ref_dirs
ref_dirs = {
"initial_opt": os.path.join(test_tor_files, "initial_opt"),
"opt_0": os.path.join(test_tor_files, "opt_0"),
"opt_90": os.path.join(test_tor_files, "opt_90"),
"opt_180": os.path.join(test_tor_files, "opt_180")
}
fake_wf = use_fake_qchem(real_wf, ref_dirs)
self.lp.add_wf(fake_wf)
rapidfire(
self.lp,
fworker=FWorker(env={"db_file": os.path.join(db_dir, "db.json")}))
wf_test = self.lp.get_wf_by_fw_id(1)
self.assertTrue(
all([s == "COMPLETED" for s in wf_test.fw_states.values()]))
# Checking of the inputs happens in fake_run_qchem so there is no point to retest the inputs
# Check the output info that gets inserted in the DB
init_opt = self.get_task_collection().find_one({
"task_label":
"initial_opt"
})
init_opt_final_mol = Molecule.from_dict(
init_opt["output"]["optimized_molecule"])
init_opt_final_e = init_opt["output"]["final_energy"]
# parse output file
act_init_opt_out = QCOutput(
os.path.join(test_tor_files, "initial_opt", "mol.qout"))
act_init_opt_mol = act_init_opt_out.data[
"molecule_from_optimized_geometry"]
act_init_opt_final_e = act_init_opt_out.data["final_energy"]
np.testing.assert_equal(act_init_opt_mol.species,
init_opt_final_mol.species)
np.testing.assert_allclose(
act_init_opt_mol.cart_coords,
init_opt_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_init_opt_final_e, init_opt_final_e)
# Optimization of 0 torsion
opt_0 = self.get_task_collection().find_one({"task_label": "opt_0"})
opt_0_final_mol = Molecule.from_dict(
opt_0["output"]["optimized_molecule"])
opt_0_final_e = opt_0["output"]["final_energy"]
# parse output file
act_opt_0_out = QCOutput(
os.path.join(test_tor_files, "opt_0", "mol.qout"))
act_opt_0_mol = act_opt_0_out.data["molecule_from_optimized_geometry"]
act_opt_0_final_e = act_opt_0_out.data["final_energy"]
np.testing.assert_equal(act_opt_0_mol.species, opt_0_final_mol.species)
np.testing.assert_allclose(
act_opt_0_mol.cart_coords,
opt_0_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_0_final_e, opt_0_final_e)
# Optimization of 90 torsion
opt_90 = self.get_task_collection().find_one({"task_label": "opt_90"})
opt_90_final_mol = Molecule.from_dict(
opt_90["output"]["optimized_molecule"])
opt_90_final_e = opt_90["output"]["final_energy"]
# parse output file
act_opt_90_out = QCOutput(
os.path.join(test_tor_files, "opt_90", "mol.qout"))
act_opt_90_mol = act_opt_90_out.data[
"molecule_from_optimized_geometry"]
act_opt_90_final_e = act_opt_90_out.data["final_energy"]
np.testing.assert_equal(act_opt_90_mol.species,
opt_90_final_mol.species)
np.testing.assert_allclose(
act_opt_90_mol.cart_coords,
opt_90_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_90_final_e, opt_90_final_e)
# Optimization of 180 torsion
opt_180 = self.get_task_collection().find_one({
"task_label": "opt_180"
})
opt_180_final_mol = Molecule.from_dict(
opt_180["output"]["optimized_molecule"])
opt_180_final_e = opt_180["output"]["final_energy"]
# parse output file
act_opt_180_out = QCOutput(
os.path.join(test_tor_files, "opt_180", "mol.qout"))
act_opt_180_mol = act_opt_180_out.data[
"molecule_from_optimized_geometry"]
act_opt_180_final_e = act_opt_180_out.data["final_energy"]
np.testing.assert_equal(act_opt_180_mol.species,
opt_180_final_mol.species)
np.testing.assert_allclose(
act_opt_180_mol.cart_coords,
opt_180_final_mol.cart_coords,
atol=0.0001)
np.testing.assert_equal(act_opt_180_final_e, opt_180_final_e)
