Beispiel #1
0
def get_vxc_giao(ni, mol, grids, xc_code, dms, max_memory=2000, verbose=None):
    xctype = ni._xc_type(xc_code)
    make_rho, nset, nao = ni._gen_rho_evaluator(mol, dms, hermi=1)
    ngrids = len(grids.weights)
    BLKSIZE = numint.BLKSIZE
    blksize = min(
        int(max_memory / 12 * 1e6 / 8 / nao / BLKSIZE) * BLKSIZE, ngrids)
    shls_slice = (0, mol.nbas)
    ao_loc = mol.ao_loc_nr()

    vmat = numpy.zeros((2, 3, nao, nao))
    if xctype == 'LDA':
        buf = numpy.empty((4, blksize, nao))
        ao_deriv = 0
        for ao, mask, weight, coords \
                in ni.block_loop(mol, grids, nao, ao_deriv, max_memory,
                                 blksize=blksize, buf=buf):
            rho_a = make_rho(0, ao, mask, 'LDA')
            rho_b = make_rho(1, ao, mask, 'LDA')
            vxc = ni.eval_xc(xc_code, (rho_a, rho_b), 1, deriv=1)[1]
            vrho = vxc[0]
            giao = mol.eval_gto('GTOval_ig',
                                coords,
                                comp=3,
                                non0tab=mask,
                                out=buf[1:])
            aow = numpy.einsum('pi,p->pi', ao, weight * vrho[:, 0])
            vmat[0, 0] += numint._dot_ao_ao(mol, aow, giao[0], mask,
                                            shls_slice, ao_loc)
            vmat[0, 1] += numint._dot_ao_ao(mol, aow, giao[1], mask,
                                            shls_slice, ao_loc)
            vmat[0, 2] += numint._dot_ao_ao(mol, aow, giao[2], mask,
                                            shls_slice, ao_loc)
            aow = numpy.einsum('pi,p->pi', ao, weight * vrho[:, 1])
            vmat[1, 0] += numint._dot_ao_ao(mol, aow, giao[0], mask,
                                            shls_slice, ao_loc)
            vmat[1, 1] += numint._dot_ao_ao(mol, aow, giao[1], mask,
                                            shls_slice, ao_loc)
            vmat[1, 2] += numint._dot_ao_ao(mol, aow, giao[2], mask,
                                            shls_slice, ao_loc)
            rho = vxc = vrho = aow = None

    elif xctype == 'GGA':
        buf = numpy.empty((10, blksize, nao))
        ao_deriv = 1
        for ao, mask, weight, coords \
                in ni.block_loop(mol, grids, nao, ao_deriv, max_memory,
                                 blksize=blksize, buf=buf):
            rho_a = make_rho(0, ao, mask, 'GGA')
            rho_b = make_rho(1, ao, mask, 'GGA')
            vxc = ni.eval_xc(xc_code, (rho_a, rho_b), 1, deriv=1)[1]
            vrho, vsigma = vxc[:2]
            giao = mol.eval_gto('GTOval_ig',
                                coords,
                                3,
                                non0tab=mask,
                                out=buf[4:])

            wva = numpy.empty_like(rho_a)
            wva[0] = weight * vrho[:, 0]
            wva[1:] = rho_a[1:] * (weight * vsigma[:, 0] * 2)  # sigma_uu
            wva[1:] += rho_b[1:] * (weight * vsigma[:, 1])  # sigma_ud
            wvb = numpy.empty_like(rho_b)
            wvb[0] = weight * vrho[:, 1]
            wvb[1:] = rho_b[1:] * (weight * vsigma[:, 2] * 2)  # sigma_dd
            wvb[1:] += rho_a[1:] * (weight * vsigma[:, 1])  # sigma_ud

            aow = numpy.einsum('npi,np->pi', ao[:4], wva)
            vmat[0, 0] += numint._dot_ao_ao(mol, aow, giao[0], mask,
                                            shls_slice, ao_loc)
            vmat[0, 1] += numint._dot_ao_ao(mol, aow, giao[1], mask,
                                            shls_slice, ao_loc)
            vmat[0, 2] += numint._dot_ao_ao(mol, aow, giao[2], mask,
                                            shls_slice, ao_loc)
            aow = numpy.einsum('npi,np->pi', ao[:4], wvb)
            vmat[1, 0] += numint._dot_ao_ao(mol, aow, giao[0], mask,
                                            shls_slice, ao_loc)
            vmat[1, 1] += numint._dot_ao_ao(mol, aow, giao[1], mask,
                                            shls_slice, ao_loc)
            vmat[1, 2] += numint._dot_ao_ao(mol, aow, giao[2], mask,
                                            shls_slice, ao_loc)

            giao = mol.eval_gto('GTOval_ipig',
                                coords,
                                9,
                                non0tab=mask,
                                out=buf[1:])
            rks_nmr._gga_sum_(vmat[0], mol, ao, giao, wva, mask, shls_slice,
                              ao_loc)
            rks_nmr._gga_sum_(vmat[1], mol, ao, giao, wvb, mask, shls_slice,
                              ao_loc)
            rho = vxc = vrho = vsigma = wv = aow = None
    elif xctype == 'MGGA':
        raise NotImplementedError('meta-GGA')

    return vmat - vmat.transpose(0, 1, 3, 2)
Beispiel #2
0
def get_vxc_giao(ni, mol, grids, xc_code, dms, max_memory=2000, verbose=None):
    xctype = ni._xc_type(xc_code)
    make_rho, nset, nao = ni._gen_rho_evaluator(mol, dms, hermi=1)
    ngrids = len(grids.weights)
    BLKSIZE = numint.BLKSIZE
    blksize = min(int(max_memory/12*1e6/8/nao/BLKSIZE)*BLKSIZE, ngrids)
    shls_slice = (0, mol.nbas)
    ao_loc = mol.ao_loc_nr()

    vmat = numpy.zeros((2,3,nao,nao))
    if xctype == 'LDA':
        buf = numpy.empty((4,blksize,nao))
        ao_deriv = 0
        for ao, mask, weight, coords \
                in ni.block_loop(mol, grids, nao, ao_deriv, max_memory,
                                 blksize=blksize, buf=buf):
            rho_a = make_rho(0, ao, mask, 'LDA')
            rho_b = make_rho(1, ao, mask, 'LDA')
            vxc = ni.eval_xc(xc_code, (rho_a, rho_b), 1, deriv=1)[1]
            vrho = vxc[0]
            giao = mol.eval_gto('GTOval_ig', coords, comp=3,
                                non0tab=mask, out=buf[1:])
            aow = numpy.einsum('pi,p->pi', ao, weight*vrho[:,0])
            vmat[0,0] += numint._dot_ao_ao(mol, aow, giao[0], mask, shls_slice, ao_loc)
            vmat[0,1] += numint._dot_ao_ao(mol, aow, giao[1], mask, shls_slice, ao_loc)
            vmat[0,2] += numint._dot_ao_ao(mol, aow, giao[2], mask, shls_slice, ao_loc)
            aow = numpy.einsum('pi,p->pi', ao, weight*vrho[:,1])
            vmat[1,0] += numint._dot_ao_ao(mol, aow, giao[0], mask, shls_slice, ao_loc)
            vmat[1,1] += numint._dot_ao_ao(mol, aow, giao[1], mask, shls_slice, ao_loc)
            vmat[1,2] += numint._dot_ao_ao(mol, aow, giao[2], mask, shls_slice, ao_loc)
            rho = vxc = vrho = aow = None

    elif xctype == 'GGA':
        buf = numpy.empty((10,blksize,nao))
        ao_deriv = 1
        for ao, mask, weight, coords \
                in ni.block_loop(mol, grids, nao, ao_deriv, max_memory,
                                 blksize=blksize, buf=buf):
            rho_a = make_rho(0, ao, mask, 'GGA')
            rho_b = make_rho(1, ao, mask, 'GGA')
            vxc = ni.eval_xc(xc_code, (rho_a,rho_b), 1, deriv=1)[1]
            vrho, vsigma = vxc[:2]
            giao = mol.eval_gto('GTOval_ig', coords, 3, non0tab=mask, out=buf[4:])

            wva = numpy.empty_like(rho_a)
            wva[0]  = weight * vrho[:,0]
            wva[1:] = rho_a[1:] * (weight * vsigma[:,0] * 2)  # sigma_uu
            wva[1:]+= rho_b[1:] * (weight * vsigma[:,1])      # sigma_ud
            wvb = numpy.empty_like(rho_b)
            wvb[0]  = weight * vrho[:,1]
            wvb[1:] = rho_b[1:] * (weight * vsigma[:,2] * 2)  # sigma_dd
            wvb[1:]+= rho_a[1:] * (weight * vsigma[:,1])      # sigma_ud

            aow = numpy.einsum('npi,np->pi', ao[:4], wva)
            vmat[0,0] += numint._dot_ao_ao(mol, aow, giao[0], mask, shls_slice, ao_loc)
            vmat[0,1] += numint._dot_ao_ao(mol, aow, giao[1], mask, shls_slice, ao_loc)
            vmat[0,2] += numint._dot_ao_ao(mol, aow, giao[2], mask, shls_slice, ao_loc)
            aow = numpy.einsum('npi,np->pi', ao[:4], wvb)
            vmat[1,0] += numint._dot_ao_ao(mol, aow, giao[0], mask, shls_slice, ao_loc)
            vmat[1,1] += numint._dot_ao_ao(mol, aow, giao[1], mask, shls_slice, ao_loc)
            vmat[1,2] += numint._dot_ao_ao(mol, aow, giao[2], mask, shls_slice, ao_loc)

            giao = mol.eval_gto('GTOval_ipig', coords, 9, non0tab=mask, out=buf[1:])
            rks_nmr._gga_sum_(vmat[0], mol, ao, giao, wva, mask, shls_slice, ao_loc)
            rks_nmr._gga_sum_(vmat[1], mol, ao, giao, wvb, mask, shls_slice, ao_loc)
            rho = vxc = vrho = vsigma = wv = aow = None
    elif xctype == 'MGGA':
        raise NotImplementedError('meta-GGA')

    return vmat - vmat.transpose(0,1,3,2)