def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None): log = logger.new_logger(mp, verbose) time0 = (time.clock(), time.time()) eris = _ChemistsERIs(mp, mo_coeff) nocca, noccb = mp.get_nocc() nmoa, nmob = mp.get_nmo() nvira, nvirb = nmoa-nocca, nmob-noccb nao = eris.mo_coeff[0].shape[0] nmo_pair = nmoa * (nmoa+1) // 2 nao_pair = nao * (nao+1) // 2 mem_incore = (nao_pair**2 + nmo_pair**2) * 8/1e6 mem_now = lib.current_memory()[0] max_memory = max(0, mp.max_memory-mem_now) moa = eris.mo_coeff[0] mob = eris.mo_coeff[1] orboa = moa[:,:nocca] orbob = mob[:,:noccb] orbva = moa[:,nocca:] orbvb = mob[:,noccb:] if (mp.mol.incore_anyway or (mp._scf._eri is not None and mem_incore+mem_now < mp.max_memory)): log.debug('transform (ia|jb) incore') if callable(ao2mofn): eris.ovov = ao2mofn((orboa,orbva,orboa,orbva)).reshape(nocca*nvira,nocca*nvira) eris.ovOV = ao2mofn((orboa,orbva,orbob,orbvb)).reshape(nocca*nvira,noccb*nvirb) eris.OVOV = ao2mofn((orbob,orbvb,orbob,orbvb)).reshape(noccb*nvirb,noccb*nvirb) else: eris.ovov = ao2mo.general(mp._scf._eri, (orboa,orbva,orboa,orbva)) eris.ovOV = ao2mo.general(mp._scf._eri, (orboa,orbva,orbob,orbvb)) eris.OVOV = ao2mo.general(mp._scf._eri, (orbob,orbvb,orbob,orbvb)) elif getattr(mp._scf, 'with_df', None): logger.warn(mp, 'UMP2 detected DF being used in the HF object. ' 'MO integrals are computed based on the DF 3-index tensors.\n' 'It\'s recommended to use DF-UMP2 module.') log.debug('transform (ia|jb) with_df') eris.ovov = mp._scf.with_df.ao2mo((orboa,orbva,orboa,orbva)) eris.ovOV = mp._scf.with_df.ao2mo((orboa,orbva,orbob,orbvb)) eris.OVOV = mp._scf.with_df.ao2mo((orbob,orbvb,orbob,orbvb)) else: log.debug('transform (ia|jb) outcore') eris.feri = lib.H5TmpFile() _ao2mo_ovov(mp, (orboa,orbva,orbob,orbvb), eris.feri, max(2000, max_memory), log) eris.ovov = eris.feri['ovov'] eris.ovOV = eris.feri['ovOV'] eris.OVOV = eris.feri['OVOV'] time1 = log.timer('Integral transformation', *time0) return eris
def general(mydf, mo_coeffs, kpts=None, compact=True): if isinstance(mo_coeffs, numpy.ndarray) and mo_coeffs.ndim == 2: mo_coeffs = (mo_coeffs,) * 4 eri = mydf.get_eri(kpts) #################### # gamma point, the integral is real and with s4 symmetry if eri.dtype == numpy.float64: return ao2mo.general(eri, mo_coeffs, compact=compact) else: mokl, klslice = ao2mo.incore._conc_mos(mo_coeffs[2], mo_coeffs[3], False)[2:] if mokl.dtype == numpy.float64: mokl = mokl + 0j nao = mo_coeffs[0].shape[0] nmoi = mo_coeffs[0].shape[1] nmoj = mo_coeffs[1].shape[1] nmok = mo_coeffs[2].shape[1] nmol = mo_coeffs[3].shape[1] moi = numpy.asarray(mo_coeffs[0], order='F') moj = numpy.asarray(mo_coeffs[1], order='F') tao = [0] ao_loc = None pqkl = _ao2mo.r_e2(eri.reshape(-1,nao**2), mokl, klslice, tao, ao_loc, aosym='s1') pqkl = pqkl.reshape(nao,nao,nmok*nmol) pjkl = numpy.empty((nao,nmoj,nmok*nmol), dtype=numpy.complex128) for i in range(nao): lib.dot(moj.T, pqkl[i], 1, pjkl[i], 0) pqkl = None eri_mo = lib.dot(moi.T.conj(), pjkl.reshape(nao,-1)) return eri_mo.reshape(nmoi*nmoj,-1)
def add_hf_(a, b, hyb=1): eri_mo = ao2mo.general(mol, [orbo,mo,mo,mo], compact=False) eri_mo = eri_mo.reshape(nocc,nmo,nmo,nmo) a += numpy.einsum('iabj->iajb', eri_mo[:nocc,nocc:,nocc:,:nocc]) * 2 a -= numpy.einsum('ijba->iajb', eri_mo[:nocc,:nocc,nocc:,nocc:]) * hyb b += numpy.einsum('iajb->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:]) * 2 b -= numpy.einsum('jaib->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:]) * hyb
def test_mp2_ao2mo_ovov(self): pt = mp.mp2.MP2(mf) orbo = mf.mo_coeff[:,:8] orbv = mf.mo_coeff[:,8:] ftmp = lib.H5TmpFile() h5dat = mp.mp2._ao2mo_ovov(pt, orbo, orbv, ftmp, 1) ovov = numpy.asarray(h5dat) ovov_ref = ao2mo.general(mf._eri, (orbo,orbv,orbo,orbv)) self.assertAlmostEqual(numpy.linalg.norm(ovov_ref-ovov), 0, 9)
def _exact_paaa(self, mo, u, out=None): nmo = mo.shape[1] ncore = self.ncore ncas = self.ncas nocc = ncore + ncas mo1 = numpy.dot(mo, u) mo1_cas = mo1[:,ncore:nocc] mos = (mo1_cas, mo1_cas, mo1, mo1_cas) if self._scf._eri is None: aapa = ao2mo.general(self.mol, mos) else: aapa = ao2mo.general(self._scf._eri, mos) paaa = numpy.empty((nmo*ncas,ncas*ncas)) buf = numpy.empty((ncas,ncas,nmo*ncas)) for ij, (i, j) in enumerate(zip(*numpy.tril_indices(ncas))): buf[i,j] = buf[j,i] = aapa[ij] paaa = lib.transpose(buf.reshape(ncas*ncas,-1), out=out) return paaa.reshape(nmo,ncas,ncas,ncas)
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 test_ump2_ao2mo_ovov(self): pt = mp.UMP2(mf) nocca, noccb = mol.nelec orboa = mf.mo_coeff[0][:,:nocca] orbva = mf.mo_coeff[0][:,nocca:] orbob = mf.mo_coeff[1][:,:noccb] orbvb = mf.mo_coeff[1][:,noccb:] orbs = (orboa, orbva, orbob, orbvb) ftmp = lib.H5TmpFile() mp.ump2._ao2mo_ovov(pt, orbs, ftmp, 1) ovov = numpy.asarray(ftmp['ovov']) ovOV = numpy.asarray(ftmp['ovOV']) OVOV = numpy.asarray(ftmp['OVOV']) ovov_ref = ao2mo.general(mf._eri, (orboa,orbva,orboa,orbva)) ovOV_ref = ao2mo.general(mf._eri, (orboa,orbva,orbob,orbvb)) OVOV_ref = ao2mo.general(mf._eri, (orbob,orbvb,orbob,orbvb)) self.assertAlmostEqual(numpy.linalg.norm(ovov_ref-ovov), 0, 9) self.assertAlmostEqual(numpy.linalg.norm(ovOV_ref-ovOV), 0, 9) self.assertAlmostEqual(numpy.linalg.norm(OVOV_ref-OVOV), 0, 9)
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None): log = logger.new_logger(mp, verbose) time0 = (time.clock(), time.time()) eris = _ChemistsERIs(mp, mo_coeff) mo_coeff = eris.mo_coeff nocc = mp.nocc nmo = mp.nmo nvir = nmo - nocc mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir) mem_now = lib.current_memory()[0] max_memory = max(0, mp.max_memory - mem_now) if max_memory < mem_basic: log.warn( 'Not enough memory for integral transformation. ' 'Available mem %s MB, required mem %s MB', max_memory, mem_basic) co = numpy.asarray(mo_coeff[:, :nocc], order='F') cv = numpy.asarray(mo_coeff[:, nocc:], order='F') if (mp.mol.incore_anyway or (mp._scf._eri is not None and mem_incore < max_memory)): log.debug('transform (ia|jb) incore') if callable(ao2mofn): eris.ovov = ao2mofn( (co, cv, co, cv)).reshape(nocc * nvir, nocc * nvir) else: eris.ovov = ao2mo.general(mp._scf._eri, (co, cv, co, cv)) elif getattr(mp._scf, 'with_df', None): # To handle the PBC or custom 2-electron with 3-index tensor. # Call dfmp2.MP2 for efficient DF-MP2 implementation. log.warn('DF-HF is found. (ia|jb) is computed based on the DF ' '3-tensor integrals.\n' 'You can switch to dfmp2.MP2 for better performance') log.debug('transform (ia|jb) with_df') eris.ovov = mp._scf.with_df.ao2mo((co, cv, co, cv)) else: log.debug('transform (ia|jb) outcore') eris.feri = lib.H5TmpFile() #ao2mo.outcore.general(mp.mol, (co,cv,co,cv), eris.feri, # max_memory=max_memory, verbose=log) #eris.ovov = eris.feri['eri_mo'] eris.ovov = _ao2mo_ovov(mp, co, cv, eris.feri, max(2000, max_memory), log) time1 = log.timer('Integral transformation', *time0) return eris
def myump2(mol, mo_energy, mo_coeff, mo_occ): o = numpy.hstack((mo_coeff[0][:,mo_occ[0]>0] ,mo_coeff[1][:,mo_occ[1]>0])) v = numpy.hstack((mo_coeff[0][:,mo_occ[0]==0],mo_coeff[1][:,mo_occ[1]==0])) eo = numpy.hstack((mo_energy[0][mo_occ[0]>0] ,mo_energy[1][mo_occ[1]>0])) ev = numpy.hstack((mo_energy[0][mo_occ[0]==0],mo_energy[1][mo_occ[1]==0])) no = o.shape[1] nv = v.shape[1] noa = sum(mo_occ[0]>0) nva = sum(mo_occ[0]==0) eri = ao2mo.general(mol, (o,v,o,v)).reshape(no,nv,no,nv) eri[:noa,nva:] = eri[noa:,:nva] = eri[:,:,:noa,nva:] = eri[:,:,noa:,:nva] = 0 g = eri - eri.transpose(0,3,2,1) eov = eo.reshape(-1,1) - ev.reshape(-1) de = 1/(eov.reshape(-1,1) + eov.reshape(-1)).reshape(g.shape) emp2 = .25 * numpy.einsum('iajb,iajb,iajb->', g, g, de) return emp2
def test_incore_eri_s4(self): numpy.random.seed(1) norb = 4 # A 4-index eri with 4-fold symmetry h2_s1 = numpy.random.random((norb, norb, norb, norb)) h2_s1 = h2_s1 + h2_s1.transpose(1, 0, 2, 3) h2_s1 = h2_s1 + h2_s1.transpose(0, 1, 3, 2) # pack the eri to 2-index h2_s4 = ao2mo.restore(4, h2_s1, norb) mos = numpy.random.random((4, norb, norb - 1)) eri_mo_from_s4 = ao2mo.general(h2_s4, mos) eri_ref = trans(h2_s4, mos).reshape(eri_mo_from_s4.shape) self.assertAlmostEqual(abs(eri_mo_from_s4 - eri_ref).max(), 0, 12)
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 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 internal stablity analysis')
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None): log = logger.new_logger(mp, verbose) time0 = (time.clock(), time.time()) eris = _ChemistsERIs(mp, mo_coeff) mo_coeff = eris.mo_coeff nocc = mp.nocc nmo = mp.nmo nvir = nmo - nocc mem_incore, mem_outcore, mem_basic = _mem_usage(nocc, nvir) mem_now = lib.current_memory()[0] max_memory = max(0, mp.max_memory - mem_now) if max_memory < mem_basic: log.warn('Not enough memory for integral transformation. ' 'Available mem %s MB, required mem %s MB', max_memory, mem_basic) co = numpy.asarray(mo_coeff[:,:nocc], order='F') cv = numpy.asarray(mo_coeff[:,nocc:], order='F') if (mp.mol.incore_anyway or (mp._scf._eri is not None and mem_incore < max_memory)): log.debug('transform (ia|jb) incore') if callable(ao2mofn): eris.ovov = ao2mofn((co,cv,co,cv)).reshape(nocc*nvir,nocc*nvir) else: eris.ovov = ao2mo.general(mp._scf._eri, (co,cv,co,cv)) elif getattr(mp._scf, 'with_df', None): # To handle the PBC or custom 2-electron with 3-index tensor. # Call dfmp2.MP2 for efficient DF-MP2 implementation. log.warn('DF-HF is found. (ia|jb) is computed based on the DF ' '3-tensor integrals.\n' 'You can switch to dfmp2.MP2 for better performance') log.debug('transform (ia|jb) with_df') eris.ovov = mp._scf.with_df.ao2mo((co,cv,co,cv)) else: log.debug('transform (ia|jb) outcore') eris.feri = lib.H5TmpFile() #ao2mo.outcore.general(mp.mol, (co,cv,co,cv), eris.feri, # max_memory=max_memory, verbose=log) #eris.ovov = eris.feri['eri_mo'] eris.ovov = _ao2mo_ovov(mp, co, cv, eris.feri, max(2000, max_memory), log) time1 = log.timer('Integral transformation', *time0) return eris
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 myump2(mol, mo_energy, mo_coeff, mo_occ): o = numpy.hstack( (mo_coeff[0][:, mo_occ[0] > 0], mo_coeff[1][:, mo_occ[1] > 0])) v = numpy.hstack( (mo_coeff[0][:, mo_occ[0] == 0], mo_coeff[1][:, mo_occ[1] == 0])) eo = numpy.hstack( (mo_energy[0][mo_occ[0] > 0], mo_energy[1][mo_occ[1] > 0])) ev = numpy.hstack( (mo_energy[0][mo_occ[0] == 0], mo_energy[1][mo_occ[1] == 0])) no = o.shape[1] nv = v.shape[1] noa = sum(mo_occ[0] > 0) nva = sum(mo_occ[0] == 0) eri = ao2mo.general(mol, (o, v, o, v)).reshape(no, nv, no, nv) eri[:noa, nva:] = eri[noa:, :nva] = eri[:, :, :noa, nva:] = eri[:, :, noa:, :nva] = 0 g = eri - eri.transpose(0, 3, 2, 1) eov = eo.reshape(-1, 1) - ev.reshape(-1) de = 1 / (eov.reshape(-1, 1) + eov.reshape(-1)).reshape(g.shape) emp2 = .25 * numpy.einsum('iajb,iajb,iajb->', g, g, de) return emp2
def myump2(mf): # As UHF objects, mo_energy, mo_occ, mo_coeff are two-item lists # (the first item for alpha spin, the second for beta spin). mo_energy = mf.mo_energy mo_occ = mf.mo_occ mo_coeff = mf.mo_coeff o = np.hstack((mo_coeff[0][:,mo_occ[0]>0] ,mo_coeff[1][:,mo_occ[1]>0])) v = np.hstack((mo_coeff[0][:,mo_occ[0]==0],mo_coeff[1][:,mo_occ[1]==0])) eo = np.hstack((mo_energy[0][mo_occ[0]>0] ,mo_energy[1][mo_occ[1]>0])) ev = np.hstack((mo_energy[0][mo_occ[0]==0],mo_energy[1][mo_occ[1]==0])) no = o.shape[1] nv = v.shape[1] noa = sum(mo_occ[0]>0) nva = sum(mo_occ[0]==0) eri = ao2mo.general(mf.mol, (o,v,o,v)).reshape(no,nv,no,nv) eri[:noa,nva:] = eri[noa:,:nva] = eri[:,:,:noa,nva:] = eri[:,:,noa:,:nva] = 0 g = eri - eri.transpose(0,3,2,1) eov = eo.reshape(-1,1) - ev.reshape(-1) de = 1/(eov.reshape(-1,1) + eov.reshape(-1)).reshape(g.shape) emp2 = .25 * np.einsum('iajb,iajb,iajb->', g, g, de) return emp2
def kernel(self): no = self.mol.nelectron // 2 nv = len(self.mf.mo_energy) - no #cprint(no) #cprint(nv) co = self.mf.mo_coeff[:, :no] cv = self.mf.mo_coeff[:, no:] ''' g = core4hf_(self.mf, 0, (-1,-1)) g = ao2mo_4(g, cv, co, cv, co) # abij ''' #from pyscf import ao2mo g = ao2mo.general(self.mol, (cv, co, cv, co)).reshape(nv, no, nv, no).transpose(0,2,1,3) e = self.mf.mo_energy ie = np.empty((nv, nv, no, no)) for a in xrange(nv): for b in xrange(nv): for i in xrange(no): for j in xrange(no): ie[a, b, i, j] = 1.0 / (e[i] + e[j] - e[a + no] - e[b + no]) #ie = ie.reshape(nv * nv, -1) # abij return np.dot((g.conj() * ie).reshape(-1), (2 * g - g.transpose(0,1,3,2)).reshape(-1))
def ao2mo(self, coeff): """ Phys ERI in MO basis. Args: coeff (Iterable): MO orbitals; Returns: ERI in MO basis. """ coeff = (coeff[0], coeff[2], coeff[1], coeff[3]) if "with_df" in dir(self.model): if "kpt" in dir(self.model): result = self.model.with_df.ao2mo(coeff, (self.model.kpt, ) * 4, compact=False) else: result = self.model.with_df.ao2mo(coeff, compact=False) else: result = ao2mo.general(self.model.mol, coeff, compact=False) return result.reshape(tuple(i.shape[1] for i in coeff)).swapaxes(1, 2)
def general(mydf, mo_coeffs, kpts=None, compact=True): if isinstance(mo_coeffs, numpy.ndarray) and mo_coeffs.ndim == 2: mo_coeffs = (mo_coeffs, ) * 4 eri = mydf.get_eri(kpts) #################### # gamma point, the integral is real and with s4 symmetry if eri.dtype == numpy.float64: return ao2mo.general(eri, mo_coeffs, compact=compact) else: mokl, klslice = ao2mo.incore._conc_mos(mo_coeffs[2], mo_coeffs[3], False)[2:] if mokl.dtype == numpy.float64: mokl = mokl + 0j nao = mo_coeffs[0].shape[0] nmoi = mo_coeffs[0].shape[1] nmoj = mo_coeffs[1].shape[1] nmok = mo_coeffs[2].shape[1] nmol = mo_coeffs[3].shape[1] moi = numpy.asarray(mo_coeffs[0], order='F') moj = numpy.asarray(mo_coeffs[1], order='F') tao = [0] ao_loc = None pqkl = _ao2mo.r_e2(eri.reshape(-1, nao**2), mokl, klslice, tao, ao_loc, aosym='s1') pqkl = pqkl.reshape(nao, nao, nmok * nmol) pjkl = numpy.empty((nao, nmoj, nmok * nmol), dtype=numpy.complex128) for i in range(nao): lib.dot(moj.T, pqkl[i], 1, pjkl[i], 0) pqkl = None eri_mo = lib.dot(moi.T.conj(), pjkl.reshape(nao, -1)) return eri_mo.reshape(nmoi * nmoj, -1)
def transform_integrals_incore(myadc): occ = myadc.mo_coeff[:, :myadc._nocc] vir = myadc.mo_coeff[:, myadc._nocc:] nocc = occ.shape[1] nvir = vir.shape[1] eris = lambda: None # TODO: check if myadc._scf._eri is not None eris.oooo = ao2mo.general(myadc._scf._eri, (occ, occ, occ, occ), compact=False).reshape(nocc, nocc, nocc, nocc).copy() eris.ovoo = ao2mo.general(myadc._scf._eri, (occ, vir, occ, occ), compact=False).reshape(nocc, nvir, nocc, nocc).copy() eris.ovov = ao2mo.general(myadc._scf._eri, (occ, vir, occ, vir), compact=False).reshape(nocc, nvir, nocc, nvir).copy() eris.oovv = ao2mo.general(myadc._scf._eri, (occ, occ, vir, vir), compact=False).reshape(nocc, nocc, nvir, nvir).copy() eris.ovvo = ao2mo.general(myadc._scf._eri, (occ, vir, vir, occ), compact=False).reshape(nocc, nvir, nvir, nocc).copy() eris.ovvv = ao2mo.general(myadc._scf._eri, (occ, vir, vir, vir), compact=True).reshape(nocc, nvir, -1).copy() if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"): eris.vvvv = ao2mo.general(myadc._scf._eri, (vir, vir, vir, vir), compact=False).reshape( nvir, nvir, nvir, nvir) eris.vvvv = np.ascontiguousarray(eris.vvvv.transpose(0, 2, 1, 3)) eris.vvvv = eris.vvvv.reshape(nvir * nvir, nvir * nvir) return eris
def perform_uhf_partial(self): assert self.pyscfmol is not None nocc_a, nvirt_a, nocc_b, nvirt_b = self.occupations C_occ_alph = self.C[0, :, :nocc_a] C_virt_alph = self.C[0, :, nocc_a:] C_occ_beta = self.C[1, :, :nocc_b] C_virt_beta = self.C[1, :, nocc_b:] C_ovov_aaaa = (C_occ_alph, C_virt_alph, C_occ_alph, C_virt_alph) C_ovov_aabb = (C_occ_alph, C_virt_alph, C_occ_beta, C_virt_beta) C_ovov_bbaa = (C_occ_beta, C_virt_beta, C_occ_alph, C_virt_alph) C_ovov_bbbb = (C_occ_beta, C_virt_beta, C_occ_beta, C_virt_beta) C_oovv_aaaa = (C_occ_alph, C_occ_alph, C_virt_alph, C_virt_alph) C_oovv_bbbb = (C_occ_beta, C_occ_beta, C_virt_beta, C_virt_beta) from pyscf.ao2mo import general tei_mo_ovov_aaaa = general( self.pyscfmol, C_ovov_aaaa, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_a, nvirt_a, nocc_a, nvirt_a) tei_mo_ovov_aabb = general( self.pyscfmol, C_ovov_aabb, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_a, nvirt_a, nocc_b, nvirt_b) tei_mo_ovov_bbaa = general( self.pyscfmol, C_ovov_bbaa, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_b, nvirt_b, nocc_a, nvirt_a) tei_mo_ovov_bbbb = general( self.pyscfmol, C_ovov_bbbb, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_b, nvirt_b, nocc_b, nvirt_b) tei_mo_oovv_aaaa = general( self.pyscfmol, C_oovv_aaaa, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_a, nocc_a, nvirt_a, nvirt_a) tei_mo_oovv_bbbb = general( self.pyscfmol, C_oovv_bbbb, aosym="s4", compact=False, verbose=self.verbose ).reshape(nocc_b, nocc_b, nvirt_b, nvirt_b) self.tei_mo = ( tei_mo_ovov_aaaa, tei_mo_ovov_aabb, tei_mo_ovov_bbaa, tei_mo_ovov_bbbb, tei_mo_oovv_aaaa, tei_mo_oovv_bbbb, )
def _make_eris(mp, mo_coeff=None, ao2mofn=None, verbose=None): log = logger.new_logger(mp, verbose) time0 = (time.clock(), time.time()) eris = _ChemistsERIs(mp, mo_coeff) nocca, noccb = mp.get_nocc() nmoa, nmob = mp.get_nmo() nvira, nvirb = nmoa - nocca, nmob - noccb nao = eris.mo_coeff[0].shape[0] nmo_pair = nmoa * (nmoa + 1) // 2 nao_pair = nao * (nao + 1) // 2 mem_incore = (nao_pair**2 + nmo_pair**2) * 8 / 1e6 mem_now = lib.current_memory()[0] max_memory = max(0, mp.max_memory - mem_now) moa = eris.mo_coeff[0] mob = eris.mo_coeff[1] orboa = moa[:, :nocca] orbob = mob[:, :noccb] orbva = moa[:, nocca:] orbvb = mob[:, noccb:] if (mp.mol.incore_anyway or (mp._scf._eri is not None and mem_incore + mem_now < mp.max_memory)): log.debug('transform (ia|jb) incore') if callable(ao2mofn): eris.ovov = ao2mofn( (orboa, orbva, orboa, orbva)).reshape(nocca * nvira, nocca * nvira) eris.ovOV = ao2mofn( (orboa, orbva, orbob, orbvb)).reshape(nocca * nvira, noccb * nvirb) eris.OVOV = ao2mofn( (orbob, orbvb, orbob, orbvb)).reshape(noccb * nvirb, noccb * nvirb) else: eris.ovov = ao2mo.general(mp._scf._eri, (orboa, orbva, orboa, orbva)) eris.ovOV = ao2mo.general(mp._scf._eri, (orboa, orbva, orbob, orbvb)) eris.OVOV = ao2mo.general(mp._scf._eri, (orbob, orbvb, orbob, orbvb)) elif getattr(mp._scf, 'with_df', None): logger.warn( mp, 'UMP2 detected DF being used in the HF object. ' 'MO integrals are computed based on the DF 3-index tensors.\n' 'It\'s recommended to use DF-UMP2 module.') log.debug('transform (ia|jb) with_df') eris.ovov = mp._scf.with_df.ao2mo((orboa, orbva, orboa, orbva)) eris.ovOV = mp._scf.with_df.ao2mo((orboa, orbva, orbob, orbvb)) eris.OVOV = mp._scf.with_df.ao2mo((orbob, orbvb, orbob, orbvb)) else: log.debug('transform (ia|jb) outcore') eris.feri = lib.H5TmpFile() _ao2mo_ovov(mp, (orboa, orbva, orbob, orbvb), eris.feri, max(2000, max_memory), log) eris.ovov = eris.feri['ovov'] eris.ovOV = eris.feri['ovOV'] eris.OVOV = eris.feri['OVOV'] time1 = log.timer('Integral transformation', *time0) return eris
def write_chk(mc,root,chkfile): t0 = (time.clock(), time.time()) fh5 = h5py.File(chkfile,'w') if mc.fcisolver.nroots > 1: mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root) fh5['mol'] = mc.mol.dumps() fh5['mc/mo'] = mc.mo_coeff fh5['mc/ncore'] = mc.ncore fh5['mc/ncas'] = mc.ncas nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore fh5['mc/nvirt'] = nvirt fh5['mc/nelecas'] = mc.nelecas fh5['mc/root'] = root fh5['mc/orbe'] = mc.mo_energy fh5['mc/nroots'] = mc.fcisolver.nroots fh5['mc/wfnsym'] = mc.fcisolver.wfnsym if getattr(mc.mo_coeff, 'orbsym', None) is not None: fh5.create_dataset('mc/orbsym',data=mc.mo_coeff.orbsym) if getattr(mc.mo_coeff, 'orbsym', None) is not None and mc.mol.symmetry: orbsym = numpy.asarray(mc.mo_coeff.orbsym) pair_irrep = orbsym.reshape(-1,1) ^ orbsym else: pair_irrep = None ncore = mc.ncore nocc = mc.ncore + mc.ncas mo_core = mc.mo_coeff[:,:mc.ncore] mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas] mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:] core_dm = numpy.dot(mo_core,mo_core.T) *2 core_vhf = mc.get_veff(mc.mol,core_dm) h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas)) h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core)) h1e, e_core = mc.h1e_for_cas() if pair_irrep is not None: h1e_Sr[pair_irrep[nocc:,ncore:nocc] != 0] = 0 h1e_Si[pair_irrep[ncore:nocc,:ncore] != 0] = 0 h1e[pair_irrep[ncore:nocc,ncore:nocc] != 0] = 0 fh5['h1e_Si'] = h1e_Si fh5['h1e_Sr'] = h1e_Sr fh5['h1e'] = h1e fh5['e_core'] = e_core if mc._scf._eri is None: h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) if pair_irrep is not None: sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) != pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape) h2e_t[sym_forbid] = 0 h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si else: eri = mc._scf._eri h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) if pair_irrep is not None: sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) != pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape) h2e_t[sym_forbid] = 0 h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si fh5.close() logger.timer(mc,'Write MPS NEVPT integral', *t0)
grad = numpy.array(feri['eri_mo']).reshape(-1,nocc,nvir,nocc,nvir) print('shape of gradient integrals %s' % str(grad.shape)) import tempfile import numpy import h5py from pyscf import ao2mo nocc = mol.nelectron // 2 nvir = len(mf.mo_energy) - nocc co = mf.mo_coeff[:,:nocc] cv = mf.mo_coeff[:,nocc:] hess1tmp = tempfile.NamedTemporaryFile() ao2mo.kernel(mol, (co,cv,co,cv), hess1tmp.name, intor='cint2e_ipvip1_sph', dataname='hessints1', aosym='s4', comp=9, verbose=0) with ao2mo.load(hess1tmp, 'hessints1') as eri: hess1 = numpy.array(eri).reshape(-1,nocc,nvir,nocc,nvir) hess2tmp = tempfile.NamedTemporaryFile() ao2mo.general(mol, (co,cv,co,cv), hess2tmp.name, intor='cint2e_ipip1_sph', dataname='hessints2', aosym='s2kl', comp=9, verbose=0) feri = h5py.File(hess2tmp.name, 'r') hess2 = numpy.array(feri['hessints2']).reshape(-1,nocc,nvir,nocc,nvir) hess3tmp = tempfile.NamedTemporaryFile() with ao2mo.load(ao2mo.general(mol, (co,cv,co,cv), hess3tmp.name, intor='cint2e_ip1ip2_sph', aosym='s1', comp=9, verbose=0)) as eri: hess3 = numpy.array(eri).reshape(-1,nocc,nvir,nocc,nvir) print('shape of hessian integrals: hess1 %s, hess2 %s, hess3 %s' % (str(hess1.shape), str(hess2.shape), str(hess3.shape)))
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 _make_eris_outcore(myci, mo_coeff=None): cput0 = (time.clock(), time.time()) log = logger.Logger(myci.stdout, myci.verbose) eris = _UCISD_ERIs(myci, mo_coeff) nocca = eris.nocca noccb = eris.noccb nmoa = eris.focka.shape[0] nmob = eris.fockb.shape[0] nvira = nmoa - nocca nvirb = nmob - noccb moa, mob = eris.mo_coeff mol = myci.mol eris.feri = lib.H5TmpFile() dtype = 'f8' eris.oooo = eris.feri.create_dataset('oooo', (nocca, nocca, nocca, nocca), dtype) eris.vooo = eris.feri.create_dataset('vooo', (nvira, nocca, nocca, nocca), dtype) eris.voov = eris.feri.create_dataset('voov', (nvira, nocca, nocca, nvira), dtype) eris.vvoo = eris.feri.create_dataset('vvoo', (nvira, nvira, nocca, nocca), dtype) eris.vovv = eris.feri.create_dataset('vovv', (nvira, nocca, nvira * (nvira + 1) // 2), dtype) #eris.vvvv = eris.feri.create_dataset('vvvv', (nvira,nvira,nvira,nvira), dtype) eris.OOOO = eris.feri.create_dataset('OOOO', (noccb, noccb, noccb, noccb), dtype) eris.VOOO = eris.feri.create_dataset('VOOO', (nvirb, noccb, noccb, noccb), dtype) eris.VOOV = eris.feri.create_dataset('VOOV', (nvirb, noccb, noccb, nvirb), dtype) eris.VVOO = eris.feri.create_dataset('VVOO', (nvirb, nvirb, noccb, noccb), dtype) eris.VOVV = eris.feri.create_dataset('VOVV', (nvirb, noccb, nvirb * (nvirb + 1) // 2), dtype) #eris.VVVV = eris.feri.create_dataset('VVVV', (nvirb,nvirb,nvirb,nvirb), dtype) eris.ooOO = eris.feri.create_dataset('ooOO', (nocca, nocca, noccb, noccb), dtype) eris.voOO = eris.feri.create_dataset('voOO', (nvira, nocca, noccb, noccb), dtype) eris.voOV = eris.feri.create_dataset('voOV', (nvira, nocca, noccb, nvirb), dtype) eris.vvOO = eris.feri.create_dataset('vvOO', (nvira, nvira, noccb, noccb), dtype) eris.voVV = eris.feri.create_dataset('voVV', (nvira, nocca, nvirb * (nvirb + 1) // 2), dtype) #eris.vvVV = eris.feri.create_dataset('vvVV', (nvira,nvira,nvirb,nvirb), dtype) eris.VOoo = eris.feri.create_dataset('VOoo', (nvirb, noccb, nocca, nocca), dtype) eris.VVoo = eris.feri.create_dataset('VVoo', (nvirb, nvirb, nocca, nocca), dtype) eris.VOvv = eris.feri.create_dataset('VOvv', (nvirb, noccb, nvira * (nvira + 1) // 2), dtype) cput1 = time.clock(), time.time() # <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp) tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) ao2mo.general(mol, (moa, moa[:, :nocca], moa, moa), tmpfile2.name, 'aa') with h5py.File(tmpfile2.name) as f: buf = lib.unpack_tril(f['aa'][:nocca * nocca]) buf = buf.reshape(nocca, nocca, nmoa, nmoa) eris.oooo[:] = buf[:, :, :nocca, :nocca] oovv = buf[:, :, nocca:, nocca:].reshape(nocca**2, nvira**2) eris.vvoo[:] = lib.transpose(oovv).reshape(nvira, nvira, nocca, nocca) buf = oovv = None for i0, i1 in lib.prange(0, nvira, nocca): buf = lib.unpack_tril(f['aa'][(nocca + i0) * nocca:(nocca + i1) * nocca]) eris.vovv[i0:i1] = lib.pack_tril(buf[:, nocca:, nocca:]).reshape( i1 - i0, nocca, -1) buf = buf.reshape(i1 - i0, nocca, nmoa, nmoa) eris.vooo[i0:i1] = buf[:, :nocca, :nocca, :nocca] eris.voov[i0:i1] = buf[:, :nocca, :nocca, nocca:] buf = None del (f['aa']) if noccb > 0: ao2mo.general(mol, (mob, mob[:, :noccb], mob, mob), tmpfile2.name, 'bb') with h5py.File(tmpfile2.name) as f: buf = lib.unpack_tril(f['bb'][:noccb * noccb]) buf = buf.reshape(noccb, noccb, nmob, nmob) eris.OOOO[:] = buf[:, :, :noccb, :noccb] oovv = buf[:, :, noccb:, noccb:].reshape(noccb**2, nvirb**2) eris.VVOO[:] = lib.transpose(oovv).reshape(nvirb, nvirb, noccb, noccb) buf = oovv = None for i0, i1 in lib.prange(0, nvirb, noccb): buf = lib.unpack_tril(f['bb'][(noccb + i0) * noccb:(noccb + i1) * noccb]) eris.VOVV[i0:i1] = lib.pack_tril(buf[:, noccb:, noccb:]).reshape( i1 - i0, noccb, -1) buf = buf.reshape(i1 - i0, noccb, nmob, nmob) eris.VOOO[i0:i1] = buf[:, :noccb, :noccb, :noccb] eris.VOOV[i0:i1] = buf[:, :noccb, :noccb, noccb:] buf = None del (f['bb']) ao2mo.general(mol, (moa, moa[:, :nocca], mob, mob), tmpfile2.name, 'ab') with h5py.File(tmpfile2.name) as f: buf = lib.unpack_tril(f['ab'][:nocca * nocca]) buf = buf.reshape(nocca, nocca, nmob, nmob) eris.ooOO[:] = buf[:, :, :noccb, :noccb] oovv = buf[:, :, noccb:, noccb:].reshape(nocca**2, nvirb**2) eris.VVoo[:] = lib.transpose(oovv).reshape(nvirb, nvirb, nocca, nocca) buf = oovv = None for i0, i1 in lib.prange(0, nvira, nocca): buf = lib.unpack_tril(f['ab'][(nocca + i0) * nocca:(nocca + i1) * nocca]) eris.voVV[i0:i1] = lib.pack_tril(buf[:, noccb:, noccb:]).reshape( i1 - i0, nocca, -1) buf = buf.reshape(i1 - i0, nocca, nmob, nmob) eris.voOO[i0:i1] = buf[:, :nocca, :noccb, :noccb] eris.voOV[i0:i1] = buf[:, :nocca, :noccb, noccb:] buf = None del (f['ab']) if noccb > 0: ao2mo.general(mol, (mob, mob[:, :noccb], moa, moa), tmpfile2.name, 'ba') with h5py.File(tmpfile2.name) as f: buf = lib.unpack_tril(f['ba'][:noccb * noccb]) buf = buf.reshape(noccb, noccb, nmoa, nmoa) oovv = buf[:, :, nocca:, nocca:].reshape(noccb**2, nvira**2) eris.vvOO[:] = lib.transpose(oovv).reshape(nvira, nvira, noccb, noccb) buf = oovv = None for i0, i1 in lib.prange(0, nvirb, noccb): buf = lib.unpack_tril(f['ba'][(noccb + i0) * noccb:(noccb + i1) * noccb]) eris.VOvv[i0:i1] = lib.pack_tril(buf[:, nocca:, nocca:]).reshape( i1 - i0, noccb, -1) buf = buf.reshape(i1 - i0, noccb, nmoa, nmoa) eris.VOoo[i0:i1] = buf[:, :noccb, :nocca, :nocca] buf = None del (f['ba']) cput1 = log.timer_debug1('transforming vopq', *cput1) orbva = moa[:, nocca:] orbvb = mob[:, noccb:] 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 = log.timer_debug1('transforming vvvv', *cput1) log.timer('CISD integral transformation', *cput0) return eris
def fn(x, mo0, mo1, mo2, mo3): return ao2mo.general(x, (mo0, mo1, mo2, mo3), compact=False).reshape(mo0.shape[-1], mo1.shape[-1], mo2.shape[-1], mo3.shape[-1])
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')
ehf = mf.kernel() ncore = 0 nao, nmo = mf.mo_coeff.shape nocc = mol.nelectron // 2 - ncore nvir = nmo - nocc - ncore nov = nocc * nvir mo_core = mf.mo_coeff[:, :ncore] mo_occ = mf.mo_coeff[:, ncore:ncore + nocc] mo_vir = mf.mo_coeff[:, ncore + nocc:] co = mo_occ cv = mo_vir eo = mf.mo_energy[ncore:ncore + nocc] ev = mf.mo_energy[ncore + nocc:] v_ijab = ao2mo.general(mf._eri, (co, co, cv, cv), compact=False) v_ijab = v_ijab.reshape(nocc, nocc, nvir, nvir) v_iajb = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False) v_iajb = v_iajb.reshape(nocc, nvir, nocc, nvir) def diagonalize(a, b, nroots=3): e, c = numpy.linalg.eig(\ numpy.bmat([[ a, b], [-b,-a]])) c = numpy.array(c) idx = numpy.where(e > 0) idx = numpy.asarray(idx[0]) e = e[idx] c = c[:, idx] idx = numpy.argsort(e)
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 _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
mf.conv_tol = 1e-8 e = mf.kernel() print('E = %.15g, ref -230.776765415' % e) # # Given four MOs, compute the MO-integrals and saved in dataset "mp2_bz" # eritmp = tempfile.NamedTemporaryFile() nocc = mol.nelectron // 2 nvir = len(mf.mo_energy) - nocc co = mf.mo_coeff[:,:nocc] cv = mf.mo_coeff[:,nocc:] orbs = (co, cv, co, cv) # Depending on your hardware and BLAS library, it needs about 1 min on I5 3GHz # CPU with MKL library to transform the integrals ao2mo.general(mol, orbs, eritmp.name, dataname='mp2_bz')#, verbose=5) eia = mf.mo_energy[:nocc,None] - mf.mo_energy[None,nocc:] f = h5py.File(eritmp.name, 'r') eri = f['mp2_bz'] print('Note the shape of the transformed integrals (ij|kl) is %s.' % str(eri.shape)) print("It's a 2D array: the first index for compressed ij, the second index for compressed kl") emp2 = 0 for i in range(nocc): dajb = eia[i].reshape(-1,1) + eia.reshape(1,-1) gi = numpy.array(eri[i*nvir:(i+1)*nvir]) t2 = gi.flatten() / dajb.flatten() gi = gi.reshape(nvir,nocc,nvir) theta = gi*2 - gi.transpose(2,1,0) emp2 += numpy.dot(t2, theta.flatten())
def dump(self, fname='mole.h5'): # Effective nbas = self.nbas - self.nfrozen sbas = nbas * 2 print '\n[iface.dump] (self.nbas,nbas)=', (self.nbas, nbas) # # Basic information # f = h5py.File(fname, "w") cal = f.create_dataset("cal", (1, ), dtype='i') enuc = self.mol.energy_nuc() nelec = self.nelec - self.nfrozen * 2 cal.attrs["nelec"] = nelec cal.attrs["sbas"] = sbas cal.attrs["enuc"] = enuc cal.attrs[ "escf"] = 0. # Not useful at all: self.mf.energy_elec(self.mf.make_rdm1())[0] # # Intergrals # flter = 'lzf' # Local or CMO if self.iflocal: self.local() mo_coeff = self.lmo_coeff.copy() else: print 'canonical or user defined mo' mo_coeff = self.mo_coeff[:, self.nfrozen:].copy() # Reorder if self.ifreorder: order = list(self.reorder(mo_coeff)) else: order = range(mo_coeff.shape[1]) mo_coeff = mo_coeff[:, numpy.array(order)].copy() self.molden(mo_coeff, fname='mocoeff') # Dump MO coefficients f.create_dataset("mo_coeff_spatial", data=mo_coeff) # Occupation occun = numpy.zeros(sbas) for i in range(self.nalpha - self.nfrozen): occun[2 * i] = 1.0 for i in range(self.nbeta - self.nfrozen): occun[2 * i + 1] = 1.0 print print 'initial occun for', len(occun), ' spin orbitals:\n', occun sorder = numpy.array([[2 * i, 2 * i + 1] for i in order]).flatten() occun = occun[sorder].copy() assert abs(numpy.sum(occun) - nelec) < 1.e-10 print "sorder:", sorder print "occun :", occun # Symmetry if self.mol.symmetry and not self.iflocal: import pyscf.symm irrep_name = self.mol.irrep_id orbsym0 = pyscf.symm.label_orb_symm(self.mol, irrep_name, self.mol.symm_orb, mo_coeff) print '\nSpatial orbsym:\n', orbsym0 orbsym = numpy.array([[i, i] for i in orbsym0]).flatten() else: orbsym = numpy.array([0] * sbas) spinsym = numpy.array([[0, 1] for i in range(nbas)]).flatten() print "orbsym :", orbsym print "spinsym:", spinsym f.create_dataset("occun", data=occun) f.create_dataset("orbsym", data=orbsym) f.create_dataset("spinsym", data=spinsym) #==================================================================== # Spin orbital integrals #==================================================================== # Integral transformation # SPECIAL FORM of MO for TRANS gmo_coeff = numpy.hstack((self.mo_coeff[:, :self.nfrozen], mo_coeff)) print 'gmo_coeff.shape=', gmo_coeff.shape f.create_dataset("mo_coeff_spatialAll", data=gmo_coeff) kbas = gmo_coeff.shape[0] abas = gmo_coeff.shape[1] * 2 b = numpy.zeros((kbas, abas)) b[:, ::2] = gmo_coeff.copy() b[:, 1::2] = gmo_coeff.copy() # INT1e: h = self.mf.get_hcore() hmo = reduce(numpy.dot, (b.T, h, b)) hmo[::2, 1::2] = hmo[1::2, ::2] = 0. # INT2e: from pyscf import ao2mo nb = abas eri = ao2mo.general(self.mol, (b, b, b, b), compact=0).reshape(nb, nb, nb, nb) #eri = ao2mo.incore.general(self.mf._eri,(b,b,b,b),compact=0).reshape(nb,nb,nb,nb) eri[::2, 1::2] = eri[1::2, ::2] = eri[:, :, ::2, 1::2] = eri[:, :, 1::2, ::2] = 0. # <ij|kl>=[ik|jl] eri = eri.transpose(0, 2, 1, 3) # Antisymmetrize V[pqrs]=-1/2*<pq||rs> - In MPO construnction, only r<s part is used. eri = -0.5 * (eri - eri.transpose(0, 1, 3, 2)) #------------------ Frozen Core ------------------ # fpq = hpq + <pr||qr>nr sfrozen = 2 * self.nfrozen nr = numpy.zeros(abas) nr[:sfrozen] = 1.0 # Ecore = hcc + 1/2*<pq||pq>npnq ecore = numpy.einsum('pp,p',hmo,nr)\ - numpy.einsum('pqpq,p,q',eri,nr,nr) print 'E[core]=', ecore cal.attrs["ecor"] = ecore fpq = hmo - 2.0 * numpy.einsum('prqr,r->pq', eri, nr) orbrg = range(sfrozen, abas) hmo = fpq[numpy.ix_(orbrg, orbrg)].copy() eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy() #------------------ Frozen Core ------------------ # DUMP modified Integrals e1 = cal.attrs["escf"] ioccun = map(lambda x: x[0], numpy.argwhere(occun > 1.e-4)) #print 'ioccun=',ioccun e2 = numpy.einsum('ii',hmo[numpy.ix_(ioccun,ioccun)])\ - numpy.einsum('ijij',eri[numpy.ix_(ioccun,ioccun,ioccun,ioccun)]) ediff = abs(e1 - e2 - ecore) print 'E[pyscf]=', e1 print 'E[elec] =', e2, ' E[elec]+E[core]=', e2 + ecore print 'E[diff] =', ediff #===================================== # Complex case with SOC [ZL@20161014] #===================================== # Construct hSO hSO = numpy.zeros((sbas, sbas), dtype=numpy.complex_) # alpha,beta-ordering for iatom in range(self.mol.natm): zA = self.mol.atom_charge(iatom) xyz = self.mol.atom_coord(iatom) self.mol.set_rinv_orig(xyz) soxyz = zA * self.mol.intor('cint1e_prinvxp_sph', 3) # transform to MO for ic in range(3): soxyz[ic] = reduce(numpy.dot, (gmo_coeff.T.conj(), soxyz[ic], gmo_coeff)) # [ hZ hX-i*hY ] # i*sigma*lA/r3 = i*[ ] # [ hX+i*hY -hZ] hSO[0::2, 0::2] += soxyz[2] hSO[1::2, 1::2] += -soxyz[2] hSO[0::2, 1::2] += soxyz[0] - 1.j * soxyz[1] hSO[1::2, 0::2] += soxyz[0] + 1.j * soxyz[1] if iatom == 0: print '\nCheck antisymmetricity:' print 'iatom=',iatom,\ numpy.linalg.norm(soxyz[0]+soxyz[0].T),\ numpy.linalg.norm(soxyz[1]+soxyz[1].T),\ numpy.linalg.norm(soxyz[2]+soxyz[2].T) # Check Hermiticity hSO = 1.j * hSO diff = numpy.linalg.norm(hSO - hSO.T.conj()) print 'Hermicity of Hso=', diff assert diff < 1.e-10 fsc = 0.25 * (1.0 / self.mol.light_speed)**2 h1e = numpy.zeros(hmo.shape, dtype=numpy.complex_) h1e = hmo + fsc * hSO h2e = numpy.zeros(eri.shape, dtype=numpy.complex_) h2e = eri + 0.j int1e = f.create_dataset("int1e", data=h1e, compression=flter) int2e = f.create_dataset("int2e", data=h2e, compression=flter) #===================================== #==================================================================== # Spatial integrals #==================================================================== b = gmo_coeff # INT1e: h = self.mf.get_hcore() hmo = reduce(numpy.dot, (b.T, h, b)) # INT2e: from pyscf import ao2mo nb = abas / 2 eri = ao2mo.general(self.mol, (b, b, b, b), compact=0).reshape(nb, nb, nb, nb) # Frozen core case: # fpq = hpq + [pq|rr]*nr - 0.5*[pr|rq]*nr nr = numpy.zeros(nb) nr[:self.nfrozen] = 2.0 Fpq = hmo + numpy.einsum('pqrr,r->pq',eri,nr)\ - 0.5*numpy.einsum('prrq,r->pq',eri,nr) #print numpy.linalg.norm(fpq[::2,::2] - Fpq) #print numpy.linalg.norm(fpq[1::2,1::2] - Fpq) #print numpy.linalg.norm(fpq[::2,1::2]) #print numpy.linalg.norm(fpq[1::2,::2]) orbrg = range(self.nfrozen, self.nbas) hmo = Fpq[numpy.ix_(orbrg, orbrg)].copy() eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy() f.create_dataset("int1e_spatial", data=hmo, compression=flter) f.create_dataset("int2e_spatial", data=eri, compression=flter) #==================================================================== f.close() print 'Successfully dump information for HS-DMRG calculations! fname=', fname self.check(fname) return 0
def _make_eris_incore(myci, mo_coeff=None): cput0 = (time.clock(), time.time()) eris = _UCISD_ERIs(myci, mo_coeff) nocca = eris.nocca noccb = eris.noccb nmoa = eris.focka.shape[0] nmob = eris.fockb.shape[0] nvira = nmoa - nocca nvirb = nmob - noccb moa, mob = eris.mo_coeff eri_aa = ao2mo.restore(1, ao2mo.full(myci._scf._eri, moa), nmoa) eris.oooo = eri_aa[:nocca, :nocca, :nocca, :nocca].copy() eris.ooov = eri_aa[:nocca, :nocca, :nocca, nocca:].copy() eris.vooo = eri_aa[nocca:, :nocca, :nocca, :nocca].copy() eris.oovo = eri_aa[:nocca, :nocca, nocca:, :nocca].copy() eris.voov = eri_aa[nocca:, :nocca, :nocca, nocca:].copy() eris.vvoo = eri_aa[nocca:, nocca:, :nocca, :nocca].copy() eris.oovv = eri_aa[:nocca, :nocca, nocca:, nocca:].copy() eris.vovo = eri_aa[nocca:, :nocca, nocca:, :nocca].copy() eris.vovv = eri_aa[nocca:, :nocca, nocca:, nocca:].copy() #vovv = eri_aa[nocca:,:nocca,nocca:,nocca:].reshape(-1,nvira,nvira) #eris.vovv = lib.pack_tril(vovv).reshape(nvira,nocca,nvira*(nvira+1)//2) eris.vvvv = ao2mo.restore(4, eri_aa[nocca:, nocca:, nocca:, nocca:].copy(), nvira) vovv = eri_aa = None eri_bb = ao2mo.restore(1, ao2mo.full(myci._scf._eri, mob), nmob) eris.OOOO = eri_bb[:noccb, :noccb, :noccb, :noccb].copy() eris.OOOV = eri_bb[:noccb, :noccb, :noccb, noccb:].copy() eris.VOOO = eri_bb[noccb:, :noccb, :noccb, :noccb].copy() eris.OOVO = eri_bb[:noccb, :noccb, noccb:, :noccb].copy() eris.VOOV = eri_bb[noccb:, :noccb, :noccb, noccb:].copy() eris.VVOO = eri_bb[noccb:, noccb:, :noccb, :noccb].copy() eris.OOVV = eri_bb[:noccb, :noccb, noccb:, noccb:].copy() eris.VOVO = eri_bb[noccb:, :noccb, noccb:, :noccb].copy() eris.VOVV = eri_bb[noccb:, :noccb, noccb:, noccb:].copy() #VOVV = eri_bb[noccb:,:noccb,noccb:,noccb:].reshape(-1,nvirb,nvirb) #eris.VOVV = lib.pack_tril(VOVV).reshape(nvirb,noccb,nvirb*(nvirb+1)//2) eris.VVVV = ao2mo.restore(4, eri_bb[noccb:, noccb:, noccb:, noccb:].copy(), nvirb) VOVV = eri_bb = None eri_ab = ao2mo.general(myci._scf._eri, (moa, moa, mob, mob), compact=False) eri_ab = eri_ab.reshape(nmoa, nmoa, nmob, nmob) eris.ooOO = eri_ab[:nocca, :nocca, :noccb, :noccb].copy() eris.ooOV = eri_ab[:nocca, :nocca, :noccb, noccb:].copy() eris.voOO = eri_ab[nocca:, :nocca, :noccb, :noccb].copy() eris.ooVO = eri_ab[:nocca, :nocca, noccb:, :noccb].copy() eris.voOV = eri_ab[nocca:, :nocca, :noccb, noccb:].copy() eris.ooVV = eri_ab[:nocca, :nocca, noccb:, noccb:].copy() eris.vvOO = eri_ab[nocca:, nocca:, :noccb, :noccb].copy() eris.voVO = eri_ab[nocca:, :nocca, noccb:, :noccb].copy() eris.voVV = eri_ab[nocca:, :nocca, noccb:, noccb:].copy() #voVV = eri_ab[nocca:,:nocca,noccb:,noccb:].reshape(nocca*nvira,nvirb,nvirb) #eris.voVV = lib.pack_tril(voVV).reshape(nvira,nocca,nvirb*(nvirb+1)//2) voVV = None vvVV = eri_ab[nocca:, nocca:, noccb:, noccb:].reshape(nvira**2, nvirb**2) idxa = numpy.tril_indices(nvira) idxb = numpy.tril_indices(nvirb) eris.vvVV = lib.take_2d(vvVV, idxa[0] * nvira + idxa[1], idxb[0] * nvirb + idxb[1]) eri_ba = lib.transpose(eri_ab.reshape(nmoa**2, nmob**2)) eri_ba = eri_ba.reshape(nmob, nmob, nmoa, nmoa) eris.OOoo = eri_ba[:noccb, :noccb, :nocca, :nocca].copy() eris.OOov = eri_ba[:noccb, :noccb, :nocca, nocca:].copy() eris.VOoo = eri_ba[noccb:, :noccb, :nocca, :nocca].copy() eris.OOvo = eri_ba[:noccb, :noccb, nocca:, :nocca].copy() eris.VOov = eri_ba[noccb:, :noccb, :nocca, nocca:].copy() eris.VVoo = eri_ba[noccb:, noccb:, :nocca, :nocca].copy() eris.VOvo = eri_ba[noccb:, :noccb, nocca:, :nocca].copy() eris.VOvv = eri_ba[noccb:, :noccb, nocca:, nocca:].copy() #VOvv = eri_ba[noccb:,:noccb,nocca:,nocca:].reshape(noccb*nvirb,nvira,nvira) #eris.VOvv = lib.pack_tril(VOvv).reshape(nvirb,noccb,nvira*(nvira+1)//2) VOvv = None eris.VVvv = eri_ba[noccb:, noccb:, nocca:, nocca:].copy() return eris
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
def write_chk(mc, root, chkfile): t0 = (time.clock(), time.time()) fh5 = h5py.File(chkfile, 'w') if mc.fcisolver.nroots > 1: mc.mo_coeff, _, mc.mo_energy = mc.canonicalize(mc.mo_coeff, ci=root) fh5['mol'] = mc.mol.dumps() fh5['mc/mo'] = mc.mo_coeff fh5['mc/ncore'] = mc.ncore fh5['mc/ncas'] = mc.ncas nvirt = mc.mo_coeff.shape[1] - mc.ncas - mc.ncore fh5['mc/nvirt'] = nvirt fh5['mc/nelecas'] = mc.nelecas fh5['mc/root'] = root fh5['mc/orbe'] = mc.mo_energy fh5['mc/nroots'] = mc.fcisolver.nroots fh5['mc/wfnsym'] = mc.fcisolver.wfnsym if hasattr(mc, 'orbsym'): fh5.create_dataset('mc/orbsym', data=mc.orbsym) else: fh5.create_dataset('mc/orbsym', data=[]) mo_core = mc.mo_coeff[:, :mc.ncore] mo_cas = mc.mo_coeff[:, mc.ncore:mc.ncore + mc.ncas] mo_virt = mc.mo_coeff[:, mc.ncore + mc.ncas:] core_dm = numpy.dot(mo_core, mo_core.T) * 2 core_vhf = mc.get_veff(mc.mol, core_dm) h1e_Sr = reduce(numpy.dot, (mo_virt.T, mc.get_hcore() + core_vhf, mo_cas)) h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore() + core_vhf, mo_core)) fh5['h1e_Si'] = h1e_Si fh5['h1e_Sr'] = h1e_Sr h1e, e_core = mc.h1e_for_cas() fh5['h1e'] = h1e fh5['e_core'] = e_core if mc._scf._eri is None: h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff, mo_cas, mo_cas, mo_cas), compact=False) h2e_t = h2e_t.reshape(-1, mc.ncas, mc.ncas, mc.ncas) h2e = h2e_t[mc.ncore:mc.ncore + mc.ncas, :, :, :] fh5['h2e'] = h2e h2e_Sr = h2e_t[mc.ncore + mc.ncas:, :, :, :] fh5['h2e_Sr'] = h2e_Sr h2e_Si = numpy.transpose(h2e_t[:mc.ncore, :, :, :], (1, 0, 2, 3)) fh5['h2e_Si'] = h2e_Si else: eri = mc._scf._eri h2e_t = ao2mo.general(eri, [mc.mo_coeff, mo_cas, mo_cas, mo_cas], compact=False) h2e_t = h2e_t.reshape(-1, mc.ncas, mc.ncas, mc.ncas) h2e = h2e_t[mc.ncore:mc.ncore + mc.ncas, :, :, :] fh5['h2e'] = h2e h2e_Sr = h2e_t[mc.ncore + mc.ncas:, :, :, :] fh5['h2e_Sr'] = h2e_Sr h2e_Si = numpy.transpose(h2e_t[:mc.ncore, :, :, :], (1, 0, 2, 3)) fh5['h2e_Si'] = h2e_Si fh5.close() logger.timer(mc, 'Write MPS NEVPT integral', *t0)
ev = energy[ncore + nocc:] e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) + eo.reshape(-1, 1) - ev) eri_ao = ao2mo.restore(1, mf._eri, nao0) eri_ao = eri_ao.reshape((nao0, nao0, nao0, nao0)) def spin_block(eri): identity = numpy.eye(2) eri = numpy.kron(identity, eri) return numpy.kron(identity, eri.T) eri_ao = spin_block(eri_ao) eri_mo = ao2mo.general(eri_ao, (co, cv, co, cv), compact=False) eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir) # Antisymmetrize: # <pr||qs> = <pr|qs> - <ps|qr> #eri_mo = eri_mo - eri_mo.transpose(0,3,2,1) #t2 = numpy.zeros((nocc,nvir,nocc,nvir)) #t2 = einsum('iajb,iajb->iajb', eri_mo, e_denom) #e_mp2 = 0.25*numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True) #lib.logger.info(mf,"!*** E(MP2): %12.8f" % e_mp2) #lib.logger.info(mf,"!**** E(HF+MP2): %12.8f" % (e_mp2+ehf)) t2 = numpy.zeros((nocc, nvir, nocc, nvir)) t2 = numpy.einsum('iajb,iajb->iajb', \ eri_mo - eri_mo.transpose(0,3,2,1), e_denom, optimize=True) e_mp2 = 0.5 * numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True)
mf = x2c.RHF(mol) dm = mf.get_init_guess() + 0.1j mf.kernel(dm) ncore = 2 eri_ao = mol.intor('int2e_spinor') pt = MP2(mf) pt.frozen = ncore pt.kernel() rdm1 = pt.make_rdm1() rdm2 = pt.make_rdm2() c = mf.mo_coeff nmo = mf.mo_coeff.shape[1] eri_mo = ao2mo.general(eri_ao, (c, c, c, c)).reshape(nmo, nmo, nmo, nmo) hcore = mf.get_hcore() h1 = reduce(numpy.dot, (mf.mo_coeff.T.conj(), hcore, mf.mo_coeff)) e = numpy.einsum('ij,ji', h1, rdm1) e += numpy.einsum('ijkl,ijkl', eri_mo, rdm2) * 0.5 e += mol.energy_nuc() print("!*** E(X2CMP2) with RDM: %s" % e) mo_coeff, mo_energy, mo_occ = pt.fno() pt = MP2(mf, mo_coeff=mo_coeff, mo_occ=mo_occ) pt.frozen = ncore pt.kernel(mo_energy=mo_energy) rdm1 = pt.make_rdm1() rdm2 = pt.make_rdm2() c = mo_coeff
mf = scf.RHF(mol) mf.conv_tol = 1e-8 e = mf.scf() print('E = %.15g, ref -230.776765415' % e) # Given four MOs, compute the MO-integrals import tempfile import numpy import h5py from pyscf import ao2mo eritmp = tempfile.NamedTemporaryFile() nocc = mol.nelectron // 2 nvir = len(mf.mo_energy) - nocc co = mf.mo_coeff[:,:nocc] cv = mf.mo_coeff[:,nocc:] ao2mo.general(mol, (co,cv,co,cv), eritmp.name, max_memory=500, dataname='mp2_bz', verbose=5) eia = mf.mo_energy[:nocc,None] - mf.mo_energy[None,nocc:] f = h5py.File(eritmp.name, 'r') eri = f['mp2_bz'] emp2 = 0 for i in range(nocc): dajb = (eia[i].reshape(-1,1) + eia.reshape(1,-1)).ravel() gi = numpy.array(eri[i*nvir:(i+1)*nvir]).reshape(nvir,nocc,nvir) t2 = (gi.ravel()/dajb).reshape(nvir,nocc,nvir) theta = gi.ravel()*2 - gi.transpose(2,1,0).ravel() emp2 += numpy.dot(t2.ravel(), theta) print('E_MP2 = %.15g, ref = -1.0435476768' % emp2) f.close()
ehf = mf.kernel(dm) ncore = 1 nao, nmo = mf.mo_coeff.shape nocc = mol.nelectron // 2 - ncore nvir = nmo - nocc - ncore mo_core = mf.mo_coeff[:, :ncore] mo_occ = mf.mo_coeff[:, ncore:ncore + nocc] mo_vir = mf.mo_coeff[:, ncore + nocc:] co = mo_occ cv = mo_vir eo = mf.mo_energy[ncore:ncore + nocc] ev = mf.mo_energy[ncore + nocc:] lib.logger.info(mf, "* Core orbitals: %d" % ncore) lib.logger.info(mf, "* Virtual orbitals: %d" % (len(ev))) eri_mo = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False) eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir) e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) + eo.reshape(-1, 1) - ev) t2 = numpy.zeros((nocc, nvir, nocc, nvir)) # erf(omega * r12) / r12 omega = 0.5 mol.set_range_coulomb(omega) erf_r12 = mol.intor('cint2e_sph') erf_r12 = ao2mo.restore(8, erf_r12, nao) eri_mo_erfr12 = ao2mo.general(erf_r12, (co, cv, co, cv), compact=False) eri_mo_erfr12 = eri_mo_erfr12.reshape(nocc, nvir, nocc, nvir) erfc_r12 = eri_mo - eri_mo_erfr12 #erfc_r12 = 1.0 - eri_mo_erfr12
def transform_integrals_outcore(myadc): cput0 = (logger.process_clock(), logger.perf_counter()) log = logger.Logger(myadc.stdout, myadc.verbose) mo_a = myadc.mo_coeff[0] mo_b = myadc.mo_coeff[1] nmo_a = mo_a.shape[1] nmo_b = mo_b.shape[1] occ_a = myadc.mo_coeff[0][:, :myadc._nocc[0]] occ_b = myadc.mo_coeff[1][:, :myadc._nocc[1]] vir_a = myadc.mo_coeff[0][:, myadc._nocc[0]:] vir_b = myadc.mo_coeff[1][:, myadc._nocc[1]:] nocc_a = occ_a.shape[1] nocc_b = occ_b.shape[1] nvir_a = vir_a.shape[1] nvir_b = vir_b.shape[1] nvpair_a = nvir_a * (nvir_a + 1) // 2 nvpair_b = nvir_b * (nvir_b + 1) // 2 eris = lambda: None eris.feri1 = lib.H5TmpFile() eris.oooo = eris.feri1.create_dataset('oooo', (nocc_a, nocc_a, nocc_a, nocc_a), 'f8') eris.oovv = eris.feri1.create_dataset('oovv', (nocc_a, nocc_a, nvir_a, nvir_a), 'f8', chunks=(nocc_a, nocc_a, 1, nvir_a)) eris.ovoo = eris.feri1.create_dataset('ovoo', (nocc_a, nvir_a, nocc_a, nocc_a), 'f8', chunks=(nocc_a, 1, nocc_a, nocc_a)) eris.ovvo = eris.feri1.create_dataset('ovvo', (nocc_a, nvir_a, nvir_a, nocc_a), 'f8', chunks=(nocc_a, 1, nvir_a, nocc_a)) eris.ovvv = eris.feri1.create_dataset('ovvv', (nocc_a, nvir_a, nvpair_a), 'f8') eris.OOOO = eris.feri1.create_dataset('OOOO', (nocc_b, nocc_b, nocc_b, nocc_b), 'f8') eris.OOVV = eris.feri1.create_dataset('OOVV', (nocc_b, nocc_b, nvir_b, nvir_b), 'f8', chunks=(nocc_b, nocc_b, 1, nvir_b)) eris.OVOO = eris.feri1.create_dataset('OVOO', (nocc_b, nvir_b, nocc_b, nocc_b), 'f8', chunks=(nocc_b, 1, nocc_b, nocc_b)) eris.OVVO = eris.feri1.create_dataset('OVVO', (nocc_b, nvir_b, nvir_b, nocc_b), 'f8', chunks=(nocc_b, 1, nvir_b, nocc_b)) eris.OVVV = eris.feri1.create_dataset('OVVV', (nocc_b, nvir_b, nvpair_b), 'f8') eris.ooOO = eris.feri1.create_dataset('ooOO', (nocc_a, nocc_a, nocc_b, nocc_b), 'f8') eris.ooVV = eris.feri1.create_dataset('ooVV', (nocc_a, nocc_a, nvir_b, nvir_b), 'f8', chunks=(nocc_a, nocc_a, 1, nvir_b)) eris.ovOO = eris.feri1.create_dataset('ovOO', (nocc_a, nvir_a, nocc_b, nocc_b), 'f8', chunks=(nocc_a, 1, nocc_b, nocc_b)) eris.ovVO = eris.feri1.create_dataset('ovVO', (nocc_a, nvir_a, nvir_b, nocc_b), 'f8', chunks=(nocc_a, 1, nvir_b, nocc_b)) eris.ovVV = eris.feri1.create_dataset('ovVV', (nocc_a, nvir_a, nvpair_b), 'f8') eris.OOvv = eris.feri1.create_dataset('OOvv', (nocc_b, nocc_b, nvir_a, nvir_a), 'f8', chunks=(nocc_b, nocc_b, 1, nvir_a)) eris.OVoo = eris.feri1.create_dataset('OVoo', (nocc_b, nvir_b, nocc_a, nocc_a), 'f8', chunks=(nocc_b, 1, nocc_a, nocc_a)) eris.OVvo = eris.feri1.create_dataset('OVvo', (nocc_b, nvir_b, nvir_a, nocc_a), 'f8', chunks=(nocc_b, 1, nvir_a, nocc_a)) eris.OVvv = eris.feri1.create_dataset('OVvv', (nocc_b, nvir_b, nvpair_a), 'f8') cput1 = logger.process_clock(), logger.perf_counter() mol = myadc.mol tmpf = lib.H5TmpFile() if nocc_a > 0: ao2mo.general(mol, (occ_a, mo_a, mo_a, mo_a), tmpf, 'aa') buf = np.empty((nmo_a, nmo_a, nmo_a)) for i in range(nocc_a): lib.unpack_tril(tmpf['aa'][i * nmo_a:(i + 1) * nmo_a], out=buf) eris.oooo[i] = buf[:nocc_a, :nocc_a, :nocc_a] eris.ovoo[i] = buf[nocc_a:, :nocc_a, :nocc_a] eris.oovv[i] = buf[:nocc_a, nocc_a:, nocc_a:] eris.ovvo[i] = buf[nocc_a:, nocc_a:, :nocc_a] eris.ovvv[i] = lib.pack_tril(buf[nocc_a:, nocc_a:, nocc_a:]) del (tmpf['aa']) if nocc_b > 0: buf = np.empty((nmo_b, nmo_b, nmo_b)) ao2mo.general(mol, (occ_b, mo_b, mo_b, mo_b), tmpf, 'bb') for i in range(nocc_b): lib.unpack_tril(tmpf['bb'][i * nmo_b:(i + 1) * nmo_b], out=buf) eris.OOOO[i] = buf[:nocc_b, :nocc_b, :nocc_b] eris.OVOO[i] = buf[nocc_b:, :nocc_b, :nocc_b] eris.OOVV[i] = buf[:nocc_b, nocc_b:, nocc_b:] eris.OVVO[i] = buf[nocc_b:, nocc_b:, :nocc_b] eris.OVVV[i] = lib.pack_tril(buf[nocc_b:, nocc_b:, nocc_b:]) del (tmpf['bb']) if nocc_a > 0: buf = np.empty((nmo_a, nmo_b, nmo_b)) ao2mo.general(mol, (occ_a, mo_a, mo_b, mo_b), tmpf, 'ab') for i in range(nocc_a): lib.unpack_tril(tmpf['ab'][i * nmo_a:(i + 1) * nmo_a], out=buf) eris.ooOO[i] = buf[:nocc_a, :nocc_b, :nocc_b] eris.ovOO[i] = buf[nocc_a:, :nocc_b, :nocc_b] eris.ooVV[i] = buf[:nocc_a, nocc_b:, nocc_b:] eris.ovVO[i] = buf[nocc_a:, nocc_b:, :nocc_b] eris.ovVV[i] = lib.pack_tril(buf[nocc_a:, nocc_b:, nocc_b:]) del (tmpf['ab']) if nocc_b > 0: buf = np.empty((nmo_b, nmo_a, nmo_a)) ao2mo.general(mol, (occ_b, mo_b, mo_a, mo_a), tmpf, 'ba') for i in range(nocc_b): lib.unpack_tril(tmpf['ba'][i * nmo_b:(i + 1) * nmo_b], out=buf) eris.OVoo[i] = buf[nocc_b:, :nocc_a, :nocc_a] eris.OOvv[i] = buf[:nocc_b, nocc_a:, nocc_a:] eris.OVvo[i] = buf[nocc_b:, nocc_a:, :nocc_a] eris.OVvv[i] = lib.pack_tril(buf[nocc_b:, nocc_a:, nocc_a:]) del (tmpf['ba']) buf = None cput1 = logger.timer_debug1(myadc, 'transforming oopq, ovpq', *cput1) ############### forming eris_vvvv ######################################## if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"): cput2 = logger.process_clock(), logger.perf_counter() ind_vv_g = np.tril_indices(nvir_a, k=-1) ind_VV_g = np.tril_indices(nvir_b, k=-1) eris.vvvv_p = [] eris.VVVV_p = [] eris.vVvV_p = [] eris.VvVv_p = [] avail_mem = (myadc.max_memory - lib.current_memory()[0]) * 0.25 vvv_mem = (nvir_a**3) * 8 / 1e6 chnk_size = int(avail_mem / vvv_mem) if chnk_size <= 0: chnk_size = 1 for p in range(0, vir_a.shape[1], chnk_size): if chnk_size < vir_a.shape[1]: orb_slice = vir_a[:, p:p + chnk_size] else: orb_slice = vir_a[:, p:] _, tmp = tempfile.mkstemp() ao2mo.outcore.general(mol, (orb_slice, vir_a, vir_a, vir_a), tmp, max_memory=avail_mem, ioblk_size=100, compact=False) vvvv = radc_ao2mo.read_dataset(tmp, 'eri_mo') del (tmp) vvvv = vvvv.reshape(orb_slice.shape[1], vir_a.shape[1], vir_a.shape[1], vir_a.shape[1]) vvvv = np.ascontiguousarray(vvvv.transpose(0, 2, 1, 3)) vvvv -= np.ascontiguousarray(vvvv.transpose(0, 1, 3, 2)) vvvv = vvvv[:, :, ind_vv_g[0], ind_vv_g[1]] vvvv_p = radc_ao2mo.write_dataset(vvvv) del vvvv eris.vvvv_p.append(vvvv_p) for p in range(0, vir_b.shape[1], chnk_size): if chnk_size < vir_b.shape[1]: orb_slice = vir_b[:, p:p + chnk_size] else: orb_slice = vir_b[:, p:] _, tmp = tempfile.mkstemp() ao2mo.outcore.general(mol, (orb_slice, vir_b, vir_b, vir_b), tmp, max_memory=avail_mem, ioblk_size=100, compact=False) VVVV = radc_ao2mo.read_dataset(tmp, 'eri_mo') del (tmp) VVVV = VVVV.reshape(orb_slice.shape[1], vir_b.shape[1], vir_b.shape[1], vir_b.shape[1]) VVVV = np.ascontiguousarray(VVVV.transpose(0, 2, 1, 3)) VVVV -= np.ascontiguousarray(VVVV.transpose(0, 1, 3, 2)) VVVV = VVVV[:, :, ind_VV_g[0], ind_VV_g[1]] VVVV_p = radc_ao2mo.write_dataset(VVVV) del VVVV eris.VVVV_p.append(VVVV_p) for p in range(0, vir_a.shape[1], chnk_size): if chnk_size < vir_a.shape[1]: orb_slice = vir_a[:, p:p + chnk_size] else: orb_slice = vir_a[:, p:] _, tmp = tempfile.mkstemp() ao2mo.outcore.general(mol, (orb_slice, vir_a, vir_b, vir_b), tmp, max_memory=avail_mem, ioblk_size=100, compact=False) vVvV = radc_ao2mo.read_dataset(tmp, 'eri_mo') del (tmp) vVvV = vVvV.reshape(orb_slice.shape[1], vir_a.shape[1], vir_b.shape[1], vir_b.shape[1]) vVvV = np.ascontiguousarray(vVvV.transpose(0, 2, 1, 3)) vVvV = vVvV.reshape(-1, vir_b.shape[1], vir_a.shape[1] * vir_b.shape[1]) vVvV_p = radc_ao2mo.write_dataset(vVvV) del vVvV eris.vVvV_p.append(vVvV_p) for p in range(0, vir_b.shape[1], chnk_size): if chnk_size < vir_b.shape[1]: orb_slice = vir_b[:, p:p + chnk_size] else: orb_slice = vir_b[:, p:] _, tmp = tempfile.mkstemp() ao2mo.outcore.general(mol, (orb_slice, vir_b, vir_a, vir_a), tmp, max_memory=avail_mem, ioblk_size=100, compact=False) VvVv = radc_ao2mo.read_dataset(tmp, 'eri_mo') del tmp VvVv = VvVv.reshape(orb_slice.shape[1], vir_b.shape[1], vir_a.shape[1], vir_a.shape[1]) VvVv = np.ascontiguousarray(VvVv.transpose(0, 2, 1, 3)) VvVv = VvVv.reshape(-1, vir_a.shape[1], vir_b.shape[1] * vir_a.shape[1]) VvVv_p = radc_ao2mo.write_dataset(VvVv) del VvVv eris.VvVv_p.append(VvVv_p) cput2 = logger.timer_debug1(myadc, 'transforming vvvv', *cput2) log.timer('ADC outcore integral transformation', *cput0) return eris
def dump(self, fname='mole.h5'): # Effective nbas = self.nbas - self.nfrozen sbas = nbas * 2 print('\n[iface.dump] (self.nbas,nbas)=', (self.nbas, nbas)) # # Basic information # f = h5py.File(fname, "w") cal = f.create_dataset("cal", (1, ), dtype='i') enuc = self.mol.energy_nuc() nelec = self.nelec - self.nfrozen * 2 cal.attrs["nelec"] = nelec cal.attrs["sbas"] = sbas cal.attrs["enuc"] = enuc cal.attrs[ "escf"] = 0. # Not useful at all: self.mf.energy_elec(self.mf.make_rdm1())[0] # # Intergrals # flter = 'lzf' # Local or CMO if self.iflocal: self.local() mo_coeff = self.lmo_coeff.copy() else: print('canonical or user defined mo') mo_coeff = self.mo_coeff[:, self.nfrozen:].copy() # Reorder if self.ifreorder: order = list(self.reorder(mo_coeff)) else: order = list(range(mo_coeff.shape[1])) mo_coeff = mo_coeff[:, numpy.array(order)].copy() self.molden(mo_coeff, fname='mocoeff') # Dump MO coefficients f.create_dataset("mo_coeff_spatial", data=mo_coeff) # Occupation occun = numpy.zeros(sbas) for i in range(self.nalpha - self.nfrozen): occun[2 * i] = 1.0 for i in range(self.nbeta - self.nfrozen): occun[2 * i + 1] = 1.0 print() print('initial occun for', len(occun), ' spin orbitals:\n', occun) sorder = numpy.array([[2 * i, 2 * i + 1] for i in order]).flatten() occun = occun[sorder].copy() assert abs(numpy.sum(occun) - nelec) < 1.e-10 print("sorder:", sorder) print("occun :", occun) # Symmetry if self.mol.symmetry and not self.iflocal: import pyscf.symm irrep_name = self.mol.irrep_id orbsym0 = pyscf.symm.label_orb_symm(self.mol, irrep_name, self.mol.symm_orb, mo_coeff) print('\nSpatial orbsym:\n', orbsym0) orbsym = numpy.array([[i, i] for i in orbsym0]).flatten() else: orbsym = numpy.array([0] * sbas) spinsym = numpy.array([[0, 1] for i in range(nbas)]).flatten() print("orbsym :", orbsym) print("spinsym:", spinsym) f.create_dataset("occun", data=occun) f.create_dataset("orbsym", data=orbsym) f.create_dataset("spinsym", data=spinsym) #==================================================================== # Spin orbital integrals #==================================================================== # Integral transformation # SPECIAL FORM of MO for TRANS gmo_coeff = numpy.hstack((self.mo_coeff[:, :self.nfrozen], mo_coeff)) print('gmo_coeff.shape=', gmo_coeff.shape) f.create_dataset("mo_coeff_spatialAll", data=gmo_coeff) kbas = gmo_coeff.shape[0] abas = gmo_coeff.shape[1] * 2 b = numpy.zeros((kbas, abas)) b[:, ::2] = gmo_coeff.copy() b[:, 1::2] = gmo_coeff.copy() # INT1e: h = self.mf.get_hcore() hmo = reduce(numpy.dot, (b.T, h, b)) hmo[::2, 1::2] = hmo[1::2, ::2] = 0. # INT2e: from pyscf import ao2mo nb = abas eri = ao2mo.general(self.mol, (b, b, b, b), compact=0).reshape(nb, nb, nb, nb) #eri = ao2mo.incore.general(self.mf._eri,(b,b,b,b),compact=0).reshape(nb,nb,nb,nb) eri[::2, 1::2] = eri[1::2, ::2] = eri[:, :, ::2, 1::2] = eri[:, :, 1::2, ::2] = 0. # <ij|kl>=[ik|jl] eri = eri.transpose(0, 2, 1, 3) # Antisymmetrize V[pqrs]=-1/2*<pq||rs> - In MPO construnction, only r<s part is used. eri = -0.5 * (eri - eri.transpose(0, 1, 3, 2)) #------------------ Frozen Core ------------------ # fpq = hpq + <pr||qr>nr sfrozen = 2 * self.nfrozen nr = numpy.zeros(abas) nr[:sfrozen] = 1.0 # Ecore = hcc + 1/2*<pq||pq>npnq ecore = numpy.einsum('pp,p',hmo,nr)\ - numpy.einsum('pqpq,p,q',eri,nr,nr) print('E[core]=', ecore) cal.attrs["ecor"] = ecore fpq = hmo - 2.0 * numpy.einsum('prqr,r->pq', eri, nr) orbrg = list(range(sfrozen, abas)) hmo = fpq[numpy.ix_(orbrg, orbrg)].copy() eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy() #------------------ Frozen Core ------------------ # DUMP modified Integrals e1 = cal.attrs["escf"] ioccun = [x[0] for x in numpy.argwhere(occun > 1.e-4)] #print 'ioccun=',ioccun e2 = numpy.einsum('ii',hmo[numpy.ix_(ioccun,ioccun)])\ - numpy.einsum('ijij',eri[numpy.ix_(ioccun,ioccun,ioccun,ioccun)]) ediff = abs(e1 - e2 - ecore) print('E[pyscf]=', e1) print('E[elec] =', e2, ' E[elec]+E[core]=', e2 + ecore) print('E[diff] =', ediff) #assert ediff<1.e-10 # can be different for casscf case int1e = f.create_dataset("int1e", data=hmo, compression=flter) int2e = f.create_dataset("int2e", data=eri, compression=flter) #==================================================================== # Spatial integrals #==================================================================== b = gmo_coeff # INT1e: h = self.mf.get_hcore() hmo = reduce(numpy.dot, (b.T, h, b)) # INT2e: from pyscf import ao2mo nb = abas // 2 eri = ao2mo.general(self.mol, (b, b, b, b), compact=0).reshape(nb, nb, nb, nb) # Frozen core case: # fpq = hpq + [pq|rr]*nr - 0.5*[pr|rq]*nr nr = numpy.zeros(nb) nr[:self.nfrozen] = 2.0 Fpq = hmo + numpy.einsum('pqrr,r->pq',eri,nr)\ - 0.5*numpy.einsum('prrq,r->pq',eri,nr) #print numpy.linalg.norm(fpq[::2,::2] - Fpq) #print numpy.linalg.norm(fpq[1::2,1::2] - Fpq) #print numpy.linalg.norm(fpq[::2,1::2]) #print numpy.linalg.norm(fpq[1::2,::2]) orbrg = list(range(self.nfrozen, self.nbas)) hmo = Fpq[numpy.ix_(orbrg, orbrg)].copy() eri = eri[numpy.ix_(orbrg, orbrg, orbrg, orbrg)].copy() f.create_dataset("int1e_spatial", data=hmo, compression=flter) f.create_dataset("int2e_spatial", data=eri, compression=flter) #==================================================================== f.close() print('Successfully dump information for HS-DMRG calculations! fname=', fname) self.check(fname) return 0
def transform_integrals_incore(myadc): cput0 = (logger.process_clock(), logger.perf_counter()) log = logger.Logger(myadc.stdout, myadc.verbose) occ_a = myadc.mo_coeff[0][:, :myadc._nocc[0]] occ_b = myadc.mo_coeff[1][:, :myadc._nocc[1]] vir_a = myadc.mo_coeff[0][:, myadc._nocc[0]:] vir_b = myadc.mo_coeff[1][:, myadc._nocc[1]:] nocc_a = occ_a.shape[1] nocc_b = occ_b.shape[1] nvir_a = vir_a.shape[1] nvir_b = vir_b.shape[1] ind_vv_g = np.tril_indices(nvir_a, k=-1) ind_VV_g = np.tril_indices(nvir_b, k=-1) eris = lambda: None # TODO: check if myadc._scf._eri is not None eris.oooo = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, occ_a, occ_a), compact=False).reshape( nocc_a, nocc_a, nocc_a, nocc_a).copy() # noqa: E501 eris.ovoo = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, occ_a, occ_a), compact=False).reshape( nocc_a, nvir_a, nocc_a, nocc_a).copy() # noqa: E501 eris.ovvo = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_a, occ_a), compact=False).reshape( nocc_a, nvir_a, nvir_a, nocc_a).copy() # noqa: E501 eris.oovv = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, vir_a, vir_a), compact=False).reshape( nocc_a, nocc_a, nvir_a, nvir_a).copy() # noqa: E501 eris.ovvv = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_a, vir_a), compact=True).reshape(nocc_a, nvir_a, -1).copy() # noqa: E501 eris.OOOO = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, occ_b, occ_b), compact=False).reshape( nocc_b, nocc_b, nocc_b, nocc_b).copy() # noqa: E501 eris.OVOO = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, occ_b, occ_b), compact=False).reshape( nocc_b, nvir_b, nocc_b, nocc_b).copy() # noqa: E501 eris.OOVV = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, vir_b, vir_b), compact=False).reshape( nocc_b, nocc_b, nvir_b, nvir_b).copy() # noqa: E501 eris.OVVO = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_b, occ_b), compact=False).reshape( nocc_b, nvir_b, nvir_b, nocc_b).copy() # noqa: E501 eris.OVVV = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_b, vir_b), compact=True).reshape(nocc_b, nvir_b, -1).copy() # noqa: E501 eris.ooOO = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, occ_b, occ_b), compact=False).reshape( nocc_a, nocc_a, nocc_b, nocc_b).copy() # noqa: E501 eris.ovOO = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, occ_b, occ_b), compact=False).reshape( nocc_a, nvir_a, nocc_b, nocc_b).copy() # noqa: E501 eris.ooVV = ao2mo.general(myadc._scf._eri, (occ_a, occ_a, vir_b, vir_b), compact=False).reshape( nocc_a, nocc_a, nvir_b, nvir_b).copy() # noqa: E501 eris.ovVO = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_b, occ_b), compact=False).reshape( nocc_a, nvir_a, nvir_b, nocc_b).copy() # noqa: E501 eris.ovVV = ao2mo.general(myadc._scf._eri, (occ_a, vir_a, vir_b, vir_b), compact=True).reshape(nocc_a, nvir_a, -1).copy() # noqa: E501 eris.OVoo = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, occ_a, occ_a), compact=False).reshape( nocc_b, nvir_b, nocc_a, nocc_a).copy() # noqa: E501 eris.OOvv = ao2mo.general(myadc._scf._eri, (occ_b, occ_b, vir_a, vir_a), compact=False).reshape( nocc_b, nocc_b, nvir_a, nvir_a).copy() # noqa: E501 eris.OVvo = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_a, occ_a), compact=False).reshape( nocc_b, nvir_b, nvir_a, nocc_a).copy() # noqa: E501 eris.OVvv = ao2mo.general(myadc._scf._eri, (occ_b, vir_b, vir_a, vir_a), compact=True).reshape(nocc_b, nvir_b, -1).copy() # noqa: E501 if (myadc.method == "adc(2)-x" or myadc.method == "adc(3)"): eris.vvvv_p = ao2mo.general(myadc._scf._eri, (vir_a, vir_a, vir_a, vir_a), compact=False).reshape( nvir_a, nvir_a, nvir_a, nvir_a) eris.vvvv_p = eris.vvvv_p.transpose(0, 2, 1, 3) eris.vvvv_p -= eris.vvvv_p.transpose(0, 1, 3, 2) eris.vvvv_p = eris.vvvv_p[:, :, ind_vv_g[0], ind_vv_g[1]] eris.vvvv_p = eris.vvvv_p[ind_vv_g[0], ind_vv_g[1]].copy() eris.VVVV_p = ao2mo.general(myadc._scf._eri, (vir_b, vir_b, vir_b, vir_b), compact=False).reshape( nvir_b, nvir_b, nvir_b, nvir_b) eris.VVVV_p = eris.VVVV_p.transpose(0, 2, 1, 3) eris.VVVV_p -= eris.VVVV_p.transpose(0, 1, 3, 2) eris.VVVV_p = eris.VVVV_p[:, :, ind_VV_g[0], ind_VV_g[1]] eris.VVVV_p = eris.VVVV_p[ind_VV_g[0], ind_VV_g[1]].copy() eris.vVvV_p = ao2mo.general(myadc._scf._eri, (vir_a, vir_a, vir_b, vir_b), compact=False).reshape( nvir_a, nvir_a, nvir_b, nvir_b) eris.vVvV_p = np.ascontiguousarray(eris.vVvV_p.transpose(0, 2, 1, 3)) eris.vVvV_p = eris.vVvV_p.reshape(nvir_a * nvir_b, nvir_a * nvir_b) log.timer('ADC incore integral transformation', *cput0) return eris
t = time.time() lib.logger.debug(mf, 'Start building spin AO eri') eri_ao = spin_block(eri_ao) eri_ao = eri_ao - eri_ao.transpose(0, 3, 2, 1) hao = numpy.kron(numpy.eye(2), mf.get_hcore()) lib.logger.debug(mf, '.. finished in %.3f seconds.' % (time.time() - t)) o = slice(0, nocc) v = slice(nocc, None) x = numpy.newaxis c = coeff[:, ncore:] n = c.shape[1] t = time.time() lib.logger.debug(mf, 'Start transform AO to MO basis') eri_mo = ao2mo.general(eri_ao, (c, c, c, c), compact=False) lib.logger.debug(mf, '.. finished in %.3f seconds.' % (time.time() - t)) eri_mo = eri_mo.reshape(n, n, n, n) def ao_to_mo(hao, c): return c.T.dot(hao).dot(c) hmo = ao_to_mo(hao, c) # Intialize amplitudes and RDMs t2 = numpy.zeros((nvir, nocc, nvir, nocc)) opdm_corr = numpy.zeros((nso, nso)) opdm_ref = numpy.zeros((nso, nso)) opdm_ref[o, o] = numpy.identity(nocc)
mol.basis = 'aug-cc-pvdz' mol.verbose = 4 mol.build() mf = scf.RHF(mol) ehf = mf.kernel() nao, nmo = mf.mo_coeff.shape ncore = 0 nocc = mol.nelectron / 2 - ncore nvir = nmo - nocc - ncore c = mf.mo_coeff[:, ncore:ncore + nocc + nvir] eo = mf.mo_energy[ncore:ncore + nocc] ev = mf.mo_energy[ncore + nocc:] eri_mo = ao2mo.general(mf._eri, (c, c, c, c), compact=False) eri_mo = eri_mo.reshape(nocc + nvir, nocc + nvir, nocc + nvir, nocc + nvir) epsilon = 1 / (eo.reshape(-1, 1, 1, 1) + eo.reshape(-1, 1, 1) - ev.reshape(-1, 1) - ev) o = slice(0, nocc) v = slice(nocc, None) eri_mo = eri_mo.swapaxes(1, 2) t2 = numpy.zeros((nocc, nvir, nocc, nvir)) t2 = 2.0 * numpy.einsum('rsab,abrs->abrs', eri_mo[v, v, o, o], epsilon) t2 -= numpy.einsum('rsba,abrs->abrs', eri_mo[v, v, o, o], epsilon) t2 = t2.swapaxes(1, 2) e_mp2 = numpy.einsum('iajb,iajb->', eri_mo[o, o, v, v].swapaxes(1, 2), t2) lib.logger.info(mf, "!*** E(MP2): %12.8f" % e_mp2) lib.logger.info(mf, "!**** E(HF+MP2): %12.8f" % (e_mp2 + ehf))
def update_casdm(self, mo, u, fcivec, e_ci, eris): nmo = mo.shape[1] rmat = u - numpy.eye(nmo) #g = hessian_co(self, mo, rmat, fcivec, e_ci, eris) ### hessian_co part start ### ncas = self.ncas nelecas = self.nelecas ncore = self.ncore nocc = ncore + ncas uc = u[:,:ncore] ua = u[:,ncore:nocc].copy() ra = rmat[:,ncore:nocc].copy() rc = rmat[:,:ncore] h1e_mo = reduce(numpy.dot, (mo.T, self.get_hcore(), mo)) ddm = numpy.dot(uc, uc.T) * 2 # ~ dm(1) + dm(2) ddm[numpy.diag_indices(ncore)] -= 2 if self.ci_update_dep == 4 or self.grad_update_dep == 4: from pyscf import ao2mo mo1 = numpy.dot(mo, u) dm_core0 = numpy.dot(mo[:,:ncore], mo[:,:ncore].T) * 2 dm_core = numpy.dot(mo1[:,:ncore], mo1[:,:ncore].T) * 2 vj, vk = self._scf.get_jk(self.mol, dm_core-dm_core0) vhf_c =(reduce(numpy.dot, (mo1.T, vj-vk*.5, mo1[:,:nocc])) + reduce(numpy.dot, (u.T, eris.vhf_c, u[:,:nocc]))) h1 =(reduce(numpy.dot, (ua.T, h1e_mo, ua)) + vhf_c[ncore:nocc,ncore:nocc]) mo1_cas = mo1[:,ncore:nocc] if self._scf._eri is None: paaa = ao2mo.general(self.mol, (mo1,)+(mo1_cas,)*3, compact=False) eris._paaa = paaa.reshape(nmo,ncas,ncas,ncas) else: paaa = ao2mo.general(self._scf._eri, (mo1,)+(mo1_cas,)*3, compact=False) eris._paaa = paaa.reshape(nmo,ncas,ncas,ncas) h2 = eris._paaa[ncore:nocc] vj = vk = paaa = None elif self.ci_update_dep == 2: # (0) + (1) + part-of-(2) ## missing terms: #jk =(numpy.dot(numpy.einsum('upqv,qv->up', eris.appc, rc*2), rc) # - numpy.dot(numpy.einsum('upqv,pv->uq', eris.appc, rc), rc)*.5 # - numpy.dot(numpy.einsum('uvpq,pv->uq', eris.acpp, rc), rc)*.5) #jk = jk + jk.T p1aa = numpy.empty((nmo,ncas,ncas**2)) paa1 = numpy.empty((nmo,ncas**2,ncas)) jk = reduce(numpy.dot, (ua.T, eris.vhf_c, ua)) for i in range(nmo): jbuf = eris.ppaa[i] kbuf = eris.papa[i] jk +=(numpy.einsum('quv,q->uv', jbuf, ddm[i]) - numpy.einsum('uqv,q->uv', kbuf, ddm[i]) * .5) p1aa[i] = pyscf.lib.dot(ua.T, jbuf.reshape(nmo,-1)) paa1[i] = pyscf.lib.dot(kbuf.transpose(0,2,1).reshape(-1,nmo), ra) h1 = reduce(numpy.dot, (ua.T, h1e_mo, ua)) + jk aa11 = pyscf.lib.dot(ua.T, p1aa.reshape(nmo,-1)).reshape((ncas,)*4) aaaa = eris.ppaa[ncore:nocc,ncore:nocc,:,:] aa11 = aa11 + aa11.transpose(2,3,0,1) - aaaa a11a = numpy.dot(ra.T, paa1.reshape(nmo,-1)).reshape((ncas,)*4) a11a = a11a + a11a.transpose(1,0,2,3) a11a = a11a + a11a.transpose(0,1,3,2) h2 = aa11 + a11a jbuf = kbuf = p1aa = paa1 = aaaa = aa11 = a11a = None else: # jk(0) + jk(1) ddm[:] = 0 ddm[:,:ncore] = rc * 2 ddm[:ncore] += rc.T * 2 jk = numpy.dot(ra.T, eris.vhf_c[:,ncore:nocc]) jk = jk + jk.T + eris.vhf_c[ncore:nocc,ncore:nocc] for i in range(nmo): jk +=(numpy.einsum('quv,q->uv', eris.ppaa[i], ddm[i]) - numpy.einsum('uqv,q->uv', eris.papa[i], ddm[i]) * .5) h1 = numpy.dot(ra.T, h1e_mo[:,ncore:nocc]) h1 = h1 + h1.T + h1e_mo[ncore:nocc,ncore:nocc] + jk a1aa = numpy.empty((ncas,ncas,ncas**2)) for i in range(ncas): jbuf = eris.ppaa[ncore+i] a1aa[i] = pyscf.lib.dot(ra.T, jbuf.reshape(nmo,-1)) aaaa = eris.ppaa[ncore:nocc,ncore:nocc,:,:] a1aa = a1aa.reshape((ncas,)*4) a1aa = a1aa + a1aa.transpose(1,0,2,3) a1aa = a1aa + a1aa.transpose(2,3,0,1) h2 = aaaa + a1aa jbuf = aaaa = a1aa = None # pure core response # response of (1/2 dm * vhf * dm) ~ ddm*vhf # Should I consider core response as a part of CI gradients? ecore =(numpy.einsum('pq,pq->', h1e_mo, ddm) + numpy.einsum('pq,pq->', eris.vhf_c, ddm)) ### hessian_co part end ### ci1, g = self.solve_approx_ci(h1, h2, fcivec, ecore, e_ci) casdm1, casdm2 = self.fcisolver.make_rdm12(ci1, ncas, nelecas) return casdm1, casdm2, g, ci1
nocc = nocca + noccb nvir = nvira + nvirb lib.logger.info(mf, "* Core orbitals: %d %d" % ncore) lib.logger.info(mf, "* Virtual orbitals: %d %d" % (nvira, nvirb)) coa = mf.mo_coeff[0][:, ncorea:ncorea + nocca] cob = mf.mo_coeff[1][:, ncoreb:ncoreb + noccb] cva = mf.mo_coeff[0][:, ncorea + nocca:] cvb = mf.mo_coeff[1][:, ncoreb + noccb:] eoa = mf.mo_energy[0][ncorea:ncorea + nocca] eob = mf.mo_energy[1][ncoreb:ncoreb + noccb] eva = mf.mo_energy[0][ncorea + nocca:] evb = mf.mo_energy[1][ncoreb + noccb:] # Transform the alpha part eri = ao2mo.general(mol, (coa, cva, coa, cva)) eri = eri.reshape(nocca, nvira, nocca, nvira) e_denom = 1.0/(eoa.reshape(-1, 1, 1, 1) - eva.reshape(-1, 1, 1) + \ eoa.reshape(-1, 1) - eva) rdm2_ss_aa = numpy.zeros((nocca, nvira, nocca, nvira)) rdm2_ss_aa = numpy.einsum('iajb,iajb->iajb', eri, e_denom) rdm2_ss_aa -= numpy.einsum('ibja,iajb->iajb', eri, e_denom) echeck_aa = numpy.einsum('iajb,iajb->', eri, rdm2_ss_aa) * 0.5 print('E(MP2 SS AA) is %12.8f' % echeck_aa) # Transform the beta part eri = ao2mo.general(mol, (cob, cvb, cob, cvb)) eri = eri.reshape(noccb, nvirb, noccb, nvirb) e_denom = 1.0/(eob.reshape(-1, 1, 1, 1) - evb.reshape(-1, 1, 1) + \ eob.reshape(-1, 1) - evb) rdm2_ss_bb = numpy.zeros((noccb, nvirb, noccb, nvirb))
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() self.feri1 = lib.H5TmpFile() 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 = lib.H5TmpFile() 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 write_chk(mc,root,chkfile): t0 = (time.clock(), time.time()) fh5 = h5py.File(chkfile,'w') if mc.fcisolver.nroots > 1: mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root) fh5['mol'] = mc.mol.dumps() fh5['mc/mo'] = mc.mo_coeff fh5['mc/ncore'] = mc.ncore fh5['mc/ncas'] = mc.ncas nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore fh5['mc/nvirt'] = nvirt fh5['mc/nelecas'] = mc.nelecas fh5['mc/root'] = root fh5['mc/orbe'] = mc.mo_energy fh5['mc/nroots'] = mc.fcisolver.nroots fh5['mc/wfnsym'] = mc.fcisolver.wfnsym if hasattr(mc.mo_coeff, 'orbsym'): fh5.create_dataset('mc/orbsym',data=mc.mo_coeff.orbsym) else : fh5.create_dataset('mc/orbsym',data=[]) if hasattr(mc.mo_coeff, 'orbsym') and mc.mol.symmetry: orbsym = numpy.asarray(mc.mo_coeff.orbsym) pair_irrep = orbsym.reshape(-1,1) ^ orbsym else: pair_irrep = None ncore = mc.ncore nocc = mc.ncore + mc.ncas mo_core = mc.mo_coeff[:,:mc.ncore] mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas] mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:] core_dm = numpy.dot(mo_core,mo_core.T) *2 core_vhf = mc.get_veff(mc.mol,core_dm) h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas)) h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core)) h1e, e_core = mc.h1e_for_cas() if pair_irrep is not None: h1e_Sr[pair_irrep[nocc:,ncore:nocc] != 0] = 0 h1e_Si[pair_irrep[ncore:nocc,:ncore] != 0] = 0 h1e[pair_irrep[ncore:nocc,ncore:nocc] != 0] = 0 fh5['h1e_Si'] = h1e_Si fh5['h1e_Sr'] = h1e_Sr fh5['h1e'] = h1e fh5['e_core'] = e_core if mc._scf._eri is None: h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) if pair_irrep is not None: sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) != pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape) h2e_t[sym_forbid] = 0 h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si else: eri = mc._scf._eri h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) if pair_irrep is not None: sym_forbid = (pair_irrep[:,ncore:nocc].reshape(-1,1) != pair_irrep[ncore:nocc,ncore:nocc].ravel()).reshape(h2e_t.shape) h2e_t[sym_forbid] = 0 h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si fh5.close() logger.timer(mc,'Write MPS NEVPT integral', *t0)
def write_chk(mc,root,chkfile): t0 = (time.clock(), time.time()) fh5 = h5py.File(chkfile,'w') if mc.fcisolver.nroots > 1: mc.mo_coeff,_, mc.mo_energy = mc.canonicalize(mc.mo_coeff,ci=root) fh5['mol'] = mc.mol.dumps() fh5['mc/mo'] = mc.mo_coeff fh5['mc/ncore'] = mc.ncore fh5['mc/ncas'] = mc.ncas nvirt = mc.mo_coeff.shape[1] - mc.ncas-mc.ncore fh5['mc/nvirt'] = nvirt fh5['mc/nelecas'] = mc.nelecas fh5['mc/root'] = root fh5['mc/orbe'] = mc.mo_energy fh5['mc/nroots'] = mc.fcisolver.nroots fh5['mc/wfnsym'] = mc.fcisolver.wfnsym if hasattr(mc, 'orbsym'): fh5.create_dataset('mc/orbsym',data=mc.orbsym) else : fh5.create_dataset('mc/orbsym',data=[]) mo_core = mc.mo_coeff[:,:mc.ncore] mo_cas = mc.mo_coeff[:,mc.ncore:mc.ncore+mc.ncas] mo_virt = mc.mo_coeff[:,mc.ncore+mc.ncas:] core_dm = numpy.dot(mo_core,mo_core.T) *2 core_vhf = mc.get_veff(mc.mol,core_dm) h1e_Sr = reduce(numpy.dot, (mo_virt.T,mc.get_hcore()+core_vhf , mo_cas)) h1e_Si = reduce(numpy.dot, (mo_cas.T, mc.get_hcore()+core_vhf , mo_core)) fh5['h1e_Si'] = h1e_Si fh5['h1e_Sr'] = h1e_Sr h1e, e_core = mc.h1e_for_cas() fh5['h1e'] = h1e fh5['e_core'] = e_core if mc._scf._eri is None: h2e_t = ao2mo.general(mc.mol, (mc.mo_coeff,mo_cas,mo_cas,mo_cas), compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si else: eri = mc._scf._eri h2e_t = ao2mo.general(eri, [mc.mo_coeff,mo_cas,mo_cas,mo_cas], compact=False) h2e_t = h2e_t.reshape(-1,mc.ncas,mc.ncas,mc.ncas) h2e =h2e_t[mc.ncore:mc.ncore+mc.ncas,:,:,:] fh5['h2e'] = h2e h2e_Sr =h2e_t[mc.ncore+mc.ncas:,:,:,:] fh5['h2e_Sr'] = h2e_Sr h2e_Si =numpy.transpose(h2e_t[:mc.ncore,:,:,:], (1,0,2,3)) fh5['h2e_Si'] = h2e_Si fh5.close() logger.timer(mc,'Write MPS NEVPT integral', *t0)
ncore = 0 nao, nmo = mf.mo_coeff.shape nocc = cell.nelectron // 2 - ncore nvir = nmo - nocc - ncore mo_core = mf.mo_coeff[:, :ncore] mo_occ = mf.mo_coeff[:, ncore:ncore + nocc] mo_vir = mf.mo_coeff[:, ncore + nocc:] co = mo_occ cv = mo_vir eo = mf.mo_energy[ncore:ncore + nocc] ev = mf.mo_energy[ncore + nocc:] lib.logger.info(mf, "\n+++ GAMMA point MP2 ") lib.logger.info(mf, "* Core orbitals: %d" % ncore) lib.logger.info(mf, "* Virtual orbitals: %d" % (len(ev))) eri_mo = ao2mo.general(mf._eri, (co, cv, co, cv), compact=False) eri_mo = eri_mo.reshape(nocc, nvir, nocc, nvir) e_denom = 1.0 / (eo.reshape(-1, 1, 1, 1) - ev.reshape(-1, 1, 1) + eo.reshape(-1, 1) - ev) t2 = numpy.zeros((nocc, nvir, nocc, nvir)) t2 = 2.0 * lib.einsum('iajb,iajb->iajb', eri_mo, e_denom) t2 -= lib.einsum('ibja,iajb->iajb', eri_mo, e_denom) e_mp2 = numpy.einsum('iajb,iajb->', eri_mo, t2, optimize=True) lib.logger.info(mf, "!*** E(MP2): %12.8f" % e_mp2) lib.logger.info(mf, "!**** E(HF+MP2): %12.8f" % (e_mp2 + ehf)) wfn_file = name + '.wfn' ao_loc = cell.ao_loc_nr() fspt = open(wfn_file, 'w') wfn_format.write_mo(fspt, cell,
def __init__(self, cc, mo_coeff=None, method='incore', ao2mofn=ao2mo.full): cput0 = (time.clock(), time.time()) moidx = get_frozen_mask(cc) 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): if ao2mofn == ao2mo.full: if cc._scf._eri is not None: eri = ao2mo.restore(1, ao2mofn(cc._scf._eri, mo_coeff), nmo) else: eri = ao2mo.restore( 1, ao2mofn(cc._scf.mol, mo_coeff, compact=0), nmo) else: 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) self.dtype = eri.dtype self.oooo = eri[:nocc, :nocc, :nocc, :nocc].copy() self.ooov = eri[:nocc, :nocc, :nocc, nocc:].copy() self.ovoo = eri[:nocc, nocc:, :nocc, :nocc].copy() self.oovo = eri[:nocc, :nocc, nocc:, :nocc].copy() self.ovov = eri[:nocc, nocc:, :nocc, nocc:].copy() self.oovv = eri[:nocc, :nocc, nocc:, nocc:].copy() self.ovvo = eri[:nocc, nocc:, nocc:, :nocc].copy() self.ovvv = eri[:nocc, nocc:, nocc:, nocc:].copy() elif hasattr(cc._scf, 'with_df') and cc._scf.with_df: raise NotImplementedError else: orbo = mo_coeff[:, :nocc] self.dtype = mo_coeff.dtype ds_type = mo_coeff.dtype.char self.feri = lib.H5TmpFile() self.oooo = self.feri.create_dataset('oooo', (nocc, nocc, nocc, nocc), ds_type) self.ooov = self.feri.create_dataset('ooov', (nocc, nocc, nocc, nvir), ds_type) self.ovoo = self.feri.create_dataset('ovoo', (nocc, nvir, nocc, nocc), ds_type) self.oovo = self.feri.create_dataset('oovo', (nocc, nocc, nvir, nocc), ds_type) self.ovov = self.feri.create_dataset('ovov', (nocc, nvir, nocc, nvir), ds_type) self.oovv = self.feri.create_dataset('oovv', (nocc, nocc, nvir, nvir), ds_type) self.ovvo = self.feri.create_dataset('ovvo', (nocc, nvir, nvir, nocc), ds_type) self.ovvv = self.feri.create_dataset('ovvv', (nocc, nvir, nvir, nvir), ds_type) cput1 = time.clock(), time.time() # <ij||pq> = <ij|pq> - <ij|qp> = (ip|jq) - (iq|jp) tmpfile2 = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) ao2mo.general(cc.mol, (orbo, mo_coeff, mo_coeff, mo_coeff), tmpfile2.name, 'aa') with h5py.File(tmpfile2.name) as f: buf = numpy.empty((nmo, nmo, nmo)) for i in range(nocc): lib.unpack_tril(f['aa'][i * nmo:(i + 1) * nmo], out=buf) self.oooo[i] = buf[:nocc, :nocc, :nocc] self.ooov[i] = buf[:nocc, :nocc, nocc:] self.ovoo[i] = buf[nocc:, :nocc, :nocc] self.ovov[i] = buf[nocc:, :nocc, nocc:] self.oovo[i] = buf[:nocc, nocc:, :nocc] self.oovv[i] = buf[:nocc, nocc:, nocc:] self.ovvo[i] = buf[nocc:, nocc:, :nocc] self.ovvv[i] = buf[nocc:, nocc:, nocc:] del (f['aa']) buf = None cput1 = log.timer_debug1('transforming oopq, ovpq', *cput1) log.timer('GW integral transformation', *cput0)