def run(mm):
tester = psr.PyTester("Testing Building of the DF coefficients")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_3C2E", "DF_INTS_KEY", "LIBINT_3C2E")
mm.change_option("PSR_Metric", "METRIC_INTS_KEY", "LIBINT_Metric")
bs = wf.system.get_basis_set("PRIMARY")
dfcoef = mm.get_module("PSR_DFCoef", 0)
ints = dfcoef.calculate("???", 0, wf, bs, bs, bs)[0]
dims = ints.sizes()
flat_ints = []
for i in range(dims[0]):
for j in range(dims[1]):
for k in range(dims[2]):
flat_ints.append(ints.get_value([i, j, k]))
tester.test_double_vector("d^Q_{mn}", flat_ints, corr_ints)
dfcoef.options().change("FORCE_CACHE", True)
ints = dfcoef.calculate("???", 0, wf, bs, bs, bs)[0]
dims = ints.sizes()
flat_ints = []
for i in range(dims[0]):
for j in range(dims[1]):
for k in range(dims[2]):
flat_ints.append(ints.get_value([i, j, k]))
tester.test_double_vector("Cacheing d^Q_{mn} works", flat_ints, corr_ints)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing Building of the core Hamiltonian")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_GAV","V_INTS_KEY","LIBINT_V")
mm.change_option("PSR_GAT","T_INTS_KEY","LIBINT_T")
mm.change_option("PSR_S","S_INTS_KEY","LIBINT_S")
mm.change_option("PSR_GA_JK","ERI_KEY","LIBINT_ERI")
mm.change_option("PSR_Sieve","ERI_INTS_KEY","LIBINT_ERI")
mm.change_option("PSR_DCore","H_KEY","PSR_GAH")
bs=wf.system.get_basis_set("PRIMARY")
guess=mm.get_module("PSR_DCore",0).deriv(0,wf)[0]
T_maker=mm.get_module("PSR_GAG",0)
for x in [False,True]:
T_maker.options().change("FORCE_CACHE",x)
_T=T_maker.calculate("???",0,guess,bs,bs)
dims=_T[0].sizes()
T=np.ndarray(dims)
for i in range(dims[0]):
for j in range(dims[1]):
T[i,j]=_T[0].get_value([i,j])
tester.test_double_vector("G",T.flatten(),corr_G)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester(
"Testing Building of the nuclear-electron attraction energy matrix")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V", "V_INTS_KEY", "LIBINT_V")
bs = wf.system.get_basis_set("PRIMARY")
V_maker = mm.get_module("PSR_V", 0)
V = V_maker.calculate("???", 0, wf, bs, bs)
V = np.array(V[0].get_matrix())
tester.test_double_vector("nuclear-electron attraction", V.flatten(),
corr_T)
V_maker.options().change("FORCE_CACHE", True)
V = V_maker.calculate("", 0, wf, bs, bs)
V = np.array(V[0].get_matrix())
tester.test_double_vector("nuclear-electron attraction cache works",
V.flatten(), corr_T)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing JK builder")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V","V_INTS_KEY","LIBINT_V")
mm.change_option("PSR_T","T_INTS_KEY","LIBINT_T")
mm.change_option("PSR_S","S_INTS_KEY","LIBINT_S")
mm.change_option("PSR_JK","ERI_KEY","LIBINT_ERI")
mm.change_option("PSR_Sieve","ERI_INTS_KEY","LIBINT_ERI")
mm.change_option("PSR_Metric","METRIC_INTS_KEY","LIBINT_Metric")
mm.change_option("PSR_3C2E","DF_INTS_KEY","LIBINT_3C2E")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
bs=wf.system.get_basis_set("PRIMARY")
guess=mm.get_module("PSR_DCore",0).deriv(0,wf)[0]
Fmod=mm.get_module("PSR_F",0)
for x in [False,True]:
Fmod.options().change("FORCE_CACHE",x)
F=Fmod.calculate("???",0,guess,bs,bs)
F=np.array(F[0].get_matrix())
tester.test_double_vector("F",F.flatten(),corr_F)
def run(mm):
tester = psr.PyTester("Testing Building of the 2 electron, 3 center integrals")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_3C2E","DF_INTS_KEY","LIBINT_3C2E")
bs=wf.system.get_basis_set("PRIMARY")
da_builder=mm.get_module("PSR_3C2E",0)
ints=da_builder.calculate("???",0,wf,bs,bs,bs)[0]
dims=ints.sizes()
flat_ints=[]
for i in range(dims[0]):
for j in range(dims[1]):
for k in range(dims[2]):
flat_ints.append(ints.get_value([i,j,k]))
tester.test_double_vector("3 center, 2 e matrix",flat_ints,corr_ints)
da_builder.options().change("FORCE_CACHE",True)
ints=da_builder.calculate("???",0,wf,bs,bs,bs)[0]
dims=ints.sizes()
flat_ints=[]
for i in range(dims[0]):
for j in range(dims[1]):
for k in range(dims[2]):
flat_ints.append(ints.get_value([i,j,k]))
tester.test_double_vector("Cache 3 center, 2 e matrix",flat_ints,corr_ints)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing Building of the orthogonalizing matrix")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_S", "S_INTS_KEY", "LIBINT_S")
bs = wf.system.get_basis_set("PRIMARY")
X_maker = mm.get_module("PSR_X", 0)
X = X_maker.calculate("???", 0, wf, bs, bs)
X, Xinv = np.array(X[0].get_matrix()), np.array(X[1].get_matrix())
#Only defined up to a sign...
for i, j in zip(X.flatten(), corr_X):
desc = "X: " + str(i) + "," + str(j)
tester.test_double(desc, abs(float(i)), abs(j))
for i, j in zip(Xinv.flatten(), corr_Xinv):
desc = "Xinv: " + str(i) + "," + str(j)
tester.test_double(desc, abs(float(i)), abs(j))
X_maker.options().change("FORCE_CACHE", True)
X = X_maker.calculate("???", 0, wf, bs, bs)
X, Xinv = np.array(X[0].get_matrix()), np.array(X[1].get_matrix())
#Only defined up to a sign...
for i, j in zip(X.flatten(), corr_X):
desc = "Cache X: " + str(i) + "," + str(j)
tester.test_double(desc, abs(float(i)), abs(j))
for i, j in zip(Xinv.flatten(), corr_Xinv):
desc = "Cache Xinv: " + str(i) + "," + str(j)
tester.test_double(desc, abs(float(i)), abs(j))
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing the Pulsar-ForceManII API")
wfn = psr.Wavefunction()
wfn.system = psr.make_system("""
0 1
O 0.0 0.0 0.0
H 1.0 0.0 0.0
H 0.0 1.0 0.0
""")
atom_types = [2001, 2002, 2002]
ff = "AMBER99"
model = "HARMONICOSCILLATOR"
coord = "BOND"
mod_key = "H.O."
mm.load_module("fmanii", "FFTerm", mod_key)
mm.load_module("fmanii", "FFCharges", "Chgs")
mm.change_option(mod_key, "FORCE_FIELD", ff)
mm.change_option(mod_key, "ATOM_TYPES", atom_types)
mm.change_option("Chgs", "FORCE_FIELD", ff)
mm.change_option("Chgs", "ATOM_TYPES", atom_types)
mm.change_option(mod_key, "MODEL_NAME", model)
mm.change_option(mod_key, "COORD_NAME", coord)
my_mod = mm.get_module(mod_key, 0)
newwfn, deriv = my_mod.deriv(0, wfn)
tester.test_double("H.O. Bond stretch", deriv[0], 0.0032286707269852354)
my_mod = mm.get_module("Chgs", 0)
chgs = my_mod.calculate(0, wfn)
corr_chgs = [-0.834, 0.417, 0.417]
for q1, q2 in zip(chgs, corr_chgs):
tester.test_double("Charge", q1, q2)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester(
"Testing Building of the nuclear-electron attraction matrix")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_GAV", "V_INTS_KEY", "LIBINT_V")
bs = wf.system.get_basis_set("PRIMARY")
T_maker = mm.get_module("PSR_GAV", 0)
for x in [False, True]:
T_maker.options().change("FORCE_CACHE", x)
_T = T_maker.calculate("???", 0, wf, bs, bs)
dims = _T[0].sizes()
T = np.ndarray(dims)
for i in range(dims[0]):
for j in range(dims[1]):
T[i, j] = _T[0].get_value([i, j])
tester.test_double_vector("V", T.flatten(), corr_T)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing Building of the orthogonalizer matrix")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_GAS","S_INTS_KEY","LIBINT_S")
bs=wf.system.get_basis_set("PRIMARY")
T_maker=mm.get_module("PSR_GAX",0)
for x in [False,True]:
T_maker.options().change("FORCE_CACHE",x)
_T=T_maker.calculate("???",0,wf,bs,bs)
dims=_T[0].sizes()
for i in range(dims[0]):
for j in range(dims[1]):
x=_T[0].get_value([i,j])
xcorr=corr_X[i*7+j]
name="X "+str(x)+" "+str(xcorr)
tester.test_double(name,abs(x),abs(xcorr))
xinv=_T[1].get_value([i,j])
xinvcorr=corr_Xinv[i*7+j]
name="Xinv "+str(xinv)+" "+str(xinvcorr)
tester.test_double(name,abs(xinv),abs(xinvcorr))
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing JK builder")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V","V_INTS_KEY","LIBINT_V")
mm.change_option("PSR_T","T_INTS_KEY","LIBINT_T")
mm.change_option("PSR_S","S_INTS_KEY","LIBINT_S")
mm.change_option("PSR_JK","ERI_KEY","LIBINT_ERI")
mm.change_option("PSR_Sieve","ERI_INTS_KEY","LIBINT_ERI")
mm.change_option("PSR_Metric","METRIC_INTS_KEY","LIBINT_Metric")
mm.change_option("PSR_3C2E","DF_INTS_KEY","LIBINT_3C2E")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
bs=wf.system.get_basis_set("PRIMARY")
guess=mm.get_module("PSR_DCore",0).deriv(0,wf)[0]
JKmod=mm.get_module("PSR_JK",0)
JK=JKmod.calculate("???",0,guess,bs,bs)
J=np.array(JK[0].get_matrix())
K=np.array(JK[1].get_matrix())
tester.test_double_vector("J",J.flatten(),corr_J)
tester.test_double_vector("K",K.flatten(),corr_K)
JKmod.options().change("FORCE_CACHE",True)
JK=JKmod.calculate("???",0,guess,bs,bs)
J=np.array(JK[0].get_matrix())
K=np.array(JK[1].get_matrix())
tester.test_double_vector("Cache J",J.flatten(),corr_J)
tester.test_double_vector("Cache K",K.flatten(),corr_K)
#I'm lazy and am going to use the STO-3G for the fitting basis too
guess.system=psr.apply_single_basis("FITTING","sto-3g",guess.system)
JKmod=mm.get_module("PSR_DFJK",0)
JK=JKmod.calculate("",0,guess,bs,bs)
J=np.array(JK[0].get_matrix())
K=np.array(JK[1].get_matrix())
tester.test_double_vector("DF-J",J.flatten(),corr_J_DF)
tester.test_double_vector("DF-K",K.flatten(),corr_K_DF)
JKmod.options().change("FORCE_CACHE",True)
JK=JKmod.calculate("",0,guess,bs,bs)
J=np.array(JK[0].get_matrix())
K=np.array(JK[1].get_matrix())
tester.test_double_vector("Cache DF-J",J.flatten(),corr_J_DF)
tester.test_double_vector("Cache DF-K",K.flatten(),corr_K_DF)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing JK builder")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V", "V_INTS_KEY", "LIBINT_V")
mm.change_option("PSR_T", "T_INTS_KEY", "LIBINT_T")
mm.change_option("PSR_S", "S_INTS_KEY", "LIBINT_S")
mm.change_option("PSR_GA_JK", "ERI_KEY", "LIBINT_ERI")
mm.change_option("PSR_Sieve", "ERI_INTS_KEY", "LIBINT_ERI")
mm.change_option("PSR_Metric", "METRIC_INTS_KEY", "LIBINT_Metric")
mm.change_option("PSR_3C2E", "DF_INTS_KEY", "LIBINT_3C2E")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
bs = wf.system.get_basis_set("PRIMARY")
guess = mm.get_module("PSR_DCore", 0).deriv(0, wf)[0]
JKmod = mm.get_module("PSR_GA_JK", 0)
for x in [False, True]:
JKmod.options().change("FORCE_CACHE", x)
JK = JKmod.calculate("???", 0, guess, bs, bs)
dims = JK[0].sizes()
J = np.ndarray(dims)
K = np.ndarray(dims)
for i in range(dims[0]):
for j in range(dims[1]):
J[i, j] = JK[0].get_value([i, j])
K[i, j] = JK[1].get_value([i, j])
tester.test_double_vector("J", J.flatten(), corr_J)
tester.test_double_vector("K", K.flatten(), corr_K)
#JKmod=mm.get_module("PSR_DFJK",0)
#JK=JKmod.calculate("",0,guess,bs,bs)
#J=np.array(JK[0].get_matrix())
#K=np.array(JK[1].get_matrix())
#tester.test_double_vector("DF-J",J.flatten(),corr_J_DF)
#tester.test_double_vector("DF-K",K.flatten(),corr_K_DF)
#JKmod.options().change("FORCE_CACHE",True)
#JK=JKmod.calculate("",0,guess,bs,bs)
#J=np.array(JK[0].get_matrix())
#K=np.array(JK[1].get_matrix())
#tester.test_double_vector("Cache DF-J",J.flatten(),corr_J_DF)
#tester.test_double_vector("Cache DF-K",K.flatten(),corr_K_DF)
#tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing core guess")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V","V_INTS_KEY","LIBINT_V")
mm.change_option("PSR_T","T_INTS_KEY","LIBINT_T")
mm.change_option("PSR_S","S_INTS_KEY","LIBINT_S")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
bs=wf.system.get_basis_set("PRIMARY")
guess=mm.get_module("PSR_DCore",0).deriv(0,wf)[0]
temp=guess.opdm.get(psr.Irrep.A,psr.Spin.alpha).get_matrix()
D=np.array(temp)
tester.test_double_vector("Core Guess",D.flatten(),corr_D)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing Building of the overlap matrix")
wf=psr.make_wf("sto-3g","""
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_S","S_INTS_KEY","LIBINT_S")
bs=wf.system.get_basis_set("PRIMARY")
S_maker=mm.get_module("PSR_S",0)
S=S_maker.calculate("???",0,wf,bs,bs)
S=np.array(S[0].get_matrix())
tester.test_double_vector("Overlap matrix",S.flatten(),corr_S)
S_maker.options().change("FORCE_CACHE",True)
S = S_maker.calculate("",0,wf,bs,bs)
S=np.array(S[0].get_matrix())
tester.test_double_vector("Overlap matrix cache works",S.flatten(),corr_S)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester("Testing pulsar SCF")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_V", "V_INTS_KEY", "LIBINT_V")
mm.change_option("PSR_T", "T_INTS_KEY", "LIBINT_T")
mm.change_option("PSR_S", "S_INTS_KEY", "LIBINT_S")
mm.change_option("PSR_JK", "ERI_KEY", "LIBINT_ERI")
mm.change_option("PSR_Sieve", "ERI_INTS_KEY", "LIBINT_ERI")
wf = psr.make_wf(
"aug-cc-pvdz", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
guess = mm.get_module("PSR_DCore", 0).deriv(0, wf)[0]
#TODO test wf
egy = mm.get_module("PSR_SCF", 0).deriv(0, guess)[1][0]
tester.test_double("RHF Energy", -76.00335405845436, egy)
tester.print_results()
return tester.nfailed()
def run(mm):
tester = psr.PyTester(
"Testing Building of the density fitting metric matrix")
wf = psr.make_wf(
"sto-3g", """
O 0.0 -0.07579 0.0
H 0.86681 0.60144 0.0
H -0.86681 0.60144 0.0
""")
mm.load_supermodule("pulsar_libint")
mm.load_supermodule("pulsar_scf")
mm.change_option("PSR_Metric", "METRIC_INTS_KEY", "LIBINT_Metric")
bs = wf.system.get_basis_set("PRIMARY")
metric_builder = mm.get_module("PSR_Metric", 0)
metric = metric_builder.calculate("???", 0, wf, bs, bs)
metric = np.array(metric[0].get_matrix())
tester.test_double_vector("Metric matrix", metric.flatten(), corr_metric)
metric_builder.options().change("FORCE_CACHE", True)
metric = metric_builder.calculate("???", 0, wf, bs, bs)
metric = np.array(metric[0].get_matrix())
tester.test_double_vector("Metric matrix cache works", metric.flatten(),
corr_metric)
tester.print_results()
return tester.nfailed()