def _get_molecule(program, method):
if program in ["openmm", "terachem_pbs"]:
return qcng.get_molecule("water")
elif program == "gamess" and method == "ccsd(t)":
return qcng.get_molecule("water")
else:
return qcng.get_molecule("hydrogen")
def test_openmm_task_url_basis():
from qcengine.programs.openmm import OpenMMHarness
input_data = {
"molecule": qcng.get_molecule("water"),
"driver": "energy",
"model": {
"method":
"openmm",
"basis":
"openff-1.0.0",
"url":
"https://raw.githubusercontent.com/openforcefield/openff-forcefields/1.0.0/openforcefields/offxml/openff-1.0.0.offxml",
},
"keywords": {},
}
ret = qcng.compute(input_data, "openmm", raise_error=True)
cachelength = len(OpenMMHarness._CACHE)
assert cachelength > 0
assert ret.success is True
ret = qcng.compute(input_data, "openmm", raise_error=True)
# ensure cache has not grown
assert len(OpenMMHarness._CACHE) == cachelength
assert ret.success is True
def test_openmm_cmiles_gradient_nomatch():
program = "openmm"
water = qcng.get_molecule("water")
water_dict = water.dict()
# add ethane cmiles to the molecule
water_dict["extras"] = {
"cmiles": {
"canonical_isomeric_explicit_hydrogen_mapped_smiles":
"[H:3][C:1]([H:4])([H:5])[C:2]([H:6])([H:7])[H:8]"
}
}
molecule = Molecule.from_data(water_dict)
model = {"method": "openff-1.0.0", "basis": "smirnoff"}
inp = AtomicInput(molecule=molecule, driver="gradient", model=model)
ret = qcng.compute(inp, program, raise_error=False)
# if we correctly find the cmiles this should fail as the molecule and cmiles are different
assert ret.success is False
assert (
"molecule.add_conformer given input of the wrong shape: Given (3, 3), expected (8, 3)"
in ret.error.error_message)
def test_geometric_generic(input_data, program, model, bench):
input_data["initial_molecule"] = qcng.get_molecule("water")
input_data["input_specification"]["model"] = model
input_data["keywords"]["program"] = program
input_data["input_specification"]["extras"] = {
"_secret_tags": {
"mysecret_tag": "data1"
}
}
ret = qcng.compute_procedure(input_data, "geometric", raise_error=True)
assert ret.success is True
assert "Converged!" in ret.stdout
r01, r02, r12, a102 = ret.final_molecule.measure([[0, 1], [0, 2], [1, 2],
[1, 0, 2]])
assert pytest.approx(r01, 1.0e-4) == bench[0]
assert pytest.approx(r02, 1.0e-4) == bench[0]
assert pytest.approx(r12, 1.0e-4) == bench[1]
assert pytest.approx(a102, 1.0e-4) == bench[2]
assert "_secret_tags" in ret.trajectory[0].extras
assert "data1" == ret.trajectory[0].extras["_secret_tags"]["mysecret_tag"]
def test_openmm_task_smirnoff():
from qcengine.programs.openmm import OpenMMHarness
input_data = {
"molecule": qcng.get_molecule("water"),
"driver": "energy",
"model": {
"method": "openff-1.0.0",
"basis": "smirnoff"
},
"keywords": {},
}
ret = qcng.compute(input_data, "openmm", raise_error=True)
cachelength = len(OpenMMHarness._CACHE)
assert cachelength > 0
assert ret.success is True
ret = qcng.compute(input_data, "openmm", raise_error=True)
# ensure cache has not grown
assert len(OpenMMHarness._CACHE) == cachelength
assert ret.success is True
def test_nwchem_restart(tmpdir):
# Make the input file
input_data = {
"input_specification": {
"model": {
"method": "HF",
"basis": "sto-3g"
},
"keywords": {
"driver__maxiter": 2,
"set__driver:linopt": 0
},
"extras": {
"allow_restarts": True
},
},
"initial_molecule": qcng.get_molecule("hydrogen"),
}
input_data = OptimizationInput(**input_data)
# Run an initial step, which should not converge
local_opts = {"scratch_messy": True, "scratch_directory": str(tmpdir)}
ret = qcng.compute_procedure(input_data,
"nwchemdriver",
local_options=local_opts,
raise_error=False)
assert not ret.success
# Run it again, which should converge
new_ret = qcng.compute_procedure(input_data,
"nwchemdriver",
local_options=local_opts,
raise_error=True)
assert new_ret.success
def test_xtb_task_gfn1xtb_m01():
thr = 1.0e-7
return_result = np.array(
[
[-0.000358030800412827, +0.000500962437171796, -0.009256666294614777],
[+0.001228927299439432, +0.000322925070197139, +0.002327951513695912],
[-0.000336383869223903, +0.023413253286994400, -0.003233956461896982],
[+0.004257485938529293, -0.003712584842768384, +0.000112655448628981],
[+0.001349484431325273, +0.001591703446467543, -0.001444564232184169],
[+0.001902096016850091, -0.010806282150986885, -0.002612898358134064],
[-0.000694337971868170, -0.003558134599236037, +0.002566433298563669],
[-0.003819207888143676, -0.000529277869208852, +0.004041924390207515],
[-0.000170900544431631, +0.009573597947311165, +0.008463731042553293],
[+0.004036505931939967, +0.003025020761338415, -0.004557936832112239],
[+0.004790375712217767, -0.006895073623195738, +0.006111995172986280],
[-0.001527116100844721, -0.005269034163367844, -0.008340510436175520],
[-0.005441057023457164, +0.003102606807119279, +0.000817922187552893],
[-0.003996677758010005, -0.021839390583571504, +0.010361632086933262],
[-0.003219908482914395, +0.017669626267348096, -0.011084538678920158],
[+0.001998745109004805, -0.006589918191612544, +0.005726826152916107],
]
)
atomic_input = qcel.models.AtomicInput(
molecule=qcng.get_molecule("mindless-01"), model={"method": "GFN1-xTB"}, driver="gradient",
)
atomic_result = qcng.compute(atomic_input, "xtb")
assert atomic_result.success
assert pytest.approx(atomic_result.return_result, thr) == return_result
def test_xtb_task_gfn2xtb_m01():
thr = 1.0e-7
return_result = np.array(
[
[+1.7603980711827444e-03, -1.0892843650556535e-03, -1.4000925937447548e-02],
[+7.2828551455461962e-03, -3.7216708563619287e-04, -1.7598863191610557e-03],
[-4.3636138516365761e-04, +3.0781059500885385e-02, -2.4027777032994326e-03],
[-4.9615553784293671e-03, +2.4184700438294312e-03, -1.8273143544031206e-03],
[-3.1941473089998765e-03, -2.0177319546503510e-03, +6.0230398095918502e-03],
[+3.5807344500847016e-03, -2.3730921963802166e-03, -2.0271824139507818e-03],
[+1.0323930350176554e-03, +3.3301666520180575e-04, +2.6197885276710883e-03],
[+6.4140580960895879e-03, -1.0424376542844720e-02, +1.7654830175669090e-02],
[+2.1841001857333085e-03, +8.5100245114072097e-03, -6.7175792414255900e-03],
[+8.1719403581595913e-03, +7.3797085798300455e-03, -7.5901731542113542e-03],
[+1.1557950311395539e-03, -4.1907703068314668e-04, +1.7047910821890132e-03],
[-4.5861988817335895e-03, -2.1269884595520816e-02, -1.4002736618139961e-02],
[+1.1542155825459586e-04, +8.6721397831818186e-03, +3.9953426868203148e-03],
[-1.8552117264088834e-03, -2.0185103100139296e-02, +1.3339454522070686e-02],
[-2.9643338287258375e-03, -4.2193920947953519e-03, +6.6460843884674770e-06],
[-1.3699887421746685e-02, +4.2756898813700889e-03, +4.9846828536382450e-03],
]
)
atomic_input = qcel.models.AtomicInput(
molecule=qcng.get_molecule("mindless-01"), model={"method": "GFN2-xTB"}, driver="gradient",
)
atomic_result = qcng.compute(atomic_input, "xtb")
assert atomic_result.success
assert pytest.approx(atomic_result.return_result, thr) == return_result
def test_mopac_task():
input_data = {
"molecule": qcng.get_molecule("water"),
"driver": "gradient",
"model": {
"method": "PM6",
"basis": None
},
"keywords": {
"pulay": False
},
}
ret = qcng.compute(input_data, "mopac", raise_error=True)
assert ret.extras.keys() >= {
"heat_of_formation", "energy_electronic", "dip_vec"
}
energy = pytest.approx(-0.08474117913025125, rel=1.0e-5)
# Check gradient
ret = qcng.compute(input_data, "mopac", raise_error=True)
assert ret.extras.keys() >= {
"heat_of_formation", "energy_electronic", "dip_vec"
}
assert np.linalg.norm(ret.return_result) == pytest.approx(
0.03543560156912385, rel=1.0e-4)
assert ret.properties.return_energy == energy
# Check energy
input_data["driver"] = "energy"
ret = qcng.compute(input_data, "mopac", raise_error=True)
assert ret.return_result == energy
assert "== MOPAC DONE ==" in ret.stdout
def test_run_procedure(tmp_path):
"""Tests qcengine run-procedure with geometric, psi4, and JSON input"""
def check_result(stdout):
output = json.loads(stdout)
assert output["provenance"]["creator"].lower() == "geometric"
assert output["success"] is True
inp = {"schema_name": "qcschema_optimization_input",
"schema_version": 1,
"keywords": {
"coordsys": "tric",
"maxiter": 100,
"program": "psi4"
},
"input_specification": {
"schema_name": "qcschema_input",
"schema_version": 1,
"driver": "gradient",
"model": {"method": "HF", "basis": "sto-3g"},
"keywords": {},
},
"initial_molecule": get_molecule("hydrogen")}
inp = OptimizationInput(**inp)
args = ["run-procedure", "geometric", inp.json()]
check_result(run_qcengine_cli(args))
args = ["run-procedure", "geometric", os.path.join(tmp_path, "input.json")]
with util.disk_files({"input.json": inp.json()}, {}, cwd=tmp_path):
check_result(run_qcengine_cli(args))
args = ["run-procedure", "geometric", inp.json()]
check_result(run_qcengine_cli(args, stdin=inp.json()))
def test_geometric_psi4(input_data):
input_data["initial_molecule"] = qcng.get_molecule("hydrogen")
input_data["input_specification"]["model"] = {
"method": "HF",
"basis": "sto-3g"
}
input_data["input_specification"]["keywords"] = {
"scf_properties": ["wiberg_lowdin_indices"]
}
input_data["keywords"]["program"] = "psi4"
input_data = OptimizationInput(**input_data)
ret = qcng.compute_procedure(input_data, "geometric", raise_error=True)
assert 10 > len(ret.trajectory) > 1
assert pytest.approx(ret.final_molecule.measure([0, 1]),
1.0e-4) == 1.3459150737
assert ret.provenance.creator.lower() == "geometric"
assert ret.trajectory[0].provenance.creator.lower() == "psi4"
# Check keywords passing
for single in ret.trajectory:
assert "scf_properties" in single.keywords
assert "WIBERG_LOWDIN_INDICES" in single.extras["qcvars"]
def test_openmm_gaff_keywords(gaff_settings):
"""
Test the different running settings with gaff.
"""
program = "openmm"
water = qcng.get_molecule("water")
water_dict = water.dict()
# add water cmiles to the molecule
water_dict["extras"] = {
"cmiles": {
"canonical_isomeric_explicit_hydrogen_mapped_smiles":
"[H:2][O:1][H:3]"
}
}
molecule = Molecule.from_data(water_dict)
keywords, error, expected_result = gaff_settings
model = {"method": "gaff-2.1", "basis": "antechamber"}
inp = AtomicInput(molecule=molecule,
driver="energy",
model=model,
keywords=keywords)
if error is not None:
with pytest.raises(error):
_ = qcng.compute(inp, program, raise_error=True)
else:
ret = qcng.compute(inp, program, raise_error=False)
assert ret.success is True
assert ret.return_result == pytest.approx(expected_result, rel=1e-6)
def test_compute_bad_models(program, model):
if not testing.has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="energy", model=model)
with pytest.raises(ValueError) as exc:
ret = qcng.compute(inp, program, raise_error=True)
def test_compute_gradient(program, model):
if not testing.has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="gradient", model=model)
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, list)
def test_rdkit_task():
json_data = copy.deepcopy(_base_json)
json_data["molecule"] = qcng.get_molecule("water")
json_data["driver"] = "gradient"
json_data["model"] = {"method": "UFF"}
json_data["keywords"] = {}
ret = qcng.compute(json_data, "rdkit", raise_error=True)
assert ret.success is True
def test_compute_bad_models(program, model):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
adriver = model.pop("driver", "energy")
amodel = model
inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"), driver=adriver, model=amodel)
with pytest.raises(qcng.exceptions.InputError) as exc:
ret = qcng.compute(inp, program, raise_error=True)
def test_geometric_torchani():
inp = copy.deepcopy(_base_json)
inp["initial_molecule"] = qcng.get_molecule("water")
inp["input_specification"]["model"] = {"method": "ANI1x", "basis": None}
inp["keywords"]["program"] = "torchani"
ret = qcng.compute_procedure(inp, "geometric", raise_error=True)
assert ret.success is True
assert "Converged!" in ret.stdout
def test_xtb_task_unknown_method():
atomic_input = qcel.models.AtomicInput(
molecule=qcng.get_molecule("water"), model={"method": "GFN-xTB"}, driver="energy",
)
error = qcel.models.ComputeError(error_type="input_error", error_message="Invalid method GFN-xTB provided in model")
atomic_result = qcng.compute(atomic_input, "xtb")
assert not atomic_result.success
assert atomic_result.error == error
def test_compute_energy(program, model):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"),
driver="energy",
model=model)
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, float)
def test_torchani_task():
json_data = copy.deepcopy(_base_json)
json_data["molecule"] = qcng.get_molecule("water")
json_data["driver"] = "gradient"
json_data["model"] = {"method": "ANI1x", "basis": None}
json_data["keywords"] = {}
ret = qcng.compute(json_data, "torchani", raise_error=True)
assert ret.success is True
assert ret.driver == "gradient"
def test_geometric_stdout(input_data):
input_data["initial_molecule"] = qcng.get_molecule("water")
input_data["input_specification"]["model"] = {"method": "UFF", "basis": ""}
input_data["keywords"]["program"] = "rdkit"
input_data = OptimizationInput(**input_data)
ret = qcng.compute_procedure(input_data, "geometric", raise_error=True)
assert ret.success is True
assert "Converged!" in ret.stdout
def test_geometric_torchani():
inp = copy.deepcopy(_base_json)
inp["initial_molecule"] = dc.get_molecule("water")
inp["input_specification"]["model"] = {"method": "ANI1", "basis": None}
inp["keywords"]["program"] = "torchani"
ret = dc.compute_procedure(inp, "geometric")
assert ret["success"] is True
assert "Converged!" in ret["stdout"]
assert ret["stderr"] == "No stderr recieved."
def test_geometric_rdkit_error(input_data):
input_data["initial_molecule"] = qcng.get_molecule("water").copy(exclude={"connectivity_"})
input_data["input_specification"]["model"] = {"method": "UFF", "basis": ""}
input_data["keywords"]["program"] = "rdkit"
input_data = OptimizationInput(**input_data)
ret = qcng.compute_procedure(input_data, "geometric")
assert ret.success is False
assert isinstance(ret.error.error_message, str)
def test_rdkit_task():
json_data = copy.deepcopy(_base_json)
json_data["molecule"] = dc.get_molecule("water")
json_data["driver"] = "gradient"
json_data["model"] = {"method": "UFF", "basis": ""}
json_data["keywords"] = {}
json_data["return_output"] = False
ret = dc.compute(json_data, "rdkit", raise_error=True)
assert ret["success"] is True
def test_geometric_psi4():
inp = copy.deepcopy(_base_json)
inp["initial_molecule"] = dc.get_molecule("hydrogen")
inp["input_specification"]["model"] = {"method": "HF", "basis": "sto-3g"}
inp["keywords"]["program"] = "psi4"
ret = dc.compute_procedure(inp, "geometric")
assert 10 > len(ret["trajectory"]) > 1
geom = ret["final_molecule"]["geometry"]
assert pytest.approx(_bond_dist(geom, 0, 1), 1.e-4) == 1.3459150737
def test_dftd3_task(method):
json_data = {"molecule": qcng.get_molecule("eneyne"), "driver": "energy", "model": {"method": method}}
ret = qcng.compute(json_data, "dftd3", raise_error=True, return_dict=True)
assert ret["driver"] == "energy"
assert "provenance" in ret
assert "normal termination of dftd3" in ret["stdout"]
for key in ["cpu", "hostname", "username", "wall_time"]:
assert key in ret["provenance"]
assert ret["success"] is True
def test_torchani_task():
json_data = copy.deepcopy(_base_json)
json_data["molecule"] = dc.get_molecule("water")
json_data["driver"] = "gradient"
json_data["model"] = {"method": "ANI1", "basis": None}
json_data["keywords"] = {}
json_data["return_output"] = False
ret = dc.compute(json_data, "torchani", raise_error=True)
assert ret["success"] is True
assert ret["driver"] == "gradient"
assert "provenance" in ret
def test_rdkit_task(method):
input_data = {
"molecule": qcng.get_molecule("water"),
"driver": "gradient",
"model": {
"method": method
},
"keywords": {},
}
ret = qcng.compute(input_data, "rdkit", raise_error=True)
assert ret.success is True
def test_dftd3_task(method):
json_data = {"molecule": qcng.get_molecule("eneyne"), "driver": "energy", "model": {"method": method}}
ret = qcng.compute(json_data, "dftd3", raise_error=True, return_dict=True)
assert ret["driver"] == "energy"
assert "provenance" in ret
assert "normal termination of dftd3" in ret["stdout"]
for key in ["cpu", "hostname", "username", "wall_time"]:
assert key in ret["provenance"]
assert ret["success"] is True
def test_xtb_task_unsupported_driver():
atomic_input = qcel.models.AtomicInput(
molecule=qcng.get_molecule("water"), model={"method": "GFN2-xTB"}, driver="hessian",
)
error = qcel.models.ComputeError(
error_type="input_error", error_message="Calculation succeeded but invalid driver request provided"
)
atomic_result = qcng.compute(atomic_input, "xtb")
assert not atomic_result.success
assert atomic_result.error == error
def test_rdkit_connectivity_error():
json_data = copy.deepcopy(_base_json)
json_data["molecule"] = qcng.get_molecule("water").dict()
json_data["driver"] = "gradient"
json_data["model"] = {"method": "UFF", "basis": ""}
json_data["keywords"] = {}
del json_data["molecule"]["connectivity"]
ret = qcng.compute(json_data, "rdkit")
assert ret.success is False
assert "connectivity" in ret.error.error_message
with pytest.raises(qcng.exceptions.InputError):
qcng.compute(json_data, "rdkit", raise_error=True)
