#!/usr/bin/env python
import numpy
import ctypes
from pyscf import lib
from pyscf.lib import parameters as param
libdft = lib.load_library('libdft')
HMINIMAL = numpy.finfo(numpy.float64).eps
EPS = 1e-7
LEBEDEV_NGRID = numpy.asarray((
1 , 6 , 14 , 26 , 38 , 50 , 74 , 86 , 110 , 146 ,
170 , 194 , 230 , 266 , 302 , 350 , 434 , 590 , 770 , 974 ,
1202, 1454, 1730, 2030, 2354, 2702, 3074, 3470, 3890, 4334,
4802, 5294, 5810))
#########################
# JCP 41 3199 (1964).
BRAGG = 1.0/param.BOHR * numpy.array((0, # Ghost atom
0.35, 1.40, # 1s
1.45, 1.05, 0.85, 0.70, 0.65, 0.60, 0.50, 1.50, # 2s2p
1.80, 1.50, 1.25, 1.10, 1.00, 1.00, 1.00, 1.80, # 3s3p
2.20, 1.80, # 4s
1.60, 1.40, 1.35, 1.40, 1.40, 1.40, 1.35, 1.35, 1.35, 1.35, # 3d
1.30, 1.25, 1.15, 1.15, 1.15, 1.90, # 4p
2.35, 2.00, # 5s
1.80, 1.55, 1.45, 1.45, 1.35, 1.30, 1.35, 1.40, 1.60, 1.55, # 4d
1.55, 1.45, 1.45, 1.40, 1.40, 2.10, # 5p
2.60, 2.15, # 6s
#
# Author: Qiming Sun <*****@*****.**>
#
'''
XC functional, the interface to xcfun (https://github.com/dftlibs/xcfun)
U. Ekstrom et al, J. Chem. Theory Comput., 6, 1971
'''
import copy
import ctypes
import math
import numpy
from pyscf import lib
_itrf = lib.load_library('libxcfun_itrf')
XC = XC_CODES = {
'SLATERX' : 0, # Slater LDA exchange
'PW86X' : 1, # PW86 exchange
'VWN3C' : 2, # VWN3 LDA Correlation functional
'VWN5C' : 3, # VWN5 LDA Correlation functional
'PBEC' : 4, # PBE correlation functional
'PBEX' : 5, # PBE Exchange Functional
'BECKEX' : 6, # Becke 88 exchange
'BECKECORRX' : 7, # Becke 88 exchange correction
'BECKESRX' : 8, # Short range Becke 88 exchange
'BECKECAMX' : 9, # CAM Becke 88 exchange
'BRX' : 10, # Becke-Roussells exchange with jp dependence
'BRC' : 11, # Becke-Roussells correlation with jp dependence
'BRXC' : 12, # Becke-Roussells correlation with jp dependence
# Authors: Qiming Sun <*****@*****.**>
# Susi Lehtola <*****@*****.**>
'''
XC functional, the interface to libxc
(http://www.tddft.org/programs/octopus/wiki/index.php/Libxc)
'''
import sys
import copy
import ctypes
import math
import numpy
from pyscf import lib
_itrf = lib.load_library('libxc_itrf')
_itrf.LIBXC_is_lda.restype = ctypes.c_int
_itrf.LIBXC_is_gga.restype = ctypes.c_int
_itrf.LIBXC_is_meta_gga.restype = ctypes.c_int
_itrf.LIBXC_is_hybrid.restype = ctypes.c_int
_itrf.LIBXC_max_deriv_order.restype = ctypes.c_int
_itrf.LIBXC_hybrid_coeff.restype = ctypes.c_double
# xc_code from libxc
#cat lib/deps/include/xc_funcs.h | awk '{printf("'\''%s'\'' %3i",$2,$3); for(i=4;i<NF;i++) {printf(" %s",$i)}; printf("\n")}' | sed "s|/\*|# |g" | awk '{printf("%-30s : %4i\,",$1,$2); for(i=4;i<NF;i++) {printf(" %s",$i)}; printf("\n")}'
XC = XC_CODES = {
'XC_LDA_X' : 1, # Exchange
'XC_LDA_C_WIGNER' : 2, # Wigner parametrization
'XC_LDA_C_RPA' : 3, # Random Phase Approximation
'XC_LDA_C_HL' : 4, # Hedin & Lundqvist
#!/usr/bin/env python
import os
import ctypes
import unittest
import numpy
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
libcvhf2 = lib.load_library('libcvhf')
mol = gto.Mole()
mol.verbose = 0
mol.output = None#'out_h2o'
mol.atom = [
['O' , (0. , 0. , 0.)],
[1 , (0. , -0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)] ]
mol.basis = 'cc-pvdz'
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
nao = mol.nao_nr()
npair = nao*(nao+1)//2
c_atm = numpy.array(mol._atm, dtype=numpy.int32)
import numpy
import h5py
import ctypes
import signal
from pyscf import lib
from pyscf.lib import logger
signal.signal(signal.SIGINT, signal.SIG_DFL)
# For code compatiblity in python-2 and python-3
if sys.version_info >= (3,):
unicode = str
_loaderpath = os.path.dirname(__file__)
libaim = numpy.ctypeslib.load_library('libaim.so', _loaderpath)
libcgto = lib.load_library('libcgto')
name = 'h2o.chk.h5'
idx = 1
jdx = 2
idx1 = 'qlm'+str(idx)
idx2 = 'qlm'+str(jdx)
with h5py.File(name) as f:
lmax1 = f[idx1+'/lmax'].value
qlm1 = f[idx1+'/totprops'].value
lmax2 = f[idx2+'/lmax'].value
qlm2 = f[idx2+'/totprops'].value
idx1 = 'atom'+str(idx)
with h5py.File(name) as f:
Note the 1-particle density matrix has the same convention as the mean-field
1-particle density matrix (see McWeeney's book Eq 5.4.20), which is
dm[p,q] = < q^+ p >
The contraction between 1-particle Hamiltonian and 1-pdm is
E = einsum('pq,qp', h1, 1pdm)
Different conventions are used in the high order density matrices:
dm[p,q,r,s,...] = < p^+ r^+ ... s q >
'''
import ctypes
import numpy
from pyscf import lib
from pyscf.fci import cistring
from pyscf.fci.addons import _unpack_nelec
librdm = lib.load_library('libfci')
def reorder_rdm(rdm1, rdm2, inplace=False):
nmo = rdm1.shape[0]
if not inplace:
rdm2 = rdm2.copy()
for k in range(nmo):
rdm2[:,k,k,:] -= rdm1.T
#return rdm1, rdm2
rdm2 = lib.transpose_sum(rdm2.reshape(nmo*nmo,-1), inplace=True) * .5
return rdm1, rdm2.reshape(nmo,nmo,nmo,nmo)
# dm[p,q] = <|q^+ p|>
def make_rdm1_ms0(fname, cibra, ciket, norb, nelec, link_index=None):
assert(cibra is not None and ciket is not None)
cibra = numpy.asarray(cibra, order='C')
import sys
import time
import numpy
import ctypes
import signal
from pyscf.pbc import lib as libpbc
from pyscf.pbc import dft
from pyscf import lib
from pyscf.lib import logger
import grid
_loaderpath = os.path.dirname(__file__)
libaim = numpy.ctypeslib.load_library('libaim.so', _loaderpath)
libpbcgto = lib.load_library('libpbc')
signal.signal(signal.SIGINT, signal.SIG_DFL)
# For code compatiblity in python-2 and python-3
if sys.version_info >= (3,):
unicode = str
GRADEPS = 1e-10
RHOEPS = 1e-10
MINSTEP = 1e-6
MAXSTEP = 0.75
SAFETY = 0.9
ENLARGE = 1.6
HMINIMAL = numpy.finfo(numpy.float64).eps
(JCTC 2016, 12, 3674-3680)
Simple usage::
'''
import numpy
import time
import ctypes
from pyscf import lib
from pyscf import ao2mo
from pyscf.lib import logger
from pyscf.fci import cistring
from pyscf.fci import direct_spin1
libhci = lib.load_library('libhci')
def contract_2e_ctypes(h1_h2, civec, norb, nelec, hdiag=None, **kwargs):
h1, eri = h1_h2
strs = civec._strs
ndet = len(strs)
if hdiag is None:
hdiag = make_hdiag(h1, eri, strs, norb, nelec)
ci1 = numpy.zeros_like(civec)
h1 = numpy.asarray(h1, order='C')
eri = numpy.asarray(eri, order='C')
strs = numpy.asarray(strs, order='C')
civec = numpy.asarray(civec, order='C')
hdiag = numpy.asarray(hdiag, order='C')
ci1 = numpy.asarray(ci1, order='C')
import scipy.linalg
import h5py
from pyscf import lib
from pyscf import gto
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf.ao2mo import _ao2mo
from pyscf.scf import _vhf
from pyscf.df import incore
from pyscf.df import _ri
#
# for auxe1 (P|ij)
#
libri = lib.load_library("libri")
def cholesky_eri(
mol,
erifile,
auxbasis="weigend+etb",
dataname="eri_mo",
tmpdir=None,
int3c="cint3c2e_sph",
aosym="s2ij",
int2c="cint2c2e_sph",
comp=1,
ioblk_size=256,
auxmol=None,
verbose=0,
from pyscf import gto, scf
from pyscf.tools import molden
from pyscf.lib import parameters as param
from pyscf.lib import logger
from pyscf.lib import linalg_helper
from pyscf.scf import _vhf
from pyscf import ao2mo
import numpy as np
import scipy
#import time
import ctypes
from pyscf.lib import load_library
liblocalizer = load_library('liblocalizer')
class localizer:
def __init__(self, mol, orbital_coeff, thetype, use_full_hessian=True):
r'''Initializer for the localization procedure
Args:
mol : A molecule which has been built
orbital_coeff: Set of orthonormal orbitals, expressed in terms of the AO, which should be localized
thetype: Which cost function to optimize: 'boys' or 'edmiston'
use_full_hessian: Whether to do augmented Hessian Newton-Raphson (True) or just -gradient/diag(hessian) (False)
'''
assert ((thetype == 'boys') or (thetype == 'edmiston'))
import sys
import struct
import tempfile
from subprocess import check_call, check_output, STDOUT, CalledProcessError
import numpy
from pyscf import lib
from pyscf import tools
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf import mcscf
from pyscf.dmrgscf import dmrg_sym
from pyscf import __config__
# Libraries
libunpack = lib.load_library('libunpack')
# Settings
try:
from pyscf.dmrgscf import settings
except ImportError:
settings = lambda: None
settings.BLOCKEXE = getattr(__config__, 'dmrgscf_BLOCKEXE', None)
settings.BLOCKEXE_COMPRESS_NEVPT = \
getattr(__config__, 'dmrgscf_BLOCKEXE_COMPRESS_NEVPT', None)
settings.BLOCKSCRATCHDIR = getattr(__config__, 'dmrgscf_BLOCKSCRATCHDIR',
None)
settings.BLOCKRUNTIMEDIR = getattr(__config__, 'dmrgscf_BLOCKRUNTIMEDIR',
None)
settings.MPIPREFIX = getattr(__config__, 'dmrgscf_MPIPREFIX', None)
settings.BLOCKVERSION = getattr(__config__, 'dmrgscf_BLOCKVERSION', None)
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ctypes
import unittest
import numpy
from pyscf import lib, gto
libcgto = lib.load_library('libdft')
BLKSIZE = 64
mol = gto.M(atom='''
O 0.5 0.5 0.
H 1. 1.2 0.
H 0. 0. 1.3
''',
basis='ccpvqz')
def eval_gto(mol, eval_name, coords,
comp=1, shls_slice=None, non0tab=None, ao_loc=None, out=None):
atm = numpy.asarray(mol._atm, dtype=numpy.int32, order='C')
bas = numpy.asarray(mol._bas, dtype=numpy.int32, order='C')
env = numpy.asarray(mol._env, dtype=numpy.double, order='C')
coords = numpy.asarray(coords, dtype=numpy.double, order='F')
def _gen_jk_direct(mol, aosym, with_j, with_k, direct_scf_tol):
'''Contraction between sgX Coulomb integrals and density matrices
J: einsum('guv,xg->xuv', gbn, dms) if dms == rho at grid
einsum('gij,xij->xg', gbn, dms) if dms are density matrices
K: einsum('gtv,xgt->xgv', gbn, fg)
'''
intor = mol._add_suffix('int3c2e')
cintopt = gto.moleintor.make_cintopt(mol._atm, mol._bas, mol._env, intor)
ncomp = 1
nao = mol.nao
vhfopt = _vhf.VHFOpt(mol, 'int1e_ovlp', 'SGXnr_ovlp_prescreen',
'SGXsetnr_direct_scf')
vhfopt.direct_scf_tol = direct_scf_tol
cintor = _vhf._fpointer(intor)
fdot = _vhf._fpointer('SGXdot_nr' + aosym)
drv = _vhf.libcvhf.SGXnr_direct_drv
# for linsgx, from _vhf.VHFOpt
libcvhf = lib.load_library('libcvhf')
intor = mol._add_suffix('int1e_ovlp')
c_atm = numpy.asarray(mol._atm, dtype=numpy.int32, order='C')
c_bas = numpy.asarray(mol._bas, dtype=numpy.int32, order='C')
c_env = numpy.asarray(mol._env, dtype=numpy.double, order='C')
natm = ctypes.c_int(c_atm.shape[0])
nbas = ctypes.c_int(c_bas.shape[0])
@profile
def jk_part(mol, grid_coords, dms, fg):
# transfer bvv to SGXsetnr_direct_scf_blk. from _vhf.VHFOpt
# need add mol._bvv in scf.mole.py
c_bvv = numpy.asarray(mol._bvv, dtype=numpy.int32, order='C')
nbvv = ctypes.c_int(c_bvv.shape[0])
ao_loc = make_loc(c_bas, intor)
fsetqcond = getattr(libcvhf, 'SGXsetnr_direct_scf_blk')
fsetqcond(vhfopt._this, getattr(libcvhf, intor), lib.c_null_ptr(),
ao_loc.ctypes.data_as(ctypes.c_void_p),
c_atm.ctypes.data_as(ctypes.c_void_p), natm,
c_bas.ctypes.data_as(ctypes.c_void_p), nbas,
c_env.ctypes.data_as(ctypes.c_void_p),
c_bvv.ctypes.data_as(ctypes.c_void_p), nbvv)
fakemol = gto.fakemol_for_charges(grid_coords)
atm, bas, env = gto.mole.conc_env(mol._atm, mol._bas, mol._env,
fakemol._atm, fakemol._bas,
fakemol._env)
ao_loc = moleintor.make_loc(bas, intor)
shls_slice = (0, mol.nbas, 0, mol.nbas, mol.nbas, len(bas))
ngrids = grid_coords.shape[0]
vj = vk = None
fjk = []
dmsptr = []
vjkptr = []
if with_j:
if dms[0].ndim == 1: # the value of density at each grid
vj = numpy.zeros((len(dms), ncomp, nao, nao))[:, 0]
for i, dm in enumerate(dms):
dmsptr.append(dm.ctypes.data_as(ctypes.c_void_p))
vjkptr.append(vj[i].ctypes.data_as(ctypes.c_void_p))
fjk.append(_vhf._fpointer('SGXnr' + aosym + '_ijg_g_ij'))
else:
vj = numpy.zeros((len(dms), ncomp, ngrids))[:, 0]
for i, dm in enumerate(dms):
dmsptr.append(dm.ctypes.data_as(ctypes.c_void_p))
vjkptr.append(vj[i].ctypes.data_as(ctypes.c_void_p))
fjk.append(_vhf._fpointer('SGXnr' + aosym + '_ijg_ji_g'))
if with_k:
vk = numpy.zeros((len(fg), ncomp, ngrids, nao))[:, 0]
for i, dm in enumerate(fg):
dmsptr.append(dm.ctypes.data_as(ctypes.c_void_p))
vjkptr.append(vk[i].ctypes.data_as(ctypes.c_void_p))
fjk.append(_vhf._fpointer('SGXnr' + aosym + '_ijg_gj_gi'))
n_dm = len(fjk)
fjk = (ctypes.c_void_p * (n_dm))(*fjk)
dmsptr = (ctypes.c_void_p * (n_dm))(*dmsptr)
vjkptr = (ctypes.c_void_p * (n_dm))(*vjkptr)
drv(cintor, fdot, fjk, dmsptr, vjkptr, n_dm, ncomp,
(ctypes.c_int * 6)(*shls_slice),
ao_loc.ctypes.data_as(ctypes.c_void_p), cintopt, vhfopt._this,
atm.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(mol.natm),
bas.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(mol.nbas),
env.ctypes.data_as(ctypes.c_void_p))
return vj, vk
return jk_part
#!/usr/bin/env python
import os
import ctypes
import unittest
from functools import reduce
import numpy
import h5py
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
from pyscf.ao2mo import _ao2mo
from pyscf.scf import _vhf
libao2mo1 = lib.load_library("libao2mo")
mol = gto.Mole()
mol.verbose = 0
mol.output = None #'out_h2o'
mol.atom.extend([["O", (0.0, 0.0, 0.0)], [1, (0.0, -0.757, 0.587)], [1, (0.0, 0.757, 0.587)]])
mol.basis = "cc-pvdz"
mol.build()
nao = mol.nao_nr()
naopair = nao * (nao + 1) // 2
numpy.random.seed(15)
mo = numpy.random.random((nao, nao))
mo = mo.copy(order="F")
c_atm = numpy.array(mol._atm, dtype=numpy.int32)
#!/usr/bin/env python
#
# Author: Qiming Sun <*****@*****.**>
#
'''
XC functional, the interface to xcfun (https://github.com/dftlibs/xcfun)
U. Ekstrom et al, J. Chem. Theory Comput., 6, 1971
'''
import copy
import ctypes
import math
import numpy
from pyscf import lib
_itrf = lib.load_library('libxcfun_itrf')
XC = XC_CODES = {
'SLATERX': 0, # Slater LDA exchange
'VWN5C': 1, # VWN5 LDA Correlation functional
'BECKEX': 2, # Becke 88 exchange
'BECKECORRX': 3, # Becke 88 exchange correction
'BECKESRX': 4, # Short range Becke 88 exchange
'OPTX': 5, # OPTX Handy & Cohen exchange
'LYPC': 6, # LYP correlation
'PBEX': 7, # PBE Exchange Functional
'REVPBEX': 8, # Revised PBE Exchange Functional
'RPBEX': 9, # RPBE Exchange Functional
'PBEC': 10, # PBE correlation functional
'SPBEC': 11, # sPBE correlation functional
'VWN_PBEC': 12, # PBE correlation functional using VWN LDA correlation.
[2] J. J. Stewart, J. Mol. Model 10, 155 (2004)
'''
raise NotImplementedError('AM1 model is in testing')
import ctypes
import copy
import numpy
from pyscf import lib
from pyscf.lib import logger
from pyscf import gto
from pyscf import scf
from pyscf import ao2mo
from pyscf.data.elements import _symbol
from pyscf.semiempirical import mopac_param, mindo3
libsemiempirical = lib.load_library('libsemiempirical')
ndpointer = numpy.ctypeslib.ndpointer
libsemiempirical.MOPAC_rotate.argtypes = [
ctypes.c_int,
ctypes.c_int,
ndpointer(dtype=numpy.double), # xi
ndpointer(dtype=numpy.double), # xj
ndpointer(dtype=numpy.double), # w
ndpointer(dtype=numpy.double), # e1b
ndpointer(dtype=numpy.double), # e2a
ndpointer(dtype=numpy.double), # enuc
ndpointer(dtype=numpy.double), # alp
ndpointer(dtype=numpy.double), # dd
ndpointer(dtype=numpy.double), # qq
ndpointer(dtype=numpy.double), # am
ndpointer(dtype=numpy.double), # ad
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from functools import reduce
import numpy
from pyscf import lib
from pyscf.fci import cistring
from pyscf.fci.addons import _unpack_nelec
librdm = lib.load_library('libfci')
######################################################
# Spin squared operator
######################################################
# S^2 = (S+ * S- + S- * S+)/2 + Sz * Sz
# S+ = \sum_i S_i+ ~ effective for all beta occupied orbitals.
# S- = \sum_i S_i- ~ effective for all alpha occupied orbitals.
# There are two cases for S+*S-
# 1) same electron \sum_i s_i+*s_i-, <CI|s_i+*s_i-|CI> gives
# <p|s+s-|q> \gammalpha_qp = trace(\gammalpha) = neleca
# 2) different electrons for \sum s_i+*s_j- (i\neq j, n*(n-1) terms)
# As a two-particle operator S+*S-
# = <ij|s+s-|kl>Gamma_{ik,jl} = <iajb|s+s-|kbla>Gamma_{iakb,jbla}
# = <ia|s+|kb><jb|s-|la>Gamma_{iakb,jbla}
# <CI|S+*S-|CI> = neleca + <ia|s+|kb><jb|s-|la>Gamma_{iakb,jbla}
Reference for Lebedev-Laikov grid:
V. I. Lebedev, and D. N. Laikov "A quadrature formula for the sphere of the
131st algebraic order of accuracy", Doklady Mathematics, 59, 477-481 (1999)
'''
import ctypes
import numpy
from pyscf import lib
from pyscf.lib import logger
from pyscf import gto
from pyscf.dft import radi
from pyscf import __config__
libdft = lib.load_library('libdft')
BLKSIZE = 128 # needs to be the same to lib/gto/grid_ao_drv.c
# ~= (L+1)**2/3
LEBEDEV_ORDER = {
0: 1,
3: 6,
5: 14,
7: 26,
9: 38,
11: 50,
13: 74,
15: 86,
17: 110,
19: 146,
21: 170,
# Author: Qiming Sun <*****@*****.**>
#
import time
import ctypes
import tempfile
import numpy
import h5py
import pyscf.lib as lib
from pyscf.lib import logger
import pyscf.ao2mo
import pyscf.cc.ccsd_slow as ccsd
from pyscf.cc import ccsd_rdm
from pyscf import grad
libcc = lib.load_library('libcc')
def IX_intermediates(cc, t1, t2, l1, l2, eris=None, d1=None, d2=None):
if eris is None:
# Note eris are in Chemist's notation
eris = ccsd._ERIS(cc)
if d1 is None:
doo, dvv = ccsd_rdm.gamma1_intermediates(cc, t1, t2, l1, l2)
else:
doo, dvv = d1
if d2 is None:
# Note gamma2 are in Chemist's notation
d2 = ccsd_rdm.gamma2_intermediates(cc, t1, t2, l1, l2)
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = d2
dvvov = dovvv.transpose(2,3,0,1)
nocc, nvir = t1.shape
#!/usr/bin/env python
import os
import ctypes
import numpy
from pyscf import lib
libcc = lib.load_library("libcc")
# NOTE requisite on data continuous
def unpack_tril(tril, out=None):
assert tril.flags.c_contiguous
count = tril.shape[0]
nd = int(numpy.sqrt(tril.shape[1] * 2))
if out is None:
out = numpy.empty((count, nd, nd))
libcc.CCunpack_tril(
tril.ctypes.data_as(ctypes.c_void_p), out.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(count), ctypes.c_int(nd)
)
return out
def pack_tril(mat, out=None):
assert mat.flags.c_contiguous
count, nd = mat.shape[:2]
if out is None:
out = numpy.empty((count, nd * (nd + 1) // 2))
libcc.CCpack_tril(
(JCTC 2016, 12, 3674-3680)
Simple usage::
'''
import numpy
import time
import ctypes
from pyscf import lib
from pyscf import ao2mo
from pyscf.lib import logger
from pyscf.fci import cistring
from pyscf.fci import direct_spin1
libhci = lib.load_library('libhci')
def contract_2e_ctypes(h1_h2, civec, norb, nelec, hdiag=None, **kwargs):
h1, eri = h1_h2
strs = civec._strs
ndet = len(strs)
if hdiag is None:
hdiag = make_hdiag(h1, eri, strs, norb, nelec)
ci1 = numpy.zeros_like(civec)
h1 = numpy.asarray(h1, order='C')
eri = numpy.asarray(eri, order='C')
strs = numpy.asarray(strs, order='C')
civec = numpy.asarray(civec, order='C')
hdiag = numpy.asarray(hdiag, order='C')
ci1 = numpy.asarray(ci1, order='C')
if (sys.platform.startswith('linux') or
sys.platform.startswith('gnukfreebsd')):
so_ext = '.so'
elif sys.platform.startswith('darwin'):
so_ext = '.dylib'
elif sys.platform.startswith('win'):
so_ext = '.dll'
else:
raise OSError('Unknown platform')
libname_so = libname + so_ext
return ctypes.CDLL(os.path.join(os.path.dirname(__file__), libname_so))
else:
_loaderpath = os.path.dirname(__file__)
return np.ctypeslib.load_library(libname, _loaderpath)
libdft = lib.load_library('libdft')
libcvhf = lib.load_library('libcvhf')
def eval_rhoc(mol, ao, mo_coeff, mo_occ, non0tab=None, xctype='LDA',
verbose=None):
assert(ao.flags.c_contiguous)
xctype = xctype.upper()
if xctype == 'LDA':
ngrids, nao = ao.shape
else:
ngrids, nao = ao[0].shape
if non0tab is None:
non0tab = np.ones(((ngrids+BLKSIZE-1)//BLKSIZE,mol.nbas),
dtype=np.int8)
pos = mo_occ.real > OCCDROP
import struct
import time
import tempfile
from subprocess import check_call, check_output, STDOUT, CalledProcessError
import numpy
from pyscf import lib
from pyscf import tools
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf import mcscf
from pyscf.dmrgscf import dmrg_sym
from pyscf import __config__
# Libraries
import pyscf.lib
libunpack = lib.load_library('libicmpspt')
# Settings
try:
from pyscf.dmrgscf import settings
except ImportError:
settings = lambda: None
settings.BLOCKEXE = getattr(__config__, 'dmrgscf_BLOCKEXE', None)
settings.BLOCKEXE_COMPRESS_NEVPT = \
getattr(__config__, 'dmrgscf_BLOCKEXE_COMPRESS_NEVPT', None)
settings.BLOCKSCRATCHDIR = getattr(__config__, 'dmrgscf_BLOCKSCRATCHDIR', None)
settings.BLOCKRUNTIMEDIR = getattr(__config__, 'dmrgscf_BLOCKRUNTIMEDIR', None)
settings.MPIPREFIX = getattr(__config__, 'dmrgscf_MPIPREFIX', None)
settings.BLOCKVERSION = getattr(__config__, 'dmrgscf_BLOCKVERSION', None)
if (settings.BLOCKEXE is None or settings.BLOCKSCRATCHDIR is None):
import sys
>>> mf = scf.RHF(mol).run()
>>> h1 = mf.mo_coeff.T.dot(mf.get_hcore()).dot(mf.mo_coeff)
>>> h2 = ao2mo.kernel(mol, mf.mo_coeff)
>>> e = fci.select_ci.kernel(h1, h2, mf.mo_coeff.shape[1], mol.nelectron)[0]
"""
import ctypes
import numpy
from pyscf import lib
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf.fci import cistring
from pyscf.fci import direct_spin1
from pyscf.fci import rdm
libfci = lib.load_library("libfci")
def contract_2e(eri, civec_strs, norb, nelec, link_index=None):
ci_coeff, nelec, ci_strs = _unpack(civec_strs, nelec)
if link_index is None:
link_index = _all_linkstr_index(ci_strs, norb, nelec)
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = cd_indexa.shape[:2]
nb, nlinkb = cd_indexb.shape[:2]
ma, mlinka = dd_indexa.shape[:2]
mb, mlinkb = dd_indexb.shape[:2]
eri = ao2mo.restore(1, eri, norb)
eri1 = eri.transpose(0, 2, 1, 3) - eri.transpose(0, 2, 3, 1)
idx, idy = numpy.tril_indices(norb, -1)
# limitations under the License.
#
# Author: Qiming Sun <*****@*****.**>
#
import copy
import time
import ctypes
import numpy
import scipy.linalg
from pyscf import lib
from pyscf import scf
from pyscf.lib import logger
from pyscf.ao2mo import _ao2mo
libri = lib.load_library('libri')
def density_fit(mf, auxbasis=None, with_df=None, only_dfj=False):
'''For the given SCF object, update the J, K matrix constructor with
corresponding density fitting integrals.
Args:
mf : an SCF object
Kwargs:
auxbasis : str or basis dict
Same format to the input attribute mol.basis. If auxbasis is
None, optimal auxiliary basis based on AO basis (if possible) or
even-tempered Gaussian basis will be used.
import numpy
import ctypes
import math
from functools import reduce
#import sys, os
#sys.path.append(os.path.join(os.path.dirname(__file__), '../lib'))
from shci4qmc.lib.rel_parity import rel_parity
import shci4qmc.src.vec as vec
import pyscf
from pyscf import symm
from pyscf.lib import load_library
ndpointer = numpy.ctypeslib.ndpointer
shci_lib = load_library('libshciscf')
transformComplex = shci_lib.transformDinfh
transformComplex.restyp = None
transformComplex.argtypes = [
ctypes.c_int,
ndpointer(ctypes.c_int32),
ndpointer(ctypes.c_int32),
ndpointer(ctypes.c_double),
ndpointer(ctypes.c_double),
ndpointer(ctypes.c_double)
]
writeIntNoSymm = shci_lib.writeIntNoSymm
writeIntNoSymm.argtypes = [
ctypes.c_int,
except ImportError:
from pyscf import __config__
settings = lambda: None
settings.SHCIEXE = getattr(__config__, 'shci_SHCIEXE', None)
settings.SHCISCRATCHDIR = getattr(__config__, 'shci_SHCISCRATCHDIR', None)
settings.SHCIRUNTIMEDIR = getattr(__config__, 'shci_SHCIRUNTIMEDIR', None)
settings.MPIPREFIX = getattr(__config__, 'shci_MPIPREFIX', None)
if (settings.SHCIEXE is None or settings.SHCISCRATCHDIR is None):
import sys
sys.stderr.write(
'settings.py not found. Please create %s\n' %
os.path.join(os.path.dirname(__file__), 'settings.py'))
raise ImportError('settings.py not found')
# Libraries
libE3unpack = load_library('libicmpspt')
# TODO: Organize this better.
shciLib = load_library('libshciscf')
transformDinfh = shciLib.transformDinfh
transformDinfh.restyp = None
transformDinfh.argtypes = [
ctypes.c_int,
ndpointer(ctypes.c_int32),
ndpointer(ctypes.c_int32),
ndpointer(ctypes.c_double),
ndpointer(ctypes.c_double),
ndpointer(ctypes.c_double)
]
transformRDMDinfh = shciLib.transformRDMDinfh
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Author: Qiming Sun <*****@*****.**>
#
import warnings
import ctypes
import numpy
from pyscf import lib
from pyscf.gto.moleintor import make_loc
BLKSIZE = 128 # needs to be the same to lib/gto/grid_ao_drv.c
libcgto = lib.load_library('libcgto')
def eval_gto(mol, eval_name, coords,
comp=None, shls_slice=None, non0tab=None, ao_loc=None, out=None):
r'''Evaluate AO function value on the given grids,
Args:
eval_name : str
================== ====== =======================
Function comp Expression
================== ====== =======================
"GTOval_sph" 1 |AO>
"GTOval_ip_sph" 3 nabla |AO>
"GTOval_ig_sph" 3 (#C(0 1) g) |AO>
"GTOval_ipig_sph" 3 (#C(0 1) nabla g) |AO>
import sys
import struct
import time
import tempfile
from subprocess import check_call, check_output, STDOUT, CalledProcessError
import numpy
from pyscf import lib
from pyscf import tools
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf import mcscf
from pyscf.dmrgscf import dmrg_sym
from pyscf import __config__
# Libraries
libunpack = lib.load_library('libicmpspt')
# Settings
try:
from pyscf.dmrgscf import settings
except ImportError:
settings = lambda: None
settings.BLOCKEXE = getattr(__config__, 'dmrgscf_BLOCKEXE', None)
settings.BLOCKEXE_COMPRESS_NEVPT = \
getattr(__config__, 'dmrgscf_BLOCKEXE_COMPRESS_NEVPT', None)
settings.BLOCKSCRATCHDIR = getattr(__config__, 'dmrgscf_BLOCKSCRATCHDIR',
None)
settings.BLOCKRUNTIMEDIR = getattr(__config__, 'dmrgscf_BLOCKRUNTIMEDIR',
None)
settings.MPIPREFIX = getattr(__config__, 'dmrgscf_MPIPREFIX', None)
settings.BLOCKVERSION = getattr(__config__, 'dmrgscf_BLOCKVERSION', None)
def getints4c(intor_name,
atm,
bas,
env,
shls_slice=None,
comp=1,
aosym='s1',
ao_loc=None,
cintopt=None,
out=None):
aosym = _stand_sym_code(aosym)
atm = numpy.asarray(atm, dtype=numpy.int32, order='C')
bas = numpy.asarray(bas, dtype=numpy.int32, order='C')
env = numpy.asarray(env, dtype=numpy.double, order='C')
c_atm = atm.ctypes.data_as(ctypes.c_void_p)
c_bas = bas.ctypes.data_as(ctypes.c_void_p)
c_env = env.ctypes.data_as(ctypes.c_void_p)
natm = atm.shape[0]
nbas = bas.shape[0]
ao_loc = make_loc(bas, intor_name)
if cintopt is None:
cintopt = make_cintopt(atm, bas, env, intor_name)
if aosym == 's8':
#assert(intor_name in ('int2e_sph', 'int2e_cart'))
assert (shls_slice is None)
libcvhf = lib.load_library('libcvhf')
nao = ao_loc[-1]
nao_pair = nao * (nao + 1) // 2
out = numpy.ndarray((nao_pair * (nao_pair + 1) // 2), buffer=out)
drv = libcvhf.GTO2e_cart_or_sph
drv(getattr(libcgto, intor_name), out.ctypes.data_as(ctypes.c_void_p),
ao_loc.ctypes.data_as(ctypes.c_void_p), c_atm, ctypes.c_int(natm),
c_bas, ctypes.c_int(nbas), c_env)
return out
else:
if shls_slice is None:
shls_slice = (0, nbas, 0, nbas, 0, nbas, 0, nbas)
elif len(shls_slice) == 4:
shls_slice = shls_slice + (0, nbas, 0, nbas)
else:
assert (shls_slice[1] <= nbas and shls_slice[3] <= nbas
and shls_slice[5] <= nbas and shls_slice[7] <= nbas)
i0, i1, j0, j1, k0, k1, l0, l1 = shls_slice
naoi = ao_loc[i1] - ao_loc[i0]
naoj = ao_loc[j1] - ao_loc[j0]
naok = ao_loc[k1] - ao_loc[k0]
naol = ao_loc[l1] - ao_loc[l0]
if aosym in ('s4', 's2ij'):
nij = naoi * (naoi + 1) // 2
assert (numpy.all(ao_loc[i0:i1] - ao_loc[i0] == ao_loc[j0:j1] -
ao_loc[j0]))
else:
nij = naoi * naoj
if aosym in ('s4', 's2kl'):
nkl = naok * (naok + 1) // 2
assert (numpy.all(ao_loc[k0:k1] - ao_loc[k0] == ao_loc[l0:l1] -
ao_loc[l0]))
else:
nkl = naok * naol
if comp == 1:
out = numpy.ndarray((nij, nkl), buffer=out)
else:
out = numpy.ndarray((comp, nij, nkl), buffer=out)
prescreen = lib.c_null_ptr()
drv = libcgto.GTOnr2e_fill_drv
drv(getattr(libcgto, intor_name),
getattr(libcgto, 'GTOnr2e_fill_' + aosym), prescreen,
out.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(comp),
(ctypes.c_int * 8)(*shls_slice),
ao_loc.ctypes.data_as(ctypes.c_void_p), cintopt, c_atm,
ctypes.c_int(natm), c_bas, ctypes.c_int(nbas), c_env)
return out
#!/usr/bin/env python
import os
import ctypes
import unittest
import numpy
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
libcvhf2 = lib.load_library("libcvhf")
mol = gto.Mole()
mol.verbose = 0
mol.output = None #'out_h2o'
mol.atom = [["O", (0.0, 0.0, 0.0)], [1, (0.0, -0.757, 0.587)], [1, (0.0, 0.757, 0.587)]]
mol.basis = "cc-pvdz"
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
nao = mol.nao_nr()
npair = nao * (nao + 1) // 2
c_atm = numpy.array(mol._atm, dtype=numpy.int32)
c_bas = numpy.array(mol._bas, dtype=numpy.int32)
c_env = numpy.array(mol._env)
natm = ctypes.c_int(c_atm.shape[0])
from pyscf import gto, scf
from pyscf.tools import molden
from pyscf.lib import parameters as param
from pyscf.lib import logger
from pyscf.lib import linalg_helper
from pyscf.scf import _vhf
from pyscf import ao2mo
import numpy as np
import scipy
#import time
import ctypes
import _ctypes
from pyscf.lib import load_library
liblocalizer = load_library('liblocalizer')
class localizer:
def __init__( self, mol, orbital_coeff, thetype, use_full_hessian=True ):
r'''Initializer for the localization procedure
Args:
mol : A molecule which has been built
orbital_coeff: Set of orthonormal orbitals, expressed in terms of the AO, which should be localized
thetype: Which cost function to optimize: 'boys' or 'edmiston'
use_full_hessian: Whether to do augmented Hessian Newton-Raphson (True) or just -gradient/diag(hessian) (False)
'''
assert( ( thetype == 'boys' ) or ( thetype == 'edmiston' ) )
import os
import ctypes
import time
import tempfile
from functools import reduce
import numpy
import h5py
from pyscf import lib
from pyscf.lib import logger
from pyscf import fci
from pyscf.mcscf import mc_ao2mo
from pyscf import ao2mo
from pyscf.ao2mo import _ao2mo
libmc = lib.load_library('libmcscf')
NUMERICAL_ZERO = 1e-14
# Ref JCP, 117, 9138
# h1e is the CAS space effective 1e hamiltonian
# h2e is the CAS space 2e integrals in notation # a' -> p # b' -> q # c' -> r
# d' -> s
def make_a16(h1e, h2e, dms, civec, norb, nelec, link_index=None):
dm3 = dms['3']
#dm4 = dms['4']
if 'f3ca' in dms and 'f3ac' in dms:
f3ca = dms['f3ca']
f3ac = dms['f3ac']
else:
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Author: Oliver J. Backhouse <*****@*****.**>
# Alejandro Santana-Bonilla <*****@*****.**>
# George H. Booth <*****@*****.**>
#
import numpy as np
import ctypes
from pyscf import lib
from pyscf.agf2 import mpi_helper
libagf2 = lib.load_library('libagf2')
def cholesky_build(vv, vev, eps=1e-16):
''' Constructs the truncated auxiliaries from :attr:`vv` and :attr:`vev`.
Performs a Cholesky decomposition via :func:`numpy.linalg.cholesky`,
for a positive-definite or positive-semidefinite matrix. For the
latter, the null space is removed.
The :attr:`vv` matrix of :func:`build_se_part` can be positive-
semidefinite when :attr:`gf_occ.naux` < :attr:`gf_occ.nphys` for
the occupied self-energy, or :attr:`gf_vir.naux` < :attr:`gf_vir.nphys`
for the virtual self-energy.
'''
nmo = vv.shape[0]
#!/usr/bin/env python
#
# Author: Qiming Sun <*****@*****.**>
#
import ctypes
import numpy
from pyscf import lib
from pyscf.lib import logger
from pyscf import ao2mo
from pyscf.fci import direct_spin1
from pyscf.fci import direct_spin1_symm
from pyscf.fci import select_ci
from pyscf.fci import addons
libfci = lib.load_library('libfci')
def reorder4irrep_minors(eri, norb, link_index, orbsym):
if orbsym is None:
return eri, link_index, numpy.array(norb, dtype=numpy.int32)
orbsym = numpy.asarray(orbsym) % 10
trilirrep = (orbsym[:,None]^orbsym)[numpy.tril_indices(norb,-1)]
dimirrep = numpy.array(numpy.bincount(trilirrep), dtype=numpy.int32)
order = numpy.argsort(trilirrep)
rank = order.argsort()
eri = lib.take_2d(eri, order, order)
link_index_irrep = link_index.copy()
link_index_irrep[:,:,0] = rank[link_index[:,:,0]]
return numpy.asarray(eri, order='C'), link_index_irrep, dimirrep
def contract_2e(eri, civec_strs, norb, nelec, link_index=None, orbsym=None):
# Author: Qiming Sun <*****@*****.**>
#
import time
import ctypes
import tempfile
import numpy
import h5py
import pyscf.lib as lib
from pyscf.lib import logger
import pyscf.ao2mo
import pyscf.cc.ccsd_slow as ccsd
from pyscf.cc import ccsd_rdm
from pyscf import grad
libcc = lib.load_library('libcc')
def IX_intermediates(cc, t1, t2, l1, l2, eris=None, d1=None, d2=None):
if eris is None:
# Note eris are in Chemist's notation
eris = ccsd._ERIS(cc)
if d1 is None:
doo, dov, dvo, dvv = ccsd_rdm.gamma1_intermediates(cc, t1, t2, l1, l2)
else:
doo, dov, dvo, dvv = d1
if d2 is None:
# Note gamma2 are in Chemist's notation
d2 = ccsd_rdm.gamma2_intermediates(cc, t1, t2, l1, l2)
dovov, dvvvv, doooo, doovv, dovvo, dvvov, dovvv, dooov = d2
dvvov = dovvv.transpose(2,3,0,1)
nocc, nvir = t1.shape
import ctypes
import numpy as np
import scipy.linalg
import scipy.optimize
import pyscf.lib.parameters as param
from pyscf import lib
from pyscf.lib import logger
from pyscf.gto import mole
from pyscf.gto import moleintor
from pyscf.gto.mole import _symbol, _rm_digit, _std_symbol, _charge
from pyscf.gto.mole import conc_env
from pyscf.pbc.gto import basis
from pyscf.pbc.gto import pseudo
from pyscf.pbc.tools import pbc as pbctools
libpbc = lib.load_library('libpbc')
def M(**kwargs):
r'''This is a shortcut to build up Cell object.
Examples:
>>> from pyscf.pbc import gto
>>> cell = gto.M(h=numpy.eye(3)*4, atom='He 1 1 1', basis='6-31g', gs=[10]*3)
'''
cell = Cell()
cell.build(**kwargs)
return cell
def format_pseudo(pseudo_tab):
#!/usr/bin/env python
import os
import ctypes
import _ctypes
import unittest
import numpy
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
libcvhf2 = lib.load_library('libcvhf')
mol = gto.Mole()
mol.verbose = 0
mol.output = None#'out_h2o'
mol.atom = [
['O' , (0. , 0. , 0.)],
[1 , (0. , -0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)] ]
mol.basis = 'cc-pvdz'
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
nao = mol.nao_nr()
npair = nao*(nao+1)//2
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Author: Qiming Sun <*****@*****.**>
#
import ctypes
import tempfile
import numpy
import h5py
from pyscf import lib
libao2mo = lib.load_library('libao2mo')
class load(object):
'''load 2e integrals from hdf5 file
Usage:
with load(erifile) as eri:
print(eri.shape)
'''
def __init__(self, eri, dataname='eri_mo'):
self.eri = eri
self.dataname = dataname
self.feri = None
def __enter__(self):
if isinstance(self.eri, str):
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ctypes
import unittest
import numpy
from pyscf import lib, gto, df
from pyscf.gto.eval_gto import BLKSIZE
libcgto = lib.load_library('libdft')
mol = gto.M(atom='''
O 0.5 0.5 0.
H 1. 1.2 0.
H 0. 0. 1.3
''',
basis='ccpvqz')
def eval_gto(mol, eval_name, coords,
comp=1, shls_slice=None, non0tab=None, ao_loc=None, out=None):
atm = numpy.asarray(mol._atm, dtype=numpy.int32, order='C')
bas = numpy.asarray(mol._bas, dtype=numpy.int32, order='C')
env = numpy.asarray(mol._env, dtype=numpy.double, order='C')
coords = numpy.asarray(coords, dtype=numpy.double, order='F')
natm = atm.shape[0]
#
import ctypes
import time
import tempfile
from functools import reduce
import numpy
import h5py
from pyscf import lib
from pyscf.lib import logger
from pyscf import fci
from pyscf.mcscf import mc_ao2mo
from pyscf import ao2mo
from pyscf.ao2mo import _ao2mo
libmc = lib.load_library('libmcscf')
NUMERICAL_ZERO = 1e-14
# Ref JCP 117, 9138 (2002); DOI:10.1063/1.1515317
# h1e is the CAS space effective 1e hamiltonian
# h2e is the CAS space 2e integrals in notation # a' -> p # b' -> q # c' -> r
# d' -> s
def make_a16(h1e, h2e, dms, civec, norb, nelec, link_index=None):
dm3 = dms['3']
#dm4 = dms['4']
if 'f3ca' in dms and 'f3ac' in dms:
f3ca = dms['f3ca']
f3ac = dms['f3ac']
else:
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import ctypes
import unittest
import numpy
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
# FIXME
libri1 = lib.load_library('libri')
mol = gto.Mole()
mol.verbose = 0
mol.output = None#'out_h2o'
mol.atom = [
['O' , (0. , 0. , 0.)],
[1 , (0. , -0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)] ]
mol.basis = {'H': 'cc-pvdz',
'O': 'cc-pvdz',}
mol.build()
rhf = scf.RHF(mol)
rhf.scf()
import scipy.linalg
import scipy.optimize
import pyscf.lib.parameters as param
from pyscf import lib
from pyscf import dft
from pyscf.lib import logger
from pyscf.gto import mole
from pyscf.gto import moleintor
from pyscf.gto.mole import _symbol, _rm_digit, _std_symbol, _charge
from pyscf.gto.mole import conc_env
from pyscf.pbc.gto import basis
from pyscf.pbc.gto import pseudo
from pyscf.pbc.tools import pbc as pbctools
from pyscf.gto.basis import ALIAS as MOLE_ALIAS
libpbc = lib.load_library('libpbc')
def M(**kwargs):
r'''This is a shortcut to build up Cell object.
Examples:
>>> from pyscf.pbc import gto
>>> cell = gto.M(a=numpy.eye(3)*4, atom='He 1 1 1', basis='6-31g', gs=[10]*3)
'''
cell = Cell()
cell.build(**kwargs)
return cell
# limitations under the License.
import os
import ctypes
import unittest
from functools import reduce
import numpy
import h5py
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
from pyscf.ao2mo import _ao2mo
from pyscf.scf import _vhf
libao2mo1 = lib.load_library('libao2mo')
mol = gto.Mole()
mol.verbose = 0
mol.output = None #'out_h2o'
mol.atom.extend([['O', (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]])
mol.basis = 'cc-pvdz'
mol.build()
nao = mol.nao_nr()
naopair = nao * (nao + 1) // 2
numpy.random.seed(15)
mo = numpy.random.random((nao, nao))
mo = mo.copy(order='F')
# limitations under the License.
#
# Author: Qiming Sun <*****@*****.**>
#
import ctypes
import numpy
from pyscf import lib
from pyscf import ao2mo
from pyscf.fci import direct_spin1
from pyscf.fci import direct_spin1_symm
from pyscf.fci import selected_ci
from pyscf.fci import selected_ci_symm
from pyscf.fci import selected_ci_spin0
libfci = lib.load_library('libfci')
def contract_2e(eri, civec_strs, norb, nelec, link_index=None, orbsym=None):
ci_coeff, nelec, ci_strs = selected_ci._unpack(civec_strs, nelec)
if link_index is None:
link_index = selected_ci._all_linkstr_index(ci_strs, norb, nelec)
cd_indexa, dd_indexa, cd_indexb, dd_indexb = link_index
na, nlinka = nb, nlinkb = cd_indexa.shape[:2]
eri = ao2mo.restore(1, eri, norb)
eri1 = eri.transpose(0, 2, 1, 3) - eri.transpose(0, 2, 3, 1)
idx, idy = numpy.tril_indices(norb, -1)
idx = idx * norb + idy
eri1 = lib.take_2d(eri1.reshape(norb**2, -1), idx, idx) * 2
lib.transpose_sum(eri1, inplace=True)
#!/usr/bin/env python
import os
import ctypes
import _ctypes
import unittest
from functools import reduce
import numpy
import h5py
from pyscf import lib
from pyscf import scf
from pyscf import gto
from pyscf import ao2mo
import pyscf.scf._vhf as _vhf
libcvhf = lib.load_library("libcvhf")
libao2mo1 = lib.load_library("libao2mo")
mol = gto.Mole()
mol.verbose = 0
mol.output = None #'out_h2o'
mol.atom.extend([["O", (0.0, 0.0, 0.0)], [1, (0.0, -0.757, 0.587)], [1, (0.0, 0.757, 0.587)]])
mol.basis = "cc-pvdz"
mol.build()
nao = mol.nao_nr()
naopair = nao * (nao + 1) // 2
numpy.random.seed(15)
mo = numpy.random.random((nao, nao))
mo = mo.copy(order="F")
