mpi_array.indexing.HaloIndexingExtent¶

class mpi_array.indexing.HaloIndexingExtent(slice=None, start=None, stop=None, halo=None, struct=None)[source]¶

Bases: mpi_array.indexing.IndexingExtent

Indexing bounds with ghost (halo) elements, for a single tile of domain decomposition.

Example:

>>> from mpi_array.indexing import HaloIndexingExtent
>>>
>>> hie = HaloIndexingExtent(start=(10,), stop=(20,), halo=((2,4),))
>>> print("hie.start_n = %s" % (hie.start_n,)) # start without halo
hie.start_n = [10]
>>> print("hie.start_h = %s" % (hie.start_h,)) # start with halo
hie.start_h = [8]
>>> print("hie.stop_n  = %s" % (hie.stop_n,))  # stop without halo
hie.stop_n  = [20]
>>> print("hie.stop_h  = %s" % (hie.stop_h,))  # stop with halo
hie.stop_h  = [24]

Methods

`__init__`([slice, start, stop, halo, struct])	Construct.
`calc_intersection`(other)	Returns the indexing extent which is the intersection of this extent with the `other` extent.
`calc_intersection_split`(other)	Returns `(leftovers, intersection)` pair, where `intersection` is the `IndexingExtent` object (possibly `None`) indicating the intersection of this (`self`) extent with the `other` extent and `leftovers` is a list of `IndexingExtent` objects indicating regions of `self` which do not intersect with the `other` extent.
`create_struct_dtype_from_ndim`(ndim)	Creates a `numpy.dtype` structure for holding start and stop indices.
`create_struct_instance`(ndim)	Creates a struct instance with `numpy.dtype` `self.struct_dtype_dict[ndim]`.
`get_struct_dtype`(ndim)
`get_struct_dtype_from_ndim`(ndim)
`globale_to_locale_extent_h`(gext)	Return `gext` converted to locale index.
`globale_to_locale_h`(gidx)	Convert globale array index to locale array index.
`globale_to_locale_n`(gidx)	Convert globale array index to locale array index.
`globale_to_locale_slice_h`(gslice)	Return `gslice` converted to locale slice.
`globale_to_locale_slice_n`(gslice)	Return `gslice` converted to locale slice.
`locale_to_globale_extent_h`(lext)	Return `lext` converted to globale index.
`locale_to_globale_h`(lidx)	Convert locale array index to globale array index.
`locale_to_globale_n`(lidx)	Convert locale array index to globale array index.
`locale_to_globale_slice_h`(lslice)	Return `lslice` converted to globale slice.
`locale_to_globale_slice_n`(lslice)	Return `lslice` converted to globale slice.
`split`(a, index)	Split this extent into two extents by cutting along axis `a` at index `index`.
`to_slice`()	Same as `to_slice_n()`.
`to_slice_h`()	Returns “`tuple` of `slice`” equivalent of this indexing extent including halo.
`to_slice_n`()	Returns “`tuple` of `slice`” equivalent of this indexing extent without halo (“no halo”).
`to_tuple`()	Convert this instance to a `tuple` which can be passed to constructor (or used as a `dict` key).

Attributes

`HALO`
`HALO_STR`
`HI`	The “high index” indices.
`LO`	The “low index” indices.
`START`
`START_N`
`START_N_STR`
`START_STR`
`STOP`
`STOP_N`
`STOP_N_STR`
`STOP_STR`
`halo`	A `(len(self.start), 2)` shaped array of `int` indicating the per-axis number of outer ghost elements.
`ndim`	Dimension of indexing.
`shape`	Same as `shape_n`.
`shape_h`	The shape of the tile with “halo” elements.
`shape_n`	The shape of the tile without “halo” elements (“no halo”).
`size_h`	Integer indicating the number of elements in this extent including halo.
`size_n`	Integer indicating the number of elements in this extent without halo (“no halo”)
`start`	Same as `start_n`.
`start_h`	The start index of the tile with “halo” elements.
`start_n`	The start index of the tile without “halo” elements (“no halo”).
`stop`	Same as `stop_n`.
`stop_h`	The stop index of the tile with “halo” elements.
`stop_n`	The stop index of the tile without “halo” elements (“no halo”).
`struct_dtype_dict`