File size: 2,438 Bytes
6288873 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 | import numpy as np
from typing import Sequence, Tuple, Union
def calculate_periodic_indices(
key: Tuple[Union[int, slice], Union[int, slice]],
structure: Tuple[Tuple[int, ...], ...],
real_ix: int,
real_iy: int,
) -> Sequence[Sequence[int]]:
"""
Get indices according to unit cell structure.
Args:
key (:obj:`tuple` of 2 :obj:`int` or :obj:`slice` elements):
x and y coordinates to select. Can be either integers or slices.
Negative numbers as selectors are supported.
structure (2d :obj:`jax.numpy.ndarray`):
Two dimensional array modeling the structure of the unit cell. For
details see the description of :obj:`~varipeps.peps.PEPS_Unit_Cell`.
real_ix (:obj:`int`):
Which real x index of structure correspond to x = 0.
real_iy (:obj:`int`):
Which real y index of structure correspond to y = 0.
Returns:
:term:`sequence` of :term:`sequence` of :obj:`int`:
2d sequence with the indices of the selected objects.
"""
if not isinstance(key, tuple) or not len(key) == 2:
raise TypeError("Expect a tuple with coordinates x and y.")
x, y = key
if isinstance(x, int):
x = slice(x, x + 1, None)
if isinstance(y, int):
y = slice(y, y + 1, None)
if not isinstance(x, slice) or not isinstance(y, slice):
raise TypeError("Key elements have to be integers or slices.")
unit_cell_len_x = len(structure)
unit_cell_len_y = len(structure[0])
if x.start is not None and x.start < 0:
shift = (-x.start // unit_cell_len_x + 1) * unit_cell_len_x
x = slice(x.start + shift, x.stop + shift, x.step)
if x.start is None and x.stop < 0:
x = slice(None, x.stop + unit_cell_len_x, x.step)
if y.start is not None and y.start < 0:
shift = (-y.start // unit_cell_len_y + 1) * unit_cell_len_y
y = slice(y.start + shift, y.stop + shift, y.step)
if y.start is None and y.stop < 0:
y = slice(None, y.stop + unit_cell_len_y, y.step)
xarr = np.arange(
x.start or 0, x.stop if x.stop is not None else unit_cell_len_x, x.step
)
yarr = np.arange(
y.start or 0, y.stop if y.stop is not None else unit_cell_len_y, y.step
)
xarr = (real_ix + xarr) % unit_cell_len_x
yarr = (real_iy + yarr) % unit_cell_len_y
return tuple(tuple(structure[xi][yi] for yi in yarr) for xi in xarr)
|