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)