def test_projected_kirkland():
f = lambda r: kirkland(r, parameters[6])
parameters = load_kirkland_parameters()
r = np.geomspace(.01, 10, 100)
integrator = PotentialIntegrator(f, r, 20)
assert np.allclose(
integrator.integrate(np.array([0.]), -10, 10)[0],
kirkland_projected(r, parameters[6]))
import numpy as np
from abtem.parametrizations import lobato, kirkland, load_kirkland_parameters, load_lobato_parameters
from abtem.potentials import kappa
kirkland_parameters = load_kirkland_parameters()
lobato_parameters = load_lobato_parameters()
def test_similar():
r = np.linspace(.1, 2, 5)
assert np.allclose(lobato(r, lobato_parameters[47]),
kirkland(r, kirkland_parameters[47]),
rtol=.1)
def test_values():
r = np.array([1., 1.316074, 1.7320508, 2.2795072, 3.])
assert np.allclose(
lobato(r, lobato_parameters[47]) / kappa,
[10.877785, 3.5969334, 1.1213292, 0.29497656, 0.05587856])
assert np.allclose(
kirkland(r, kirkland_parameters[47]) / kappa,
[10.966407, 3.7869546, 1.1616056, 0.2839873, 0.04958321])
def __init__(self,
atoms: Union[Atoms, AbstractFrozenPhonons] = None,
gpts: Union[int, Sequence[int]] = None,
sampling: Union[float, Sequence[float]] = None,
slice_thickness: float = .5,
parametrization: str = 'lobato',
projection: str = 'finite',
cutoff_tolerance: float = 1e-3,
device='cpu',
precalculate: bool = True,
storage=None):
self._cutoff_tolerance = cutoff_tolerance
self._parametrization = parametrization
self._slice_thickness = slice_thickness
self._storage = storage
if parametrization.lower() == 'lobato':
self._parameters = load_lobato_parameters()
self._function = lobato
self._derivative = dvdr_lobato
elif parametrization.lower() == 'kirkland':
self._parameters = load_kirkland_parameters()
self._function = kirkland
self._derivative = dvdr_kirkland
else:
raise RuntimeError(
'Parametrization {} not recognized'.format(parametrization))
if projection == 'infinite':
if parametrization.lower() != 'kirkland':
raise RuntimeError(
'Infinite projections are only implemented for the Kirkland parametrization'
)
elif (projection != 'finite'):
raise RuntimeError('Projection must be "finite" or "infinite"')
self._projection = projection
if isinstance(atoms, AbstractFrozenPhonons):
self._frozen_phonons = atoms
else:
self._frozen_phonons = DummyFrozenPhonons(atoms)
atoms = next(iter(self._frozen_phonons))
if np.abs(atoms.cell[2, 2]) < 1e-12:
raise RuntimeError('Atoms cell has no thickness')
if not is_cell_orthogonal(atoms):
raise RuntimeError('Atoms are not orthogonal')
self._atoms = atoms
self._grid = Grid(extent=np.diag(atoms.cell)[:2],
gpts=gpts,
sampling=sampling,
lock_extent=True)
self._cutoffs = {}
self._integrators = {}
self._disc_indices = {}
def grid_changed_callback(*args, **kwargs):
self._integrators = {}
self._disc_indices = {}
self.grid.changed.register(grid_changed_callback)
self.changed = Event()
if storage is None:
storage = device
super().__init__(precalculate=precalculate,
device=device,
storage=storage)
def __init__(self,
atoms: Union[Atoms, AbstractFrozenPhonons] = None,
gpts: Union[int, Sequence[int]] = None,
sampling: Union[float, Sequence[float]] = None,
slice_thickness: float = .5,
parametrization: str = 'lobato',
cutoff_tolerance: float = 1e-3,
device='cpu',
storage=None):
self._cutoff_tolerance = cutoff_tolerance
self._parametrization = parametrization
self._slice_thickness = slice_thickness
self._storage = storage
if parametrization == 'lobato':
self._parameters = load_lobato_parameters()
self._function = lobato # lambda r: lobato(r, parameters[atomic_number])
self._derivative = dvdr_lobato # lambda r: dvdr_lobato(r, parameters[atomic_number])
elif parametrization == 'kirkland':
self._parameters = load_kirkland_parameters()
self._function = kirkland # lambda r: kirkland(r, parameters[atomic_number])
self._derivative = dvdr_kirkland # lambda r: dvdr_kirkland(r, parameters[atomic_number])
else:
raise RuntimeError(
'Parametrization {} not recognized'.format(parametrization))
if isinstance(atoms, AbstractFrozenPhonons):
self._frozen_phonons = atoms
else:
self._frozen_phonons = DummyFrozenPhonons(atoms)
atoms = next(iter(self._frozen_phonons))
if np.abs(atoms.cell[2, 2]) < 1e-12:
raise RuntimeError('Atoms cell has no thickness')
if not is_cell_orthogonal(atoms):
raise RuntimeError('Atoms are not orthogonal')
self._atoms = atoms
self._grid = Grid(extent=np.diag(atoms.cell)[:2],
gpts=gpts,
sampling=sampling,
lock_extent=True)
self._cutoffs = {}
self._integrators = {}
def grid_changed_callback(*args, **kwargs):
self._integrators = {}
self.grid.changed.register(grid_changed_callback)
self.changed = Event()
self._device = device
if storage is None:
self._storage = device
super().__init__(storage=storage)