def test_run(h2o): inp = qcel.models.AtomicInput(molecule=h2o, driver="properties", model={ "method": "adc2", "basis": "sto-3g" }, keywords={"n_singlets": 3}) ret = qcng.compute(inp, "adcc", raise_error=True, local_options={"ncores": 1}, return_dict=True) ref_excitations = np.array( [0.0693704245883876, 0.09773854881340478, 0.21481589246935925]) ref_hf_energy = -74.45975898670224 ref_mp2_energy = -74.67111187456267 assert ret["success"] is True qcvars = ret["extras"]["qcvars"] assert qcvars["EXCITATION KIND"] == "SINGLET" assert compare_values(ref_excitations[0], ret["return_result"]) assert compare_values(ref_hf_energy, ret["properties"]["scf_total_energy"]) assert compare_values(ref_mp2_energy, ret["properties"]["mp2_total_energy"]) assert compare_values(ref_excitations, qcvars["ADC2 EXCITATION ENERGIES"])
def test_homo_lumo(h20v2): # Run NH2 resi = { "molecule": h20v2, "driver": "energy", "model": {"method": "dft", "basis": "3-21g"}, "keywords": {"dft__xc": "b3lyp"}, } res = qcng.compute(resi, "nwchem", raise_error=True, return_dict=True) # Make sure the calculation completed successfully assert compare_values(-75.968095, res["return_result"], atol=1e-3) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # Check the other status information assert res["extras"]["qcvars"]["N ALPHA ELECTRONS"] == "5" assert res["extras"]["qcvars"]["N ATOMS"] == "3" assert res["extras"]["qcvars"]["N BASIS FUNCTIONS"] == "13" # Make sure the properties parsed correctly assert compare_values(-75.968095, res["properties"]["return_energy"], atol=1e-3) assert res["properties"]["calcinfo_natom"] == 3 assert res["properties"]["calcinfo_nalpha"] == 5 assert res["properties"]["calcinfo_nbasis"] == 13 # Make sure Dipole Moment and center of charge parsed correctly assert compare_values(-0.2636515, float(res["extras"]["qcvars"]["H**O"][0]), atol=1e-5) assert compare_values(0.08207131, float(res["extras"]["qcvars"]["LUMO"][0]), atol=1e-5)
def test_mp2d__run_mp2d__2body(inp, subjects, request): subject = subjects()[inp['parent']][inp['subject']] expected = ref[inp['parent']][inp['lbl']][inp['subject']] #gexpected = gref[inp['parent']][inp['lbl']][inp['subject']].ravel() if 'qcmol' in request.node.name: mol = subject else: mol = subject.to_schema(dtype=2) resinp = { 'schema_name': 'qcschema_input', 'schema_version': 1, 'molecule': mol, 'driver': 'energy', #gradient', 'model': { 'method': inp['name'] }, 'keywords': {}, } jrec = qcng.compute(resinp, 'mp2d', raise_error=True) jrec = jrec.dict() #assert len(jrec['extras']['qcvars']) == 8 assert compare_values(expected, jrec['extras']['qcvars']['CURRENT ENERGY'], atol=1.e-7) assert compare_values(expected, jrec['extras']['qcvars']['DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values(expected, jrec['extras']['qcvars'][inp['lbl'] + ' DISPERSION CORRECTION ENERGY'], atol=1.e-7)
def test_qchem_orientation(): mol = qcel.models.Molecule.from_data(""" He 0.0 0.7 0.7 He 0.0 -0.7 -0.7 """) # Compare with rotation inp = { "molecule": mol, "driver": "gradient", "model": { "method": "HF", "basis": "6-31g" } } ret = qcng.compute(inp, "qchem", raise_error=True) assert compare_values(np.linalg.norm(ret.return_result, axis=0), [0, 0, 0.00791539]) # Compare without rotations mol_noorient = mol.copy(update={"fix_orientation": True}) inp = { "molecule": mol_noorient, "driver": "gradient", "model": { "method": "HF", "basis": "6-31g" } } ret = qcng.compute(inp, "qchem", raise_error=True) assert compare_values(np.linalg.norm(ret.return_result, axis=0), [0, 0.00559696541, 0.00559696541])
def test_b3lyp(nh2): # Run NH2 resi = { "molecule": nh2, "driver": "energy", "model": { "method": "b3lyp", "basis": "3-21g" } } res = qcng.compute(resi, "nwchem", raise_error=True, return_dict=True) # Make sure the calculation completed successfully assert compare_values(-55.554037, res["return_result"], atol=1e-3) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # Check the other status information assert res["extras"]["qcvars"]["N ALPHA ELECTRONS"] == "5" assert res["extras"]["qcvars"]["N ATOMS"] == "3" assert res["extras"]["qcvars"]["N BASIS"] == "13" # Make sure the properties parsed correctly assert compare_values(-55.554037, res["properties"]["return_energy"], atol=1e-3) assert res["properties"]["calcinfo_natom"] == 3 assert res["properties"]["calcinfo_nalpha"] == 5 assert res["properties"]["calcinfo_nbasis"] == 13
def test_energy(h2o): mr_kws = { "world_prec": 1.0e-3, "world_size": 6, "world_unit": "bohr", } inp = qcel.models.AtomicInput( molecule=h2o, driver="energy", model={ "method": "BLYP", }, keywords=mr_kws, ) res = qcng.compute(inp, "mrchem", raise_error=True, return_dict=True) # Make sure the calculation completed successfully assert compare_values(-76.4546307, res["return_result"], atol=1e-3) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # Make sure the properties parsed correctly assert compare_values(-76.4546307, res["properties"]["return_energy"], atol=1e-3) assert res["properties"]["calcinfo_natom"] == 3 assert res["properties"]["calcinfo_nalpha"] == 5 assert res["properties"]["calcinfo_nbeta"] == 5 assert res["properties"]["calcinfo_nmo"] == 10 assert compare_values([-3.766420e-07, 0.0, 0.720473], res["properties"]["scf_dipole_moment"], atol=1e-3)
def test_hess(nh2): resi = { "molecule": nh2, "driver": "hessian", "model": { "method": "b3lyp", "basis": "3-21g" } } res = qcng.compute(resi, "nwchem", raise_error=True, return_dict=False) assert compare_values(-3.5980754370e-02, res.return_result[0, 0], atol=1e-3) assert compare_values(0, res.return_result[1, 0], atol=1e-3) assert compare_values(0.018208307756, res.return_result[3, 0], atol=1e-3) assert np.allclose(res.return_result, res.return_result.T, atol=1e-8) # Should be symmetric about diagonal # Test that the Hessian changes with rotation, but that its determinants remain the same shifted_nh2, _ = nh2.scramble(do_shift=False, do_mirror=False, do_rotate=True, do_resort=False) resi["molecule"] = shifted_nh2 res_shifted = qcng.compute(resi, "nwchem", raise_error=True, return_dict=False) assert not np.allclose( res.return_result, res_shifted.return_result, atol=1e-8) assert np.isclose(np.linalg.det(res.return_result), np.linalg.det(res_shifted.return_result))
def test_gradient(nh2): resi = { "molecule": nh2, "driver": "gradient", "model": {"method": "b3lyp", "basis": "3-21g"}, "keywords": {"dft__convergence__gradient": "1e-6"}, } res = qcng.compute(resi, "nwchem", raise_error=True, return_dict=True) assert compare_values(4.22418267e-2, res["return_result"][2], atol=1e-7) # Beyond accuracy of NWChem stdout # Rotate the molecule and verify that the gradient changes shifted_nh2, _ = nh2.scramble(do_shift=False, do_mirror=False, do_rotate=True, do_resort=False) resi["molecule"] = shifted_nh2 res_shifted = qcng.compute(resi, "nwchem", raise_error=True, return_dict=True) assert not compare_values(4.22418267e-2, res_shifted["return_result"][2], atol=1e-7) # Make sure the two matrices still have the same determinant and norms, as they are just rotations of each other # I am leveraging the fact that the gradients are square, 3x3 matrices just by happenstance of the # test molecule having 3 atoms orig_grads = np.reshape(res["return_result"], (-1, 3)) shif_grads = np.reshape(res_shifted["return_result"], (-1, 3)) # Test that the magnitude of forces are the same assert np.allclose(np.linalg.norm(orig_grads, ord=2, axis=1), np.linalg.norm(shif_grads, ord=2, axis=1)) # Test that the determinants are the same orig_det = np.linalg.det(orig_grads) shif_det = np.linalg.det(shif_grads) assert np.allclose(orig_det, shif_det)
def _asserter(asserter_args, contractual_args, contractual_fn): """For expectations in `contractual_fn`, check that the QCVars are present in P::e.globals and wfn and match expected ref_block.""" qcvar_stores, ref_block, atol, ref_block_conv, atol_conv, tnm = asserter_args for obj in qcvar_stores: for rpv, pv, present in contractual_fn(*contractual_args): label = tnm + " " + pv if present: # verify exact match to method (may be df) and near match to conventional (non-df) method tf, errmsg = compare_values( ref_block[rpv], query_qcvar(obj, pv), label, atol=atol, return_message=True, quiet=True ) assert compare_values(ref_block[rpv], query_qcvar(obj, pv), label, atol=atol), errmsg tf, errmsg = compare_values( ref_block_conv[rpv], query_qcvar(obj, pv), label, atol=atol_conv, return_message=True, quiet=True, ) assert compare_values(ref_block_conv[rpv], query_qcvar(obj, pv), label, atol=atol_conv), errmsg # Note that the double compare_values lines are to collect the errmsg in the first for assertion in the second. # If the errmsg isn't present in the assert, the string isn't accessible through `e.value`. # If a plain bool is compared in the assert, the printed message will show booleans and not numbers. else: # verify and forgive known contract violations assert compare(False, query_has_qcvar(obj, pv), label + " SKIP")
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)
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)
def test_kabsch_identity(): oco10 = qcel.molparse.from_string(soco10) oco12 = qcel.molparse.from_string(soco10) oco10_geom_au = oco10["qm"]["geom"].reshape((-1, 3)) / qcel.constants.bohr2angstroms oco12_geom_au = oco12["qm"]["geom"].reshape((-1, 3)) / qcel.constants.bohr2angstroms rmsd, rot, shift = qcel.molutil.kabsch_align(oco10_geom_au, oco12_geom_au) assert compare_values(0.0, rmsd, "identical") assert compare_values(np.identity(3), rot, "identity rotation matrix") assert compare_values(np.zeros(3), shift, "identical COM")
def test_qc_units(): au2D = 2.541746451895025916414946904 au2Q = au2D * 0.52917721067 onedebye = qcel.Datum("CC dipole", "e a0", np.array([0, 0, 1 / au2D])) onebuckingham = qcel.Datum( "CC quadrupole", "e a0^2", np.array([0, 0, 1 / au2Q, 0, 0, 0, 0, 0, 0]).reshape((3, 3))) assert compare_values(np.array([0, 0, 1.0]), onedebye.to_units("D")) assert compare_values(np.array([[0, 0, 1.0], [0, 0, 0], [0, 0, 0]]), onebuckingham.to_units("D Å"))
def test_dftd3__run_dftd3__3body(inp, subjects, request): subject = subjects()[inp['parent']][inp['subject']] expected = ref[inp['parent']][inp['lbl']][inp['subject']] gexpected = gref[inp['parent']][inp['lbl']][inp['subject']].ravel() if 'qcmol' in request.node.name: subject.update({ 'model': { 'method': inp['name'] }, 'driver': 'gradient', 'keywords': {}, 'schema_name': 'qcschema_input', 'schema_version': 1 }) jrec = dftd3.run_json(subject) else: jrec = dftd3.run_dftd3(inp['name'], subject, options={}, ptype='gradient') assert len(jrec['extras']['qcvars']) == 8 assert compare_values(expected, jrec['extras']['qcvars']['CURRENT ENERGY'], atol=1.e-7) assert compare_values(expected, jrec['extras']['qcvars']['DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values(expected, jrec['extras']['qcvars']['3-BODY DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values( expected, jrec['extras']['qcvars']['AXILROD-TELLER-MUTO 3-BODY DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values(gexpected, jrec['extras']['qcvars']['CURRENT GRADIENT'], atol=1.e-7) assert compare_values(gexpected, jrec['extras']['qcvars']['DISPERSION CORRECTION GRADIENT'], atol=1.e-7) assert compare_values(gexpected, jrec['extras']['qcvars']['3-BODY DISPERSION CORRECTION GRADIENT'], atol=1.e-7) assert compare_values( gexpected, jrec['extras']['qcvars']['AXILROD-TELLER-MUTO 3-BODY DISPERSION CORRECTION GRADIENT'], atol=1.e-7)
def test_qcore_methods(method, energy, gradient_norm): atomic_input = qcel.models.AtomicInput( molecule=qcng.get_molecule("water"), model=method, driver="gradient", ) atomic_result = qcng.compute(atomic_input, "qcore") assert atomic_result.success, atomic_result.error.error_message assert compare_values(atomic_result.properties.return_energy, energy) assert compare_values(np.linalg.norm(atomic_result.return_result), gradient_norm) assert atomic_result.wavefunction is None
def test_dftd3__run_dftd3__3body(inp, subjects, request): subject = subjects()[inp['parent']][inp['subject']] expected = ref[inp['parent']][inp['lbl']][inp['subject']] gexpected = gref[inp['parent']][inp['lbl']][inp['subject']] if 'qcmol' in request.node.name: mol = subject else: mol = subject.to_schema(dtype=2) resinp = { 'schema_name': 'qcschema_input', 'schema_version': 1, 'molecule': mol, 'driver': 'gradient', 'model': { 'method': inp['name'] }, 'keywords': {}, } jrec = qcng.compute(resinp, 'dftd3', raise_error=True) jrec = jrec.dict() assert len(jrec['extras']['qcvars']) == 8 assert compare_values(expected, jrec['extras']['qcvars']['CURRENT ENERGY'], atol=1.e-7) assert compare_values( expected, jrec['extras']['qcvars']['DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values( expected, jrec['extras']['qcvars']['3-BODY DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values( expected, jrec['extras']['qcvars'] ['AXILROD-TELLER-MUTO 3-BODY DISPERSION CORRECTION ENERGY'], atol=1.e-7) assert compare_values(gexpected, jrec['extras']['qcvars']['CURRENT GRADIENT'], atol=1.e-7) assert compare_values( gexpected, jrec['extras']['qcvars']['DISPERSION CORRECTION GRADIENT'], atol=1.e-7) assert compare_values( gexpected, jrec['extras']['qcvars']['3-BODY DISPERSION CORRECTION GRADIENT'], atol=1.e-7) assert compare_values( gexpected, jrec['extras']['qcvars'] ['AXILROD-TELLER-MUTO 3-BODY DISPERSION CORRECTION GRADIENT'], atol=1.e-7)
def test_clbrbutRS(): mol, data = clbrbutRS.align(clbrbutRR, do_plot=do_plot, verbose=verbose, uno_cutoff=uno_cutoff, run_mirror=run_mirror) assert compare_values(1.092, data['rmsd'], '2-chloro-3-bromobutane RR, RS', atol=1.)
def test_sp_ccsd_rhf_full(program, basis, keywords, h2o): """cfour/sp-rhf-ccsd/input.dat #! single point CCSD/qz2p on water """ resi = { "molecule": h2o, "driver": "energy", "model": { "method": "ccsd", "basis": basis }, "keywords": keywords, } res = qcng.compute(resi, program, raise_error=True, return_dict=True) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # aug-cc-pvdz scftot = -76.0413815332 mp2tot = -76.2632792578 mp2corl = -0.2218977246 ccsdcorl = -0.2294105794 ccsdtot = -76.2707921127 atol = 1.e-6 #assert compare_values(scftot, qcdb.variable('scf total energy'), tnm() + ' SCF', atol=atol) #if not (mtd == 'nwc-ccsd' and keywords.get('qc_module', 'nein').lower() == 'tce'): # assert compare_values(mp2tot, qcdb.variable('mp2 total energy'), tnm() + ' MP2', atol=atol) #assert compare_values(ccsdcorl, qcdb.variable('ccsd correlation energy'), tnm() + ' CCSD corl', atol=atol) assert compare_values(ccsdtot, res["return_result"], atol=atol)
def test_sp_ccsd_rohf_full(program, basis, keywords, nh2): resi = { "molecule": nh2, "driver": "energy", "model": { "method": "ccsd", "basis": basis }, "keywords": keywords, } res = qcng.compute(resi, program, raise_error=True, return_dict=True) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # aug-cc-pvdz scftot = -55.570724348574 ssccsdcorl = -0.0339827 osccsdcorl = -0.1442533 ccsdcorl = -0.178236032911 ccsdtot = -55.748960381485 atol = 1.e-6 #assert compare_values(scftot, qcdb.variable('scf total energy'), tnm() + 'SCF', atol=atol) #if not (method in ['gms-ccsd', 'nwc-ccsd']): # # cfour isn't splitting out the singles from OS. and psi4 isn't incl the singles in either so SS + OS != corl # # and maybe singles moved from SS to OS in Cfour btwn 2010 and 2014 versions (change in ref) # # assert compare_values(osccsdcorl, qcdb.variable('ccsd opposite-spin correlation energy'), tnm() + ' CCSD OS corl', atol=atol) # assert compare_values(ssccsdcorl, qcdb.variable('ccsd same-spin correlation energy'), tnm() + ' CCSD SS corl', atol=atol) #assert compare_values(ccsdcorl, qcdb.variable('ccsd correlation energy'), tnm() + ' CCSD corl', atol=atol) #assert compare_values(ccsdtot, qcdb.variable('ccsd total energy'), tnm() + ' CCSD', atol=atol) #assert compare_values(ccsdcorl, qcdb.variable('current correlation energy'), tnm() + ' Current corl', atol=atol) assert compare_values(ccsdtot, res["return_result"], atol=atol)
def test_sp_hf_rhf(program, basis, keywords, h2o): """cfour/sp-rhf-hf/input.dat #! single point HF/adz on water """ resi = { "molecule": h2o, "driver": "energy", "model": { "method": "hf", "basis": basis }, "keywords": keywords, } res = qcng.compute(resi, program, raise_error=True, return_dict=True) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # aug-cc-pvdz scf_tot = -76.0413815332 atol = 1.e-6 assert compare_values(scf_tot, res["return_result"], atol=atol)
def test_molsymm_alone(subject): pg = data[subject]["pg"] sigma = data[subject]["rsn"] if subject.startswith("iso"): isbohr = data[subject[3:]].get("au", False) molstr = data[subject[3:]]["mol"].format(isoA=data[subject]["A"]) refgeomang = None else: isbohr = data[subject].get("au", False) molstr = data[subject]["mol"].format(isoA="") refgeomang = data[subject]["ref"] symmol = qcdb.Molecule(molstr) symmol.update_geometry() # symmol.axis_representation() assert compare(pg, symmol.get_full_point_group(), pg + " point group: " + subject) assert compare(sigma, symmol.rotational_symmetry_number(), pg + " sigma") if isbohr: geom_now = symmol.full_geometry() else: geom_now = qcdb.util.vecutil.mscale(symmol.full_geometry(), qcel.constants.bohr2angstroms) if refgeomang: assert compare_values(refgeomang, geom_now, pg + " orientation", atol=1.0e-6)
def test_dibromobutRS_SS(): mol, data = dibromobutRS.align(dibromobutSS, do_plot=do_plot, verbose=verbose, uno_cutoff=uno_cutoff, run_mirror=run_mirror) assert compare_values(1.560, data['rmsd'], '2,3-dibromobutane SS, RS', atol=1.e-1)
def _test_dihedral(p1, p2, p3, p4, value, degrees=True): tmp = qcelemental.util.compute_dihedral(p1, p2, p3, p4, degrees=degrees) assert compare_values(value, float(tmp), label="test_dihedral1")
def test_model_b787(): oco10 = qcel.models.Molecule.from_data(soco10) oco12 = qcel.models.Molecule.from_data(sooc12) mol, data = oco12.align(oco10, verbose=4) assert compare_values(ref_rmsd, data["rmsd"], "known rmsd qcel.models.Molecule.align", atol=1.0e-6)
def test_psz_main(): """Checks that the main function on the psithonyzer script returns the correct values for precomputed psithon outputs.""" root = os.getcwd() d = os.path.join(root, "crystalatte", "data", "out") os.chdir(d) results, crystal_lattice_energy = crystalatte.psz_main(2) a = [] a.append("2mer-0+1 | 0.87719178 | 6 | 2.63157535 | 2.63157535 | 1.748924e-03 | 2.588 ") a.append("3mer-0+1+2 | 0.03591565 | 3 | 0.03591565 | 2.66749100 | 6.255109e-07 | 2.428 2.588 2.588 ") a.append("3mer-0+1+5 | -0.10631085 | 3 | -0.10631085 | 2.56118015 | 6.255109e-07 | 2.588 2.588 2.588 ") a.append("4mer-0+1+2+3 | 0.00643113 | 1 | 0.00160778 | 2.56278793 | 9.355871e-12 | 2.428 2.428 2.428 2.588 2.588 2.588 ") a.append("5mer-0+1+2+3+4 | -0.00086359 | 3 | -0.00051816 | 2.56226977 | 4.005201e-25 | 2.428 2.428 2.428 2.588 2.588 2.588 2.588 2.588 3.945 5.012 ") assert compare(a[0], results[0]) assert compare(a[1], results[1]) assert compare(a[2], results[2]) assert compare(a[3], results[3]) assert compare(a[4], results[4]) assert compare_values(2.56226977, crystal_lattice_energy, atol=1.e-9) # Change directory back to root. os.chdir(root) # Clean-up generated test files. subprocess.call(["rm", "crystalatte/data/out/Ammonia.csv"])
def test_sp_mp2_rhf_full(program, basis, keywords, h2o): """cfour/sp-rhf-ccsd/input.dat #! single point MP2/adz on water """ resi = { "molecule": h2o, "driver": "energy", "model": { "method": "mp2", "basis": basis }, "keywords": keywords } res = qcng.compute(resi, program, raise_error=True, return_dict=True) assert res["driver"] == "energy" assert "provenance" in res assert res["success"] is True # aug-cc-pvdz mp2_tot = -76.2632792578 atol = 1.0e-6 assert compare_values(mp2_tot, res["return_result"], atol=atol)
def test_atom_labels(qcprog, basis, keywords): kmol = qcel.models.Molecule.from_data(""" H 0 0 0 H5 5 0 0 H_other 0 5 0 H_4sq 5 5 0 units au """) assert compare(["H", "H", "H", "H"], kmol.symbols, "elem") assert compare(["", "5", "_other", "_4sq"], kmol.atom_labels, "elbl") atin = qcel.models.AtomicInput( **{ "molecule": kmol, "model": { "method": "mp2", "basis": basis }, "driver": "energy", "keywords": keywords }) atres = qcng.compute(atin, qcprog) pprint.pprint(atres.dict(), width=200) nre = 1.0828427 assert compare_values( nre, atres.properties.nuclear_repulsion_energy, atol=1.0e-4, label="nre" ), f"nre: {atres.properties.nuclear_repulsion_energy} != {nre}" nmo = 36 assert compare( nmo, atres.properties.calcinfo_nmo, label="nmo"), f"nmo: {atres.properties.calcinfo_nmo} != {nmo}" scf = -1.656138508 assert compare_values( scf, atres.properties.scf_total_energy, atol=3.0e-6, label="scf ene" ), f"scf ene: {atres.properties.scf_total_energy} != {scf}" mp2 = -1.7926264513 assert compare_values(mp2, atres.return_result, atol=3.0e-6, label="ene"), f"ene: {atres.return_result} != {mp2}"
def test_dibromobutRS_SR(): mol, data = dibromobutRS.align(dibromobutSR, do_plot=do_plot, verbose=verbose, uno_cutoff=uno_cutoff, run_mirror=True) assert compare_values(0.004, data['rmsd'], '2,3-dibromobutane SR, RS', atol=1.e-3) assert compare(True, data['mill'].mirror, '2,3-dibromobutane SR, RS identical')
def test_center_supercell(): """Checks the routine to read the supercell XYZ file and create Numpy arrays from it containing the center of the supercell, its coordinates and elements.""" args = [ '', '-i', 'crystalatte/data/cif/Ammonia.cif', '-o', 'sc.xyz', '-b', '1', '1', '1', '-r' ] crystalatte.cif_main(args) # Execute the main function of crystalatte and retrieve the N-mers dictionary. scell_geom_max_coords, scell_geom, scell_elem = crystalatte.center_supercell( "sc.xyz", 2) scgmc = np.array([4.84761994, 4.84761994, 4.84761994]) sce = np.array([ 'N', 'N', 'N', 'N', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' ]) l_scg = [[-0.91910799, 3.92851196, 3.16646478], [3.92851196, 3.16646478, -0.91910799], [3.16646478, -0.91910799, 3.92851196], [-1.68115516, -1.68115516, -1.68115516], [2.3947252, 3.71327782, 0.], [-1.46592103, 4.84761994, 4.70025154], [-2.45289475, 3.38169892, 2.24735679], [0., 2.3947252, 3.71327782], [4.84761994, 4.70025154, -1.46592103], [3.38169892, 2.24735679, -2.45289475], [2.24735679, -2.45289475, 3.38169892], [3.71327782, 0., 2.3947252], [4.70025154, -1.46592103, 4.84761994], [-2.60026315, -0.1473684, -1.13434212], [-1.13434212, -2.60026315, -0.1473684], [-0.1473684, -1.13434212, -2.60026315]] scg = np.array(l_scg) assert compare_values(scgmc, scell_geom_max_coords) assert compare_values(scg, scell_geom) assert compare(sce, scell_elem) # Clean-up generated test files subprocess.call(["rm", "sc.xyz"])
def test_nonphysical_spec(): mol = qcel.models.Molecule(symbols=["He"], masses=[100], geometry=[0, 0, 0], nonphysical=True) assert compare_values([100.0], mol.masses, "nonphysical mass") print(mol.to_string(dtype="psi4"))
def test_dibromobutSS_RR(): mol, data = dibromobutSS.align(dibromobutRR, do_plot=do_plot, verbose=verbose, uno_cutoff=uno_cutoff, run_mirror=run_mirror) assert compare_values(1.296e-2, data['rmsd'], '2,3-dibromobutane RR, SS', atol=1.e-3) assert compare(True, data['mill'].mirror, '2,3-dibromobutane RR, SS enantiomers')
def test_qcdb__energy_d3(): eneyne = qcdb.set_molecule(seneyne) eneyne.update_geometry() E, jrec = qcdb.energy('d3-b3lyp-d2', return_wfn=True) assert compare_values(ref['eneyne']['B3LYP-D2']['dimer'], E, 7, 'P: Ethene-Ethyne -D2') assert compare_values(ref['eneyne']['B3LYP-D2']['dimer'], jrec['qcvars']['DISPERSION CORRECTION ENERGY'].data, 7, tnm()) assert compare_values(ref['eneyne']['B3LYP-D2']['dimer'], jrec['qcvars']['B3LYP-D2 DISPERSION CORRECTION ENERGY'].data, 7, tnm()) mA = eneyne.extract_subsets(1) E, jrec = qcdb.energy('d3-b3lyp-d3bj', return_wfn=True, molecule=mA) assert compare_values(ref['eneyne']['B3LYP-D3(BJ)']['mA'], E, 7, tnm()) assert compare_values(ref['eneyne']['B3LYP-D3(BJ)']['mA'], jrec['qcvars']['DISPERSION CORRECTION ENERGY'].data, 7, tnm()) assert compare_values(ref['eneyne']['B3LYP-D3(BJ)']['mA'], jrec['qcvars']['B3LYP-D3(BJ) DISPERSION CORRECTION ENERGY'].data, 7, tnm())