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 DimensionTuple(*sizes,
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 DimensionTuple(*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 DimensionTuple(*offsets,
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 DimensionTuple(*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 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.dimensions]
ret = tuple(Add(i, j, k) for i, j, k in zip(domain, halo, padding))
return DimensionTuple(*ret, getters=self.dimensions)
def __new__(cls, expr, *dims, **kwargs):
if type(expr) == sympy.Derivative:
raise ValueError("Cannot nest sympy.Derivative with devito.Derivative")
if not isinstance(expr, Differentiable):
raise ValueError("`expr` must be a Differentiable object")
new_dims, orders, fd_o, var_count = cls._process_kwargs(expr, *dims, **kwargs)
# Construct the actual Derivative object
obj = Differentiable.__new__(cls, expr, *var_count)
obj._dims = tuple(OrderedDict.fromkeys(new_dims))
skip = kwargs.get('preprocessed', False) or obj.ndims == 1
obj._fd_order = fd_o if skip else DimensionTuple(*fd_o, getters=obj._dims)
obj._deriv_order = orders if skip else DimensionTuple(*orders, getters=obj._dims)
obj._side = kwargs.get("side")
obj._transpose = kwargs.get("transpose", direct)
obj._subs = as_tuple(kwargs.get("subs"))
obj._x0 = kwargs.get('x0', None)
return obj
def __call__(self, x0=None, fd_order=None, side=None):
if self.ndims == 1:
_fd_order = fd_order or self._fd_order
_side = side or self._side
new_x0 = {self.dims[0]: x0} if x0 is not None else self.x0
return self._new_from_self(fd_order=_fd_order, side=_side, x0=new_x0)
if side is not None:
raise TypeError("Side only supported for first order single"
"Dimension derivative such as `.dxl` or .dx(side=left)")
# Cross derivative
_x0 = self._x0 or {}
_fd_order = dict(self.fd_order._getters)
try:
_fd_order.update(**(fd_order or {}))
_fd_order = tuple(_fd_order.values())
_fd_order = DimensionTuple(*_fd_order, getters=self.dims)
_x0.update(x0)
except AttributeError:
raise TypeError("Multi-dimensional Derivative, input expected as a dict")
return self._new_from_self(fd_order=_fd_order, x0=_x0)
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 DimensionTuple(*offsets, 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 DimensionTuple(*sizes, getters=self.dimensions)
def _size_domain(self):
"""Number of points in the domain region."""
return DimensionTuple(*self.shape, getters=self.dimensions)
def indices_ref(self):
"""The reference indices of the object (indices at first creation)."""
return DimensionTuple(*self.function.indices, getters=self.dimensions)
def indices(self):
"""The indices (aka dimensions) of the object."""
return DimensionTuple(*self.args, getters=self.dimensions)
def indices(self):
return DimensionTuple(*super().indices,
getters=self.function.dimensions)
