def run(mf, helper=None, method='2', which='ip', nroots=5, tol=1e-9,
maxiter=100, maxspace=12, do_mp2=False, koopmans=False, verbose=False):
''' Runs the ADC method.
Arguments:
mf : scf.HF
Mean-field method from pyscf, must be converged.
helper : ADCHelper
Specify the ADCHelper class, if None then it is handled
automatically by the attributes mf and which.
method : str
One of '2', '2x', '3'
which : str
One of 'ip', 'ea' or 'ee'.
nroots : int
Number of states to solver for.
tol : float
Convergence tolerance for Davidson method.
do_mp2 : bool
Whether to compute the MP2 energy.
koopmans : bool
Target only quasiparticle-like states
Returns:
e : ndarray
Excitation energies, may be in a nested list if an unrestricted
reference or PBC is used.
v : ndarray
Eigenvectors, structured as above.
mp2 : float
MP2 correlation energy, if do_mp2 is True.
'''
if hasattr(mf, 'kpts'):
return _run_pbc(mf, helper, method, which, nroots, tol, maxiter, maxspace, do_mp2, koopmans)
if helper is None:
helper = load_helper(mf, method=method, which=which)
if callable(helper):
helper = helper(mf)
matvec, diag = helper.get_matvec()
matvecs = lambda xs: [matvec(x) for x in xs]
guesses = helper.get_guesses(diag, nroots, koopmans=koopmans)
pick = get_picker(koopmans=koopmans, real_system=True, guess=guesses)
kwargs = dict(tol=tol, nroots=nroots, pick=pick, max_cycle=maxiter,
max_space=maxspace, verbose=9 if verbose else 0)
conv, e, v = lib.davidson_nosym1(matvecs, guesses, diag, **kwargs)
if which == 'ip':
e = utils.nested_apply(e, lambda x: -x)
if do_mp2:
mp2 = helper.mp2()
if which == 'ea':
mp2 *= -1
return e, v, conv, mp2
else:
return e, v, conv
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
cpu0 = (logger.process_clock(), logger.perf_counter())
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &
(w.real > POSTIVE_EIG_THRESHOLD))[0]
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx,
real_eigenvectors=True)
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_cycle=self.max_cycle,
max_space=self.max_space, pick=pickeig,
verbose=log)
nmo = self._scf.mo_occ[0].size
nocca = (self._scf.mo_occ[0]>0).sum()
noccb = (self._scf.mo_occ[1]>0).sum()
nvira = nmo - nocca
nvirb = nmo - noccb
e = []
xy = []
for i, z in enumerate(x1):
x, y = z.reshape(2,-1)
norm = lib.norm(x)**2 - lib.norm(y)**2
if norm > 0:
norm = 1/numpy.sqrt(norm)
e.append(w[i])
xy.append(((x[:nocca*nvira].reshape(nocca,nvira) * norm, # X_alpha
x[nocca*nvira:].reshape(noccb,nvirb) * norm), # X_beta
(y[:nocca*nvira].reshape(nocca,nvira) * norm, # Y_alpha
y[nocca*nvira:].reshape(noccb,nvirb) * norm)))# Y_beta
self.e = numpy.array(e)
self.xy = xy
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.timer('TDDFT', *cpu0)
self._finalize()
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
mo_energy = self._scf.mo_energy
nocc = (self._scf.mo_occ>0).sum()
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
nvir = eai.shape[0]
if x0 is None:
x0 = self.init_guess(eai, self.nstates)
precond = self.get_precond(eai.ravel())
# We only need positive eigenvalues
def pickeig(w, v, nroots, x0):
realidx = numpy.where((abs(w.imag) < 1e-6) & (w.real > 0))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:,idx].real, idx
w, x1 = lib.davidson_nosym1(self.get_vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=self.verbose)[1:]
self.e = w
def norm_xy(z):
x, y = z.reshape(2,nvir,nocc)
norm = 2*(lib.norm(x)**2 - lib.norm(y)**2)
norm = 1/numpy.sqrt(norm)
return x*norm, y*norm
self.xy = [norm_xy(z) for z in x1]
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
vind, hdiag = self.get_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < 1e-4) & (w.real > 0))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:,idx].real, idx
w, x1 = lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=self.verbose)[1:]
mo_occ = self._scf.mo_occ
self.e = w
def norm_xy(z):
x, y = z.reshape(2,-1)
norm = 2*(lib.norm(x)**2 - lib.norm(y)**2)
norm = 1/numpy.sqrt(norm)
x *= norm
y *= norm
return _unpack(x, mo_occ), _unpack(y, mo_occ)
self.xy = [norm_xy(z) for z in x1]
return self.e, self.xy
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
cpu0 = (logger.process_clock(), logger.perf_counter())
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > POSTIVE_EIG_THRESHOLD))[0]
# If the complex eigenvalue has small imaginary part, both the
# real part and the imaginary part of the eigenvector can
# approximately be used as the "real" eigen solutions.
return lib.linalg_helper._eigs_cmplx2real(w,
v,
realidx,
real_eigenvectors=True)
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_cycle=self.max_cycle,
max_space=self.max_space, pick=pickeig,
verbose=log)
nocc = (self._scf.mo_occ > 0).sum()
nmo = self._scf.mo_occ.size
nvir = nmo - nocc
self.e = w
def norm_xy(z):
x, y = z.reshape(2, nocc, nvir)
norm = lib.norm(x)**2 - lib.norm(y)**2
norm = numpy.sqrt(.5 / norm) # normalize to 0.5 for alpha spin
return x * norm, y * norm
self.xy = [norm_xy(z) for z in x1]
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.timer('TDDFT', *cpu0)
self._finalize()
return self.e, self.xy
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &
(w.real > POSTIVE_EIG_THRESHOLD))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:,idx].real, idx
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=log)
nmo = self._scf.mo_occ[0].size
nocca = (self._scf.mo_occ[0]>0).sum()
noccb = (self._scf.mo_occ[1]>0).sum()
nvira = nmo - nocca
nvirb = nmo - noccb
e = []
xy = []
for i, z in enumerate(x1):
x, y = z.reshape(2,-1)
norm = lib.norm(x)**2 - lib.norm(y)**2
if norm > 0:
norm = 1/numpy.sqrt(norm)
e.append(w[i])
xy.append(((x[:nocca*nvira].reshape(nocca,nvira) * norm, # X_alpha
x[nocca*nvira:].reshape(noccb,nvirb) * norm), # X_beta
(y[:nocca*nvira].reshape(nocca,nvira) * norm, # Y_alpha
y[nocca*nvira:].reshape(noccb,nvirb) * norm)))# Y_beta
self.e = numpy.array(e)
self.xy = xy
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.note('Excited State energies (eV)\n%s', self.e * nist.HARTREE2EV)
return self.e, self.xy
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
cpu0 = (logger.process_clock(), logger.perf_counter())
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
ensure_real = self._scf.mo_coeff.dtype == numpy.double
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > self.positive_eig_threshold))[0]
# FIXME: Should the amplitudes be real? It also affects x2c-tdscf
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx,
ensure_real)
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_cycle=self.max_cycle,
max_space=self.max_space, pick=pickeig,
verbose=log)
nocc = (self._scf.mo_occ > 0).sum()
nmo = self._scf.mo_occ.size
nvir = nmo - nocc
self.e = w
def norm_xy(z):
x, y = z.reshape(2, nocc, nvir)
norm = lib.norm(x)**2 - lib.norm(y)**2
norm = numpy.sqrt(1. / norm)
return x * norm, y * norm
self.xy = [norm_xy(z) for z in x1]
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.timer('TDDFT', *cpu0)
self._finalize()
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
vind, hdiag = self.get_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < 1e-6) & (w.real > 0))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:, idx].real, idx
w, x1 = lib.davidson_nosym1(vind,
x0,
precond,
tol=self.conv_tol,
nroots=self.nstates,
lindep=self.lindep,
max_space=self.max_space,
pick=pickeig,
verbose=self.verbose)[1:]
nmo = self._scf.mo_occ[0].size
nocca = (self._scf.mo_occ[0] > 0).sum()
noccb = (self._scf.mo_occ[1] > 0).sum()
nvira = nmo - nocca
nvirb = nmo - noccb
e = []
xy = []
for i, z in enumerate(x1):
x, y = z.reshape(2, -1)
norm = lib.norm(x)**2 - lib.norm(y)**2
if norm > 0:
norm = 1 / numpy.sqrt(norm)
e.append(w[i])
xy.append((
(
x[:nocca * nvira].reshape(nvira, nocca) *
norm, # X_alpha
x[nocca * nvira:].reshape(nvirb, noccb) *
norm), # X_beta
(
y[:nocca * nvira].reshape(nvira, nocca) *
norm, # Y_alpha
y[nocca * nvira:].reshape(nvirb, noccb) *
norm))) # Y_beta
self.e = numpy.array(e)
self.xy = xy
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
logger.warn(
self, 'PBC-TDDFT is an experimental feature. '
'It is numerically sensitive to the accuracy of integrals '
'(relating to cell.precision).')
self.check_sanity()
self.dump_flags()
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
real_system = (gamma_point(self._scf.kpts)
and self._scf.mo_coeff[0].dtype == numpy.double)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > POSTIVE_EIG_THRESHOLD))[0]
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx,
real_system)
log = logger.Logger(self.stdout, self.verbose)
precision = self.cell.precision * 1e-2
hermi = 0
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
fill_heff=purify_krlyov_heff(precision, hermi, log),
verbose=self.verbose)
mo_occ = self._scf.mo_occ
self.e = w
def norm_xy(z):
x, y = z.reshape(2, -1)
norm = 2 * (lib.norm(x)**2 - lib.norm(y)**2)
norm = 1 / numpy.sqrt(norm)
x *= norm
y *= norm
return _unpack(x, mo_occ), _unpack(y, mo_occ)
self.xy = [norm_xy(z) for z in x1]
return self.e, self.xy
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &
(w.real > POSTIVE_EIG_THRESHOLD))[0]
# If the complex eigenvalue has small imaginary part, both the
# real part and the imaginary part of the eigenvector can
# approximately be used as the "real" eigen solutions.
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx)
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=log)
nocc = (self._scf.mo_occ>0).sum()
nmo = self._scf.mo_occ.size
nvir = nmo - nocc
self.e = w
def norm_xy(z):
x, y = z.reshape(2,nocc,nvir)
norm = lib.norm(x)**2 - lib.norm(y)**2
norm = numpy.sqrt(.5/norm) # normalize to 0.5 for alpha spin
return x*norm, y*norm
self.xy = [norm_xy(z) for z in x1]
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.note('Excited State energies (eV)\n%s', self.e * nist.HARTREE2EV)
return self.e, self.xy
def kernel(self, x0=None, nstates=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
if nstates is None:
nstates = self.nstates
else:
self.nstates = nstates
log = logger.Logger(self.stdout, self.verbose)
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > POSTIVE_EIG_THRESHOLD))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:, idx].real, idx
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=log)
nocc = (self._scf.mo_occ > 0).sum()
nmo = self._scf.mo_occ.size
nvir = nmo - nocc
self.e = w
def norm_xy(z):
x, y = z.reshape(2, nocc, nvir)
norm = lib.norm(x)**2 - lib.norm(y)**2
norm = numpy.sqrt(.5 / norm) # normalize to 0.5 for alpha spin
return x * norm, y * norm
self.xy = [norm_xy(z) for z in x1]
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.note('Excited State energies (eV)\n%s', self.e * nist.HARTREE2EV)
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
vind, hdiag = self.gen_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
real_system = (gamma_point(self._scf.kpts)
and self._scf.mo_coeff[0][0].dtype == numpy.double)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > POSTIVE_EIG_THRESHOLD))[0]
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx,
real_system)
log = logger.Logger(self.stdout, self.verbose)
precision = self.cell.precision * 1e-2
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
fill_heff=purify_krlyov_heff(precision, 0, log),
verbose=self.verbose)
mo_occ = self._scf.mo_occ
e = []
xy = []
for i, z in enumerate(x1):
xs, ys = z.reshape(2, -1)
norm = lib.norm(xs)**2 - lib.norm(ys)**2
if norm > 0:
norm = 1 / numpy.sqrt(norm)
xs *= norm
ys *= norm
e.append(w[i])
xy.append((_unpack(xs, mo_occ), _unpack(ys, mo_occ)))
self.e = numpy.array(e)
self.xy = xy
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
logger.warn(
self, 'PBC-TDDFT is an experimental feature. '
'It is numerically sensitive to the accuracy of integrals '
'(relating to cell.precision).')
self.check_sanity()
self.dump_flags()
vind, hdiag = self.get_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD)
& (w.real > POSTIVE_EIG_THRESHOLD))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:, idx].real, idx
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=self.verbose)
mo_occ = self._scf.mo_occ
self.e = w
def norm_xy(z):
x, y = z.reshape(2, -1)
norm = 2 * (lib.norm(x)**2 - lib.norm(y)**2)
norm = 1 / numpy.sqrt(norm)
x *= norm
y *= norm
return _unpack(x, mo_occ), _unpack(y, mo_occ)
self.xy = [norm_xy(z) for z in x1]
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
vind, hdiag = self.get_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < 1e-6) & (w.real > 0))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:, idx].real, idx
w, x1 = lib.davidson_nosym1(vind,
x0,
precond,
tol=self.conv_tol,
nroots=self.nstates,
lindep=self.lindep,
max_space=self.max_space,
pick=pickeig,
verbose=self.verbose)[1:]
mo_occ = self._scf.mo_occ
e = []
xy = []
for i, z in enumerate(x1):
xs, ys = z.reshape(2, -1)
norm = lib.norm(xs)**2 - lib.norm(ys)**2
if norm > 0:
norm = 1 / numpy.sqrt(norm)
xs *= norm
ys *= norm
e.append(w[i])
xy.append((_unpack(xs, mo_occ), _unpack(ys, mo_occ)))
self.e = numpy.array(e)
self.xy = xy
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
mo_energy = self._scf.mo_energy
nocc = (self._scf.mo_occ > 0).sum()
eai = lib.direct_sum('a-i->ai', mo_energy[nocc:], mo_energy[:nocc])
nvir = eai.shape[0]
if x0 is None:
x0 = self.init_guess(eai, self.nstates)
precond = self.get_precond(eai.ravel())
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < 1e-6) & (w.real > 0))[0]
idx = realidx[w[realidx].real.argsort()]
return w[idx].real, v[:, idx].real, idx
w, x1 = lib.davidson_nosym1(self.get_vind,
x0,
precond,
tol=self.conv_tol,
nroots=self.nstates,
lindep=self.lindep,
max_space=self.max_space,
pick=pickeig,
verbose=self.verbose)[1:]
self.e = w
def norm_xy(z):
x, y = z.reshape(2, nvir, nocc)
norm = 2 * (lib.norm(x)**2 - lib.norm(y)**2)
norm = 1 / numpy.sqrt(norm)
return x * norm, y * norm
self.xy = [norm_xy(z) for z in x1]
return self.e, self.xy
def kernel(self, x0=None):
'''TDHF diagonalization with non-Hermitian eigenvalue solver
'''
self.check_sanity()
self.dump_flags()
vind, hdiag = self.get_vind(self._scf)
precond = self.get_precond(hdiag)
if x0 is None:
x0 = self.init_guess(self._scf, self.nstates)
# We only need positive eigenvalues
def pickeig(w, v, nroots, envs):
realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &
(w.real > POSTIVE_EIG_THRESHOLD))[0]
return lib.linalg_helper._eigs_cmplx2real(w, v, realidx)
self.converged, w, x1 = \
lib.davidson_nosym1(vind, x0, precond,
tol=self.conv_tol,
nroots=self.nstates, lindep=self.lindep,
max_space=self.max_space, pick=pickeig,
verbose=self.verbose)
mo_occ = self._scf.mo_occ
e = []
xy = []
for i, z in enumerate(x1):
xs, ys = z.reshape(2,-1)
norm = lib.norm(xs)**2 - lib.norm(ys)**2
if norm > 0:
norm = 1/numpy.sqrt(norm)
xs *= norm
ys *= norm
e.append(w[i])
xy.append((_unpack(xs, mo_occ), _unpack(ys, mo_occ)))
self.e = numpy.array(e)
self.xy = xy
return self.e, self.xy
def _run_pbc(mf, helper=None, method='2', which='ip', nroots=5, tol=1e-12,
maxiter=100, maxspace=12, do_mp2=False, koopmans=False, verbose=False):
if helper is None:
helper = load_helper(mf, method=method, which=which)
if callable(helper):
helper = helper(mf)
es = []
vs = []
mp2 = []
convs = []
for ki in range(helper.nkpts):
matvec, diag = helper.get_matvec(ki)
matvecs = lambda xs: [matvec(x) for x in xs]
guesses = helper.get_guesses(ki, diag, nroots, koopmans=koopmans)
pick = get_picker(koopmans=koopmans, real_system=False, guess=guesses)
kwargs = dict(tol=tol, nroots=nroots, pick=pick, max_cycle=maxiter,
max_space=maxspace, verbose=9 if verbose else 0)
conv, e, v = lib.davidson_nosym1(matvecs, guesses, diag, **kwargs)
if which == 'ip':
e = utils.nested_apply(e, lambda x: -x)
es.append(e)
vs.append(v)
convs.append(conv)
if do_mp2:
mp2 = helper.mp2()
if which == 'ea':
mp2 *= -1
return es, vs, convs, mp2
else:
return es, vs, convs
def davidson(self, *args, **kwargs):
return lib.davidson_nosym1(*args, **kwargs)