def symbolic_shape(self):
"""
The symbolic shape of the object. This includes the domain, halo, and
padding regions. While halo and padding are known quantities (integers),
the domain size is given as a symbol.
"""
halo = [Add(*i) for i in self._size_halo]
padding = [Add(*i) for i in self._size_padding]
domain = [i.symbolic_size for i in self.indices]
ret = tuple(Add(i, j, k) for i, j, k in zip(domain, halo, padding))
return EnrichedTuple(*ret, getters=self.dimensions)
def _extent_padding(self):
"""
The number of grid points in the padding region.
"""
left = tuple(zip(*self._padding))[0]
right = tuple(zip(*self._padding))[1]
Extent = namedtuple('Extent', 'left right')
extents = tuple(Extent(i, j) for i, j in self._padding)
return EnrichedTuple(*extents, getters=self.dimensions, left=left, right=right)
def _size_nodomain(self):
"""Number of points in the padding+halo region."""
left = tuple(i for i, _ in np.add(self._halo, self._padding))
right = tuple(i for _, i in np.add(self._halo, self._padding))
sizes = tuple(Size(i, j) for i, j in np.add(self._halo, self._padding))
return EnrichedTuple(*sizes,
getters=self.dimensions,
left=left,
right=right)
def _offset_owned(self):
"""Number of points before the first and last owned elements."""
left = tuple(self._offset_domain)
right = tuple(np.add(self._offset_halo.left, self._size_domain))
offsets = tuple(Offset(i, j) for i, j in zip(left, right))
return EnrichedTuple(*offsets,
getters=self.dimensions,
left=left,
right=right)
def _size_padding(self):
"""Number of points in the padding region."""
left = tuple(zip(*self._padding))[0]
right = tuple(zip(*self._padding))[1]
sizes = tuple(Size(i, j) for i, j in self._padding)
return EnrichedTuple(*sizes,
getters=self.dimensions,
left=left,
right=right)
def _size_owned(self):
"""Number of points in the owned region."""
left = tuple(self._size_halo.right)
right = tuple(self._size_halo.left)
sizes = tuple(Size(i.right, i.left) for i in self._size_halo)
return EnrichedTuple(*sizes,
getters=self.dimensions,
left=left,
right=right)
def symbolic_shape(self):
"""
The symbolic shape of the object. This includes:
* the domain, halo, and padding regions. While halo and padding are
known quantities (integers), the domain size is represented by a symbol.
* the shifting induced by the ``staggered`` mask.
"""
symbolic_shape = super(DiscreteFunction, self).symbolic_shape
ret = tuple(Add(i, -j) for i, j in zip(symbolic_shape, self.staggered))
return EnrichedTuple(*ret, getters=self.dimensions)
def aindices(self):
aindices = []
for i, fi in zip(self, self.findices):
if q_monoaffine(i, fi, self.findices):
aindices.append(fi)
elif isinstance(i, Dimension):
aindices.append(i)
else:
dims = {i for i in i.free_symbols if isinstance(i, Dimension)}
aindices.append(dims.pop() if len(dims) == 1 else None)
return EnrichedTuple(*aindices, getters=self.findices)
def _extent_halo(self):
"""
The number of grid points in the halo region.
"""
left = tuple(zip(*self._halo))[0]
right = tuple(zip(*self._halo))[1]
Extent = namedtuple('Extent', 'left right')
extents = tuple(Extent(i, j) for i, j in self._halo)
return EnrichedTuple(*extents, left=left, right=right)
def _size_halo(self):
"""Number of points in the halo region."""
left = tuple(zip(*self._halo))[0]
right = tuple(zip(*self._halo))[1]
Size = namedtuple('Size', 'left right')
sizes = tuple(Size(i, j) for i, j in self._halo)
return EnrichedTuple(*sizes,
getters=self.dimensions,
left=left,
right=right)
def _offset_domain(self):
"""
The number of grid points between the first (last) allocated element
(possibly in the halo/padding region) and the first (last) domain element,
for each dimension.
"""
left = tuple(np.add(self._extent_halo.left, self._extent_padding.left))
right = tuple(np.add(self._extent_halo.right, self._extent_padding.right))
Offset = namedtuple('Offset', 'left right')
offsets = tuple(Offset(i, j) for i, j in np.add(self._halo, self._padding))
return EnrichedTuple(*offsets, left=left, right=right)
def _offset_halo(self):
"""Number of points before the first and last halo elements."""
left = tuple(self._size_padding.left)
right = tuple(
np.add(np.add(left, self._size_halo.left), self._size_domain))
Offset = namedtuple('Offset', 'left right')
offsets = tuple(Offset(i, j) for i, j in zip(left, right))
return EnrichedTuple(*offsets,
getters=self.dimensions,
left=left,
right=right)
def _offset_halo(self):
"""
The number of grid points between the first (last) allocated element
(possibly in the halo/padding region) and the first (last) halo element,
for each dimension.
"""
left = self._extent_padding.left
right = self._extent_padding.right
Offset = namedtuple('Offset', 'left right')
offsets = tuple(Offset(i, j) for i, j in self._padding)
return EnrichedTuple(*offsets, getters=self.dimensions, left=left, right=right)
def aindices(self):
retval = []
for i, fi in zip(self, self.findices):
dims = {j for j in i.free_symbols if isinstance(j, Dimension)}
if len(dims) == 1:
retval.append(dims.pop())
elif isinstance(i, Dimension):
retval.append(i)
elif q_constant(i):
retval.append(fi)
else:
retval.append(None)
return EnrichedTuple(*retval, getters=self.findices)
def _size_outhalo(self):
"""Number of points in the outer halo region."""
if self._distributor is None:
return self._size_inhalo
left = [self._distributor.glb_to_loc(d, i, LEFT, strict=False)
for d, i in zip(self.dimensions, self._size_inhalo.left)]
right = [self._distributor.glb_to_loc(d, i, RIGHT, strict=False)
for d, i in zip(self.dimensions, self._size_inhalo.right)]
Size = namedtuple('Size', 'left right')
sizes = tuple(Size(i, j) for i, j in zip(left, right))
return EnrichedTuple(*sizes, getters=self.dimensions, left=left, right=right)
def symbolic_shape(self):
"""
Return the symbolic shape of the object. This includes the padding,
halo, and domain regions. While halo and padding are known quantities
(integers), the domain size is represented by a symbol.
"""
halo_sizes = [sympy.Add(*i, evaluate=False) for i in self._extent_halo]
padding_sizes = [
sympy.Add(*i, evaluate=False) for i in self._extent_padding
]
domain_sizes = [i.symbolic_size for i in self.indices]
ret = tuple(
sympy.Add(i, j, k, evaluate=False)
for i, j, k in zip(domain_sizes, halo_sizes, padding_sizes))
return EnrichedTuple(*ret, getters=self.dimensions)
def index_mode(self):
retval = []
for i, fi in zip(self, self.findices):
dims = {j for j in i.free_symbols if isinstance(j, Dimension)}
if len(dims) == 0 and q_constant(i):
retval.append(AFFINE)
elif len(dims) == 1:
candidate = dims.pop()
if fi in candidate._defines and q_affine(i, candidate):
retval.append(AFFINE)
else:
retval.append(IRREGULAR)
else:
retval.append(IRREGULAR)
return EnrichedTuple(*retval, getters=self.findices)
def _size_domain(self):
"""Number of points in the domain region."""
return EnrichedTuple(*self.shape, getters=self.dimensions)
def indices_ref(self):
"""The reference indices of the object (indices at first creation)."""
return EnrichedTuple(*self.function.indices, getters=self.dimensions)
def glb_numb(self):
"""The global indices owned by the calling MPI rank."""
assert len(self.mycoords) == len(self.decomposition)
glb_numb = [i[j] for i, j in zip(self.decomposition, self.mycoords)]
return EnrichedTuple(*glb_numb, getters=self.dimensions)
def decomposition(self):
"""The Decompositions, one for each decomposed Dimension."""
return EnrichedTuple(*self._decomposition, getters=self.dimensions)
def glb_shape(self):
"""Shape of the decomposed domain."""
return EnrichedTuple(*self._glb_shape, getters=self.dimensions)
def decomposition(self):
"""The :class:`Decomposition`s, one for each decomposed :class:`Dimension`."""
return EnrichedTuple(*self._decomposition, getters=self.dimensions)
def glb_numb(self):
"""Return the global numbering of this process' domain section."""
assert len(self._comm.coords) == len(self._glb_numbs)
glb_numb = [i[j] for i, j in zip(self._glb_numbs, self._comm.coords)]
return EnrichedTuple(*glb_numb, getters=self.dimensions)
def _size_nopad(self):
"""Number of points in the domain+halo region."""
sizes = tuple(i+sum(j) for i, j in zip(self._size_domain, self._size_halo))
return EnrichedTuple(*sizes, getters=self.dimensions)
def _offset_domain(self):
"""Number of points before the first domain element."""
offsets = tuple(np.add(self._size_padding.left, self._size_halo.left))
return EnrichedTuple(*offsets, getters=self.dimensions)
def glb_shape(self):
return EnrichedTuple(*self._glb_shape, getters=self.dimensions)