def get_j(self, cell=None, dm=None, hermi=1, kpt=None, kpts_band=None):
r'''Compute J matrix for the given density matrix and k-point (kpt).
When kpts_band is given, the J matrices on kpts_band are evaluated.
J_{pq} = \sum_{rs} (pq|rs) dm[s,r]
where r,s are orbitals on kpt. p and q are orbitals on kpts_band
if kpts_band is given otherwise p and q are orbitals on kpt.
'''
#return self.get_jk(cell, dm, hermi, kpt, kpts_band)[0]
if cell is None: cell = self.cell
if dm is None: dm = self.make_rdm1()
if kpt is None: kpt = self.kpt
cpu0 = (time.clock(), time.time())
dm = np.asarray(dm)
nao = dm.shape[-1]
if (kpts_band is None and
(self._eri is not None or cell.incore_anyway or
(not self.direct_scf and self._is_mem_enough()))):
if self._eri is None:
logger.debug(self, 'Building PBC AO integrals incore')
self._eri = self.with_df.get_ao_eri(kpt, compact=True)
vj, vk = mol_hf.dot_eri_dm(self._eri, dm.reshape(-1,nao,nao), hermi)
else:
vj = self.with_df.get_jk(dm.reshape(-1,nao,nao), hermi,
kpt, kpts_band, with_k=False)[0]
logger.timer(self, 'vj', *cpu0)
return _format_jks(vj, dm, kpts_band)
def get_jk(self, mol=None, dm=None, hermi=1):
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
cpu0 = (time.clock(), time.time())
if self._eri is not None or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = hf.get_jk(mol, dm, hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
def get_jk(self, mol=None, dm=None, hermi=1):
'''Coulomb (J) and exchange (K)
Args:
dm : a list of 2D arrays or a list of 3D arrays
(alpha_dm, beta_dm) or (alpha_dms, beta_dms)
'''
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = mol.intor('int2e', aosym='s8')
vj, vk = hf.dot_eri_dm(self._eri, dm, hermi)
else:
vj, vk = hf.SCF.get_jk(self, mol, dm, hermi)
return numpy.asarray(vj), numpy.asarray(vk)
def get_jk_(self, mol=None, dm=None, hermi=1):
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1]
cpu0 = (time.clock(), time.time())
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1,nao,nao), hermi)
else:
if self.direct_scf:
self.opt = self.init_direct_scf(mol)
vj, vk = hf.get_jk(mol, dm.reshape(-1,nao,nao), hermi, self.opt)
logger.timer(self, 'vj and vk', *cpu0)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def get_jk(self, mol=None, dm=None, hermi=1):
'''Coulomb (J) and exchange (K)
Args:
dm : a list of 2D arrays or a list of 3D arrays
(alpha_dm, beta_dm) or (alpha_dms, beta_dms)
'''
if mol is None: mol = self.mol
if dm is None: dm = self.make_rdm1()
dm = numpy.asarray(dm)
nao = dm.shape[-1] # Get nao from dm shape because the hamiltonian
# might be not defined from mol
if self._eri is not None or mol.incore_anyway or self._is_mem_enough():
if self._eri is None:
self._eri = _vhf.int2e_sph(mol._atm, mol._bas, mol._env)
vj, vk = hf.dot_eri_dm(self._eri, dm.reshape(-1,nao,nao), hermi)
else:
vj, vk = hf.SCF.get_jk(self, mol, dm.reshape(-1,nao,nao), hermi)
return vj.reshape(dm.shape), vk.reshape(dm.shape)
def get_jk(self, cell=None, dm=None, hermi=1, kpt=None, kpts_band=None):
r'''Get Coulomb (J) and exchange (K) following :func:`scf.hf.RHF.get_jk_`.
for particular k-point (kpt).
When kpts_band is given, the J, K matrices on kpts_band are evaluated.
J_{pq} = \sum_{rs} (pq|rs) dm[s,r]
K_{pq} = \sum_{rs} (pr|sq) dm[r,s]
where r,s are orbitals on kpt. p and q are orbitals on kpts_band
if kpts_band is given otherwise p and q are orbitals on kpt.
'''
if cell is None: cell = self.cell
if dm is None: dm = self.make_rdm1()
if kpt is None: kpt = self.kpt
cpu0 = (time.clock(), time.time())
dm = np.asarray(dm)
nao = dm.shape[-1]
if (kpts_band is None and
(self.exxdiv == 'ewald' or not self.exxdiv) and
(self._eri is not None or cell.incore_anyway or
(not self.direct_scf and self._is_mem_enough()))):
if self._eri is None:
logger.debug(self, 'Building PBC AO integrals incore')
self._eri = self.with_df.get_ao_eri(kpt, compact=True)
vj, vk = mol_hf.dot_eri_dm(self._eri, dm, hermi)
if self.exxdiv == 'ewald':
from pyscf.pbc.df.df_jk import _ewald_exxdiv_for_G0
# G=0 is not inculded in the ._eri integrals
_ewald_exxdiv_for_G0(self.cell, kpt, dm.reshape(-1,nao,nao),
vk.reshape(-1,nao,nao))
else:
vj, vk = self.with_df.get_jk(dm.reshape(-1,nao,nao), hermi,
kpt, kpts_band, exxdiv=self.exxdiv)
logger.timer(self, 'vj and vk', *cpu0)
vj = _format_jks(vj, dm, kpts_band)
vk = _format_jks(vk, dm, kpts_band)
return vj, vk
def dot_eri_dm(eri, dm, hermi=0):
'''Compute J, K matrices in terms of the given 2-electron integrals and
density matrix. eri or dm can be complex.
Args:
eri : ndarray
complex integral array with N^4 elements (N is the number of orbitals)
dm : ndarray or list of ndarrays
A density matrix or a list of density matrices
Kwargs:
hermi : int
Whether J, K matrix is hermitian
| 0 : no hermitian or symmetric
| 1 : hermitian
| 2 : anti-hermitian
Returns:
Depending on the given dm, the function returns one J and one K matrix,
or a list of J matrices and a list of K matrices, corresponding to the
input density matrices.
'''
dm = np.asarray(dm)
if np.iscomplexobj(dm) or np.iscomplexobj(eri):
nao = dm.shape[-1]
eri = eri.reshape((nao,)*4)
def contract(dm):
vj = np.einsum('ijkl,ji->kl', eri, dm)
vk = np.einsum('ijkl,jk->il', eri, dm)
return vj, vk
if isinstance(dm, np.ndarray) and dm.ndim == 2:
vj, vk = contract(dm)
else:
vjk = [contract(dmi) for dmi in dm]
vj = lib.asarray([v[0] for v in vjk]).reshape(dm.shape)
vk = lib.asarray([v[1] for v in vjk]).reshape(dm.shape)
else:
vj, vk = hf.dot_eri_dm(eri, dm, hermi)
return vj, vk
def get_jk(self,
cell=None,
dm=None,
hermi=1,
kpt=None,
kpts_band=None,
with_j=True,
with_k=True,
omega=None,
**kwargs):
r'''Get Coulomb (J) and exchange (K) following :func:`scf.hf.RHF.get_jk_`.
for particular k-point (kpt).
When kpts_band is given, the J, K matrices on kpts_band are evaluated.
J_{pq} = \sum_{rs} (pq|rs) dm[s,r]
K_{pq} = \sum_{rs} (pr|sq) dm[r,s]
where r,s are orbitals on kpt. p and q are orbitals on kpts_band
if kpts_band is given otherwise p and q are orbitals on kpt.
'''
if cell is None: cell = self.cell
if dm is None: dm = self.make_rdm1()
if kpt is None: kpt = self.kpt
cpu0 = (logger.process_clock(), logger.perf_counter())
dm = np.asarray(dm)
nao = dm.shape[-1]
if (not omega and kpts_band is None and
# TODO: generate AO integrals with rsjk algorithm
not self.rsjk and (self.exxdiv == 'ewald' or not self.exxdiv)
and (self._eri is not None or cell.incore_anyway or
(not self.direct_scf and self._is_mem_enough()))):
if self._eri is None:
logger.debug(self, 'Building PBC AO integrals incore')
self._eri = self.with_df.get_ao_eri(kpt, compact=True)
vj, vk = mol_hf.dot_eri_dm(self._eri, dm, hermi, with_j, with_k)
if with_k and self.exxdiv == 'ewald':
from pyscf.pbc.df.df_jk import _ewald_exxdiv_for_G0
# G=0 is not inculded in the ._eri integrals
_ewald_exxdiv_for_G0(self.cell, kpt, dm.reshape(-1, nao, nao),
vk.reshape(-1, nao, nao))
elif self.rsjk:
vj, vk = self.rsjk.get_jk(dm.reshape(-1, nao, nao),
hermi,
kpt,
kpts_band,
with_j,
with_k,
omega,
exxdiv=self.exxdiv)
else:
vj, vk = self.with_df.get_jk(dm.reshape(-1, nao, nao),
hermi,
kpt,
kpts_band,
with_j,
with_k,
omega,
exxdiv=self.exxdiv)
if with_j:
vj = _format_jks(vj, dm, kpts_band)
if with_k:
vk = _format_jks(vk, dm, kpts_band)
logger.timer(self, 'vj and vk', *cpu0)
return vj, vk
