| 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) |
|
|
