def _make_eris_outcore(mycc, mo_coeff=None): cput0 = (logger.process_clock(), logger.perf_counter()) log = logger.Logger(mycc.stdout, mycc.verbose) eris = _ChemistsERIs() eris._common_init_(mycc, mo_coeff) mol = mycc.mol mo_coeff = eris.mo_coeff nocc = eris.nocc nao, nmo = mo_coeff.shape nvir = nmo - nocc eris.feri1 = lib.H5TmpFile() eris.oooo = eris.feri1.create_dataset('oooo', (nocc, nocc, nocc, nocc), 'f8') eris.ovoo = eris.feri1.create_dataset('ovoo', (nocc, nvir, nocc, nocc), 'f8', chunks=(nocc, 1, nocc, nocc)) eris.ovov = eris.feri1.create_dataset('ovov', (nocc, nvir, nocc, nvir), 'f8', chunks=(nocc, 1, nocc, nvir)) eris.ovvo = eris.feri1.create_dataset('ovvo', (nocc, nvir, nvir, nocc), 'f8', chunks=(nocc, 1, nvir, nocc)) eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc, nvir, nvir, nvir), 'f8') eris.oovv = eris.feri1.create_dataset('oovv', (nocc, nocc, nvir, nvir), 'f8', chunks=(nocc, nocc, 1, nvir)) max_memory = max(MEMORYMIN, mycc.max_memory - lib.current_memory()[0]) ftmp = lib.H5TmpFile() ao2mo.full(mol, mo_coeff, ftmp, max_memory=max_memory, verbose=log) eri = ftmp['eri_mo'] nocc_pair = nocc * (nocc + 1) // 2 tril2sq = lib.square_mat_in_trilu_indices(nmo) oo = eri[:nocc_pair] eris.oooo[:] = ao2mo.restore(1, oo[:, :nocc_pair], nocc) oovv = lib.take_2d(oo, tril2sq[:nocc, :nocc].ravel(), tril2sq[nocc:, nocc:].ravel()) eris.oovv[:] = oovv.reshape(nocc, nocc, nvir, nvir) oo = oovv = None tril2sq = lib.square_mat_in_trilu_indices(nmo) blksize = min(nvir, max(BLKMIN, int(max_memory * 1e6 / 8 / nmo**3 / 2))) for p0, p1 in lib.prange(0, nvir, blksize): q0, q1 = p0 + nocc, p1 + nocc off0 = q0 * (q0 + 1) // 2 off1 = q1 * (q1 + 1) // 2 buf = lib.unpack_tril(eri[off0:off1]) tmp = buf[tril2sq[q0:q1, :nocc] - off0] eris.ovoo[:, p0:p1] = tmp[:, :, :nocc, :nocc].transpose(1, 0, 2, 3) eris.ovvo[:, p0:p1] = tmp[:, :, nocc:, :nocc].transpose(1, 0, 2, 3) eris.ovov[:, p0:p1] = tmp[:, :, :nocc, nocc:].transpose(1, 0, 2, 3) eris.ovvv[:, p0:p1] = tmp[:, :, nocc:, nocc:].transpose(1, 0, 2, 3) buf = tmp = None log.timer('GW integral transformation', *cput0) return eris
def from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT, molpro_orbsym=MOLPRO_ORBSYM): '''Use the given SCF object to transfrom the 1-electron and 2-electron integrals then dump them to FCIDUMP. Kwargs: molpro_orbsym (bool): Whether to dump the orbsym in Molpro orbsym convention as documented in https://www.molpro.net/info/current/doc/manual/node36.html ''' mol = mf.mol mo_coeff = mf.mo_coeff assert mo_coeff.dtype == numpy.double h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff)) if mf._eri is None: if getattr(mf, 'exxdiv', None): # PBC system eri = mf.with_df.ao2mo(mo_coeff) else: eri = ao2mo.full(mf.mol, mo_coeff) else: # Handle cached integrals or customized systems eri = ao2mo.full(mf._eri, mo_coeff) orbsym = getattr(mo_coeff, 'orbsym', None) if molpro_orbsym and orbsym is not None: orbsym = [ORBSYM_MAP[mol.groupname][i] for i in orbsym] nuc = mf.energy_nuc() from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0, orbsym, tol, float_format)
def update_l1l2(mf, t1, t2, l1, l2, orbspin): mol = mf.mol nao, nmo = mf.mo_coeff[0].shape nelec = mol.nelectron nso = nmo * 2 hcore = mf.get_hcore() h1e = np.zeros((nso, nso)) idxa = orbspin == 0 idxb = orbspin == 1 idxaa = idxa[:, None] & idxa idxbb = idxb[:, None] & idxb h1e[idxaa] = reduce(np.dot, (mf.mo_coeff[0].T, hcore, mf.mo_coeff[0])).ravel() h1e[idxbb] = reduce(np.dot, (mf.mo_coeff[1].T, hcore, mf.mo_coeff[1])).ravel() int2e = np.zeros((nso, nso, nso, nso)) int2e[idxaa[:, :, None, None] & idxaa] = ao2mo.full(mol, mf.mo_coeff[0], aosym='s1').ravel() int2e[idxbb[:, :, None, None] & idxbb] = ao2mo.full(mol, mf.mo_coeff[1], aosym='s1').ravel() eri_aabb = ao2mo.general( mol, [mf.mo_coeff[0], mf.mo_coeff[0], mf.mo_coeff[1], mf.mo_coeff[1]], aosym='s1').reshape([nmo] * 4) int2e[idxaa[:, :, None, None] & idxbb] = eri_aabb.ravel() int2e[idxbb[:, :, None, None] & idxaa] = eri_aabb.transpose(2, 3, 0, 1).ravel() int2e = int2e.transpose(0, 2, 1, 3) int2e = int2e - int2e.transpose(0, 1, 3, 2) mycc = ccsd(nso, nelec, h1e, int2e, h1e_is_fock=False) l1, l2 = update_l1l2_sub(mycc, t1, t2, l1, l2) return l1, l2
def make_fcidump(self, filename): mo_coeff = self.mf.mo_coeff h1 = reduce(numpy.dot, (mo_coeff.T, self.mf.get_hcore(), mo_coeff)) if self.mf._eri is None: eri = ao2mo.full(self.mol, mo_coeff) else: eri = ao2mo.full(self.mf._eri, mo_coeff) nuc = self.mf.energy_nuc() orbsym = getattr(mo_coeff, 'orbsym', None) if self.symmetry in ('DOOH', 'COOV'): self.writeComplexOrbIntegrals(h1, eri, h1.shape[0], self.n_up + self.n_down, nuc, orbsym, self.partner_orbs) fcidump.from_integrals("FCIDUMP_real_orbs", h1, eri, h1.shape[0], self.mol.nelec, nuc, 0, orbsym) else: orbsym = [sym + 1 for sym in orbsym] fcidump.from_integrals(filename, h1, eri, h1.shape[0], self.mol.nelec, nuc, 0, orbsym, tol=1e-15, float_format=' %.16g')
def set_frozdm (self, frozdm1=None, frozdm2=None, eri_fo=None): self.frozdm1 = frozdm1 self.frozdm2 = frozdm2 ncore = self.ncore nfroz = self.nfroz nocc = ncore + self.nfroz fo_coeff = self.get_fo_coeff () if frozdm1 is not None: fo_occ, u_no = sp.linalg.eigh (frozdm1) idx = np.argsort (-fo_occ) fo_occ = fo_occ[idx] u_no = u_no[:,idx] frozdm1, frozdm2 = update_rdm12 (u_no, frozdm1, frozdm2) assert (np.allclose (fo_occ, np.diag (frozdm1))), "fo_occ = {0}\nfrozdm1 =\n{1}".format (fo_occ, frozdm1) self.wo_coeff[:,ncore:nocc] = np.dot (self.wo_coeff[:,ncore:nocc], u_no) self._fo_occ = fo_occ dm1 = reduce (np.dot, [fo_coeff, frozdm1, fo_coeff.conjugate ().T]) self._e1_froz = energy_elec (self, dm1)[1] if frozdm2 is not None: if eri_fo is None and getattr (self, '_eri', None) is not None: eri_fo = ao2mo.full(self._eri, fo_coeff, compact=False).reshape (nfroz, nfroz, nfroz, nfroz) elif eri_fo is None: eri_fo = ao2mo.full(self.mol, fo_coeff, compact=False).reshape (nfroz, nfroz, nfroz, nfroz) else: eri_fo = update_2body (u_no, ao2mo.restore (1, eri_fo, nfroz)) self._e2_froz = 0.5 * np.tensordot (eri_fo, frozdm2, axes=4)
def kernel(self, h1e=None, eri=None, norb=None, nelec=None, ci0=None, ecore=None, **kwargs): if h1e is None or eri is None: if mf is None: if h1e is None: h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo)) if eri is None: eri = ao2mo.full(mol, mo) if ecore is None: ecore = mol.energy_nuc() else: if h1e is None: h1e = reduce(numpy.dot, (mo.T, mf.get_hcore(mol), mo)) if eri is None: if mf._eri is None: eri = ao2mo.full(mol, mo) else: eri = ao2mo.full(mf._eri, mo) if ecore is None: ecore = mf.energy_nuc() if norb is None: norb = mo.shape[1] if nelec is None: nelec = mol.nelec self.eci, self.ci = \ cis.__class__.kernel(self, h1e, eri, norb, nelec, ci0, ecore=ecore, **kwargs) return self.eci, self.ci
def ref_energy(mf): moa, mob = mf.mo_coeff nmoa, nmob = moa.shape[1], mob.shape[1] nea, neb = mf.mol.nelec hcore = mf.get_hcore() ha = np.linalg.multi_dot([moa.T,hcore,moa]) hb = np.linalg.multi_dot([mob.T,hcore,mob]) E0 = sum(ha.diagonal()[:nea]) + sum(hb.diagonal()[:neb]) eriao = mf._eri eri_aa = ao2mo.restore(1, ao2mo.full(eriao, moa), nmoa) eri_bb = ao2mo.restore(1, ao2mo.full(eriao, mob), nmob) eri_ab = ao2mo.general(eriao, (moa,moa,mob,mob), compact=False) eri_aa = eri_aa.reshape(nmoa,nmoa,nmoa,nmoa) eri_bb = eri_bb.reshape(nmob,nmob,nmob,nmob) eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob) oooo = eri_aa[:nea,:nea,:nea,:nea].copy() OOOO = eri_bb[:neb,:neb,:neb,:neb].copy() ooOO = eri_ab[:nea,:nea,:neb,:neb].copy() temp = einsum('iijj',OOOO)-einsum('ijji',OOOO) temp += einsum('iijj',oooo)-einsum('ijji',oooo) temp += 2*einsum('iijj',ooOO) E0 += 0.5*temp return E0
def gen_hop_uhf_external(mf): mol = mf.mol mo_a, mo_b = mf.mo_coeff mo_ea, mo_eb = mf.mo_energy mo_occa, mo_occb = mf.mo_occ nmo = mo_a.shape[1] nocca = numpy.count_nonzero(mo_occa) noccb = numpy.count_nonzero(mo_occb) nvira = nmo - nocca nvirb = nmo - noccb eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo) eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a, mo_a, mo_b, mo_b]), nmo) eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo) # alpha -> alpha haa = -numpy.einsum('abji->iajb', eri_aa[nocca:, nocca:, :nocca, :nocca]) haa += numpy.einsum('ajbi->iajb', eri_aa[nocca:, :nocca, nocca:, :nocca]) for a in range(nvira): for i in range(nocca): haa[i, a, i, a] += mo_ea[nocca + a] - mo_ea[i] # beta -> beta hbb = -numpy.einsum('abji->iajb', eri_bb[noccb:, noccb:, :noccb, :noccb]) hbb += numpy.einsum('ajbi->iajb', eri_bb[noccb:, :noccb, noccb:, :noccb]) for a in range(nvirb): for i in range(noccb): hbb[i, a, i, a] += mo_eb[noccb + a] - mo_eb[i] nova = nocca * nvira novb = noccb * nvirb h1 = numpy.zeros((nova + novb, nova + novb)) h1[:nova, :nova] = haa.transpose(1, 0, 3, 2).reshape(nova, nova) h1[nova:, nova:] = hbb.transpose(1, 0, 3, 2).reshape(novb, novb) def hop1(x): return h1.dot(x) h11 = -numpy.einsum('abji->iajb', eri_ab[nocca:, nocca:, :noccb, :noccb]) for a in range(nvira): for i in range(noccb): h11[i, a, i, a] += mo_ea[nocca + a] - mo_eb[i] h22 = -numpy.einsum('jiab->iajb', eri_ab[:nocca, :nocca, noccb:, noccb:]) for a in range(nvirb): for i in range(nocca): h22[i, a, i, a] += mo_eb[noccb + a] - mo_ea[i] h12 = -numpy.einsum('ajbi->iajb', eri_ab[nocca:, :nocca, noccb:, :noccb]) h21 = -numpy.einsum('biaj->iajb', eri_ab[nocca:, :nocca, noccb:, :noccb]) n1 = noccb * nvira n2 = nocca * nvirb h2 = numpy.empty((n1 + n2, n1 + n2)) h2[:n1, :n1] = h11.transpose(1, 0, 3, 2).reshape(n1, n1) h2[n1:, n1:] = h22.transpose(1, 0, 3, 2).reshape(n2, n2) h2[:n1, n1:] = h12.transpose(1, 0, 3, 2).reshape(n1, n2) h2[n1:, :n1] = h21.transpose(1, 0, 3, 2).reshape(n2, n1) def hop2(x): return h2.dot(x) return hop1, hop2
def _make_eris_outcore(mycc, mo_coeff=None): cput0 = (time.clock(), time.time()) log = logger.Logger(mycc.stdout, mycc.verbose) eris = _ChemistsERIs() eris._common_init_(mycc, mo_coeff) mol = mycc.mol mo_coeff = eris.mo_coeff nocc = eris.nocc nao, nmo = mo_coeff.shape nvir = nmo - nocc orbo = mo_coeff[:,:nocc] orbv = mo_coeff[:,nocc:] nvpair = nvir * (nvir+1) // 2 eris.feri1 = lib.H5TmpFile() eris.oooo = eris.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8') eris.ovoo = eris.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), 'f8', chunks=(nocc,1,nocc,nocc)) eris.ovov = eris.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), 'f8', chunks=(nocc,1,nocc,nvir)) eris.ovvo = eris.feri1.create_dataset('ovvo', (nocc,nvir,nvir,nocc), 'f8', chunks=(nocc,1,nvir,nocc)) eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc,nvir,nvir,nvir), 'f8') eris.oovv = eris.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), 'f8', chunks=(nocc,nocc,1,nvir)) eris.vvvv = eris.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), 'f8') max_memory = max(MEMORYMIN, mycc.max_memory-lib.current_memory()[0]) ftmp = lib.H5TmpFile() ao2mo.full(mol, mo_coeff, ftmp, max_memory=max_memory, verbose=log) eri = ftmp['eri_mo'] nocc_pair = nocc*(nocc+1)//2 tril2sq = lib.square_mat_in_trilu_indices(nmo) oo = eri[:nocc_pair] eris.oooo[:] = ao2mo.restore(1, oo[:,:nocc_pair], nocc) oovv = lib.take_2d(oo, tril2sq[:nocc,:nocc].ravel(), tril2sq[nocc:,nocc:].ravel()) eris.oovv[:] = oovv.reshape(nocc,nocc,nvir,nvir) oo = oovv = None tril2sq = lib.square_mat_in_trilu_indices(nmo) blksize = min(nvir, max(BLKMIN, int(max_memory*1e6/8/nmo**3/2))) for p0, p1 in lib.prange(0, nvir, blksize): q0, q1 = p0+nocc, p1+nocc off0 = q0*(q0+1)//2 off1 = q1*(q1+1)//2 buf = lib.unpack_tril(eri[off0:off1]) tmp = buf[ tril2sq[q0:q1,:nocc] - off0 ] eris.ovoo[:,p0:p1] = tmp[:,:,:nocc,:nocc].transpose(1,0,2,3) eris.ovvo[:,p0:p1] = tmp[:,:,nocc:,:nocc].transpose(1,0,2,3) eris.ovov[:,p0:p1] = tmp[:,:,:nocc,nocc:].transpose(1,0,2,3) eris.ovvv[:,p0:p1] = tmp[:,:,nocc:,nocc:].transpose(1,0,2,3) tmp = buf[ tril2sq[q0:q1,nocc:q1] - off0 ] eris.vvvv[p0:p1,:p1] = tmp[:,:,nocc:,nocc:] if p0 > 0: eris.vvvv[:p0,p0:p1] = tmp[:,:p0,nocc:,nocc:].transpose(1,0,2,3) buf = tmp = None log.timer('CCSD integral transformation', *cput0) return eris
def gen_hop_uhf_external(mf): mol = mf.mol mo_a, mo_b = mf.mo_coeff mo_ea, mo_eb = mf.mo_energy mo_occa, mo_occb = mf.mo_occ nmo = mo_a.shape[1] nocca = numpy.count_nonzero(mo_occa) noccb = numpy.count_nonzero(mo_occb) nvira = nmo - nocca nvirb = nmo - noccb eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo) eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo) eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo) # alpha -> alpha haa =-numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca]) haa+= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca]) for a in range(nvira): for i in range(nocca): haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i] # beta -> beta hbb =-numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb]) hbb+= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb]) for a in range(nvirb): for i in range(noccb): hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i] nova = nocca * nvira novb = noccb * nvirb h1 = numpy.zeros((nova+novb,nova+novb)) h1[:nova,:nova] = haa.transpose(1,0,3,2).reshape(nova,nova) h1[nova:,nova:] = hbb.transpose(1,0,3,2).reshape(novb,novb) def hop1(x): return h1.dot(x) h11 =-numpy.einsum('abji->iajb', eri_ab[nocca:,nocca:,:noccb,:noccb]) for a in range(nvira): for i in range(noccb): h11[i,a,i,a] += mo_ea[nocca+a] - mo_eb[i] h22 =-numpy.einsum('jiab->iajb', eri_ab[:nocca,:nocca,noccb:,noccb:]) for a in range(nvirb): for i in range(nocca): h22[i,a,i,a] += mo_eb[noccb+a] - mo_ea[i] h12 =-numpy.einsum('ajbi->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb]) h21 =-numpy.einsum('biaj->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb]) n1 = noccb * nvira n2 = nocca * nvirb h2 = numpy.empty((n1+n2,n1+n2)) h2[:n1,:n1] = h11.transpose(1,0,3,2).reshape(n1,n1) h2[n1:,n1:] = h22.transpose(1,0,3,2).reshape(n2,n2) h2[:n1,n1:] = h12.transpose(1,0,3,2).reshape(n1,n2) h2[n1:,:n1] = h21.transpose(1,0,3,2).reshape(n2,n1) def hop2(x): return h2.dot(x) return hop1, hop2
def make_real2complex_coeffs(self): mo_coeff = self.mf.mo_coeff h1 = reduce(numpy.dot, (mo_coeff.T, self.mf.get_hcore(), mo_coeff)) if self.mf._eri is None: eri = ao2mo.full(self.mol, mo_coeff) else: eri = ao2mo.full(self.mf._eri, mo_coeff) nuc = self.mf.energy_nuc() orbsym = getattr(mo_coeff, 'orbsym', None) self.get_real2complex_coeffs(h1, eri, h1.shape[0], self.n_up + self.n_down, nuc, orbsym, self.partner_orbs)
def ao2mo(self, mo_coeff=None): if mo_coeff is None: mo_coeff = self.mo_coeff[:,self.ncore:self.ncore+self.ncas] elif mo_coeff.shape[1] != self.ncas: mo_coeff = mo_coeff[:,self.ncore:self.ncore+self.ncas] if self._scf._eri is not None: eri = ao2mo.full(self._scf._eri, mo_coeff, max_memory=self.max_memory) else: eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose, max_memory=self.max_memory) return eri
def from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Use the given SCF object to transfrom the 1-electron and 2-electron integrals then dump them to FCIDUMP. ''' mo_coeff = mf.mo_coeff h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff)) if mf._eri is None: eri = ao2mo.full(mol, mo_coeff) else: eri = ao2mo.full(mf._eri, mo_coeff) orbsym = getattr(mo_coeff, 'orbsym', None) nuc = mf.energy_nuc() from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0, orbsym, tol, float_format)
def uhf_internal(mf, verbose=None): log = logger.new_logger(mf, verbose) mol = mf.mol mo_a, mo_b = mf.mo_coeff mo_ea, mo_eb = mf.mo_energy mo_occa, mo_occb = mf.mo_occ nmo = mo_a.shape[1] nocca = numpy.count_nonzero(mo_occa) noccb = numpy.count_nonzero(mo_occb) nvira = nmo - nocca nvirb = nmo - noccb eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo) eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a, mo_a, mo_b, mo_b]), nmo) eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo) # alpha -> alpha haa = numpy.einsum('aijb->iajb', eri_aa[nocca:, :nocca, :nocca, nocca:]) * 2 haa -= numpy.einsum('abji->iajb', eri_aa[nocca:, nocca:, :nocca, :nocca]) haa -= numpy.einsum('ajbi->iajb', eri_aa[nocca:, :nocca, nocca:, :nocca]) for a in range(nvira): for i in range(nocca): haa[i, a, i, a] += mo_ea[nocca + a] - mo_ea[i] # beta -> beta hbb = numpy.einsum('aijb->iajb', eri_bb[noccb:, :noccb, :noccb, noccb:]) * 2 hbb -= numpy.einsum('abji->iajb', eri_bb[noccb:, noccb:, :noccb, :noccb]) hbb -= numpy.einsum('ajbi->iajb', eri_bb[noccb:, :noccb, noccb:, :noccb]) for a in range(nvirb): for i in range(noccb): hbb[i, a, i, a] += mo_eb[noccb + a] - mo_eb[i] # (alpha -> alpha, beta -> beta) hab = numpy.einsum('aijb->iajb', eri_ab[nocca:, :nocca, :noccb, noccb:]) * 2 nova = nocca * nvira novb = noccb * nvirb hall = numpy.empty((nova + novb, nova + novb)) hall[:nova, :nova] = haa.reshape(nova, nova) hall[nova:, nova:] = hbb.reshape(novb, novb) hall[:nova, nova:] = hab.reshape(nova, novb) hall[nova:, :nova] = hab.reshape(nova, novb).T e = scipy.linalg.eigh(hall)[0] log.debug('uhf_internal: lowest eigs of H = %s', e[e <= max(e[0], 1e-5)]) if e[0] < -1e-5: log.log('UHF wavefunction has an internal instablity. ' 'It maybe corresponds to (spatial) symmetry broken wfn.') else: log.log('UHF wavefunction is stable in the intenral stablity analysis')
def from_chkfile(filename, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Read SCF results from PySCF chkfile and transform 1-electron, 2-electron integrals using the SCF orbitals. The transformed integrals is written to FCIDUMP''' from pyscf import scf, symm with open(filename, 'w') as fout: mol, scf_rec = scf.chkfile.load_scf(chkfile) mo_coeff = numpy.array(scf_rec['mo_coeff']) nmo = mo_coeff.shape[1] if mol.symmetry: orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, mo_coeff, check=False) write_head(fout, nmo, mol.nelectron, mol.spin, orbsym) else: write_head(fout, nmo, mol.nelectron, mol.spin) eri = ao2mo.full(mol, mo_coeff, verbose=0) write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format) t = mol.intor_symmetric('int1e_kin') v = mol.intor_symmetric('int1e_nuc') h = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff)) write_hcore(fout, h, nmo, tol, float_format) output_format = ' ' + float_format + ' 0 0 0 0\n' fout.write(output_format % mol.energy_nuc())
def gen_hop_rhf_external(mf): mol = mf.mol mo_coeff = mf.mo_coeff mo_energy = mf.mo_energy mo_occ = mf.mo_occ nmo = mo_coeff.shape[1] nocc = numpy.count_nonzero(mo_occ) nvir = nmo - nocc nov = nocc * nvir eri_mo = ao2mo.full(mol, mo_coeff) eri_mo = ao2mo.restore(1, eri_mo, nmo) eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc]) # A h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2 h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc]) for a in range(nvir): for i in range(nocc): h[i,a,i,a] += eai[a,i] # B h-= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2 h+= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) h1 = h.transpose(1,0,3,2).reshape(nov,nov) def hop1(x): return h1.dot(x) h =-numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc]) for a in range(nvir): for i in range(nocc): h[i,a,i,a] += eai[a,i] h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) h2 = h.transpose(1,0,3,2).reshape(nov,nov) def hop2(x): return h2.dot(x) return hop1, hop2
def get_eris_in_basis(basis, orbs): """ Get electron repulsion integrals transformed in (in form eri[i,j,k,l] = (ij|kl)) """ pmol = mol_to_pyscf(basis.wfn.molecule, basis=basis.basisname) eri = ao2mo.full(pmol, orbs.T, compact=True) * u.hartree eri.defunits_inplace() return orbitals.ERI4FoldTensor(eri, orbs)
def from_mo(mol, filename, mo_coeff, orbsym=None, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT, molpro_orbsym=MOLPRO_ORBSYM): '''Use the given MOs to transfrom the 1-electron and 2-electron integrals then dump them to FCIDUMP. Kwargs: molpro_orbsym (bool): Whether to dump the orbsym in Molpro orbsym convention as documented in https://www.molpro.net/info/current/doc/manual/node36.html ''' if getattr(mol, '_mesh', None): raise NotImplementedError('PBC system') if orbsym is None: orbsym = getattr(mo_coeff, 'orbsym', None) if molpro_orbsym: orbsym = [ORBSYM_MAP[mol.groupname][i] for i in orbsym] t = mol.intor_symmetric('int1e_kin') v = mol.intor_symmetric('int1e_nuc') h1e = reduce(numpy.dot, (mo_coeff.T, t + v, mo_coeff)) eri = ao2mo.full(mol, mo_coeff, verbose=0) nuc = mol.energy_nuc() from_integrals(filename, h1e, eri, h1e.shape[0], mol.nelec, nuc, 0, orbsym, tol, float_format)
def rhf_internal(mf, verbose=None): log = logger.new_logger(mf, verbose) mol = mf.mol mo_coeff = mf.mo_coeff mo_energy = mf.mo_energy mo_occ = mf.mo_occ nmo = mo_coeff.shape[1] nocc = numpy.count_nonzero(mo_occ) nvir = nmo - nocc eri_mo = ao2mo.full(mol, mo_coeff) eri_mo = ao2mo.restore(1, eri_mo, nmo) eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc]) # A h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2 h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc]) for a in range(nvir): for i in range(nocc): h[i,a,i,a] += eai[a,i] # B h+= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2 h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) nov = nocc * nvir e = scipy.linalg.eigh(h.reshape(nov,nov))[0] log.debug('rhf_internal: lowest eigs = %s', e[e<=max(e[0],1e-5)]) if e[0] < -1e-5: log.log('RHF wavefunction has an internal instablity') else: log.log('RHF wavefunction is stable in the intenral stablity analysis')
def from_chkfile(output, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Read SCF results from PySCF chkfile and transform 1-electron, 2-electron integrals using the SCF orbitals. The transformed integrals is written to FCIDUMP''' from pyscf import scf, ao2mo, symm with open(output, 'w') as fout: mol, scf_rec = scf.chkfile.load_scf(chkfile) mo_coeff = numpy.array(scf_rec['mo_coeff']) nmo = mo_coeff.shape[1] if mol.symmetry: orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, mo_coeff, check=False) write_head(fout, nmo, mol.nelectron, mol.spin, orbsym) else: write_head(fout, nmo, mol.nelectron, mol.spin) eri = ao2mo.full(mol, mo_coeff, verbose=0) write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format) t = mol.intor_symmetric('int1e_kin') v = mol.intor_symmetric('int1e_nuc') h = reduce(numpy.dot, (mo_coeff.T, t + v, mo_coeff)) write_hcore(fout, h, nmo, tol, float_format) output_format = ' ' + float_format + ' 0 0 0 0\n' fout.write(output_format % mol.energy_nuc())
def from_chkfile(filename, chkfile, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Read SCF results from PySCF chkfile and transform 1-electron, 2-electron integrals using the SCF orbitals. The transformed integrals is written to FCIDUMP''' from pyscf import scf, symm mol, scf_rec = scf.chkfile.load_scf(chkfile) mo_coeff = numpy.array(scf_rec['mo_coeff']) nmo = mo_coeff.shape[1] s = reduce(numpy.dot, (mo_coeff.conj().T, mol.intor_symmetric('int1e_ovlp'), mo_coeff)) if abs(s - numpy.eye(nmo)).max() > 1e-6: # Not support the chkfile from pbc calculation raise RuntimeError('Non-orthogonal orbitals found in chkfile') with open(filename, 'w') as fout: if mol.symmetry: orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, mo_coeff, check=False) write_head(fout, nmo, mol.nelectron, mol.spin, orbsym) else: write_head(fout, nmo, mol.nelectron, mol.spin) eri = ao2mo.full(mol, mo_coeff, verbose=0) write_eri(fout, ao2mo.restore(8, eri, nmo), nmo, tol, float_format) t = mol.intor_symmetric('int1e_kin') v = mol.intor_symmetric('int1e_nuc') h = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff)) write_hcore(fout, h, nmo, tol, float_format) output_format = ' ' + float_format + ' 0 0 0 0\n' fout.write(output_format % mol.energy_nuc())
def rhf_internal(mf, verbose=None): log = logger.new_logger(mf, verbose) mol = mf.mol mo_coeff = mf.mo_coeff mo_energy = mf.mo_energy mo_occ = mf.mo_occ nmo = mo_coeff.shape[1] nocc = numpy.count_nonzero(mo_occ) nvir = nmo - nocc eri_mo = ao2mo.full(mol, mo_coeff) eri_mo = ao2mo.restore(1, eri_mo, nmo) eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc]) # A h = numpy.einsum('ckld->kcld', eri_mo[nocc:,:nocc,:nocc,nocc:]) * 2 h-= numpy.einsum('cdlk->kcld', eri_mo[nocc:,nocc:,:nocc,:nocc]) for a in range(nvir): for i in range(nocc): h[i,a,i,a] += eai[a,i] # B h+= numpy.einsum('ckdl->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) * 2 h-= numpy.einsum('cldk->kcld', eri_mo[nocc:,:nocc,nocc:,:nocc]) nov = nocc * nvir e = scipy.linalg.eigh(h.reshape(nov,nov))[0] log.debug('rhf_internal: lowest eigs = %s', e[e<=max(e[0],1e-5)]) if e[0] < -1e-5: log.log('RHF wavefunction has an internal instablity') else: log.log('RHF wavefunction is stable in the internal stablity analysis')
def kernel(self): if (self.norb > 64): raise RuntimeError('''Only support up to 64 orbitals''') self.ncore = self.mol.nelectron - self.nelec[0] - self.nelec[1] self.ncore = self.ncore // 2 e_core = self.mol.energy_nuc() ci_idx = self.ncore + numpy.arange(self.norb) coeff = self.mf.mo_coeff hcore = self.mf.get_hcore() corevhf = 0.0 if (self.ncore != 0): core_idx = numpy.arange(self.ncore) core_dm = numpy.dot(coeff[:, core_idx], coeff[:, core_idx].T) * 2.0 e_core += numpy.einsum('ij,ji', core_dm, hcore) corevhf = self.mf.get_veff(mol, core_dm) e_core += numpy.einsum('ij,ji', core_dm, corevhf) * 0.5 self.e_core = e_core self.dump_flags() self.h1e = reduce( numpy.dot, (coeff[:, ci_idx].T, hcore + corevhf, coeff[:, ci_idx])) self.h2e = ao2mo.full(self.mf._eri, coeff[:, ci_idx]) self.h2e = ao2mo.restore(1, self.h2e, self.norb) self.gen_strs() self.build_h() return self
def uhf_internal(mf, verbose=None): log = logger.new_logger(mf, verbose) mol = mf.mol mo_a, mo_b = mf.mo_coeff mo_ea, mo_eb = mf.mo_energy mo_occa, mo_occb = mf.mo_occ nmo = mo_a.shape[1] nocca = numpy.count_nonzero(mo_occa) noccb = numpy.count_nonzero(mo_occb) nvira = nmo - nocca nvirb = nmo - noccb eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo) eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo) eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo) # alpha -> alpha haa = numpy.einsum('aijb->iajb', eri_aa[nocca:,:nocca,:nocca,nocca:]) * 2 haa-= numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca]) haa-= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca]) for a in range(nvira): for i in range(nocca): haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i] # beta -> beta hbb = numpy.einsum('aijb->iajb', eri_bb[noccb:,:noccb,:noccb,noccb:]) * 2 hbb-= numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb]) hbb-= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb]) for a in range(nvirb): for i in range(noccb): hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i] # (alpha -> alpha, beta -> beta) hab = numpy.einsum('aijb->iajb', eri_ab[nocca:,:nocca,:noccb,noccb:]) * 2 nova = nocca * nvira novb = noccb * nvirb hall = numpy.empty((nova+novb,nova+novb)) hall[:nova,:nova] = haa.reshape(nova,nova) hall[nova:,nova:] = hbb.reshape(novb,novb) hall[:nova,nova:] = hab.reshape(nova,novb) hall[nova:,:nova] = hab.reshape(nova,novb).T e = scipy.linalg.eigh(hall)[0] log.debug('uhf_internal: lowest eigs of H = %s', e[e<=max(e[0],1e-5)]) if e[0] < -1e-5: log.log('UHF wavefunction has an internal instablity. ' 'It maybe corresponds to (spatial) symmetry broken wfn.') else: log.log('UHF wavefunction is stable in the intenral stablity analysis')
def ao2mo(self, mo_coeff=None): ncore = self.ncore ncas = self.ncas nocc = ncore + ncas if mo_coeff is None: ncore = self.ncore mo_coeff = self.mo_coeff[:,ncore:nocc] elif mo_coeff.shape[1] != ncas: mo_coeff = mo_coeff[:,ncore:nocc] if self._scf._eri is not None: eri = ao2mo.full(self._scf._eri, mo_coeff, max_memory=self.max_memory) else: eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose, max_memory=self.max_memory) return eri
def write_integrals(xci, orb): mol = xci.mol orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, orb) h1e = reduce(numpy.dot, (orb.T, xci.get_hcore(), orb)) norb = orb.shape[1] if xci._eri is not None: h2e = ao2mo.restore(1, ao2mo.full(xci._eri, orb), norb) else: h2e = ao2mo.restore(1, ao2mo.full(mol, orb), norb) with h5py.File(xci.integralfile, 'w') as f: f['h1e'] = h1e f['h2e'] = h2e f['norb' ] = numpy.array(norb, dtype=numpy.int32) f['group' ] = mol.groupname f['orbsym'] = numpy.asarray(orbsym, dtype=numpy.int32) f['ecore' ] = mol.energy_nuc()
def write_integrals(xci, orb): mol = xci.mol orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, orb) h1e = reduce(numpy.dot, (orb.T, xci.get_hcore(), orb)) norb = orb.shape[1] if xci._eri is not None: h2e = ao2mo.restore(1, ao2mo.full(xci._eri, orb), norb) else: h2e = ao2mo.restore(1, ao2mo.full(mol, orb), norb) with h5py.File(xci.integralfile, 'w') as f: f['h1e'] = h1e f['h2e'] = h2e f['norb'] = numpy.array(norb, dtype=numpy.int32) f['group'] = mol.groupname f['orbsym'] = numpy.asarray(orbsym, dtype=numpy.int32) f['ecore'] = mol.energy_nuc()
def perform_rhf_full(self) -> None: norb = self.C.shape[-1] tei_mo = full(self.pyscfmol, self.C[0], aosym="s4", compact=False, verbose=self.verbose).reshape(norb, norb, norb, norb) self.tei_mo = (tei_mo, )
def perform_rhf_full(self): assert self.pyscfmol is not None norb = self.C.shape[-1] from pyscf.ao2mo import full tei_mo = full( self.pyscfmol, self.C[0], aosym="s4", compact=False, verbose=self.verbose ).reshape(norb, norb, norb, norb) self.tei_mo = (tei_mo,)
def get_eris_in_basis(basis, orbs): """ Get electron repulsion integrals transformed into this basis (in form eri[i,j,k,l] = (ij|kl)) """ from pyscf import ao2mo pmol = mol_to_pyscf(basis.wfn.mol, basis=basis.basisname) eri = ao2mo.full(pmol, orbs.T, compact=True) * u.hartree eri.defunits_inplace() return orbitals.ERI4FoldTensor(eri, orbs)
def test_from_integral(self): tmpfcidump = tempfile.NamedTemporaryFile() h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff)) h2 = ao2mo.full(mf._eri, mf.mo_coeff) fcidump.from_integrals(tmpfcidump.name, h1, h2, h1.shape[0], mol.nelectron, tol=1e-15)
def __init__(self): self.__dict__.update(cis.__dict__) self.h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo)) self.eri = ao2mo.full(mol, mo) self.eci = None self.ci = None if mol.symmetry: self.orbsym = symm.label_orb_symm(mol, mol.irrep_id, mol.symm_orb, mo) self._keys = set(self.__dict__.keys())
def ao2mo(self, mo_coeff=None): '''Compute the active space two-particle Hamiltonian. ''' ncore = self.ncore ncas = self.ncas nocc = ncore + ncas if mo_coeff is None: ncore = self.ncore mo_coeff = self.mo_coeff[:,ncore:nocc] elif mo_coeff.shape[1] != ncas: mo_coeff = mo_coeff[:,ncore:nocc] if self._scf._eri is not None: eri = ao2mo.full(self._scf._eri, mo_coeff, max_memory=self.max_memory) else: eri = ao2mo.full(self.mol, mo_coeff, verbose=self.verbose, max_memory=self.max_memory) return eri
def from_scf(mf, filename, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Use the given SCF object to transfrom the 1-electron and 2-electron integrals then dump them to FCIDUMP. ''' mo_coeff = mf.mo_coeff assert mo_coeff.dtype == numpy.double h1e = reduce(numpy.dot, (mo_coeff.T, mf.get_hcore(), mo_coeff)) if mf._eri is None: if getattr(mf, 'exxdiv'): # PBC system eri = mf.with_df.ao2mo(mo_coeff) else: eri = ao2mo.full(mf.mol, mo_coeff) else: # Handle cached integrals or customized systems eri = ao2mo.full(mf._eri, mo_coeff) orbsym = getattr(mo_coeff, 'orbsym', None) nuc = mf.energy_nuc() from_integrals(filename, h1e, eri, h1e.shape[0], mf.mol.nelec, nuc, 0, orbsym, tol, float_format)
def __init__(self, mycc, mo_coeff=None): moidx = uccsd.get_umoidx(mycc) if mo_coeff is None: mo_coeff = (mycc.mo_coeff[0][:,moidx[0]], mycc.mo_coeff[1][:,moidx[1]]) else: mo_coeff = (mo_coeff[0][:,moidx[0]], mo_coeff[1][:,moidx[1]]) # Note: Always recompute the fock matrix in UCISD because the mf object may be # converted from ROHF object in which orbital energies are eigenvalues of # Roothaan Fock rather than the true alpha, beta orbital energies. dm = mycc._scf.make_rdm1(mycc.mo_coeff, mycc.mo_occ) fockao = mycc._scf.get_hcore() + mycc._scf.get_veff(mycc.mol, dm) self.focka = reduce(numpy.dot, (mo_coeff[0].T, fockao[0], mo_coeff[0])) self.fockb = reduce(numpy.dot, (mo_coeff[1].T, fockao[1], mo_coeff[1])) self.mo_coeff = mo_coeff self.nocca, self.noccb = mycc.get_nocc() nocca = self.nocca noccb = self.noccb nmoa = self.focka.shape[0] nmob = self.fockb.shape[0] nvira = nmoa - nocca nvirb = nmob - noccb moa, mob = self.mo_coeff eri_aa = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, moa), nmoa) self.vovp = eri_aa[nocca:,:nocca,nocca:].copy() self.vooo = eri_aa[nocca:,:nocca,:nocca,:nocca].copy() eri_bb = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, mob), nmob) self.VOVP = eri_bb[noccb:,:noccb,noccb:].copy() self.VOOO = eri_bb[noccb:,:noccb,:noccb,:noccb].copy() eri_ab = ao2mo.general(mycc._scf._eri, (moa,moa,mob,mob), compact=False) eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob) self.voVP = eri_ab[nocca:,:nocca,noccb:].copy() self.voOO = eri_ab[nocca:,:nocca,:noccb,:noccb].copy() eri_ba = lib.transpose(eri_ab.reshape(nmoa**2,nmob**2)) eri_ba = eri_ba.reshape(nmob,nmob,nmoa,nmoa) self.VOvp = eri_ba[noccb:,:noccb,nocca:].copy() self.VOoo = eri_ba[noccb:,:noccb,:nocca,:nocca].copy()
def get_ham (self, mo_coeff=None): if mo_coeff is None: mo_coeff = self.mo_coeff h0 = self.mol.energy_nuc () h1 = self.mol.intor_symmetric ('int1e_kin') h1 += self.mol.intor_symmetric ('int1e_nuc') # Gotta at least make an orthonormal basis if mo_coeff is None: s0 = self.mol.intor_symmetric ('int1e_ovlp') e1, mo_coeff = linalg.eigh (h1, b=s0) h1 = mo_coeff.T @ h1 @ mo_coeff h1 = h1[np.tril_indices (self.norb)] h2 = ao2mo.restore (4, ao2mo.full (self.mol, mo_coeff), self.norb) return mo_coeff, h0, h1, h2
def from_mo(mol, filename, mo_coeff, orbsym=None, tol=TOL, float_format=DEFAULT_FLOAT_FORMAT): '''Use the given MOs to transfrom the 1-electron and 2-electron integrals then dump them to FCIDUMP. ''' if orbsym is None: orbsym = getattr(mo_coeff, 'orbsym', None) t = mol.intor_symmetric('int1e_kin') v = mol.intor_symmetric('int1e_nuc') h1e = reduce(numpy.dot, (mo_coeff.T, t+v, mo_coeff)) eri = ao2mo.full(mol, mo_coeff, verbose=0) nuc = mol.energy_nuc() from_integrals(filename, h1e, eri, h1e.shape[0], mol.nelec, nuc, 0, orbsym, tol, float_format)
def test_mp2_dm(self): nocc = mol.nelectron // 2 nmo = mf.mo_energy.size nvir = nmo - nocc co = mf.mo_coeff[:, :nocc] cv = mf.mo_coeff[:, nocc:] g = ao2mo.incore.general(mf._eri, (co, cv, co, cv)).ravel() eia = mf.mo_energy[:nocc, None] - mf.mo_energy[nocc:] t2ref0 = g / (eia.reshape(-1, 1) + eia.reshape(-1)).ravel() t2ref0 = t2ref0.reshape(nocc, nvir, nocc, nvir).transpose(0, 2, 3, 1) pt = mp.mp2.MP2(mf) emp2, t2 = pt.kernel() t2s = numpy.zeros((nocc * 2, nocc * 2, nvir * 2, nvir * 2)) t2s[::2, ::2, ::2, ::2] = t2ref0 - t2ref0.transpose(0, 1, 3, 2) t2s[1::2, 1::2, 1::2, 1::2] = t2ref0 - t2ref0.transpose(0, 1, 3, 2) t2s[::2, 1::2, 1::2, ::2] = t2ref0 t2s[1::2, ::2, ::2, 1::2] = t2ref0 t2s[::2, 1::2, ::2, 1::2] = -t2ref0.transpose(0, 1, 3, 2) t2s[1::2, ::2, 1::2, ::2] = -t2ref0.transpose(0, 1, 3, 2) dm1occ = -.5 * numpy.einsum('ikab,jkab->ij', t2s, t2s) dm1vir = .5 * numpy.einsum('ijac,ijbc->ab', t2s, t2s) dm1ref = numpy.zeros((nmo, nmo)) dm1ref[:nocc, :nocc] = dm1occ[::2, ::2] + dm1occ[1::2, 1::2] dm1ref[nocc:, nocc:] = dm1vir[::2, ::2] + dm1vir[1::2, 1::2] for i in range(nocc): dm1ref[i, i] += 2 dm1refao = reduce(numpy.dot, (mf.mo_coeff, dm1ref, mf.mo_coeff.T)) rdm1 = mp.mp2.make_rdm1_ao(pt, mf.mo_energy, mf.mo_coeff) self.assertTrue(numpy.allclose(rdm1, dm1refao)) self.assertTrue(numpy.allclose(pt.make_rdm1(), dm1ref)) dm2ref = numpy.zeros((nmo * 2, ) * 4) dm2ref[:nocc * 2, nocc * 2:, :nocc * 2, nocc * 2:] = t2s.transpose(0, 3, 1, 2) * .5 dm2ref[nocc * 2:, :nocc * 2, nocc * 2:, :nocc * 2] = t2s.transpose(3, 0, 2, 1) * .5 dm2ref = dm2ref[ ::2, ::2, ::2, ::2] + dm2ref[1::2,1::2,1::2,1::2] \ + dm2ref[ ::2, ::2,1::2,1::2] + dm2ref[1::2,1::2, ::2, ::2] eris = ao2mo.restore(1, ao2mo.full(mf._eri, mf.mo_coeff), mf.mo_coeff.shape[1]) self.assertAlmostEqual( numpy.einsum('iajb,iajb', eris, dm2ref) * .5, emp2, 9) for i in range(nocc): for j in range(nocc): dm2ref[i, i, j, j] += 4 dm2ref[i, j, j, i] -= 2 self.assertTrue(numpy.allclose(pt.make_rdm2(), dm2ref))
def kernel(self, h1e=None, eri=None, norb=None, nelec=None, ci0=None, ecore=None, **kwargs): if h1e is None or eri is None: if mf is None: if h1e is None: h1e = reduce(numpy.dot, (mo.T, scf.hf.get_hcore(mol), mo)) if eri is None: eri = ao2mo.full(mol, mo) if ecore is None: ecore = mol.energy_nuc() else: if h1e is None: h1e = reduce(numpy.dot, (mo.T, mf.get_hcore(mol), mo)) if eri is None: if mf._eri is None: eri = ao2mo.full(mol, mo) else: eri = ao2mo.full(mf._eri, mo) if ecore is None: ecore = mf.energy_nuc() if norb is None: norb = mo.shape[1] if nelec is None: nelec = mol.nelec return cis.__class__.kernel(self, h1e, eri, norb, nelec, ci0, ecore=ecore, **kwargs)
def test_mp2_dm(self): nocc = mol.nelectron//2 nmo = mf.mo_energy.size nvir = nmo - nocc co = mf.mo_coeff[:,:nocc] cv = mf.mo_coeff[:,nocc:] g = ao2mo.incore.general(mf._eri, (co,cv,co,cv)).ravel() eia = mf.mo_energy[:nocc,None] - mf.mo_energy[nocc:] t2ref0 = g/(eia.reshape(-1,1)+eia.reshape(-1)).ravel() t2ref0 = t2ref0.reshape(nocc,nvir,nocc,nvir).transpose(0,2,3,1) pt = mp.mp2.MP2(mf) emp2, t2 = pt.kernel() t2s = numpy.zeros((nocc*2,nocc*2,nvir*2,nvir*2)) t2s[ ::2, ::2, ::2, ::2] = t2ref0 - t2ref0.transpose(0,1,3,2) t2s[1::2,1::2,1::2,1::2] = t2ref0 - t2ref0.transpose(0,1,3,2) t2s[ ::2,1::2,1::2, ::2] = t2ref0 t2s[1::2, ::2, ::2,1::2] = t2ref0 t2s[ ::2,1::2, ::2,1::2] = -t2ref0.transpose(0,1,3,2) t2s[1::2, ::2,1::2, ::2] = -t2ref0.transpose(0,1,3,2) dm1occ =-.5 * numpy.einsum('ikab,jkab->ij', t2s, t2s) dm1vir = .5 * numpy.einsum('ijac,ijbc->ab', t2s, t2s) dm1ref = numpy.zeros((nmo,nmo)) dm1ref[:nocc,:nocc] = dm1occ[ ::2, ::2]+dm1occ[1::2,1::2] dm1ref[nocc:,nocc:] = dm1vir[ ::2, ::2]+dm1vir[1::2,1::2] for i in range(nocc): dm1ref[i,i] += 2 dm1refao = reduce(numpy.dot, (mf.mo_coeff, dm1ref, mf.mo_coeff.T)) rdm1 = mp.mp2.make_rdm1_ao(pt, mf.mo_energy, mf.mo_coeff) self.assertTrue(numpy.allclose(rdm1, dm1refao)) self.assertTrue(numpy.allclose(pt.make_rdm1(), dm1ref)) dm2ref = numpy.zeros((nmo*2,)*4) dm2ref[:nocc*2,nocc*2:,:nocc*2,nocc*2:] = t2s.transpose(0,3,1,2) * .5 dm2ref[nocc*2:,:nocc*2,nocc*2:,:nocc*2] = t2s.transpose(3,0,2,1) * .5 dm2ref = dm2ref[ ::2, ::2, ::2, ::2] + dm2ref[1::2,1::2,1::2,1::2] \ + dm2ref[ ::2, ::2,1::2,1::2] + dm2ref[1::2,1::2, ::2, ::2] eris = ao2mo.restore(1, ao2mo.full(mf._eri, mf.mo_coeff), mf.mo_coeff.shape[1]) self.assertAlmostEqual(numpy.einsum('iajb,iajb', eris, dm2ref)*.5, emp2, 9) for i in range(nocc): for j in range(nocc): dm2ref[i,i,j,j] += 4 dm2ref[i,j,j,i] -= 2 self.assertTrue(numpy.allclose(pt.make_rdm2(), dm2ref))
def __init__(self, cc, mo_coeff): nocc = numpy.count_nonzero(cc.mo_occ > 0) eri0 = ao2mo.full(cc._scf._eri, mo_coeff) eri0 = ao2mo.restore(1, eri0, mo_coeff.shape[1]) eri0 = eri0.reshape((mo_coeff.shape[1],)*4) self.oooo = eri0[:nocc,:nocc,:nocc,:nocc].copy() self.ooov = eri0[:nocc,:nocc,:nocc,nocc:].copy() self.ovoo = eri0[:nocc,nocc:,:nocc,:nocc].copy() self.oovo = eri0[:nocc,:nocc,nocc:,:nocc].copy() self.oovv = eri0[:nocc,:nocc,nocc:,nocc:].copy() self.ovov = eri0[:nocc,nocc:,:nocc,nocc:].copy() self.ovvo = eri0[:nocc,nocc:,nocc:,:nocc].copy() self.ovvv = eri0[:nocc,nocc:,nocc:,nocc:].copy() self.vvvv = eri0[nocc:,nocc:,nocc:,nocc:].copy() self.vvvo = eri0[nocc:,nocc:,nocc:,:nocc].copy() self.vovv = eri0[nocc:,:nocc,nocc:,nocc:].copy() self.vvov = eri0[nocc:,nocc:,:nocc,nocc:].copy() self.vvoo = eri0[nocc:,nocc:,:nocc,:nocc].copy() self.voov = eri0[nocc:,:nocc,:nocc,nocc:].copy() self.vooo = eri0[nocc:,:nocc,:nocc,:nocc].copy() self.mo_coeff = mo_coeff self.fock = numpy.diag(cc._scf.mo_energy)
def update_l1l2(mf, t1, t2, l1, l2, orbspin): mol = mf.mol nao,nmo = mf.mo_coeff[0].shape nelec = mol.nelectron nso = nmo * 2 hcore = mf.get_hcore() mo = np.zeros((nao,nso)) mo[:,orbspin==0] = mf.mo_coeff[0] mo[:,orbspin==1] = mf.mo_coeff[1] h1e = reduce(np.dot, (mo.T, hcore, mo)) h1e[orbspin[:,None]!=orbspin] = 0 int2e = ao2mo.full(mf._eri, mo) sym_forbid = (orbspin[:,None] != orbspin)[np.tril_indices(nso)] int2e[sym_forbid] = 0 int2e[:,sym_forbid] = 0 int2e = ao2mo.restore(1, int2e, nso) int2e = int2e.transpose(0,2,1,3) int2e = int2e - int2e.transpose(0,1,3,2) mycc = ccsd(nso,nelec,h1e,int2e,h1e_is_fock=False) l1, l2 = update_l1l2_sub(mycc, t1, t2, l1, l2) return l1, l2
def uhf_external(mf, verbose=None): log = logger.new_logger(mf, verbose) mol = mf.mol mo_a, mo_b = mf.mo_coeff mo_ea, mo_eb = mf.mo_energy mo_occa, mo_occb = mf.mo_occ nmo = mo_a.shape[1] nocca = numpy.count_nonzero(mo_occa) noccb = numpy.count_nonzero(mo_occb) nvira = nmo - nocca nvirb = nmo - noccb eri_aa = ao2mo.restore(1, ao2mo.full(mol, mo_a), nmo) eri_ab = ao2mo.restore(1, ao2mo.general(mol, [mo_a,mo_a,mo_b,mo_b]), nmo) eri_bb = ao2mo.restore(1, ao2mo.full(mol, mo_b), nmo) # alpha -> alpha haa =-numpy.einsum('abji->iajb', eri_aa[nocca:,nocca:,:nocca,:nocca]) haa+= numpy.einsum('ajbi->iajb', eri_aa[nocca:,:nocca,nocca:,:nocca]) for a in range(nvira): for i in range(nocca): haa[i,a,i,a] += mo_ea[nocca+a] - mo_ea[i] # beta -> beta hbb =-numpy.einsum('abji->iajb', eri_bb[noccb:,noccb:,:noccb,:noccb]) hbb+= numpy.einsum('ajbi->iajb', eri_bb[noccb:,:noccb,noccb:,:noccb]) for a in range(nvirb): for i in range(noccb): hbb[i,a,i,a] += mo_eb[noccb+a] - mo_eb[i] nova = nocca * nvira novb = noccb * nvirb hall = numpy.zeros((nova+novb,nova+novb)) hall[:nova,:nova] = haa.reshape(nova,nova) hall[nova:,nova:] = hbb.reshape(novb,novb) e1 = scipy.linalg.eigh(hall)[0] log.debug('uhf_external: lowest eigs of H = %s', e1[e1<=max(e1[0],1e-5)]) if e1[0] < -1e-5: log.log('UHF wavefunction has an UHF real -> complex instablity') else: log.log('UHF wavefunction is stable in the UHF real -> complex stablity analysis') h11 =-numpy.einsum('abji->iajb', eri_ab[nocca:,nocca:,:noccb,:noccb]) for a in range(nvira): for i in range(noccb): h11[i,a,i,a] += mo_ea[nocca+a] - mo_eb[i] h22 =-numpy.einsum('jiab->iajb', eri_ab[:nocca,:nocca,noccb:,noccb:]) for a in range(nvirb): for i in range(nocca): h22[i,a,i,a] += mo_eb[noccb+a] - mo_ea[i] h12 =-numpy.einsum('ajbi->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb]) h21 =-numpy.einsum('biaj->iajb', eri_ab[nocca:,:nocca,noccb:,:noccb]) n1 = noccb * nvira n2 = nocca * nvirb hall = numpy.empty((n1+n2,n1+n2)) hall[:n1,:n1] = h11.reshape(n1,n1) hall[n1:,n1:] = h22.reshape(n2,n2) hall[:n1,n1:] = h12.reshape(n1,n2) hall[n1:,:n1] = h21.reshape(n2,n1) e3 = scipy.linalg.eigh(hall)[0] log.debug('uhf_external: lowest eigs of H = %s', e3[e3<=max(e3[0],1e-5)]) if e3[0] < -1e-5: log.log('UHF wavefunction has an UHF -> GHF instablity.') else: log.log('UHF wavefunction is stable in the UHF -> GHF stablity analysis')
def writeNumpyforMRLCC(mc, E1, E2, frozen) : ncore = mc.ncore nact = mc.ncas norbs = mc.mo_coeff.shape[1] nelec = mc.nelecas[0]+mc.nelecas[1] nvirt = norbs - ncore-nact nc = ncore+nact nactElec = nelec - 2*ncore #this is chemistry notation int2popo = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff, mc.mo_coeff[:,:nc], mc.mo_coeff, mc.mo_coeff[:,:nc]), compact=False) int2ppoo = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff, mc.mo_coeff, mc.mo_coeff[:,:nc], mc.mo_coeff[:,:nc]), compact=False) int2popo.shape=(norbs, nc, norbs, nc) int2ppoo.shape=(norbs, norbs, nc, nc) mo = mc.mo_coeff dmcore = numpy.dot(mo[:,:frozen], mo[:,:frozen].T)*2 vj, vk = mc._scf.get_jk(mc.mol, dmcore) vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo)) int1 = reduce(numpy.dot, (mc.mo_coeff.T, mc.get_hcore(), mc.mo_coeff)) +vhfcore dmcore = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)*2 vj, vk = mc._scf.get_jk(mc.mol, dmcore) vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo)) int1_eff = reduce(numpy.dot, (mc.mo_coeff.T, mc.get_hcore(), mc.mo_coeff)) +vhfcore #int1_eff = makeheff(int1, int2popo, int2ppoo, E1, ncore, nvirt, frozen) energy_frozen_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \ + numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5 #numpy.save("int/E3",E3) #numpy.save("int/E3B.npy", E3.transpose(0,3,1,4,2,5)) #numpy.save("int/E3C.npy", E3.transpose(5,0,2,4,1,3)) numpy.save("int/E2",numpy.asfortranarray(E2)) numpy.save("int/E1",numpy.asfortranarray(E1)) #numpy.save("int/int2",int2) numpy.save("int/int1",numpy.asfortranarray(int1[frozen:,frozen:])) numpy.save("int/int1eff",numpy.asfortranarray(int1_eff[frozen:, frozen:])) numpy.save("int/W:caca", numpy.asfortranarray(int2ppoo[frozen:ncore, frozen:ncore, ncore:nc, ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:caac", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, ncore:nc, frozen:ncore].transpose(0,2,1,3))) numpy.save("int/W:cece", numpy.asfortranarray(int2ppoo[nc:, nc:, frozen:ncore, frozen:ncore].transpose(2,0,3,1))) numpy.save("int/W:ceec", numpy.asfortranarray(int2popo[nc:, frozen:ncore, nc:, frozen:ncore].transpose(1,2,0,3))) numpy.save("int/W:aeae", numpy.asfortranarray(int2ppoo[nc:, nc:, ncore:nc,ncore:nc].transpose(2,0,3,1))) numpy.save("int/W:aeea", numpy.asfortranarray(int2popo[nc:, ncore:nc,nc:, ncore:nc].transpose(1,2,0,3))) numpy.save("int/W:cccc", numpy.asfortranarray(int2ppoo[frozen:ncore,frozen:ncore, frozen:ncore, frozen:ncore].transpose(0,2,1,3))) numpy.save("int/W:aaaa", numpy.asfortranarray(int2ppoo[ncore:nc,ncore:nc, ncore:nc, ncore:nc].transpose(0,2,1,3))) feri = h5py.File("int/int2eeee.hdf5", 'w') ao2mo.full(mc.mol, mc.mo_coeff[:,nc:], feri, compact=False) for o in range(nvirt): int2eee = feri['eri_mo'][o*(norbs-nc):(o+1)*(norbs-nc),:] numpy.asfortranarray(int2eee).tofile("int/W:eeee%04d"%(o)) #store perturbers numpy.save("int/W:eecc", numpy.asfortranarray(int2popo[nc:,frozen:ncore,nc:,frozen:ncore].transpose(0,2,1,3))) numpy.save("int/W:eeca", numpy.asfortranarray(int2popo[nc:,frozen:ncore, nc:, ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:ccaa", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, frozen:ncore, ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:eeaa", numpy.asfortranarray(int2popo[nc:,ncore:nc, nc:, ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:eaca", numpy.asfortranarray(int2popo[nc:,frozen:ncore, ncore:nc, ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:aeca", numpy.asfortranarray(int2popo[ncore:nc,frozen:ncore, nc:,ncore:nc].transpose(0,2,1,3))) numpy.save("int/W:ccae", numpy.asfortranarray(int2popo[frozen:ncore,ncore:nc, nc:, frozen:ncore].transpose(0,3,1,2))) #write FCIDUMP_AAAV and FCIDUMP_AAAC from pyscf import symm mol = mc.mol orbsymout=[] orbsym = [] if (mol.symmetry): orbsym = symm.label_orb_symm(mc.mol, mc.mol.irrep_id, mc.mol.symm_orb, mc.mo_coeff, s=mc._scf.get_ovlp()) if mol.symmetry and orbsym: if mol.groupname.lower() == 'dooh': orbsymout = [dmrg_sym.IRREP_MAP['D2h'][i % 10] for i in orbsym] elif mol.groupname.lower() == 'coov': orbsymout = [dmrg_sym.IRREP_MAP['C2v'][i % 10] for i in orbsym] else: orbsymout = [dmrg_sym.IRREP_MAP[mol.groupname][i] for i in orbsym] else: orbsymout = [] ''' dmcore = numpy.dot(mo[:,frozen:ncore], mo[:,frozen:ncore].T)*2 vj, vk = mc._scf.get_jk(mc.mol, dmcore) vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo)) h1eff = int1+vhfcore energy_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \ + numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5\ +energy_frozen_core ''' dmcore = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)*2 vj, vk = mc._scf.get_jk(mc.mol, dmcore) vhfcore = reduce(numpy.dot, (mo.T, vj-vk*0.5, mo)) h1eff = int1_eff energy_core = numpy.einsum('ij,ji', dmcore, mc.get_hcore()) \ + numpy.einsum('ij,ji', dmcore, vj-0.5*vk) * .5 #print energy_core2+mc.mol.energy_nuc(), energy_core+mc.mol.energy_nuc(), energy_frozen_core+mc.mol.energy_nuc() nc = mc.ncore+mc.ncas energyE0 = 1.0*numpy.einsum('ij,ij', h1eff[ncore:nc, ncore:nc], E1) #+ 0.5*numpy.einsum('ikjl,ijkl', E2, int2ppoo[ncore:,ncore:,ncore:,ncore:]) for i in range(mc.ncas): for j in range(mc.ncas): for k in range(mc.ncas): for l in range(mc.ncas): I,J = max(i,j)+ncore, min(i,j)+ncore K,L = max(k,l)+ncore, min(k,l)+ncore energyE0 += 0.5*E2[i,k,j,l] * int2ppoo[i+ncore, j+ncore, k+ncore, l+ncore] energyE0 += energy_core energyE0 += mc.mol.energy_nuc() print "Energy = ", energyE0 fout = open('FCIDUMP_aaav0','w') tools.fcidump.write_head(fout, int1.shape[0]-ncore, mc.mol.nelectron-2*ncore, orbsym= orbsymout[ncore:]) for i in range(ncore,int1.shape[0]): for j in range(ncore, i+1): for k in range(mc.ncas): for l in range(k+1): if abs(int2ppoo[i,j, k+ncore,l+ncore]) > 1.e-8 : fout.write(' %17.9e %4d %4d %4d %4d\n' \ % (int2ppoo[i,j, k+ncore,l+ncore], i+1-ncore, j+1-ncore, k+1, l+1)) if (j >= nc and abs(int2popo[i, k+ncore, j, l+ncore]) > 1.e-8): fout.write(' %17.9e %4d %4d %4d %4d\n' \ % (int2popo[i,k+ncore,j, l+ncore], i+1-ncore, k+1, l+1, j+1-ncore)) if (j >= nc and abs(int2popo[i, l+ncore, j, k+ncore]) > 1.e-8): fout.write(' %17.9e %4d %4d %4d %4d\n' \ % (int2popo[i,l+ncore, j, k+ncore], i+1-ncore, l+1, k+1, j+1-ncore)) tools.fcidump.write_hcore(fout, h1eff[ncore:,ncore:], int1.shape[0]-ncore, tol=1e-8) fout.write(' %17.9e 0 0 0 0\n' %( mc.mol.energy_nuc()+energy_core-energyE0)) fout.close() nc = ncore+mc.ncas eri1cas = ao2mo.outcore.general_iofree(mc.mol, (mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc], mc.mo_coeff[:,frozen:nc]), compact=True) tools.fcidump.from_integrals("FCIDUMP_aaac", int1[frozen:nc,frozen:nc], eri1cas, nc-frozen, mc.mol.nelectron-2*frozen, nuc=mc.mol.energy_nuc()-energyE0, orbsym = orbsymout[frozen:nc], tol=1e-8) return energyE0, norbs
def kernel(mc, mo_coeff=None, ci=None, atmlst=None, mf_grad=None, verbose=None): if mo_coeff is None: mo_coeff = mc._scf.mo_coeff if ci is None: ci = mc.ci if mf_grad is None: mf_grad = mc._scf.nuc_grad_method() mol = mc.mol ncore = mc.ncore ncas = mc.ncas nocc = ncore + ncas nelecas = mc.nelecas nao, nmo = mo_coeff.shape nao_pair = nao * (nao+1) // 2 mo_energy = mc._scf.mo_energy hcore_deriv = mf_grad.hcore_generator(mol) s1 = mf_grad.get_ovlp(mol) mo_occ = mo_coeff[:,:nocc] mo_core = mo_coeff[:,:ncore] mo_cas = mo_coeff[:,ncore:nocc] casdm1, casdm2 = mc.fcisolver.make_rdm12(mc.ci, ncas, nelecas) # gfock = Generalized Fock, Adv. Chem. Phys., 69, 63 dm_core = numpy.dot(mo_core, mo_core.T) * 2 dm_cas = reduce(numpy.dot, (mo_cas, casdm1, mo_cas.T)) aapa = ao2mo.kernel(mol, (mo_cas, mo_cas, mo_occ, mo_cas), compact=False) aapa = aapa.reshape(ncas,ncas,nocc,ncas) vj, vk = mc._scf.get_jk(mol, (dm_core, dm_cas)) h1 = mc.get_hcore() vhf_c = vj[0] - vk[0] * .5 vhf_a = vj[1] - vk[1] * .5 gfock = reduce(numpy.dot, (mo_occ.T, h1 + vhf_c + vhf_a, mo_occ)) * 2 gfock[:,ncore:nocc] = reduce(numpy.dot, (mo_occ.T, h1 + vhf_c, mo_cas, casdm1)) gfock[:,ncore:nocc] += numpy.einsum('uviw,vuwt->it', aapa, casdm2) dme0 = reduce(numpy.dot, (mo_occ, (gfock+gfock.T)*.5, mo_occ.T)) aapa = vj = vk = vhf_c = vhf_a = h1 = gfock = None dm1 = dm_core + dm_cas vhf1c, vhf1a = mf_grad.get_veff(mol, (dm_core, dm_cas)) diag_idx = numpy.arange(nao) diag_idx = diag_idx * (diag_idx+1) // 2 + diag_idx casdm2_cc = casdm2 + casdm2.transpose(0,1,3,2) dm2buf = ao2mo._ao2mo.nr_e2(casdm2_cc.reshape(ncas**2,ncas**2), mo_cas.T, (0, nao, 0, nao)).reshape(ncas**2,nao,nao) dm2buf = lib.pack_tril(dm2buf) dm2buf[:,diag_idx] *= .5 dm2buf = dm2buf.reshape(ncas,ncas,nao_pair) #casdm2 = casdm2_cc = None atmlst = range(mol.natm) aoslices = mol.aoslice_by_atom() de = numpy.zeros((len(atmlst),3)) max_memory = mc.max_memory - lib.current_memory()[0] blksize = int(max_memory*.9e6/8 / ((aoslices[:,3]-aoslices[:,2]).max()*nao_pair)) blksize = min(nao, max(2, blksize)) for k, ia in enumerate(atmlst): shl0, shl1, p0, p1 = aoslices[ia] h1ao = hcore_deriv(ia) de[k] += numpy.einsum('xij,ij->x', h1ao, dm1) #de[k] -= numpy.einsum('xij,ij->x', s1[:,p0:p1], dme0[p0:p1]) * 2 q1 = 0 for b0, b1, nf in _shell_prange(mol, 0, mol.nbas, blksize): q0, q1 = q1, q1 + nf dm2_ao = lib.einsum('ijw,pi,qj->pqw', dm2buf, mo_cas[p0:p1], mo_cas[q0:q1]) shls_slice = (shl0,shl1,b0,b1,0,mol.nbas,0,mol.nbas) eri1 = mol.intor('int2e_ip1', comp=3, aosym='s2kl', shls_slice=shls_slice).reshape(3,p1-p0,nf,nao_pair) de[k] -= numpy.einsum('xijw,ijw->x', eri1, dm2_ao) * 2 eri1 = None de[k] += numpy.einsum('xij,ij->x', vhf1c[:,p0:p1], dm1[p0:p1]) * 2 de[k] += numpy.einsum('xij,ij->x', vhf1a[:,p0:p1], dm_core[p0:p1]) * 2 dm2 = numpy.zeros((nmo,nmo,nmo,nmo)) for i in range(ncore): for j in range(ncore): dm2[i,i,j,j] += 4 dm2[i,j,j,i] -= 2 dm2[i,i,ncore:nocc,ncore:nocc] = casdm1 * 2 dm2[ncore:nocc,ncore:nocc,i,i] = casdm1 * 2 dm2[i,ncore:nocc,ncore:nocc,i] =-casdm1 dm2[ncore:nocc,i,i,ncore:nocc] =-casdm1 dm2[ncore:nocc,ncore:nocc,ncore:nocc,ncore:nocc] = casdm2 eri0 = ao2mo.restore(1, ao2mo.full(mc._scf._eri, mo_coeff), nmo) Imat = numpy.einsum('pjkl,qjkl->pq', eri0, dm2) dm1 = numpy.zeros((nmo,nmo)) for i in range(ncore): dm1[i,i] = 2 dm1[ncore:nocc,ncore:nocc] = casdm1 neleca, nelecb = mol.nelec h1 =-(mol.intor('int1e_ipkin', comp=3) +mol.intor('int1e_ipnuc', comp=3)) s1 =-mol.intor('int1e_ipovlp', comp=3) eri1 = mol.intor('int2e_ip1', comp=3).reshape(3,nao,nao,nao,nao) eri1 = numpy.einsum('xipkl,pj->xijkl', eri1, mo_coeff) eri1 = numpy.einsum('xijpl,pk->xijkl', eri1, mo_coeff) eri1 = numpy.einsum('xijkp,pl->xijkl', eri1, mo_coeff) h0 = reduce(numpy.dot, (mo_coeff.T, mc._scf.get_hcore(), mo_coeff)) g0 = ao2mo.restore(1, ao2mo.full(mol, mo_coeff), nmo) def hess(): nocc = mol.nelectron//2 nvir = nmo - nocc eri_mo = g0 eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc]) h = eri_mo[nocc:,:nocc,nocc:,:nocc] * 4 h-= numpy.einsum('cdlk->ckdl', eri_mo[nocc:,nocc:,:nocc,:nocc]) h-= numpy.einsum('cldk->ckdl', eri_mo[nocc:,:nocc,nocc:,:nocc]) for a in range(nvir): for i in range(nocc): h[a,i,a,i] += eai[a,i] return -h.reshape(nocc*nvir,-1) hh = hess() ee = mo_energy[:,None] - mo_energy for k,(sh0, sh1, p0, p1) in enumerate(mol.offset_nr_by_atom()): mol.set_rinv_origin(mol.atom_coord(k)) vrinv = -mol.atom_charge(k) * mol.intor('int1e_iprinv', comp=3) # 2e AO integrals dot 2pdm for i in range(3): g1 = numpy.einsum('pjkl,pi->ijkl', eri1[i,p0:p1], mo_coeff[p0:p1]) g1 = g1 + g1.transpose(1,0,2,3) g1 = g1 + g1.transpose(2,3,0,1) g1 *= -1 hx =(numpy.einsum('pq,pi,qj->ij', h1[i,p0:p1], mo_coeff[p0:p1], mo_coeff) + reduce(numpy.dot, (mo_coeff.T, vrinv[i], mo_coeff))) hx = hx + hx.T sx = numpy.einsum('pq,pi,qj->ij', s1[i,p0:p1], mo_coeff[p0:p1], mo_coeff) sx = sx + sx.T fij =(hx[:neleca,:neleca] - numpy.einsum('ij,j->ij', sx[:neleca,:neleca], mo_energy[:neleca]) - numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca], g0[:neleca,:neleca,:neleca,:neleca]) * 2 + numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca], g0[:neleca,:neleca,:neleca,:neleca]) + numpy.einsum('ijkk->ij', g1[:neleca,:neleca,:neleca,:neleca]) * 2 - numpy.einsum('ikkj->ij', g1[:neleca,:neleca,:neleca,:neleca])) fab =(hx[neleca:,neleca:] - numpy.einsum('ij,j->ij', sx[neleca:,neleca:], mo_energy[neleca:]) - numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca], g0[neleca:,neleca:,:neleca,:neleca]) * 2 + numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca], g0[neleca:,:neleca,:neleca,neleca:]) + numpy.einsum('ijkk->ij', g1[neleca:,neleca:,:neleca,:neleca]) * 2 - numpy.einsum('ikkj->ij', g1[neleca:,:neleca,:neleca,neleca:])) fai =(hx[neleca:,:neleca] - numpy.einsum('ai,i->ai', sx[neleca:,:neleca], mo_energy[:neleca]) - numpy.einsum('kl,ijlk->ij', sx[:neleca,:neleca], g0[neleca:,:neleca,:neleca,:neleca]) * 2 + numpy.einsum('kl,iklj->ij', sx[:neleca,:neleca], g0[neleca:,:neleca,:neleca,:neleca]) + numpy.einsum('ijkk->ij', g1[neleca:,:neleca,:neleca,:neleca]) * 2 - numpy.einsum('ikkj->ij', g1[neleca:,:neleca,:neleca,:neleca])) c1 = numpy.zeros((nmo,nmo)) c1[:neleca,:neleca] = -.5 * sx[:neleca,:neleca] c1[neleca:,neleca:] = -.5 * sx[neleca:,neleca:] cvo1 = numpy.linalg.solve(hh, fai.ravel()).reshape(-1,neleca) cov1 = -(sx[neleca:,:neleca] + cvo1).T c1[neleca:,:neleca] = cvo1 c1[:neleca,neleca:] = cov1 v1 = numpy.einsum('pqai,ai->pq', g0[:,:,neleca:,:neleca], cvo1) * 4 v1-= numpy.einsum('paiq,ai->pq', g0[:,neleca:,:neleca,:], cvo1) v1-= numpy.einsum('piaq,ai->pq', g0[:,:neleca,neleca:,:], cvo1) fij += v1[:neleca,:neleca] fab += v1[neleca:,neleca:] c1[:ncore,ncore:neleca] = -fij[:ncore,ncore:] / ee[:ncore,ncore:neleca] c1[ncore:neleca,:ncore] = -fij[ncore:,:ncore] / ee[ncore:neleca,:ncore] m = nocc - neleca c1[nocc:,neleca:nocc] = -fab[m:,:m] / ee[nocc:,neleca:nocc] c1[neleca:nocc,nocc:] = -fab[:m,m:] / ee[neleca:nocc,nocc:] h0c1 = h0.dot(c1) h0c1 = h0c1 + h0c1.T g0c1 = numpy.einsum('pjkl,pi->ijkl', g0, c1) g0c1 = g0c1 + g0c1.transpose(1,0,2,3) g0c1 = g0c1 + g0c1.transpose(2,3,0,1) de[k,i] += numpy.einsum('ij,ji', h0c1, dm1) de[k,i] += numpy.einsum('ijkl,jilk', g0c1, dm2)*.5 de += rhf_grad.grad_nuc(mol) return de
def __init__(self, cc, mo_coeff=None, method='incore'): cput0 = (time.clock(), time.time()) moidx = numpy.ones(cc.mo_occ.size, dtype=numpy.bool) if isinstance(cc.frozen, (int, numpy.integer)): moidx[:cc.frozen] = False elif len(cc.frozen) > 0: moidx[numpy.asarray(cc.frozen)] = False if mo_coeff is None: self.mo_coeff = mo_coeff = cc.mo_coeff[:,moidx] else: self.mo_coeff = mo_coeff = mo_coeff[:,moidx] dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ) fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm) self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff)) nocc = cc.nocc nmo = cc.nmo nvir = nmo - nocc mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir) mem_now = lib.current_memory()[0] log = logger.Logger(cc.stdout, cc.verbose) if hasattr(cc._scf, 'with_df') and cc._scf.with_df: #log.warn('CCSD detected DF being bound to the HF object. ' # 'MO integrals are computed based on the DF 3-tensor integrals.\n' # 'You can switch to dfccsd.CCSD for the DF-CCSD implementation') nvir_pair = nvir * (nvir+1) // 2 oooo = numpy.zeros((nocc*nocc,nocc*nocc)) ooov = numpy.zeros((nocc*nocc,nocc*nvir)) ovoo = numpy.zeros((nocc*nvir,nocc*nocc)) oovv = numpy.zeros((nocc*nocc,nvir*nvir)) ovov = numpy.zeros((nocc*nvir,nocc*nvir)) ovvv = numpy.zeros((nocc*nvir,nvir_pair)) vvvv = numpy.zeros((nvir_pair,nvir_pair)) mo = numpy.asarray(mo_coeff, order='F') nmo = mo.shape[1] ijslice = (0, nmo, 0, nmo) Lpq = None for eri1 in cc._scf.with_df.loop(): Lpq = _ao2mo.nr_e2(eri1, mo, ijslice, aosym='s2', out=Lpq).reshape(-1,nmo,nmo) Loo = Lpq[:,:nocc,:nocc].reshape(-1,nocc**2) Lov = Lpq[:,:nocc,nocc:].reshape(-1,nocc*nvir) Lvv = Lpq[:,nocc:,nocc:].reshape(-1,nvir**2) lib.ddot(Loo.T, Loo, 1, oooo, 1) lib.ddot(Loo.T, Lov, 1, ooov, 1) lib.ddot(Lov.T, Loo, 1, ovoo, 1) lib.ddot(Loo.T, Lvv, 1, oovv, 1) lib.ddot(Lov.T, Lov, 1, ovov, 1) Lvv = lib.pack_tril(Lvv.reshape(-1,nvir,nvir)) lib.ddot(Lov.T, Lvv, 1, ovvv, 1) lib.ddot(Lvv.T, Lvv, 1, vvvv, 1) _tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) self.feri1 = feri1 = h5py.File(_tmpfile1.name) def __del__feri1(self): feri1.close() self.feri1.__del__ = __del__feri1 self.feri1['oooo'] = oooo.reshape(nocc,nocc,nocc,nocc) self.feri1['ooov'] = ooov.reshape(nocc,nocc,nocc,nvir) self.feri1['ovoo'] = ovoo.reshape(nocc,nvir,nocc,nocc) self.feri1['oovv'] = oovv.reshape(nocc,nocc,nvir,nvir) self.feri1['ovov'] = ovov.reshape(nocc,nvir,nocc,nvir) self.feri1['ovvv'] = ovvv.reshape(nocc,nvir,nvir_pair) self.feri1['vvvv'] = vvvv.reshape(nvir_pair,nvir_pair) self.oooo = self.feri1['oooo'] self.ooov = self.feri1['ooov'] self.ovoo = self.feri1['ovoo'] self.oovv = self.feri1['oovv'] self.ovov = self.feri1['ovov'] self.ovvv = self.feri1['ovvv'] self.vvvv = self.feri1['vvvv'] elif (method == 'incore' and cc._scf._eri is not None and (mem_incore+mem_now < cc.max_memory) or cc.mol.incore_anyway): eri1 = ao2mo.incore.full(cc._scf._eri, mo_coeff) #:eri1 = ao2mo.restore(1, eri1, nmo) #:self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy() #:self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy() #:self.ovoo = eri1[:nocc,nocc:,:nocc,:nocc].copy() #:self.oovv = eri1[:nocc,:nocc,nocc:,nocc:].copy() #:self.ovov = eri1[:nocc,nocc:,:nocc,nocc:].copy() #:ovvv = eri1[:nocc,nocc:,nocc:,nocc:].copy() #:self.ovvv = numpy.empty((nocc,nvir,nvir*(nvir+1)//2)) #:for i in range(nocc): #: for j in range(nvir): #: self.ovvv[i,j] = lib.pack_tril(ovvv[i,j]) #:self.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir) nvir_pair = nvir * (nvir+1) // 2 self.oooo = numpy.empty((nocc,nocc,nocc,nocc)) self.ooov = numpy.empty((nocc,nocc,nocc,nvir)) self.ovoo = numpy.empty((nocc,nvir,nocc,nocc)) self.oovv = numpy.empty((nocc,nocc,nvir,nvir)) self.ovov = numpy.empty((nocc,nvir,nocc,nvir)) self.ovvv = numpy.empty((nocc,nvir,nvir_pair)) self.vvvv = numpy.empty((nvir_pair,nvir_pair)) ij = 0 outbuf = numpy.empty((nmo,nmo,nmo)) for i in range(nocc): buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1]) for j in range(i+1): self.oooo[i,j] = self.oooo[j,i] = buf[j,:nocc,:nocc] self.ooov[i,j] = self.ooov[j,i] = buf[j,:nocc,nocc:] self.oovv[i,j] = self.oovv[j,i] = buf[j,nocc:,nocc:] ij += i + 1 ij1 = 0 for i in range(nocc,nmo): buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1]) self.ovoo[:,i-nocc] = buf[:nocc,:nocc,:nocc] self.ovov[:,i-nocc] = buf[:nocc,:nocc,nocc:] for j in range(nocc): self.ovvv[j,i-nocc] = lib.pack_tril(_cp(buf[j,nocc:,nocc:])) for j in range(nocc, i+1): self.vvvv[ij1] = lib.pack_tril(_cp(buf[j,nocc:,nocc:])) ij1 += 1 ij += i + 1 else: cput1 = time.clock(), time.time() _tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) _tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) self.feri1 = feri1 = h5py.File(_tmpfile1.name) def __del__feri1(self): feri1.close() self.feri1.__del__ = __del__feri1 orbo = mo_coeff[:,:nocc] orbv = mo_coeff[:,nocc:] nvpair = nvir * (nvir+1) // 2 self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8') self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), 'f8') self.ovoo = self.feri1.create_dataset('ovoo', (nocc,nvir,nocc,nocc), 'f8') self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), 'f8') self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), 'f8') self.ovvv = self.feri1.create_dataset('ovvv', (nocc,nvir,nvpair), 'f8') fsort = _ccsd.libcc.CCsd_sort_inplace nocc_pair = nocc*(nocc+1)//2 nvir_pair = nvir*(nvir+1)//2 def sort_inplace(eri): fsort(eri.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(nocc), ctypes.c_int(nvir), ctypes.c_int(eri.shape[0])) vv = eri[:,:nvir_pair] oo = eri[:,nvir_pair:nvir_pair+nocc_pair] ov = eri[:,nvir_pair+nocc_pair:].reshape(-1,nocc,nvir) return oo, ov, vv buf = numpy.empty((nmo,nmo,nmo)) def save_occ_frac(i, p0, p1, eri): oo, ov, vv = sort_inplace(eri) self.oooo[i,p0:p1] = lib.unpack_tril(oo, out=buf) self.ooov[i,p0:p1] = ov self.oovv[i,p0:p1] = lib.unpack_tril(vv, out=buf) def save_vir_frac(i, p0, p1, eri): oo, ov, vv = sort_inplace(eri) self.ovoo[i,p0:p1] = lib.unpack_tril(oo, out=buf) self.ovov[i,p0:p1] = ov self.ovvv[i,p0:p1] = vv if not cc.direct: max_memory = max(2000,cc.max_memory-lib.current_memory()[0]) self.feri2 = feri2 = h5py.File(_tmpfile2.name) def __del__feri2(self): feri2.close() self.feri2.__del__ = __del__feri2 ao2mo.full(cc.mol, orbv, self.feri2, max_memory=max_memory, verbose=log) self.vvvv = self.feri2['eri_mo'] cput1 = log.timer_debug1('transforming vvvv', *cput1) tmpfile3 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) with h5py.File(tmpfile3.name, 'w') as feri: max_memory = max(2000, cc.max_memory-lib.current_memory()[0]) mo = numpy.hstack((orbv, orbo)) ao2mo.general(cc.mol, (orbo,mo,mo,mo), feri, max_memory=max_memory, verbose=log) cput1 = log.timer_debug1('transforming oppp', *cput1) blksize = max(1, int(min(8e9,max_memory*.5e6)/8/nmo**2)) handler = None for i in range(nocc): for p0, p1 in lib.prange(0, nvir, blksize): eri = _cp(feri['eri_mo'][i*nmo+p0:i*nmo+p1]) handler = async_do(handler, save_vir_frac, i, p0, p1, eri) for p0, p1 in lib.prange(0, nocc, blksize): eri = _cp(feri['eri_mo'][i*nmo+nvir+p0:i*nmo+nvir+p1]) handler = async_do(handler, save_occ_frac, i, p0, p1, eri) cput1 = log.timer_debug1('sorting %d'%i, *cput1) if handler is not None: handler.join() for key in feri.keys(): del(feri[key]) log.timer('CCSD integral transformation', *cput0)
def __init__(self, myci, mo_coeff=None, method='incore'): cput0 = (time.clock(), time.time()) moidx = numpy.ones(myci.mo_occ.size, dtype=numpy.bool) if isinstance(myci.frozen, (int, numpy.integer)): moidx[:myci.frozen] = False elif len(myci.frozen) > 0: moidx[numpy.asarray(myci.frozen)] = False if mo_coeff is None: self.mo_coeff = mo_coeff = myci.mo_coeff[:,moidx] else: self.mo_coeff = mo_coeff = mo_coeff[:,moidx] dm = myci._scf.make_rdm1(myci.mo_coeff, myci.mo_occ) fockao = myci._scf.get_hcore() + myci._scf.get_veff(myci.mol, dm) self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff)) nocc = myci.nocc nmo = myci.nmo nvir = nmo - nocc mem_incore, mem_outcore, mem_basic = ccsd._mem_usage(nocc, nvir) mem_now = lib.current_memory()[0] log = logger.Logger(myci.stdout, myci.verbose) if (method == 'incore' and myci._scf._eri is not None and (mem_incore+mem_now < myci.max_memory) or myci.mol.incore_anyway): eri1 = ao2mo.incore.full(myci._scf._eri, mo_coeff) #:eri1 = ao2mo.restore(1, eri1, nmo) #:self.oooo = eri1[:nocc,:nocc,:nocc,:nocc].copy() #:self.ooov = eri1[:nocc,:nocc,:nocc,nocc:].copy() #:self.vooo = eri1[nocc:,:nocc,:nocc,:nocc].copy() #:self.voov = eri1[nocc:,:nocc,:nocc,nocc:].copy() #:self.vvoo = eri1[nocc:,nocc:,:nocc,:nocc].copy() #:vovv = eri1[nocc:,:nocc,nocc:,nocc:].copy() #:self.vovv = lib.pack_tril(vovv.reshape(-1,nvir,nvir)) #:self.vvvv = ao2mo.restore(4, eri1[nocc:,nocc:,nocc:,nocc:], nvir) nvir_pair = nvir * (nvir+1) // 2 self.oooo = numpy.empty((nocc,nocc,nocc,nocc)) self.ooov = numpy.empty((nocc,nocc,nocc,nvir)) self.vooo = numpy.empty((nvir,nocc,nocc,nocc)) self.voov = numpy.empty((nvir,nocc,nocc,nvir)) self.vovv = numpy.empty((nvir,nocc,nvir_pair)) self.vvvv = numpy.empty((nvir_pair,nvir_pair)) ij = 0 outbuf = numpy.empty((nmo,nmo,nmo)) oovv = numpy.empty((nocc,nocc,nvir,nvir)) for i in range(nocc): buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1]) for j in range(i+1): self.oooo[i,j] = self.oooo[j,i] = buf[j,:nocc,:nocc] self.ooov[i,j] = self.ooov[j,i] = buf[j,:nocc,nocc:] oovv[i,j] = oovv[j,i] = buf[j,nocc:,nocc:] ij += i + 1 self.vvoo = lib.transpose(oovv.reshape(nocc**2,-1)).reshape(nvir,nvir,nocc,nocc) oovv = None ij1 = 0 for i in range(nocc,nmo): buf = lib.unpack_tril(eri1[ij:ij+i+1], out=outbuf[:i+1]) self.vooo[i-nocc] = buf[:nocc,:nocc,:nocc] self.voov[i-nocc] = buf[:nocc,:nocc,nocc:] lib.pack_tril(_cp(buf[:nocc,nocc:,nocc:]), out=self.vovv[i-nocc]) dij = i - nocc + 1 lib.pack_tril(_cp(buf[nocc:i+1,nocc:,nocc:]), out=self.vvvv[ij1:ij1+dij]) ij += i + 1 ij1 += dij else: cput1 = time.clock(), time.time() _tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) _tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) self.feri1 = feri1 = h5py.File(_tmpfile1.name) def __del__feri1(self): feri1.close() self.feri1.__del__ = __del__feri1 orbo = mo_coeff[:,:nocc] orbv = mo_coeff[:,nocc:] nvpair = nvir * (nvir+1) // 2 self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), 'f8') self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), 'f8') self.vvoo = self.feri1.create_dataset('vvoo', (nvir,nvir,nocc,nocc), 'f8') self.vooo = self.feri1.create_dataset('vooo', (nvir,nocc,nocc,nocc), 'f8') self.voov = self.feri1.create_dataset('voov', (nvir,nocc,nocc,nvir), 'f8') self.vovv = self.feri1.create_dataset('vovv', (nvir,nocc,nvpair), 'f8') fsort = _ccsd.libcc.CCsd_sort_inplace nocc_pair = nocc*(nocc+1)//2 nvir_pair = nvir*(nvir+1)//2 def sort_inplace(p0, p1, eri): fsort(eri.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(nocc), ctypes.c_int(nvir), ctypes.c_int((p1-p0)*nocc)) vv = eri[:,:nvir_pair] oo = eri[:,nvir_pair:nvir_pair+nocc_pair] ov = eri[:,nvir_pair+nocc_pair:].reshape(-1,nocc,nvir) return oo, ov, vv buf = numpy.empty((nmo,nmo,nmo)) oovv = numpy.empty((nocc,nocc,nvir,nvir)) def save_occ_frac(p0, p1, eri): oo, ov, vv = sort_inplace(p0, p1, eri) self.oooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(p1-p0,nocc,nocc,nocc) self.ooov[p0:p1] = ov.reshape(p1-p0,nocc,nocc,nvir) oovv[p0:p1] = lib.unpack_tril(vv, out=buf).reshape(p1-p0,nocc,nvir,nvir) def save_vir_frac(p0, p1, eri): oo, ov, vv = sort_inplace(p0, p1, eri) self.vooo[p0:p1] = lib.unpack_tril(oo, out=buf).reshape(p1-p0,nocc,nocc,nocc) self.voov[p0:p1] = ov.reshape(p1-p0,nocc,nocc,nvir) self.vovv[p0:p1] = vv.reshape(p1-p0,nocc,-1) if not myci.direct: max_memory = max(2000,myci.max_memory-lib.current_memory()[0]) self.feri2 = feri2 = h5py.File(_tmpfile2.name) def __del__feri2(self): feri2.close() self.feri2.__del__ = __del__feri2 ao2mo.full(myci.mol, orbv, self.feri2, max_memory=max_memory, verbose=log) self.vvvv = self.feri2['eri_mo'] cput1 = log.timer_debug1('transforming vvvv', *cput1) tmpfile3 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) with h5py.File(tmpfile3.name, 'w') as feri: max_memory = max(2000, myci.max_memory-lib.current_memory()[0]) mo = numpy.hstack((orbv, orbo)) ao2mo.general(myci.mol, (mo,orbo,mo,mo), feri, max_memory=max_memory, verbose=log) cput1 = log.timer_debug1('transforming oppp', *cput1) blksize = max(1, int(min(8e9,max_memory*.5e6)/8/nmo**2/nocc)) handler = None for p0, p1 in lib.prange(0, nvir, blksize): eri = _cp(feri['eri_mo'][p0*nocc:p1*nocc]) handler = async_do(handler, save_vir_frac, p0, p1, eri) for p0, p1 in lib.prange(0, nocc, blksize): eri = _cp(feri['eri_mo'][(p0+nvir)*nocc:(p1+nvir)*nocc]) handler = async_do(handler, save_occ_frac, p0, p1, eri) if handler is not None: handler.join() self.vvoo[:] = lib.transpose(oovv.reshape(nocc**2,-1)).reshape(nvir,nvir,nocc,nocc) log.timer('CISD integral transformation', *cput0)
def test_from_integral(self): tmpfcidump = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff)) h2 = ao2mo.full(mf._eri, mf.mo_coeff) fcidump.from_integrals(tmpfcidump.name, h1, h2, h1.shape[0], mol.nelectron, tol=1e-15)
def kernel(cc, t1, t2, l1, l2, eris=None): if eris is None: eris = _ERIS(cc, cc.mo_coeff) mol = cc.mol mo_coeff = cc.mo_coeff mo_energy = cc._scf.mo_energy nao, nmo = mo_coeff.shape nocc = numpy.count_nonzero(cc.mo_occ > 0) nvir = nmo - nocc mo_e_o = mo_energy[:nocc] mo_e_v = mo_energy[nocc:] with_frozen = not (cc.frozen is None or cc.frozen is 0) d1 = _gamma1_intermediates(cc, t1, t2, l1, l2) d2 = _gamma2_intermediates(cc, t1, t2, l1, l2) dm2 = ccsd_rdm._make_rdm2(cc, d1, d2, with_dm1=False, with_frozen=False) eri = ao2mo.restore(1, ao2mo.full(cc.mol, mo_coeff), nmo) Imat = numpy.einsum('jqrs,iqrs->ij', dm2, eri) * -1 Ioo = Imat[:nocc,:nocc] Ivv = Imat[nocc:,nocc:] doo, dov, dvo, dvv = d1 if with_frozen: OA, VA, OF, VF = index_frozen_active(cc) doo[OF[:,None],OA] = Ioo[OF[:,None],OA] / lib.direct_sum('i-j->ij', mo_e_o[OF], mo_e_o[OA]) doo[OA[:,None],OF] = Ioo[OA[:,None],OF] / lib.direct_sum('i-j->ij', mo_e_o[OA], mo_e_o[OF]) dvv[VF[:,None],VA] = Ivv[VF[:,None],VA] / lib.direct_sum('a-b->ab', mo_e_v[VF], mo_e_v[VA]) dvv[VA[:,None],VF] = Ivv[VA[:,None],VF] / lib.direct_sum('a-b->ab', mo_e_v[VA], mo_e_v[VF]) dm1 = scipy.linalg.block_diag(doo+doo.T, dvv+dvv.T) dm1ao = reduce(numpy.dot, (mo_coeff, dm1, mo_coeff.T)) vj, vk = cc._scf.get_jk(cc.mol, dm1ao) Xvo = reduce(numpy.dot, (mo_coeff[:,nocc:].T, vj*2-vk, mo_coeff[:,:nocc])) Xvo += Imat[:nocc,nocc:].T - Imat[nocc:,:nocc] dm1 += ccsd_grad._response_dm1(cc, Xvo, eris) Imat[nocc:,:nocc] = Imat[:nocc,nocc:].T h1 =-(mol.intor('int1e_ipkin', comp=3) +mol.intor('int1e_ipnuc', comp=3)) s1 =-mol.intor('int1e_ipovlp', comp=3) zeta = lib.direct_sum('i-j->ij', mo_energy, mo_energy) eri1 = mol.intor('int2e_ip1', comp=3).reshape(3,nao,nao,nao,nao) eri1 = numpy.einsum('xipkl,pj->xijkl', eri1, mo_coeff) eri1 = numpy.einsum('xijpl,pk->xijkl', eri1, mo_coeff) eri1 = numpy.einsum('xijkp,pl->xijkl', eri1, mo_coeff) g0 = ao2mo.restore(1, ao2mo.full(mol, mo_coeff), nmo) de = numpy.empty((mol.natm,3)) for k,(sh0, sh1, p0, p1) in enumerate(mol.offset_nr_by_atom()): mol.set_rinv_origin(mol.atom_coord(k)) vrinv = -mol.atom_charge(k) * mol.intor('int1e_iprinv', comp=3) # 2e AO integrals dot 2pdm de2 = numpy.zeros(3) for i in range(3): g1 = numpy.einsum('pjkl,pi->ijkl', eri1[i,p0:p1], mo_coeff[p0:p1]) g1 = g1 + g1.transpose(1,0,2,3) g1 = g1 + g1.transpose(2,3,0,1) g1 *= -1 hx =(numpy.einsum('pq,pi,qj->ij', h1[i,p0:p1], mo_coeff[p0:p1], mo_coeff) + reduce(numpy.dot, (mo_coeff.T, vrinv[i], mo_coeff))) hx = hx + hx.T sx = numpy.einsum('pq,pi,qj->ij', s1[i,p0:p1], mo_coeff[p0:p1], mo_coeff) sx = sx + sx.T fij =(hx[:nocc,:nocc] - numpy.einsum('ij,j->ij', sx[:nocc,:nocc], mo_e_o) * .5 - numpy.einsum('ij,i->ij', sx[:nocc,:nocc], mo_e_o) * .5 - numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc], g0[:nocc,:nocc,:nocc,:nocc]) * 2 + numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc], g0[:nocc,:nocc,:nocc,:nocc]) + numpy.einsum('ijkk->ij', g1[:nocc,:nocc,:nocc,:nocc]) * 2 - numpy.einsum('ikkj->ij', g1[:nocc,:nocc,:nocc,:nocc])) fab =(hx[nocc:,nocc:] - numpy.einsum('ij,j->ij', sx[nocc:,nocc:], mo_e_v) * .5 - numpy.einsum('ij,i->ij', sx[nocc:,nocc:], mo_e_v) * .5 - numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc], g0[nocc:,nocc:,:nocc,:nocc]) * 2 + numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc], g0[nocc:,:nocc,:nocc,nocc:]) + numpy.einsum('ijkk->ij', g1[nocc:,nocc:,:nocc,:nocc]) * 2 - numpy.einsum('ikkj->ij', g1[nocc:,:nocc,:nocc,nocc:])) if with_frozen: fij[OA[:,None],OF] -= numpy.einsum('ij,j->ij', sx[OA[:,None],OF], mo_e_o[OF]) * .5 fij[OA[:,None],OF] += numpy.einsum('ij,i->ij', sx[OA[:,None],OF], mo_e_o[OA]) * .5 fij[OF[:,None],OA] -= numpy.einsum('ij,j->ij', sx[OF[:,None],OA], mo_e_o[OA]) * .5 fij[OF[:,None],OA] += numpy.einsum('ij,i->ij', sx[OF[:,None],OA], mo_e_o[OF]) * .5 fab[VA[:,None],VF] -= numpy.einsum('ij,j->ij', sx[VA[:,None],VF], mo_e_v[VF]) * .5 fab[VA[:,None],VF] += numpy.einsum('ij,i->ij', sx[VA[:,None],VF], mo_e_v[VA]) * .5 fab[VF[:,None],VA] -= numpy.einsum('ij,j->ij', sx[VF[:,None],VA], mo_e_v[VA]) * .5 fab[VF[:,None],VA] += numpy.einsum('ij,i->ij', sx[VF[:,None],VA], mo_e_v[VF]) * .5 fai =(hx[nocc:,:nocc] - numpy.einsum('ai,i->ai', sx[nocc:,:nocc], mo_e_o) - numpy.einsum('kl,ijlk->ij', sx[:nocc,:nocc], g0[nocc:,:nocc,:nocc,:nocc]) * 2 + numpy.einsum('kl,iklj->ij', sx[:nocc,:nocc], g0[nocc:,:nocc,:nocc,:nocc]) + numpy.einsum('ijkk->ij', g1[nocc:,:nocc,:nocc,:nocc]) * 2 - numpy.einsum('ikkj->ij', g1[nocc:,:nocc,:nocc,:nocc])) f1 = numpy.zeros((nmo,nmo)) f1[:nocc,:nocc] = fij f1[nocc:,nocc:] = fab f1[nocc:,:nocc] = fai f1[:nocc,nocc:] = fai.T de2[i] += numpy.einsum('ij,ji', f1, dm1) de2[i] += numpy.einsum('ij,ji', sx, Imat) de2[i] += numpy.einsum('iajb,iajb', dm2, g1) * .5 de[k] = de2 return de
def _make_eris_incore(mycc, mo_coeff=None, ao2mofn=None): cput0 = (time.clock(), time.time()) eris = _ChemistsERIs() eris._common_init_(mycc, mo_coeff) nocca, noccb = mycc.nocc nmoa, nmob = mycc.nmo nvira, nvirb = nmoa-nocca, nmob-noccb moa = eris.mo_coeff[0] mob = eris.mo_coeff[1] nmoa = moa.shape[1] nmob = mob.shape[1] if callable(ao2mofn): eri_aa = ao2mofn(moa).reshape([nmoa]*4) eri_bb = ao2mofn(mob).reshape([nmob]*4) eri_ab = ao2mofn((moa,moa,mob,mob)) else: eri_aa = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, moa), nmoa) eri_bb = ao2mo.restore(1, ao2mo.full(mycc._scf._eri, mob), nmob) eri_ab = ao2mo.general(mycc._scf._eri, (moa,moa,mob,mob), compact=False) eri_ba = eri_ab.reshape(nmoa,nmoa,nmob,nmob).transpose(2,3,0,1) eri_aa = eri_aa.reshape(nmoa,nmoa,nmoa,nmoa) eri_ab = eri_ab.reshape(nmoa,nmoa,nmob,nmob) eri_ba = eri_ba.reshape(nmob,nmob,nmoa,nmoa) eri_bb = eri_bb.reshape(nmob,nmob,nmob,nmob) eris.oooo = eri_aa[:nocca,:nocca,:nocca,:nocca].copy() eris.ovoo = eri_aa[:nocca,nocca:,:nocca,:nocca].copy() eris.ovov = eri_aa[:nocca,nocca:,:nocca,nocca:].copy() eris.oovv = eri_aa[:nocca,:nocca,nocca:,nocca:].copy() eris.ovvo = eri_aa[:nocca,nocca:,nocca:,:nocca].copy() eris.ovvv = eri_aa[:nocca,nocca:,nocca:,nocca:].copy() eris.vvvv = eri_aa[nocca:,nocca:,nocca:,nocca:].copy() eris.OOOO = eri_bb[:noccb,:noccb,:noccb,:noccb].copy() eris.OVOO = eri_bb[:noccb,noccb:,:noccb,:noccb].copy() eris.OVOV = eri_bb[:noccb,noccb:,:noccb,noccb:].copy() eris.OOVV = eri_bb[:noccb,:noccb,noccb:,noccb:].copy() eris.OVVO = eri_bb[:noccb,noccb:,noccb:,:noccb].copy() eris.OVVV = eri_bb[:noccb,noccb:,noccb:,noccb:].copy() eris.VVVV = eri_bb[noccb:,noccb:,noccb:,noccb:].copy() eris.ooOO = eri_ab[:nocca,:nocca,:noccb,:noccb].copy() eris.ovOO = eri_ab[:nocca,nocca:,:noccb,:noccb].copy() eris.ovOV = eri_ab[:nocca,nocca:,:noccb,noccb:].copy() eris.ooVV = eri_ab[:nocca,:nocca,noccb:,noccb:].copy() eris.ovVO = eri_ab[:nocca,nocca:,noccb:,:noccb].copy() eris.ovVV = eri_ab[:nocca,nocca:,noccb:,noccb:].copy() eris.vvVV = eri_ab[nocca:,nocca:,noccb:,noccb:].copy() #eris.OOoo = eri_ba[:noccb,:noccb,:nocca,:nocca].copy() eris.OVoo = eri_ba[:noccb,noccb:,:nocca,:nocca].copy() #eris.OVov = eri_ba[:noccb,noccb:,:nocca,nocca:].copy() eris.OOvv = eri_ba[:noccb,:noccb,nocca:,nocca:].copy() eris.OVvo = eri_ba[:noccb,noccb:,nocca:,:nocca].copy() eris.OVvv = eri_ba[:noccb,noccb:,nocca:,nocca:].copy() #eris.VVvv = eri_ba[noccb:,noccb:,nocca:,nocca:].copy() if not callable(ao2mofn): ovvv = eris.ovvv.reshape(nocca*nvira,nvira,nvira) eris.ovvv = lib.pack_tril(ovvv).reshape(nocca,nvira,nvira*(nvira+1)//2) eris.vvvv = ao2mo.restore(4, eris.vvvv, nvira) OVVV = eris.OVVV.reshape(noccb*nvirb,nvirb,nvirb) eris.OVVV = lib.pack_tril(OVVV).reshape(noccb,nvirb,nvirb*(nvirb+1)//2) eris.VVVV = ao2mo.restore(4, eris.VVVV, nvirb) ovVV = eris.ovVV.reshape(nocca*nvira,nvirb,nvirb) eris.ovVV = lib.pack_tril(ovVV).reshape(nocca,nvira,nvirb*(nvirb+1)//2) vvVV = eris.vvVV.reshape(nvira**2,nvirb**2) idxa = np.tril_indices(nvira) idxb = np.tril_indices(nvirb) eris.vvVV = lib.take_2d(vvVV, idxa[0]*nvira+idxa[1], idxb[0]*nvirb+idxb[1]) OVvv = eris.OVvv.reshape(noccb*nvirb,nvira,nvira) eris.OVvv = lib.pack_tril(OVvv).reshape(noccb,nvirb,nvira*(nvira+1)//2) return eris
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() nmo = rhf.mo_energy.size fock0 = numpy.diag(rhf.mo_energy) nocc = mol.nelectron // 2 nvir = nmo - nocc eris = mcc.ao2mo() 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.cc import ccsd_rdm dm1 = ccsd_rdm.make_rdm1(mcc, t1, t2, l1, l2) dm2 = ccsd_rdm.make_rdm2(mcc, t1, t2, l1, l2) h1 = reduce(numpy.dot, (rhf.mo_coeff.T, rhf.get_hcore(), rhf.mo_coeff)) eri = ao2mo.full(rhf._eri, rhf.mo_coeff) eri = ao2mo.restore(1, eri, nmo).reshape((nmo,) * 4) e1 = numpy.einsum("pq,pq", h1, dm1) e2 = numpy.einsum("pqrs,pqrs", eri, dm2) * 0.5 print(e1 + e2 + mol.energy_nuc() - rhf.e_tot - ecc)
# Author: Qiming Sun <*****@*****.**> # ''' Assign spin state for HCI wavefunction. If spin-contamination is observed for HCI wavefunction, :func:`hci.fix_spin` function can be used to level shift the states of wrong spin. This is often helpful to reduce the spin-contamination. ''' from pyscf import gto, scf, ao2mo from pyscf.hci import hci mol = gto.M(atom='O 0 0 0', basis='631g', spin=0) myhf = scf.RHF(mol).run() cisolver = hci.SCI(mol) nmo = myhf.mo_coeff.shape[1] nelec = mol.nelec h1 = myhf.mo_coeff.T.dot(myhf.get_hcore()).dot(myhf.mo_coeff) h2 = ao2mo.full(mol, myhf.mo_coeff) e, civec = cisolver.kernel(h1, h2, nmo, nelec, verbose=4) print('E = %.12f 2S+1 = %.7f' % (e, cisolver.spin_square(civec[0], nmo, nelec)[1])) cisolver = hci.fix_spin(cisolver, ss=0) # ss = S^2 e, civec = cisolver.kernel(h1, h2, nmo, nelec, verbose=4) print('E = %.12f 2S+1 = %.7f' % (e, cisolver.spin_square(civec[0], nmo, nelec)[1]))
def __init__(self, cc, mo_coeff=None, method='incore', ao2mofn=ao2mo.outcore.general_iofree): cput0 = (time.clock(), time.time()) moidx = numpy.ones(cc.mo_occ.size, dtype=numpy.bool) if isinstance(cc.frozen, (int, numpy.integer)): moidx[:cc.frozen] = False elif len(cc.frozen) > 0: moidx[numpy.asarray(cc.frozen)] = False if mo_coeff is None: self.mo_coeff = mo_coeff = cc.mo_coeff[:,moidx] else: # If mo_coeff is not canonical orbital self.mo_coeff = mo_coeff = mo_coeff[:,moidx] dm = cc._scf.make_rdm1(cc.mo_coeff, cc.mo_occ) fockao = cc._scf.get_hcore() + cc._scf.get_veff(cc.mol, dm) self.fock = reduce(numpy.dot, (mo_coeff.T, fockao, mo_coeff)) nocc = cc.nocc nmo = cc.nmo nvir = nmo - nocc mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir) mem_now = lib.current_memory()[0] log = logger.Logger(cc.stdout, cc.verbose) if (method == 'incore' and (mem_incore+mem_now < cc.max_memory) or cc.mol.incore_anyway): eri = ao2mofn(cc._scf.mol, (mo_coeff,mo_coeff,mo_coeff,mo_coeff), compact=0) if mo_coeff.dtype == np.float: eri = eri.real eri = eri.reshape((nmo,)*4) # <ij|kl> = (ik|jl) eri = eri.transpose(0,2,1,3) self.dtype = eri.dtype self.oooo = eri[:nocc,:nocc,:nocc,:nocc].copy() self.ooov = eri[:nocc,:nocc,:nocc,nocc:].copy() self.oovv = eri[:nocc,:nocc,nocc:,nocc:].copy() self.ovov = eri[:nocc,nocc:,:nocc,nocc:].copy() self.voov = eri[nocc:,:nocc,:nocc,nocc:].copy() self.vovv = eri[nocc:,:nocc,nocc:,nocc:].copy() self.vvvv = eri[nocc:,nocc:,nocc:,nocc:].copy() else: _tmpfile1 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) self.feri1 = h5py.File(_tmpfile1.name) orbo = mo_coeff[:,:nocc] orbv = mo_coeff[:,nocc:] if mo_coeff.dtype == np.complex: ds_type = 'c16' else: ds_type = 'f8' self.oooo = self.feri1.create_dataset('oooo', (nocc,nocc,nocc,nocc), ds_type) self.ooov = self.feri1.create_dataset('ooov', (nocc,nocc,nocc,nvir), ds_type) self.oovv = self.feri1.create_dataset('oovv', (nocc,nocc,nvir,nvir), ds_type) self.ovov = self.feri1.create_dataset('ovov', (nocc,nvir,nocc,nvir), ds_type) self.voov = self.feri1.create_dataset('voov', (nvir,nocc,nocc,nvir), ds_type) self.vovv = self.feri1.create_dataset('vovv', (nvir,nocc,nvir,nvir), ds_type) self.vvvv = self.feri1.create_dataset('vvvv', (nvir,nvir,nvir,nvir), ds_type) cput1 = time.clock(), time.time() # <ij|pq> = (ip|jq) buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbo,mo_coeff), compact=0) if mo_coeff.dtype == np.float: buf = buf.real buf = buf.reshape((nocc,nmo,nocc,nmo)).transpose(0,2,1,3) cput1 = log.timer_debug1('transforming oopq', *cput1) self.dtype = buf.dtype self.oooo[:,:,:,:] = buf[:,:,:nocc,:nocc] self.ooov[:,:,:,:] = buf[:,:,:nocc,nocc:] self.oovv[:,:,:,:] = buf[:,:,nocc:,nocc:] cput1 = time.clock(), time.time() # <ia|pq> = (ip|aq) buf = ao2mofn(cc._scf.mol, (orbo,mo_coeff,orbv,mo_coeff), compact=0) if mo_coeff.dtype == np.float: buf = buf.real buf = buf.reshape((nocc,nmo,nvir,nmo)).transpose(0,2,1,3) cput1 = log.timer_debug1('transforming ovpq', *cput1) self.ovov[:,:,:,:] = buf[:,:,:nocc,nocc:] self.vovv[:,:,:,:] = buf[:,:,nocc:,nocc:].transpose(1,0,3,2) self.voov[:,:,:,:] = buf[:,:,nocc:,:nocc].transpose(1,0,3,2) _tmpfile2 = tempfile.NamedTemporaryFile() self.feri2 = h5py.File(_tmpfile2.name, 'w') ao2mo.full(cc.mol, orbv, self.feri2, max_memory=cc.max_memory, verbose=log, compact=False) vvvv_buf = self.feri2['eri_mo'] for a in range(nvir): abrange = a*nvir + np.arange(nvir) self.vvvv[a,:,:,:] = np.array(vvvv_buf[abrange,:]).reshape((nvir,nvir,nvir)).transpose(1,0,2) cput1 = log.timer_debug1('transforming vvvv', *cput1) log.timer('CCSD integral transformation', *cput0)
def _make_eris_outcore(mycc, mo_coeff=None): cput0 = (time.clock(), time.time()) eris = _ChemistsERIs() eris._common_init_(mycc, mo_coeff) nocca, noccb = mycc.nocc nmoa, nmob = mycc.nmo nvira, nvirb = nmoa-nocca, nmob-noccb moa = eris.mo_coeff[0] mob = eris.mo_coeff[1] nmoa = moa.shape[1] nmob = mob.shape[1] orboa = moa[:,:nocca] orbob = mob[:,:noccb] orbva = moa[:,nocca:] orbvb = mob[:,noccb:] eris.feri = lib.H5TmpFile() eris.oooo = eris.feri.create_dataset('oooo', (nocca,nocca,nocca,nocca), 'f8') eris.ovoo = eris.feri.create_dataset('ovoo', (nocca,nvira,nocca,nocca), 'f8') eris.ovov = eris.feri.create_dataset('ovov', (nocca,nvira,nocca,nvira), 'f8') eris.oovv = eris.feri.create_dataset('oovv', (nocca,nocca,nvira,nvira), 'f8') eris.ovvo = eris.feri.create_dataset('ovvo', (nocca,nvira,nvira,nocca), 'f8') eris.ovvv = eris.feri.create_dataset('ovvv', (nocca,nvira,nvira*(nvira+1)//2), 'f8') #eris.vvvv = eris.feri.create_dataset('vvvv', (nvira,nvira,nvira,nvira), 'f8') eris.OOOO = eris.feri.create_dataset('OOOO', (noccb,noccb,noccb,noccb), 'f8') eris.OVOO = eris.feri.create_dataset('OVOO', (noccb,nvirb,noccb,noccb), 'f8') eris.OVOV = eris.feri.create_dataset('OVOV', (noccb,nvirb,noccb,nvirb), 'f8') eris.OOVV = eris.feri.create_dataset('OOVV', (noccb,noccb,nvirb,nvirb), 'f8') eris.OVVO = eris.feri.create_dataset('OVVO', (noccb,nvirb,nvirb,noccb), 'f8') eris.OVVV = eris.feri.create_dataset('OVVV', (noccb,nvirb,nvirb*(nvirb+1)//2), 'f8') #eris.VVVV = eris.feri.create_dataset('VVVV', (nvirb,nvirb,nvirb,nvirb), 'f8') eris.ooOO = eris.feri.create_dataset('ooOO', (nocca,nocca,noccb,noccb), 'f8') eris.ovOO = eris.feri.create_dataset('ovOO', (nocca,nvira,noccb,noccb), 'f8') eris.ovOV = eris.feri.create_dataset('ovOV', (nocca,nvira,noccb,nvirb), 'f8') eris.ooVV = eris.feri.create_dataset('ooVV', (nocca,nocca,nvirb,nvirb), 'f8') eris.ovVO = eris.feri.create_dataset('ovVO', (nocca,nvira,nvirb,noccb), 'f8') eris.ovVV = eris.feri.create_dataset('ovVV', (nocca,nvira,nvirb*(nvirb+1)//2), 'f8') #eris.vvVV = eris.feri.create_dataset('vvVV', (nvira,nvira,nvirb,nvirb), 'f8') eris.OVoo = eris.feri.create_dataset('OVoo', (noccb,nvirb,nocca,nocca), 'f8') eris.OOvv = eris.feri.create_dataset('OOvv', (noccb,noccb,nvira,nvira), 'f8') eris.OVvo = eris.feri.create_dataset('OVvo', (noccb,nvirb,nvira,nocca), 'f8') eris.OVvv = eris.feri.create_dataset('OVvv', (noccb,nvirb,nvira*(nvira+1)//2), 'f8') cput1 = time.clock(), time.time() mol = mycc.mol # <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp) tmpf = lib.H5TmpFile() if nocca > 0: ao2mo.general(mol, (orboa,moa,moa,moa), tmpf, 'aa') buf = np.empty((nmoa,nmoa,nmoa)) for i in range(nocca): lib.unpack_tril(tmpf['aa'][i*nmoa:(i+1)*nmoa], out=buf) eris.oooo[i] = buf[:nocca,:nocca,:nocca] eris.ovoo[i] = buf[nocca:,:nocca,:nocca] eris.ovov[i] = buf[nocca:,:nocca,nocca:] eris.oovv[i] = buf[:nocca,nocca:,nocca:] eris.ovvo[i] = buf[nocca:,nocca:,:nocca] eris.ovvv[i] = lib.pack_tril(buf[nocca:,nocca:,nocca:]) del(tmpf['aa']) if noccb > 0: buf = np.empty((nmob,nmob,nmob)) ao2mo.general(mol, (orbob,mob,mob,mob), tmpf, 'bb') for i in range(noccb): lib.unpack_tril(tmpf['bb'][i*nmob:(i+1)*nmob], out=buf) eris.OOOO[i] = buf[:noccb,:noccb,:noccb] eris.OVOO[i] = buf[noccb:,:noccb,:noccb] eris.OVOV[i] = buf[noccb:,:noccb,noccb:] eris.OOVV[i] = buf[:noccb,noccb:,noccb:] eris.OVVO[i] = buf[noccb:,noccb:,:noccb] eris.OVVV[i] = lib.pack_tril(buf[noccb:,noccb:,noccb:]) del(tmpf['bb']) if nocca > 0: buf = np.empty((nmoa,nmob,nmob)) ao2mo.general(mol, (orboa,moa,mob,mob), tmpf, 'ab') for i in range(nocca): lib.unpack_tril(tmpf['ab'][i*nmoa:(i+1)*nmoa], out=buf) eris.ooOO[i] = buf[:nocca,:noccb,:noccb] eris.ovOO[i] = buf[nocca:,:noccb,:noccb] eris.ovOV[i] = buf[nocca:,:noccb,noccb:] eris.ooVV[i] = buf[:nocca,noccb:,noccb:] eris.ovVO[i] = buf[nocca:,noccb:,:noccb] eris.ovVV[i] = lib.pack_tril(buf[nocca:,noccb:,noccb:]) del(tmpf['ab']) if noccb > 0: buf = np.empty((nmob,nmoa,nmoa)) ao2mo.general(mol, (orbob,mob,moa,moa), tmpf, 'ba') for i in range(noccb): lib.unpack_tril(tmpf['ba'][i*nmob:(i+1)*nmob], out=buf) eris.OVoo[i] = buf[noccb:,:nocca,:nocca] eris.OOvv[i] = buf[:noccb,nocca:,nocca:] eris.OVvo[i] = buf[noccb:,nocca:,:nocca] eris.OVvv[i] = lib.pack_tril(buf[noccb:,nocca:,nocca:]) del(tmpf['ba']) buf = None cput1 = logger.timer_debug1(mycc, 'transforming oopq, ovpq', *cput1) if not mycc.direct: ao2mo.full(mol, orbva, eris.feri, dataname='vvvv') ao2mo.full(mol, orbvb, eris.feri, dataname='VVVV') ao2mo.general(mol, (orbva,orbva,orbvb,orbvb), eris.feri, dataname='vvVV') eris.vvvv = eris.feri['vvvv'] eris.VVVV = eris.feri['VVVV'] eris.vvVV = eris.feri['vvVV'] cput1 = logger.timer_debug1(mycc, 'transforming vvvv', *cput1) return eris