def test_gen(self):
ewald = ls.Ewald([0.7, 0.7, 0.7], [0.2, 0.1, 0.05])
self.assertTrue(len(ewald.scales) == 3)
self.assertTrue(len(ewald.omegas) == 3)
self.assertTrue(ewald.scales[0] == 0.7)
self.assertTrue(ewald.scales[1] == 0.7)
self.assertTrue(ewald.scales[2] == 0.7)
self.assertTrue(ewald.omegas[0] == 0.2)
self.assertTrue(ewald.omegas[1] == 0.1)
self.assertTrue(ewald.omegas[2] == 0.05)
self.assertFalse(ewald.is_coulomb)
self.assertFalse(ewald.is_sr)
self.assertFalse(ewald.is_lr)
with self.assertRaises(IndexError):
ewald.scales[3]
with self.assertRaises(IndexError):
ewald.omegas[3]
with self.assertRaises(RuntimeError):
ewald.sr_scale
with self.assertRaises(RuntimeError):
ewald.sr_omega
with self.assertRaises(RuntimeError):
ewald.lr_scale
with self.assertRaises(RuntimeError):
ewald.lr_omega
def test_fake_sr(self):
ewald = ls.Ewald([-0.7, 0.7], [-1.0, -1.0])
self.assertTrue(len(ewald.scales) == 2)
self.assertTrue(len(ewald.omegas) == 2)
self.assertTrue(ewald.scales[0] == -0.7)
self.assertTrue(ewald.scales[1] == 0.7)
self.assertTrue(ewald.omegas[0] == -1.0)
self.assertTrue(ewald.omegas[1] == -1.0)
self.assertFalse(ewald.is_coulomb)
self.assertFalse(ewald.is_sr)
self.assertFalse(ewald.is_lr)
with self.assertRaises(IndexError):
ewald.scales[2]
with self.assertRaises(IndexError):
ewald.omegas[2]
with self.assertRaises(RuntimeError):
ewald.sr_scale
with self.assertRaises(RuntimeError):
ewald.sr_omega
with self.assertRaises(RuntimeError):
ewald.lr_scale
with self.assertRaises(RuntimeError):
ewald.lr_omega
def test_lr(self):
ewald = ls.Ewald([0.7], [0.3])
self.assertTrue(len(ewald.scales) == 1)
self.assertTrue(len(ewald.omegas) == 1)
self.assertTrue(ewald.scales[0] == 0.7)
self.assertTrue(ewald.omegas[0] == 0.3)
self.assertFalse(ewald.is_coulomb)
self.assertFalse(ewald.is_sr)
self.assertTrue(ewald.is_lr)
with self.assertRaises(IndexError):
ewald.scales[1]
with self.assertRaises(IndexError):
ewald.omegas[1]
with self.assertRaises(RuntimeError):
ewald.sr_scale
with self.assertRaises(RuntimeError):
ewald.sr_omega
self.assertTrue(ewald.lr_scale == 0.7)
self.assertTrue(ewald.lr_omega == 0.3)
def test_coulomb(self):
ewald = ls.Ewald([1.0], [-1.0])
self.assertTrue(len(ewald.scales) == 1)
self.assertTrue(len(ewald.omegas) == 1)
self.assertTrue(ewald.scales[0] == 1.0)
self.assertTrue(ewald.omegas[0] == -1.0)
self.assertTrue(ewald.is_coulomb)
self.assertFalse(ewald.is_sr)
self.assertFalse(ewald.is_lr)
with self.assertRaises(IndexError):
ewald.scales[1]
with self.assertRaises(IndexError):
ewald.omegas[1]
with self.assertRaises(RuntimeError):
ewald.sr_scale
with self.assertRaises(RuntimeError):
ewald.sr_omega
with self.assertRaises(RuntimeError):
ewald.lr_scale
with self.assertRaises(RuntimeError):
ewald.lr_omega
def run_mix_basis_4(run_dir):
tol = 1.0E-12
res = ls.ResourceList.build(1024**2,1024**2)
ewald = ls.Ewald([1.0], [-1.0])
xyz_list = ['h2o', 'nh3', 'ch4', 'c2h4']
bas_list = ['sto-3g', '6-31gs', 'cc-pvdz', '3-21g']
# molecule list
mol = []
for i, xyz_i in enumerate(xyz_list):
mol.append(ls.Molecule.from_xyz_file(run_dir + xyz_i + '.xyz'))
molC = ls.Molecule.concatenate(mol,0,1)
xyzc = molC.xyzZ
print("")
print(" Task: J,K")
print("\n %-12s%-12s%-12s%-12s%15s" % \
("Mol1", "Mol2", "Mol3", "Mol4", "Max_Diff"))
print(" %s" % ('-'*63))
# reference npz file
npzfile = run_dir + "mix"
for xyzname in xyz_list:
npzfile += "_" + xyzname
npzfile += ".npz"
refs = np.load(npzfile)
# basis list
bas_list_2 = bas_list + bas_list
for ind in range(len(bas_list)):
new_bas_list = bas_list_2[ind:ind+len(xyz_list)]
bas = []
N = []
for i, bas_i in enumerate(new_bas_list):
bas.append(ls.Basis.from_gbs_file(mol[i], bas_i))
N.append(bas[i].nao)
N1 = N[0]
N2 = N[0] + N[1]
N3 = N[0] + N[1] + N[2]
N4 = N[0] + N[1] + N[2] + N[3]
basC = ls.Basis.concatenate(bas)
pairs_11 = ls.PairList.build_schwarz(bas[0],bas[0],True,1.0E-14)
pairs_22 = ls.PairList.build_schwarz(bas[1],bas[1],True,1.0E-14)
pairs_33 = ls.PairList.build_schwarz(bas[2],bas[2],True,1.0E-14)
pairs_12 = ls.PairList.build_schwarz(bas[0],bas[1],False,1.0E-14)
pairs_21 = ls.PairList.build_schwarz(bas[1],bas[0],False,1.0E-14)
pairs_13 = ls.PairList.build_schwarz(bas[0],bas[2],False,1.0E-14)
pairs_31 = ls.PairList.build_schwarz(bas[2],bas[0],False,1.0E-14)
pairs_23 = ls.PairList.build_schwarz(bas[1],bas[2],False,1.0E-14)
pairs_32 = ls.PairList.build_schwarz(bas[2],bas[1],False,1.0E-14)
pairs_34 = ls.PairList.build_schwarz(bas[2],bas[3],False,1.0E-14)
pairs_42 = ls.PairList.build_schwarz(bas[3],bas[1],False,1.0E-14)
suffix = ""
for basname in new_bas_list:
suffix += "_" + basname.upper()
# calculate integrals in mixed basis set
vals = collections.OrderedDict()
D11 = ls.Tensor.array(refs['D11'+suffix])
D12 = ls.Tensor.array(refs['D12'+suffix])
# D11 (11|pq) => Jpq
vals['J1111'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_11, pairs_11, D11, 1.0E-14, 1.0E-14
)
vals['J1112'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_11, D11, 1.0E-14, 1.0E-14
)
vals['J1122'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_11, D11, 1.0E-14, 1.0E-14
)
vals['J1123'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_23, pairs_11, D11, 1.0E-14, 1.0E-14
)
# D12 (12|pq) => Jpq
vals['J1234'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_34, pairs_12, D12, 1.0E-14, 1.0E-14
)
vals['J1233'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_33, pairs_12, D12, 1.0E-14, 1.0E-14
)
vals['J1223'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_23, pairs_12, D12, 1.0E-14, 1.0E-14
)
vals['J1222'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_12, D12, 1.0E-14, 1.0E-14
)
vals['J1213'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_13, pairs_12, D12, 1.0E-14, 1.0E-14
)
vals['J1212'+suffix] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_12, D12, 1.0E-14, 1.0E-14
)
# D11 (1p|1q) => Kpq
vals['K1111'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_11, D11, True, 1.0E-14, 1.0E-14
)
vals['K1112'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_21, D11, True, 1.0E-14, 1.0E-14
)
vals['K1122'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_21, D11, True, 1.0E-14, 1.0E-14
)
vals['K1123'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_31, D11, True, 1.0E-14, 1.0E-14
)
# D12 (1p|2q) => Kpq
vals['K1234'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_31, pairs_42, D12, False, 1.0E-14, 1.0E-14
)
vals['K1233'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_31, pairs_32, D12, False, 1.0E-14, 1.0E-14
)
vals['K1223'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_32, D12, False, 1.0E-14, 1.0E-14
)
vals['K1222'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_22, D12, False, 1.0E-14, 1.0E-14
)
vals['K1213'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_32, D12, False, 1.0E-14, 1.0E-14
)
vals['K1212'+suffix] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_22, D12, False, 1.0E-14, 1.0E-14
)
# compare with reference
max_diff = 0.0
error_str = "\n"
for key, val in list(vals.items()):
ref = ls.Tensor.array(refs[key])
diff = np.max(np.abs(val.np - ref.np))
if (diff > max_diff):
max_diff = diff
if (diff >= tol):
error_str += " %-6s diff=%15.6e\n" % (key, diff)
print(" %-12s%-12s%-12s%-12s%15.6e" % \
(xyz_list[0].upper() + '/' + new_bas_list[0],
xyz_list[1].upper() + '/' + new_bas_list[1],
xyz_list[2].upper() + '/' + new_bas_list[2],
xyz_list[3].upper() + '/' + new_bas_list[3],
max_diff))
if (max_diff >= tol):
print(error_str)
return False
return True
def run_mix_basis_2(run_dir):
tol = 1.0E-12
res = ls.ResourceList.build(1024**2,1024**2)
ewald = ls.Ewald([1.0], [-1.0])
xyz_list = ['h2o', 'nh3']
bas_list = ['sto-3g', '6-31gs', 'cc-pvdz']
# molecule list
mol = []
for i, xyz_i in enumerate(xyz_list):
mol.append(ls.Molecule.from_xyz_file(run_dir + xyz_i + '.xyz'))
molC = ls.Molecule.concatenate(mol,0,1)
xyzc = molC.xyzZ
print(" Task: S,T,V,J,K")
print("\n %-15s%-15s%15s" % \
("Mol1", "Mol2", "Max_Diff"))
print(" %s" % ('-'*45))
# reference npz file
npzfile = run_dir + "mix"
for xyzname in xyz_list:
npzfile += "_" + xyzname
npzfile += ".npz"
refs = np.load(npzfile)
# basis list
for a, bas_a in enumerate(bas_list):
bas1 = ls.Basis.from_gbs_file(mol[0], bas_a)
N1 = bas1.nao
for b, bas_b in enumerate(bas_list):
if (b == a): continue
bas2 = ls.Basis.from_gbs_file(mol[1], bas_b)
basC = ls.Basis.concatenate([bas1,bas2])
N2 = bas2.nao
pairs_11 = ls.PairList.build_schwarz(bas1,bas1,True,1.0E-14)
pairs_12 = ls.PairList.build_schwarz(bas1,bas2,False,1.0E-14)
pairs_21 = ls.PairList.build_schwarz(bas2,bas1,False,1.0E-14)
pairs_22 = ls.PairList.build_schwarz(bas2,bas2,True,1.0E-14)
suffix = "_" + bas_a.upper() + "_" + bas_b.upper()
# calculate integrals in mixed basis set
vals = collections.OrderedDict()
# overlap
vals['S'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['S'+suffix].np[:N1,:N1] = ls.IntBox.overlap(res, pairs_11).np[:,:]
vals['S'+suffix].np[:N1,N1:] = ls.IntBox.overlap(res, pairs_12).np[:,:]
vals['S'+suffix].np[N1:,:N1] = ls.IntBox.overlap(res, pairs_21).np[:,:]
vals['S'+suffix].np[N1:,N1:] = ls.IntBox.overlap(res, pairs_22).np[:,:]
# kinetic
vals['T'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['T'+suffix].np[:N1,:N1] = ls.IntBox.kinetic(res, pairs_11).np[:,:]
vals['T'+suffix].np[:N1,N1:] = ls.IntBox.kinetic(res, pairs_12).np[:,:]
vals['T'+suffix].np[N1:,:N1] = ls.IntBox.kinetic(res, pairs_21).np[:,:]
vals['T'+suffix].np[N1:,N1:] = ls.IntBox.kinetic(res, pairs_22).np[:,:]
# nuclear potential
vals['V'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['V'+suffix].np[:N1,:N1] = ls.IntBox.potential(res, ewald, pairs_11, xyzc).np[:,:]
vals['V'+suffix].np[:N1,N1:] = ls.IntBox.potential(res, ewald, pairs_12, xyzc).np[:,:]
vals['V'+suffix].np[N1:,:N1] = ls.IntBox.potential(res, ewald, pairs_21, xyzc).np[:,:]
vals['V'+suffix].np[N1:,N1:] = ls.IntBox.potential(res, ewald, pairs_22, xyzc).np[:,:]
D12 = ls.Tensor.zeros((N1,N2))
D12.np[...] = refs['D0'+suffix][:N1,N1:]
# J0: (11|12), (12|12), (21|12), (22|12)
vals['J0'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['J0'+suffix].np[:N1,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_11, pairs_12, D12, 1.0E-14, 1.0E-14
).np[:,:]
vals['J0'+suffix].np[:N1,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_12, D12, 1.0E-14, 1.0E-14
).np[:,:]
vals['J0'+suffix].np[N1:,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_21, pairs_12, D12, 1.0E-14, 1.0E-14
).np[:,:]
vals['J0'+suffix].np[N1:,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_12, D12, 1.0E-14, 1.0E-14
).np[:,:]
# K0: (11|12), (11|22), (21|12), (21|22)
vals['K0'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['K0'+suffix].np[:N1,:N1] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_12, D12, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K0'+suffix].np[:N1,N1:] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_22, D12, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K0'+suffix].np[N1:,:N1] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_12, D12, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K0'+suffix].np[N1:,N1:] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_22, D12, False, 1.0E-14, 1.0E-14
).np[:,:]
D22 = ls.Tensor.zeros((N2,N2))
D22.np[...] = refs['D1'+suffix][N1:,N1:]
# J1: (11|22), (12|22), (21|22), (22|22)
vals['J1'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['J1'+suffix].np[:N1,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_11, pairs_22, D22, 1.0E-14, 1.0E-14
).np[:,:]
vals['J1'+suffix].np[:N1,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_22, D22, 1.0E-14, 1.0E-14
).np[:,:]
vals['J1'+suffix].np[N1:,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_21, pairs_22, D22, 1.0E-14, 1.0E-14
).np[:,:]
vals['J1'+suffix].np[N1:,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_22, D22, 1.0E-14, 1.0E-14
).np[:,:]
# K1: (12|12), (12|22), (22|12), (22|22)
vals['K1'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['K1'+suffix].np[:N1,:N1] = ls.IntBox.exchange(
res, ewald, pairs_12, pairs_12, D22, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K1'+suffix].np[:N1,N1:] = ls.IntBox.exchange(
res, ewald, pairs_12, pairs_22, D22, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K1'+suffix].np[N1:,:N1] = ls.IntBox.exchange(
res, ewald, pairs_22, pairs_12, D22, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K1'+suffix].np[N1:,N1:] = ls.IntBox.exchange(
res, ewald, pairs_22, pairs_22, D22, True, 1.0E-14, 1.0E-14
).np[:,:]
D11 = ls.Tensor.zeros((N1,N1))
D11.np[...] = refs['D2'+suffix][:N1,:N1]
# J2: (11|11), (12|11), (21|11), (22|11)
vals['J2'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['J2'+suffix].np[:N1,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_11, pairs_11, D11, 1.0E-14, 1.0E-14
).np[:,:]
vals['J2'+suffix].np[:N1,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_11, D11, 1.0E-14, 1.0E-14
).np[:,:]
vals['J2'+suffix].np[N1:,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_21, pairs_11, D11, 1.0E-14, 1.0E-14
).np[:,:]
vals['J2'+suffix].np[N1:,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_11, D11, 1.0E-14, 1.0E-14
).np[:,:]
# K2: (11|11), (11|21), (21|11), (21|21)
vals['K2'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['K2'+suffix].np[:N1,:N1] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_11, D11, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K2'+suffix].np[:N1,N1:] = ls.IntBox.exchange(
res, ewald, pairs_11, pairs_21, D11, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K2'+suffix].np[N1:,:N1] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_11, D11, True, 1.0E-14, 1.0E-14
).np[:,:]
vals['K2'+suffix].np[N1:,N1:] = ls.IntBox.exchange(
res, ewald, pairs_21, pairs_21, D11, True, 1.0E-14, 1.0E-14
).np[:,:]
D21 = ls.Tensor.zeros((N2,N1))
D21.np[...] = refs['D3'+suffix][N1:,:N1]
# J3: (11|21), (12|21), (21|21), (22|21)
vals['J3'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['J3'+suffix].np[:N1,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_11, pairs_21, D21, 1.0E-14, 1.0E-14
).np[:,:]
vals['J3'+suffix].np[:N1,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_12, pairs_21, D21, 1.0E-14, 1.0E-14
).np[:,:]
vals['J3'+suffix].np[N1:,:N1] = ls.IntBox.coulomb(
res, ewald, pairs_21, pairs_21, D21, 1.0E-14, 1.0E-14
).np[:,:]
vals['J3'+suffix].np[N1:,N1:] = ls.IntBox.coulomb(
res, ewald, pairs_22, pairs_21, D21, 1.0E-14, 1.0E-14
).np[:,:]
# K3: (12|11), (12|21), (22|11), (22|21)
vals['K3'+suffix] = ls.Tensor.zeros((N1+N2,N1+N2))
vals['K3'+suffix].np[:N1,:N1] = ls.IntBox.exchange(
res, ewald, pairs_12, pairs_11, D21, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K3'+suffix].np[:N1,N1:] = ls.IntBox.exchange(
res, ewald, pairs_12, pairs_21, D21, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K3'+suffix].np[N1:,:N1] = ls.IntBox.exchange(
res, ewald, pairs_22, pairs_11, D21, False, 1.0E-14, 1.0E-14
).np[:,:]
vals['K3'+suffix].np[N1:,N1:] = ls.IntBox.exchange(
res, ewald, pairs_22, pairs_21, D21, False, 1.0E-14, 1.0E-14
).np[:,:]
# compare with reference
max_diff = 0.0
error_str = "\n"
for key, val in list(vals.items()):
ref = ls.Tensor.array(refs[key])
diff = np.max(np.abs(val.np - ref.np))
if (diff > max_diff):
max_diff = diff
if (diff >= tol):
error_str += " %-6s diff=%15.6e\n" % (key, diff)
print(" %-15s%-15s%15.6e" % \
(xyz_list[0].upper()+'/'+bas_a,
xyz_list[1].upper()+'/'+bas_b,
max_diff))
if (max_diff >= tol):
print(error_str)
return False
return True
def run_mix_grad_2(run_dir):
tol = 1.0E-09
res = ls.ResourceList.build(1024**2, 1024**2)
ewald = ls.Ewald([1.0], [-1.0])
xyz_list = ['h2o', 'nh3']
bas_list = ['sto-3g', '6-31gs', 'cc-pvdz']
# molecule list
mol = []
for i, xyz_i in enumerate(xyz_list):
mol.append(ls.Molecule.from_xyz_file(run_dir + xyz_i + '.xyz'))
molC = ls.Molecule.concatenate(mol, 0, 1)
xyzc = molC.xyzZ
print(" Task: V, J and K gradient")
print("\n %-15s%-15s%15s" % \
("Mol1", "Mol2", "G_Diff"))
print(" %s" % ('-' * 45))
# reference npz file
npzfile = run_dir + "mix"
for xyzname in xyz_list:
npzfile += "_" + xyzname
npzfile += ".npz"
refs = np.load(npzfile)
# basis list
for a, bas_a in enumerate(bas_list):
bas1 = ls.Basis.from_gbs_file(mol[0], bas_a)
N1 = bas1.nao
natom1 = mol[0].natom
xyzc1 = mol[0].xyzZ
for b, bas_b in enumerate(bas_list):
if (b == a): continue
bas2 = ls.Basis.from_gbs_file(mol[1], bas_b)
basC = ls.Basis.concatenate([bas1, bas2])
N2 = bas2.nao
natom2 = mol[1].natom
xyzc2 = mol[1].xyzZ
xyzcC = ls.Molecule.concatenate(mol, 0, 1).xyzZ
pairs_11 = ls.PairList.build_schwarz(bas1, bas1, True, 1.0E-14)
pairs_22 = ls.PairList.build_schwarz(bas2, bas2, True, 1.0E-14)
pairs_12 = ls.PairList.build_schwarz(bas1, bas2, False, 1.0E-14)
pairs = ls.PairList.build_schwarz(basC, basC, True, 1.0E-14)
suffix = "_" + bas_a.upper() + "_" + bas_b.upper()
# read in density matrices of monomers
D22 = ls.Tensor.zeros((N2, N2))
D22.np[...] = refs['D1' + suffix][N1:, N1:]
D11 = ls.Tensor.zeros((N1, N1))
D11.np[...] = refs['D2' + suffix][:N1, :N1]
# idiot check to make sure that the D11 and D22 are not zero
assert (np.max(D22.np) > 0.1)
assert (np.max(D11.np) > 0.1)
# D == D1 (+) D2
D = ls.Tensor.zeros((N1 + N2, N1 + N2))
D1 = ls.Tensor.zeros((N1 + N2, N1 + N2))
D2 = ls.Tensor.zeros((N1 + N2, N1 + N2))
D.np[:N1, :N1] = D11.np[...]
D.np[N1:, N1:] = D22.np[...]
D1.np[:N1, :N1] = D11.np[...]
D2.np[N1:, N1:] = D22.np[...]
# reference V gradient
Vgr = ls.IntBox.potentialGrad(res, ewald, pairs, D, xyzcC)
# reference J and K gradient: (G(D1+D2) - G(D1) - G(D2)) / 2
Jgr = ls.IntBox.coulombGrad(res, ewald, pairs, D, D, 1.0E-14,
1.0E-14)
Jgr.np[...] -= ls.IntBox.coulombGrad(res, ewald, pairs, D2, D2,
1.0E-14, 1.0E-14).np
Jgr.np[...] -= ls.IntBox.coulombGrad(res, ewald, pairs, D1, D1,
1.0E-14, 1.0E-14).np
Jgr.scale(0.5)
Kgr = ls.IntBox.exchangeGrad(res, ewald, pairs, D, D, True, True,
True, 1.0E-14, 1.0E-14)
Kgr.np[...] -= ls.IntBox.exchangeGrad(res, ewald, pairs, D2, D2,
True, True, True, 1.0E-14,
1.0E-14).np
Kgr.np[...] -= ls.IntBox.exchangeGrad(res, ewald, pairs, D1, D1,
True, True, True, 1.0E-14,
1.0E-14).np
Kgr.scale(0.5)
# calculated V gradient from advanced routine
vec_v1 = ls.IntBox.potentialGradAdv2(
res,
ewald,
pairs_11,
D11,
xyzcC,
)
vec_v2 = ls.IntBox.potentialGradAdv2(
res,
ewald,
pairs_22,
D22,
xyzcC,
)
v12 = ls.Tensor.zeros((natom1 + natom2, 3))
v12.np[:natom1, :] += vec_v1[0].np
v12.np[natom1:, :] += vec_v2[0].np
v12.np[:, :] += vec_v1[1].np
v12.np[:, :] += vec_v2[1].np
# calculated J and K gradient from advanced routine
vec_j12 = ls.IntBox.coulombGradAdv(res, ewald, pairs_11, pairs_22,
D11, D22, 1.0E-14, 1.0E-14)
vec_k12 = ls.IntBox.exchangeGradAdv(res, ewald, pairs_12, pairs_12,
D11, D22, True, True, False,
1.0E-14, 1.0E-14)
j12 = ls.Tensor.zeros((natom1 + natom2, 3))
j12.np[:natom1, :] += vec_j12[0].np
j12.np[:natom1, :] += vec_j12[1].np
j12.np[natom1:, :] += vec_j12[2].np
j12.np[natom1:, :] += vec_j12[3].np
k12 = ls.Tensor.zeros((natom1 + natom2, 3))
k12.np[:natom1, :] += vec_k12[0].np
k12.np[natom1:, :] += vec_k12[1].np
k12.np[:natom1, :] += vec_k12[2].np
k12.np[natom1:, :] += vec_k12[3].np
# compare results
diff_Vgr = np.max(np.abs(v12.np - Vgr.np))
diff_Jgr = np.max(np.abs(j12.np - Jgr.np))
diff_Kgr = np.max(np.abs(k12.np - Kgr.np))
print(" %-15s%-15s%15.6e" % \
(xyz_list[0].upper()+'/'+bas_a,
xyz_list[1].upper()+'/'+bas_b,
max(diff_Vgr, diff_Jgr, diff_Kgr)))
if (diff_Vgr >= tol):
print(" %-6s diff=%15.6e\n" % ("Vgr", diff_Vgr))
return False
if (diff_Jgr >= tol):
print(" %-6s diff=%15.6e\n" % ("Jgr", diff_Jgr))
return False
if (diff_Kgr >= tol):
print(" %-6s diff=%15.6e\n" % ("Kgr", diff_Kgr))
return False
return True
def run_ewald_int(run_dir, run_xyz, run_basis):
tol = 1.0E-12
xyzfile = run_dir + run_xyz + ".xyz"
mol = ls.Molecule.from_xyz_file(xyzfile)
bas = ls.Basis.from_gbs_file(mol, run_basis)
res = ls.ResourceList.build(1024**2, 1024**2)
xyzc = mol.xyzZ
# long-range, short-range, and mixed ewald operators
ewald_ops = [
ls.Ewald([1.0], [0.3]), # lr
ls.Ewald([0.7, 0.7, 0.7], [0.2, 0.1, 0.05]), # lr2
ls.Ewald([-0.7, 0.7], [0.3, -1.0]), # sr
ls.Ewald([-0.7, 0.7], [-1.0, -1.0]), # sr2
ls.Ewald([0.8, 0.2], [0.2, -1.0]) # mix
]
ewald_names = ["lr", "lr2", "sr", "sr2", "mix"]
# reference npz file
npzfile = run_dir + "ewald_" + run_xyz + "_" + run_basis + ".npz"
refs = np.load(npzfile)
max_diff = 0.0
error_str = "\n"
# Test both symmetric and nonsymmetric pairlists
for run in range(2):
pairlist_sym = (run == 0)
pairs = ls.PairList.build_schwarz(bas, bas, pairlist_sym, 1.0E-14)
# Test ewald operators
for ind, ewald in enumerate(ewald_ops):
suffix = '_' + ewald_names[ind].upper()
# calculate ewald-related integrals (V,J,K,ESP)
vals = collections.OrderedDict()
vals['V' + suffix] = ls.IntBox.potential(res, ewald, pairs, xyzc)
D = ls.Tensor.array(refs['D' + suffix])
D2 = ls.Tensor.array(refs['D2' + suffix])
vals['J' + suffix] = ls.IntBox.coulomb(res, ewald, pairs, pairs, D,
1.0E-14, 1.0E-14)
vals['J2' + suffix] = ls.IntBox.coulomb(res, ewald, pairs, pairs,
D2, 1.0E-14, 1.0E-14)
vals['K' + suffix] = ls.IntBox.exchange(res, ewald, pairs, pairs,
D, True, 1.0E-14, 1.0E-14)
vals['K2' + suffix] = ls.IntBox.exchange(res, ewald, pairs, pairs,
D2, False, 1.0E-14,
1.0E-14)
XYZ = ls.Tensor.array(refs['XYZ' + suffix])
vals['ESP' + suffix] = ls.IntBox.esp(res, ewald, pairs, D, XYZ)
vals['ESP2' + suffix] = ls.IntBox.esp(res, ewald, pairs, D2, XYZ)
# compare results
for key, val in list(vals.items()):
ref = ls.Tensor.array(refs[key])
diff = np.max(np.abs(val.np - ref.np))
if (diff > max_diff):
max_diff = diff
if (diff >= tol):
error_str += " %-6s diff=%15.6e\n" % (key, diff)
symm_str = "yes" if pairlist_sym else "no"
print(" %-12s %-6s %15.6e" %
(run_xyz + '/' + run_basis, symm_str, max_diff))
if (max_diff >= tol):
print(error_str)
return False
return True
def test_bad_constructor(self):
with self.assertRaises(RuntimeError):
ewald = ls.Ewald([], [])
with self.assertRaises(RuntimeError):
ewald = ls.Ewald([1.0], [1.0, 1.0])
def run_prop_int(run_dir, run_xyz, run_basis):
tol = 1.0E-9
xyzfile = run_dir + run_xyz + ".xyz"
npzfile = run_dir + "prop_" + run_xyz + "_" + run_basis + ".npz"
mol = ls.Molecule.from_xyz_file(xyzfile)
bas = ls.Basis.from_gbs_file(mol, run_basis)
res = ls.ResourceList.build(1024**2,1024**2)
#res = ls.ResourceList.build_cpu()
ewald = ls.Ewald([1.0], [-1.0])
xyzc = mol.xyzZ
xyz = mol.xyz
print(res)
vals = []
timing = []
for run in range(2):
pairlist_sym = (run == 0)
pairs = ls.PairList.build_schwarz(bas,bas,pairlist_sym,1.0E-14)
# Calculate integrals and gradients
# Each integral/gradient is calculated twice to test the accumulation
vals.append(collections.OrderedDict())
timing.append(collections.OrderedDict())
t0 = time.time()
vals[run]['S'] = ls.IntBox.overlap(res, pairs)
timing[run]['S'] = time.time() - t0
vals[run]['S'] = ls.IntBox.overlap(res, pairs, vals[run]['S'])
t0 = time.time()
vals[run]['T'] = ls.IntBox.kinetic(res, pairs)
timing[run]['T'] = time.time() - t0
vals[run]['T'] = ls.IntBox.kinetic(res, pairs, vals[run]['T'])
t0 = time.time()
vals[run]['V'] = ls.IntBox.potential(res, ewald, pairs, xyzc)
timing[run]['V'] = time.time() - t0
vals[run]['V'] = ls.IntBox.potential(res, ewald, pairs, xyzc, vals[run]['V'])
D = ls.Tensor.array(np.load(npzfile)['D'])
D2 = ls.Tensor.array(np.load(npzfile)['D2'])
t0 = time.time()
vals[run]['EF'] = ls.IntBox.field(res, ewald, pairs, D, xyz)
vals[run]['EF'] = ls.IntBox.field(res, ewald, pairs, D, xyz, vals[run]['EF'])
t0 = time.time()
vals[run]['J'] = ls.IntBox.coulomb(
res, ewald, pairs, pairs, D, 1.0E-14, 1.0E-14
)
timing[run]['J'] = time.time() - t0
vals[run]['J'] = ls.IntBox.coulomb(
res, ewald, pairs, pairs, D, 1.0E-14, 1.0E-14, vals[run]['J']
)
t0 = time.time()
vals[run]['J2'] = ls.IntBox.coulomb(
res, ewald, pairs, pairs, D2, 1.0E-14, 1.0E-14
)
timing[run]['J2'] = time.time() - t0
vals[run]['J2'] = ls.IntBox.coulomb(
res, ewald, pairs, pairs, D2, 1.0E-14, 1.0E-14, vals[run]['J2']
)
t0 = time.time()
vals[run]['K'] = ls.IntBox.exchange(
res, ewald, pairs, pairs, D, True, 1.0E-14, 1.0E-14
)
timing[run]['K'] = time.time() - t0
vals[run]['K'] = ls.IntBox.exchange(
res, ewald, pairs, pairs, D, True, 1.0E-14, 1.0E-14, vals[run]['K']
)
t0 = time.time()
vals[run]['K2'] = ls.IntBox.exchange(
res, ewald, pairs, pairs, D2, False, 1.0E-14, 1.0E-14
)
timing[run]['K2'] = time.time() - t0
vals[run]['K2'] = ls.IntBox.exchange(
res, ewald, pairs, pairs, D2, False, 1.0E-14, 1.0E-14, vals[run]['K2']
)
W = ls.Tensor.array(np.load(npzfile)['W'])
W2 = ls.Tensor.array(np.load(npzfile)['W2'])
if (pairlist_sym):
"""
t0 = time.time()
vals[run]['Vgr'] = ls.IntBox.potentialGrad(res, ewald, pairs, D, xyzc)
timing[run]['Vgr'] = time.time() - t0
vals[run]['Vgr'] = ls.IntBox.potentialGrad(res, ewald, pairs, D, xyzc, vals[run]['Vgr'])
t0 = time.time()
vals[run]['Vgr2'] = ls.IntBox.potentialGrad(res, ewald, pairs, D2, xyzc)
timing[run]['Vgr2'] = time.time() - t0
vals[run]['Vgr2'] = ls.IntBox.potentialGrad(res, ewald, pairs, D2, xyzc, vals[run]['Vgr2'])
"""
t0 = time.time()
Vgr = ls.IntBox.potentialGradAdv2(res, ewald, pairs, D, xyzc)
timing[run]['Vgr'] = time.time() - t0
Vgr = ls.IntBox.potentialGradAdv2(res, ewald, pairs, D, xyzc, Vgr)
vals[run]['Vgr'] = Vgr[0].clone()
vals[run]['Vgr'].np[...] += Vgr[1].np
t0 = time.time()
Vgr2 = ls.IntBox.potentialGradAdv2(res, ewald, pairs, D2, xyzc)
timing[run]['Vgr2'] = time.time() - t0
Vgr2 = ls.IntBox.potentialGradAdv2(res, ewald, pairs, D2, xyzc, Vgr2)
vals[run]['Vgr2'] = Vgr2[0].clone()
vals[run]['Vgr2'].np[...] += Vgr2[1].np
t0 = time.time()
vals[run]['Jgr'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D, D, 1.0E-14, 1.0E-14
)
timing[run]['Jgr'] = time.time() - t0
vals[run]['Jgr'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D, D, 1.0E-14, 1.0E-14, vals[run]['Jgr']
)
t0 = time.time()
vals[run]['Jgr2'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D2, D2, 1.0E-14, 1.0E-14
)
timing[run]['Jgr2'] = time.time() - t0
vals[run]['Jgr2'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D2, D2, 1.0E-14, 1.0E-14, vals[run]['Jgr2']
)
t0 = time.time()
vals[run]['Jgr3'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D, D2, 1.0E-14, 1.0E-14
)
timing[run]['Jgr3'] = time.time() - t0
vals[run]['Jgr3'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D, D2, 1.0E-14, 1.0E-14, vals[run]['Jgr3']
)
t0 = time.time()
vals[run]['Jgr4'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D2, D, 1.0E-14, 1.0E-14
)
timing[run]['Jgr4'] = time.time() - t0
vals[run]['Jgr4'] = ls.IntBox.coulombGrad(
res, ewald, pairs, D2, D, 1.0E-14, 1.0E-14, vals[run]['Jgr4']
)
t0 = time.time()
vals[run]['Kgr'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D, D, True, True, True, 1.0E-14, 1.0E-14
)
timing[run]['Kgr'] = time.time() - t0
vals[run]['Kgr'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D, D, True, True, True, 1.0E-14, 1.0E-14, vals[run]['Kgr']
)
t0 = time.time()
vals[run]['Kgr2'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D2, D2, False, False, True, 1.0E-14, 1.0E-14
)
timing[run]['Kgr2'] = time.time() - t0
vals[run]['Kgr2'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D2, D2, False, False, True, 1.0E-14, 1.0E-14, vals[run]['Kgr2']
)
t0 = time.time()
vals[run]['Kgr3'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D, D2, True, False, False, 1.0E-14, 1.0E-14
)
timing[run]['Kgr3'] = time.time() - t0
vals[run]['Kgr3'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D, D2, True, False, False, 1.0E-14, 1.0E-14, vals[run]['Kgr3']
)
t0 = time.time()
vals[run]['Kgr4'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D2, D, False, True, False, 1.0E-14, 1.0E-14
)
timing[run]['Kgr4'] = time.time() - t0
vals[run]['Kgr4'] = ls.IntBox.exchangeGrad(
res, ewald, pairs, D2, D, False, True, False, 1.0E-14, 1.0E-14, vals[run]['Kgr4']
)
t0 = time.time()
vals[run]['Sgr'] = ls.IntBox.overlapGrad(res, pairs, W)
timing[run]['Sgr'] = time.time() - t0
vals[run]['Sgr'] = ls.IntBox.overlapGrad(res, pairs, W, vals[run]['Sgr'])
t0 = time.time()
vals[run]['Sgr2'] = ls.IntBox.overlapGrad(res, pairs, W2)
timing[run]['Sgr2'] = time.time() - t0
vals[run]['Sgr2'] = ls.IntBox.overlapGrad(res, pairs, W2, vals[run]['Sgr2'])
t0 = time.time()
vals[run]['Tgr'] = ls.IntBox.kineticGrad(res, pairs, D)
timing[run]['Tgr'] = time.time() - t0
vals[run]['Tgr'] = ls.IntBox.kineticGrad(res, pairs, D, vals[run]['Tgr'])
t0 = time.time()
vals[run]['Tgr2'] = ls.IntBox.kineticGrad(res, pairs, D2)
timing[run]['Tgr2'] = time.time() - t0
vals[run]['Tgr2'] = ls.IntBox.kineticGrad(res, pairs, D2, vals[run]['Tgr2'])
t0 = time.time()
Dipgrad = ls.IntBox.dipoleGrad(res, pairs, 0.0, 0.0 ,0.0, D)
Dipgrad = ls.IntBox.dipoleGrad(res, pairs, 0.0, 0.0, 0.0, D, Dipgrad)
vals[run]['DXgr'] = Dipgrad[0]
vals[run]['DYgr'] = Dipgrad[1]
vals[run]['DZgr'] = Dipgrad[2]
else:
t0 = time.time()
Vgr = ls.IntBox.potentialGradAdv(res, ewald, pairs, D, xyzc)
timing[run]['Vgr'] = time.time() - t0
Vgr = ls.IntBox.potentialGradAdv(res, ewald, pairs, D, xyzc, Vgr)
vals[run]['Vgr'] = Vgr[0].clone()
vals[run]['Vgr'].np[...] += Vgr[1].np
vals[run]['Vgr'].np[...] += Vgr[2].np
t0 = time.time()
Vgr2 = ls.IntBox.potentialGradAdv(res, ewald, pairs, D2, xyzc)
timing[run]['Vgr2'] = time.time() - t0
Vgr2 = ls.IntBox.potentialGradAdv(res, ewald, pairs, D2, xyzc, Vgr2)
vals[run]['Vgr2'] = Vgr2[0].clone()
vals[run]['Vgr2'].np[...] += Vgr2[1].np
vals[run]['Vgr2'].np[...] += Vgr2[2].np
# TODO: Coulomb gradient with asymmetric pairlist
vals[run]['Jgr'] = vals[0]['Jgr'].clone()
vals[run]['Jgr2'] = vals[0]['Jgr2'].clone()
vals[run]['Jgr3'] = vals[0]['Jgr3'].clone()
vals[run]['Jgr4'] = vals[0]['Jgr4'].clone()
t0 = time.time()
Kgr = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D, D, True, True, True, 1.0E-14, 1.0E-14
)
timing[run]['Kgr'] = time.time() - t0
Kgr = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D, D, True, True, True, 1.0E-14, 1.0E-14, Kgr
)
vals[run]['Kgr'] = Kgr[0].clone()
vals[run]['Kgr'].np[...] += Kgr[1].np
vals[run]['Kgr'].np[...] += Kgr[2].np
vals[run]['Kgr'].np[...] += Kgr[3].np
t0 = time.time()
Kgr2 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D2, D2, False, False, True, 1.0E-14, 1.0E-14
)
timing[run]['Kgr2'] = time.time() - t0
Kgr2 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D2, D2, False, False, True, 1.0E-14, 1.0E-14, Kgr2
)
vals[run]['Kgr2'] = Kgr2[0].clone()
vals[run]['Kgr2'].np[...] += Kgr2[1].np
vals[run]['Kgr2'].np[...] += Kgr2[2].np
vals[run]['Kgr2'].np[...] += Kgr2[3].np
t0 = time.time()
Kgr3 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D, D2, True, False, False, 1.0E-14, 1.0E-14
)
timing[run]['Kgr3'] = time.time() - t0
Kgr3 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D, D2, True, False, False, 1.0E-14, 1.0E-14, Kgr3
)
vals[run]['Kgr3'] = Kgr3[0].clone()
vals[run]['Kgr3'].np[...] += Kgr3[1].np
vals[run]['Kgr3'].np[...] += Kgr3[2].np
vals[run]['Kgr3'].np[...] += Kgr3[3].np
t0 = time.time()
Kgr4 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D2, D, False, True, False, 1.0E-14, 1.0E-14
)
timing[run]['Kgr4'] = time.time() - t0
Kgr4 = ls.IntBox.exchangeGradAdv(
res, ewald, pairs, pairs, D2, D, False, True, False, 1.0E-14, 1.0E-14, Kgr4
)
vals[run]['Kgr4'] = Kgr4[0].clone()
vals[run]['Kgr4'].np[...] += Kgr4[1].np
vals[run]['Kgr4'].np[...] += Kgr4[2].np
vals[run]['Kgr4'].np[...] += Kgr4[3].np
t0 = time.time()
Sgr = ls.IntBox.overlapGradAdv(res, pairs, W)
timing[run]['Sgr'] = time.time() - t0
Sgr = ls.IntBox.overlapGradAdv(res, pairs, W, Sgr)
vals[run]['Sgr'] = Sgr[0].clone()
vals[run]['Sgr'].np[...] += Sgr[1].np
t0 = time.time()
Sgr2 = ls.IntBox.overlapGradAdv(res, pairs, W2)
timing[run]['Sgr2'] = time.time() - t0
Sgr2 = ls.IntBox.overlapGradAdv(res, pairs, W2, Sgr2)
vals[run]['Sgr2'] = Sgr2[0].clone()
vals[run]['Sgr2'].np[...] += Sgr2[1].np
t0 = time.time()
Tgr = ls.IntBox.kineticGradAdv(res, pairs, D)
timing[run]['Tgr'] = time.time() - t0
Tgr = ls.IntBox.kineticGradAdv(res, pairs, D, Tgr)
vals[run]['Tgr'] = Tgr[0].clone()
vals[run]['Tgr'].np[...] += Tgr[1].np
t0 = time.time()
Tgr2 = ls.IntBox.kineticGradAdv(res, pairs, D2)
timing[run]['Tgr2'] = time.time() - t0
Tgr2 = ls.IntBox.kineticGradAdv(res, pairs, D2, Tgr2)
vals[run]['Tgr2'] = Tgr2[0].clone()
vals[run]['Tgr2'].np[...] += Tgr2[1].np
t0 = time.time()
Dipgrad = ls.IntBox.dipoleGradAdv(res, pairs, 0.0, 0.0 ,0.0, D)
Dipgrad = ls.IntBox.dipoleGradAdv(res, pairs, 0.0, 0.0, 0.0, D, Dipgrad)
vals[run]['DXgr'] = Dipgrad[0][0].clone()
vals[run]['DXgr'].np[...] += Dipgrad[0][1]
vals[run]['DYgr'] = Dipgrad[1][0].clone()
vals[run]['DYgr'].np[...] += Dipgrad[1][1]
vals[run]['DZgr'] = Dipgrad[2][0].clone()
vals[run]['DZgr'].np[...] += Dipgrad[2][1]
# anti-symmetric overlap gradient
ASgr = ls.IntBox.overlapGradAdv(res, pairs, W)
ASgr = ls.IntBox.overlapGradAdv(res, pairs, W, ASgr)
vals[run]['ASgr'] = ASgr[1]
ASgr2 = ls.IntBox.overlapGradAdv(res, pairs, W2)
ASgr2 = ls.IntBox.overlapGradAdv(res, pairs, W2, ASgr2)
vals[run]['ASgr2'] = ASgr2[1]
# read in a number of grid points and calculate ESP
XYZ = ls.Tensor.array(np.load(npzfile)['XYZ'])
t0 = time.time()
vals[run]['ESP'] = ls.IntBox.esp(res, ewald, pairs, D, XYZ)
timing[run]['ESP'] = time.time() - t0
vals[run]['ESP'] = ls.IntBox.esp(res, ewald, pairs, D, XYZ, vals[run]['ESP'])
t0 = time.time()
vals[run]['ESP2'] = ls.IntBox.esp(res, ewald, pairs, D2, XYZ)
timing[run]['ESP2'] = time.time() - t0
vals[run]['ESP2'] = ls.IntBox.esp(res, ewald, pairs, D2, XYZ, vals[run]['ESP2'])
Dipole = ls.IntBox.dipole(res, pairs, 0., 0., 0.)
Dipole = ls.IntBox.dipole(res, pairs, 0., 0., 0., Dipole)
vals[run]['DX'] = Dipole[0]
vals[run]['DY'] = Dipole[1]
vals[run]['DZ'] = Dipole[2]
Quadrupole = ls.IntBox.quadrupole(res, pairs, 0., 0., 0.)
Quadrupole = ls.IntBox.quadrupole(res, pairs, 0., 0., 0., Quadrupole)
vals[run]['QXX'] = Quadrupole[0]
vals[run]['QXY'] = Quadrupole[1]
vals[run]['QXZ'] = Quadrupole[2]
vals[run]['QYY'] = Quadrupole[3]
vals[run]['QYZ'] = Quadrupole[4]
vals[run]['QZZ'] = Quadrupole[5]
Nabla = ls.IntBox.nabla(res, pairs)
Nabla = ls.IntBox.nabla(res, pairs, Nabla)
vals[run]['PX'] = Nabla[0]
vals[run]['PY'] = Nabla[1]
vals[run]['PZ'] = Nabla[2]
AngMom = ls.IntBox.angularMomentum(res, pairs, 0., 0., 0.)
AngMom = ls.IntBox.angularMomentum(res, pairs, 0., 0., 0., AngMom)
vals[run]['LX'] = AngMom[0]
vals[run]['LY'] = AngMom[1]
vals[run]['LZ'] = AngMom[2]
# compare results
print("%-11s %-27s %-25s" % (run_basis, "sym", "non-sym"))
max_diff = 0.0
max_diff2 = 0.0
for key, val in list(vals[0].items()):
ref = ls.Tensor.array(np.load(npzfile)[key])
ref[...] *= 2.0
val2 = vals[1][key]
# Need the prefactor of 0.5 since each integral/gradient is calculated twice
diff = np.max(np.abs(val.np - ref.np))
diff2 = np.max(np.abs(val2.np - ref.np))
time_str = ""
if key in timing[0]:
time_str += "%.0f ms" % (timing[0][key]*1000)
time_str2 = ""
if key in timing[1]:
time_str2 += "%.0f ms" % (timing[1][key]*1000)
print(" %-6s %15.6e%12s %15.6e%12s" % (key, diff, time_str, diff2, time_str2))
if (diff > max_diff):
max_diff = diff
if (diff2 > max_diff2):
max_diff2 = diff2
if (diff >= tol):
print("")
ref.name = key + "(ref)"
val.name = key + "(calc)"
print(ref)
print(val)
print(ls.Tensor.array(ref[...] - val[...]))
if (diff2 >= tol):
print("")
ref.name = key + "(ref)"
val2.name = key + "(calc)"
print(ref)
print(val2)
print(" %s" % ("-"*50))
print(" %-6s%16.6e%28.6e" % ("MAX", max_diff, max_diff2))
return (max_diff < tol and max_diff2 < tol)
def run_charge(run_dir):
energy_tol = 1.0E-11
grad_tol = 1.0E-07
res = ls.ResourceList.build_cpu()
ewald = ls.Ewald([1.0], [-1.0])
ewald_lr = ls.Ewald([0.8], [0.3])
ewald_sr = ls.Ewald([-0.8, 0.8], [0.3, -1.0])
xyz_list = ['h2o', 'nh3', 'ch4']
ref_energy = [
[8.002367030356384, 4.035198827718412, 2.3666947965666942],
[20.55322877327911, 15.492218243839702, 0.9503647747835862],
[18.525177050762682, 14.28124517557294, 0.5388964650372082],
[11.880867186027105, 5.743556199066088, 3.7611375497555968],
[11.715537761726901, 9.367396015926191, 0.005034193455331343],
[13.686514602165177, 7.002374264251431, 3.9468374174807144]
]
print("\n %-7s%-7s%15s%15s" % ("Mol1", "Mol2", "E_Diff", "G_Diff"))
print(" %s" % ('-' * 44))
calc_energy = ls.Tensor.zeros(
(len(xyz_list) * (len(xyz_list) + 1) // 2, 3))
ind = 0
for i in range(len(xyz_list)):
mol_1 = ls.Molecule.from_xyz_file(run_dir + xyz_list[i] + ".xyz")
xyzc_1 = mol_1.xyzZ
for j in range(i, len(xyz_list)):
mol_2 = ls.Molecule.from_xyz_file(run_dir + xyz_list[j] + ".xyz")
xyzc_2 = mol_2.xyzZ
# Calculate energies
if ls.Molecule.equivalent(mol_1, mol_2):
calc_energy.np[ind, :] = [
ls.IntBox.chargeEnergySelf(res, ewald, xyzc_1),
ls.IntBox.chargeEnergySelf(res, ewald_lr, xyzc_1),
ls.IntBox.chargeEnergySelf(res, ewald_sr, xyzc_1)
]
else:
calc_energy.np[ind, :] = [
ls.IntBox.chargeEnergyOther(res, ewald, xyzc_1, xyzc_2),
ls.IntBox.chargeEnergyOther(res, ewald_lr, xyzc_1, xyzc_2),
ls.IntBox.chargeEnergyOther(res, ewald_sr, xyzc_1, xyzc_2)
]
diff_energy = np.max(
np.abs(ref_energy[ind][:] - calc_energy.np[ind, :]))
if (diff_energy >= energy_tol):
print("\n %s %s diff_energy %16.6e\n" %
(xyz_list[i], xyz_list[j], diff_energy))
return False
# Calculate gradients
# Each gradient is calculated twice to test the accumulation
if (ls.Molecule.equivalent(mol_1, mol_2)):
for my_ewald in [ewald, ewald_sr, ewald_lr]:
ana_grad = ls.IntBox.chargeGradSelf(res, my_ewald, xyzc_1)
ana_grad = ls.IntBox.chargeGradSelf(
res, my_ewald, xyzc_1, ana_grad)
num_grad = run_num_grad_1(res, my_ewald, xyzc_1)
# Need the prefactor of 0.5 since each gradient is calculated twice
diff_grad = np.max(np.abs(ana_grad.np * 0.5 - num_grad.np))
if (diff_grad >= grad_tol):
print("\n %s diff_grad %16.6e\n" %
(xyz_list[i], diff_grad))
return False
else:
for my_ewald in [ewald, ewald_sr, ewald_lr]:
ana_grad = ls.IntBox.chargeGradOther(
res, my_ewald, xyzc_1, xyzc_2)
ana_grad = ls.IntBox.chargeGradOther(
res, my_ewald, xyzc_1, xyzc_2, ana_grad)
num_grad = [
run_num_grad_2(res, my_ewald, xyzc_1, xyzc_2),
run_num_grad_2(res, my_ewald, xyzc_2, xyzc_1)
]
# Need the prefactor of 0.5 since each gradient is calculated twice
diff_grad = max(
np.max(np.abs(ana_grad[0].np * 0.5 - num_grad[0].np)),
np.max(np.abs(ana_grad[1].np * 0.5 - num_grad[1].np)))
if (diff_grad >= grad_tol):
print("\n %s %s diff_grad %16.6e\n" %
(xyz_list[i], xyz_list[j], diff_grad))
return False
print(" %-7s%-7s%15.6e%15.6e" %
(xyz_list[i].upper(), xyz_list[j].upper(), diff_energy,
diff_grad))
ind += 1
return True
