def make_rdm1_spin1(fname, cibra, ciket, norb, nelec, link_index=None):
assert(cibra is not None and ciket is not None)
cibra = numpy.asarray(cibra, order='C')
ciket = numpy.asarray(ciket, order='C')
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = link_indexb = cistring.gen_linkstr_index(range(norb), neleca)
if neleca != nelecb:
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
else:
link_indexa, link_indexb = link_index
na,nlinka = link_indexa.shape[:2]
nb,nlinkb = link_indexb.shape[:2]
assert(cibra.size == na*nb)
assert(ciket.size == na*nb)
rdm1 = numpy.empty((norb,norb))
fn = getattr(librdm, fname)
fn(rdm1.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(nlinka), ctypes.c_int(nlinkb),
link_indexa.ctypes.data_as(ctypes.c_void_p),
link_indexb.ctypes.data_as(ctypes.c_void_p))
return rdm1.T
def make_rdm1_spin1(fname, cibra, ciket, norb, nelec, link_index=None):
assert (cibra is not None and ciket is not None)
cibra = numpy.asarray(cibra, order='C')
ciket = numpy.asarray(ciket, order='C')
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = link_indexb = cistring.gen_linkstr_index(
range(norb), neleca)
if neleca != nelecb:
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
else:
link_indexa, link_indexb = link_index
na, nlinka = link_indexa.shape[:2]
nb, nlinkb = link_indexb.shape[:2]
assert (cibra.size == na * nb)
assert (ciket.size == na * nb)
rdm1 = numpy.empty((norb, norb))
fn = getattr(librdm, fname)
fn(rdm1.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb), ctypes.c_int(nlinka),
ctypes.c_int(nlinkb), link_indexa.ctypes.data_as(ctypes.c_void_p),
link_indexb.ctypes.data_as(ctypes.c_void_p))
return rdm1.T
def contract_2e(self, eri, fcivec, norb, nelec, link_index=None,
orbsym=None, wfnsym=None, **kwargs):
if orbsym is None: orbsym = self.orbsym
if wfnsym is None: wfnsym = self.wfnsym
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
nelec = _unpack_nelec(nelec, self.spin)
return contract_2e(eri, fcivec, norb, nelec, link_index, orbsym, wfnsym, **kwargs)
def make_rdm12_ms0(fname, cibra, ciket, norb, nelec, link_index=None, symm=0):
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
assert(neleca == nelecb)
link_index = cistring.gen_linkstr_index(range(norb), neleca)
link_index = (link_index, link_index)
return make_rdm12_spin1(fname, cibra, ciket, norb, nelec, link_index, symm)
def make_rdm12_ms0(fname, cibra, ciket, norb, nelec, link_index=None, symm=0):
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
assert (neleca == nelecb)
link_index = cistring.gen_linkstr_index(range(norb), neleca)
link_index = (link_index, link_index)
return make_rdm12_spin1(fname, cibra, ciket, norb, nelec, link_index, symm)
def guess_wfnsym(self,
norb,
nelec,
fcivec=None,
orbsym=None,
wfnsym=None,
**kwargs):
'''
Guess point group symmetry of the FCI wavefunction. If fcivec is
given, the symmetry of fcivec is used. Otherwise the symmetry is
based on the HF determinant.
'''
if orbsym is None:
orbsym = self.orbsym
nelec = _unpack_nelec(nelec, self.spin)
if fcivec is None:
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
else:
# TODO: if wfnsym is given in the input, check whether the
# symmetry of fcivec is consistent with given wfnsym.
wfnsym = addons.guess_wfnsym(fcivec, norb, nelec, orbsym)
verbose = kwargs.get('verbose', None)
log = logger.new_logger(self, verbose)
log.debug('Guessing CI wfn symmetry = %s', wfnsym)
return wfnsym
def get_init_guess(norb, nelec, nroots, hdiag):
'''Initial guess is the single Slater determinant
'''
neleca, nelecb = _unpack_nelec(nelec)
na = cistring.num_strings(norb, neleca)
nb = cistring.num_strings(norb, nelecb)
return _get_init_guess(na, nb, nroots, hdiag)
def make_hdiag(h1e, eri, norb, nelec):
'''Diagonal Hamiltonian for Davidson preconditioner
'''
if h1e.dtype == numpy.complex or eri.dtype == numpy.complex:
raise NotImplementedError('Complex Hamiltonian')
neleca, nelecb = _unpack_nelec(nelec)
h1e = numpy.asarray(h1e, order='C')
eri = ao2mo.restore(1, eri, norb)
occslsta = occslstb = cistring._gen_occslst(range(norb), neleca)
if neleca != nelecb:
occslstb = cistring._gen_occslst(range(norb), nelecb)
na = len(occslsta)
nb = len(occslstb)
hdiag = numpy.empty(na * nb)
jdiag = numpy.asarray(numpy.einsum('iijj->ij', eri), order='C')
kdiag = numpy.asarray(numpy.einsum('ijji->ij', eri), order='C')
c_h1e = h1e.ctypes.data_as(ctypes.c_void_p)
c_jdiag = jdiag.ctypes.data_as(ctypes.c_void_p)
c_kdiag = kdiag.ctypes.data_as(ctypes.c_void_p)
libfci.FCImake_hdiag_uhf(hdiag.ctypes.data_as(ctypes.c_void_p), c_h1e,
c_h1e, c_jdiag, c_jdiag, c_jdiag, c_kdiag,
c_kdiag, ctypes.c_int(norb), ctypes.c_int(na),
ctypes.c_int(nb), ctypes.c_int(neleca),
ctypes.c_int(nelecb),
occslsta.ctypes.data_as(ctypes.c_void_p),
occslstb.ctypes.data_as(ctypes.c_void_p))
return hdiag
def make_hdiag(h1e, eri, norb, nelec):
'''Diagonal Hamiltonian for Davidson preconditioner
'''
neleca, nelecb = _unpack_nelec(nelec)
h1e = numpy.asarray(h1e, order='C')
eri = ao2mo.restore(1, eri, norb)
occslsta = occslstb = cistring._gen_occslst(range(norb), neleca)
if neleca != nelecb:
occslstb = cistring._gen_occslst(range(norb), nelecb)
na = len(occslsta)
nb = len(occslstb)
hdiag = numpy.empty(na*nb)
jdiag = numpy.asarray(numpy.einsum('iijj->ij',eri), order='C')
kdiag = numpy.asarray(numpy.einsum('ijji->ij',eri), order='C')
c_h1e = h1e.ctypes.data_as(ctypes.c_void_p)
c_jdiag = jdiag.ctypes.data_as(ctypes.c_void_p)
c_kdiag = kdiag.ctypes.data_as(ctypes.c_void_p)
libfci.FCImake_hdiag_uhf(hdiag.ctypes.data_as(ctypes.c_void_p),
c_h1e, c_h1e, c_jdiag, c_jdiag, c_jdiag, c_kdiag, c_kdiag,
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(neleca), ctypes.c_int(nelecb),
occslsta.ctypes.data_as(ctypes.c_void_p),
occslstb.ctypes.data_as(ctypes.c_void_p))
return hdiag
def get_init_guess(norb, nelec, nroots, hdiag):
'''Initial guess is the single Slater determinant
'''
neleca, nelecb = _unpack_nelec(nelec)
na = cistring.num_strings(norb, neleca)
nb = cistring.num_strings(norb, nelecb)
return _get_init_guess(na, nb, nroots, hdiag)
def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
neleca, nelecb = _unpack_nelec(nelec)
strsa = cistring.gen_strings4orblist(range(norb), neleca)
airreps = birreps = _gen_strs_irrep(strsa, orbsym)
if neleca != nelecb:
strsb = cistring.gen_strings4orblist(range(norb), nelecb)
birreps = _gen_strs_irrep(strsb, orbsym)
return _get_init_guess(airreps, birreps, nroots, hdiag, orbsym, wfnsym)
def make_rdm2(self, fcivec, norb, nelec, link_index=None, reorder=True):
r'''Spin traced 2-particle density matrice
NOTE the 2pdm is :math:`\langle p^\dagger q^\dagger s r\rangle` but
stored as [p,r,q,s]
'''
nelec = _unpack_nelec(nelec, self.spin)
return self.make_rdm12(fcivec, norb, nelec, link_index, reorder)[1]
def get_init_guess(norb, nelec, nroots, hdiag, orbsym, wfnsym=0):
neleca, nelecb = _unpack_nelec(nelec)
strsa = cistring.gen_strings4orblist(range(norb), neleca)
airreps = birreps = _gen_strs_irrep(strsa, orbsym)
if neleca != nelecb:
strsb = cistring.gen_strings4orblist(range(norb), nelecb)
birreps = _gen_strs_irrep(strsb, orbsym)
return _get_init_guess(airreps, birreps, nroots, hdiag, orbsym, wfnsym)
def make_rdm2(self, fcivec, norb, nelec, link_index=None, reorder=True):
r'''Spin traced 2-particle density matrice
NOTE the 2pdm is :math:`\langle p^\dagger q^\dagger s r\rangle` but
stored as [p,r,q,s]
'''
nelec = _unpack_nelec(nelec, self.spin)
return self.make_rdm12(fcivec, norb, nelec, link_index, reorder)[1]
def trans_rdm12(self,
cibra,
ciket,
norb,
nelec,
link_index=None,
reorder=True):
nelec = _unpack_nelec(nelec, self.spin)
return trans_rdm12(cibra, ciket, norb, nelec, link_index, reorder)
def _unpack(norb, nelec, link_index, spin=None):
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec, spin)
link_indexa = link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), neleca)
if neleca != nelecb:
link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), nelecb)
return link_indexa, link_indexb
else:
return link_index
def large_ci(self,
fcivec,
norb,
nelec,
tol=getattr(__config__, 'fci_addons_large_ci_tol', .1),
return_strs=getattr(__config__,
'fci_addons_large_ci_return_strs', True)):
nelec = _unpack_nelec(nelec, self.spin)
return addons.large_ci(fcivec, norb, nelec, tol, return_strs)
def _id_wfnsym(cis, norb, nelec, orbsym, wfnsym):
if wfnsym is None:
neleca, nelecb = _unpack_nelec(nelec)
wfnsym = 0 # Ag, A1 or A
for i in orbsym[nelecb:neleca]:
wfnsym ^= i
elif isinstance(wfnsym, str):
wfnsym = symm.irrep_name2id(cis.mol.groupname, wfnsym)
return wfnsym % 10
def _id_wfnsym(cis, norb, nelec, orbsym, wfnsym):
if wfnsym is None:
neleca, nelecb = _unpack_nelec(nelec)
wfnsym = 0 # Ag, A1 or A
for i in orbsym[nelecb:neleca]:
wfnsym ^= i
elif isinstance(wfnsym, str):
wfnsym = symm.irrep_name2id(cis.mol.groupname, wfnsym)
return wfnsym % 10
def _unpack(norb, nelec, link_index, spin=None):
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec, spin)
link_indexa = link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), neleca)
if neleca != nelecb:
link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), nelecb)
return link_indexa, link_indexb
else:
return link_index
def _id_wfnsym(cisolver, norb, nelec, orbsym, wfnsym):
'''Guess wfnsym or convert wfnsym to symmetry ID if it's a symmetry label'''
if wfnsym is None:
neleca, nelecb = _unpack_nelec(nelec)
wfnsym = 0 # Ag, A1 or A
for i in orbsym[nelecb:neleca]:
wfnsym ^= i
elif isinstance(wfnsym, str):
wfnsym = symm.irrep_name2id(cisolver.mol.groupname, wfnsym)
return wfnsym % 10
def gen_linkstr(self, norb, nelec, tril=True, spin=None):
if spin is None:
spin = self.spin
neleca, nelecb = _unpack_nelec(nelec, spin)
if tril:
link_indexa = cistring.gen_linkstr_index_trilidx(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), nelecb)
else:
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
return link_indexa, link_indexb
def gen_linkstr(self, norb, nelec, tril=True, spin=None):
if spin is None:
spin = self.spin
neleca, nelecb = _unpack_nelec(nelec, spin)
if tril:
link_indexa = cistring.gen_linkstr_index_trilidx(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index_trilidx(range(norb), nelecb)
else:
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
return link_indexa, link_indexb
def pspace(h1e, eri, norb, nelec, hdiag=None, np=400):
'''pspace Hamiltonian to improve Davidson preconditioner. See, CPL, 169, 463
'''
if norb > 63:
raise NotImplementedError('norb > 63')
if h1e.dtype == numpy.complex or eri.dtype == numpy.complex:
raise NotImplementedError('Complex Hamiltonian')
neleca, nelecb = _unpack_nelec(nelec)
h1e = numpy.ascontiguousarray(h1e)
eri = ao2mo.restore(1, eri, norb)
nb = cistring.num_strings(norb, nelecb)
if hdiag is None:
hdiag = make_hdiag(h1e, eri, norb, nelec)
if hdiag.size < np:
addr = numpy.arange(hdiag.size)
else:
try:
addr = numpy.argpartition(hdiag, np - 1)[:np].copy()
except AttributeError:
addr = numpy.argsort(hdiag)[:np].copy()
addra, addrb = divmod(addr, nb)
stra = cistring.addrs2str(norb, neleca, addra)
strb = cistring.addrs2str(norb, nelecb, addrb)
np = len(addr)
h0 = numpy.zeros((np, np))
libfci.FCIpspace_h0tril(h0.ctypes.data_as(ctypes.c_void_p),
h1e.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
stra.ctypes.data_as(ctypes.c_void_p),
strb.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(np))
HERMITIAN_THRESHOLD = 1e-10
if (abs(h1e - h1e.T).max() < HERMITIAN_THRESHOLD and
abs(eri - eri.transpose(1, 0, 3, 2)).max() < HERMITIAN_THRESHOLD):
# symmetric Hamiltonian
h0 = lib.hermi_triu(h0)
else:
# Fill the upper triangular part
h0 = numpy.asarray(h0, order='F')
h1e = numpy.asarray(h1e.T, order='C')
eri = numpy.asarray(eri.transpose(1, 0, 3, 2), order='C')
libfci.FCIpspace_h0tril(h0.ctypes.data_as(ctypes.c_void_p),
h1e.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
stra.ctypes.data_as(ctypes.c_void_p),
strb.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(np))
idx = numpy.arange(np)
h0[idx, idx] = hdiag[addr]
return addr, h0
def guess_wfnsym(self,
norb,
nelec,
fcivec=None,
orbsym=None,
wfnsym=None,
**kwargs):
'''
Guess point group symmetry of the FCI wavefunction. If fcivec is
given, the symmetry of fcivec is used. Otherwise the symmetry is
based on the HF determinant.
'''
if orbsym is None:
orbsym = self.orbsym
verbose = kwargs.get('verbose', None)
log = logger.new_logger(self, verbose)
nelec = _unpack_nelec(nelec, self.spin)
if fcivec is None:
# guess wfnsym if initial guess is not given
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
log.debug('Guessing CI wfn symmetry = %s', wfnsym)
elif wfnsym is None:
wfnsym = addons.guess_wfnsym(fcivec, norb, nelec, orbsym)
log.debug('Guessing CI wfn symmetry = %s', wfnsym)
else:
# verify if the input wfnsym is consistent with the symmetry of fcivec
neleca, nelecb = nelec
strsa = numpy.asarray(cistring.make_strings(range(norb), neleca))
strsb = numpy.asarray(cistring.make_strings(range(norb), nelecb))
na, nb = strsa.size, strsb.size
orbsym_in_d2h = numpy.asarray(orbsym) % 10
airreps = numpy.zeros(na, dtype=numpy.int32)
birreps = numpy.zeros(nb, dtype=numpy.int32)
for i, ir in enumerate(orbsym_in_d2h):
airreps[numpy.bitwise_and(strsa, 1 << i) > 0] ^= ir
birreps[numpy.bitwise_and(strsb, 1 << i) > 0] ^= ir
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
mask = (airreps.reshape(-1, 1) ^ birreps) == wfnsym
if isinstance(fcivec, numpy.ndarray) and fcivec.ndim <= 2:
fcivec = [fcivec]
if all(abs(c.reshape(na, nb)[mask]).max() < 1e-5 for c in fcivec):
raise RuntimeError(
'Input wfnsym is not consistent with fcivec coefficients')
return wfnsym
def pspace(h1e, eri, norb, nelec, hdiag=None, np=400):
'''pspace Hamiltonian to improve Davidson preconditioner. See, CPL, 169, 463
'''
if norb > 63:
raise NotImplementedError('norb > 63')
neleca, nelecb = _unpack_nelec(nelec)
h1e = numpy.ascontiguousarray(h1e)
eri = ao2mo.restore(1, eri, norb)
nb = cistring.num_strings(norb, nelecb)
if hdiag is None:
hdiag = make_hdiag(h1e, eri, norb, nelec)
if hdiag.size < np:
addr = numpy.arange(hdiag.size)
else:
try:
addr = numpy.argpartition(hdiag, np-1)[:np]
except AttributeError:
addr = numpy.argsort(hdiag)[:np]
addra, addrb = divmod(addr, nb)
stra = cistring.addrs2str(norb, neleca, addra)
strb = cistring.addrs2str(norb, nelecb, addrb)
np = len(addr)
h0 = numpy.zeros((np,np))
libfci.FCIpspace_h0tril(h0.ctypes.data_as(ctypes.c_void_p),
h1e.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
stra.ctypes.data_as(ctypes.c_void_p),
strb.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(np))
HERMITIAN_THRESHOLD = 1e-10
if (abs(h1e - h1e.T).max() < HERMITIAN_THRESHOLD and
abs(eri - eri.transpose(1,0,3,2)).max() < HERMITIAN_THRESHOLD):
# symmetric Hamiltonian
h0 = lib.hermi_triu(h0)
else:
# Fill the upper triangular part
h0 = numpy.asarray(h0, order='F')
h1e = numpy.asarray(h1e.T, order='C')
eri = numpy.asarray(eri.transpose(1,0,3,2), order='C')
libfci.FCIpspace_h0tril(h0.ctypes.data_as(ctypes.c_void_p),
h1e.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
stra.ctypes.data_as(ctypes.c_void_p),
strb.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(np))
idx = numpy.arange(np)
h0[idx,idx] = hdiag[addr]
return addr, h0
def contract_sladder(fcivec, norb, nelec, op=-1):
''' Contract spin ladder operator S+ or S- with fcivec.
Changes neleca - nelecb without altering <S2>
Obtained by modifying pyscf.fci.spin_op.contract_ss
'''
neleca, nelecb = _unpack_nelec(nelec)
na = cistring.num_strings(norb, neleca)
nb = cistring.num_strings(norb, nelecb)
fcivec = fcivec.reshape(na, nb)
assert (op in (-1, 1)), 'op = -1 or 1'
if ((op == -1 and (neleca == 0 or nelecb == norb))
or (op == 1 and (neleca == norb or nelecb == 0))):
return np.zeros((0, 0))
# ^ Annihilate vacuum state ^
def gen_map(fstr_index, nelec, des=True):
a_index = fstr_index(range(norb), nelec)
amap = np.zeros((a_index.shape[0], norb, 2), dtype=np.int32)
if des:
for k, tab in enumerate(a_index):
amap[k, tab[:, 1]] = tab[:, 2:]
else:
for k, tab in enumerate(a_index):
amap[k, tab[:, 0]] = tab[:, 2:]
return amap
if op == -1:
aindex = gen_map(cistring.gen_des_str_index, neleca)
bindex = gen_map(cistring.gen_cre_str_index, nelecb, False)
else:
aindex = gen_map(cistring.gen_cre_str_index, neleca, False)
bindex = gen_map(cistring.gen_des_str_index, nelecb)
ci1 = np.zeros((cistring.num_strings(norb, neleca + op),
cistring.num_strings(norb, nelecb - op)))
for i in range(norb):
signa = aindex[:, i, 1]
signb = bindex[:, i, 1]
maska = np.where(signa != 0)[0]
maskb = np.where(signb != 0)[0]
addra = aindex[maska, i, 0]
addrb = bindex[maskb, i, 0]
citmp = lib.take_2d(fcivec, maska, maskb)
citmp *= signa[maska].reshape(-1, 1)
citmp *= signb[maskb]
#: ci1[addra.reshape(-1,1),addrb] += citmp
lib.takebak_2d(ci1, citmp, addra, addrb)
ci1 /= linalg.norm(ci1) # ???
return ci1
def contract_2e(self,
eri,
fcivec,
norb,
nelec,
link_index=None,
orbsym=None,
wfnsym=None,
**kwargs):
if orbsym is None: orbsym = self.orbsym
if wfnsym is None: wfnsym = self.wfnsym
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
nelec = _unpack_nelec(nelec, self.spin)
return contract_2e(eri, fcivec, norb, nelec, link_index, orbsym,
wfnsym, **kwargs)
def make_dm1234(fname, cibra, ciket, norb, nelec):
r'''Spin traced 1, 2, 3 and 4-particle density matrices.
.. note::
In this function, 2pdm[p,q,r,s] is :math:`\langle p^\dagger q r^\dagger s\rangle`;
3pdm[p,q,r,s,t,u] is :math:`\langle p^\dagger q r^\dagger s t^\dagger u\rangle`;
4pdm[p,q,r,s,t,u,v,w] is :math:`\langle p^\dagger q r^\dagger s t^\dagger u v^\dagger w\rangle`.
After calling reorder_dm123, the 2pdm and 3pdm are transformed to
the normal density matrices:
2pdm[p,r,q,s] = :math:`\langle p^\dagger q^\dagger s r\rangle`
3pdm[p,s,q,t,r,u] = :math:`\langle p^\dagger q^\dagger r^\dagger u t s\rangle`.
4pdm[p,t,q,u,r,v,s,w] = :math:`\langle p^\dagger q^\dagger r^\dagger s^dagger w v u t\rangle`.
'''
cibra = numpy.asarray(cibra, order='C')
ciket = numpy.asarray(ciket, order='C')
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
na,nlinka = link_indexa.shape[:2]
nb,nlinkb = link_indexb.shape[:2]
assert(cibra.size == na*nb)
assert(ciket.size == na*nb)
rdm1 = numpy.empty((norb,)*2)
rdm2 = numpy.empty((norb,)*4)
rdm3 = numpy.empty((norb,)*6)
rdm4 = numpy.empty((norb,)*8)
librdm.FCIrdm4_drv(getattr(librdm, fname),
rdm1.ctypes.data_as(ctypes.c_void_p),
rdm2.ctypes.data_as(ctypes.c_void_p),
rdm3.ctypes.data_as(ctypes.c_void_p),
rdm4.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(nlinka), ctypes.c_int(nlinkb),
link_indexa.ctypes.data_as(ctypes.c_void_p),
link_indexb.ctypes.data_as(ctypes.c_void_p))
rdm3 = _complete_dm3_(rdm2, rdm3)
rdm4 = _complete_dm4_(rdm3, rdm4)
return rdm1.T, rdm2, rdm3, rdm4
def make_rdm1s(fcivec, norb, nelec, link_index=None):
r'''Spin separated 1-particle density matrices.
The return values include two density matrices: (alpha,alpha), (beta,beta)
dm1[p,q] = <q^\dagger p>
The convention is based on McWeeney's book, Eq (5.4.20).
The contraction between 1-particle Hamiltonian and rdm1 is
E = einsum('pq,qp', h1, rdm1)
'''
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
link_index = (link_indexa, link_indexb)
rdm1a = rdm.make_rdm1_spin1('FCImake_rdm1a', fcivec, fcivec, norb, nelec,
link_index)
rdm1b = rdm.make_rdm1_spin1('FCImake_rdm1b', fcivec, fcivec, norb, nelec,
link_index)
return rdm1a, rdm1b
def make_rdm1s(fcivec, norb, nelec, link_index=None):
'''Spin separated 1-particle density matrices.
The return values include two density matrices: (alpha,alpha), (beta,beta)
dm1[p,q] = <q^\dagger p>
The convention is based on McWeeney's book, Eq (5.4.20).
The contraction between 1-particle Hamiltonian and rdm1 is
E = einsum('pq,qp', h1, rdm1)
'''
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
link_index = (link_indexa, link_indexb)
rdm1a = rdm.make_rdm1_spin1('FCImake_rdm1a', fcivec, fcivec,
norb, nelec, link_index)
rdm1b = rdm.make_rdm1_spin1('FCImake_rdm1b', fcivec, fcivec,
norb, nelec, link_index)
return rdm1a, rdm1b
def guess_wfnsym(self, norb, nelec, fcivec=None, orbsym=None, wfnsym=None,
**kwargs):
'''
Guess point group symmetry of the FCI wavefunction. If fcivec is
given, the symmetry of fcivec is used. Otherwise the symmetry is
based on the HF determinant.
'''
if orbsym is None:
orbsym = self.orbsym
nelec = _unpack_nelec(nelec, self.spin)
if fcivec is None:
wfnsym = _id_wfnsym(self, norb, nelec, orbsym, wfnsym)
else:
# TODO: if wfnsym is given in the input, check whether the
# symmetry of fcivec is consistent with given wfnsym.
wfnsym = addons.guess_wfnsym(fcivec, norb, nelec, orbsym)
verbose = kwargs.get('verbose', None)
log = logger.new_logger(self, verbose)
log.debug('Guessing CI wfn symmetry = %s', wfnsym)
return wfnsym
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')
ciket = numpy.asarray(ciket, order='C')
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
assert (neleca == nelecb)
link_index = cistring.gen_linkstr_index(range(norb), neleca)
na, nlink = link_index.shape[:2]
assert (cibra.size == na**2)
assert (ciket.size == na**2)
rdm1 = numpy.empty((norb, norb))
fn = getattr(librdm, fname)
fn(rdm1.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(na), ctypes.c_int(nlink),
ctypes.c_int(nlink), link_index.ctypes.data_as(ctypes.c_void_p),
link_index.ctypes.data_as(ctypes.c_void_p))
return rdm1.T
def make_dm1234(fname, cibra, ciket, norb, nelec):
r'''Spin traced 1, 2, 3 and 4-particle density matrices.
.. note::
In this function, 2pdm[p,q,r,s] is :math:`\langle p^\dagger q r^\dagger s\rangle`;
3pdm[p,q,r,s,t,u] is :math:`\langle p^\dagger q r^\dagger s t^\dagger u\rangle`;
4pdm[p,q,r,s,t,u,v,w] is :math:`\langle p^\dagger q r^\dagger s t^\dagger u v^\dagger w\rangle`.
After calling reorder_dm123, the 2pdm and 3pdm are transformed to
the normal density matrices:
2pdm[p,r,q,s] = :math:`\langle p^\dagger q^\dagger s r\rangle`
3pdm[p,s,q,t,r,u] = :math:`\langle p^\dagger q^\dagger r^\dagger u t s\rangle`.
4pdm[p,t,q,u,r,v,s,w] = :math:`\langle p^\dagger q^\dagger r^\dagger s^dagger w v u t\rangle`.
'''
cibra = numpy.asarray(cibra, order='C')
ciket = numpy.asarray(ciket, order='C')
neleca, nelecb = _unpack_nelec(nelec)
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
na, nlinka = link_indexa.shape[:2]
nb, nlinkb = link_indexb.shape[:2]
assert (cibra.size == na * nb)
assert (ciket.size == na * nb)
rdm1 = numpy.empty((norb, ) * 2)
rdm2 = numpy.empty((norb, ) * 4)
rdm3 = numpy.empty((norb, ) * 6)
rdm4 = numpy.empty((norb, ) * 8)
librdm.FCIrdm4_drv(getattr(librdm, fname),
rdm1.ctypes.data_as(ctypes.c_void_p),
rdm2.ctypes.data_as(ctypes.c_void_p),
rdm3.ctypes.data_as(ctypes.c_void_p),
rdm4.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb), ctypes.c_int(na), ctypes.c_int(nb),
ctypes.c_int(nlinka), ctypes.c_int(nlinkb),
link_indexa.ctypes.data_as(ctypes.c_void_p),
link_indexb.ctypes.data_as(ctypes.c_void_p))
rdm3 = _complete_dm3_(rdm2, rdm3)
rdm4 = _complete_dm4_(rdm3, rdm4)
return rdm1.T, rdm2, rdm3, rdm4
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')
ciket = numpy.asarray(ciket, order='C')
if link_index is None:
neleca, nelecb = _unpack_nelec(nelec)
assert(neleca == nelecb)
link_index = cistring.gen_linkstr_index(range(norb), neleca)
na, nlink = link_index.shape[:2]
assert(cibra.size == na**2)
assert(ciket.size == na**2)
rdm1 = numpy.empty((norb,norb))
fn = getattr(librdm, fname)
fn(rdm1.ctypes.data_as(ctypes.c_void_p),
cibra.ctypes.data_as(ctypes.c_void_p),
ciket.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(norb),
ctypes.c_int(na), ctypes.c_int(na),
ctypes.c_int(nlink), ctypes.c_int(nlink),
link_index.ctypes.data_as(ctypes.c_void_p),
link_index.ctypes.data_as(ctypes.c_void_p))
return rdm1.T
def pspace(self, h1e, eri, norb, nelec, hdiag=None, np=400):
nelec = _unpack_nelec(nelec, self.spin)
return pspace(h1e, eri, norb, nelec, hdiag, np)
def contract_2e(self, eri, fcivec, norb, nelec, link_index=None, **kwargs):
nelec = _unpack_nelec(nelec, self.spin)
return contract_2e(eri, fcivec, norb, nelec, link_index, **kwargs)
def trans_rdm12(self, cibra, ciket, norb, nelec, link_index=None,
reorder=True):
nelec = _unpack_nelec(nelec, self.spin)
return trans_rdm12(cibra, ciket, norb, nelec, link_index, reorder)
def make_hdiag(self, h1e, eri, norb, nelec):
nelec = _unpack_nelec(nelec, self.spin)
return make_hdiag(h1e, eri, norb, nelec)
def contract_ss(self, fcivec, norb, nelec):
from pyscf.fci import spin_op
nelec = _unpack_nelec(nelec, self.spin)
return spin_op.contract_ss(fcivec, norb, nelec)
def contract_ss(fcivec, norb, nelec):
'''Contract spin square operator with FCI wavefunction :math:`S^2 |CI>`
'''
neleca, nelecb = _unpack_nelec(nelec)
na = cistring.num_strings(norb, neleca)
nb = cistring.num_strings(norb, nelecb)
fcivec = fcivec.reshape(na,nb)
def gen_map(fstr_index, nelec, des=True):
a_index = fstr_index(range(norb), nelec)
amap = numpy.zeros((a_index.shape[0],norb,2), dtype=numpy.int32)
if des:
for k, tab in enumerate(a_index):
amap[k,tab[:,1]] = tab[:,2:]
else:
for k, tab in enumerate(a_index):
amap[k,tab[:,0]] = tab[:,2:]
return amap
if neleca > 0:
ades = gen_map(cistring.gen_des_str_index, neleca)
else:
ades = None
if nelecb > 0:
bdes = gen_map(cistring.gen_des_str_index, nelecb)
else:
bdes = None
if neleca < norb:
acre = gen_map(cistring.gen_cre_str_index, neleca, False)
else:
acre = None
if nelecb < norb:
bcre = gen_map(cistring.gen_cre_str_index, nelecb, False)
else:
bcre = None
def trans(ci1, aindex, bindex, nea, neb):
if aindex is None or bindex is None:
return None
t1 = numpy.zeros((cistring.num_strings(norb,nea),
cistring.num_strings(norb,neb)))
for i in range(norb):
signa = aindex[:,i,1]
signb = bindex[:,i,1]
maska = numpy.where(signa!=0)[0]
maskb = numpy.where(signb!=0)[0]
addra = aindex[maska,i,0]
addrb = bindex[maskb,i,0]
citmp = lib.take_2d(fcivec, maska, maskb)
citmp *= signa[maska].reshape(-1,1)
citmp *= signb[maskb]
#: t1[addra.reshape(-1,1),addrb] += citmp
lib.takebak_2d(t1, citmp, addra, addrb)
for i in range(norb):
signa = aindex[:,i,1]
signb = bindex[:,i,1]
maska = numpy.where(signa!=0)[0]
maskb = numpy.where(signb!=0)[0]
addra = aindex[maska,i,0]
addrb = bindex[maskb,i,0]
citmp = lib.take_2d(t1, addra, addrb)
citmp *= signa[maska].reshape(-1,1)
citmp *= signb[maskb]
#: ci1[maska.reshape(-1,1), maskb] += citmp
lib.takebak_2d(ci1, citmp, maska, maskb)
ci1 = numpy.zeros((na,nb))
trans(ci1, ades, bcre, neleca-1, nelecb+1) # S+*S-
trans(ci1, acre, bdes, neleca+1, nelecb-1) # S-*S+
ci1 *= .5
ci1 += (neleca-nelecb)**2*.25*fcivec
return ci1
def make_rdm12(self, fcivec, norb, nelec, link_index=None, reorder=True):
nelec = _unpack_nelec(nelec, self.spin)
return make_rdm12(fcivec, norb, nelec, link_index, reorder)
def make_rdm1(self, fcivec, norb, nelec, link_index=None):
nelec = _unpack_nelec(nelec, self.spin)
return make_rdm1(fcivec, norb, nelec, link_index)
def transform_ci_for_orbital_rotation(self, fcivec, norb, nelec, u):
nelec = _unpack_nelec(nelec, self.spin)
return addons.transform_ci_for_orbital_rotation(fcivec, norb, nelec, u)
def trans_rdm1(self, cibra, ciket, norb, nelec, link_index=None):
nelec = _unpack_nelec(nelec, self.spin)
return trans_rdm1(cibra, ciket, norb, nelec, link_index)
def contract_1e(self, f1e, fcivec, norb, nelec, link_index=None, **kwargs):
nelec = _unpack_nelec(nelec, self.spin)
return contract_1e(f1e, fcivec, norb, nelec, link_index, **kwargs)
def large_ci(self, fcivec, norb, nelec,
tol=getattr(__config__, 'fci_addons_large_ci_tol', .1),
return_strs=getattr(__config__, 'fci_addons_large_ci_return_strs', True)):
nelec = _unpack_nelec(nelec, self.spin)
return addons.large_ci(fcivec, norb, nelec, tol, return_strs)
def get_init_guess(self, norb, nelec, nroots, hdiag):
wfnsym = _id_wfnsym(self, norb, nelec, self.orbsym, self.wfnsym)
nelec = _unpack_nelec(nelec, self.spin)
return get_init_guess(norb, nelec, nroots, hdiag, self.orbsym, wfnsym)
def energy(self, h1e, eri, fcivec, norb, nelec, link_index=None):
nelec = _unpack_nelec(nelec, self.spin)
h2e = self.absorb_h1e(h1e, eri, norb, nelec, .5)
ci1 = self.contract_2e(h2e, fcivec, norb, nelec, link_index)
return numpy.dot(fcivec.reshape(-1), ci1.reshape(-1))
def make_rdm1(self, fcivec, norb, nelec, link_index=None):
nelec = _unpack_nelec(nelec, self.spin)
return make_rdm1(fcivec, norb, nelec, link_index)
def spin_square(self, fcivec, norb, nelec):
nelec = _unpack_nelec(nelec, self.spin)
return spin_op.spin_square0(fcivec, norb, nelec)
def contract_ss(self, fcivec, norb, nelec):
from pyscf.fci import spin_op
nelec = _unpack_nelec(nelec, self.spin)
return spin_op.contract_ss(fcivec, norb, nelec)
def make_rdm12(self, fcivec, norb, nelec, link_index=None, reorder=True):
nelec = _unpack_nelec(nelec, self.spin)
return make_rdm12(fcivec, norb, nelec, link_index, reorder)
def absorb_h1e(self, h1e, eri, norb, nelec, fac=1):
nelec = _unpack_nelec(nelec, self.spin)
return direct_spin1.absorb_h1e(h1e, eri, norb, nelec, fac)
def trans_rdm1(self, cibra, ciket, norb, nelec, link_index=None):
nelec = _unpack_nelec(nelec, self.spin)
return trans_rdm1(cibra, ciket, norb, nelec, link_index)
def spin_square(self, fcivec, norb, nelec):
nelec = _unpack_nelec(nelec, self.spin)
return spin_op.spin_square0(fcivec, norb, nelec)
def make_hdiag(self, h1e, eri, norb, nelec):
nelec = _unpack_nelec(nelec, self.spin)
return direct_spin1.make_hdiag(h1e, eri, norb, nelec)
def contract_2e(eri, fcivec, norb, nelec, link_index=None, orbsym=None, wfnsym=0):
if orbsym is None:
return direct_spin1.contract_2e(eri, fcivec, norb, nelec, link_index)
eri = ao2mo.restore(4, eri, norb)
neleca, nelecb = _unpack_nelec(nelec)
link_indexa, link_indexb = direct_spin1._unpack(norb, nelec, link_index)
na, nlinka = link_indexa.shape[:2]
nb, nlinkb = link_indexb.shape[:2]
eri_irs, rank_eri, irrep_eri = reorder_eri(eri, norb, orbsym)
strsa = cistring.gen_strings4orblist(range(norb), neleca)
aidx, link_indexa = gen_str_irrep(strsa, orbsym, link_indexa, rank_eri, irrep_eri)
if neleca == nelecb:
bidx, link_indexb = aidx, link_indexa
else:
strsb = cistring.gen_strings4orblist(range(norb), nelecb)
bidx, link_indexb = gen_str_irrep(strsb, orbsym, link_indexb, rank_eri, irrep_eri)
Tirrep = ctypes.c_void_p*TOTIRREPS
linka_ptr = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in link_indexa])
linkb_ptr = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in link_indexb])
eri_ptrs = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in eri_irs])
dimirrep = (ctypes.c_int*TOTIRREPS)(*[x.shape[0] for x in eri_irs])
fcivec_shape = fcivec.shape
fcivec = fcivec.reshape((na,nb), order='C')
ci1new = numpy.zeros_like(fcivec)
nas = (ctypes.c_int*TOTIRREPS)(*[x.size for x in aidx])
nbs = (ctypes.c_int*TOTIRREPS)(*[x.size for x in bidx])
# aa, ab
ci0 = []
ci1 = []
for ir in range(TOTIRREPS):
ma, mb = aidx[ir].size, bidx[wfnsym^ir].size
ci0.append(numpy.zeros((ma,mb)))
ci1.append(numpy.zeros((ma,mb)))
if ma > 0 and mb > 0:
lib.take_2d(fcivec, aidx[ir], bidx[wfnsym^ir], out=ci0[ir])
ci0_ptrs = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in ci0])
ci1_ptrs = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in ci1])
libfci.FCIcontract_2e_symm1(eri_ptrs, ci0_ptrs, ci1_ptrs,
ctypes.c_int(norb), nas, nbs,
ctypes.c_int(nlinka), ctypes.c_int(nlinkb),
linka_ptr, linkb_ptr, dimirrep,
ctypes.c_int(wfnsym))
for ir in range(TOTIRREPS):
if ci0[ir].size > 0:
lib.takebak_2d(ci1new, ci1[ir], aidx[ir], bidx[wfnsym^ir])
# bb, ba
ci0T = []
for ir in range(TOTIRREPS):
mb, ma = bidx[ir].size, aidx[wfnsym^ir].size
ci0T.append(numpy.zeros((mb,ma)))
if ma > 0 and mb > 0:
lib.transpose(ci0[wfnsym^ir], out=ci0T[ir])
ci0, ci0T = ci0T, None
ci1 = [numpy.zeros_like(x) for x in ci0]
ci0_ptrs = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in ci0])
ci1_ptrs = Tirrep(*[x.ctypes.data_as(ctypes.c_void_p) for x in ci1])
libfci.FCIcontract_2e_symm1(eri_ptrs, ci0_ptrs, ci1_ptrs,
ctypes.c_int(norb), nbs, nas,
ctypes.c_int(nlinkb), ctypes.c_int(nlinka),
linkb_ptr, linka_ptr, dimirrep,
ctypes.c_int(wfnsym))
for ir in range(TOTIRREPS):
if ci0[ir].size > 0:
lib.takebak_2d(ci1new, lib.transpose(ci1[ir]), aidx[wfnsym^ir], bidx[ir])
return ci1new.reshape(fcivec_shape)
def transform_ci_for_orbital_rotation(self, fcivec, norb, nelec, u):
nelec = _unpack_nelec(nelec, self.spin)
return addons.transform_ci_for_orbital_rotation(fcivec, norb, nelec, u)
def pspace(self, h1e, eri, norb, nelec, hdiag, np=400):
nelec = _unpack_nelec(nelec, self.spin)
return direct_spin1.pspace(h1e, eri, norb, nelec, hdiag, np)
