pyMOTO 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

pymoto/modules/assembly.py

@@ -49,8 +49,8 @@ class AssembleGeneral(Module):
         self.dofconn = domain.get_dofconnectivity(self.ndof)
 
         # Row and column indices for the matrix
-        self.rows = np.kron(self.dofconn, np.ones((domain.elemnodes*self.ndof, 1), dtype=int)).flatten()
-        self.cols = np.kron(self.dofconn, np.ones((1, domain.elemnodes*self.ndof), dtype=int)).flatten()
+        self.rows = np.kron(self.dofconn, np.ones((1, domain.elemnodes*self.ndof), dtype=int)).flatten()
+        self.cols = np.kron(self.dofconn, np.ones((domain.elemnodes * self.ndof, 1), dtype=int)).flatten()
         self.matrix_type = matrix_type
 
         # Boundary conditions
@@ -68,6 +68,8 @@ class AssembleGeneral(Module):
         self.add_constant = add_constant
 
     def _response(self, xscale: np.ndarray):
+        nel = self.dofconn.shape[0]
+        assert xscale.size == nel, f"Input vector wrong size ({xscale.size}), must be of size #nel ({nel})"
         scaled_el = ((self.elmat.flatten()[np.newaxis]).T * xscale).flatten(order='F')
 
         # Set boundary conditions
@@ -104,15 +106,17 @@ class AssembleGeneral(Module):
             return dgdmat.contract(self.elmat, self.dofconn, self.dofconn)
 
 
-def get_B(dN_dx):
+def get_B(dN_dx, voigt=True):
     """ Gets the strain-displacement relation (Cook, eq 3.1-9, P.80)
 
       - 1D : [ε_x]_i = B [u]_i
       - 2D : [ε_x; ε_y; γ_xy]_i = B [u, v]_i
-      - 3D : [ε_x; ε_y; ε_z; γ_xy; γ_yz; γ_zx]_i = B [u, v, w]_i
+      - 3D : [ε_x; ε_y; ε_z; γ_xy; γ_yz; γ_zx]_i = B [u, v, w]_i (standard notation)
+             [ε_x; ε_y; ε_z; γ_yz; γ_zx; γ_xy]_i = B [u, v, w]_i (Voigt notation)
 
     Args:
         dN_dx: Shape function derivatives [dNi_dxj] of size (#shapefn. x #dimensions)
+        voigt(optional): Use Voigt notation for the shear terms [yz, zx, xy] or standard notation [xy, yz, zx]
 
     Returns:
         B strain-displacement relation of size (#strains x #shapefn.*#dimensions)
@@ -130,12 +134,21 @@ def get_B(dN_dx):
                                                   [dN_dx[1, i], dN_dx[0, i]]])
     elif n_dim == 3:
         for i in range(n_shapefn):
-            B[:, i*n_dim:(i+1)*n_dim] = np.array([[dN_dx[0, i], 0,           0],
-                                                  [0,           dN_dx[1, i], 0],
-                                                  [0,           0,           dN_dx[2, i]],
-                                                  [dN_dx[1, i], dN_dx[0, i], 0],
-                                                  [0,           dN_dx[2, i], dN_dx[1, i]],
-                                                  [dN_dx[2, i], 0,           dN_dx[0, i]]])
+            if voigt:
+                B[:, i*n_dim:(i+1)*n_dim] = np.array([[dN_dx[0, i], 0,           0],
+                                                      [0,           dN_dx[1, i], 0],
+                                                      [0,           0,           dN_dx[2, i]],
+                                                      [0,           dN_dx[2, i], dN_dx[1, i]],
+                                                      [dN_dx[2, i], 0,           dN_dx[0, i]],
+                                                      [dN_dx[1, i], dN_dx[0, i], 0],
+                                                      ])
+            else:
+                B[:, i * n_dim:(i + 1) * n_dim] = np.array([[dN_dx[0, i], 0, 0],
+                                                            [0, dN_dx[1, i], 0],
+                                                            [0, 0, dN_dx[2, i]],
+                                                            [dN_dx[1, i], dN_dx[0, i], 0],
+                                                            [0, dN_dx[2, i], dN_dx[1, i]],
+                                                            [dN_dx[2, i], 0, dN_dx[0, i]]])
     else:
         raise ValueError(f"Number of dimensions ({n_dim}) cannot be greater than 3")
     return B
@@ -209,7 +222,7 @@ class AssembleStiffness(AssembleGeneral):
         ndof = nnode*domain.dim
 
         # Element stiffness matrix
-        self.KE = np.zeros((ndof, ndof))
+        self.stiffness_element = np.zeros((ndof, ndof))
 
         # Numerical integration
         siz = domain.element_size
@@ -218,13 +231,13 @@ class AssembleStiffness(AssembleGeneral):
             pos = n*(siz/2)/np.sqrt(3)  # Sampling point
             dN_dx = domain.eval_shape_fun_der(pos)
             B = get_B(dN_dx)
-            self.KE += w * B.T @ D @ B  # Add contribution
+            self.stiffness_element += w * B.T @ D @ B  # Add contribution
 
-        super()._prepare(domain, self.KE, *args, **kwargs)
+        super()._prepare(domain, self.stiffness_element, *args, **kwargs)
 
 
 class AssembleMass(AssembleGeneral):
-    r""" Consistent mass matrix assembly by scaling elements
+    r""" Consistent mass matrix or equivalents assembly by scaling elements
     :math:`\mathbf{M} = \sum_e x_e \mathbf{M}_e`
 
     Input Signal:
@@ -235,38 +248,186 @@ class AssembleMass(AssembleGeneral):
 
     Args:
         domain: The domain to assemble for -- this determines the element size and dimensionality
+        ndof: Amount of dofs per node (for mass and damping: ndof = domain.dim; else ndof=1)
         *args: Other arguments are passed to AssembleGeneral
 
     Keyword Args:
-        rho: Base density
+        material_property: Material property to use in the element matrix (for mass matrix the material density is used;
+            for damping the damping parameter, and for a thermal capacity matrix the thermal capacity multiplied with
+            density)
         bcdiagval: The value to put on the diagonal in case of boundary conditions (bc)
-        **kwargs : Other keyword-arguments are passed to AssembleGeneral
+        **kwargs: Other keyword-arguments are passed to AssembleGeneral
     """
 
-    def _prepare(self, domain: DomainDefinition, *args, rho: float = 1.0, bcdiagval=0.0, **kwargs):
-        # Element mass matrix
-        # 1/36 Mass of one element
-        mel = rho * np.prod(domain.element_size)
+    def _prepare(self, domain: DomainDefinition, *args, material_property: float = 1.0, ndof: int = 1,
+                 bcdiagval: float = 0.0, **kwargs):
+        # Element mass (or equivalent) matrix
+        self.el_mat = np.zeros((domain.elemnodes * ndof, domain.elemnodes * ndof))
 
+        # Numerical integration
+        siz = domain.element_size
+        w = np.prod(siz[:domain.dim] / 2)
+        if domain.dim != 3:
+            material_property *= np.prod(siz[domain.dim:])
+        Nmat = np.zeros((ndof, domain.elemnodes * ndof))
+
+        for n in domain.node_numbering:
+            pos = n * (siz / 2) / np.sqrt(3)  # Sampling point
+            N = domain.eval_shape_fun(pos)
+            for d in range(domain.elemnodes):
+                Nmat[0:ndof, ndof * d:ndof * d + ndof] = np.identity(ndof) * N[d]  # fill up shape function matrix according to ndof
+            self.el_mat += w * material_property * Nmat.T @ Nmat  # Add contribution
+
+        super()._prepare(domain, self.el_mat, *args, bcdiagval=bcdiagval, **kwargs)
+
+
+class AssemblePoisson(AssembleGeneral):
+    r""" Assembly of matrix to solve Poisson equation (e.g. Thermal conductivity, Electric permittivity)
+    :math:`\mathbf{P} = \sum_e x_e \mathbf{P}_e`
+
+    Input Signal:
+        - ``x``: Scaling vector of size ``(Nel)``
+
+    Output Signal:
+        - ``P``: Poisson matrix of size ``(n, n)``
+
+    Args:
+        domain: The domain to assemble for -- this determines the element size and dimensionality
+        args (optional): Other arguments are passed to AssembleGeneral
+
+    Keyword Args:
+        material_property: Material property (e.g. thermal conductivity, electric permittivity)
+        bcdiagval: The value to put on the diagonal in case of boundary conditions (bc)
+        kwargs: Other keyword-arguments are passed to AssembleGeneral
+    """
+
+    def _prepare(self, domain: DomainDefinition, *args, material_property: float = 1.0, **kwargs):
+        # Prepare material properties and element matrices
+        self.material_property = material_property
+        self.poisson_element = np.zeros((domain.elemnodes, domain.elemnodes))
+
+        # Numerical Integration
+        siz = domain.element_size
+        w = np.prod(siz[:domain.dim]/2)
+        if domain.dim != 3:
+            self.material_property *= siz[domain.dim:]
+
+        for n in domain.node_numbering:
+            pos = n*(siz/2)/np.sqrt(3)  # Sampling point
+            Bn = domain.eval_shape_fun_der(pos)
+            self.poisson_element += w * self.material_property * Bn.T @ Bn  # Add contribution
+
+        super()._prepare(domain, self.poisson_element, *args, **kwargs)
+
+
+class ElementOperation(Module):
+    r""" Generic module for element-wise operations based on nodal information
+
+    :math:`y_e = \mathbf{B} \mathbf{u}_e`
+
+    Input Signal:
+        - ``u``: Nodal vector of size ``(n_dof_per_element * #nodes)``
+
+    Output Signal:
+        - ``y``: Elemental output data of size ``(..., #elements)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., n_dof_per_element)``
+    """
+    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
+        if element_matrix.shape[-1] % domain.elemnodes != 0:
+            raise IndexError("Size of last dimension of element operator matrix is not compatible with mesh. "
+                             "Must be dividable by the number of nodes.")
+
+        ndof = element_matrix.shape[-1] // domain.elemnodes
+
+        self.element_matrix = element_matrix
+        self.dofconn = domain.get_dofconnectivity(ndof)
+        self.usiz = ndof * domain.nnodes
+
+    def _response(self, u):
+        assert u.size == self.usiz
+        return einsum('...k, lk -> ...l', self.element_matrix, u[self.dofconn], optimize=True)
+
+    def _sensitivity(self, dy):
+        du_el = einsum('...k, ...l -> lk', self.element_matrix, dy, optimize=True)
+        du = np.zeros_like(self.sig_in[0].state)
+        np.add.at(du, self.dofconn, du_el)
+        return du
+
+
+class Strain(ElementOperation):
+    r""" Evaluate average mechanical strains in solid elements based on deformation
+
+    The strains are returned in Voigt notation.
+    :math:`\mathbf{\epsilon}_e = \mathbf{B} \mathbf{u}_e`
+
+    Each integration point in the element has different strain values. Here, the average is returned.
+
+    The returned strain is either
+    :math:`\mathbf{\epsilon} = \begin{bmatrix}\epsilon_{xx} & \epsilon_{yy} & \epsilon_{xy} \end{bmatrix}`
+    in case ``voigt = False`` or
+    :math:`\mathbf{\epsilon} = \begin{bmatrix}\epsilon_{xx} & \epsilon_{yy} & \gamma_{xy} \end{bmatrix}`
+    in case ``voigt = True``, for which :math:`\gamma_{xy}=2\epsilon_{xy}`.
+
+    Input Signal:
+       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+
+    Output Signal:
+       - ``e``: Strain matrix of size ``(#strains per element, #elements)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+
+    Keyword Args:
+        voigt: Use Voigt strain notation (2x off-diagonal strain contribution)
+    """
+    def _prepare(self, domain: DomainDefinition, voigt: bool = True):
+        # Numerical integration
+        B = None
+        siz = domain.element_size
+        w = 1/domain.elemnodes  # Average strain at the integration points
+        for n in domain.node_numbering:
+            pos = n * (siz / 2) / np.sqrt(3)  # Sampling point
+            dN_dx = domain.eval_shape_fun_der(pos)
+            B_add = w*get_B(dN_dx)  # Add contribution
+            if B is None:
+                B = B_add
+            else:
+                B += B_add
+
+        if voigt:
+            idx_shear = np.count_nonzero(B, axis=1) == 2*domain.elemnodes  # Shear is combination of two displacements
+            B[idx_shear, :] *= 2  # Use engineering strain
+
+        super()._prepare(domain, B)
+
+
+class Stress(Strain):
+    """ Calculate the average stresses per element
+
+    Input Signal:
+       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+
+    Output Signal:
+       - ``s``: Stress matrix of size ``(#stresses per element, #elements)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+
+    Keyword Args:
+        e_modulus: Young's modulus
+        poisson_ratio: Poisson ratio
+        plane: Plane 'strain' or 'stress'
+    """
+    def _prepare(self, domain: DomainDefinition,
+                 e_modulus: float = 1.0, poisson_ratio: float = 0.3, plane: str = 'strain'):
+
+        super()._prepare(domain, voigt=True)
+
+        # Get material relation
+        D = get_D(e_modulus, poisson_ratio, '3d' if domain.dim == 3 else plane.lower())
         if domain.dim == 2:
-            # Consistent mass matrix
-            ME = mel / 36 * np.array([[4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0, 0.0],
-                                      [0.0, 4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0],
-                                      [2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0, 0.0],
-                                      [0.0, 2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0],
-                                      [2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0, 0.0],
-                                      [0.0, 2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0],
-                                      [1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0, 0.0],
-                                      [0.0, 1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0]])
-        elif domain.dim == 3:
-            ME = np.zeros((domain.elemnodes*domain.dim, domain.elemnodes*domain.dim))
-            weights = np.array([8.0, 4.0, 2.0, 1.0])
-            for n1 in range(domain.elemnodes):
-                for n2 in range(domain.elemnodes):
-                    dist = round(np.sum(abs(np.array(domain.node_numbering[n1]) - np.array(domain.node_numbering[n2])))/2)
-                    ME[n1*domain.dim+np.arange(domain.dim), n2*domain.dim+np.arange(domain.dim)] = weights[dist]
-
-            ME *= mel / 216
-        else:
-            raise RuntimeError("Only for 2D and 3D")
-        super()._prepare(domain, ME, *args, bcdiagval=bcdiagval, **kwargs)
+            D *= domain.element_size[2]
+        self.element_matrix = D @ self.element_matrix

pymoto/modules/complex.py

@@ -73,7 +73,7 @@ class MakeComplex(Module):
 
 
 class RealPart(Module):
-    """ Takes the real part of a complex value :math:`x = \\text{Re}(z)`
+    r""" Takes the real part of a complex value :math:`x = \text{Re}(z)`
 
     Input Signal:
         - ``z``: Complex value
@@ -89,7 +89,7 @@ class RealPart(Module):
 
 
 class ImagPart(Module):
-    """ Takes the imaginary part of a complex value :math:`y = \\text{Im}(z)`
+    r""" Takes the imaginary part of a complex value :math:`y = \text{Im}(z)`
 
     Input Signal:
         - ``z``: Complex value
@@ -105,7 +105,7 @@ class ImagPart(Module):
 
 
 class ComplexNorm(Module):
-    """ Takes the complex norm :math:`A = z z^*`
+    r""" Takes the complex norm :math:`A = \sqrt(z z^*)`
 
     Input Signal:
         - ``z``: Complex value

pymoto/modules/filter.py

@@ -1,46 +1,191 @@
-from pymoto import Module
-from .assembly import DomainDefinition
+from pymoto import Module, DomainDefinition
 import numpy as np
 from scipy.sparse import coo_matrix
-from scipy.ndimage import convolve
+from scipy.signal import convolve, correlate
+from numbers import Number
 
 
 class FilterConv(Module):
-    def _prepare(self, domain: DomainDefinition, weights: np.ndarray, mode: str = 'reflect'):
-        self.domain = domain
-        self.weights = weights
-        self.mode = mode
+    r""" Density filter based on convolution
+
+    Either the argument filter radius (`radius`) or a filtering kernel `weights` needs to be provided. If a filter
+    radius is passed, the standard linear density filter will be used (see :py:class:`pymoto.DensityFilter`).
+
+    For the boundaries, a padded effect can be selected from the following options:
+        'symmetric' (default)
+            Pads with the reflection of the vector mirrored
+            along the edge of the array.
+        value (e.g. `1.0` or `0.0`)
+            Pads with a constant value.
+        'edge'
+            Pads with the edge values of array.
+        'wrap'
+            Pads with the wrap of the vector along the axis.
+            The first values are used to pad the end and the
+            end values are used to pad the beginning.
 
-    def set_filter_radius(self, radius: float, relative_units: bool = False):
+    Args:
+        domain: The DomainDefinition
+        radius (optional): Filter radius
+        relative_units(optional): Indicate if the filter radius is in relative units with respect to the element-size or
+          is given as an absolute size
+        weights(optional): Filtering kernel (2D or 3D array)
+        xmin_bc(optional): Boundary condition for the boundary at minimum x-value
+        xmax_bc(optional): Boundary condition for the boundary at maximum x-value
+        ymin_bc(optional): Boundary condition at minimum y
+        ymax_bc(optional): Boundary condition at maximum y
+        zmin_bc(optional): Boundary condition at minimum z (only in 3D)
+        zmax_bc(optional): Bounadry condition at maximum z (only in 3D)
+    """
+    def _prepare(self, domain: DomainDefinition, radius: float = None, relative_units: bool = True, weights: np.ndarray = None,
+                 xmin_bc='symmetric', xmax_bc='symmetric',
+                 ymin_bc='symmetric', ymax_bc='symmetric',
+                 zmin_bc='symmetric', zmax_bc='symmetric'):
+
+        self.domain = domain
+        self.weights = None
+        if (weights is None and radius is None) or (weights is not None and radius is not None):
+            raise ValueError("Only one of arguments 'filter_radius' or 'weights' must be provided.")
+        elif weights is not None:
+            self.weights = weights.copy()
+            while self.weights.ndim < 3:
+                self.weights = np.expand_dims(self.weights, axis=-1)
+            for i in range(self.weights.ndim):
+                assert self.weights.shape[i] % 2 == 1, "Size of weights must be uneven"
+        elif radius is not None:
+            self.set_filter_radius(radius, relative_units)
+
+        # Process padding
+        self.overrides = []
+        self.pad_sizes = [v//2 for v in self.weights.shape]
+
+        domain_sizes = [self.domain.nelx, self.domain.nely, self.domain.nelz]
+        el_x, el_y, el_z = np.meshgrid(*[np.arange(max(1, s)) for s in domain_sizes], indexing='ij')
+        self.el3d_orig = self.domain.get_elemnumber(el_x, el_y, el_z)
+
+        padx = self._process_padding(self.el3d_orig, xmin_bc, xmax_bc, 0, self.pad_sizes[0])
+        pady = self._process_padding(padx, ymin_bc, ymax_bc, 1, self.pad_sizes[1])
+        self.el3d_pad = self._process_padding(pady, zmin_bc, zmax_bc, 2, self.pad_sizes[2])
+
+    def _process_padding(self, indices, type_edge0, type_edge1, direction: int, pad_size: int):
+        # First process wrapped padding
+        wrap_size = (0, 0)
+        do_wrap = False
+        if type_edge0 == 'wrap':
+            do_wrap = True
+            wrap_size = (pad_size, wrap_size[1])
+        if type_edge1 == 'wrap':
+            do_wrap = True
+            wrap_size = (wrap_size[0], pad_size)
+
+        if do_wrap:
+            pad_width = [(0, 0) for _ in range(indices.ndim)]
+            pad_width[direction] = wrap_size
+            pad1a = np.pad(indices, pad_width, mode='wrap')
+        else:
+            pad1a = indices
+
+        domain_sizes = [self.domain.nelx, self.domain.nely, self.domain.nelz]
+        padded_sizes = [self.domain.nelx + 2 * self.pad_sizes[0],
+                        self.domain.nely + 2 * self.pad_sizes[1],
+                        self.domain.nelz + 2 * self.pad_sizes[2]]
+
+        # Process edge 1
+        pad_width = [(0, 0) for _ in range(indices.ndim)]
+        pad_width[direction] = (0, pad_size)
+        if type_edge1 == 'edge':
+            pad1b = np.pad(pad1a, pad_width, mode='edge')
+        elif type_edge1 == 'symmetric':
+            pad1b = np.pad(pad1a, pad_width, mode='symmetric')
+        elif isinstance(type_edge1, Number):  # Constant
+            value = type_edge1
+            pad1b = np.pad(pad1a, pad_width, mode='constant', constant_values=0)
+
+            n_range = [np.arange(max(1, s)) for s in padded_sizes]
+            n_range[direction] = pad_size + domain_sizes[direction] + np.arange(pad_size)
+
+            el_nos = np.meshgrid(*n_range, indexing='ij')
+            self.override_padded_values(tuple(el_nos), value)
+        else:
+            pad1b = pad1a
+
+        # Process edge 0
+        pad_width = [(0, 0) for _ in range(indices.ndim)]
+        pad_width[direction] = (pad_size, 0)
+        if type_edge0 == 'edge':
+            pad1 = np.pad(pad1b, pad_width, mode='edge')
+        elif type_edge0 == 'symmetric':
+            pad1 = np.pad(pad1b, pad_width, mode='symmetric')
+        elif isinstance(type_edge0, Number):
+            value = type_edge0
+            pad1 = np.pad(pad1b, pad_width, mode='constant', constant_values=0)
+
+            n_range = [np.arange(max(1, s)) for s in padded_sizes]
+            n_range[direction] = np.arange(pad_size)
+
+            el_nos = np.meshgrid(*n_range, indexing='ij')
+            self.override_padded_values(tuple(el_nos), value)
+        else:
+            pad1 = pad1b
+        return pad1
+
+    @property
+    def padded_domain(self):
+        domain_sizes = [self.domain.nelx, self.domain.nely, self.domain.nelz]
+        nx, ny, nz = [n + 2*p for n, p in zip(domain_sizes, self.pad_sizes)]
+        lx, ly, lz = self.domain.element_size
+        return DomainDefinition(nx, ny, nz, unitx=lx, unity=ly, unitz=lz)
+
+    def override_padded_values(self, index, value):
+        if all([np.asarray(i).size == 0 for i in index]):
+            # Don't add empty sets
+            return
+        self.overrides.append((index, value))
+
+    def override_values(self, index, value):
+        # Change index to extended domain
+        xrange = self.pad_sizes[0] + np.arange(max(1, self.domain.nelx))
+        yrange = self.pad_sizes[1] + np.arange(max(1, self.domain.nely))
+        zrange = self.pad_sizes[2] + np.arange(max(1, self.domain.nelz))
+        el_x, el_y, el_z = np.meshgrid(xrange, yrange, zrange, indexing='ij')
+        self.overrides.append(((el_x[index], el_y[index], el_z[index]), value))
+
+    def get_padded_vector(self, x):
+        xpad = x[self.el3d_pad]
+        for index, value in self.overrides:
+            xpad[index] = value
+        return xpad
+
+    def set_filter_radius(self, radius: float, relative_units: bool = True):
         if relative_units:
             dx, dy, dz = 1.0, 1.0, 1.0
         else:
             dx, dy, dz = self.domain.element_size
-        delemx, delemy, delemz = int((radius-1e-10*dx)/dx), int((radius-1e-10*dy)/dy), int((radius-1e-10*dz)/dz)
-        if self.domain.dim < 3:
-            delemz = 0
+        nx, ny, nz = self.domain.nelx, self.domain.nely, self.domain.nelz
+        delemx = min(nx, int((radius-1e-10*dx)/dx))
+        delemy = min(ny, int((radius-1e-10*dy)/dy))
+        delemz = min(nz, int((radius-1e-10*dz)/dz))
         xrange = np.arange(-delemx, delemx+1)*dx
         yrange = np.arange(-delemy, delemy+1)*dy
         zrange = np.arange(-delemz, delemz+1)*dz
-        coords_x, coords_y, coords_z = np.meshgrid(xrange, yrange, zrange)
+        coords_x, coords_y, coords_z = np.meshgrid(xrange, yrange, zrange, indexing='ij')
         self.weights = np.maximum(0.0, radius - np.sqrt(coords_x*coords_x + coords_y*coords_y + coords_z*coords_z))
         self.weights /= np.sum(self.weights)  # Volume preserving
-        if self.domain.dim < 3:
-            self.weights = self.weights[:, :, 0]
 
     def _response(self, x):
-        domain_sizes = [self.domain.nelx, self.domain.nely]
-        if self.domain.dim >= 3:
-            domain_sizes.append(self.domain.nely)
-        xbox = x.reshape(*domain_sizes, order='F').T  # TODO 3d?
-        return convolve(xbox, self.weights, mode=self.mode).flatten()
+        xpad = self.get_padded_vector(x)
+        y3d = convolve(xpad, self.weights, mode='valid')
+        y = np.zeros_like(x)
+        np.add.at(y, self.el3d_orig, y3d)
+        return y
 
     def _sensitivity(self, dfdv):
-        domain_sizes = [self.domain.nelx, self.domain.nely]
-        if self.domain.dim == 3:
-            domain_sizes.append(self.domain.nely)
-        ybox = dfdv.reshape(*domain_sizes, order='F').T  # TODO 3d
-        return convolve(ybox, self.weights, mode=self.mode).flatten()
+        dx3d = correlate(dfdv[self.el3d_orig], self.weights, mode='full')
+        for index, _ in self.overrides:
+            dx3d[index] = 0
+        dx = np.zeros_like(self.sig_in[0].state)
+        np.add.at(dx, self.el3d_pad, dx3d)
+        return dx
 
 
 class Filter(Module):
@@ -167,6 +312,8 @@ class DensityFilter(Filter):
         nwindy = yupp - ylow + 1
         nwindz = zupp - zlow + 1
         nwind = nwindx * nwindy * nwindz
+        if np.sum(nwind) < 0:
+            raise OverflowError("Filter size too large for this mesh size")
 
         # Total number of window elements
         ncum = np.cumsum(nwind)

pymoto/modules/generic.py

@@ -105,10 +105,21 @@ class MathGeneral(Module):
             if np.isrealobj(dg_dx[i]) and np.iscomplexobj(dg_dx_add):
                 dg_dx_add = np.real(dg_dx_add)
 
-            # Add the contribution
+            # Add the contribution according to broadcasting rules of NumPy
+            # https://numpy.org/doc/stable/user/basics.broadcasting.html
             if (not hasattr(dg_dx[i], '__len__')) or (hasattr(dg_dx[i], 'ndim') and dg_dx[i].ndim == 0):
                 # Scalar type or 0-dimensional array
                 dg_dx[i] += np.sum(dg_dx_add)
+            elif dg_dx[i].shape != dg_dx_add.shape:
+                # Reverse broadcast https://stackoverflow.com/questions/76002989/numpy-is-there-a-reverse-broadcast
+                n_leading_dims = dg_dx_add.ndim - dg_dx[i].ndim
+                broadcasted_dims = tuple(range(n_leading_dims))
+                for ii in range(dg_dx_add.ndim - n_leading_dims):
+                    if dg_dx[i].shape[ii] == 1 and dg_dx_add.shape[ii+n_leading_dims] != 1:
+                        broadcasted_dims = (*broadcasted_dims, n_leading_dims+ii)
+
+                dg_dx_add1 = np.add.reduce(dg_dx_add, axis=broadcasted_dims, keepdims=True)  # Sum broadcasted axis
+                dg_dx[i] += np.squeeze(dg_dx_add1, axis=tuple(range(n_leading_dims)))  # Squeeze out singleton axis
             else:
                 dg_dx[i] += dg_dx_add
 

pymoto/modules/io.py

@@ -14,7 +14,7 @@ from pymoto import Module
 from .assembly import DomainDefinition
 
 
-class _FigModule(Module):
+class FigModule(Module):
     """ Abstract base class for any module which produces a figure
 
     Keyword Args:
@@ -55,7 +55,7 @@ class _FigModule(Module):
         plt.close(self.fig)
 
 
-class PlotDomain(_FigModule):
+class PlotDomain(FigModule):
     """ Plots the densities of a domain (2D or 3D)
 
     Input Signal:
@@ -96,10 +96,16 @@ class PlotDomain(_FigModule):
             self.im.set_data(data)
         else:
             ax = self.fig.add_subplot(111)
-            self.im = ax.imshow(data, origin='lower', cmap=self.cmap)
+            Lx = self.domain.nelx * self.domain.unitx
+            Ly = self.domain.nely * self.domain.unity
+            self.im = ax.imshow(data, cmap=self.cmap, origin='lower', extent=(0.0, Lx, 0.0, Ly))
             self.cbar = self.fig.colorbar(self.im, orientation='horizontal')
             ax.set(xlabel='x', ylabel='y')
-        clim = [np.min(data), np.max(data)] if self.clim is None else self.clim
+        vmin, vmax = np.min(data), np.max(data)
+        if vmin < 0:
+            vabs = max(abs(vmin), abs(vmax))
+            vmin, vmax = -vabs, vabs
+        clim = [vmin, vmax] if self.clim is None else self.clim
         self.im.set_clim(vmin=clim[0], vmax=clim[1])
 
     def _plot_3d(self, x):
@@ -138,7 +144,7 @@ class PlotDomain(_FigModule):
         self.fac = ax.voxels(sel, facecolors=colors, linewidth=0.5, edgecolors='k')
 
 
-class PlotGraph(_FigModule):
+class PlotGraph(FigModule):
     """ Plot an X-Y graph
 
     Input Signals:
@@ -175,14 +181,15 @@ class PlotGraph(_FigModule):
         for i, y in enumerate(ys):
             self.line[i].set_xdata(x)
             self.line[i].set_ydata(y)
-            ymin, ymax = min(ymin, min(y)), max(ymax, max(y))
-        self.ax.set_xlim([min(x), max(x)])
-        self.ax.set_ylim([ymin, ymax])
+            ymin, ymax = min(ymin, np.min(y)), max(ymax, np.max(y))
+        self.ax.set_xlim([np.min(x), np.max(x)])
+        dy = ymax - ymin
+        self.ax.set_ylim([ymin-0.05*dy, ymax+0.05*dy])
 
         self._update_fig()
 
 
-class PlotIter(_FigModule):
+class PlotIter(FigModule):
     """ Plot iteration history of one or more variables
 
     Input Signals:
@@ -193,10 +200,12 @@ class PlotIter(_FigModule):
         overwrite (bool): Overwrite saved image every time the figure is updated, else prefix ``_0000`` is added to the
           filename (default = ``False``)
         show (bool): Show the figure on the screen
+        ylim: Provide y-axis limits for the plot
     """
-    def _prepare(self):
+    def _prepare(self, ylim=None):
         self.minlim = 1e+200
         self.maxlim = -1e+200
+        self.ylim = ylim
 
     def _response(self, *args):
         if not hasattr(self, 'ax'):
@@ -227,7 +236,9 @@ class PlotIter(_FigModule):
         dy = max((self.maxlim - self.minlim)*0.05, sys.float_info.min)
 
         self.ax.set_xlim([-0.5, self.iter+0.5])
-        if np.isfinite(self.minlim) and np.isfinite(self.maxlim):
+        if self.ylim is not None:
+            self.ax.set_ylim(self.ylim)
+        elif np.isfinite(self.minlim) and np.isfinite(self.maxlim):
             self.ax.set_ylim([self.minlim - dy, self.maxlim + dy])
 
         self._update_fig()