def pad_atoms(atoms: Atoms, margin: float):
"""
Repeat the atoms in x and y, retaining only the repeated atoms within the margin distance from the cell boundary.
Parameters
----------
atoms: ASE Atoms object
The atoms that should be padded.
margin: float
The padding margin.
Returns
-------
ASE Atoms object
Padded atoms.
"""
if not is_cell_orthogonal(atoms):
raise RuntimeError('The cell of the atoms must be orthogonal.')
left = atoms[atoms.positions[:, 0] < margin]
left.positions[:, 0] += atoms.cell[0, 0]
right = atoms[atoms.positions[:, 0] > atoms.cell[0, 0] - margin]
right.positions[:, 0] -= atoms.cell[0, 0]
atoms += left + right
top = atoms[atoms.positions[:, 1] < margin]
top.positions[:, 1] += atoms.cell[1, 1]
bottom = atoms[atoms.positions[:, 1] > atoms.cell[1, 1] - margin]
bottom.positions[:, 1] -= atoms.cell[1, 1]
atoms += top + bottom
return atoms
def pad_atoms(atoms, margin):
if not is_cell_orthogonal(atoms):
raise RuntimeError()
left = atoms[atoms.positions[:, 0] < margin]
left.positions[:, 0] += atoms.cell[0, 0]
right = atoms[atoms.positions[:, 0] > atoms.cell[0, 0] - margin]
right.positions[:, 0] -= atoms.cell[0, 0]
atoms += left + right
top = atoms[atoms.positions[:, 1] < margin]
top.positions[:, 1] += atoms.cell[1, 1]
bottom = atoms[atoms.positions[:, 1] > atoms.cell[1, 1] - margin]
bottom.positions[:, 1] -= atoms.cell[1, 1]
atoms += top + bottom
return atoms
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)