def kernel(self, h1e, eri, norb, nelec, ci0=None, **kwargs):
if self.verbose > logger.QUIET:
pyscf.gto.mole.check_sanity(self, self._keys, self.stdout)
wfnsym = _id_wfnsym(self, norb, nelec, self.wfnsym)
if 'verbose' in kwargs:
if isinstance(kwargs['verbose'], logger.Logger):
log = kwargs['verbose']
else:
log = logger.Logger(self.stdout, kwargs['verbose'])
log.debug('total symmetry = %s',
symm.irrep_id2name(self.mol.groupname, wfnsym))
else:
logger.debug(self, 'total symmetry = %s',
symm.irrep_id2name(self.mol.groupname, wfnsym))
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0,
**kwargs)
if self.wfnsym is not None:
# should I remove the non-symmetric contributions in each
# call of contract_2e?
if self.nroots > 1:
c = [addons.symmetrize_wfn(ci, norb, nelec, self.orbsym, wfnsym)
for ci in c]
else:
c = addons.symmetrize_wfn(c, norb, nelec, self.orbsym, wfnsym)
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, ecore=0, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is not None:
self.orbsym, orbsym_bak = orbsym, self.orbsym
if wfnsym is None:
wfnsym = self.wfnsym
if self.verbose >= logger.WARN:
self.check_sanity()
self.norb = norb
self.nelec = nelec
nelec = direct_spin1._unpack_nelec(nelec, self.spin)
wfnsym_bak = self.wfnsym
self.wfnsym = self.guess_wfnsym(norb, nelec, ci0, wfnsym, **kwargs)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0, None,
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, ecore=ecore,
**kwargs)
if orbsym is not None:
self.orbsym = orbsym_bak
self.wfnsym = wfnsym_bak
self.eci, self.ci = e, c
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is not None:
self.orbsym, orbsym_bak = orbsym, self.orbsym
if wfnsym is not None:
self.wfnsym, wfnsym_bak = wfnsym, self.wfnsym
else:
wfnsym_bak = None
if self.verbose >= logger.WARN:
self.check_sanity()
wfnsym = self.guess_wfnsym(norb, nelec, ci0, self.wfnsym, **kwargs)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0, None,
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, **kwargs)
if self.wfnsym is not None:
# should I remove the non-symmetric contributions in each
# call of contract_2e?
if nroots > 1:
c = [addons.symmetrize_wfn(ci, norb, nelec, self.orbsym, wfnsym)
for ci in c]
else:
c = addons.symmetrize_wfn(c, norb, nelec, self.orbsym, wfnsym)
if orbsym is not None:
self.orbsym = orbsym_bak
if wfnsym_bak is not None:
self.wfnsym = wfnsym_bak
return e, c
def kernel(h1e, eri, norb, nelec, ci0=None, level_shift=.001, tol=1e-10,
lindep=1e-14, max_cycle=50, nroots=1, orbsym=[], wfnsym=None,
**kwargs):
assert(len(orbsym) == norb)
cis = FCISolver(None)
cis.level_shift = level_shift
cis.orbsym = orbsym
cis.conv_tol = tol
cis.lindep = lindep
cis.max_cycle = max_cycle
cis.wfnsym = wfnsym
cis.nroots = nroots
unknown = []
for k, v in kwargs.items():
setattr(cis, k, v)
if not hasattr(cis, k):
unknown.append(k)
if unknown:
sys.stderr.write('Unknown keys %s for FCI kernel %s\n' %
(str(unknown), __name__))
wfnsym = _id_wfnsym(cis, norb, nelec, cis.wfnsym)
if cis.wfnsym is not None and ci0 is None:
ci0 = addons.symm_initguess(norb, nelec, orbsym, wfnsym)
e, c = direct_spin1.kernel_ms1(cis, h1e, eri, norb, nelec, ci0=ci0)
if cis.wfnsym is not None:
if cis.nroots > 1:
c = [addons.symmetrize_wfn(ci, norb, nelec, orbsym, wfnsym)
for ci in c]
else:
c = addons.symmetrize_wfn(c, norb, nelec, orbsym, wfnsym)
return e, c
def kernel(self,
h1e,
eri,
norb,
nelec,
ci0=None,
tol=None,
lindep=None,
max_cycle=None,
max_space=None,
nroots=None,
davidson_only=None,
pspace_size=None,
orbsym=None,
wfnsym=None,
**kwargs):
if isinstance(nelec, (int, numpy.number)):
nelecb = nelec // 2
neleca = nelec - nelecb
else:
neleca, nelecb = nelec
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0,
(link_indexa, link_indexb), tol, lindep,
max_cycle, max_space, nroots,
davidson_only, pspace_size, **kwargs)
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is not None:
self.orbsym, orbsym_bak = orbsym, self.orbsym
if wfnsym is not None:
self.wfnsym, wfnsym_bak = wfnsym, self.wfnsym
if self.verbose >= logger.WARN:
self.check_sanity()
wfnsym0 = self.guess_wfnsym(norb, nelec, ci0, self.wfnsym, **kwargs)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0, None,
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, **kwargs)
if self.wfnsym is not None:
# should I remove the non-symmetric contributions in each
# call of contract_2e?
if nroots > 1:
c = [addons.symmetrize_wfn(ci, norb, nelec, self.orbsym, wfnsym0)
for ci in c]
else:
c = addons.symmetrize_wfn(c, norb, nelec, self.orbsym, wfnsym0)
if orbsym is not None:
self.orbsym = orbsym_bak
if wfnsym is not None:
self.wfnsym = wfnsym_bak
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, **kwargs):
if isinstance(nelec, (int, numpy.integer)):
nelecb = nelec//2
neleca = nelec - nelecb
else:
neleca, nelecb = nelec
link_indexa = cistring.gen_linkstr_index(range(norb), neleca)
link_indexb = cistring.gen_linkstr_index(range(norb), nelecb)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0,
(link_indexa,link_indexb),
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, **kwargs)
return e, c
def kernel(self,
h1e,
eri,
norb,
nelec,
ci0=None,
tol=None,
lindep=None,
max_cycle=None,
max_space=None,
nroots=None,
davidson_only=None,
pspace_size=None,
orbsym=None,
wfnsym=None,
ecore=0,
**kwargs):
if nroots is None: nroots = self.nroots
if orbsym is None: orbsym = self.orbsym
if wfnsym is None: wfnsym = self.wfnsym
if self.verbose >= logger.WARN:
self.check_sanity()
self.norb = norb
self.nelec = nelec
wfnsym = self.guess_wfnsym(norb, nelec, ci0, orbsym, wfnsym, **kwargs)
with lib.temporary_env(self, orbsym=orbsym, wfnsym=wfnsym):
e, c = direct_spin1.kernel_ms1(self,
h1e,
eri,
norb,
nelec,
ci0,
None,
tol,
lindep,
max_cycle,
max_space,
nroots,
davidson_only,
pspace_size,
ecore=ecore,
**kwargs)
self.eci, self.ci = e, c
return e, c
def kernel(h1e, eri, norb, nelec, ci0=None, level_shift=.001, tol=1e-8,
lindep=1e-8, max_cycle=50, **kwargs):
cis = FCISolver(None)
cis.level_shift = level_shift
cis.conv_tol = tol
cis.lindep = lindep
cis.max_cycle = max_cycle
unknown = []
for k, v in kwargs.items():
setattr(cis, k, v)
if not hasattr(cis, k):
unknown.append(k)
if unknown:
sys.stderr.write('Unknown keys %s for FCI kernel %s\n' %
(str(unknown), __name__))
return direct_spin1.kernel_ms1(cis, h1e, eri, norb, nelec, ci0=ci0)
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, ecore=0, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is None: orbsym = self.orbsym
if wfnsym is None: wfnsym = self.wfnsym
if self.verbose >= logger.WARN:
self.check_sanity()
self.norb = norb
self.nelec = nelec
wfnsym = self.guess_wfnsym(norb, nelec, ci0, orbsym, wfnsym, **kwargs)
with lib.temporary_env(self, orbsym=orbsym, wfnsym=wfnsym):
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0, None,
tol, lindep, max_cycle, max_space,
nroots, davidson_only, pspace_size,
ecore=ecore, **kwargs)
self.eci, self.ci = e, c
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is not None:
self.orbsym, orbsym_bak = orbsym, self.orbsym
if wfnsym is not None:
self.wfnsym, wfnsym_bak = wfnsym, self.wfnsym
else:
wfnsym_bak = None
if self.verbose > logger.QUIET:
pyscf.gto.mole.check_sanity(self, self._keys, self.stdout)
wfnsym = _id_wfnsym(self, norb, nelec, self.wfnsym)
if 'verbose' in kwargs:
if isinstance(kwargs['verbose'], logger.Logger):
log = kwargs['verbose']
else:
log = logger.Logger(self.stdout, kwargs['verbose'])
log.debug('total symmetry = %s', wfnsym)
else:
logger.debug(self, 'total symmetry = %s', wfnsym)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0,
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, **kwargs)
if self.wfnsym is not None:
# should I remove the non-symmetric contributions in each
# call of contract_2e?
if nroots > 1:
c = [addons.symmetrize_wfn(ci, norb, nelec, self.orbsym, wfnsym)
for ci in c]
else:
c = addons.symmetrize_wfn(c, norb, nelec, self.orbsym, wfnsym)
if orbsym is not None:
self.orbsym = orbsym_bak
if wfnsym_bak is not None:
self.wfnsym = wfnsym_bak
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None,
tol=None, lindep=None, max_cycle=None, max_space=None,
nroots=None, davidson_only=None, pspace_size=None,
orbsym=None, wfnsym=None, ecore=0, **kwargs):
if nroots is None: nroots = self.nroots
if orbsym is not None:
self.orbsym, orbsym_bak = orbsym, self.orbsym
if wfnsym is None:
wfnsym = self.wfnsym
if self.verbose >= logger.WARN:
self.check_sanity()
nelec = direct_spin1._unpack_nelec(nelec, self.spin)
wfnsym_bak = self.wfnsym
self.wfnsym = self.guess_wfnsym(norb, nelec, ci0, wfnsym, **kwargs)
e, c = direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0, None,
tol, lindep, max_cycle, max_space, nroots,
davidson_only, pspace_size, ecore=ecore,
**kwargs)
if orbsym is not None:
self.orbsym = orbsym_bak
self.wfnsym = wfnsym_bak
return e, c
def kernel(self, h1e, eri, norb, nelec, ci0=None, **kwargs):
if self.verbose > pyscf.lib.logger.QUIET:
pyscf.gto.mole.check_sanity(self, self._keys, self.stdout)
return direct_spin1.kernel_ms1(self, h1e, eri, norb, nelec, ci0,
**kwargs)
