def test_cc(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf = scf.RHF(mol)
rhf = scf.density_fit(scf.RHF(mol))
rhf.scf() # -76.0267656731
from tcc.rccsd_mul import RCCSD_MUL_RI
from tcc.rccsd_cpd import RCCSD_CPD_LS_T
from tcc.cc_solvers import (residual_diis_solver, classic_solver,
root_solver)
cc1 = RCCSD_CPD_LS_T(rhf, rankt={'t2': 20})
cc2 = RCCSD_MUL_RI(rhf)
converged1, energy1, amps1 = classic_solver(cc1, max_cycle=150)
converged2, energy2, amps2 = classic_solver(cc2, max_cycle=150)
def test_cpd_equals_ncpd():
from tcc.hubbard import hubbard_from_scf
from pyscf import scf
N = 6
U = 4
USE_PBC = 'y'
rhf = hubbard_from_scf(scf.RHF, N, N, U, USE_PBC)
rhf.scf() # -76.0267656731
from tcc.rccsd_cpd import (RCCSD_nCPD_LS_T_HUB, RCCSD_CPD_LS_T_HUB)
cc1 = RCCSD_CPD_LS_T_HUB(rhf, rankt={'t2': 30})
cc2 = RCCSD_nCPD_LS_T_HUB(rhf, rankt={'t2': 30})
from tcc.cc_solvers import (residual_diis_solver, update_diis_solver,
classic_solver)
cc1._converged = False
converged1, energy1, amps1 = classic_solver(cc1,
conv_tol_energy=1e-8,
conv_tol_res=1e-8,
lam=3,
max_cycle=140)
cc2._converged = False
converged2, energy2, amps2 = classic_solver(cc2,
conv_tol_energy=1e-8,
conv_tol_res=1e-8,
lam=3,
max_cycle=140)
print(energy2 - energy1)
def test_cc(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'sto-3g',
'O': 'sto-3g',
}
mol.build()
uhf = scf.UHF(mol)
uhf.scf() # -76.0267656731
rhf = scf.RHF(mol)
rhf.scf() # -76.0267656731
from tcc.uccsd_dir import UCCSD
from tcc.rccsd import RCCSD
cc1 = UCCSD(uhf)
cc2 = RCCSD(rhf)
from tcc.cc_solvers import classic_solver
converged1, energy1, amps1 = classic_solver(cc1,
conv_tol_energy=1e-8,
max_cycle=100)
converged2, energy2, amps2 = classic_solver(cc2,
conv_tol_energy=1e-8,
max_cycle=100)
def test_classic_solver(self):
from tcc.cc_solvers import classic_solver
from tcc.rccsd import RCCSD
cc = RCCSD(self.rhf)
converged, energy, amps = classic_solver(cc)
self.assertEqual(converged, True)
self.assertEqual(np.allclose(energy, -0.2133432609672395, 1e-5), True)
converged, energy, _ = classic_solver(cc,
amps,
lam=3,
conv_tol_energy=1e-10)
self.assertEqual(converged, True)
self.assertEqual(np.allclose(energy, -0.2133432609672395, 1e-5), True)
def test_cc_step(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'sto-3g',
'O': 'sto-3g',
}
mol.build()
rhf = scf.RHF(mol)
rhf.scf() # -76.0267656731
from tcc.cc_solvers import step_solver, classic_solver
from tcc.rccsd import RCCSD
cc = RCCSD(rhf)
converged1, energy1, _ = classic_solver(cc,
conv_tol_energy=1e-10,
conv_tol_res=1e-10,
max_cycle=20)
cc._converged = False
converged2, energy2, _ = step_solver(cc,
conv_tol_energy=1e-10,
beta=0.5,
max_cycle=100)
def test_cc_unit(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf = scf.RHF(mol)
rhf = scf.density_fit(scf.RHF(mol))
rhf.scf()
from tcc.rccsdt_ri import RCCSDT_UNIT_RI
from tcc.cc_solvers import (classic_solver, update_diis_solver)
cc = RCCSDT_UNIT_RI(rhf)
converged, energy, amps = classic_solver(cc,
conv_tol_energy=1e-8,
max_cycle=100)
cc._converged = False
converged, energy, amps = update_diis_solver(cc,
conv_tol_energy=1e-8,
max_cycle=100)
print('dE: {}'.format(energy - -1.304738e-01))
def test_rccsd_mul_ri(self):
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'sto-3g',
'O': 'sto-3g',
}
mol.build(parse_arg=False)
rhfri = scf.density_fit(scf.RHF(mol))
rhfri.scf() # -74.961181409648674
from tcc.cc_solvers import classic_solver
from tcc.rccsd_mul import RCCSD_MUL_RI
cc = RCCSD_MUL_RI(rhfri)
converged, energy, _ = classic_solver(cc,
conv_tol_amps=1e-8,
conv_tol_energy=1e-8)
self.assertEqual(np.allclose(energy, -0.049399404240317468, 1e-6),
True)
def test_cc_t2f(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [
[8, (0., 0., 0.)],
[1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {'H': '3-21g',
'O': '3-21g', }
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
rhfri = scf.density_fit(scf.RHF(mol))
rhfri.scf()
from tcc.rccsdt import RCCSDT, RCCSDT_UNIT
from tcc.rccsdt_cpd import (RCCSDT_UNIT_nCPD_LS_T,
RCCSDT_UNIT_nCPD_T_LS_T)
from tcc.cc_solvers import (classic_solver, step_solver)
cc1 = RCCSDT_UNIT(rhf)
cc2 = RCCSDT_UNIT_nCPD_T_LS_T(rhfri, rankt={'t3': 40})
converged1, energy1, amps1 = classic_solver(
cc1, conv_tol_energy=1e-7, lam=3,
max_cycle=100)
converged2, energy2, amps2 = step_solver(
cc2, conv_tol_energy=1e-7, beta=1 - 1 / 5,
max_cycle=100)
print('E(full) - E(T2 CPD): {}'.format(energy2 - energy1))
def test_cc(): # pragma: nocover
from pyscf import scf
from tcc.hubbard import hubbard_from_scf
rhf = hubbard_from_scf(scf.RHF, 10, 10, 4, 'y')
rhf.scf()
from tcc.rccsdt import RCCSDT_UNIT
from tcc.cc_solvers import residual_diis_solver, classic_solver
cc = RCCSDT(rhf)
converged, energy, amps = classic_solver(cc,
conv_tol_energy=1e-12,
conv_tol_res=1e-12,
lam=17,
max_cycle=1000)
h = cc.create_ham()
res = cc.calc_residuals(h, amps)
r3 = res.t3
# Apply n_body symmetry
r3 = (+r3 + r3.transpose([1, 2, 0, 4, 5, 3]) +
r3.transpose([2, 0, 1, 5, 3, 4]) + r3.transpose([0, 2, 1, 3, 5, 4]) +
r3.transpose([2, 1, 0, 5, 4, 3]) +
r3.transpose([1, 0, 2, 4, 3, 5])) / 6
import numpy as np
norms = res.map(np.linalg.norm)
print('E: {}'.format(energy))
print('r1: {}, r2: {}, r3: {}, r3_nbody: {}'.format(
norms.t1, norms.t2, norms.t3, np.linalg.norm(r3)))
print('dE: {}'.format(energy - -1.311811e-01))
def test_cpd_unf():
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf_ri = scf.density_fit(scf.RHF(mol))
rhf_ri.scf() # -76.0267656731
from tcc.rccsd import RCCSD, RCCSD_DIR_RI
from tcc.rccsd_cpd import (RCCSD_nCPD_LS_T, RCCSD_CPD_LS_T)
from tcc.cc_solvers import (classic_solver, step_solver)
cc1 = RCCSD_DIR_RI(rhf_ri)
cc2 = RCCSD_nCPD_LS_T(rhf_ri, rankt={'t2': 30})
cc3 = RCCSD_CPD_LS_T(rhf_ri, rankt={'t2': 30})
converged1, energy1, amps1 = classic_solver(
cc1,
conv_tol_energy=1e-8,
)
converged2, energy2, amps2 = classic_solver(cc2,
conv_tol_energy=1e-8,
max_cycle=50)
converged2, energy2, amps2 = step_solver(cc2,
conv_tol_energy=1e-8,
beta=0,
max_cycle=150)
converged3, energy3, amps3 = classic_solver(cc3,
conv_tol_energy=1e-8,
max_cycle=50)
converged3, energy3, amps3 = step_solver(cc3,
conv_tol_energy=1e-8,
beta=0,
max_cycle=150)
def compare_to_aq(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf = scf.RHF(mol)
rhf.scf() # -76.0267656731
# load reference arrays
import h5py
import numpy as np
f1 = h5py.File('data/test_references/aq_ccsd_amps.h5', 'r')
# use amplitudes from the last iteration
num_steps = int(len(f1.keys()) / 2)
t1 = f1['t1_' + str(num_steps)][()].T
t2 = f1['t2_' + str(num_steps)][()].T
f1.close()
f1 = h5py.File('data/test_references/aq_ccsd_mos.h5', 'r')
CA = np.hstack((f1['cI'][()].T, f1['cA'][()].T))
CB = np.hstack((f1['ci'][()].T, f1['ca'][()].T))
f1.close()
# permute AO indices to match pyscf order
perm = [0, 1, 2, 4, 5, 3, 7, 8, 6, 9, 10, 11, 12]
from tcc.utils import perm_matrix
m = perm_matrix(perm)
CA_perm = m.dot(CA)
from tcc.cc_solvers import residual_diis_solver
from tcc.cc_solvers import step_solver, classic_solver
from tcc.rccsd import RCCSD
cc = RCCSD(rhf, mo_coeff=CA_perm)
converged, energy, amps = classic_solver(cc,
conv_tol_energy=1e-14,
conv_tol_res=1e-10,
max_cycle=200)
print('dt1: {}'.format(np.max(t1 - amps.t1)))
print('dt2: {}'.format(np.max(t2 - amps.t2)))
from tcc.tensors import Tensors
test_amps = Tensors(t1=t1, t2=t2)
h = cc.create_ham()
r = cc.calc_residuals(h, test_amps)
print('max r1: {}'.format(np.max(r.t1)))
print('max r2: {}'.format(np.max(r.t2)))
def test_hubbard(): # pragma: nocover
from pyscf import scf
from tcc.hubbard import hubbard_from_scf
rhf = hubbard_from_scf(scf.RHF, 6, 6, 1, 'y')
rhf.damp = -4.0
rhf.scf()
from tcc.cc_solvers import (classic_solver, root_solver)
from tcc.rccsd_mul import RCCSD_MUL_RI_HUB
from tcc.rccsd_cpd import RCCSD_CPD_LS_T_HUB
cc1 = RCCSD_MUL_RI_HUB(rhf)
cc2 = RCCSD_CPD_LS_T_HUB(rhf, rankt={'t2': 30})
converged1, energy1, amps1 = classic_solver(cc1, lam=5, max_cycle=50)
converged2, energy2, amps2 = classic_solver(cc2,
lam=1,
conv_tol_energy=1e-8,
max_cycle=500)
def test_rccsd_unit(self):
from tcc.cc_solvers import classic_solver, residual_diis_solver
from tcc.rccsd import RCCSD, RCCSD_UNIT
cc1 = RCCSD(self.rhf)
cc2 = RCCSD_UNIT(self.rhf)
converged1, energy1, amps = classic_solver(cc1)
converged2, energy2, _ = classic_solver(cc2)
self.assertEqual(converged1, converged2)
self.assertEqual(np.allclose(energy1, -0.2133432609672395, 1e-5), True)
self.assertEqual(np.allclose(energy1, energy2, 1e-5), True)
converged1, energy1, _ = residual_diis_solver(cc1, amps=amps,
conv_tol_energy=1e-10)
converged2, energy2, _ = residual_diis_solver(cc2, amps=amps,
conv_tol_energy=1e-10)
self.assertEqual(np.allclose(energy1, -0.2133432609672395, 1e-5), True)
self.assertEqual(np.allclose(energy1, energy2, 1e-5), True)
def test_compare_to_hirata(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = """
# H2O
H 0.000000000000000 1.079252144093028 1.474611055780858
O 0.000000000000000 0.000000000000000 0.000000000000000
H 0.000000000000000 1.079252144093028 -1.474611055780858
"""
mol.unit = 'Bohr'
mol.basis = {
'H':
gto.basis.parse("""
H S
3.42525091 0.15432897
0.62391373 0.53532814
0.16885540 0.44463454
"""),
'O':
gto.basis.parse("""
O S
130.70932000 0.15432897
23.80886100 0.53532814
6.44360830 0.44463454
O S
5.03315130 -0.09996723
1.16959610 0.39951283
0.38038900 0.70011547
O P
5.03315130 0.15591627
1.16959610 0.60768372
0.38038900 0.39195739
"""),
}
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
from tcc.cc_solvers import classic_solver, update_diis_solver
from tcc.rccsdt import RCCSDT, RCCSDT_UNIT, RCCSDT_UNIT_ANTI
cc1 = RCCSDT(rhf)
converged, energy, amps = classic_solver(cc1,
conv_tol_energy=1e-11,
lam=3,
conv_tol_res=1e-11,
max_cycle=200)
print('E_cc: {}'.format(energy))
print('E_tot: {}'.format(rhf.e_tot + energy))
print('delta E: {}'.format(energy - -0.0502322580))
def test_compare_to_aq(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf = scf.RHF(mol)
rhf.scf() # -76.0267656731
# load reference arrays
import h5py
import numpy as np
f1 = h5py.File('data/test_references/aq_ccsdt_amps.h5', 'r')
# use amplitudes from the last iteration
num_steps = int(len(f1.keys()) / 4)
t1 = f1['t1_' + str(num_steps)][()].T
t2 = f1['t2_' + str(num_steps)][()].T
t3 = f1['t3_' + str(num_steps)][()].T
t3a = f1['t3b_' + str(num_steps)][()].T
f1.close()
f1 = h5py.File('data/test_references/aq_ccsdt_mos.h5', 'r')
CA = np.hstack((f1['cI'][()].T, f1['cA'][()].T))
CB = np.hstack((f1['ci'][()].T, f1['ca'][()].T))
f1.close()
# permute AO indices to match pyscf order
from tcc.utils import perm_matrix
perm = [0, 1, 2, 4, 5, 3, 7, 8, 6, 9, 10, 11, 12]
m = perm_matrix(perm)
CA_perm = m.dot(CA)
from tcc.cc_solvers import residual_diis_solver
from tcc.cc_solvers import (step_solver, classic_solver,
residual_diis_solver)
from tcc.rccsdt import RCCSDT
from tcc.rccsd import RCCSD
cc = RCCSDT(rhf, mo_coeff=CA_perm)
converged, energy, amps = classic_solver(cc,
conv_tol_energy=1e-10,
conv_tol_res=1e-10,
max_cycle=300)
print('delta E: {}'.format(energy - -0.1311305308))
def test_cc_ri(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [['O', (0., 0., 0.)], ['H', (0., -0.757, 0.587)],
['H', (0., 0.757, 0.587)]]
mol.basis = 'sto-3g'
mol.build()
rhf = scf.RHF(mol)
rhf.scf() # -76.0267656731
rhf_ri = scf.density_fit(scf.RHF(mol))
rhf_ri.scf()
from tcc.cc_solvers import residual_diis_solver
from tcc.cc_solvers import classic_solver
from tcc.rccsd import RCCSD_DIR_RI, RCCSD
cc1 = RCCSD_DIR_RI(rhf_ri)
cc2 = RCCSD(rhf)
converged1, energy2, _ = classic_solver(cc1, conv_tol_energy=-1)
converged2, energy2, _ = classic_solver(cc2, conv_tol_energy=-1)
def calc_solutions_diff_r_eq_cpd():
"""
Plot error of RCCSD-CPD vs rank for weak corellation
"""
rankst = RANKS_T.copy()
# Run RHF calculations
rhf = hubbard_from_scf(scf.RHF, N, N, U, 'y')
rhf.damp = -4.0
rhf.scf()
rhf_results = tuple([rhf.e_tot, rhf.mo_coeff, rhf.mo_energy])
with open('calculated/{}-site/amps_and_scf_eq/rhf_results_u_{}.p'.format(N, U), 'wb') as fp:
pickle.dump(rhf_results, fp)
# Run reference calculation
cc_ref = RCCSD_UNIT(rhf)
_, energy_ref, amps_ref = root_solver(cc_ref, conv_tol=1e-10)
cc_results = tuple([energy_ref, amps_ref])
with open('calculated/{}-site/amps_and_scf_eq/cc_results_u_{}.p'.format(N, U), 'wb') as fp:
pickle.dump(cc_results, fp)
all_amps = []
for idx, rank in enumerate(rankst):
tim = time.process_time()
cc = RCCSD_nCPD_LS_T_HUB(rhf, rankt={'t2': rank})
converged, energy, amps = classic_solver(
cc, lam=1.8, conv_tol_energy=1e-14,
conv_tol_amps=1e-10, max_cycle=40000,
verbose=logger.NOTE)
if not converged:
Warning(
'Warning: N = {}, U = {} '
'Rank = {} did not converge'.format(N, U, rank)
)
all_amps.append(tuple([energy, rank, amps]))
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}'.format(
idx + 1, len(rankst), rank, elapsed
))
with open('calculated/{}-site/amps_and_scf_eq/energy_rank_amps_u_{}.p'.format(N, U), 'wb') as fp:
pickle.dump(all_amps, fp)
def test_cc(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': '3-21g',
'O': '3-21g',
}
mol.build()
rhf = scf.RHF(mol)
rhf = scf.density_fit(scf.RHF(mol))
rhf.scf()
from tcc.rccsdt_ri import RCCSDT_RI
from tcc.rccsdt_cpd import RCCSDT_nCPD_LS_T
from tcc.rccsdt_cpd import RCCSDT_CPD_LS_T
from tcc.cc_solvers import (classic_solver, step_solver)
cc1 = RCCSDT_RI(rhf)
cc2 = RCCSDT_nCPD_LS_T(rhf, rankt={'t2': 20, 't3': 40})
cc3 = RCCSDT_CPD_LS_T(rhf, rankt={'t2': 20, 't3': 40})
converged1, energy1, amps1 = classic_solver(cc1,
conv_tol_energy=1e-9,
conv_tol_res=1e-8,
max_cycle=100)
print('dE: {}'.format(energy1 - -1.304876e-01))
import numpy as np
np.seterr(all='raise')
import warnings
warnings.filterwarnings("error")
converged2, energy2, amps2 = step_solver(cc2,
conv_tol_energy=1e-8,
max_cycle=100)
converged3, energy3, amps3 = step_solver(cc3,
conv_tol_energy=1e-8,
max_cycle=100)
print('dE: {}'.format(energy2 - -0.12621546190311517))
print('E(CPD)-E(nCPD): {}'.format(energy3 - energy2))
def test_rccsd_mul(self):
from tcc.cc_solvers import classic_solver, residual_diis_solver
from tcc.rccsd_mul import RCCSD_MUL
cc = RCCSD_MUL(self.rhf)
converged, energy, amps = classic_solver(cc,
conv_tol_amps=1e-8,
conv_tol_energy=1e-8)
self.assertEqual(converged, True)
self.assertEqual(np.allclose(energy, -0.049467456410677929, 1e-5),
True)
cc._converged = False
converged, energy1, _ = residual_diis_solver(cc,
amps=amps,
conv_tol_energy=1e-10)
self.assertEqual(np.allclose(energy, -0.049467456410677929, 1e-5),
True)
def test_hubbard_iterations():
from pyscf import gto
from pyscf import scf
from tcc.hubbard import hubbard_from_scf
rhf = hubbard_from_scf(scf.RHF, 6, 6, 3, 'y')
rhf.damp = -4.0
rhf.scf()
from scipy.io import loadmat
ref = loadmat('reference_hub_rccsdthc.mat', matlab_compatible=True)
mo_coeff = ref['orbA']
mo_energy = ref['valsA'].flatten()
from tcc.cc_solvers import classic_solver
from tcc.rccsd_thc import RCCSD_THC_LS_T_HUB
cc = RCCSD_THC_LS_T_HUB(rhf,
rankt=3,
mo_energy=mo_energy,
mo_coeff=mo_coeff)
t1 = ref['t1']
t2l = ref['t2s'][0][0]
amps = cc.types.AMPLITUDES_TYPE(t1, *t2l)
t1n = ref['t1n']
t2ln = ref['t2sn'][0][0]
ref_amps = cc.types.AMPLITUDES_TYPE(t1n, *t2ln)
dt1 = ref['dt1']
dt2l = ref['dt2s'][0][0]
delta = cc.types.AMPLITUDES_TYPE(dt1, *dt2l)
ham = cc.create_ham()
res = cc.calc_residuals(ham, amps)
rhs = cc.update_rhs(ham, amps, res)
new_amps = cc.solve_amps(ham, amps, rhs)
delta1 = cc.types.AMPLITUDES_TYPE(
new_amps.t1 - amps.t1, new_amps.x1 - amps.x1, new_amps.t1 - amps.x2,
new_amps.t1 - amps.x3, new_amps.t1 - amps.x4, new_amps.t1 - amps.x5)
# cc = RCCSD_THC_LS_T_HUB(rhf, rankt=3)
converged, energy, _ = classic_solver(cc, max_cycle=300, lam=3, amps=amps)
print(converged, energy)
def test_cc(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = {
'H': 'cc-pvdz',
'O': 'cc-pvdz',
}
mol.build()
rhf = scf.RHF(mol)
rhf = scf.density_fit(scf.RHF(mol))
rhf.scf() # -76.0267656731
from tcc.cc_solvers import classic_solver
from tcc.rccsd_mul import RCCSD_MUL_RI
cc = RCCSD_MUL_RI(rhf)
converged, energy, _ = classic_solver(cc)
def test_cc_anti(): # pragma: nocover
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.unit = 'Angstrom'
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '3-21g'
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
from tcc.rccsdt import RCCSDT_UNIT_ANTI
from tcc.cc_solvers import classic_solver
cc = RCCSDT_UNIT_ANTI(rhf)
converged, energy, amps = classic_solver(cc,
conv_tol_energy=1e-10,
conv_tol_res=1e-10,
lam=3,
max_cycle=100)
h = cc.create_ham()
res = cc.calc_residuals(h, amps)
r3 = res.t3
# Extract antisymmetric part only
r3 = 1 / 6 * (+r3 - r3.transpose([1, 0, 2, 3, 4, 5]) + r3.transpose(
[1, 2, 0, 3, 4, 5]) - r3.transpose([2, 1, 0, 3, 4, 5]) + r3.transpose(
[2, 0, 1, 3, 4, 5]) - r3.transpose([0, 2, 1, 3, 4, 5]))
r3 = 1 / 6 * (+r3 - r3.transpose([0, 1, 2, 4, 3, 5]) + r3.transpose(
[0, 1, 2, 4, 5, 3]) - r3.transpose([0, 1, 2, 5, 4, 3]) + r3.transpose(
[0, 1, 2, 5, 3, 4]) - r3.transpose([0, 1, 2, 3, 5, 4]))
import numpy as np
norms = res.map(np.linalg.norm)
print('r1: {}, r2: {}, r3: {}, r3_antisym: {}'.format(
norms.t1, norms.t2, norms.t3, np.linalg.norm(r3)))
# The energy should be higher than in the correct RCCSDT
# due to more restrictions on the symmetry of T3 than needed
# r3 residual is not zero, but its antisymmetric part is
print('dE: {}'.format(energy - -1.311811e-01))
def test_update_diis_solver():
from tcc.hubbard import hubbard_from_scf
from pyscf import scf
N = 6
U = 4
USE_PBC = 'y'
rhf = hubbard_from_scf(scf.RHF, N, N, U, USE_PBC)
rhf.scf() # -76.0267656731
from tcc.rccsd import RCCSD_UNIT
from tcc.rccsd_cpd import (RCCSD_nCPD_LS_T_HUB)
cc1 = RCCSD_UNIT(rhf)
cc2 = RCCSD_nCPD_LS_T_HUB(rhf, rankt={'t2': 30})
from tcc.cc_solvers import (residual_diis_solver, update_diis_solver,
classic_solver)
cc1._converged = False
converged1, energy1, amps1 = residual_diis_solver(cc1,
conv_tol_energy=1e-8,
lam=3,
max_cycle=100)
import pickle
with open('test_amps.p', 'rb') as fp:
ampsi = pickle.load(fp)
cc2._converged = False
converged2, energy2, amps2 = update_diis_solver(cc2,
conv_tol_energy=1e-8,
conv_tol_res=1e-8,
beta=0.666,
max_cycle=100,
amps=ampsi)
cc2._converged = False
converged2, energy2, amps2 = classic_solver(cc2,
conv_tol_energy=1e-8,
conv_tol_res=1e-8,
lam=3,
max_cycle=100)
def calc_t1_norm_vs_u_cpd():
"""
Plot T1 norm of RCCSD-CPD for all corellation strengths
"""
# Set up parameters of the script
N = 10
us = np.linspace(1, 10, num=10)
lambdas = [
3,
] * 6 + [
4,
] * 3 + [
4,
]
rankst = np.array([5, 7, 8, 10, 12, 20]).astype('int')
results = np.array(us)
results_t1 = np.array(us)
results_t2 = np.array(us)
# Run all scfs here so we will have same starting points for CC
run_scfs(N, us, 'calculated/{}-site/scfs_different_u_t1.p'.format(N))
with open('calculated/{}-site/scfs_different_u_t1.p'.format(N),
'rb') as fp:
ref_scfs = pickle.load(fp)
for idxr, rank in enumerate(rankst):
t1_norms = []
energies = []
t2_norms = []
# timb = time.process_time()
for idxu, (u, curr_scf) in enumerate(zip(us, ref_scfs)):
tim = time.process_time()
rhf = hubbard_from_scf(scf.RHF, N, N, u, 'y')
rhf.max_cycle = 1
rhf.scf()
e_scf, mo_coeff, mo_energy = curr_scf
cc = RCCSD_CPD_LS_T_HUB(rhf,
rankt=rank,
mo_coeff=mo_coeff,
mo_energy=mo_energy)
converged = False
if idxu == 0:
converged, energy, amps = classic_solver(cc,
lam=lambdas[idxu],
conv_tol_energy=1e-8,
conv_tol_amps=1e-7,
max_cycle=20000,
verbose=logger.NOTE)
else:
converged, energy, amps = classic_solver(cc,
lam=lambdas[idxu],
conv_tol_energy=1e-8,
conv_tol_amps=1e-7,
max_cycle=30000,
verbose=logger.NOTE)
if np.isnan(energy):
Warning('Warning: N = {}, U = {} '
'Rank = {} did not converge'.format(N, u, rank))
energies.append(energy + e_scf)
if not np.isnan(energy):
t1_norms.append(np.linalg.norm(amps.t1))
else:
t1_norms.append(np.nan)
if not np.isnan(energy):
tmp, _ = cpd_normalize(amps[1:])
t2_norms.append(tmp[0])
else:
t2_norms.append(np.nan)
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}\n'.format(
idxu + 1, len(us), rank, elapsed))
results = np.column_stack((results, energies))
results_t1 = np.column_stack((results_t1, t1_norms))
results_t2 = np.column_stack((results_t2, t2_norms))
# elapsedb = time.process_time() - timb
# print('Batch {} out of {}, rank = {}, time: {}'.format(
# 0 + 1, len(rankst), rank, elapsedb))
# np.savetxt(
# 'calculated/{}-site/t1_norm_vs_u_energies.txt'.format(N),
# results,
# header='U '+' '.join('R={}'.format(rr) for rr in rankst)
# )
# np.savetxt(
# 'calculated/{}-site/t1_norm_vs_u.txt'.format(N),
# results_t1,
# header='U '+' '.join('R={}'.format(rr) for rr in rankst)
# )
np.savetxt('calculated/{}-site/lam_1_vs_u.txt'.format(N),
results_t2,
header='U ' + ' '.join('R={}'.format(rr) for rr in rankst))
us, *t1_norms_l = np.loadtxt(
'calculated/{}-site/t1_norm_vs_u.txt'.format(N), unpack=True)
# Plot
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
plt.plot(us, t1_norms)
plt.xlabel('$U$')
plt.ylabel('$||T^{1}||$')
plt.title('Energy behavior for different ranks')
fig.show()
def calc_energy_vs_u_cpd():
"""
Plot energy of RCCSD-CPD for all corellation strengths
"""
# Set up parameters of the script
us = U_VALUES.copy()
lambdas = LAMBDAS.copy()
rankst = RANKS_T.copy()
results = np.array(us)
print('Running CC-CPD')
# Run all scfs here so we will have same starting points for CC
run_scfs(N, us, 'calculated/{}-site/scfs_different_u.p'.format(N))
with open('calculated/{}-site/scfs_different_u.p'.format(N), 'rb') as fp:
ref_scfs = pickle.load(fp)
for idxr, rank in enumerate(rankst):
energies = []
converged = False
# timb = time.process_time()
amps = None
for idxu, (u, curr_scf) in enumerate(zip(us, ref_scfs)):
tim = time.process_time()
rhf = hubbard_from_scf(scf.RHF, N, N, u, USE_PBC)
rhf.max_cycle = 1
rhf.scf()
e_scf, mo_coeff, mo_energy = curr_scf
cc = RCCSD_CPD_LS_T_HUB(rhf,
rankt={'t2': rank},
mo_coeff=mo_coeff,
mo_energy=mo_energy)
if not converged:
amps = None
converged, energy, amps = classic_solver(cc,
lam=lambdas[idxr][idxu],
conv_tol_energy=1e-8,
conv_tol_amps=1e-7,
max_cycle=40000,
verbose=logger.NOTE)
# converged, energy, amps = step_solver(
# cc, beta=0.7, # (1 - 1. / lambdas[idxr][idxu]),
# conv_tol_energy=1e-8,
# conv_tol_amps=1e-7, max_cycle=20000,
# verbose=logger.NOTE)
if np.isnan(energy):
Warning('Warning: N = {}, U = {} '
'Rank = {} did not converge'.format(N, u, rank))
energies.append(energy + e_scf)
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}\n'.format(
idxu + 1, len(us), rank, elapsed))
results = np.column_stack((results, energies))
# elapsedb = time.process_time() - timb
# print('Batch {} out of {}, rank = {}, time: {}'.format(
# 0 + 1, len(rankst), rank, elapsedb))
np.savetxt('calculated/{}-site/energy_vs_u.txt'.format(N),
results,
header='U ' + ' '.join('R={}'.format(rr) for rr in rankst))
us, *energies_l = np.loadtxt(
'calculated/{}-site/energy_vs_u.txt'.format(N), unpack=True)
# Plot
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
plt.plot(us, energies)
plt.xlabel('$U$')
plt.ylabel('$E$, H')
plt.title('Energy behavior for different ranks')
fig.show()
def calc_err_vs_r_cpd():
"""
Plot error of RCCSD-CPD vs rank for weak corellation
"""
# Set up parameters of the script
N = 14
U = 2
rankst = np.round(N**np.linspace(0.2, 1.8, num=10)).astype('int')
# Run RHF calculations
from pyscf import scf
from tcc.hubbard import hubbard_from_scf
rhf = hubbard_from_scf(scf.RHF, N, N, U, 'y')
rhf.damp = -4.0
rhf.scf()
from tcc.cc_solvers import (classic_solver, root_solver)
from tcc.rccsd import RCCSD_UNIT
from tcc.rccsd_cpd import RCCSD_CPD_LS_T_HUB
from tensorly.decomposition import parafac
# Run reference calculation
cc_ref = RCCSD_UNIT(rhf)
_, energy_ref, amps_ref = root_solver(cc_ref, conv_tol=1e-10)
energies = []
deltas = []
for idx, rank in enumerate(rankst):
tim = time.process_time()
cc = RCCSD_CPD_LS_T_HUB(rhf, rankt=rank)
xs = parafac(
amps_ref.t2, rank, tol=1e-14
)
amps_guess = cc.types.AMPLITUDES_TYPE(
amps_ref.t1, *xs
)
converged, energy, amps = classic_solver(
cc, lam=1.8, conv_tol_energy=1e-14,
conv_tol_amps=1e-10, max_cycle=10000,
amps=amps_guess, verbose=logger.NOTE)
if not converged:
Warning(
'Warning: N = {}, U = {} '
'Rank = {} did not converge'.format(N, U, rank)
)
energies.append(energy)
deltas.append(energy - energy_ref)
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}'.format(
idx + 1, len(rankst), rank, elapsed
))
results = np.column_stack((rankst, energies, deltas))
np.savetxt(
'calculated/{}-site/err_vs_rank.txt'.format(N),
results, header='Rank Energy Delta', fmt=('%i', '%e', '%e')
)
rankst, energies, deltas = np.loadtxt(
'calculated/{}-site/err_vs_rank.txt'.format(N), unpack=True)
# Plot
from matplotlib import pyplot as plt
plt.plot(np.log(rankst)/np.log(N), np.log10(np.abs(deltas)))
plt.xlabel('log$_N(R)$')
plt.ylabel('log($\Delta$)')
plt.title('Error dependence on rank in weak correlation regime')
plt.show()
def calc_energy_vs_d_cpd():
"""
Plot energy of RCCSD-CPD for different distances in dissociation of N2
"""
# Set up parameters of the script
basis = 'cc-pvdz'
dists = np.linspace(0.8, 2.7, num=15)
lambdas = [
3,
] * 6 + [
5,
] * 6 + [
6,
] * 3
rankst = np.array([2, 4, 5, 6, 8]).astype('int')
def make_mol(dist):
from pyscf import gto
mol = gto.Mole()
mol.atom = [[7, (0., 0., 0.)], [7, (0., 0., dist)]]
mol.basis = {'N': basis}
mol.build()
return mol
mols = [make_mol(dist) for dist in dists]
results = np.array(dists)
# Run all scfs here so we will have same starting points for CC
run_scfs(mols, 'calculated/{}/scfs_different_dist.p'.format(basis))
with open('calculated/{}/scfs_different_dist.p'.format(basis), 'rb') as fp:
ref_scfs = pickle.load(fp)
for idxr, rank in enumerate(rankst):
lambdas = [
3,
] * 6 + [
4,
] * 0 + [
6,
] * 6 + [
6,
] * 3
energies = []
converged = False
# timb = time.process_time()
for idxd, (dist, curr_scf) in enumerate(zip(dists, ref_scfs)):
tim = time.process_time()
rhf = scf.density_fit(scf.RHF(mols[idxd]))
rhf.max_cycle = 1
rhf.scf()
e_scf, mo_coeff, mo_energy = curr_scf
cc = RCCSD_CPD_LS_T(rhf,
rankt=rank,
mo_coeff=mo_coeff,
mo_energy=mo_energy)
if not converged:
amps = None
converged, energy, amps = classic_solver(cc,
lam=lambdas[idxd],
conv_tol_energy=1e-8,
conv_tol_amps=1e-7,
max_cycle=30000,
verbose=logger.NOTE)
if not converged:
Warning('Warning: D = {} Rank = {}'
' did not converge'.format(dist, rank))
energies.append(energy + e_scf)
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}\n'.format(
idxd + 1, len(dists), rank, elapsed))
results = np.column_stack((results, energies))
# elapsedb = time.process_time() - timb
# print('Batch {} out of {}, rank = {}, time: {}'.format(
# 0 + 1, len(rankst), rank, elapsedb))
np.savetxt('calculated/{}/energy_vs_d.txt'.format(basis),
results,
header='Dist ' + ' '.join('R={}'.format(rr) for rr in rankst))
us, *energies_l = np.loadtxt('calculated/{}/energy_vs_d.txt'.format(basis),
unpack=True)
# Plot
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
plt.plot(dists, energies, marker='o')
plt.xlabel('$D, \AA$')
plt.ylabel('$E$, H')
plt.title('Energy behavior for different ranks')
fig.show()
def calc_solutions_diff_u_cpd():
"""
Run RCCSD-CPD for all corellation strengths
"""
# Set up parameters of the script
us = U_VALUES.copy()
lambdas = LAMBDAS.copy()
rankst = RANKS_T.copy()
results = np.array(us)
results_t1 = np.array(us)
results_t2 = np.array(us)
# Run all scfs here so we will have same starting points for CC
run_scfs(N, us, 'calculated/{}-site/scfs_different_u_t1.p'.format(N))
with open('calculated/{}-site/scfs_different_u_t1.p'.format(N),
'rb') as fp:
ref_scfs = pickle.load(fp)
for idxr, rank in enumerate(rankst):
t1_norms = []
energies = []
t2_norms = []
# timb = time.process_time()
solutions = []
for idxu, (u, curr_scf) in enumerate(zip(us, ref_scfs)):
tim = time.process_time()
rhf = hubbard_from_scf(scf.RHF, N, N, u, 'y')
rhf.max_cycle = 1
rhf.scf()
e_scf, mo_coeff, mo_energy = curr_scf
cc = RCCSD_nCPD_LS_T_HUB(rhf,
rankt={'t2': rank},
mo_coeff=mo_coeff,
mo_energy=mo_energy)
converged = False
if idxu == 0:
converged, energy, amps = classic_solver(
cc,
lam=lambdas[idxr][idxu],
conv_tol_energy=1e-8,
conv_tol_amps=1e-7,
max_cycle=50000,
verbose=logger.NOTE)
else:
converged, energy, amps = classic_solver(
cc,
lam=lambdas[idxr][idxu],
conv_tol_energy=1e-8,
conv_tol_amps=1e-8,
max_cycle=60000,
verbose=logger.NOTE,
amps=amps)
solutions.append((u, curr_scf, amps))
if np.isnan(energy):
Warning('Warning: N = {}, U = {} '
'Rank = {} did not converge'.format(N, u, rank))
energies.append(energy + e_scf)
norms = amps.map(np.linalg.norm)
if not np.isnan(energy):
t1_norms.append(norms.t1)
else:
t1_norms.append(np.nan)
if not np.isnan(energy):
t2_norms.append(amps.t2.xlam[0, 0])
else:
t2_norms.append(np.nan)
elapsed = time.process_time() - tim
print('Step {} out of {}, rank = {}, time: {}\n'.format(
idxu + 1, len(us), rank, elapsed))
results = np.column_stack((results, energies))
results_t1 = np.column_stack((results_t1, t1_norms))
results_t2 = np.column_stack((results_t2, t2_norms))
with open('amps_and_scf_rank_{}.p'.format(rank), 'wb') as fp:
pickle.dump(solutions, fp)
