# error for multiple entries
return AtomXYZ(**{key: interval}, **new_kwargs)
elif len(interval) != 0:
raise ValueError(
f"{cls.__name__} non-keyword argumest must be 1 tuple, or 2 values"
)
return AtomXYZ(**new_kwargs)
return _new
# Iterate over all directions that deserve an individual class
for key in ("x", "y", "z", "f_x", "f_y", "f_z", "a_x", "a_y", "a_z"):
# The underscores are just kept for the key that is passed to AtomXYZ,
# but the name of the category will have no underscore
name = key.replace("_", "")
# Create the class for this direction
# note this is lower case since AtomZ should not interfere with Atomz
new_cls = AtomXYZMeta(f"Atom{name}", (AtomCategory, ),
{"__new__": _new_factory(key)})
new_cls = set_module("sisl.geom")(new_cls)
# Set it as an attribute of `AtomXYZ`, so that you can access them from it.
# Note that the classes are never exposed, so you can not import them, and the way
# to use them is either through the kw builder in `AtomCategory` or from `AtomXYZ` attributes.
# This enables AtomXYZ.fz < 0.5, for example.
setattr(AtomXYZ, name, new_cls)
eigvalsh = _partial(sl.eigvalsh, check_finite=False, overwrite_a=False, overwrite_b=False, turbo=True)
eigvalsh_dc = eigvalsh
eigvalsh_qr = _partial(sl.eigvalsh, check_finite=False, overwrite_a=False, overwrite_b=False, turbo=False)
__all__ += _append('eigvalsh', ['', '_dc', '_qr'])
eigvalsh_destroy = _partial(sl.eigvalsh, check_finite=False, overwrite_a=True, overwrite_b=True, turbo=True)
eigvalsh_dc_destroy = eigvalsh_destroy
eigvalsh_qr_destroy = _partial(sl.eigvalsh, check_finite=False, overwrite_a=True, overwrite_b=True, turbo=False)
__all__ += _append('eigvalsh_', ['destroy', 'dc_destroy', 'qr_destroy'])
# SVD problem
svd = _partial(sl.svd, check_finite=False, overwrite_a=False)
svd_destroy = _partial(sl.svd, check_finite=False, overwrite_a=True)
__all__ += _append('svd', ['', '_destroy'])
# Determinants
det = _partial(sl.det, check_finite=False, overwrite_a=False)
det_destroy = _partial(sl.det, check_finite=False, overwrite_a=True)
__all__ += _append('det', ['', '_destroy'])
# Sparse linalg routines
# Solve eigenvalue problem
eigs = set_module("sisl.linalg")(ssl.eigs)
__all__ += ['eigs']
# Solve symmetric/hermitian eigenvalue problem (generic == no overwrite)
eigsh = set_module("sisl.linalg")(ssl.eigsh)
__all__ += ['eigsh']
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at https://mozilla.org/MPL/2.0/.
from ..sile import add_sile
from sisl._internal import set_module
from sisl.io.siesta.binaries import _gfSileSiesta
__all__ = ['tbtgfSileTBtrans']
dic = {}
try:
dic['__doc__'] = _gfSileSiesta.__doc__.replace(_gfSileSiesta.__name__,
'tbtgfSileTBtrans')
except Exception:
pass
tbtgfSileTBtrans = set_module("sisl.io.tbtrans")(type("tbtgfSileTBtrans",
(_gfSileSiesta, ), dic))
del dic
add_sile('TBTGF', tbtgfSileTBtrans)
return coef * (hist[0] + self.weight * hist[1])
return reduce(add, map(frac_hist, coefficients, self.history))
def __call__(self, f, df, delta=None, append=True):
# Add to history
if append:
if delta is None:
self.history.append(f, df)
else:
self.history.append(f, df, delta)
# Calculate new mixing quantity
return self.mix(self.coefficients())
PulayMixer = set_module("sisl.mixing")(type("PulayMixer", (DIISMixer, ), {}))
@set_module("sisl.mixing")
class AdaptiveDIISMixer(DIISMixer):
r""" Adapt the mixing weight according to the Lagrange multiplier
The Lagrange multiplier calculated in a DIIS/Pulay mixing scheme
is the squared norm of the residual that is minimized using the
Lagrange method. It holds information on the closeness of the functional
to a minimum.
Thus we can use the Lagrange multiplier to adjust the weight such that
for large values we know our next guess (:math:`f_{\mathrm{new}}`) will
be relatively far from the true saddle point, and for small values we
will be close to the saddle point.
