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_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)