def test_denisty_fit_interface(self): mydf = df.DF(mol) mycc1 = ccsd.CCSD(mf).density_fit(auxbasis='ccpvdz-ri', with_df=mydf).run() self.assertAlmostEqual(mycc1.e_tot, -76.119348934346789, 7)
mycc = gccsd.GCCSD(mf) eris = mycc.ao2mo() mycc.kernel(eris=eris) l1, l2 = mycc.solve_lambda(mycc.t1, mycc.t2, eris=eris) l1 = mycc.spin2spatial(l1, mycc.mo_coeff.orbspin) l2 = mycc.spin2spatial(l2, mycc.mo_coeff.orbspin) print(lib.finger(l1[0]) - -0.0030030170069977758) print(lib.finger(l1[1]) - -0.0030030170069977758) print(lib.finger(l2[0]) - -0.041444910588788492) print(lib.finger(l2[1]) - 0.1077575086912813) print(lib.finger(l2[2]) - -0.041444910588788492) print(abs(l2[1] - l2[1].transpose(1, 0, 2, 3) - l2[0]).max()) print(abs(l2[1] - l2[1].transpose(0, 1, 3, 2) - l2[0]).max()) from pyscf.cc import ccsd mycc0 = ccsd.CCSD(mf0) eris0 = mycc0.ao2mo() mycc0.kernel(eris=eris0) t1 = mycc0.t1 t2 = mycc0.t2 imds = ccsd_lambda.make_intermediates(mycc0, t1, t2, eris0) l1, l2 = ccsd_lambda.update_lambda(mycc0, t1, t2, t1, t2, eris0, imds) l1ref, l2ref = ccsd_lambda.update_lambda(mycc0, t1, t2, l1, l2, eris0, imds) t1 = mycc.spatial2spin(t1, mycc.mo_coeff.orbspin) t2 = mycc.spatial2spin(t2, mycc.mo_coeff.orbspin) l1 = mycc.spatial2spin(l1, mycc.mo_coeff.orbspin) l2 = mycc.spatial2spin(l2, mycc.mo_coeff.orbspin) imds = make_intermediates(mycc, t1, t2, eris) l1, l2 = update_lambda(mycc, t1, t2, l1, l2, eris, imds) l1 = mycc.spin2spatial(l1, mycc.mo_coeff.orbspin)
no, nv = mycc1.t1.shape mycci = copy.copy(mycc1) erisi = copy.copy(eris1) erisi.oooo = eris1.oooo + numpy.sin(eris1.oooo) * 1j erisi.oooo = erisi.oooo + erisi.oooo.conj().transpose(1, 0, 3, 2) erisi.ovoo = eris1.ovoo + numpy.sin(eris1.ovoo) * 1j erisi.ovvo = eris1.ovvo + numpy.sin(eris1.ovvo) * 1j erisi.oovv = eris1.oovv + numpy.sin(eris1.oovv) * 1j erisi.oovv = erisi.oovv + erisi.oovv.conj().transpose(1, 0, 3, 2) erisi.ovov = eris1.ovov + numpy.sin(eris1.ovov) * 1j erisi.ovvv = eris1.ovvv + numpy.sin(eris1.ovvv) * 1j erisi.vvvv = eris1.vvvv + numpy.sin(eris1.vvvv) * 1j erisi.vvvv = erisi.vvvv + erisi.vvvv.conj().transpose(1, 0, 3, 2) mycc2 = ccsd.CCSD(mf) mycc21 = ccsd.CCSD(mf1) mycc2.__dict__.update(mycc.__dict__) mycc21.__dict__.update(mycc1.__dict__) eris21 = mycc21.ao2mo() mycc3 = ccsd.CCSD(mf) mycc31 = ccsd.CCSD(mf1) mycc3.__dict__.update(mycc.__dict__) mycc31.__dict__.update(mycc1.__dict__) mycc3 = mycc3.set(max_memory=0, direct=True) mycc31 = mycc31.set(max_memory=0, direct=True) eris31 = mycc31.ao2mo() def tearDownModule():
def test_update_amps(self): mol = gto.M() nocc, nvir = 5, 12 nmo = nocc + nvir nmo_pair = nmo * (nmo + 1) // 2 mf = scf.RHF(mol) np.random.seed(12) mf._eri = np.random.random(nmo_pair * (nmo_pair + 1) // 2) mf.mo_coeff = np.random.random((nmo, nmo)) mf.mo_energy = np.arange(0., nmo) mf.mo_occ = np.zeros(nmo) mf.mo_occ[:nocc] = 2 vhf = mf.get_veff(mol, mf.make_rdm1()) cinv = np.linalg.inv(mf.mo_coeff) mf.get_hcore = lambda *args: (reduce(np.dot, (cinv.T * mf.mo_energy, cinv)) - vhf) mycc1 = rccsd.RCCSD(mf) eris1 = mycc1.ao2mo() mycc2 = ccsd.CCSD(mf) eris2 = mycc2.ao2mo() a = np.random.random((nmo, nmo)) * .1 eris1.fock += a + a.T.conj() eris2.fock += a + a.T t1 = np.random.random((nocc, nvir)) * .1 t2 = np.random.random((nocc, nocc, nvir, nvir)) * .1 t2 = t2 + t2.transpose(1, 0, 3, 2) t1b, t2b = ccsd.update_amps(mycc2, t1, t2, eris2) self.assertAlmostEqual(lib.finger(t1b), -106360.5276951083, 6) self.assertAlmostEqual(lib.finger(t2b), 66540.100267798145, 6) mycc2.max_memory = 0 t1a, t2a = ccsd.update_amps(mycc2, t1, t2, eris2) self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 9) self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 9) t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2) self.assertAlmostEqual(lib.finger(t2tril), 13306.139402693696, 8) Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2) self.assertAlmostEqual(lib.finger(Ht2), 760.50164232208408, 9) mycc1.cc2 = False t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1) self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7) self.assertAlmostEqual(lib.finger(t2a), 66540.100267798145, 6) self.assertAlmostEqual(abs(t1a - t1b).max(), 0, 6) self.assertAlmostEqual(abs(t2a - t2b).max(), 0, 6) mycc1.cc2 = True t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1) self.assertAlmostEqual(lib.finger(t1a), -106360.5276951083, 7) self.assertAlmostEqual(lib.finger(t2a), -1517.9391800662809, 7) mol = gto.Mole() mol.verbose = 0 mol.atom = [[8, (0., 0., 0.)], [1, (1., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]] mol.basis = { 'H': 'sto3g', 'O': 'cc-pvdz', } mol.charge = 1 mol.build(0, 0) mycc2.direct = True eris2.vvvv = None eris2.mol = mol mycc2.mo_coeff, eris2.mo_coeff = eris2.mo_coeff, None t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=True) self.assertAlmostEqual(lib.finger(t2tril), 680.07199094501584, 9) t2tril = ccsd._add_vvvv_tril(mycc2, t1, t2, eris2, with_ovvv=False) self.assertAlmostEqual(lib.finger(t2tril), 446.56702664171348, 9) Ht2 = ccsd._add_vvvv_full(mycc2, t1, t2, eris2) self.assertAlmostEqual(lib.finger(Ht2), 48.122317842230686, 9) eri1 = np.random.random((nmo, nmo, nmo, nmo)) + np.random.random( (nmo, nmo, nmo, nmo)) * 1j eri1 = eri1.transpose(0, 2, 1, 3) eri1 = eri1 + eri1.transpose(1, 0, 3, 2).conj() eri1 = eri1 + eri1.transpose(2, 3, 0, 1) eri1 *= .1 eris1.oooo = eri1[:nocc, :nocc, :nocc, :nocc].copy() eris1.ovoo = eri1[:nocc, nocc:, :nocc, :nocc].copy() eris1.ovov = eri1[:nocc, nocc:, :nocc, nocc:].copy() eris1.oovv = eri1[:nocc, :nocc, nocc:, nocc:].copy() eris1.ovvo = eri1[:nocc, nocc:, nocc:, :nocc].copy() eris1.ovvv = eri1[:nocc, nocc:, nocc:, nocc:].copy() eris1.vvvv = eri1[nocc:, nocc:, nocc:, nocc:].copy() a = np.random.random((nmo, nmo)) * .1j eris1.fock = eris1.fock + a + a.T.conj() t1 = t1 + np.random.random((nocc, nvir)) * .1j t2 = t2 + np.random.random((nocc, nocc, nvir, nvir)) * .1j t2 = t2 + t2.transpose(1, 0, 3, 2) mycc1.cc2 = False t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1) self.assertAlmostEqual(lib.finger(t1a), -13.32050019680894 - 1.8825765910430254j, 9) self.assertAlmostEqual(lib.finger(t2a), 9.2521062044785189 + 29.999480274811873j, 9) mycc1.cc2 = True t1a, t2a = rccsd.update_amps(mycc1, t1, t2, eris1) self.assertAlmostEqual(lib.finger(t1a), -13.32050019680894 - 1.8825765910430254j, 9) self.assertAlmostEqual(lib.finger(t2a), -0.056223856104895858 + 0.025472249329733986j, 9)
def test(): nao = 2 U = 2. solver = 'cc' # 'scf', 'cc', 'fci' if solver == 'fci': assert (fci_) htb = -1*_tb(nao) htb[0,0]=0.0 eri = np.zeros([nao,nao,nao,nao]) for k in range(nao): eri[k,k,k,k] = U #delta = _get_delta(htb) delta=0.01 mol = gto.M() mol.build() mol.nelectron = 2 #nao mf = scf.RHF(mol) mf.verbose = 0 # mf.verbose = 4 mf.max_memory = 1000 mf.get_hcore = lambda *args: htb mf.get_ovlp = lambda *args: np.eye(nao) mf._eri = ao2mo.restore(8, eri, nao) mf.init_guess = '1e' mf.scf() print 'MF energy = %20.12f' % (mf.e_tot) print 'MO energies :' print mf.mo_energy print '----\n' HamCheMPS2, theFCI = None, None if solver == 'cc': cc = ccsd.CCSD(mf) ecc = cc.ccsd()[0] print "CCSD corr = %20.12f" % (ecc) print "Solving lambda equations..." cc.solve_lambda() print "Repeating with EOM CCSD" #cc_eom = eom_rccsd.RCCSD(mf) # cc_eomip = eom_rccsd.EOMIP(cc) # cc_eomea = eom_rccsd.EOMEA(cc) #def ao2mofn_ (mol, bas, compact): # return ao2mo.incore.general(mf._eri, bas, compact=compact) #eri_eom = eom_rccsd._ERIS(cc_eom, ao2mofn=ao2mofn_) #ecc_eom = cc_eom.ccsd(eris=eri_eom)[0] #print "EOM-CCSD corr = %20.12f" % (ecc_eom) #print '====\n' #cc_eom.t1 = cc.t1 #cc_eom.t2 = cc.t2 #cc_eom.l1 = cc.l1 #cc_eom.l2 = cc.l2 e_vector = list() b_vector = list() for q in range(nao): e_vector.append(greens_function.greens_e_vector_ip_rhf(cc,q)) b_vector.append(greens_function.greens_b_vector_ip_rhf(cc,q)) dm = np.zeros((nao,nao,), np.complex128) for q in range(nao): for p in range(nao): dm[p,q] = -np.dot(e_vector[q], b_vector[p]) print dm.real hc = np.dot(mf.mo_coeff.T, np.dot(mf.get_hcore(), mf.mo_coeff)) print 'CC IP evals' eomip = eom_rccsd.EOMIP(cc) evals, evecs = eomip.ipccsd(nroots=e_vector[0].shape[0]) print evals # these are sums over principal poles A = np.dot(evecs, np.dot(np.diag(evals), inv(evecs))) dt = np.zeros((nao,nao,), np.complex128) for q in range(nao): for p in range(nao): dt[p,q] = np.dot(e_vector[q], np.dot(A, b_vector[p])) nn = 2*0.5*np.trace(dm).real ee = 2*0.5*np.trace(np.dot(dm, hc)).real \ + 2*0.5*np.trace(dt).real print 'N = %16.8f' % (nn) print 'E = %16.8f' % (ee) elif solver == 'fci': h0 = 0. h1t = np.dot(mf.mo_coeff.T, np.dot(htb, mf.mo_coeff)) erit = ao2mo.incore.full(mf._eri, mf.mo_coeff, compact=False) erit = erit.reshape([nao,nao,nao,nao]) HamCheMPS2, theFCI, GSvector, en_FCIgs = \ fci_sol (h0, h1t, erit, mol.nelectron) print "FCI corr = %20.12f" % (en_FCIgs-mf.e_tot) evals, evecs = scipy.linalg.eigh(htb) mu = ( mf.mo_energy[mol.nelectron//2-1] + \ mf.mo_energy[mol.nelectron//2] )/2. #mu += 0.05 def _gf (w, delta): if solver == 'scf': return mf_gf (w, delta, mf.mo_coeff, mf.mo_energy) elif solver == 'cc': return cc_gf (w, delta, cc, mf.mo_coeff) elif solver == 'fci': return fci_gf (w, delta, mf.mo_coeff, en_FCIgs, GSvector, \ HamCheMPS2, theFCI) def _mf_gf (w, delta): return mf_gf (w, delta, evecs, evals) freqs_ = _get_linear_freqs(-6+U/2., 6+U/2., 64)[0] gfx = _gf (freqs_, delta) dos = np.zeros([freqs_.shape[0]]) for k in range(nao): dos[:] += -1./np.pi * np.imag(gfx[k,k,:]) plt.plot(freqs_, dos) plt.show() def _eval_p(w, delta): gf_ = _gf(np.array([w]), delta) return gf_[:,:,0] def _eval_n(w, delta): return np.trace(_eval_p(w, delta)) powers = [10**i for i in range(7)] for LARGE in powers: #LARGE = 100000000 mf_infi = _mf_gf(np.array([1j*LARGE+mu]), delta_) gf_infi = _gf(np.array([1j*LARGE+mu]), delta_) sigma_infi = get_sigma(mf_infi, gf_infi)[:,:,0] mf_infr = _mf_gf(np.array([LARGE]), delta_) gf_infr = _gf(np.array([LARGE]), delta_) sigma_infr = get_sigma(mf_infr, gf_infr)[:,:,0] print LARGE, sigma_infi[0,0] print LARGE, sigma_infr[0,0] def _eval_en0(w, delta): gf_ = _gf(np.array([w]), delta) return np.trace(np.dot(htb, gf_[:,:,0])) def _eval_en1(w, delta): gf_ = _gf(np.array([w]), delta) if np.iscomplex(w): return np.trace(np.dot(sigma_infi, gf_[:,:,0])) else: return np.trace(np.dot(sigma_infr, gf_[:,:,0])) def _eval_en2(w, delta): mf_ = _mf_gf(np.array([w]), delta) gf_ = _gf(np.array([w]), delta) sigma = get_sigma(mf_, gf_) if np.iscomplex(w): return np.trace(np.dot(sigma[:,:,0]-sigma_infi, gf_[:,:,0])) else: return np.trace(np.dot(sigma[:,:,0]-sigma_infr, gf_[:,:,0])) lplt = False if lplt: def real_fn(w, gf_fn): return -1./np.pi * np.imag(gf_fn(w, delta_)) def imag_fn(w, gf_fn): return -2./np.pi * np.real(gf_fn(1j*w+mu, delta_)) #fnr0 = np.zeros_like(freqs_) #fnr1 = np.zeros_like(freqs_) #fnr2 = np.zeros_like(freqs_) #fnr3 = np.zeros_like(freqs_) fni0 = np.zeros_like(freqs_) fni1 = np.zeros_like(freqs_) fni2 = np.zeros_like(freqs_) fni3 = np.zeros_like(freqs_) wmin = np.min(freqs_) wmax = np.max(freqs_) for iw, w in enumerate(freqs_): #fnr0[iw] = real_fn(w+mu, _eval_n) #fnr1[iw] = real_fn(w+mu, _eval_en0) #fnr2[iw] = real_fn(w+mu, _eval_en1) #fnr3[iw] = real_fn(w+mu, _eval_en2) fni0[iw] = imag_fn(w, _eval_n) fni1[iw] = imag_fn(w, _eval_en0) fni2[iw] = imag_fn(w, _eval_en1) fni3[iw] = imag_fn(w, _eval_en2) #plt.plot(freqs_+mu, fnr0) #plt.figure() #plt.plot(freqs_+mu, fnr1) #plt.figure() #plt.plot(freqs_+mu, fnr2) #plt.figure() #plt.plot(freqs_+mu, fnr3) #plt.figure() plt.plot(freqs_, fni0) plt.figure() plt.plot(freqs_, fni1) plt.figure() plt.plot(freqs_, fni2) plt.figure() plt.plot(freqs_, fni3) plt.show() li = True lr = False # NL = # poles to left of mu, NR = # poles to right of mu # nao = NL + NR # integration gives NR - NL (factor of 2 in imag_fn) INF=10000 if li: print '\nnumber [imag]' #nint_n = numint_.int_quad_imag (_eval_n, mu, \ # epsrel=1.0e-5, delta=delta_) nint_n = numint_.int_quad_imag (_eval_n, mu, \ epsrel=1.0e-5, delta=delta_) nint_n = 2*0.5*(nao-nint_n) print 'nint_n [imag] = ', nint_n print '----\n' if lr: print '\nnumber [real]' nint_n = numint_.int_quad_real (_eval_n, mu, x0=-40., \ epsrel=1.0e-5, delta=delta_) nint_n = numint_.int_quad_real (_eval_n, mu, x0=-40., \ epsrel=1.0e-5, delta=delta_) print 'nint_n [real] = ', 2*nint_n print '----\n' if li: print 'energy [imag]' # trace of h with GF #nint_e0 = numint_.int_quad_imag (_eval_en0, mu, \ # epsrel=1.0e-5, delta=delta_) nint_e0 = numint_.int_quad_imag (_eval_en0, mu, \ epsrel=1.0e-5, delta=delta_) print 'nint H_c [imag] = ', -nint_e0 # energy due to 1/w self-energy #nint_e2 = numint_.int_quad_imag (_eval_en2, mu, \ # epsrel=1.0e-5, delta=delta_) nint_e2 = numint_.int_quad_imag (_eval_en2, mu, \ epsrel=1.0e-5, delta=delta_) print 'nint S[w] [imag] = ', -nint_e2/2. # energy due to a constant self-energy #nint_e1 = numint_.int_quad_imag (_eval_en1, mu, \ # epsrel=1.0e-5, delta=delta_) nint_e1 = numint_.int_quad_imag (_eval_en1, mu, \ epsrel=1.0e-5, delta=delta_) e1 = (np.real(np.trace(sigma_infi)) - nint_e1) print 'nint S[inf] [imag] = ', e1/2 print 'nint_e = ', -nint_e0 + e1/2. -nint_e2/2. print '----\n' if lr: print 'energy [real]' # trace of h with GF nint_e0 = numint_.int_quad_real (_eval_en0, mu, x0=-40., \ epsrel=1.0e-5, delta=delta_) print 'nint H_c [real] = ', 2*nint_e0 # energy due to 1/w self-energy nint_e2 = numint_.int_quad_real (_eval_en2, mu, x0=-40., \ epsrel=1.0e-5, delta=delta_) print 'nint S[w] [real] = ', nint_e2 # energy due to a constant self-energy nint_e1 = numint_.int_quad_real (_eval_en1, mu, x0=-40., \ epsrel=1.0e-5, delta=delta_) print 'nint S[inf] [real] = ', nint_e1 print 'nint_e = ', 2*nint_e0 + nint_e1 + nint_e2 print '----\n'
def solve(CONST, OEI, FOCK, TEI, Norb, Nel, Nimp, DMguessRHF, energytype='LAMBDA', chempot_imp=0.0, printoutput=True): assert ((energytype == 'LAMBDA') or (energytype == 'LAMBDA_AMP') or (energytype == 'LAMBDA_ZERO') or (energytype == 'CASCI')) # Killing output if necessary if (printoutput == False): sys.stdout.flush() old_stdout = sys.stdout.fileno() new_stdout = os.dup(old_stdout) devnull = os.open('/dev/null', os.O_WRONLY) os.dup2(devnull, old_stdout) os.close(devnull) # Augment the FOCK operator with the chemical potential FOCKcopy = FOCK.copy() if (chempot_imp != 0.0): for orb in range(Nimp): FOCKcopy[orb, orb] -= chempot_imp # Get the RHF solution mol = gto.Mole() mol.build(verbose=0) mol.atom.append(('C', (0, 0, 0))) mol.nelectron = Nel mol.incore_anyway = True mf = scf.RHF(mol) mf.get_hcore = lambda *args: FOCKcopy mf.get_ovlp = lambda *args: np.eye(Norb) mf._eri = ao2mo.restore(8, TEI, Norb) mf.scf(DMguessRHF) DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T) if (mf.converged == False): mf = rhf_newtonraphson.solve(mf, dm_guess=DMloc) DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T) # Check the RHF solution assert (Nel % 2 == 0) numPairs = Nel / 2 FOCKloc = FOCKcopy + np.einsum( 'ijkl,ij->kl', TEI, DMloc) - 0.5 * np.einsum('ijkl,ik->jl', TEI, DMloc) eigvals, eigvecs = np.linalg.eigh(FOCKloc) idx = eigvals.argsort() eigvals = eigvals[idx] eigvecs = eigvecs[:, idx] print "psi4cc::solve : RHF h**o-lumo gap =", eigvals[numPairs] - eigvals[ numPairs - 1] DMloc2 = 2 * np.dot(eigvecs[:, :numPairs], eigvecs[:, :numPairs].T) print "Two-norm difference of 1-RDM(RHF) and 1-RDM(FOCK(RHF)) =", np.linalg.norm( DMloc - DMloc2) # Get the CC solution from pyscf ccsolver = ccsd.CCSD(mf) ccsolver.verbose = 5 ECORR, t1, t2 = ccsolver.ccsd() ERHF = mf.hf_energy ECCSD = ERHF + ECORR # Compute the impurity energy if (energytype == 'CASCI'): # The 2-RDM is not required # Active space energy is computed with the Fock operator of the core (not rescaled) print "ECCSD =", ECCSD ccsolver.solve_lambda() pyscfRDM1 = ccsolver.make_rdm1() # MO space pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize pyscfRDM1 = np.dot(mf.mo_coeff, np.dot(pyscfRDM1, mf.mo_coeff.T)) # From MO to localized space ImpurityEnergy = ECCSD if (chempot_imp != 0.0): # [FOCK - FOCKcopy]_{ij} = chempot_imp * delta(i,j) * delta(i \in imp) ImpurityEnergy += np.einsum('ij,ij->', FOCK - FOCKcopy, pyscfRDM1) else: # Compute the DMET impurity energy based on the lambda equations if (energytype == 'LAMBDA'): ccsolver.solve_lambda() pyscfRDM1 = ccsolver.make_rdm1() # MO space pyscfRDM2 = ccsolver.make_rdm2() # MO space if (energytype == 'LAMBDA_AMP'): # Overwrite lambda tensors with t-amplitudes pyscfRDM1 = ccsolver.make_rdm1(t1, t2, t1, t2) # MO space pyscfRDM2 = ccsolver.make_rdm2(t1, t2, t1, t2) # MO space if (energytype == 'LAMBDA_ZERO'): # Overwrite lambda tensors with 0.0 fake_l1 = np.zeros(t1.shape, dtype=float) fake_l2 = np.zeros(t2.shape, dtype=float) pyscfRDM1 = ccsolver.make_rdm1(t1, t2, fake_l1, fake_l2) # MO space pyscfRDM2 = ccsolver.make_rdm2(t1, t2, fake_l1, fake_l2) # MO space pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize # Print a few to things to double check ''' print "Do we understand how the 1-RDM is stored?", np.linalg.norm( np.einsum('ii->', pyscfRDM1) - Nel ) print "Do we understand how the 2-RDM is stored?", np.linalg.norm( np.einsum('ijkk->ij', pyscfRDM2) / (Nel - 1.0) - pyscfRDM1 ) ''' # Change the pyscfRDM1/2 from MO space to localized space pyscfRDM1 = np.dot(mf.mo_coeff, np.dot(pyscfRDM1, mf.mo_coeff.T)) pyscfRDM2 = np.einsum('ai,ijkl->ajkl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('bj,ajkl->abkl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('ck,abkl->abcl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('dl,abcl->abcd', mf.mo_coeff, pyscfRDM2) ECCSDbis = CONST + np.einsum( 'ij,ij->', FOCKcopy, pyscfRDM1) + 0.5 * np.einsum('ijkl,ijkl->', TEI, pyscfRDM2) print "ECCSD1 =", ECCSD print "ECCSD2 =", ECCSDbis # To calculate the impurity energy, rescale the JK matrix with a factor 0.5 to avoid double counting: 0.5 * ( OEI + FOCK ) = OEI + 0.5 * JK ImpurityEnergy = CONST \ + 0.25 * np.einsum('ij,ij->', pyscfRDM1[:Nimp,:], FOCK[:Nimp,:] + OEI[:Nimp,:]) \ + 0.25 * np.einsum('ij,ij->', pyscfRDM1[:,:Nimp], FOCK[:,:Nimp] + OEI[:,:Nimp]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:Nimp,:,:,:], TEI[:Nimp,:,:,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:Nimp,:,:], TEI[:,:Nimp,:,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:Nimp,:], TEI[:,:,:Nimp,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:,:Nimp], TEI[:,:,:,:Nimp]) # Reviving output if necessary if (printoutput == False): sys.stdout.flush() os.dup2(new_stdout, old_stdout) os.close(new_stdout) return (ImpurityEnergy, pyscfRDM1)
#################################### # Perform the RHF calculations # #################################### mf1 = scf.RHF(mol1) mf1.verbose = 4 mf1.scf() mf2 = scf.RHF(mol2) mf2.verbose = 4 mf2.scf() ###################### # CCSD reference # ###################### # Always calculate the CCSD energy of the small molecule (mol2) ccsolver2 = ccsd.CCSD(mf2) ccsolver2.verbose = 5 ECORR2, t1, t2 = ccsolver2.ccsd() ERHF2 = mf2.hf_energy ECCSD2 = ERHF2 + ECORR2 if (False): ccsolver1 = ccsd.CCSD(mf1) ccsolver1.verbose = 5 ECORR1, t1, t2 = ccsolver1.ccsd() ECCSD1 = mf1.hf_energy + ECORR1 print "ERHF for structure", thestructure, "=", mf1.hf_energy + ERHF2 print "ECCSD for structure", thestructure, "=", ECCSD1 + ECCSD2 # ERHF (reactants) = -925.856396874 # ECCSD (reactants) = -927.858808954 # ERHF (products) = -925.964797448
as_scanner = as_scanner Grad = Gradients ccsd.CCSD.Gradients = lib.class_as_method(Gradients) if __name__ == '__main__': from pyscf import gto from pyscf import scf mol = gto.M(atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]], basis='631g') mf = scf.RHF(mol).run() mycc = ccsd.CCSD(mf).run() g1 = mycc.Gradients().kernel() #[[ 0 0 1.00950925e-02] # [ 0 2.28063426e-02 -5.04754623e-03] # [ 0 -2.28063426e-02 -5.04754623e-03]] print(lib.finger(g1) - -0.036999389889460096) mcs = mycc.as_scanner() mol.set_geom_([["O", (0., 0., 0.001)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]]) e1 = mcs(mol) mol.set_geom_([["O", (0., 0., -0.001)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]]) e2 = mcs(mol) print(g1[0, 2] - (e1 - e2) / 0.002 * lib.param.BOHR)
for i in range(nat / 2): mol.atom.append(('C', (R * np.cos(angle), R * np.sin(angle), 0.0))) mol.atom.append( ('C', (R * np.cos(angle + shift), R * np.sin(angle + shift), 0.0))) angle += 4.0 * np.pi / nat #mol.basis = 'cc-pvdz' mol.basis = '6-31g' mol.build() mf = scf.RHF(mol) mf.verbose = 3 mf.scf() if (False): ccsolver = ccsd.CCSD(mf) ccsolver.verbose = 5 ECORR, t1, t2 = ccsolver.ccsd() ECCSD = mf.hf_energy + ECORR print "ECCSD for alpha ", alpha, " =", ECCSD if (False): mp2solver = mp.MP2(mf) ECORR, t_mp2 = mp2solver.kernel() EMP2 = mf.hf_energy + ECORR print "EMP2 for alpha ", alpha, " =", EMP2 myInts = localintegrals.localintegrals(mf, range(mol.nao_nr()), 'meta_lowdin') myInts.molden('polyyne-loc.molden')
return l1, l2 def _cp(a): return numpy.array(a, copy=False, order='C') if __name__ == '__main__': from pyscf import gto from pyscf import scf from pyscf.cc import ccsd from pyscf import ao2mo mol = gto.Mole() mol.verbose = 0 mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]] mol.basis = 'cc-pvdz' mol.build() rhf = scf.RHF(mol) rhf.conv_tol = 1e-16 rhf.scf() mcc = ccsd.CCSD(rhf) mcc.conv_tol = 1e-12 ecc, t1, t2 = mcc.kernel() conv, l1, l2 = kernel(mcc, eris, t1, t2, tol=1e-8) print(numpy.linalg.norm(l1) - 0.0132626841292) print(numpy.linalg.norm(l2) - 0.212575609057)
from pyscf import gto from pyscf import cc from pyscf.cc import ccsd from pyscf.cc import addons mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]] mol.verbose = 5 mol.output = '/dev/null' mol.basis = '631g' mol.spin = 0 mol.build() mf1 = scf.RHF(mol).run(conv_tol=1e-12) gmf = scf.addons.convert_to_ghf(mf1) myrcc = ccsd.CCSD(mf1).run() def tearDownModule(): global mol, mf1, gmf, myrcc mol.stdout.close() del mol, mf1, gmf, myrcc class KnownValues(unittest.TestCase): def test_spin2spatial(self): t1g = addons.spatial2spin(myrcc.t1) t2g = addons.spatial2spin(myrcc.t2) orbspin = gmf.mo_coeff.orbspin t1a, t1b = addons.spin2spatial(t1g, orbspin) t2aa, t2ab, t2bb = addons.spin2spatial(t2g, orbspin)
def CCSD(mf, frozen=[], mo_energy=None, mo_coeff=None, mo_occ=None): return ccsd.CCSD(mf, frozen, mo_energy, mo_coeff, mo_occ)
def CCSD(mf, frozen=[]): return ccsd.CCSD(mf, frozen)
return dm2 def _rdm2_mo2ao(dm2, mo): mo_C = mo.conj() return lib.einsum('ijkl,pi,qj,rk,sl->pqrs', dm2, mo, mo_C, mo, mo_C) if __name__ == '__main__': from functools import reduce from pyscf import gto from pyscf import scf mol = gto.M() mf = scf.RHF(mol) mcc = ccsd.CCSD(mf) numpy.random.seed(2) nocc = 5 nmo = 12 nvir = nmo - nocc eri0 = numpy.random.random((nmo,nmo,nmo,nmo)) eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo) fock0 = numpy.random.random((nmo,nmo)) fock0 = fock0 + fock0.T + numpy.diag(range(nmo))*2 t1 = numpy.random.random((nocc,nvir)) t2 = numpy.random.random((nocc,nocc,nvir,nvir)) t2 = t2 + t2.transpose(1,0,3,2) l1 = numpy.random.random((nocc,nvir)) l2 = numpy.random.random((nocc,nocc,nvir,nvir)) l2 = l2 + l2.transpose(1,0,3,2)
def test_rdm_vs_rccsd(self): mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]] mol.verbose = 5 mol.output = '/dev/null' mol.basis = '631g' mol.build() mf = scf.RHF(mol).run() myrcc = ccsd.CCSD(mf).set(diis_start_cycle=1).run() rdm1 = myrcc.make_rdm1() rdm2 = myrcc.make_rdm2() mf = scf.addons.convert_to_ghf(mf) mygcc = gccsd.GCCSD(mf).set(diis_start_cycle=1).run() dm1 = mygcc.make_rdm1() dm2 = mygcc.make_rdm2() nao = mol.nao_nr() mo_a = mf.mo_coeff[:nao] mo_b = mf.mo_coeff[nao:] nmo = mo_a.shape[1] eri = ao2mo.kernel(mf._eri, mo_a + mo_b, compact=False).reshape([nmo] * 4) orbspin = mf.mo_coeff.orbspin sym_forbid = (orbspin[:, None] != orbspin) eri[sym_forbid, :, :] = 0 eri[:, :, sym_forbid] = 0 hcore = scf.RHF(mol).get_hcore() h1 = reduce(numpy.dot, (mo_a.T.conj(), hcore, mo_a)) h1 += reduce(numpy.dot, (mo_b.T.conj(), hcore, mo_b)) e1 = numpy.einsum('ij,ji', h1, dm1) e1 += numpy.einsum('ijkl,ijkl', eri, dm2) * .5 e1 += mol.energy_nuc() self.assertAlmostEqual(e1, mygcc.e_tot, 7) idxa = numpy.where(orbspin == 0)[0] idxb = numpy.where(orbspin == 1)[0] trdm1 = dm1[idxa[:, None], idxa] trdm1 += dm1[idxb[:, None], idxb] trdm2 = dm2[idxa[:, None, None, None], idxa[:, None, None], idxa[:, None], idxa] trdm2 += dm2[idxb[:, None, None, None], idxb[:, None, None], idxb[:, None], idxb] dm2ab = dm2[idxa[:, None, None, None], idxa[:, None, None], idxb[:, None], idxb] trdm2 += dm2ab trdm2 += dm2ab.transpose(2, 3, 0, 1) self.assertAlmostEqual(abs(trdm1 - rdm1).max(), 0, 6) self.assertAlmostEqual(abs(trdm2 - rdm2).max(), 0, 6) rt1 = myrcc.t1 + numpy.cos(myrcc.t1) * .2j rl1 = myrcc.l1 + numpy.cos(myrcc.l1) * .2j rt2 = myrcc.t2 + numpy.sin(myrcc.t2) * .8j rl2 = myrcc.l2 + numpy.sin(myrcc.l2) * .8j rdm1 = myrcc.make_rdm1(rt1, rt2, rl1, rl2) rdm2 = myrcc.make_rdm2(rt1, rt2, rl1, rl2) gt1 = mygcc.spatial2spin(rt1) gt2 = mygcc.spatial2spin(rt2) gl1 = mygcc.spatial2spin(rl1) gl2 = mygcc.spatial2spin(rl2) gdm1 = mygcc.make_rdm1(gt1, gt2, gl1, gl2) gdm2 = mygcc.make_rdm2(gt1, gt2, gl1, gl2) trdm1 = gdm1[idxa[:, None], idxa] trdm1 += gdm1[idxb[:, None], idxb] trdm2 = gdm2[idxa[:, None, None, None], idxa[:, None, None], idxa[:, None], idxa] trdm2 += gdm2[idxb[:, None, None, None], idxb[:, None, None], idxb[:, None], idxb] dm2ab = gdm2[idxa[:, None, None, None], idxa[:, None, None], idxb[:, None], idxb] trdm2 += dm2ab trdm2 += dm2ab.transpose(2, 3, 0, 1) self.assertAlmostEqual(abs(trdm1 - rdm1).max(), 0, 9) self.assertAlmostEqual(abs(trdm2 - rdm2).max(), 0, 9)
def test(tf, nobs, U): nao = 2 U = U htb = -1 * tools.tb(nao) htb[0, 0] = 0.01 # make it non-symmetric eri = np.zeros([nao, nao, nao, nao]) eri[0, 0, 0, 0] = U mol = gto.M() mol.build() mol.nelectron = nao #nao mf = scf.RHF(mol) mf.verbose = 0 mf.max_memory = 1000 mf.get_hcore = lambda *args: htb mf.get_ovlp = lambda *args: np.eye(nao) mf._eri = pyscf.ao2mo.restore(8, eri, nao) mf.init_guess = '1e' mf.scf() print 'MF energy = %20.12f' % (mf.e_tot) print 'MO energies :' print mf.mo_energy print '----\n' # 2*pi*max energy << tf-ti ti = 0 tf = tf nobs = nobs times = np.linspace(ti, tf, nobs) deltat = float(tf - ti) / nobs # ================= # single particle GF # ================== nocc = mol.nelectron / 2 gip0 = single_particle.get_gip(mf.mo_energy, nocc, times) gea0 = single_particle.get_gea(mf.mo_energy, nocc, times) # ================= # CC GF # ================== cc = ccsd.CCSD(mf) ecc = cc.ccsd()[0] print "CCSD corr = %20.12f" % (ecc) start = time.time() print "Solving lambda equations..." cc.solve_lambda() stop = time.time() print "Elapsed time for CC", stop - start # This tolerance controls the accuracy of the # RK45 integrator used in the green's function algorithm # Each element will be computed to an accuracy of tol tol = 1.e-5 start = time.time() gip = get_ip_ao(cc, 1, times, mf.mo_coeff, tol) gea = get_ea_ao(cc, 1, times, mf.mo_coeff, tol) stop = time.time() print "Elasped time for TD-propagation", stop - start # This is the difference between the exact MF and CC # Green's functions. If you dial tol up, this will go to 0 print "IP difference", np.linalg.norm(gip - gip0) print "EA difference", np.linalg.norm(gea - gea0) # predict out to long times # note ntotal must be 2**n+1 since # we use romberg integration to do fourier transform integral tmax0 = 10000 ntotal0 = tmax0 / deltat nbase2 = np.int(np.log(ntotal0) / np.log(2)) ntotal = 2**nbase2 + 1 # 2*pi/tmax gives a minimum oscillation frequency, so # graph will wiggle at least on this scale print "Total propagation time: ", ntotal * deltat print "Predict ip0 ============" predicted_gf_ip0 = tools.predict_gf(gip0, ntotal) predicted_gf_ea0 = tools.predict_gf(gea0, ntotal) print "Predict ip ============" start = time.time() predicted_gf_ip = tools.predict_gf(gip, ntotal) predicted_gf_ea = tools.predict_gf(gea, ntotal) stop = time.time() print "Elasped time for prediction", stop - start print "Norm difference", np.linalg.norm(gip - gip0) #ddd # transform time-domain to frequency domain gret0 = -1j * (predicted_gf_ip0 + predicted_gf_ea0) gret_ao0 = np.einsum("pi,ijt,jq->pqt", mf.mo_coeff, gret0, mf.mo_coeff.T) # old stuff # gret = -1j * (predicted_gf_ip + predicted_gf_ea) # gret_ao = np.einsum("pi,ijt,jq->pqt", mf.mo_coeff, gret, # mf.mo_coeff.T) gret_ao = -1j * (predicted_gf_ip + predicted_gf_ea) extrapolated_times = np.array([deltat * i for i in range(ntotal)]) tmax = extrapolated_times[-1] # for i in range(gret_ao.shape[2]): # print i, extrapolated_times[i], gret_ao0[0,0,i], gret_ao[0,0,i] print np.linalg.norm(gret_ao0 - gret_ao) # compute freq. dependent GF freqs = np.linspace(-10, +10, 400) delta = 1.e-1 # this should be on the scale of pi/tmax # tdgf_w0 = tools.get_gfw(gret_ao0, extrapolated_times, # freqs, delta) start = time.time() tdgf_w = tools.get_gfw(gret_ao, extrapolated_times, freqs, delta) stop = time.time() print "Elapsed time: FT", stop - start start = time.time() # w_gf_w = cc_gf(freqs, delta, cc, mf.mo_coeff) # "1" is the number of impurities w_gf_w = cc_gf_ao(1, freqs, delta, cc, mf.mo_coeff) stop = time.time() print "Elapsed time: frequency CC", stop - start # when you see the peak, in addition to the broadening # there is also a small real shift (on the size of the broadening); # I don't fully get why it's there (maybe it's the use of the Gaussian # form of broadening?) #plt.plot(freqs, -1./np.pi*tdgf_w0[0,0].imag, "rx-") plt.plot(freqs, -1. / np.pi * tdgf_w[0, 0].imag, "b+-") plt.plot(freqs, -1. / np.pi * w_gf_w[0, 0].imag, "g*-") plt.savefig("AO_" + str(U) + "_" + str(tf) + "_" + str(nobs) + ".pdf") plt.close()
def _cp(a): return numpy.array(a, copy=False, order='C') if __name__ == '__main__': from pyscf import gto from pyscf import scf from pyscf.cc import ccsd from pyscf import ao2mo mol = gto.M() mf = scf.RHF(mol) mcc = ccsd.CCSD(mf) numpy.random.seed(12) nocc = 5 nmo = 12 nvir = nmo - nocc eri0 = numpy.random.random((nmo, nmo, nmo, nmo)) eri0 = ao2mo.restore(1, ao2mo.restore(8, eri0, nmo), nmo) fock0 = numpy.random.random((nmo, nmo)) fock0 = fock0 + fock0.T + numpy.diag(range(nmo)) * 2 t1 = numpy.random.random((nocc, nvir)) t2 = numpy.random.random((nocc, nocc, nvir, nvir)) t2 = t2 + t2.transpose(1, 0, 3, 2) l1 = numpy.random.random((nocc, nvir)) l2 = numpy.random.random((nocc, nocc, nvir, nvir)) l2 = l2 + l2.transpose(1, 0, 3, 2)
from pyscf.cc import ccsd_t_lambda_slow as ccsd_t_lambda from pyscf import ao2mo mol = gto.Mole() #mol.verbose = 5 #mol.output = 'out_h2o' mol.atom = [[8, (0., 0., 0.)], [1, (0., -.957, .587)], [1, (0.2, .757, .487)]] #mol.basis = 'ccpvdz' mol.basis = '631g' mol.build() mf = scf.RHF(mol) mf.conv_tol = 1e-14 mf.scf() mcc = ccsd.CCSD(mf) mcc.conv_tol = 1e-14 ecc, t1, t2 = mcc.kernel() eris = mcc.ao2mo() e3ref = ccsd_t.kernel(mcc, eris, t1, t2) l1, l2 = ccsd_t_lambda.kernel(mcc, eris, t1, t2)[1:] print(ecc, e3ref) eri_mo = ao2mo.kernel(mf._eri, mf.mo_coeff, compact=False) nmo = mf.mo_coeff.shape[1] eri_mo = eri_mo.reshape(nmo, nmo, nmo, nmo) dm1 = make_rdm1(mcc, t1, t2, l1, l2, eris=eris) dm2 = make_rdm2(mcc, t1, t2, l1, l2, eris=eris) h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff)) e3 = (numpy.einsum('ij,ij->', h1, dm1) + numpy.einsum('ijkl,ijkl->', eri_mo, dm2) * .5 + mf.mol.energy_nuc())
def test_td(): nao = 2 U = 0. htb = -1 * _tb(nao) htb[0, 0] = 0.0 eri = np.zeros([nao, nao, nao, nao]) for k in range(nao): eri[k, k, k, k] = U delta = 0.01 mol = gto.M() mol.build() mol.nelectron = 2 #nao mf = scf.RHF(mol) mf.verbose = 0 mf.max_memory = 1000 mf.get_hcore = lambda *args: htb mf.get_ovlp = lambda *args: np.eye(nao) mf._eri = ao2mo.restore(8, eri, nao) mf.init_guess = '1e' mf.scf() print 'MF energy = %20.12f' % (mf.e_tot) print 'MO energies :' print mf.mo_energy print '----\n' cc = ccsd.CCSD(mf) ecc = cc.ccsd()[0] print "CCSD corr = %20.12f" % (ecc) print "Solving lambda equations..." cc.solve_lambda() ti = 0 tf = 400 nquad = 12 times = np.linspace(ti, tf, 2**nquad + 1) gf_ret = cc_td_gf(ti, tf, times, cc, mf.mo_coeff) freqs_ = _get_linear_freqs(-6, 6, 512)[0] gf_ret_w = np.zeros([gf_ret.shape[0], gf_ret.shape[1], len(freqs_)], dtype=np.complex128) halftime = (2**(nquad - 1) + 1) inttimes = times[:halftime] delta = 0.1 for iw, w in enumerate(freqs_): ftwts = 1. / (tf - ti) * np.array([ np.exp(1j * (w * t)) * np.exp(-delta**2 * t) for t in times[:halftime] ], dtype=np.complex128) for p in range(gf_ret.shape[0]): for q in range(gf_ret.shape[1]): gfft = gf_ret[p, q, :halftime] * ftwts gf_ret_w[p, q, iw] = scipy.integrate.romb(gfft) print gf_ret_w dos = np.zeros([freqs_.shape[0]]) for k in range(nao): dos[:] += 1. / np.pi * np.imag(gf_ret_w[k, k, :]) plt.plot(freqs_, dos) plt.show()