def test_json():
"""json/energy"""
import numpy as np
# Generate JSON data
json_data = {}
json_data["molecule"] = """He 0 0 0\n--\nHe 0 0 1"""
json_data["driver"] = "gradient"
json_data["method"] = 'SCF'
json_data["kwargs"] = {}
json_data["options"] = {"BASIS": "STO-3G"}
json_data["return_output"] = True
psi4.json_wrapper.run_json(json_data)
assert psi4.compare_strings("STO-3G", json_data["options"]["BASIS"], "Options test")
assert psi4.compare_integers(True, json_data["success"], "Success")
bench_energy = -5.433191881443323
cenergy = json_data["variables"]["CURRENT ENERGY"]
bench_gradient = np.array([[ 0.0 , 0.0 , 0.4206844],
[ 0.0 , 0.0 , -0.4206844]])
cgradient = psi4.core.Matrix.from_serial(json_data["return_value"])
assert psi4.compare_arrays(bench_gradient, cgradient.np, 4, "SCF RETURN_VALUE")
return_wfn = "return_wfn" not in json_data["kwargs"]
assert psi4.compare_integers(True, return_wfn, "Immutable input")
with open("pytest_output.dat", "w") as f:
f.write(json_data["raw_output"])
def test_rhf_fchk(inp, datadir):
""" FCHK RHF """
mol = psi4.geometry("""
no_reorient
0 1
O
H 1 1.01
H 1 1.0 2 104.5
""")
psi4.set_options({
"BASIS": "pcseg-0",
'd_convergence': 1e-12,
})
FCHK_file = f"rhf-{inp['name']}.fchk"
reference_file = datadir.join(f"rhf-{inp['name']}.ref")
psi4.set_options(inp['options'])
e, wfn = psi4.gradient(inp['name'], return_wfn=True, molecule=mol)
ret = psi4.driver.fchk(wfn, FCHK_file, debug=True)
if inp['name'] in ['mp2', 'dct', 'omp2']:
refwfn = wfn.reference_wavefunction()
expected = calcD(refwfn)
else:
expected = calcD(wfn)
assert psi4.compare_arrays(ret["Total SCF Density"], expected, 9, "FCHK RHF Density")
assert psi4.compare_fchkfiles(reference_file, FCHK_file, 1.e-8, f" File comparison: {FCHK_file}")
def test_json():
"""json/energy"""
import numpy as np
# Generate JSON data
json_data = {}
json_data["molecule"] = """He 0 0 0\n--\nHe 0 0 1"""
json_data["driver"] = "gradient"
json_data["method"] = 'SCF'
json_data["kwargs"] = {}
json_data["options"] = {"BASIS": "STO-3G"}
json_data["return_output"] = True
psi4.json_wrapper.run_json(json_data)
assert psi4.compare_strings("STO-3G", json_data["options"]["BASIS"],
"Options test")
assert psi4.compare_integers(True, json_data["success"], "Success")
bench_energy = -5.433191881443323
cenergy = json_data["variables"]["CURRENT ENERGY"]
bench_gradient = np.array([[0.0, 0.0, 0.4206844], [0.0, 0.0, -0.4206844]])
cgradient = psi4.core.Matrix.from_serial(json_data["return_value"])
assert psi4.compare_arrays(bench_gradient, cgradient.np, 4,
"SCF RETURN_VALUE")
return_wfn = "return_wfn" not in json_data["kwargs"]
assert psi4.compare_integers(True, return_wfn, "Immutable input")
with open("pytest_output.dat", "w") as f:
f.write(json_data["raw_output"])
def test_json():
"""json/energy"""
import numpy as np
# Generate JSON data
json_input = {
"schema_name": "qc_schema_input",
"schema_version": 1,
"molecule": {
"symbols": ["He", "He"],
"geometry": [0, 0, -1, 0, 0, 1]
},
"driver": "gradient",
"model": {
"method": "SCF",
"basis": "sto-3g"
},
"keywords": {}
}
json_ret = psi4.json_wrapper.run_json(json_input)
assert psi4.compare_integers(True, json_ret["success"], "Success")
assert psi4.compare_values(-5.474227786274896, json_ret["properties"]["return_energy"], 4, "SCF ENERGY")
bench_gradient = np.array([[ 0.0 , 0.0 , 0.32746933],
[ 0.0 , 0.0 , -0.32746933]])
cgradient = np.array(json_ret["return_result"]).reshape(-1, 3)
assert psi4.compare_arrays(bench_gradient, cgradient, 4, "SCF RETURN GRADIENT")
with open("pytest_output.dat", "w") as f:
json.dump(json_ret["raw_output"], f)
def test_uhf_fchk(inp2, datadir):
""" FCHK UHF """
mol = psi4.geometry("""
no_reorient
0 2
O
O 1 1.46
H 2 0.97 1 104.6
""")
psi4.set_options({
"BASIS": "pcseg-0",
'reference': 'uhf',
'e_convergence': 1e-12,
'd_convergence': 1e-12,
'r_convergence': 1e-10,
'pcg_convergence': 1e-10,
})
FCHK_file = f"uhf-{inp2['name']}.fchk"
reference_file = datadir.join(f"uhf-{inp2['name']}.ref")
psi4.set_options(inp2['options'])
e, wfn = psi4.gradient(inp2['name'], return_wfn=True, molecule=mol)
ret = psi4.driver.fchk(wfn, FCHK_file, debug=True)
assert psi4.compare_arrays(ret["Total SCF Density"], calcD(wfn), 9,
"FCHK UHF Density")
assert psi4.compare_fchkfiles(reference_file, FCHK_file, 1.e-8,
f" File comparison: {FCHK_file}")
noorient_data["molecule"]["fix_com"] = True # Write expected output expected_return_result = -100.0194177509218 linear_dipole = 1.948993625469663 psi4.json_wrapper.run_json(json_data) # Orients to Z axis psi4.compare_integers(True, json_data["success"], "JSON Success") #TEST psi4.compare_values(expected_return_result, json_data["return_result"], 5, "Return Value") #TEST psi4.compare_values(0.0, json_data["properties"]["scf_dipole_moment"][0], 5, "DIPOLE X") #TEST psi4.compare_values(0.0, json_data["properties"]["scf_dipole_moment"][1], 5, "DIPOLE Y") #TEST psi4.compare_values(linear_dipole, json_data["properties"]["scf_dipole_moment"][2], 5, "DIPOLE Z") #TEST dist = np.linalg.norm(np.array(json_data["molecule"]["geometry"])[:3] - np.array(np.array(json_data["molecule"]["geometry"])[3:])) #TEST psi4.compare_values(1.732, dist, 4, "HF Bond Distance") #TEST psi4.json_wrapper.run_json(noorient_data) # Orients to Z axis psi4.compare_integers(True, noorient_data["success"], "JSON Success") #TEST psi4.compare_values(expected_return_result, noorient_data["return_result"], 5, "Return Value") #TEST psi4.compare_values(0.0, noorient_data["properties"]["scf_dipole_moment"][0], 5, "DIPOLE X") #TEST psi4.compare_values(linear_dipole, noorient_data["properties"]["scf_dipole_moment"][1], 5, "DIPOLE Y") #TEST psi4.compare_values(0.0, noorient_data["properties"]["scf_dipole_moment"][2], 5, "DIPOLE Z") #TEST psi4.compare_arrays([0.0, 0.0, 0.0], noorient_data["molecule"]["geometry"][:3], 5, "H Position") #TEST psi4.compare_arrays([0.0, 1.732, 0.0], noorient_data["molecule"]["geometry"][3:], 5, "F Position") #TEST
if(form == 'pqQ'):
for ind, i in enumerate(transformations):
j = space_pairs[ind]
dfh_Qmo.append(np.zeros((sizes[j[0]], sizes[j[1]], naux)))
for k in range(sizes[j[0]]):
dfh_Qmo[ind][k,:,:] = np.asarray(dfh.get_tensor(i, [k, k+1], [0, sizes[j[1]]], [0, naux]))
else:
for ind, i in enumerate(transformations):
dfh_Qmo.append(np.asarray(dfh.get_tensor(i)))
test_string = 'Alg: ' + method + ' + ' + form + ' core (AOs, MOs, met): ['
test_string += str(AO_core) + ', ' + str(MO_core) + ', ' + str(hold_met) + ']'
print(test_string)
# am i right?
for i in range(ntransforms):
if(form == 'pqQ'):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo_pqQ[i], 9, test_string)
elif(form == 'pQq'):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo_pQq[i], 9, test_string)
else:
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo[i], 9, test_string)
del dfh
# TODO:
# test tensor slicing grabs
# test pQq and pqQ builds for store and direct0
6.17969093e-03, 1.74806282e-03, 4.26579485e-03, 5.29784951e-03,
5.12333890e-03, 4.45846711e-03, -1.57567665e-02, 5.30695677e-03,
1.23293022e-02, 1.06586884e-02, 7.93900611e-03, -7.73802957e-03,
7.26178250e-03, 1.17147293e-02, 9.98332008e-03, 7.52680394e-03,
-4.70874042e-04, 7.07678716e-03, 9.28214077e-03, 8.16156593e-03,
6.44348860e-03, 1.00781695e-03, 4.75096863e-03, 6.24946368e-03,
5.97476305e-03, 5.07885832e-03, 9.07850148e-04, 2.91174728e-03,
3.98405846e-03, 4.14293807e-03, 3.80513995e-03, -5.01856357e-03,
1.66005706e-03, 5.58988126e-03, 6.25608633e-03, 5.51718510e-03,
-3.54538877e-03, 2.13874136e-03, 5.42317564e-03, 5.96499476e-03,
5.28687977e-03, -1.26041313e-03, 2.57086533e-03, 4.76216983e-03,
5.15904477e-03, 4.66727597e-03, -6.98718627e-05, 2.29543121e-03,
3.72078488e-03, 4.09219098e-03, 3.84409282e-03, 2.86099206e-04,
1.74337099e-03, 2.70404545e-03, 3.07010847e-03, 3.01768294e-03,
-2.17493011e-03, 7.08011269e-04, 2.82422496e-03, 3.69989978e-03,
3.71459579e-03, -1.77325890e-03, 8.55302891e-04, 2.77277336e-03,
3.57535348e-03, 3.59320794e-03, -9.75050076e-04, 1.08091443e-03,
2.57027134e-03, 3.22234880e-03, 3.25925100e-03, -3.45599629e-04,
1.12615341e-03, 2.20372521e-03, 2.71976417e-03, 2.79365593e-03,
-1.83114358e-05, 1.00066735e-03, 1.76948007e-03, 2.18338059e-03,
2.29358229e-03
]
# Comparison
psi4.compare_arrays(
esps_1threads, esps_4threads, 3,
"Reference value for ESP calculation, 1 thread vs. 4 threads.")
psi4.compare_arrays(
esps_1threads, reference_esps, 3,
"Reference value for ESP calculation, 1 thread vs. reference calculation.")
# Write expected output
expected_return_result = [
0.0, 0.0, -0.05959774096119619, 0.0, -0.043039786289375104,
0.02979887048056895, 0.0, 0.043039786289375104, 0.02979887048056895
]
expected_properties = {
"calcinfo_nbasis": 24,
"calcinfo_nmo": 24,
"calcinfo_nalpha": 5,
"calcinfo_nbeta": 5,
"calcinfo_natom": 3,
"scf_one_electron_energy": -122.4452968291507,
"scf_two_electron_energy": 37.62243738251799,
"nuclear_repulsion_energy": 8.80146206062943,
"scf_total_energy": -76.02139738600329,
"return_energy": -76.02139738600329
}
json_ret = psi4.json_wrapper.run_json(json_data)
with open("output.json", "w") as ofile:
json.dump(json_ret, ofile, indent=2)
psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST
psi4.compare_arrays(expected_return_result, json_ret["return_result"], 5,
"Return Value") #TEST
for k in expected_properties.keys():
psi4.compare_values(expected_properties[k], json_ret["properties"][k], 5,
k.upper()) #TEST
Ks.append(psi4.core.Matrix(nbf, nbf))
Ks.append(psi4.core.Matrix(nbf, nbf))
Ks.append(psi4.core.Matrix(nbf, nbf))
Ks.append(psi4.core.Matrix(nbf, nbf))
Ks.append(psi4.core.Matrix(nbf, nbf))
Ks.append(psi4.core.Matrix(nbf, nbf))
# invoke J/K build
dfh.build_JK(Cleft, Cright, Js, Ks)
# practice J
Q = np.zeros((naux))
D = np.dot(np.asarray(C1), np.asarray(C1).T)
# am i right?
for i in range(len(Cright)):
psi4.compare_arrays(np.asarray(Ks[i]), K[i], 9, "K builds - STORE") #TEST
#for i in range(len(Cright)):
# print (np.linalg.norm(np.asarray(Js[i]).ravel()[:naux]-Qs[i])) #TEST
Ds = []
for i in range(len(Cright)):
Ds.append(np.dot(np.asarray(Cleft[i]), np.asarray(Cright[i]).T))
print(np.linalg.norm(np.asarray(Js[i]) - Ds[i]))
#for i in range(naux):
# if (i == 80):
# print ("YUP")
# print (np.linalg.norm(np.asarray(Js[0]).ravel()[i] -Qs[0][i]))
#psi4.compare_arrays(np.asarray(Js[i]), J[i], 9, "J builds - STORE" ) #TEST
}
expected_properties = {
"calcinfo_nbasis": 13,
"calcinfo_nmo": 13,
"calcinfo_nalpha": 5,
"calcinfo_nbeta": 5,
"calcinfo_natom": 3,
"scf_one_electron_energy": -122.27509111304202,
"scf_two_electron_energy": 37.49348718008625,
"nuclear_repulsion_energy": 8.80146206062943,
"scf_total_energy": -75.98014187232634,
"return_energy": -75.98014187232634
}
json_ret = psi4.json_wrapper.run_json(json_data)
with open("output.json", "w") as ofile: #TEST
json.dump(json_ret, ofile, indent=2) #TEST
psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST
psi4.compare_strings("qc_schema_output", json_ret["schema_name"], "Schema Name") #TEST
for k in expected_return_result.keys(): #TEST
psi4.compare_arrays(expected_return_result[k], json_ret["return_result"][k], 5, "Result: " + k.upper()) #TEST
for k in expected_properties.keys(): #TEST
psi4.compare_values(expected_properties[k], json_ret["properties"][k], 5, k.upper()) #TEST
# Generate JSON data
json_data = {}
json_data["molecule"] = """He 0 0 0\n--\nHe 0 0 1"""
json_data["driver"] = "gradient"
json_data["method"] = 'SCF'
json_data["kwargs"] = {}
json_data["options"] = {"BASIS": "STO-3G"}
json_data["return_output"] = True
psi4.json_wrapper.run_json(json_data)
psi4.compare_strings("STO-3G", json_data["options"]["BASIS"], "Options test") #TEST
psi4.compare_integers(True, json_data["success"], "Success") #TEST
bench_energy = -5.433191881443323 #TEST
cenergy = json_data["variables"]["CURRENT ENERGY"] #TEST
psi4.compare_values(bench_energy, cenergy, 5, "SCF CURRENT ENERGY") #TEST
bench_gradient = np.array([[ 0.0 , 0.0 , 0.4206844],
[ 0.0 , 0.0 , -0.4206844]])
cgradient = psi4.core.Matrix.from_serial(json_data["return_value"]) #TEST
psi4.compare_arrays(bench_gradient, cgradient.np, 4, "SCF RETURN_VALUE") #TEST
return_wfn = "return_wfn" not in json_data["kwargs"] #TEST
psi4.compare_integers(True, return_wfn, "Immutable input") #TEST
with open("output.dat", "w") as f:
f.write(json_data["raw_output"])
0.0,
-0.043039786289375104,
0.02979887048056895,
0.0,
0.043039786289375104,
0.02979887048056895
]
expected_properties = {
"calcinfo_nbasis": 24,
"calcinfo_nmo": 24,
"calcinfo_nalpha": 5,
"calcinfo_nbeta": 5,
"calcinfo_natom": 3,
"scf_one_electron_energy": -122.4452968291507,
"scf_two_electron_energy": 37.62243738251799,
"nuclear_repulsion_energy": 8.80146206062943,
"scf_total_energy": -76.02139738600329,
"return_energy": -76.02139738600329
}
json_ret = psi4.schema_wrapper.run_qcschema(json_data)
with open("output.json", "w") as ofile:
json.dump(json_ret.json(), ofile, indent=2)
psi4.compare_integers(True, json_ret.success, "JSON Success") #TEST
psi4.compare_arrays(expected_return_result, json_ret.return_result.ravel(), 5, "Return Value") #TEST
for k in expected_properties.keys(): #TEST
psi4.compare_values(expected_properties[k], getattr(json_ret.properties, k), 5, k.upper()) #TEST
dfh.transpose("Qmo4", (1, 0, 2))
dfh.transpose("Qmo5", (1, 2, 0))
dfh.transpose("Qmo6", (1, 2, 0))
# grab transformed integrals
dfh_Qmo = []
dfh_Qmo.append(dfh.get_tensor("Qmo1"))
dfh_Qmo.append(dfh.get_tensor("Qmo2"))
dfh_Qmo.append(dfh.get_tensor("Qmo3"))
dfh_Qmo.append(dfh.get_tensor("Qmo4"))
dfh_Qmo.append(dfh.get_tensor("Qmo5"))
dfh_Qmo.append(dfh.get_tensor("Qmo6"))
# am i right?
for i in range(6):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo[i], 9, "STORE with some tranposes - on disk" ) #TEST
# try again without tranposing --
# untranspose python side
Qmo[2] = np.einsum("pQq->Qpq", Qmo[2])
Qmo[3] = np.einsum("pQq->Qpq", Qmo[3])
Qmo[4] = np.einsum("pqQ->Qpq", Qmo[4])
Qmo[5] = np.einsum("pqQ->Qpq", Qmo[5])
# invoke transformations
dfh.transform()
# grab transformed integrals
dfh_Qmo[0] = (dfh.get_tensor("Qmo1"))
dfh_Qmo[1] = (dfh.get_tensor("Qmo2"))
dfh_Qmo[2] = (dfh.get_tensor("Qmo3"))
def test_cc_polaroptrot():
# cc29 + polarizabilities + tensors
mol = psi4.geometry("""
O -0.028962160801 -0.694396279686 -0.049338350190
O 0.028962160801 0.694396279686 -0.049338350190
H 0.350498145881 -0.910645626300 0.783035421467
H -0.350498145881 0.910645626300 0.783035421467
symmetry c1
noreorient
""")
mw = sum([mol.mass(i) for i in range(0, 4)])
c = psi4.constants.c
h = psi4.constants.h
h2j = psi4.constants.hartree2J
Na = psi4.constants.na
me = psi4.constants.me
hbar = psi4.constants.hbar
prefactor = -72E6 * hbar**2 * Na / c**2 / me**2 / mw / 3.0
au_589 = c * h * 1E9 / h2j / 589
au_355 = c * h * 1E9 / h2j / 355
psi4.set_options({"basis": "cc-pVDZ"})
omega = [589, 355, 'nm']
psi4.set_options({
'gauge': 'both',
'omega': omega,
'freeze_core': True,
'r_convergence': 10
})
e, wfn = psi4.properties('CCSD',
properties=["polarizability", "rotation"],
return_wfn=True)
pol_589 = 8.92296 #TEST
pol_355 = 9.16134 #TEST
rotlen_589 = -76.93388 #TEST
rotvel_589 = 850.24712 #TEST
rotmvg_589 = -179.08820 #TEST
rotlen_355 = -214.73273 #TEST
rotvel_355 = 384.88786 #TEST
rotmvg_355 = -644.44746 #TEST
polr_589 = np.trace(
wfn.variable("CCSD DIPOLE POLARIZABILITY TENSOR @ 589NM").to_array()
) / 3.0 #RESULT
polr_355 = np.trace(
wfn.variable("CCSD DIPOLE POLARIZABILITY TENSOR @ 355NM").to_array()
) / 3.0 #RESULT
rotlenr_589 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (LEN) @ 589NM").to_array()
) * prefactor * au_589 #RESULT
rotvelr_589 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 589NM").to_array()
) * prefactor #RESULT
rotmvgr_589 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (MVG) @ 589NM").to_array()
) * prefactor #RESULT
rotlenr_355 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (LEN) @ 355NM").to_array()
) * prefactor * au_355 #RESULT
rotvelr_355 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 355NM").to_array()
) * prefactor #RESULT
rotmvgr_355 = np.trace(
wfn.variable("CCSD OPTICAL ROTATION TENSOR (MVG) @ 355NM").to_array()
) * prefactor #RESULT
polt_589 = np.array([[5.44184081e+00, -8.30270852e-01, 9.39878004e-14],
[-8.30270852e-01, 1.27518991e+01, -6.94720506e-14],
[9.39878004e-14, -6.94720506e-14,
8.57516214e+00]]) #TEST
polt_355 = np.array([[5.57913165e+00, -8.66951957e-01, 1.02575190e-13],
[-8.66951957e-01, 1.31256109e+01, -7.71806997e-14],
[1.02575190e-13, -7.71806997e-14,
8.77928702e+00]]) #TEST
rottvel_0 = np.array([[3.63702792e-01, -3.62754886e-01, -3.37227243e-14],
[-1.16320923e-01, 1.20784891e-02, 1.76483272e-14],
[1.90062651e-14, -2.33369227e-15,
-3.92022202e-01]]) #TEST
rottlen_589 = np.array([[1.41679366e-01, -7.07140738e-02, -2.26060131e-14],
[-2.72710108e-01, 1.28928522e-03, 1.01578936e-14],
[3.74236371e-14, 3.88522300e-15,
-1.27276912e-01]]) #TEST
rottvel_589 = np.array([[3.75624000e-01, -3.74245928e-01, -3.61489832e-14],
[-1.39409385e-01, 1.26867931e-02, 1.94630079e-14],
[2.33993608e-14, -1.61361648e-15,
-4.01726048e-01]]) #TEST
rottmvg_589 = np.array([[1.19212077e-02, -1.14910412e-02, -2.42625886e-15],
[-2.30884623e-02, 6.08303937e-04, 1.81468070e-15],
[4.39309571e-15, 7.20075789e-16,
-9.70384612e-03]]) #TEST
assert psi4.compare_values(pol_589, polr_589, 3,
"CCSD polarizability @ 589nm") #TEST
assert psi4.compare_values(pol_355, polr_355, 3,
"CCSD polarizability @ 355nm") #TEST
assert psi4.compare_values(rotlen_589, rotlenr_589, 3,
"CCSD rotation @ 589nm in length gauge") #TEST
assert psi4.compare_values(
rotvel_589, rotvelr_589, 3,
"CCSD rotation @ 589nm in velocity gauge") #TEST
assert psi4.compare_values(
rotmvg_589, rotmvgr_589, 3,
"CCSD rotation @ 589nm in modified velocity gauge") #TEST
assert psi4.compare_values(rotlen_355, rotlenr_355, 3,
"CCSD rotation @ 355nm in length gauge") #TEST
assert psi4.compare_values(
rotvel_355, rotvelr_355, 3,
"CCSD rotation @ 355nm in velocity gauge") #TEST
assert psi4.compare_values(
rotmvg_355, rotmvgr_355, 3,
"CCSD rotation @ 355nm in modified velocity gauge") #TEST
assert psi4.compare_values(
polt_589, wfn.variable("CCSD DIPOLE POLARIZABILITY TENSOR @ 589NM"), 3,
"CCSD polarizability tensor @ 589nm") #TEST
assert psi4.compare_values(
polt_355, wfn.variable("CCSD DIPOLE POLARIZABILITY TENSOR @ 355NM"), 3,
"CCSD polarizability tensor @ 355nm") #TEST
assert psi4.compare_arrays(
rottvel_0, wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 0NM"), 3,
"CCSD optrot tensor @ 0NM in velocity guage") #TEST
assert psi4.compare_arrays(
rottlen_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (LEN) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in length guage") #TEST
assert psi4.compare_arrays(
rottvel_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in velocity guage") #TEST
assert psi4.compare_arrays(
rottmvg_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (MVG) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in modified velocity guage") #TEST
def test_cc_roa():
# three tensors for ROA (polar, optrot, and dip-quad)
mol = psi4.geometry("""
O -0.028962160801 -0.694396279686 -0.049338350190
O 0.028962160801 0.694396279686 -0.049338350190
H 0.350498145881 -0.910645626300 0.783035421467
H -0.350498145881 0.910645626300 0.783035421467
symmetry c1
noreorient
""")
psi4.set_options({"basis": "cc-pVDZ"})
omega = [589, 'nm']
psi4.set_options({
'gauge': 'both',
'omega': omega,
'freeze_core': True,
'r_convergence': 10
})
e, wfn = psi4.properties('CCSD',
properties=["roa_tensor"],
return_wfn=True)
polt_589 = np.array([[5.44184081e+00, -8.30270852e-01, 9.39878004e-14],
[-8.30270852e-01, 1.27518991e+01, -6.94720506e-14],
[9.39878004e-14, -6.94720506e-14, 8.57516214e+00]])
rottvel_0 = np.array([[3.63702792e-01, -3.62754886e-01, -3.37227243e-14],
[-1.16320923e-01, 1.20784891e-02, 1.76483272e-14],
[1.90062651e-14, -2.33369227e-15, -3.92022202e-01]])
rottlen_589 = np.array([[1.41679366e-01, -7.07140738e-02, -2.26060131e-14],
[-2.72710108e-01, 1.28928522e-03, 1.01578936e-14],
[3.74236371e-14, 3.88522300e-15, -1.27276912e-01]])
rottvel_589 = np.array([[3.75624000e-01, -3.74245928e-01, -3.61489832e-14],
[-1.39409385e-01, 1.26867931e-02, 1.94630079e-14],
[2.33993608e-14, -1.61361648e-15,
-4.01726048e-01]])
rottmvg_589 = np.array([[1.19212077e-02, -1.14910412e-02, -2.42625886e-15],
[-2.30884623e-02, 6.08303937e-04, 1.81468070e-15],
[4.39309571e-15, 7.20075789e-16, -9.70384612e-03]])
quad0 = np.array([[[-2.52229282e-14, -4.33846468e-13, 3.90176525e+00],
[-4.33846468e-13, -6.81906994e-15, -5.83659009e+00],
[3.90176525e+00, -5.83659009e+00, 3.18177152e-14]],
[[1.20834634e-13, 6.99638702e-14, -2.37995874e+00],
[6.99638702e-14, -1.17603861e-13, 6.85651590e+00],
[-2.37995874e+00, 6.85651590e+00, -3.99609068e-15]],
[[-4.55024365e+00, -5.30335671e+00, 1.65990108e-13],
[-5.30335671e+00, -1.35415335e+00, -8.75522529e-13],
[1.65990108e-13, -8.75522529e-13, 5.90439700e+00]]])
assert psi4.compare_values(
polt_589, wfn.variable("CCSD DIPOLE POLARIZABILITY TENSOR @ 589NM"), 3,
"CCSD polarizability tensor @ 589nm") #TEST
assert psi4.compare_arrays(
rottvel_0, wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 0NM"), 3,
"CCSD optrot tensor @ 0NM in velocity guage") #TEST
assert psi4.compare_arrays(
rottlen_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (LEN) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in length guage") #TEST
assert psi4.compare_arrays(
rottvel_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (VEL) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in velocity guage") #TEST
assert psi4.compare_arrays(
rottmvg_589,
wfn.variable("CCSD OPTICAL ROTATION TENSOR (MVG) @ 589NM"), 3,
"CCSD optrot tensor @ 589NM in modified velocity guage") #TEST
assert psi4.compare_values(
quad0, wfn.variable("CCSD QUADRUPOLE POLARIZABILITY TENSOR @ 589NM"),
3, "CCSD quadrupole tensor @ 589nm") #TEST
psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][0], 3,
"DIPOLE X") #TEST
psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][1], 3,
"DIPOLE Y") #TEST
psi4.compare_values(linear_dipole,
json_ret["properties"]["scf_dipole_moment"][2], 3,
"DIPOLE Z") #TEST
dist = np.linalg.norm(
np.array(json_ret["molecule"]["geometry"])[:3] -
np.array(np.array(json_ret["molecule"]["geometry"])[3:])) #TEST
psi4.compare_values(1.732, dist, 4, "HF Bond Distance") #TEST
json_ret = psi4.json_wrapper.run_json(noorient_data)
# Orients to Z axis
psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST
psi4.compare_values(expected_return_result, json_ret["return_result"], 5,
"Return Value") #TEST
psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][0], 3,
"DIPOLE X") #TEST
psi4.compare_values(linear_dipole,
json_ret["properties"]["scf_dipole_moment"][1], 3,
"DIPOLE Y") #TEST
psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][2], 3,
"DIPOLE Z") #TEST
psi4.compare_arrays([0.0, 0.0, 0.0], json_ret["molecule"]["geometry"][:3], 3,
"H Position") #TEST
psi4.compare_arrays([0.0, 1.732, 0.0], json_ret["molecule"]["geometry"][3:], 3,
"F Position") #TEST
psi4.compare_integers(True, json_ret.success, "JSON Success") #TEST
psi4.compare_values(expected_return_result, json_ret.return_result, 5,
"Return Value") #TEST
psi4.compare_values(0.0, json_ret.properties.scf_dipole_moment[0], 3,
"DIPOLE X") #TEST
psi4.compare_values(0.0, json_ret.properties.scf_dipole_moment[1], 3,
"DIPOLE Y") #TEST
psi4.compare_values(linear_dipole, json_ret.properties.scf_dipole_moment[2], 3,
"DIPOLE Z") #TEST
dist = np.linalg.norm(json_ret.molecule.geometry[0] -
json_ret.molecule.geometry[1]) #TEST
psi4.compare_values(1.732, dist, 4, "HF Bond Distance") #TEST
json_ret = psi4.schema_wrapper.run_qcschema(noorient_data)
# Orients to Z axis
psi4.compare_integers(True, json_ret.success, "JSON Success") #TEST
psi4.compare_values(expected_return_result, json_ret.return_result, 5,
"Return Value") #TEST
psi4.compare_values(0.0, json_ret.properties.scf_dipole_moment[0], 3,
"DIPOLE X") #TEST
psi4.compare_values(linear_dipole, json_ret.properties.scf_dipole_moment[1], 3,
"DIPOLE Y") #TEST
psi4.compare_values(0.0, json_ret.properties.scf_dipole_moment[2], 3,
"DIPOLE Z") #TEST
psi4.compare_arrays([0.0, 0.0, 0.0], json_ret.molecule.geometry[0], 3,
"H Position") #TEST
psi4.compare_arrays([0.0, 1.732, 0.0], json_ret.molecule.geometry[1], 3,
"F Position") #TEST
DiskJK.initialize()
DiskJK.print_header()
# symm_JK
psi4.set_options({"SCF_TYPE" : "MEM_DF"})
MemJK = psi4.core.JK.build_JK(primary, aux)
MemJK.initialize()
MemJK.print_header()
# add C matrices
for Cleft, Cright in C_vectors:
DiskJK.C_left_add(Cleft)
MemJK.C_left_add(Cleft)
DiskJK.C_right_add(Cright)
MemJK.C_right_add(Cright)
# compute
DiskJK.compute()
MemJK.compute()
# get integrals
DiskJK_ints = [DiskJK.J(), DiskJK.K()]
MemJK_ints = [MemJK.J(), MemJK.K()]
# compare
for j, t in enumerate(['J', 'K']):
for i in range(len(DiskJK_ints[0])):
psi4.compare_arrays(np.asarray(DiskJK_ints[j][i]),
np.asarray(MemJK_ints[j][i]), 9, t + str(i))
noorient_data["molecule"]["fix_com"] = True # Write expected output expected_return_result = -100.0194177509218 linear_dipole = 1.948993625469663 json_ret = psi4.json_wrapper.run_json(json_data) # Orients to Z axis psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST psi4.compare_values(expected_return_result, json_ret["return_result"], 5, "Return Value") #TEST psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][0], 3, "DIPOLE X") #TEST psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][1], 3, "DIPOLE Y") #TEST psi4.compare_values(linear_dipole, json_ret["properties"]["scf_dipole_moment"][2], 3, "DIPOLE Z") #TEST dist = np.linalg.norm(np.array(json_ret["molecule"]["geometry"])[:3] - np.array(np.array(json_ret["molecule"]["geometry"])[3:])) #TEST psi4.compare_values(1.732, dist, 4, "HF Bond Distance") #TEST json_ret = psi4.json_wrapper.run_json(noorient_data) # Orients to Z axis psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST psi4.compare_values(expected_return_result, json_ret["return_result"], 5, "Return Value") #TEST psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][0], 3, "DIPOLE X") #TEST psi4.compare_values(linear_dipole, json_ret["properties"]["scf_dipole_moment"][1], 3, "DIPOLE Y") #TEST psi4.compare_values(0.0, json_ret["properties"]["scf_dipole_moment"][2], 3, "DIPOLE Z") #TEST psi4.compare_arrays([0.0, 0.0, 0.0], json_ret["molecule"]["geometry"][:3], 3, "H Position") #TEST psi4.compare_arrays([0.0, 1.732, 0.0], json_ret["molecule"]["geometry"][3:], 3, "F Position") #TEST
0.0,
-0.043039786289375104,
0.02979887048056895,
0.0,
0.043039786289375104,
0.02979887048056895
]
expected_properties = {
"calcinfo_nbasis": 24,
"calcinfo_nmo": 24,
"calcinfo_nalpha": 5,
"calcinfo_nbeta": 5,
"calcinfo_natom": 3,
"scf_one_electron_energy": -122.4452968291507,
"scf_two_electron_energy": 37.62243738251799,
"nuclear_repulsion_energy": 8.80146206062943,
"scf_total_energy": -76.02139738600329,
"return_energy": -76.02139738600329
}
json_ret = psi4.json_wrapper.run_json(json_data)
with open("output.json", "w") as ofile:
json.dump(json_ret, ofile, indent=2)
psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST
psi4.compare_arrays(expected_return_result, json_ret["return_result"], 5, "Return Value") #TEST
for k in expected_properties.keys(): #TEST
psi4.compare_values(expected_properties[k], json_ret["properties"][k], 5, k.upper()) #TEST
dfh.transpose("Qmo4", (1, 0, 2))
dfh.transpose("Qmo5", (1, 2, 0))
dfh.transpose("Qmo6", (1, 2, 0))
# grab transformed integrals
dfh_Qmo = []
dfh_Qmo.append(dfh.get_tensor("Qmo1"))
dfh_Qmo.append(dfh.get_tensor("Qmo2"))
dfh_Qmo.append(dfh.get_tensor("Qmo3"))
dfh_Qmo.append(dfh.get_tensor("Qmo4"))
dfh_Qmo.append(dfh.get_tensor("Qmo5"))
dfh_Qmo.append(dfh.get_tensor("Qmo6"))
# am i right?
for i in range(6):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo[i], 9,
"STORE with some tranposes - on disk") #TEST
# try again without tranposing --
# untranspose python side
Qmo[2] = np.einsum("pQq->Qpq", Qmo[2])
Qmo[3] = np.einsum("pQq->Qpq", Qmo[3])
Qmo[4] = np.einsum("pqQ->Qpq", Qmo[4])
Qmo[5] = np.einsum("pqQ->Qpq", Qmo[5])
# invoke transformations
dfh.transform()
# grab transformed integrals
dfh_Qmo[0] = (dfh.get_tensor("Qmo1"))
dfh_Qmo[1] = (dfh.get_tensor("Qmo2"))
dfh_Qmo[2] = (dfh.get_tensor("Qmo3"))
expected_properties = {
"calcinfo_nbasis": 13,
"calcinfo_nmo": 13,
"calcinfo_nalpha": 5,
"calcinfo_nbeta": 5,
"calcinfo_natom": 3,
"scf_one_electron_energy": -122.27509111304202,
"scf_two_electron_energy": 37.49348718008625,
"nuclear_repulsion_energy": 8.80146206062943,
"scf_total_energy": -75.98014187232634,
"return_energy": -75.98014187232634
}
json_ret = psi4.json_wrapper.run_json(json_data)
with open("output.json", "w") as ofile: #TEST
json.dump(json_ret, ofile, indent=2) #TEST
psi4.compare_integers(True, json_ret["success"], "JSON Success") #TEST
psi4.compare_strings("qc_schema_output", json_ret["schema_name"],
"Schema Name") #TEST
for k in expected_return_result.keys(): #TEST
psi4.compare_arrays(expected_return_result[k],
json_ret["return_result"][k], 5,
"Result: " + k.upper()) #TEST
for k in expected_properties.keys(): #TEST
psi4.compare_values(expected_properties[k], json_ret["properties"][k], 5,
k.upper()) #TEST
psi4.set_output_file("output.dat", False)
# Generate JSON data
json_data = {}
json_data["molecule"] = """He 0 0 0\n--\nHe 0 0 1"""
json_data["driver"] = "gradient"
json_data["method"] = 'SCF'
json_data["kwargs"] = {}
json_data["options"] = {"BASIS": "STO-3G"}
json_data["return_output"] = True
psi4.json_wrapper.run_json(json_data)
psi4.compare_strings("STO-3G", json_data["options"]["BASIS"],
"Options test") #TEST
psi4.compare_integers(True, json_data["success"], "Success") #TEST
bench_energy = -5.433191881443323 #TEST
cenergy = json_data["variables"]["CURRENT ENERGY"] #TEST
psi4.compare_values(bench_energy, cenergy, 6, "SCF CURRENT ENERGY") #TEST
bench_gradient = np.array([[0.0, 0.0, 0.4206844], [0.0, 0.0, -0.4206844]])
cgradient = psi4.core.Matrix.from_serial(json_data["return_value"]) #TEST
psi4.compare_arrays(bench_gradient, cgradient.np, 4, "SCF RETURN_VALUE") #TEST
return_wfn = "return_wfn" not in json_data["kwargs"] #TEST
psi4.compare_integers(True, return_wfn, "Immutable input") #TEST
with open("output.dat", "w") as f:
f.write(json_data["raw_output"])
dfh_Qmo[ind][k, :, :] = np.asarray(
dfh.get_tensor(i, [k, k + 1],
[0, sizes[j[1]]],
[0, naux]))
else:
for ind, i in enumerate(transformations):
dfh_Qmo.append(np.asarray(dfh.get_tensor(i)))
test_string = 'Alg: ' + method + ' + ' + form + ' core (AOs, MOs, met): ['
test_string += str(AO_core) + ', ' + str(
MO_core) + ', ' + str(hold_met) + ']'
print(test_string)
# am i right?
for i in range(ntransforms):
if (form == 'pqQ'):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]),
Qmo_pqQ[i], 9, test_string)
elif (form == 'pQq'):
psi4.compare_arrays(np.asarray(dfh_Qmo[i]),
Qmo_pQq[i], 9, test_string)
else:
psi4.compare_arrays(np.asarray(dfh_Qmo[i]), Qmo[i],
9, test_string)
del dfh
# TODO:
# test tensor slicing grabs
# test pQq and pqQ builds for store and direct0
Ks.append(psi4.core.Matrix(nbf,nbf))
Ks.append(psi4.core.Matrix(nbf,nbf))
Ks.append(psi4.core.Matrix(nbf,nbf))
Ks.append(psi4.core.Matrix(nbf,nbf))
Ks.append(psi4.core.Matrix(nbf,nbf))
# invoke J/K build
dfh.build_JK(Cleft, Cright, Js, Ks)
# practice J
Q = np.zeros((naux))
D = np.dot(np.asarray(C1), np.asarray(C1).T)
# am i right?
for i in range(len(Cright)):
psi4.compare_arrays(np.asarray(Ks[i]), K[i], 9, "K builds - STORE" ) #TEST
#for i in range(len(Cright)):
# print (np.linalg.norm(np.asarray(Js[i]).ravel()[:naux]-Qs[i])) #TEST
Ds = []
for i in range(len(Cright)):
Ds.append(np.dot(np.asarray(Cleft[i]), np.asarray(Cright[i]).T))
print (np.linalg.norm(np.asarray(Js[i]) -Ds[i]))
#for i in range(naux):
# if (i == 80):
# print ("YUP")
# print (np.linalg.norm(np.asarray(Js[0]).ravel()[i] -Qs[0][i]))
#psi4.compare_arrays(np.asarray(Js[i]), J[i], 9, "J builds - STORE" ) #TEST
