def solve(self, hand, r_conv=1.e-7, maxiter=100, max_diis=8, start_diis=1):
### Start of the solve routine
ccpert_tstart = time.time()
# calculate the pseudoresponse from guess amplitudes
pseudoresponse_old = self.pseudoresponse(hand)
print("CCPERT_%s Iteration %3d: pseudoresponse = %.15f dE = % .5E " %
(self.name, 0, pseudoresponse_old, -pseudoresponse_old))
# Set up DIIS before iterations begin
if hand == 'right':
diis_object = helper_diis(self.x1, self.x2, max_diis)
else:
diis_object = helper_diis(self.y1, self.y2, max_diis)
# calculate the inhomogenous terms of the left hand amplitudes equation before iterations begin
self.im_y1 = self.inhomogenous_y1()
self.im_y2 = self.inhomogenous_y2()
# Iterate!
for CCPERT_iter in range(1, maxiter + 1):
# Residual build and update
if hand == 'right':
rms = self.update_X()
else:
rms = self.update_Y()
# pseudoresponse with updated amplitudes
pseudoresponse = self.pseudoresponse(hand)
# Print CCPERT iteration information
print(
'CCPERT_%s Iteration %3d: pseudoresponse = %.15f dE = % .5E DIIS = %d'
%
(self.name, CCPERT_iter, pseudoresponse,
(pseudoresponse - pseudoresponse_old), diis_object.diis_size))
# Check convergence
if (rms < r_conv):
print('\nCCPERT_%s has converged in %.3f seconds!' %
(self.name, time.time() - ccpert_tstart))
return pseudoresponse
# Update old pseudoresponse
pseudoresponse_old = pseudoresponse
# Add the new error vector
if hand == 'right':
diis_object.add_error_vector(self.x1, self.x2)
else:
diis_object.add_error_vector(self.y1, self.y2)
if CCPERT_iter >= start_diis:
if hand == 'right':
self.x1, self.x2 = diis_object.extrapolate(
self.x1, self.x2)
else:
self.y1, self.y2 = diis_object.extrapolate(
self.y1, self.y2)
def solve(self, hand, r_conv=1.e-7, maxiter=100, max_diis=8, start_diis=1):
### Start of the solve routine
ccpert_tstart = time.time()
# calculate the pseudoresponse from guess amplitudes
pseudoresponse_old = self.pseudoresponse(hand)
print("CCPERT_%s Iteration %3d: pseudoresponse = %.15f dE = % .5E " % (self.name, 0, pseudoresponse_old, -pseudoresponse_old))
# Set up DIIS before iterations begin
if hand == 'right':
diis_object = helper_diis(self.x1, self.x2, max_diis)
else:
diis_object = helper_diis(self.y1, self.y2, max_diis)
# calculate the inhomogenous terms of the left hand amplitudes equation before iterations begin
self.im_y1 = self.inhomogenous_y1()
self.im_y2 = self.inhomogenous_y2()
# Iterate!
for CCPERT_iter in range(1, maxiter + 1):
# Residual build and update
if hand == 'right':
rms = self.update_X()
else:
rms = self.update_Y()
# pseudoresponse with updated amplitudes
pseudoresponse = self.pseudoresponse(hand)
# Print CCPERT iteration information
print('CCPERT_%s Iteration %3d: pseudoresponse = %.15f dE = % .5E DIIS = %d' % (self.name, CCPERT_iter, pseudoresponse, (pseudoresponse - pseudoresponse_old), diis_object.diis_size))
# Check convergence
if (rms < r_conv):
print('\nCCPERT_%s has converged in %.3f seconds!' % (self.name, time.time() - ccpert_tstart))
return pseudoresponse
# Update old pseudoresponse
pseudoresponse_old = pseudoresponse
# Add the new error vector
if hand == 'right':
diis_object.add_error_vector(self.x1, self.x2)
else:
diis_object.add_error_vector(self.y1, self.y2)
if CCPERT_iter >= start_diis:
if hand == 'right':
self.x1, self.x2 = diis_object.extrapolate(self.x1, self.x2)
else:
self.y1, self.y2 = diis_object.extrapolate(self.y1, self.y2)
def compute_energy(self,
e_conv=1e-7,
r_conv=1e-7,
maxiter=100,
max_diis=8,
start_diis=1):
### Start Iterations
ccsd_tstart = time.time()
# Compute MP2 energy (dp)
CCSDcorr_E_old = self.compute_corr_energy(self.F, self.t1, self.t2)
print(
"CCSD Iteration %3d: CCSD correlation = %.15f dE = % .5E MP2" %
(0, CCSDcorr_E_old, -CCSDcorr_E_old))
CCSDcorr_E_old = np.float32(CCSDcorr_E_old)
# Set up DIIS before iterations begin
diis_object = helper_diis(self.t1, self.t2, max_diis)
# Iterations
for CCSD_iter in range(1, maxiter + 1):
rms = self.update()
# Compute CCSD correlation energy
CCSDcorr_E = self.compute_corr_energy(self.Fsp, self.t1_sp,
self.t2_sp)
# Print CCSD iteration information
print(
'CCSD Iter %3d: CCSD Ecorr = %.15f dE = % .5E rms = % .5E DIIS = %d'
% (CCSD_iter, CCSDcorr_E, CCSDcorr_E - CCSDcorr_E_old, rms,
diis_object.diis_size))
# Check convergence
if (abs(CCSDcorr_E - CCSDcorr_E_old) < e_conv and rms < r_conv):
self.t1 = np.float64(self.t1_sp)
self.t2 = np.float64(self.t2_sp)
print('\nCCSD has converged in %.3f seconds!' %
(time.time() - ccsd_tstart))
return CCSDcorr_E
# return t1_init
# Update old energy
CCSDcorr_E_old = CCSDcorr_E
self.t1 = np.float64(self.t1_sp)
self.t2 = np.float64(self.t2_sp)
# Add the new error vector
diis_object.add_error_vector(self.t1, self.t2)
if CCSD_iter >= start_diis:
self.t1, self.t2 = diis_object.extrapolate(self.t1, self.t2)
self.t1_sp = np.float32(self.t1)
self.t2_sp = np.float32(self.t2)
def compute_lambda(self,
e_conv=1e-7,
r_conv=1e-7,
maxiter=100,
max_diis=8,
start_diis=1):
### Start Iterations
cclambda_tstart = time.time()
if self.precision == "mixed":
pseudoenergy_old = self.pseudoenergy(self.ERI64, self.l2)
else:
pseudoenergy_old = self.pseudoenergy(self.ERI, self.l2)
print("CCLAMBDA Iteration %3d: pseudoenergy = %.15f dE = % .5E" %
(0, np.real(pseudoenergy_old), np.real(-pseudoenergy_old)))
# Set up DIIS before iterations begin
diis_object = helper_diis(self.l1, self.l2, max_diis)
# Iterate
for CCLAMBDA_iter in range(1, maxiter + 1):
rms_l = self.update_l()
# Compute pseudoenergy
if self.precision == "mixed":
pseudo_energy = self.pseudoenergy(self.ERI64, self.l2)
else:
pseudo_energy = self.pseudoenergy(self.ERI, self.l2)
# Print CCLAMBDA iteration information
print(
'CCLAMBDA Iteration %3d: pseudoenergy = %.15f dE = % .5E DIIS = %d'
% (CCLAMBDA_iter, np.real(pseudo_energy),
np.real(pseudo_energy - pseudoenergy_old),
diis_object.diis_size))
# Check convergence
if (rms_l < r_conv):
print('\nCCLAMBDA has converged in %.3f seconds!' %
(time.time() - cclambda_tstart))
return pseudo_energy
# Update old pseudoenergy
pseudoenergy_old = pseudo_energy
# Add the new error vector
diis_object.add_error_vector(self.l1, self.l2)
if CCLAMBDA_iter >= start_diis:
self.l1, self.l2 = diis_object.extrapolate(self.l1, self.l2)
def compute_energy(self,
e_conv=1e-7,
r_conv=1e-7,
maxiter=100,
max_diis=8,
start_diis=1):
### Start Iterations
ccsd_tstart = time.time()
# Compute MP2 energy
CCSDcorr_E_old = self.compute_corr_energy()
print(
"CCSD Iteration %3d: CCSD correlation = %.15f dE = % .5E MP2" %
(0, CCSDcorr_E_old, -CCSDcorr_E_old))
# Set up DIIS before iterations begin
diis_object = helper_diis(self.t1, self.t2, max_diis)
# Iterate!
for CCSD_iter in range(1, maxiter + 1):
rms = self.update()
# Compute CCSD correlation energy
CCSDcorr_E = self.compute_corr_energy()
# Print CCSD iteration information
print(
'CCSD Iteration %3d: CCSD correlation = %.15f dE = % .5E DIIS = %d'
% (CCSD_iter, CCSDcorr_E, (CCSDcorr_E - CCSDcorr_E_old),
diis_object.diis_size))
# Check convergence
if (abs(CCSDcorr_E - CCSDcorr_E_old) < e_conv and rms < r_conv):
print('\nCCSD has converged in %.3f seconds!' %
(time.time() - ccsd_tstart))
return CCSDcorr_E
# Update old energy
CCSDcorr_E_old = CCSDcorr_E
# Add the new error vector
diis_object.add_error_vector(self.t1, self.t2)
if CCSD_iter >= start_diis:
self.t1, self.t2 = diis_object.extrapolate(self.t1, self.t2)
def compute_lambda(self,
r_conv=1e-7,
maxiter=100,
max_diis=8,
start_diis=1):
### Start Iterations
cclambda_tstart = time.time()
pseudoenergy_old = self.pseudoenergy()
print("CCLAMBDA Iteration %3d: pseudoenergy = %.15f dE = % .5E" %
(0, pseudoenergy_old, -pseudoenergy_old))
# Set up DIIS before iterations begin
diis_object = helper_diis(self.l1, self.l2, max_diis)
# Iterate!
for CCLAMBDA_iter in range(1, maxiter + 1):
rms = self.update()
# Compute pseudoenergy
pseudoenergy = self.pseudoenergy()
# Print CCLAMBDA iteration information
print(
'CCLAMBDA Iteration %3d: pseudoenergy = %.15f dE = % .5E DIIS = %d'
% (CCLAMBDA_iter, pseudoenergy,
(pseudoenergy - pseudoenergy_old), diis_object.diis_size))
# Check convergence
if (rms < r_conv):
print('\nCCLAMBDA has converged in %.3f seconds!' %
(time.time() - cclambda_tstart))
return pseudoenergy
# Update old pseudoenergy
pseudoenergy_old = pseudoenergy
# Add the new error vector
diis_object.add_error_vector(self.l1, self.l2)
if CCLAMBDA_iter >= start_diis:
self.l1, self.l2 = diis_object.extrapolate(self.l1, self.l2)
def compute_energy(self,
e_conv=1e-7,
r_conv=1e-7,
maxiter=100,
max_diis=8,
start_diis=1):
### Start Iterations
ccsd_tstart = time.time()
# Integrals and denominators
F = self.F
L = self.L
ERI = self.ERI
Dia = self.Dia
Dijab = self.Dijab
if self.precision == "mixed":
F64 = self.F64
L64 = self.L64
# Compute MP2 energy
# This is float64 for mixed- and double-precision; float32 for single
if self.precision == "mixed":
CCSDcorr_E_old = self.compute_corr_energy(L64, self.t1, self.t2)
else:
CCSDcorr_E_old = self.compute_corr_energy(L, self.t1, self.t2)
print("CCSD Iter %3d: CCSD Ecorr = %.15f dE = % .5E MP2" %
(0, np.real(CCSDcorr_E_old), np.real(-CCSDcorr_E_old)))
# Set up DIIS before iterations begin
diis_object = helper_diis(self.t1, self.t2, max_diis)
# Iterations
for CCSD_iter in range(1, maxiter + 1):
if self.precision == "single" or self.precision == "mixed":
t1 = np.float32(self.t1)
t2 = np.float32(self.t2)
else:
t1 = self.t1
t2 = self.t2
# build intermediates
Fae = self.build_Fae(F, L, t1, t2)
Fme = self.build_Fme(F, L, t1)
Fmi = self.build_Fmi(F, L, t1, t2)
Wmnij = self.build_Wmnij(ERI, t1, t2)
Wmbej = self.build_Wmbej(ERI, L, t1, t2)
Wmbje = self.build_Wmbje(ERI, t1, t2)
Zmbij = self.build_Zmbij(ERI, t1, t2)
if self.precision == "single" or self.precision == "mixed":
Fae = np.float32(Fae)
Fme = np.float32(Fme)
Fmi = np.float32(Fmi)
Wmnij = np.float32(Wmnij)
Wmbej = np.float32(Wmbej)
Wmbje = np.float32(Wmbje)
Zmbij = np.float32(Zmbij)
# build residuals and update the amplitues
r1 = self.r_T1(F, ERI, L, t1, t2, Fae, Fme, Fmi)
r2 = self.r_T2(F, ERI, L, t1, t2, Fae, Fme, Fmi, Wmnij, Wmbej,
Wmbje, Zmbij)
self.t1 += r1 / Dia
self.t2 += r2 / Dijab
rms = np.einsum('ia,ia->', r1 / Dia, r1 / Dia)
rms += np.einsum('ijab,ijab->', r2 / Dijab, r2 / Dijab)
rms = np.sqrt(rms)
# Compute CCSD correlation energy
if self.precision == "mixed":
CCSDcorr_E = self.compute_corr_energy(self.L64, self.t1,
self.t2)
else:
CCSDcorr_E = self.compute_corr_energy(L, self.t1, self.t2)
# Print CCSD iteration information
print(
'CCSD Iter %3d: CCSD Ecorr = %.15f dE = % .5E rms = % .5E DIIS = %d'
% (CCSD_iter, CCSDcorr_E, CCSDcorr_E - CCSDcorr_E_old, rms,
diis_object.diis_size))
# Check convergence
if (abs(CCSDcorr_E - CCSDcorr_E_old) < e_conv and rms < r_conv):
print('\nCCSD has converged in %.3f seconds!' %
(time.time() - ccsd_tstart))
return CCSDcorr_E
# Update old energy
CCSDcorr_E_old = CCSDcorr_E
# Add the new error vector
diis_object.add_error_vector(self.t1, self.t2)
if CCSD_iter >= start_diis:
self.t1, self.t2 = diis_object.extrapolate(self.t1, self.t2)
