Exemple #1
0
def make_theta(t2, out=None):
    return _ccsd.make_0132(t2, t2, -1, 2, out)
Exemple #2
0
def make_theta(t2):
    return _ccsd.make_0132(t2, t2, 2, -1)
Exemple #3
0
def make_theta(t2, out=None):
    return _ccsd.make_0132(t2, t2, 2, -1, out)
Exemple #4
0
def make_theta(t2):
    return _ccsd.make_0132(t2, t2, 2, -1)
Exemple #5
0
def update_amps(mycc, t1, t2, l1, l2, eris=None, saved=None):
    if saved is None:
        saved = make_intermediates(mycc, t1, t2, eris)
    time1 = time0 = time.clock(), time.time()
    log = logger.Logger(mycc.stdout, mycc.verbose)
    nocc, nvir = t1.shape
    nov = nocc * nvir
    foo = eris.fock[:nocc, :nocc]
    fov = eris.fock[:nocc, nocc:]
    fvv = eris.fock[:nocc, :nocc]

    #:mba = numpy.einsum('klca,klcb->ba', l2, t2*2-t2.transpose(0,1,3,2))
    #:mij = numpy.einsum('ikcd,jkcd->ij', l2, t2*2-t2.transpose(0,1,3,2))
    #:theta = t2*2 - t2.transpose(0,1,3,2)
    theta = _ccsd.make_0132(t2, t2, 2, -1)
    mba = lib.dot(theta.reshape(-1, nvir).T, l2.reshape(-1, nvir))
    mij = lib.dot(l2.reshape(nocc, -1), theta.reshape(nocc, -1).T)
    theta = None
    mba1 = numpy.einsum("jc,jb->bc", l1, t1) + mba
    mij1 = numpy.einsum("kb,jb->kj", l1, t1) + mij
    mia1 = (
        t1
        + numpy.einsum("kc,jkbc->jb", l1, t2) * 2
        - numpy.einsum("kc,jkcb->jb", l1, t2)
        - reduce(numpy.dot, (t1, l1.T, t1))
        - numpy.einsum("bd,jd->jb", mba, t1)
        - numpy.einsum("lj,lb->jb", mij, t1)
    )

    tmp = mycc.add_wvvVV(numpy.zeros_like(l1), l2, eris)
    l2new = numpy.empty((nocc, nocc, nvir, nvir))
    ij = 0
    for i in range(nocc):
        for j in range(i):
            tmp1 = tmp[ij] * 0.5  # *.5 because of l2+l2.transpose(1,0,3,2) later
            l2new[i, j] = tmp1
            l2new[j, i] = tmp1.T
            ij += 1
        l2new[i, i] = tmp[ij] * 0.5
        ij += 1
    l1new = numpy.einsum("ijab,jb->ia", l2new, t1) * 4 - numpy.einsum("jiab,jb->ia", l2new, t1) * 2
    tmp = tmp1 = None

    l1new += fov
    l1new += numpy.einsum("ib,ba->ia", l1, saved.w1)
    l1new -= numpy.einsum("ja,ij->ia", l1, saved.w2)
    l1new -= numpy.einsum("ik,ka->ia", mij, saved.w4)
    l1new -= numpy.einsum("ca,ic->ia", mba, saved.w4)
    l1new += numpy.einsum("ijab,bj->ia", l2, saved.w3) * 2
    l1new -= numpy.einsum("ijba,bj->ia", l2, saved.w3)

    l2new += numpy.einsum("ia,jb->ijab", l1, saved.w4)
    #:l2new += numpy.einsum('jibc,ca->jiba', l2, saved.w1)
    #:l2new -= numpy.einsum('kiba,jk->jiba', l2, saved.w2)
    lib.dot(l2.reshape(-1, nvir), saved.w1, 1, l2new.reshape(-1, nvir), 1)
    lib.dot(saved.w2, l2.reshape(nocc, -1), -1, l2new.reshape(nocc, -1), 1)

    eris_ooov = _cp(eris.ooov)
    l1new -= numpy.einsum("jkia,kj->ia", eris_ooov, mij1) * 2
    l1new += numpy.einsum("ikja,kj->ia", eris_ooov, mij1)
    #:l2new -= numpy.einsum('ka,kijb->jiba', l1, eris_ooov)
    lib.dot(_cp(eris_ooov.transpose(0, 2, 1, 3).reshape(nocc, -1)).T, l1, -1, l2new.reshape(-1, nvir), 1)
    eris_ooov = None

    tau = _ccsd.make_tau(t2, t1, t1)
    #:l2tau = numpy.einsum('ijcd,klcd->ijkl', l2, tau)
    l2tau = lib.dot(l2.reshape(nocc ** 2, -1), tau.reshape(nocc ** 2, -1).T).reshape((nocc,) * 4)
    tau = None
    #:l2t1 = numpy.einsum('jidc,kc->ijkd', l2, t1)
    l2t1 = lib.dot(l2.reshape(-1, nvir), t1.T).reshape(nocc, nocc, nvir, nocc)
    l2t1 = _cp(l2t1.transpose(1, 0, 3, 2))

    max_memory = mycc.max_memory - lib.current_memory()[0]
    unit = max(nvir ** 3 * 2 + nocc * nvir ** 2, nocc * nvir ** 2 * 5)
    blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory * 0.95e6 / 8 / unit)))
    log.debug1(
        "block size = %d, nocc = %d is divided into %d blocks", blksize, nocc, int((nocc + blksize - 1) / blksize)
    )
    for p0, p1 in prange(0, nocc, blksize):
        eris_ovvv = _cp(eris.ovvv[p0:p1])
        eris_ovvv = lib.unpack_tril(eris_ovvv.reshape((p1 - p0) * nvir, -1))
        eris_ovvv = eris_ovvv.reshape(p1 - p0, nvir, nvir, nvir)

        l1new[p0:p1] += numpy.einsum("iabc,bc->ia", eris_ovvv, mba1) * 2
        l1new[p0:p1] -= numpy.einsum("ibca,bc->ia", eris_ovvv, mba1)
        #:l2new[p0:p1] += numpy.einsum('ic,jbac->jiba', l1, eris_ovvv)
        tmp = lib.dot(l1, eris_ovvv.reshape(-1, nvir).T)
        l2new[p0:p1] += tmp.reshape(nocc, -1, nvir, nvir).transpose(1, 0, 2, 3)
        tmp = None
        m4buf = numpy.empty((blksize, nocc, nvir, nvir))
        eris_ovvv = _cp(eris_ovvv.transpose(0, 2, 1, 3).reshape(-1, nvir ** 2))
        for j0, j1 in prange(0, nocc, blksize):
            #:m4 = numpy.einsum('ijkd,kadb->ijab', l2t1[j0:j1,:,p0:p1], eris_ovvv)
            m4 = m4buf[: j1 - j0]
            lib.dot(_cp(l2t1[j0:j1, :, p0:p1].reshape((j1 - j0) * nocc, -1)), eris_ovvv, 1, m4.reshape(-1, nvir ** 2))
            l2new[j0:j1] -= m4
            l1new[j0:j1] -= numpy.einsum("ijab,jb->ia", m4, t1) * 2
            l1new -= numpy.einsum("ijab,ia->jb", m4, t1[j0:j1]) * 2
            l1new += numpy.einsum("jiab,jb->ia", m4, t1[j0:j1])
            l1new[j0:j1] += numpy.einsum("jiab,ia->jb", m4, t1)
        eris_ovvv = m4buf = m4 = None
        # ==== mem usage nvir**3*2 + nocc*nvir**2

        eris_ovov = _cp(eris.ovov[p0:p1])
        l1new[p0:p1] += numpy.einsum("jb,iajb->ia", l1, eris_ovov) * 2
        for i in range(p1 - p0):
            l2new[p0 + i] += eris_ovov[i].transpose(1, 0, 2) * 0.5
        #:l2new[p0:p1] -= numpy.einsum('icjb,ca->ijab', eris_ovov, mba1)
        #:l2new[p0:p1] -= numpy.einsum('jbka,ik->jiba', eris_ovov, mij1)
        tmp = numpy.empty((nocc, nvir, nvir))
        for j in range(p0, p1):
            lib.dot(eris_ovov[j - p0].reshape(nvir, -1).T, mba1, 1, tmp.reshape(-1, nvir))
            l2new[j] -= tmp.transpose(0, 2, 1)
            lib.dot(
                mij1, _cp(eris_ovov[j - p0].transpose(1, 0, 2).reshape(nocc, -1)), -1, l2new[j].reshape(nocc, -1), 1
            )
        tmp = None
        l1new[p0:p1] += numpy.einsum("iajb,jb->ia", eris_ovov, mia1) * 2
        l1new[p0:p1] -= numpy.einsum("ibja,jb->ia", eris_ovov, mia1)
        m4buf = numpy.empty((blksize, nocc, nvir, nvir))
        for j0, j1 in prange(0, nocc, blksize):
            #:m4 = numpy.einsum('kalb,ijkl->ijab', eris_ovov, l2tau[j0:j1,:,p0:p1])
            m4 = m4buf[: j1 - j0]
            lib.dot(
                l2tau[j0:j1, :, p0:p1].reshape((j1 - j0) * nocc, -1).copy(),
                _cp(eris_ovov.transpose(0, 2, 1, 3).reshape(-1, nvir ** 2)),
                0.5,
                m4.reshape(-1, nvir ** 2),
            )
            l2new[j0:j1] += m4
            l1new[j0:j1] += numpy.einsum("ijab,jb->ia", m4, t1) * 4
            l1new[j0:j1] -= numpy.einsum("ijba,jb->ia", m4, t1) * 2
        eris_ovov = m4buf = m4 = None
        # ==== mem usage nocc*nvir**2 * 3

        eris_oovv = _cp(eris.oovv[p0:p1])
        l1new[p0:p1] -= numpy.einsum("jb,ijba->ia", l1, eris_oovv)
        eris_oovv = None

        saved_wooov = _cp(saved.wooov[p0:p1])
        #:l1new[p0:p1] -= numpy.einsum('jkca,ijkc->ia', l2, saved_wooov)
        l1new[p0:p1] -= lib.dot(saved_wooov.reshape(p1 - p0, -1), l2.reshape(-1, nvir))
        saved_wovvv = _cp(saved.wovvv[p0:p1])
        #:l1new += numpy.einsum('kibc,kabc->ia', l2[p0:p1], saved_wovvv)
        for j in range(p1 - p0):
            lib.dot(l2[p0 + j].reshape(nocc, -1), saved_wovvv[j].reshape(nvir, -1).T, 1, l1new, 1)
        saved_wooov = saved_wovvv = None
        # ==== mem usage nvir**3 + nocc**2*nvir

        saved_wOvOv = _cp(saved.wOvOv[p0:p1])
        tmp_ovov = _cp(saved.wOVov[p0:p1]) * 2
        tmp_ovov += saved_wOvOv
        tmp_ovov = lib.transpose(tmp_ovov.reshape(-1, nov)).reshape(nocc, nvir, -1, nvir)
        tmp1 = numpy.empty((p1 - p0, nvir, nocc, nvir))
        tmp = numpy.empty((blksize, nvir, nocc, nvir))
        for j0, j1 in prange(0, nocc, blksize):
            #:tmp = l2[j0:j1].transpose(0,2,1,3) - l2[j0:j1].transpose(0,3,1,2)*.5
            #:l2new[p0:p1] += numpy.einsum('kcia,kcjb->jiba', tmp, tmp_ovov[j0:j1])
            for i in range(j1 - j0):
                tmp[i] = -0.5 * l2[j0 + i].transpose(2, 0, 1)
                tmp[i] += l2[j0 + i].transpose(1, 0, 2)
            lib.dot(
                tmp_ovov[j0:j1].reshape((j1 - j0) * nvir, -1).T,
                tmp[: j1 - j0].reshape((j1 - j0) * nvir, -1),
                1,
                tmp1.reshape(-1, nov),
            )
            l2new[p0:p1] += tmp1.transpose(0, 2, 1, 3)
        tmp = tmp1 = tmp_ovov = None
        # ==== mem usage nocc*nvir**2 * 5

        #:tmp = numpy.einsum('jkca,ibkc->ijab', l2, saved_wOvOv)
        tmp = numpy.empty((p1 - p0, nvir, nvir))
        for j in range(nocc):
            lib.dot(saved_wOvOv.reshape(-1, nov), l2[j].reshape(nov, -1), 1, tmp.reshape(-1, nvir))
            l2new[p0:p1, j] += tmp.transpose(0, 2, 1)
            l2new[p0:p1, j] += tmp * 0.5
        saved_wOvOv = tmp = None

        saved_woooo = _cp(saved.woooo[p0:p1])
        #:m3 = numpy.einsum('klab,ijkl->ijab', l2, saved_woooo)
        m3 = lib.dot(saved_woooo.reshape(-1, nocc ** 2), l2.reshape(nocc ** 2, -1), 0.5).reshape(-1, nocc, nvir, nvir)
        l2new[p0:p1] += m3
        l1new[p0:p1] += numpy.einsum("ijab,jb->ia", m3, t1) * 4
        l1new[p0:p1] -= numpy.einsum("ijba,jb->ia", m3, t1) * 2
        saved_woooo = m3 = None
        time1 = log.timer_debug1("lambda pass [%d:%d]" % (p0, p1), *time1)

    mo_e = eris.fock.diagonal()
    eia = lib.direct_sum("i-a->ia", mo_e[:nocc], mo_e[nocc:])
    l1new /= eia
    l1new += l1

    #    l2new = l2new + l2new.transpose(1,0,3,2)
    #    l2new /= lib.direct_sum('ia+jb->ijab', eia, eia)
    #    l2new += l2
    ij = 0
    for i in range(nocc):
        for j in range(i):
            dab = lib.direct_sum("a+b->ab", eia[i], eia[j])
            tmp = (l2new[i, j] + l2new[j, i].T) / dab + l2[i, j]
            l2new[i, j] = tmp
            l2new[j, i] = tmp.T
            ij += 1
        dab = lib.direct_sum("a+b->ab", eia[i], eia[i])
        l2new[i, i] = (l2new[i, i] + l2new[i, i].T) / dab + l2[i, i]
        ij += 1

    time0 = log.timer_debug1("update l1 l2", *time0)
    return l1new, l2new
Exemple #6
0
def update_amps(mycc, t1, t2, l1, l2, eris=None, saved=None, max_memory=2000):
    if saved is None:
        saved = make_intermediates(mycc, t1, t2, eris)
    time1 = time0 = time.clock(), time.time()
    log = logger.Logger(mycc.stdout, mycc.verbose)
    nocc, nvir = t1.shape
    nov = nocc * nvir
    foo = eris.fock[:nocc, :nocc]
    fov = eris.fock[:nocc, nocc:]
    fvv = eris.fock[:nocc, :nocc]

    #:mba = numpy.einsum('klca,klcb->ba', l2, t2*2-t2.transpose(0,1,3,2))
    #:mij = numpy.einsum('ikcd,jkcd->ij', l2, t2*2-t2.transpose(0,1,3,2))
    #:theta = t2*2 - t2.transpose(0,1,3,2)
    theta = _ccsd.make_0132(t2, t2, 2, -1)
    mba = lib.dot(theta.reshape(-1, nvir).T, l2.reshape(-1, nvir))
    mij = lib.dot(l2.reshape(nocc, -1), theta.reshape(nocc, -1).T)
    theta = None
    mba1 = numpy.einsum('jc,jb->bc', l1, t1) + mba
    mij1 = numpy.einsum('kb,jb->kj', l1, t1) + mij
    mia1 = (t1 + numpy.einsum('kc,jkbc->jb', l1, t2) * 2 -
            numpy.einsum('kc,jkcb->jb', l1, t2) -
            reduce(numpy.dot,
                   (t1, l1.T, t1)) - numpy.einsum('bd,jd->jb', mba, t1) -
            numpy.einsum('lj,lb->jb', mij, t1))

    tmp = mycc.add_wvvVV(numpy.zeros_like(l1), l2, eris, max_memory)
    l2new = numpy.empty((nocc, nocc, nvir, nvir))
    ij = 0
    for i in range(nocc):
        for j in range(i):
            tmp1 = tmp[ij] * .5  # *.5 because of l2+l2.transpose(1,0,3,2) later
            l2new[i, j] = tmp1
            l2new[j, i] = tmp1.T
            ij += 1
        l2new[i, i] = tmp[ij] * .5
        ij += 1
    l1new = (numpy.einsum('ijab,jb->ia', l2new, t1) * 4 -
             numpy.einsum('jiab,jb->ia', l2new, t1) * 2)
    tmp = tmp1 = None

    l1new += fov
    l1new += numpy.einsum('ib,ba->ia', l1, saved.w1)
    l1new -= numpy.einsum('ja,ij->ia', l1, saved.w2)
    l1new -= numpy.einsum('ik,ka->ia', mij, saved.w4)
    l1new -= numpy.einsum('ca,ic->ia', mba, saved.w4)
    l1new += numpy.einsum('ijab,bj->ia', l2, saved.w3) * 2
    l1new -= numpy.einsum('ijba,bj->ia', l2, saved.w3)

    l2new += numpy.einsum('ia,jb->ijab', l1, saved.w4)
    #:l2new += numpy.einsum('jibc,ca->jiba', l2, saved.w1)
    #:l2new -= numpy.einsum('kiba,jk->jiba', l2, saved.w2)
    lib.dot(l2.reshape(-1, nvir), saved.w1, 1, l2new.reshape(-1, nvir), 1)
    lib.dot(saved.w2, l2.reshape(nocc, -1), -1, l2new.reshape(nocc, -1), 1)

    eris_ooov = _cp(eris.ooov)
    l1new -= numpy.einsum('jkia,kj->ia', eris_ooov, mij1) * 2
    l1new += numpy.einsum('ikja,kj->ia', eris_ooov, mij1)
    #:l2new -= numpy.einsum('ka,kijb->jiba', l1, eris_ooov)
    lib.dot(
        _cp(eris_ooov.transpose(0, 2, 1, 3).reshape(nocc, -1)).T, l1, -1,
        l2new.reshape(-1, nvir), 1)
    eris_ooov = None

    tau = _ccsd.make_tau(t2, t1, t1)
    #:l2tau = numpy.einsum('ijcd,klcd->ijkl', l2, tau)
    l2tau = lib.dot(l2.reshape(nocc**2, -1),
                    tau.reshape(nocc**2, -1).T).reshape((nocc, ) * 4)
    tau = None
    #:l2t1 = numpy.einsum('jidc,kc->ijkd', l2, t1)
    l2t1 = lib.dot(l2.reshape(-1, nvir), t1.T).reshape(nocc, nocc, nvir, nocc)
    l2t1 = _cp(l2t1.transpose(1, 0, 3, 2))

    max_memory = max_memory - lib.current_memory()[0]
    unit = max(nvir**3 * 2 + nocc * nvir**2, nocc * nvir**2 * 5)
    blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory * .95e6 / 8 / unit)))
    log.debug1('block size = %d, nocc = %d is divided into %d blocks', blksize,
               nocc, int((nocc + blksize - 1) / blksize))
    for p0, p1 in prange(0, nocc, blksize):
        eris_ovvv = _cp(eris.ovvv[p0:p1])
        eris_ovvv = _ccsd.unpack_tril(eris_ovvv.reshape((p1 - p0) * nvir, -1))
        eris_ovvv = eris_ovvv.reshape(p1 - p0, nvir, nvir, nvir)

        l1new[p0:p1] += numpy.einsum('iabc,bc->ia', eris_ovvv, mba1) * 2
        l1new[p0:p1] -= numpy.einsum('ibca,bc->ia', eris_ovvv, mba1)
        #:l2new[p0:p1] += numpy.einsum('ic,jbac->jiba', l1, eris_ovvv)
        tmp = lib.dot(l1, eris_ovvv.reshape(-1, nvir).T)
        l2new[p0:p1] += tmp.reshape(nocc, -1, nvir, nvir).transpose(1, 0, 2, 3)
        tmp = None
        m4buf = numpy.empty((blksize, nocc, nvir, nvir))
        eris_ovvv = _cp(eris_ovvv.transpose(0, 2, 1, 3).reshape(-1, nvir**2))
        for j0, j1 in prange(0, nocc, blksize):
            #:m4 = numpy.einsum('ijkd,kadb->ijab', l2t1[j0:j1,:,p0:p1], eris_ovvv)
            m4 = m4buf[:j1 - j0]
            lib.dot(_cp(l2t1[j0:j1, :, p0:p1].reshape((j1 - j0) * nocc, -1)),
                    eris_ovvv, 1, m4.reshape(-1, nvir**2))
            l2new[j0:j1] -= m4
            l1new[j0:j1] -= numpy.einsum('ijab,jb->ia', m4, t1) * 2
            l1new -= numpy.einsum('ijab,ia->jb', m4, t1[j0:j1]) * 2
            l1new += numpy.einsum('jiab,jb->ia', m4, t1[j0:j1])
            l1new[j0:j1] += numpy.einsum('jiab,ia->jb', m4, t1)
        eris_ovvv = m4buf = m4 = None
        #==== mem usage nvir**3*2 + nocc*nvir**2

        eris_ovov = _cp(eris.ovov[p0:p1])
        l1new[p0:p1] += numpy.einsum('jb,iajb->ia', l1, eris_ovov) * 2
        for i in range(p1 - p0):
            l2new[p0 + i] += eris_ovov[i].transpose(1, 0, 2) * .5
        #:l2new[p0:p1] -= numpy.einsum('icjb,ca->ijab', eris_ovov, mba1)
        #:l2new[p0:p1] -= numpy.einsum('jbka,ik->jiba', eris_ovov, mij1)
        tmp = numpy.empty((nocc, nvir, nvir))
        for j in range(p0, p1):
            lib.dot(eris_ovov[j - p0].reshape(nvir, -1).T, mba1, 1,
                    tmp.reshape(-1, nvir))
            l2new[j] -= tmp.transpose(0, 2, 1)
            lib.dot(
                mij1,
                _cp(eris_ovov[j - p0].transpose(1, 0, 2).reshape(nocc, -1)),
                -1, l2new[j].reshape(nocc, -1), 1)
        tmp = None
        l1new[p0:p1] += numpy.einsum('iajb,jb->ia', eris_ovov, mia1) * 2
        l1new[p0:p1] -= numpy.einsum('ibja,jb->ia', eris_ovov, mia1)
        m4buf = numpy.empty((blksize, nocc, nvir, nvir))
        for j0, j1 in prange(0, nocc, blksize):
            #:m4 = numpy.einsum('kalb,ijkl->ijab', eris_ovov, l2tau[j0:j1,:,p0:p1])
            m4 = m4buf[:j1 - j0]
            lib.dot(
                l2tau[j0:j1, :, p0:p1].reshape((j1 - j0) * nocc, -1).copy(),
                _cp(eris_ovov.transpose(0, 2, 1, 3).reshape(-1, nvir**2)), .5,
                m4.reshape(-1, nvir**2))
            l2new[j0:j1] += m4
            l1new[j0:j1] += numpy.einsum('ijab,jb->ia', m4, t1) * 4
            l1new[j0:j1] -= numpy.einsum('ijba,jb->ia', m4, t1) * 2
        eris_ovov = m4buf = m4 = None
        #==== mem usage nocc*nvir**2 * 3

        eris_oovv = _cp(eris.oovv[p0:p1])
        l1new[p0:p1] -= numpy.einsum('jb,ijba->ia', l1, eris_oovv)
        eris_oovv = None

        saved_wooov = _cp(saved.wooov[p0:p1])
        #:l1new[p0:p1] -= numpy.einsum('jkca,ijkc->ia', l2, saved_wooov)
        l1new[p0:p1] -= lib.dot(saved_wooov.reshape(p1 - p0, -1),
                                l2.reshape(-1, nvir))
        saved_wovvv = _cp(saved.wovvv[p0:p1])
        #:l1new += numpy.einsum('kibc,kabc->ia', l2[p0:p1], saved_wovvv)
        for j in range(p1 - p0):
            lib.dot(l2[p0 + j].reshape(nocc, -1),
                    saved_wovvv[j].reshape(nvir, -1).T, 1, l1new, 1)
        saved_wooov = saved_wovvv = None
        #==== mem usage nvir**3 + nocc**2*nvir

        saved_wOvOv = _cp(saved.wOvOv[p0:p1])
        tmp_ovov = _cp(saved.wOVov[p0:p1]) * 2
        tmp_ovov += saved_wOvOv
        tmp_ovov = lib.transpose(tmp_ovov.reshape(-1, nov)).reshape(
            nocc, nvir, -1, nvir)
        tmp1 = numpy.empty((p1 - p0, nvir, nocc, nvir))
        tmp = numpy.empty((blksize, nvir, nocc, nvir))
        for j0, j1 in prange(0, nocc, blksize):
            #:tmp = l2[j0:j1].transpose(0,2,1,3) - l2[j0:j1].transpose(0,3,1,2)*.5
            #:l2new[p0:p1] += numpy.einsum('kcia,kcjb->jiba', tmp, tmp_ovov[j0:j1])
            for i in range(j1 - j0):
                tmp[i] = -.5 * l2[j0 + i].transpose(2, 0, 1)
                tmp[i] += l2[j0 + i].transpose(1, 0, 2)
            lib.dot(tmp_ovov[j0:j1].reshape((j1 - j0) * nvir, -1).T,
                    tmp[:j1 - j0].reshape((j1 - j0) * nvir, -1), 1,
                    tmp1.reshape(-1, nov))
            l2new[p0:p1] += tmp1.transpose(0, 2, 1, 3)
        tmp = tmp1 = tmp_ovov = None
        #==== mem usage nocc*nvir**2 * 5

        #:tmp = numpy.einsum('jkca,ibkc->ijab', l2, saved_wOvOv)
        tmp = numpy.empty((p1 - p0, nvir, nvir))
        for j in range(nocc):
            lib.dot(saved_wOvOv.reshape(-1, nov), l2[j].reshape(nov, -1), 1,
                    tmp.reshape(-1, nvir))
            l2new[p0:p1, j] += tmp.transpose(0, 2, 1)
            l2new[p0:p1, j] += tmp * .5
        saved_wOvOv = tmp = None

        saved_woooo = _cp(saved.woooo[p0:p1])
        #:m3 = numpy.einsum('klab,ijkl->ijab', l2, saved_woooo)
        m3 = lib.dot(saved_woooo.reshape(-1, nocc**2), l2.reshape(nocc**2, -1),
                     .5).reshape(-1, nocc, nvir, nvir)
        l2new[p0:p1] += m3
        l1new[p0:p1] += numpy.einsum('ijab,jb->ia', m3, t1) * 4
        l1new[p0:p1] -= numpy.einsum('ijba,jb->ia', m3, t1) * 2
        saved_woooo = m3 = None
        time1 = log.timer_debug1('lambda pass [%d:%d]' % (p0, p1), *time1)

    mo_e = eris.fock.diagonal()
    eia = lib.direct_sum('i-a->ia', mo_e[:nocc], mo_e[nocc:])
    l1new /= eia
    l1new += l1

    #    l2new = l2new + l2new.transpose(1,0,3,2)
    #    l2new /= lib.direct_sum('ia+jb->ijab', eia, eia)
    #    l2new += l2
    ij = 0
    for i in range(nocc):
        for j in range(i):
            dab = lib.direct_sum('a+b->ab', eia[i], eia[j])
            tmp = (l2new[i, j] + l2new[j, i].T) / dab + l2[i, j]
            l2new[i, j] = tmp
            l2new[j, i] = tmp.T
            ij += 1
        dab = lib.direct_sum('a+b->ab', eia[i], eia[i])
        l2new[i, i] = (l2new[i, i] + l2new[i, i].T) / dab + l2[i, i]
        ij += 1

    time0 = log.timer_debug1('update l1 l2', *time0)
    return l1new, l2new
Exemple #7
0
def update_amps(mycc, t1, t2, l1, l2, eris=None, saved=None):
    if saved is None:
        saved = make_intermediates(mycc, t1, t2, eris)
    time1 = time0 = time.clock(), time.time()
    log = logger.Logger(mycc.stdout, mycc.verbose)
    nocc, nvir = t1.shape
    nov = nocc * nvir
    foo = eris.fock[:nocc,:nocc]
    fov = eris.fock[:nocc,nocc:]
    fvv = eris.fock[:nocc,:nocc]

    #:mba = numpy.einsum('klca,klcb->ba', l2, t2*2-t2.transpose(0,1,3,2))
    #:mij = numpy.einsum('ikcd,jkcd->ij', l2, t2*2-t2.transpose(0,1,3,2))
    #:theta = t2*2 - t2.transpose(0,1,3,2)
    theta = _ccsd.make_0132(t2, t2, 2, -1)
    mba = lib.dot(theta.reshape(-1,nvir).T, l2.reshape(-1,nvir))
    mij = lib.dot(l2.reshape(nocc,-1), theta.reshape(nocc,-1).T)
    theta = None
    mba1 = numpy.einsum('jc,jb->bc', l1, t1) + mba
    mij1 = numpy.einsum('kb,jb->kj', l1, t1) + mij
    mia1 =(t1 + numpy.einsum('kc,jkbc->jb', l1, t2) * 2
         - numpy.einsum('kc,jkcb->jb', l1, t2)
         - reduce(numpy.dot, (t1, l1.T, t1))
         - numpy.einsum('bd,jd->jb', mba, t1)
         - numpy.einsum('lj,lb->jb', mij, t1))

    tmp = mycc.add_wvvVV(numpy.zeros_like(l1), l2, eris)
    l2new = numpy.empty((nocc,nocc,nvir,nvir))
    ij = 0
    for i in range(nocc):
        for j in range(i):
            tmp1 = tmp[ij] * .5  # *.5 because of l2+l2.transpose(1,0,3,2) later
            l2new[i,j] = tmp1
            l2new[j,i] = tmp1.T
            ij += 1
        l2new[i,i] = tmp[ij] * .5
        ij += 1
    l1new =(numpy.einsum('ijab,jb->ia', l2new, t1) * 4
          - numpy.einsum('jiab,jb->ia', l2new, t1) * 2)
    tmp = tmp1 = None

    l1new += eris.fock[:nocc,nocc:]
    l1new += numpy.einsum('ib,ba->ia', l1, saved.w1)
    l1new -= numpy.einsum('ja,ij->ia', l1, saved.w2)
    l1new -= numpy.einsum('ik,ka->ia', mij, saved.w4)
    l1new -= numpy.einsum('ca,ic->ia', mba, saved.w4)
    l1new += numpy.einsum('ijab,bj->ia', l2, saved.w3) * 2
    l1new -= numpy.einsum('ijba,bj->ia', l2, saved.w3)

    l2new += numpy.einsum('ia,jb->ijab', l1, saved.w4)
    #:l2new += numpy.einsum('jibc,ca->jiba', l2, saved.w1)
    #:l2new -= numpy.einsum('kiba,jk->jiba', l2, saved.w2)
    lib.dot(l2.reshape(-1,nvir), saved.w1, 1, l2new.reshape(-1,nvir), 1)
    lib.dot(saved.w2, l2.reshape(nocc,-1),-1, l2new.reshape(nocc,-1), 1)

    eris_ooov = _cp(eris.ooov)
    l1new -= numpy.einsum('jkia,kj->ia', eris_ooov, mij1) * 2
    l1new += numpy.einsum('ikja,kj->ia', eris_ooov, mij1)
    #:l2new -= numpy.einsum('ka,kijb->jiba', l1, eris_ooov)
    lib.dot(_cp(eris_ooov.transpose(0,2,1,3).reshape(nocc,-1)).T,
            l1, -1, l2new.reshape(-1,nvir), 1)
    eris_ooov = None

    tau = _ccsd.make_tau(t2, t1, t1)
    #:l2tau = numpy.einsum('ijcd,klcd->ijkl', l2, tau)
    l2tau = lib.dot(l2.reshape(nocc**2,-1),
                    tau.reshape(nocc**2,-1).T).reshape((nocc,)*4)
    tau = None
    l2t1 = numpy.einsum('ijcd,kc->ijkd', l2, t1)

    eris_ovvv = _cp(eris.ovvv)
    eris_ovvv = _ccsd.unpack_tril(eris_ovvv.reshape(nov,-1))
    eris_ovvv = eris_ovvv.reshape(nocc,nvir,nvir,nvir)

    l1new += numpy.einsum('iabc,bc->ia', eris_ovvv, mba1) * 2
    l1new -= numpy.einsum('ibca,bc->ia', eris_ovvv, mba1)
    #:l2new += numpy.einsum('ic,jbac->jiba', l1, eris_ovvv)
    tmp = lib.dot(l1, eris_ovvv.reshape(-1,nvir).T).reshape(nocc,-1,nvir,nvir)
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(0,2,1)
    #:m4 = numpy.einsum('ijkd,kadb->ijab', l2t1, eris_ovvv)
    m4 = tmp
    lib.dot(_cp(l2t1.reshape(nocc*nocc,-1)),
            _cp(eris_ovvv.transpose(0,2,1,3).reshape(-1,nvir**2)),
            1, m4.reshape(nocc*nocc,-1))
    l2new -= m4
    l1new -= numpy.einsum('ijab,jb->ia', m4, t1) * 2
    l1new -= numpy.einsum('ijab,ia->jb', m4, t1) * 2
    l1new += numpy.einsum('jiab,jb->ia', m4, t1)
    l1new += numpy.einsum('jiab,ia->jb', m4, t1)
    eris_ovvv = tmp = None

    eris_ovov = _cp(eris.ovov)
    l1new += numpy.einsum('jb,iajb->ia', l1, eris_ovov) * 2
    #:l2new -= numpy.einsum('jbic,ca->jiba', eris_ovov, mba1)
    #:l2new -= numpy.einsum('kajb,ik->ijab', eris_ovov, mij1)
    tmp = lib.dot(eris_ovov.reshape(-1,nvir), mba1).reshape(nocc,nvir,nocc,nvir)
    lib.dot(mij1, eris_ovov.reshape(nocc,-1), 1, tmp.reshape(nocc,-1), 1)
    tmp_oovv = numpy.empty((nocc,nocc,nvir,nvir))
    for i in range(nocc):
        tmp_oovv[i] = eris_ovov[i].transpose(1,0,2) * .5
        l2new[i] += tmp_oovv[i]
        l2new[i] -= tmp[i].transpose(1,0,2)
    tmp = None
    l1new += numpy.einsum('iajb,jb->ia', eris_ovov, mia1) * 2
    l1new -= numpy.einsum('ibja,jb->ia', eris_ovov, mia1)
    #:m4 = numpy.einsum('kalb,ijkl->ijab', eris_ovov, l2tau)
    lib.dot(l2tau.reshape(nocc*nocc,-1), tmp_oovv.reshape(-1,nvir**2),
            1, m4.reshape(nocc**2,-1))
    l2new += m4
    l1new += numpy.einsum('ijab,jb->ia', m4, t1) * 4
    l1new -= numpy.einsum('ijba,jb->ia', m4, t1) * 2
    eris_ovov = m4 = tmp_oovv = None

    eris_oovv = _cp(eris.oovv)
    l1new -= numpy.einsum('jb,ijba->ia', l1, eris_oovv)
    eris_oovv = None

    saved_wooov = _cp(saved.wooov)
    #:l1new -= numpy.einsum('jkca,ijkc->ia', l2, saved_wooov)
    l1new -= lib.dot(saved_wooov.reshape(nocc,-1), l2.reshape(-1,nvir))
    saved_wovvv = _cp(saved.wovvv)
    #:l1new += numpy.einsum('kibc,kabc->ia', l2, saved_wovvv)
    for j in range(nocc):
        l1new += lib.dot(l2[j].reshape(nocc,-1),
                         saved_wovvv[j].reshape(nvir,-1).T)
    saved_wooov = saved_wovvv = None

    saved_wOvOv = _cp(saved.wOvOv)
    tmp_ovov = _cp(saved.wOVov) * 2
    tmp_ovov += saved_wOvOv
    #:tmp = l2.transpose(0,2,1,3) - l2.transpose(0,3,1,2)*.5
    #:l2new += numpy.einsum('kcia,kcjb->jiba', tmp, tmp_ovov)
    tmp = numpy.empty((nocc,nvir,nocc,nvir))
    for i in range(nocc):
        tmp[i] = l2[i].transpose(2,0,1)*-.5
        tmp[i] += l2[i].transpose(1,0,2)
    tmp = lib.dot(tmp_ovov.reshape(-1,nov),
                  tmp.reshape(nov,-1)).reshape(-1,nvir,nocc,nvir)
    #:tmp = numpy.einsum('jkca,ibkc->ijab', l2, saved_wOvOv)
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(1,0,2)
        tmp_ovov[i] = l2[i].transpose(2,0,1)
    lib.dot(saved_wOvOv.reshape(-1,nov), tmp_ovov.reshape(nov,-1),
            1, tmp.reshape(nov,-1))
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(1,2,0)
        l2new[i] += tmp[i].transpose(1,0,2) * .5
    saved_wOvOv = tmp = tmp_ovov = None

    saved_woooo = _cp(saved.woooo)
    #:m3 = numpy.einsum('klab,ijkl->ijab', l2, saved_woooo)
    m3 = lib.dot(saved_woooo.reshape(-1,nocc**2),
                 l2.reshape(nocc**2,-1), .5).reshape(-1,nocc,nvir,nvir)
    l2new += m3
    l1new += numpy.einsum('ijab,jb->ia', m3, t1) * 4
    l1new -= numpy.einsum('ijba,jb->ia', m3, t1) * 2
    saved_woooo = m3 = None

    mo_e = eris.fock.diagonal()
    eia = lib.direct_sum('i-j->ij', mo_e[:nocc], mo_e[nocc:])
    l1new /= eia
    l1new += l1

#    l2new = l2new + l2new.transpose(1,0,3,2)
#    l2new /= lib.direct_sum('ia+jb->ijab', eia, eia)
#    l2new += l2
    ij = 0
    for i in range(nocc):
        for j in range(i):
            dab = lib.direct_sum('a+b->ab', eia[i], eia[j])
            tmp = (l2new[i,j]+l2new[j,i].T) / dab + l2[i,j]
            l2new[i,j] = tmp
            l2new[j,i] = tmp.T
            ij += 1
        dab = lib.direct_sum('a+b->ab', eia[i], eia[i])
        l2new[i,i] = (l2new[i,i]+l2new[i,i].T)/dab + l2[i,i]
        ij += 1

    time0 = log.timer_debug1('update l1 l2', *time0)
    return l1new, l2new
Exemple #8
0
def update_amps(mycc, t1, t2, l1, l2, eris=None, saved=None):
    if saved is None:
        saved = make_intermediates(mycc, t1, t2, eris)
    time1 = time0 = time.clock(), time.time()
    log = logger.Logger(mycc.stdout, mycc.verbose)
    nocc, nvir = t1.shape
    nov = nocc * nvir
    foo = eris.fock[:nocc, :nocc]
    fov = eris.fock[:nocc, nocc:]
    fvv = eris.fock[:nocc, :nocc]

    #:mba = numpy.einsum('klca,klcb->ba', l2, t2*2-t2.transpose(0,1,3,2))
    #:mij = numpy.einsum('ikcd,jkcd->ij', l2, t2*2-t2.transpose(0,1,3,2))
    #:theta = t2*2 - t2.transpose(0,1,3,2)
    theta = _ccsd.make_0132(t2, t2, 2, -1)
    mba = lib.dot(theta.reshape(-1, nvir).T, l2.reshape(-1, nvir))
    mij = lib.dot(l2.reshape(nocc, -1), theta.reshape(nocc, -1).T)
    theta = None
    mba1 = numpy.einsum('jc,jb->bc', l1, t1) + mba
    mij1 = numpy.einsum('kb,jb->kj', l1, t1) + mij
    mia1 = (t1 + numpy.einsum('kc,jkbc->jb', l1, t2) * 2 -
            numpy.einsum('kc,jkcb->jb', l1, t2) -
            reduce(numpy.dot,
                   (t1, l1.T, t1)) - numpy.einsum('bd,jd->jb', mba, t1) -
            numpy.einsum('lj,lb->jb', mij, t1))

    tmp = mycc.add_wvvVV(numpy.zeros_like(l1), l2, eris)
    l2new = numpy.empty((nocc, nocc, nvir, nvir))
    ij = 0
    for i in range(nocc):
        for j in range(i):
            tmp1 = tmp[ij] * .5  # *.5 because of l2+l2.transpose(1,0,3,2) later
            l2new[i, j] = tmp1
            l2new[j, i] = tmp1.T
            ij += 1
        l2new[i, i] = tmp[ij] * .5
        ij += 1
    l1new = (numpy.einsum('ijab,jb->ia', l2new, t1) * 4 -
             numpy.einsum('jiab,jb->ia', l2new, t1) * 2)
    tmp = tmp1 = None

    l1new += eris.fock[:nocc, nocc:]
    l1new += numpy.einsum('ib,ba->ia', l1, saved.w1)
    l1new -= numpy.einsum('ja,ij->ia', l1, saved.w2)
    l1new -= numpy.einsum('ik,ka->ia', mij, saved.w4)
    l1new -= numpy.einsum('ca,ic->ia', mba, saved.w4)
    l1new += numpy.einsum('ijab,bj->ia', l2, saved.w3) * 2
    l1new -= numpy.einsum('ijba,bj->ia', l2, saved.w3)

    l2new += numpy.einsum('ia,jb->ijab', l1, saved.w4)
    #:l2new += numpy.einsum('jibc,ca->jiba', l2, saved.w1)
    #:l2new -= numpy.einsum('kiba,jk->jiba', l2, saved.w2)
    lib.dot(l2.reshape(-1, nvir), saved.w1, 1, l2new.reshape(-1, nvir), 1)
    lib.dot(saved.w2, l2.reshape(nocc, -1), -1, l2new.reshape(nocc, -1), 1)

    eris_ooov = _cp(eris.ooov)
    l1new -= numpy.einsum('jkia,kj->ia', eris_ooov, mij1) * 2
    l1new += numpy.einsum('ikja,kj->ia', eris_ooov, mij1)
    #:l2new -= numpy.einsum('ka,kijb->jiba', l1, eris_ooov)
    lib.dot(
        _cp(eris_ooov.transpose(0, 2, 1, 3).reshape(nocc, -1)).T, l1, -1,
        l2new.reshape(-1, nvir), 1)
    eris_ooov = None

    tau = _ccsd.make_tau(t2, t1, t1)
    #:l2tau = numpy.einsum('ijcd,klcd->ijkl', l2, tau)
    l2tau = lib.dot(l2.reshape(nocc**2, -1),
                    tau.reshape(nocc**2, -1).T).reshape((nocc, ) * 4)
    tau = None
    l2t1 = numpy.einsum('ijcd,kc->ijkd', l2, t1)

    eris_ovvv = _cp(eris.ovvv)
    eris_ovvv = lib.unpack_tril(eris_ovvv.reshape(nov, -1))
    eris_ovvv = eris_ovvv.reshape(nocc, nvir, nvir, nvir)

    l1new += numpy.einsum('iabc,bc->ia', eris_ovvv, mba1) * 2
    l1new -= numpy.einsum('ibca,bc->ia', eris_ovvv, mba1)
    #:l2new += numpy.einsum('ic,jbac->jiba', l1, eris_ovvv)
    tmp = lib.dot(l1,
                  eris_ovvv.reshape(-1, nvir).T).reshape(nocc, -1, nvir, nvir)
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(0, 2, 1)
    #:m4 = numpy.einsum('ijkd,kadb->ijab', l2t1, eris_ovvv)
    m4 = tmp
    lib.dot(_cp(l2t1.reshape(nocc * nocc, -1)),
            _cp(eris_ovvv.transpose(0, 2, 1, 3).reshape(-1, nvir**2)), 1,
            m4.reshape(nocc * nocc, -1))
    l2new -= m4
    l1new -= numpy.einsum('ijab,jb->ia', m4, t1) * 2
    l1new -= numpy.einsum('ijab,ia->jb', m4, t1) * 2
    l1new += numpy.einsum('jiab,jb->ia', m4, t1)
    l1new += numpy.einsum('jiab,ia->jb', m4, t1)
    eris_ovvv = tmp = None

    eris_ovov = _cp(eris.ovov)
    l1new += numpy.einsum('jb,iajb->ia', l1, eris_ovov) * 2
    #:l2new -= numpy.einsum('jbic,ca->jiba', eris_ovov, mba1)
    #:l2new -= numpy.einsum('kajb,ik->ijab', eris_ovov, mij1)
    tmp = lib.dot(eris_ovov.reshape(-1, nvir),
                  mba1).reshape(nocc, nvir, nocc, nvir)
    lib.dot(mij1, eris_ovov.reshape(nocc, -1), 1, tmp.reshape(nocc, -1), 1)
    tmp_oovv = numpy.empty((nocc, nocc, nvir, nvir))
    for i in range(nocc):
        tmp_oovv[i] = eris_ovov[i].transpose(1, 0, 2) * .5
        l2new[i] += tmp_oovv[i]
        l2new[i] -= tmp[i].transpose(1, 0, 2)
    tmp = None
    l1new += numpy.einsum('iajb,jb->ia', eris_ovov, mia1) * 2
    l1new -= numpy.einsum('ibja,jb->ia', eris_ovov, mia1)
    #:m4 = numpy.einsum('kalb,ijkl->ijab', eris_ovov, l2tau)
    lib.dot(l2tau.reshape(nocc * nocc, -1), tmp_oovv.reshape(-1, nvir**2), 1,
            m4.reshape(nocc**2, -1))
    l2new += m4
    l1new += numpy.einsum('ijab,jb->ia', m4, t1) * 4
    l1new -= numpy.einsum('ijba,jb->ia', m4, t1) * 2
    eris_ovov = m4 = tmp_oovv = None

    eris_oovv = _cp(eris.oovv)
    l1new -= numpy.einsum('jb,ijba->ia', l1, eris_oovv)
    eris_oovv = None

    saved_wooov = _cp(saved.wooov)
    #:l1new -= numpy.einsum('jkca,ijkc->ia', l2, saved_wooov)
    l1new -= lib.dot(saved_wooov.reshape(nocc, -1), l2.reshape(-1, nvir))
    saved_wovvv = _cp(saved.wovvv)
    #:l1new += numpy.einsum('kibc,kabc->ia', l2, saved_wovvv)
    for j in range(nocc):
        l1new += lib.dot(l2[j].reshape(nocc, -1),
                         saved_wovvv[j].reshape(nvir, -1).T)
    saved_wooov = saved_wovvv = None

    saved_wOvOv = _cp(saved.wOvOv)
    tmp_ovov = _cp(saved.wOVov) * 2
    tmp_ovov += saved_wOvOv
    #:tmp = l2.transpose(0,2,1,3) - l2.transpose(0,3,1,2)*.5
    #:l2new += numpy.einsum('kcia,kcjb->jiba', tmp, tmp_ovov)
    tmp = numpy.empty((nocc, nvir, nocc, nvir))
    for i in range(nocc):
        tmp[i] = l2[i].transpose(2, 0, 1) * -.5
        tmp[i] += l2[i].transpose(1, 0, 2)
    tmp = lib.dot(tmp_ovov.reshape(-1, nov),
                  tmp.reshape(nov, -1)).reshape(-1, nvir, nocc, nvir)
    #:tmp = numpy.einsum('jkca,ibkc->ijab', l2, saved_wOvOv)
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(1, 0, 2)
        tmp_ovov[i] = l2[i].transpose(2, 0, 1)
    lib.dot(saved_wOvOv.reshape(-1, nov), tmp_ovov.reshape(nov, -1), 1,
            tmp.reshape(nov, -1))
    for i in range(nocc):
        l2new[i] += tmp[i].transpose(1, 2, 0)
        l2new[i] += tmp[i].transpose(1, 0, 2) * .5
    saved_wOvOv = tmp = tmp_ovov = None

    saved_woooo = _cp(saved.woooo)
    #:m3 = numpy.einsum('klab,ijkl->ijab', l2, saved_woooo)
    m3 = lib.dot(saved_woooo.reshape(-1, nocc**2), l2.reshape(nocc**2, -1),
                 .5).reshape(-1, nocc, nvir, nvir)
    l2new += m3
    l1new += numpy.einsum('ijab,jb->ia', m3, t1) * 4
    l1new -= numpy.einsum('ijba,jb->ia', m3, t1) * 2
    saved_woooo = m3 = None

    mo_e = eris.fock.diagonal()
    eia = lib.direct_sum('i-j->ij', mo_e[:nocc], mo_e[nocc:])
    l1new /= eia
    l1new += l1

    #    l2new = l2new + l2new.transpose(1,0,3,2)
    #    l2new /= lib.direct_sum('ia+jb->ijab', eia, eia)
    #    l2new += l2
    ij = 0
    for i in range(nocc):
        for j in range(i):
            dab = lib.direct_sum('a+b->ab', eia[i], eia[j])
            tmp = (l2new[i, j] + l2new[j, i].T) / dab + l2[i, j]
            l2new[i, j] = tmp
            l2new[j, i] = tmp.T
            ij += 1
        dab = lib.direct_sum('a+b->ab', eia[i], eia[i])
        l2new[i, i] = (l2new[i, i] + l2new[i, i].T) / dab + l2[i, i]
        ij += 1

    time0 = log.timer_debug1('update l1 l2', *time0)
    return l1new, l2new