local_options={ "ncores": 13, "retries": 1 }) assert ret.success is False assert ret.input_data["trajectory"][0]["provenance"]["retries"] == 1 assert len(ret.input_data["trajectory"]) == 2 @using("geometric") @pytest.mark.parametrize( "program, model, bench", [ pytest.param("rdkit", {"method": "UFF"}, [1.87130923886072, 2.959448636243545, 104.5099642579023], marks=using("rdkit")), pytest.param( "rdkit", {"method": "mmff94"}, [1.8310842343589573, 2.884612338953529, 103.93822919865106], marks=using("rdkit"), ), pytest.param( "rdkit", {"method": "MMFF94s"}, [1.8310842343589573, 2.884612338953529, 103.93822919865106], marks=using("rdkit"), ), pytest.param( "torchani", {"method": "ANI1x"},
import pytest import qcengine from qcelemental import constants from qcengine.programs.tests.test_dftd3_mp2d import eneyne_ne_qcdbmols from qcengine.programs.tests.test_ghost import bimol_ref from qcengine.testing import using import qcdb from .utils import * @pytest.mark.parametrize( "qcp", [ pytest.param("p4-", marks=using("psi4")), pytest.param("c4-", marks=using("cfour")), pytest.param("nwc-", marks=using("nwchem")), pytest.param("gms-", marks=using("gamess")), ], ) def test_simple_ghost(qcp): dimer = qcdb.set_molecule( f""" He -- Ne 1 R """ ) dimer.R = 2.5
], ids=['qmol', 'pmol']) @pytest.mark.parametrize( "inp", [ ({'first': 'b3lyp', 'second': 'd', 'parent': 'eneyne', 'subject': 'dimer', 'lbl': 'B3LYP-D2'}), ({'first': 'b3lyp', 'second': 'd3bj', 'parent': 'eneyne', 'subject': 'mA', 'lbl': 'B3LYP-D3(BJ)'}), ({'first': 'pbe', 'second': 'd3zero', 'parent': 'eneyne', 'subject': 'mB', 'lbl': 'PBE-D3'}), ({'first': 'pbe', 'second': 'd3zero', 'parent': 'eneyne', 'subject': 'gAmB', 'lbl': 'PBE-D3'}), ({'first': 'pbe', 'second': 'd2', 'parent': 'eneyne', 'subject': 'mAgB', 'lbl': 'PBE-D2'}), ({'first': 'b3lyp', 'second': 'd3bj', 'parent': 'ne', 'subject': 'atom', 'lbl': 'B3LYP-D3(BJ)'}), #({'first': '', 'second': 'atmgr', 'parent': 'eneyne', 'subject': 'dimer', 'lbl': 'ATM'}), #({'first': 'b3lyp', 'second': 'atmgr', 'parent': 'eneyne', 'subject': 'mA', 'lbl': 'ATM'}), #({'first': 'pbe', 'second': 'atm(gr)', 'parent': 'eneyne', 'subject': 'mB', 'lbl': 'ATM'}), #({'first': '', 'second': 'ATMgr', 'parent': 'eneyne', 'subject': 'mAgB', 'lbl': 'ATM'}), # below two xfail until dftd3 that's only 2-body is out of psi4 proper pytest.param({'first': 'atmgr', 'second': 'atmgr', 'parent': 'eneyne', 'subject': 'gAmB', 'lbl': 'ATM'}, marks=[using("dftd3_321"), pytest.mark.xfail]), pytest.param({'first': 'pbe-atmgr', 'second': None, 'parent': 'ne', 'subject': 'atom', 'lbl': 'ATM'}, marks=[using("dftd3_321"), pytest.mark.xfail]), ]) # yapf: disable def test_molecule__run_dftd3__23body(inp, subjects): subject = subjects()[inp['parent']][inp['subject']] expected = ref[inp['parent']][inp['lbl']][inp['subject']] gexpected = gref[inp['parent']][inp['lbl']][inp['subject']] E, G = subject.run_dftd3(inp['first'], inp['second']) assert compare_values(expected, E, atol=1.e-7) assert compare_values(gexpected, G, atol=1.e-7) @using_qcdb def test_qcdb__energy_d3(): eneyne = qcdb.set_molecule(seneyne)
{ 'driver': 'energy', 'name': 'Mp2', 'pv': 'MP2', 'options': {} }, id='mp2-energy'), pytest.param( { 'driver': 'energy', 'name': 'MP2-d', 'pv': 'MP2D', 'options': {} }, id='mp2d-energy', marks=using('mp2d')), pytest.param( { 'driver': 'gradient', 'name': 'Mp2', 'pv': 'MP2', 'options': {} }, id='mp2-gradient'), pytest.param( { 'driver': 'gradient', 'name': 'Mp2', 'pv': 'MP2', 'dertype': 0, 'options': {}
assert "retries" not in ret.trajectory[2].provenance.dict() # Ensure we still fail failure_engine.iter_modes = ["random_error", "pass", "random_error", "random_error", "pass"] # Iter 1 # Iter 2 ret = qcng.compute_procedure(input_data, "geometric", local_options={"ncores": 13, "retries": 1}) assert ret.success is False assert ret.input_data["trajectory"][0]["provenance"]["retries"] == 1 assert len(ret.input_data["trajectory"]) == 2 @using("geometric") @pytest.mark.parametrize( "program, model, bench", [ pytest.param( "rdkit", {"method": "UFF"}, [1.87130923886072, 2.959448636243545, 104.5099642579023], marks=using("rdkit") ), pytest.param( "rdkit", {"method": "mmff94"}, [1.8310842343589573, 2.884612338953529, 103.93822919865106], marks=using("rdkit"), ), pytest.param( "rdkit", {"method": "MMFF94s"}, [1.8310842343589573, 2.884612338953529, 103.93822919865106], marks=using("rdkit"), ), pytest.param( "torchani",
import pytest import qcengine as qcng from qcengine.testing import using def test_list_programs(): r = qcng.list_all_programs() assert r >= {"psi4", "rdkit", "molpro", "dftd3"} @pytest.mark.parametrize( "program", [ pytest.param("psi4", marks=using("psi4")), pytest.param("torchani", marks=using("torchani")), pytest.param("rdkit", marks=using("rdkit")), ], ) def test_check_program_avail(program): assert program in qcng.list_available_programs() def test_program_avail_bounce(): with pytest.raises(qcng.exceptions.InputError) as exc: qcng.compute({}, "bad_program", raise_error=True) assert "not registered" in str(exc.value)
) @pytest.mark.parametrize( "inp", [ # yapf: disable pytest.param( { "call": "cfour", "reference": "rhf", "fcae": "ae", "keywords": { "scf_conv": 12 }, }, id="hf rhf ae: cfour", marks=using("cfour")), pytest.param( { "call": "gamess", "reference": "rhf", "fcae": "ae", "keywords": {}, }, id="hf rhf ae: gamess", marks=using("gamess")), pytest.param( { "call": "nwchem", "reference": "rhf", "fcae": "ae", "keywords": {
# R=1.008 #A=105.0 0 2 N 0.000000000000000 0.000000000000000 -0.145912918634892 H 0.000000000000000 -1.511214298139000 1.013682596946108 H 0.000000000000000 1.511214298139000 1.013682596946108 units au symmetry c1 """ return qcel.models.Molecule.from_data(smol) @pytest.mark.parametrize( "program,basis,keywords", [ pytest.param( "cfour", "aug-pvdz", {"scf_conv": 12}, marks=using("cfour")), pytest.param("cfour", "aug-pvdz", {}, marks=using("cfour")), pytest.param( "qcore", "aug-cc-pVDZ", { "coulomb_method": "direct_4idx", "exchange_method": "direct_4idx" }, marks=using("qcore"), ), pytest.param( "gamess", "accd", {"contrl__ispher": 1}, marks=using("gamess")), pytest.param("molpro", "aug-cc-pvdz", {}, marks=using("molpro")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True},
def nh2(): smol = """ # R=1.008 #A=105.0 0 2 N 0.000000000000000 0.000000000000000 -0.145912918634892 H 0.000000000000000 -1.511214298139000 1.013682596946108 H 0.000000000000000 1.511214298139000 1.013682596946108 units au """ return qcel.models.Molecule.from_data(smol) @pytest.mark.parametrize( "program,basis,keywords", [ pytest.param("cfour", "aug-pvdz", {"scf_conv": 12, "cc_conv": 12}, marks=using("cfour")), pytest.param("cfour", "aug-pvdz", {}, marks=using("cfour")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True}, marks=using("nwchem")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True, "qc_module": "tce"}, marks=using("nwchem")), pytest.param("psi4", "aug-cc-pvdz", {}, marks=using("psi4")), pytest.param("gamess", "accd", {"ccinp__ncore": 0, "contrl__ispher": 1}, marks=using("gamess")), ], ) def test_sp_ccsd_t_rhf_full(program, basis, keywords, h2o): """cfour/sp-rhf-ccsd/input.dat #! single point CCSD(T)/adz on water """ resi = {"molecule": h2o, "driver": "energy", "model": {"method": "ccsd(t)", "basis": basis}, "keywords": keywords} res = qcng.compute(resi, program, raise_error=True, return_dict=True)
'keywords': { 'level_hint': 'd3bj' }, } res = qcng.compute(resinp, 'dftd3', raise_error=True) res = res.dict() #res = dftd3.run_dftd3_from_arrays(molrec=sys, name_hint='b3lyp', level_hint='d3bj') assert compare('B3LYP-D3(BJ)', _compute_key(res['extras']['local_keywords']), 'key') @using("dftd3") @pytest.mark.parametrize( "subjects", [ pytest.param(eneyne_ne_psi4mols, marks=using("psi4")), pytest.param(eneyne_ne_qcdbmols, marks=using("psi4")), # needs qcdb.Molecule, presently more common in psi4 than in qcdb ], ids=['qmol', 'pmol']) @pytest.mark.parametrize( "inp", [ ({'first': 'b3lyp', 'second': 'd', 'parent': 'eneyne', 'subject': 'dimer', 'lbl': 'B3LYP-D2'}), ({'first': 'b3lyp', 'second': 'd3bj', 'parent': 'eneyne', 'subject': 'mA', 'lbl': 'B3LYP-D3(BJ)'}), ({'first': 'pbe', 'second': 'd3zero', 'parent': 'eneyne', 'subject': 'mB', 'lbl': 'PBE-D3'}), ({'first': 'pbe', 'second': 'd3zero', 'parent': 'eneyne', 'subject': 'gAmB', 'lbl': 'PBE-D3'}), ({'first': 'pbe', 'second': 'd2', 'parent': 'eneyne', 'subject': 'mAgB', 'lbl': 'PBE-D2'}), ({'first': 'b3lyp', 'second': 'd3bj', 'parent': 'ne', 'subject': 'atom', 'lbl': 'B3LYP-D3(BJ)'}), #({'first': '', 'second': 'atmgr', 'parent': 'eneyne', 'subject': 'dimer', 'lbl': 'ATM'}), #({'first': 'b3lyp', 'second': 'atmgr', 'parent': 'eneyne', 'subject': 'mA', 'lbl': 'ATM'}), #({'first': 'pbe', 'second': 'atm(gr)', 'parent': 'eneyne', 'subject': 'mB', 'lbl': 'ATM'}),
"driver": "energy", "model": { "method": "ccsd", "basis": "aug-cc-pvdz" }, "keywords": { "reference": "rohf", "freeze_core": False }, } @pytest.mark.parametrize( "qcprog", [ pytest.param("cfour", marks=using("cfour")), pytest.param("gamess", marks=using("gamess")), pytest.param("nwchem", marks=using("nwchem")), pytest.param("psi4", marks=using("psi4")), ], ) def test_fig2a_txt(qcprog): """ Execution (a; txt) cp infile . && xcfour > outfile rungms infile > outfile nwchem infile > outfile psi4 infile outfile """
smol = """ # R=1.008 #A=105.0 0 2 N 0.000000000000000 0.000000000000000 -0.145912918634892 H 0.000000000000000 -1.511214298139000 1.013682596946108 H 0.000000000000000 1.511214298139000 1.013682596946108 units au symmetry c1 """ return qcel.models.Molecule.from_data(smol) @pytest.mark.parametrize( "program,basis,keywords", [ pytest.param("cfour", "aug-pvdz", {"scf_conv": 12}, marks=using("cfour")), pytest.param("cfour", "aug-pvdz", {}, marks=using("cfour")), pytest.param( "entos", "aug-cc-pVDZ", {"coulomb_method": "direct_4idx", "exchange_method": "direct_4idx"}, marks=using("entos"), ), pytest.param("gamess", "accd", {"contrl__ispher": 1}, marks=using("gamess")), pytest.param("molpro", "aug-cc-pvdz", {}, marks=using("molpro")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True}, marks=using("nwchem")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True, "qc_module": "tce"}, marks=using("nwchem")), pytest.param("psi4", "aug-cc-pvdz", {"scf_type": "direct"}, marks=using("psi4")), pytest.param("qchem", "aug-cc-pvdz", {}, marks=using("qchem")), pytest.param("turbomole", "aug-cc-pVDZ", {}, marks=using("turbomole")), ],
@pytest.fixture def hene(): smol = """ 0 1 He 0 0 0 @Ne 2.5 0 0 """ return qcel.models.Molecule.from_data(smol) @pytest.mark.parametrize( "program,basis,keywords", [ pytest.param("cfour", "aug-pvdz", {}, marks=using("cfour")), pytest.param( "gamess", "ccd", {"contrl__ispher": 1}, marks=using("gamess")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True}, marks=using("nwchem")), pytest.param("nwchem", "aug-cc-pvdz", { "basis__spherical": True, "qc_module": "tce" }, marks=using("nwchem")), pytest.param("psi4", "aug-cc-pvdz", {"scf_type": "direct"}, marks=using("psi4")), ],
local_options={ "ncores": 13, "retries": 1 }) assert ret.success is False assert ret.input_data["trajectory"][0]["provenance"]["retries"] == 1 assert len(ret.input_data["trajectory"]) == 2 @using("geometric") @pytest.mark.parametrize( "program, model, bench", [ pytest.param("rdkit", {"method": "UFF"}, [1.87130923886072, 2.959448636243545, 104.5099642579023], marks=using("rdkit")), pytest.param( "torchani", {"method": "ANI1x"}, [1.82581873750194, 2.866376526793269, 103.4332610730292], marks=using("torchani"), ), pytest.param( "mopac", {"method": "PM6"}, [1.7927843431811934, 2.893333237502448, 107.60441967992045], marks=using("mopac"), ), ], ) def test_geometric_generic(input_data, program, model, bench):
import pytest from .utils import * import psi4 from qcengine.testing import using @pytest.mark.parametrize('engine', [ pytest.param('optking'), pytest.param('geometric', marks=using('geometric')), ]) # yapf: disable @pytest.mark.parametrize('inp', [ pytest.param({'name': 'hf', 'options': {'scf_type': 'df'}, 'ref_ene' : -76.027032783717, 'ref_nuc': 9.300794299874}, id='rhf(df)'), pytest.param({'name': 'hf', 'options': {'scf_type': 'pk'}, 'ref_ene' : -76.027053512764, 'ref_nuc': 9.300838770294}, id='rhf(pk)'), pytest.param({'name': 'mp2', 'options': {'mp2_type': 'df'}, 'ref_ene' : -76.230938589591, 'ref_nuc': 9.133271168193}, id='mp2(df)'), pytest.param({'name': 'mp2', 'options': {'mp2_type': 'conv'}, 'ref_ene' : -76.230989373502, 'ref_nuc': 9.133125471291}, id='mp2(conv)'), pytest.param({'name': 'b3lyp', 'options': {'scf_type': 'df'}, 'ref_ene' : -76.420645414834, 'ref_nuc': 9.090397129492}, id='b3lyp'), ]) # yapf: disable def test_h2o(inp, engine): """Optimization of the square water molecule""" h2o = psi4.geometry(""" O H 1 1.0 H 1 1.0 2 90.0 """) psi4.set_options({'basis': 'cc-pvdz', 'g_convergence': 'gau_tight'}) psi4.set_options(inp['options'])
True, reason= 'Not detecting common driver. Install package if necessary and add to envvar PYTHONPATH' ) using_gcp = pytest.mark.skipif( which("gcp", return_bool=True) is False, reason= "Not detecting executable gcp. Install package if necessary and add to envvar PATH" ) using_cppe = pytest.mark.skipif( which_import('cppe', return_bool=True) is False, reason="Not detecting module cppe. Rebuild with -DENABLE_cppe") using_networkx = pytest.mark.skipif( which_import('networkx', return_bool=True) is False, reason= 'Not detecting module networkx. Install package if necessary and add to envvar PYTHONPATH' ) using_mdi = pytest.mark.skipif( which_import('mdi', return_bool=True) is False, reason= "Not detecting module mdi. Install package if necessary and add to envvar PYTHONPATH (or rebuild Psi with -DENABLE_mdi)" ) using_dftd3 = using('dftd3') using_dftd3_321 = using('dftd3') using_mp2d = using('mp2d')
) @pytest.mark.parametrize( "inp", [ # yapf: disable pytest.param( { "call": "cfour", "reference": "rhf", "fcae": "ae", "keywords": { "scf_conv": 12 }, }, id="mp2 rhf ae: cfour", marks=using("cfour")), pytest.param( { "call": "gamess", "reference": "rhf", "fcae": "ae", "keywords": { "mp2__nacore": 0 }, }, id="mp2 rhf ae: gamess", marks=using("gamess")), pytest.param( { "call": "nwchem", "reference": "rhf",
], ) @pytest.mark.parametrize( "basis, subjects", [ pytest.param("cc-pvdz", ["hf", "bh3p", "bh3p"], id="dz"), pytest.param("aug-cc-pvdz", ["h2o", "nh2", "nh2"], id="adz", marks=pytest.mark.long), pytest.param("cfour-qz2p", ["h2o", "nh2", "nh2"], id="qz2p", marks=pytest.mark.long), ], ) @pytest.mark.parametrize( "inp", [ # yapf: disable ######## Are all possible ways of computing <method> working? pytest.param({"call": "cfour", "reference": "rhf", "fcae": "ae", "keywords": {"scf_conv": 12}, }, id="hf rhf ae: cfour", marks=using("cfour")), pytest.param({"call": "gamess", "reference": "rhf", "fcae": "ae", "keywords": {}, }, id="hf rhf ae: gamess", marks=using("gamess")), pytest.param({"call": "nwchem", "reference": "rhf", "fcae": "ae", "keywords": {}, }, id="hf rhf ae: nwchem", marks=using("nwchem")), pytest.param({"call": "psi4", "reference": "rhf", "fcae": "ae", "keywords": {"scf_type": "pk"}, }, id="hf rhf ae: psi4", marks=using("psi4_mp2qcsk")), pytest.param({"call": "cfour", "reference": "uhf", "fcae": "ae", "keywords": {"reference": "uhf", "scf_conv": 12}, }, id="hf uhf ae: cfour", marks=using("cfour")), pytest.param({"call": "gamess", "reference": "uhf", "fcae": "ae", "keywords": {"contrl__scftyp": "uhf"}, }, id="hf uhf ae: gamess", marks=using("gamess")), pytest.param({"call": "nwchem", "reference": "uhf", "fcae": "ae", "keywords": {"scf__uhf": True}, }, id="hf uhf ae: nwchem", marks=using("nwchem")), pytest.param({"call": "psi4", "reference": "uhf", "fcae": "ae", "keywords": {"reference": "uhf", "scf_type": "pk"}, }, id="hf uhf ae: psi4", marks=using("psi4_mp2qcsk")), pytest.param({"call": "cfour", "reference": "rohf", "fcae": "ae", "keywords": {"reference": "rohf", "scf_conv": 12}, }, id="hf rohf ae: cfour", marks=using("cfour")), pytest.param({"call": "gamess", "reference": "rohf", "fcae": "ae", "keywords": {"contrl__scftyp": "rohf"}, }, id="hf rohf ae: gamess", marks=using("gamess")), pytest.param({"call": "nwchem", "reference": "rohf", "fcae": "ae", "keywords": {"scf__rohf": True}, }, id="hf rohf ae: nwchem", marks=using("nwchem")), pytest.param({"call": "psi4", "reference": "rohf", "fcae": "ae", "keywords": {"reference": "rohf", "scf_type": "pk"}, }, id="hf rohf ae: psi4", marks=using("psi4_mp2qcsk")), # yapf: enable ],
smol = """ # R=1.008 #A=105.0 0 2 N 0.000000000000000 0.000000000000000 -0.145912918634892 H 0.000000000000000 -1.511214298139000 1.013682596946108 H 0.000000000000000 1.511214298139000 1.013682596946108 units au """ return qcel.models.Molecule.from_data(smol) @pytest.mark.parametrize( "program,basis,keywords", [ pytest.param( "cfour", "aug-pvdz", {"scf_conv": 12}, marks=using("cfour")), pytest.param("cfour", "aug-pvdz", {}, marks=using("cfour")), pytest.param("gamess", "accd", { "mp2__nacore": 0, "contrl__ispher": 1 }, marks=using("gamess")), pytest.param("nwchem", "aug-cc-pvdz", {"basis__spherical": True}, marks=using("nwchem")), pytest.param("nwchem", "aug-cc-pvdz", { "basis__spherical": True, "qc_module": "tce" },
"method": "hf", "basis": qcsk_bs }, {}), ("nwchem", { "method": "hf", "basis": qcsk_bs }, {}), ("openmm", { "method": "openff-1.0.0", "basis": qcsk_bs }, {}), pytest.param("psi4", { "method": "hf", "basis": qcsk_bs }, {}, marks=using("psi4_mp2qcsk")), ("qchem", { "method": "hf", "basis": qcsk_bs }, {}), ("qcore", { "method": "pbe", "basis": qcsk_bs }, {}), ("turbomole", { "method": "pbe", "basis": qcsk_bs }, {}), ]
("mrchem", {"method": "blyp"}, {"world_prec": 1.0e-3}), ("cfour", {"method": "hf", "basis": "6-31G"}, {}), ("gamess", {"method": "hf", "basis": "n31"}, {"basis__NGAUSS": 6}), ("mctc-gcp", {"method": "dft/sv"}, {}), # add as programs available # ("terachem", {"method": "bad"}), ] _canonical_methods_qcsk_basis = [ ("adcc", {"method": "adc2", "basis": qcsk_bs}, {"n_triplets": 3}), ("cfour", {"method": "hf", "basis": qcsk_bs}, {}), ("gamess", {"method": "hf", "basis": qcsk_bs}, {}), ("molpro", {"method": "hf", "basis": qcsk_bs}, {}), ("nwchem", {"method": "hf", "basis": qcsk_bs}, {}), ("openmm", {"method": "openff-1.0.0", "basis": qcsk_bs}, {}), pytest.param("psi4", {"method": "hf", "basis": qcsk_bs}, {}, marks=using("psi4_mp2qcsk")), ("qchem", {"method": "hf", "basis": qcsk_bs}, {}), ("qcore", {"method": "pbe", "basis": qcsk_bs}, {}), ("turbomole", {"method": "pbe", "basis": qcsk_bs}, {}), ] def _get_molecule(program): if program in ["openmm", "terachem_pbs"]: return qcng.get_molecule("water") else: return qcng.get_molecule("hydrogen") @pytest.mark.parametrize("program, model, keywords", _canonical_methods) def test_compute_energy(program, model, keywords):
"program": None }, "input_specification": { "driver": "gradient", "model": None, "keywords": {} }, "initial_molecule": None, } @using("psi4") @pytest.mark.parametrize( "optimizer", [ pytest.param("geometric", marks=using("geometric")), pytest.param("optking", marks=using("optking")) ], ) def test_geometric_psi4(input_data, optimizer): 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"
@pytest.fixture def h2o(): mol = qcelemental.models.Molecule.from_data(""" O 0.000000000000 0.000000000000 -0.068516245955 H 0.000000000000 -0.790689888800 0.543701278274 H 0.000000000000 0.790689888800 0.543701278274 """) return mol @pytest.mark.parametrize( "method, keywords, ref_energy", [ pytest.param("hf", {}, -75.95536954370, marks=using("turbomole")), pytest.param( "pbe0", {"grid": "m5"}, -76.27371135900, marks=using("turbomole")), pytest.param("ricc2", {}, -76.1603807755, marks=using("turbomole")), pytest.param("rimp2", {}, -76.1593614075, marks=using("turbomole")), ], ) def test_turbomole_energy(method, keywords, ref_energy, h2o): resi = { "molecule": h2o, "driver": "energy", "model": { "method": method, "basis": "def2-SVP" }, "keywords": keywords
"inp", [ ("subject1", {"dtype": "xyz", "units": "kg", "prec": 8, "atom_format": "{elea}{elem}{elbl}"}), ], ) # yapf: disable def test_to_string_error(inp): mol = qcdb.Molecule(_results[inp[0]]) with pytest.raises(pint.errors.DimensionalityError): mol.to_string(**inp[1]) @pytest.mark.parametrize( "subjects", [ pytest.param("pmol", marks=using("psi4")), pytest.param("qmol"), pytest.param("qcmol"), ], ) @pytest.mark.parametrize( "inp,expected", [ (("subject1", {"dtype": "xyz", "units": "Bohr"}), "ans1_xyz_au"), (("subject1", {"dtype": "xyz", "units": "Angstrom"}), "ans1_xyz_ang"), (("subject1", {"dtype": "xyz", "prec": 8, "atom_format": "{elea}{elem}{elbl}"}), "ans1c_xyz_ang"), (("subject1", {"dtype": "xyz", "units": "nm", "prec": 8, "atom_format": "{elea}{elem}{elbl}"}), "ans1c_xyz_nm"), (("subject1", {"dtype": "psi4", "units": "angstrom"}), "ans1_psi4_ang"), (("subject1", {"dtype": "qchem", "units": "angstrom"}), "ans1_qchem_ang"), (("subject1", {"dtype": "orca", "units": "angstrom"}), "ans1_orca_ang"), (("subject2", {"dtype": "xyz", "units": "Bohr"}), "ans2_au"),