Beispiel #1
0
    def test_pwdf_k(self):
        kpts = cell.make_kpts((2,2,2))

        numpy.random.seed(1)
        nao = cell.nao_nr()
        dm = numpy.random.random((8,nao,nao))
        mydf = pwdf.PWDF(cell)
        mydf.kpts = kpts
        mydf.auxbasis = 'weigend'
        vk = pwdf_jk.get_k_kpts(mydf, dm, 0, mydf.kpts)
        self.assertAlmostEqual(finger(vk[0]), (4.3373802352168278-0.062977052131451577j)/8, 9)
        self.assertAlmostEqual(finger(vk[1]), (2.878809181709983+0.028843869853690692j) /8, 9)
        self.assertAlmostEqual(finger(vk[2]), (3.7027622609953061-0.052034330663180237j)/8, 9)
        self.assertAlmostEqual(finger(vk[3]), (5.0939994842559422+0.060094478876149444j)/8, 9)
        self.assertAlmostEqual(finger(vk[4]), (4.2942087551592651-0.061138484763336887j)/8, 9)
        self.assertAlmostEqual(finger(vk[5]), (3.9689429688683679+0.048471952758750547j)/8, 9)
        self.assertAlmostEqual(finger(vk[6]), (3.6342630872923456-0.054892635365850449j)/8, 9)
        self.assertAlmostEqual(finger(vk[7]), (3.3483735224533548+0.040877095049528467j)/8, 9)

        numpy.random.seed(1)
        dm = numpy.random.random((8,nao,nao))
        dm = dm + dm.transpose(0,2,1)
        vk = pwdf_jk.get_k_kpts(mydf, dm, 1, mydf.kpts)
        self.assertAlmostEqual(finger(vk[0]), (8.7518173818250702-0.11793770445839372j) /8, 9)
        self.assertAlmostEqual(finger(vk[1]), (5.7682393685317894+0.069482280306391239j)/8, 9)
        self.assertAlmostEqual(finger(vk[2]), (7.1890462727492324-0.088727079644645671j)/8, 9)
        self.assertAlmostEqual(finger(vk[3]), (10.08358152800003+0.1278144339422369j   )/8, 9)
        self.assertAlmostEqual(finger(vk[4]), (8.393281242945573-0.099410704957774876j) /8, 9)
        self.assertAlmostEqual(finger(vk[5]), (7.9413682328898769+0.1015563120870652j)  /8, 9)
        self.assertAlmostEqual(finger(vk[6]), (7.3743790120272408-0.096290683129384574j)/8, 9)
        self.assertAlmostEqual(finger(vk[7]), (6.8144379626901443+0.08071261392857812j) /8, 9)
Beispiel #2
0
    def test_pwdf_k(self):
        kpts = cell.make_kpts((2, 2, 2))

        numpy.random.seed(1)
        nao = cell.nao_nr()
        dm = numpy.random.random((8, nao, nao))
        mydf = pwdf.PWDF(cell)
        mydf.kpts = kpts
        mydf.auxbasis = 'weigend'
        vk = pwdf_jk.get_k_kpts(mydf, dm, 0, mydf.kpts)
        self.assertAlmostEqual(finger(
            vk[0]), (4.3373802352168278 - 0.062977052131451577j) / 8, 9)
        self.assertAlmostEqual(finger(vk[1]),
                               (2.878809181709983 + 0.028843869853690692j) / 8,
                               9)
        self.assertAlmostEqual(finger(
            vk[2]), (3.7027622609953061 - 0.052034330663180237j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[3]), (5.0939994842559422 + 0.060094478876149444j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[4]), (4.2942087551592651 - 0.061138484763336887j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[5]), (3.9689429688683679 + 0.048471952758750547j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[6]), (3.6342630872923456 - 0.054892635365850449j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[7]), (3.3483735224533548 + 0.040877095049528467j) / 8, 9)

        numpy.random.seed(1)
        dm = numpy.random.random((8, nao, nao))
        dm = dm + dm.transpose(0, 2, 1)
        vk = pwdf_jk.get_k_kpts(mydf, dm, 1, mydf.kpts)
        self.assertAlmostEqual(finger(vk[0]),
                               (8.7518173818250702 - 0.11793770445839372j) / 8,
                               9)
        self.assertAlmostEqual(finger(
            vk[1]), (5.7682393685317894 + 0.069482280306391239j) / 8, 9)
        self.assertAlmostEqual(finger(
            vk[2]), (7.1890462727492324 - 0.088727079644645671j) / 8, 9)
        self.assertAlmostEqual(finger(vk[3]),
                               (10.08358152800003 + 0.1278144339422369j) / 8,
                               9)
        self.assertAlmostEqual(finger(vk[4]),
                               (8.393281242945573 - 0.099410704957774876j) / 8,
                               9)
        self.assertAlmostEqual(finger(vk[5]),
                               (7.9413682328898769 + 0.1015563120870652j) / 8,
                               9)
        self.assertAlmostEqual(finger(
            vk[6]), (7.3743790120272408 - 0.096290683129384574j) / 8, 9)
        self.assertAlmostEqual(finger(vk[7]),
                               (6.8144379626901443 + 0.08071261392857812j) / 8,
                               9)
Beispiel #3
0
 def test_pwdf_k1(self):
     kpts = cell.get_abs_kpts([[-.25,-.25,-.25],
                               [-.25,-.25, .25],
                               [-.25, .25,-.25],
                               [-.25, .25, .25],
                               [ .25,-.25,-.25],
                               [ .25,-.25, .25],
                               [ .25, .25,-.25],
                               [ .25, .25, .25]])
     numpy.random.seed(1)
     nao = cell.nao_nr()
     dm = numpy.random.random((8,nao,nao))
     mydf = pwdf.PWDF(cell)
     mydf.kpts = kpts
     mydf.auxbasis = 'weigend'
     numpy.random.seed(1)
     dm = numpy.random.random((8,nao,nao))
     dm = dm + dm.transpose(0,2,1)
     vk = pwdf_jk.get_k_kpts(mydf, dm, 1, mydf.kpts)
     self.assertAlmostEqual(finger(vk[0]), (8.7518173818250702-0.11793770445839372j) /8, 9)
     self.assertAlmostEqual(finger(vk[1]), (5.7682393685317894+0.069482280306391239j)/8, 9)
     self.assertAlmostEqual(finger(vk[2]), (7.1890462727492324-0.088727079644645671j)/8, 9)
     self.assertAlmostEqual(finger(vk[3]), (10.08358152800003+0.1278144339422369j   )/8, 9)
     self.assertAlmostEqual(finger(vk[4]), (8.393281242945573-0.099410704957774876j) /8, 9)
     self.assertAlmostEqual(finger(vk[5]), (7.9413682328898769+0.1015563120870652j)  /8, 9)
     self.assertAlmostEqual(finger(vk[6]), (7.3743790120272408-0.096290683129384574j)/8, 9)
     self.assertAlmostEqual(finger(vk[7]), (6.8144379626901443+0.08071261392857812j) /8, 9)
Beispiel #4
0
 def test_pwdf_k(self):
     kpts = cell.get_abs_kpts([[-.25, -.25, -.25], [-.25, -.25, .25],
                               [-.25, .25, -.25], [-.25, .25, .25],
                               [.25, -.25, -.25], [.25, -.25, .25],
                               [.25, .25, -.25], [.25, .25, .25]])
     numpy.random.seed(1)
     nao = cell.nao_nr()
     dm = numpy.random.random((8, nao, nao))
     mydf = pwdf.PWDF(cell)
     mydf.kpts = kpts
     mydf.auxbasis = 'weigend'
     vk = pwdf_jk.get_k_kpts(mydf, dm, 0, mydf.kpts)
     self.assertAlmostEqual(finger(
         vk[0]), (4.3373802352168278 - 0.062977052131451577j) / 8, 9)
     self.assertAlmostEqual(finger(vk[1]),
                            (2.878809181709983 + 0.028843869853690692j) / 8,
                            9)
     self.assertAlmostEqual(finger(
         vk[2]), (3.7027622609953061 - 0.052034330663180237j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[3]), (5.0939994842559422 + 0.060094478876149444j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[4]), (4.2942087551592651 - 0.061138484763336887j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[5]), (3.9689429688683679 + 0.048471952758750547j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[6]), (3.6342630872923456 - 0.054892635365850449j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[7]), (3.3483735224533548 + 0.040877095049528467j) / 8, 9)
Beispiel #5
0
    def get_jk(self,
               dm,
               hermi=1,
               kpts=None,
               kpt_band=None,
               with_j=True,
               with_k=True,
               exxdiv='ewald'):
        if kpts is None:
            if numpy.all(self.kpts == 0):
                # Gamma-point calculation by default
                kpts = numpy.zeros(3)
            else:
                kpts = self.kpts

        if kpts.shape == (3, ):
            return pwdf_jk.get_jk(self, dm, hermi, kpts, kpt_band, with_j,
                                  with_k, exxdiv)

        vj = vk = None
        if with_k:
            vk = pwdf_jk.get_k_kpts(self, dm, hermi, kpts, kpt_band, exxdiv)
        if with_j:
            vj = pwdf_jk.get_j_kpts(self, dm, hermi, kpts, kpt_band)
        return vj, vk
Beispiel #6
0
    def get_jk(self, dm, hermi=1, kpts=None, kpt_band=None,
               with_j=True, with_k=True, exxdiv='ewald'):
        if kpts is None:
            if numpy.all(self.kpts == 0):
                # Gamma-point calculation by default
                kpts = numpy.zeros(3)
            else:
                kpts = self.kpts

        if kpts.shape == (3,):
            return pwdf_jk.get_jk(self, dm, hermi, kpts, kpt_band, with_j,
                                  with_k, exxdiv)

        vj = vk = None
        if with_k:
            vk = pwdf_jk.get_k_kpts(self, dm, hermi, kpts, kpt_band, exxdiv)
        if with_j:
            vj = pwdf_jk.get_j_kpts(self, dm, hermi, kpts, kpt_band)
        return vj, vk
Beispiel #7
0
 def test_pwdf_k(self):
     kpts = cell.get_abs_kpts([[-.25,-.25,-.25],
                               [-.25,-.25, .25],
                               [-.25, .25,-.25],
                               [-.25, .25, .25],
                               [ .25,-.25,-.25],
                               [ .25,-.25, .25],
                               [ .25, .25,-.25],
                               [ .25, .25, .25]])
     numpy.random.seed(1)
     nao = cell.nao_nr()
     dm = numpy.random.random((8,nao,nao))
     mydf = pwdf.PWDF(cell)
     mydf.kpts = kpts
     mydf.auxbasis = 'weigend'
     vk = pwdf_jk.get_k_kpts(mydf, dm, 0, mydf.kpts)
     self.assertAlmostEqual(finger(vk[0]), (4.3373802352168278-0.062977052131451577j)/8, 9)
     self.assertAlmostEqual(finger(vk[1]), (2.878809181709983+0.028843869853690692j) /8, 9)
     self.assertAlmostEqual(finger(vk[2]), (3.7027622609953061-0.052034330663180237j)/8, 9)
     self.assertAlmostEqual(finger(vk[3]), (5.0939994842559422+0.060094478876149444j)/8, 9)
     self.assertAlmostEqual(finger(vk[4]), (4.2942087551592651-0.061138484763336887j)/8, 9)
     self.assertAlmostEqual(finger(vk[5]), (3.9689429688683679+0.048471952758750547j)/8, 9)
     self.assertAlmostEqual(finger(vk[6]), (3.6342630872923456-0.054892635365850449j)/8, 9)
     self.assertAlmostEqual(finger(vk[7]), (3.3483735224533548+0.040877095049528467j)/8, 9)
Beispiel #8
0
 def test_pwdf_k1(self):
     kpts = cell.get_abs_kpts([[-.25, -.25, -.25], [-.25, -.25, .25],
                               [-.25, .25, -.25], [-.25, .25, .25],
                               [.25, -.25, -.25], [.25, -.25, .25],
                               [.25, .25, -.25], [.25, .25, .25]])
     numpy.random.seed(1)
     nao = cell.nao_nr()
     dm = numpy.random.random((8, nao, nao))
     mydf = pwdf.PWDF(cell)
     mydf.kpts = kpts
     mydf.auxbasis = 'weigend'
     numpy.random.seed(1)
     dm = numpy.random.random((8, nao, nao))
     dm = dm + dm.transpose(0, 2, 1)
     vk = pwdf_jk.get_k_kpts(mydf, dm, 1, mydf.kpts)
     self.assertAlmostEqual(finger(vk[0]),
                            (8.7518173818250702 - 0.11793770445839372j) / 8,
                            9)
     self.assertAlmostEqual(finger(
         vk[1]), (5.7682393685317894 + 0.069482280306391239j) / 8, 9)
     self.assertAlmostEqual(finger(
         vk[2]), (7.1890462727492324 - 0.088727079644645671j) / 8, 9)
     self.assertAlmostEqual(finger(vk[3]),
                            (10.08358152800003 + 0.1278144339422369j) / 8,
                            9)
     self.assertAlmostEqual(finger(vk[4]),
                            (8.393281242945573 - 0.099410704957774876j) / 8,
                            9)
     self.assertAlmostEqual(finger(vk[5]),
                            (7.9413682328898769 + 0.1015563120870652j) / 8,
                            9)
     self.assertAlmostEqual(finger(
         vk[6]), (7.3743790120272408 - 0.096290683129384574j) / 8, 9)
     self.assertAlmostEqual(finger(vk[7]),
                            (6.8144379626901443 + 0.08071261392857812j) / 8,
                            9)
Beispiel #9
0
def get_k_kpts(mydf, dm_kpts, hermi=1, kpts=numpy.zeros((1,3)), kpt_band=None,
               exxdiv=None):
    cell = mydf.cell
    log = logger.Logger(mydf.stdout, mydf.verbose)
    t1 = (time.clock(), time.time())
    if mydf._cderi is None:
        mydf.build()
        t1 = log.timer_debug1('Init get_k_kpts', *t1)

    dm_kpts = lib.asarray(dm_kpts, order='C')
    dms = _format_dms(dm_kpts, kpts)
    nset, nkpts, nao = dms.shape[:3]
    naux = mydf.auxcell.nao_nr()
    nao_pair = nao * (nao+1) // 2

    if kpt_band is None:
        kpts_band = kpts
        swap_2e = True
    else:
        kpts_band = numpy.reshape(kpt_band, (-1,3))
    nband = len(kpts_band)
    kk_table = kpts_band.reshape(-1,1,3) - kpts.reshape(1,-1,3)
    kk_todo = numpy.ones(kk_table.shape[:2], dtype=bool)
    vkR = numpy.zeros((nset,nband,nao,nao))
    vkI = numpy.zeros((nset,nband,nao,nao))
    dmsR = numpy.asarray(dms.real, order='C')
    dmsI = numpy.asarray(dms.imag, order='C')

    mem_now = lib.current_memory()[0]
    max_memory = max(2000, (mydf.max_memory - mem_now)) * .8
    log.debug1('max_memory = %d MB (%d in use)', max_memory, mem_now)
    # K_pq = ( p{k1} i{k2} | i{k2} q{k1} )
    def make_kpt(kpt):  # kpt = kptj - kpti
        # search for all possible ki and kj that has ki-kj+kpt=0
        kk_match = numpy.einsum('ijx->ij', abs(kk_table + kpt)) < 1e-9
        kpti_idx, kptj_idx = numpy.where(kk_todo & kk_match)
        nkptj = len(kptj_idx)
        kk_todo[kpti_idx,kptj_idx] = False
        if swap_2e and not is_zero(kpt):
            kk_todo[kptj_idx,kpti_idx] = False

        # Note: kj-ki for electorn 1 and ki-kj for electron 2
        # j2c ~ ({kj-ki}|{ks-kr}) ~ ({kj-ki}|-{kj-ki}) ~ ({kj-ki}|{ki-kj})
        # j3c ~ (Q|kj,ki) = j3c{ji} = (Q|ki,kj)* = conj(transpose(j3c{ij}, (0,2,1)))

        bufR = numpy.empty((mydf.blockdim*nao**2))
        bufI = numpy.empty((mydf.blockdim*nao**2))
        for ki,kj in zip(kpti_idx,kptj_idx):
            kpti = kpts_band[ki]
            kptj = kpts[kj]
            kptij = numpy.asarray((kpti,kptj))
            for LpqR, LpqI, j3cR, j3cI in mydf.sr_loop(kptij, max_memory, False):
                nrow = LpqR.shape[0]
                pLqR = numpy.ndarray((nao,nrow,nao), buffer=bufR)
                pLqI = numpy.ndarray((nao,nrow,nao), buffer=bufI)
                pjqR = numpy.ndarray((nao,nrow,nao), buffer=LpqR)
                pjqI = numpy.ndarray((nao,nrow,nao), buffer=LpqI)
                tmpR = numpy.ndarray((nao,nrow*nao), buffer=j3cR)
                tmpI = numpy.ndarray((nao,nrow*nao), buffer=j3cI)
                pLqR[:] = LpqR.reshape(-1,nao,nao).transpose(1,0,2)
                pLqI[:] = LpqI.reshape(-1,nao,nao).transpose(1,0,2)
                pjqR[:] = j3cR.reshape(-1,nao,nao).transpose(1,0,2)
                pjqI[:] = j3cI.reshape(-1,nao,nao).transpose(1,0,2)

                #:Lpq = LpqR + LpqI*1j
                #:j3c = j3cR + j3cI*1j
                #:for i in range(nset):
                #:    dm = dms[i,ki]
                #:    tmp = numpy.dot(dm, j3c.reshape(nao,-1))
                #:    vk1 = numpy.dot(Lpq.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
                #:    tmp = numpy.dot(dm, Lpq.reshape(nao,-1))
                #:    vk1+= numpy.dot(j3c.reshape(-1,nao).conj().T, tmp.reshape(-1,nao))
                #:    vkR[i,kj] += vk1.real
                #:    vkI[i,kj] += vk1.imag

                #:if swap_2e and not is_zero(kpt):
                #:    # K ~ 'Lij,Llk*,jk->il' + 'Llk*,Lij,jk->il'
                #:    for i in range(nset):
                #:        dm = dms[i,kj]
                #:        tmp = numpy.dot(j3c.reshape(-1,nao), dm)
                #:        vk1 = numpy.dot(tmp.reshape(nao,-1), Lpq.reshape(nao,-1).conj().T)
                #:        tmp = numpy.dot(Lpq.reshape(-1,nao), dm)
                #:        vk1+= numpy.dot(tmp.reshape(nao,-1), j3c.reshape(nao,-1).conj().T)
                #:        vkR[i,ki] += vk1.real
                #:        vkI[i,ki] += vk1.imag

                # K ~ 'iLj,lLk*,li->kj' + 'lLk*,iLj,li->kj'
                for i in range(nset):
                    tmpR, tmpI = zdotNN(dmsR[i,ki], dmsI[i,ki], pjqR.reshape(nao,-1),
                                        pjqI.reshape(nao,-1), 1, tmpR, tmpI)
                    vk1R, vk1I = zdotCN(pLqR.reshape(-1,nao).T, pLqI.reshape(-1,nao).T,
                                        tmpR.reshape(-1,nao), tmpI.reshape(-1,nao))
                    vkR[i,kj] += vk1R
                    vkI[i,kj] += vk1I
                    if hermi:
                        vkR[i,kj] += vk1R.T
                        vkI[i,kj] -= vk1I.T
                    else:
                        tmpR, tmpI = zdotNN(dmsR[i,ki], dmsI[i,ki], pLqR.reshape(nao,-1),
                                            pLqI.reshape(nao,-1), 1, tmpR, tmpI)
                        zdotCN(pjqR.reshape(-1,nao).T, pjqI.reshape(-1,nao).T,
                               tmpR.reshape(-1,nao), tmpI.reshape(-1,nao),
                               1, vkR[i,kj], vkI[i,kj], 1)

                if swap_2e and not is_zero(kpt):
                    tmpR = tmpR.reshape(nao*nrow,nao)
                    tmpI = tmpI.reshape(nao*nrow,nao)
                    # K ~ 'iLj,lLk*,jk->il' + 'lLk*,iLj,jk->il'
                    for i in range(nset):
                        tmpR, tmpI = zdotNN(pjqR.reshape(-1,nao), pjqI.reshape(-1,nao),
                                            dmsR[i,kj], dmsI[i,kj], 1, tmpR, tmpI)
                        vk1R, vk1I = zdotNC(tmpR.reshape(nao,-1), tmpI.reshape(nao,-1),
                                            pLqR.reshape(nao,-1).T, pLqI.reshape(nao,-1).T)
                        vkR[i,ki] += vk1R
                        vkI[i,ki] += vk1I
                        if hermi:
                            vkR[i,ki] += vk1R.T
                            vkI[i,ki] -= vk1I.T
                        else:
                            tmpR, tmpI = zdotNN(pLqR.reshape(-1,nao), pLqI.reshape(-1,nao),
                                                dmsR[i,kj], dmsI[i,kj], 1, tmpR, tmpI)
                            zdotNC(tmpR.reshape(nao,-1), tmpI.reshape(nao,-1),
                                   pjqR.reshape(nao,-1).T, pjqI.reshape(nao,-1).T,
                                   1, vkR[i,ki], vkI[i,ki], 1)
                LpqR = LpqI = j3cR = j3cI = tmpR = tmpI = None
        return None

    for ki, kpti in enumerate(kpts_band):
        for kj, kptj in enumerate(kpts):
            if kk_todo[ki,kj]:
                make_kpt(kptj-kpti)
    vkR *= 1./nkpts
    vkI *= 1./nkpts

    vk_kpts = pwdf_jk.get_k_kpts(mydf, dm_kpts, hermi, kpts, kpt_band, exxdiv)

    if (gamma_point(kpts) and gamma_point(kpts_band) and
        not numpy.iscomplexobj(dm_kpts)):
        vk_kpts += vkR.reshape(vk_kpts.shape)
    else:
        vk_kpts += (vkR+vkI*1j).reshape(vk_kpts.shape)
    return vk_kpts