pyMOTO 1.3.0__py3-none-any.whl → 1.5.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
@@ -305,3 +318,230 @@ class AssemblePoisson(AssembleGeneral):
             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`
+
+    This module is the reverse of :py:class:`pymoto.NodalOperation`.
+
+    Input Signal:
+        - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
+
+    Output Signal:
+        - ``y``: Elemental output data of size ``(..., #elements)`` or ``(#dofs, ..., #elements)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., #dofs_per_element)`` or ``(..., #nodes_per_element)``
+    """
+    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
+        if element_matrix.shape[-1] % domain.elemnodes != 0:
+            raise IndexError(
+                f"Size of last dimension of element operator matrix ({element_matrix.shape[-1]}) is not compatible "
+                f"with mesh. Must be dividable by the number of nodes per element ({domain.elemnodes})."
+            )
+        self.domain = domain
+        self.element_matrix = element_matrix
+        self.dofconn = None
+
+    def _response(self, u):
+        if u.size % self.domain.nnodes != 0:
+            raise IndexError(f"Size of input vector ({u.size}) does not match number of nodes ({self.domain.nnodes})")
+        ndof = u.size // self.domain.nnodes
+
+        if self.element_matrix.shape[-1] != self.domain.elemnodes * ndof:
+            # Initialize only after first call to response(), because the number of dofs may not yet be known
+            em = self.element_matrix.copy()
+            assert em.shape[-1] == self.domain.elemnodes, f"Size of element matrix must match #dofs_per_element ({ndof*self.domain.elemnodes}) or #nodes_per_element ({self.domain.elemnodes})."
+
+            # Element matrix is repeated for each dof
+            self.element_matrix = np.zeros((ndof, *self.element_matrix.shape[:-1], ndof * self.domain.elemnodes))
+            for i in range(ndof):
+                self.element_matrix[i, ..., i::ndof] = em
+
+        if self.dofconn is None:
+            self.dofconn = self.domain.get_dofconnectivity(ndof)
+
+        assert self.element_matrix.shape[-1] == ndof * self.domain.elemnodes
+        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 ``(#dofs_per_node * #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 ``(#dofs_per_node * #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:
+            D *= domain.element_size[2]
+        self.element_matrix = D @ self.element_matrix
+
+
+class ElementAverage(ElementOperation):
+    r""" Determine average value in element of input nodal values
+
+    Input Signal:
+       - ``v``: Nodal vector of size ``(#dofs_per_node * #nodes)``
+
+    Output Signal:
+       - ``v_el``: Elemental vector of size ``(#elements)`` or ``(#dofs, #elements)`` if ``#dofs_per_node>1``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+    """
+    def _prepare(self, domain: DomainDefinition):
+        shapefuns = domain.eval_shape_fun(pos=np.array([0, 0, 0]))
+        super()._prepare(domain, shapefuns)
+
+
+class NodalOperation(Module):
+    r""" Generic module for nodal operations based on elemental information
+
+    :math:`u_e = \mathbf{A} x_e`
+
+    This module is the reverse of :py:class:`pymoto.ElementOperation`.
+
+    Input Signal:
+        - ``x``: Elemental vector of size ``(#elements)``
+
+    Output Signal:
+        - ``u``: nodal output data of size ``(..., #dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        element_matrix: The element operator matrix :math:`\mathbf{A}` of size ``(..., #dofs_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.ndofs = ndof*domain.nnodes
+
+    def _response(self, x):
+        dofs_el = einsum('...k, ...l -> lk', self.element_matrix, x, optimize=True)
+        dofs = np.zeros(self.ndofs)
+        np.add.at(dofs, self.dofconn, dofs_el)
+        return dofs
+
+    def _sensitivity(self, dx):
+        return einsum('...k, lk -> ...l', self.element_matrix, dx[self.dofconn], optimize=True)
+
+
+class ThermoMechanical(NodalOperation):
+    r""" Determine equivalent thermo-mechanical load from design vector and elemental temperature difference
+
+    :math:`f_thermal = \mathbf{A} (x*t_delta)_e`
+
+    Input Signal:
+        - ``x*t_delta``: Elemental vector of size ``(#elements)`` containing elemental densities multiplied by
+                         elemental temperature difference
+
+    Output Signal:
+        - ``f_thermal``: nodal equivalent thermo-mechanical load of size ``(#dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        e_modulus (optional): Young's modulus
+        poisson_ratio (optional): Poisson ratio
+        alpha (optional): Coefficient of thermal expansion
+        plane (optional): Plane 'strain' or 'stress'
+    """
+    def _prepare(self, domain: DomainDefinition, e_modulus: float = 1.0, poisson_ratio: float = 0.3, alpha: float = 1e-6, plane: str = 'strain'):
+        dim = domain.dim
+        D = get_D(e_modulus, poisson_ratio, '3d' if dim == 3 else plane.lower())
+        if dim == 2:
+            Phi = np.array([1, 1, 0])
+            D *= domain.element_size[2]
+        elif dim == 3:
+            Phi = np.array([1, 1, 1, 0, 0, 0])
+
+        # Numerical integration
+        BDPhi = np.zeros(domain.elemnodes * dim)
+        siz = domain.element_size
+        w = np.prod(siz[:domain.dim] / 2)
+        for n in domain.node_numbering:
+            pos = n * (siz / 2) / np.sqrt(3)  # Sampling point
+            dN_dx = domain.eval_shape_fun_der(pos)
+            B = get_B(dN_dx)
+            BDPhi += w * B.T @ D @ Phi  # Add contribution
+
+        super()._prepare(domain, alpha*BDPhi)

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