easyfea 3.2.2__tar.gz → 3.4.0__tar.gz

{easyfea-3.2.2 → easyfea-3.4.0}/EasyFEA/FEM/Operators/Linear.py

@@ -33,3 +33,20 @@ def V(
     Ne, nPg = vec_e_pg.shape[:2]
     f = FeArray.broadcast(f, Ne, nPg)
     return (f * vec_e_pg).integrate()
+
+
+def InternalForce(
+    groupElem: "_GroupElem",
+    sigma_e_pg: FeArray.FeArrayALike,
+    matrixType: MatrixType = MatrixType.rigi,
+) -> np.ndarray:
+    """``∫_Ω σ : ε(v) dΩ`` — internal force of a known stress field.
+
+    Returns ``(Ne, nPe·dim)``.
+
+    ``sigma_e_pg`` is Kelvin-Mandel with shape ``(Ne, nPg, nstrain)``. This is the residual side
+    of a nonlinear problem: unlike :func:`Bilinear.LinearizedElasticity`, the stress is given
+    rather than derived from ``C : ε(u)``.
+    """
+    leftDispPart_e_pg = groupElem.Get_leftDispPart_e_pg(matrixType)
+    return (leftDispPart_e_pg @ FeArray.asfearray(sigma_e_pg)).integrate()

{easyfea-3.2.2 → easyfea-3.4.0}/EasyFEA/FEM/Operators/NonLinear.py

@@ -438,7 +438,7 @@ def __AdaptiveTimeQuadratureStressTensor(
             ),
             0.0,
         )
-        defect = einsum("epi,epi->ep", S, dE_vec[activeElements]) - dW[activeElements]
+        defect = S @ dE_vec[activeElements] - dW[activeElements]
         next_nPts = 3 if nPts == 1 else 2 * nPts - 1  # next level in the chain
         # accept an element once its own energy defect is within tol (all of them at the last level)
         isAccepted = (next_nPts > max(maxPoints, 1)) | (
@@ -600,9 +600,11 @@ def ActiveStressTensor(
     Returns
     -------
     tuple
-        ``(None, None)`` when ``material.active_stress == 0``. Otherwise ``Kgeo_e`` of shape ``(Ne, nPe·dim, nPe·dim)`` and ``R_e`` of shape ``(Ne, nPe·dim)``, reordered to ``(xi, yi, zi, ..., xn, yn, zn)``.
+        ``(None, None)`` when ``material.active_stress`` is nowhere non-zero. Otherwise ``Kgeo_e`` of shape ``(Ne, nPe·dim, nPe·dim)`` and ``R_e`` of shape ``(Ne, nPe·dim)``, reordered to ``(xi, yi, zi, ..., xn, yn, zn)``.
     """
-    if material.active_stress == 0.0:
+    # `np.all` rather than `== 0.0`: the magnitude may be an (Ne, nPg) field, and a partly-active
+    # body still has to be assembled
+    if np.all(material.active_stress == 0.0):
         return None, None  # type: ignore [return-value]
 
     groupElem = state.groupElem

{easyfea-3.2.2 → easyfea-3.4.0}/EasyFEA/FEM/_field.py

@@ -17,6 +17,9 @@ from ..Utilities import _types
 class Field:
     """Field class."""
 
+    _isFeField = True
+    """marks the class for :mod:`._linalg`, which cannot import it without a cycle"""
+
     def __init__(
         self,
         groupElem: _GroupElem,

{easyfea-3.2.2 → easyfea-3.4.0}/EasyFEA/FEM/_group_elem.py

@@ -211,17 +211,22 @@ class _GroupElem(ABC):
         Remark
         ------
         Ghost nodes will be computed using the given (non-ghost) nodes array.
+
+        The four index arrays are stored **sorted**, whatever order they arrive in: `Mesher` builds them
+        from python sets, so they come in hash order, while `connect` is in global-index order. Every
+        consumer pairs the two through `np.searchsorted`, which requires sorted input and returns
+        out-of-range indices rather than complaining when it does not get it.
         """
 
         Ne = self.__connect.shape[0]
         # set elements (may be smaller than Ne when ghost elements are present)
-        elements = np.asarray(elements, dtype=int)
+        elements = np.sort(np.asarray(elements, dtype=int))
         assert elements.size <= Ne
-        ghostElements = np.asarray(ghostElements, dtype=int)
+        ghostElements = np.sort(np.asarray(ghostElements, dtype=int))
         assert ghostElements.size <= Ne
         # get nodes and ghost nodes
-        nodes = np.asarray(nodes, dtype=int)
-        ghostNodes = np.asarray(list(set(self.nodes) - set(nodes)), dtype=int)
+        nodes = np.sort(np.asarray(nodes, dtype=int))
+        ghostNodes = np.sort(np.asarray(list(set(self.nodes) - set(nodes)), dtype=int))
 
         self.__partitionned_data = (rank, elements, ghostElements, nodes, ghostNodes)
 
@@ -232,6 +237,30 @@ class _GroupElem(ABC):
         (rank, elements, ghostElements, nodes, ghostNodes)"""
         return self.__partitionned_data
 
+    @property
+    def _globalElements(self) -> _types.IntArray:
+        """Global element index of each row of `connect`.
+
+        `arange(Ne)` in serial. Under MPI the rows are this rank's owned and ghost elements, sorted by
+        global index. Use it to index an array stored for the whole mesh (a fibre field, a per-element
+        contractility) with this rank's elements — the element counterpart of `_global_to_local_nodes`.
+
+        Not to be confused with `elements`, which is `arange(Ne)` in both cases because tags, `vol_e`
+        and every other per-element array are indexed by local row.
+
+        Always `Ne` long, so it indexes a whole-mesh array into exactly this group's rows. That holds
+        at the edges too: an empty group gives an empty `int` array rather than a float one, and a rank
+        holding only the boundary layer of a type (no owned element, ghosts only) gives the ghosts —
+        `connect` is built from the same `unique(owned ∪ ghosts)`.
+        """
+        _, elements, ghostElements, _, _ = self.__partitionned_data
+
+        # both arrays are stored sorted, so the merge is the only work left
+        if ghostElements.size == 0:
+            return elements
+
+        return np.unique(np.concatenate([elements, ghostElements]))
+
     @property
     def _rankPartition(self) -> Optional[_types.IntArray]:
         """Array of shape (Ne,) where rankPartition[e] is the MPI rank that owned
@@ -606,7 +635,8 @@ class _GroupElem(ABC):
             coord_e_pg[:, :, 0], coord_e_pg[:, :, 1], coord_e_pg[:, :, 2]
         )
 
-        eval_e_pg = FeArray.asfearray(eval_e_pg)
+        # func may return a constant, so go through the field constructor rather than a view
+        eval_e_pg = FeArray.broadcast(eval_e_pg, *wJ_e_pg.shape[:2])
 
         values_e = (wJ_e_pg * eval_e_pg).integrate()
 
@@ -1577,59 +1607,29 @@ class _GroupElem(ABC):
 
         assert isinstance(line, Line)
 
-        unitVector = line.unitVector
-
-        vect = self.coord - line.coord[0]
-
-        scalarProd = np.einsum("i,ni-> n", unitVector, vect, optimize="optimal")
-        crossProd = np.cross(vect, unitVector)
-        norm = np.linalg.norm(crossProd, axis=1)
-
-        eps = 1e-12
-
-        idx = np.where(
-            (norm < eps) & (scalarProd >= -eps) & (scalarProd <= line.length + eps)
-        )[0]
-
+        idx = np.where(line.Contains(self.coord, 1e-12))[0]
         return self.__nodes[idx].copy()
 
     def Get_Nodes_Domain(self, domain: "Domain") -> _types.IntArray:
         """Returns nodes in the domain."""
 
-        assert isinstance(domain, Line)
-
-        xn, yn, zn = self.coord.T
-
-        eps = 1e-12
-
-        idx = np.where(
-            (xn >= domain.pt1.x - eps)
-            & (xn <= domain.pt2.x + eps)
-            & (yn >= domain.pt1.y - eps)
-            & (yn <= domain.pt2.y + eps)
-            & (zn >= domain.pt1.z - eps)
-            & (zn <= domain.pt2.z + eps)
-        )[0]
+        assert isinstance(domain, Domain)
 
+        idx = np.where(domain.Encloses(self.coord, 1e-12))[0]
         return self.__nodes[idx].copy()
 
     def Get_Nodes_Circle(self, circle: "Circle", onlyOnEdge=False) -> _types.IntArray:
-        """Returns nodes in the circle."""
+        """Returns nodes in the circle.
 
-        assert isinstance(circle, Circle)
-
-        eps = 1e-12
+        Both selections are taken in the circle's own plane; use `Get_Nodes_Cylinder` to select through a thickness.
+        """
 
-        vals = np.linalg.norm(self.coord - circle.center.coord, axis=1)
+        assert isinstance(circle, Circle)
 
-        if onlyOnEdge:
-            idx = np.where(
-                (vals <= circle.diam / 2 + eps) & (vals >= circle.diam / 2 - eps)
-            )
-        else:
-            idx = np.where(vals <= circle.diam / 2 + eps)
+        test = circle.Contains if onlyOnEdge else circle.Encloses
 
-        return self.__nodes[idx]
+        idx = np.where(test(self.coord, 1e-12))[0]
+        return self.__nodes[idx].copy()
 
     def Get_Nodes_Cylinder(
         self, circle: "Circle", direction=[0, 0, 1], onlyOnEdge=False
@@ -1756,7 +1756,7 @@ class _GroupElem(ABC):
             return self.__dict_elements_tags[tag]
         else:
             print(f"The {tag} tag is unknown")
-            return np.array([])
+            return np.array([], dtype=int)
 
     def Get_Nodes_Tag(self, tag: str) -> _types.IntArray:
         """Returns node associated with the tag."""
@@ -1764,7 +1764,7 @@ class _GroupElem(ABC):
             return self.__dict_nodes_tags[tag]
         else:
             print(f"The {tag} tag is unknown")
-            return np.array([])
+            return np.array([], dtype=int)
 
     def Locates_sol_e(
         self, sol: _types.FloatArray, dof_n: Optional[int] = None, asFeArray=False
@@ -2138,11 +2138,14 @@ class _GroupElem(ABC):
                 # xiP are the n coordinates of the n points in (ξ, η, ζ).
                 coordInElem_n[nodesInElement, :] = np.asarray(xiP)  # type: ignore
 
-        detectedNodes = detectedNodes[detectedNodes != None].astype(int)
+        # both arrays are object arrays pre-filled with None, so the comparison is
+        # elementwise; np.not_equal says so without tripping E711
+        mask_n = np.not_equal(detectedNodes, None)
+        detectedNodes = detectedNodes[mask_n].astype(int)
 
-        mask = detectedElements_e != None
-        detectedElements_e = detectedElements_e[mask].astype(int)
-        connect_e_n = connect_e_n[mask]
+        mask_e = np.not_equal(detectedElements_e, None)
+        detectedElements_e = detectedElements_e[mask_e].astype(int)
+        connect_e_n = connect_e_n[mask_e]
 
         return detectedNodes, detectedElements_e, connect_e_n, coordInElem_n
 
@@ -2216,7 +2219,7 @@ class _GroupElem(ABC):
 # --------------------------------------------------------------------------------------------
 
 # import must be done here to avoid circular imports
-from . import Elems
+from . import Elems  # noqa: E402
 
 
 class GroupElemFactory:
@@ -2264,7 +2267,9 @@ class GroupElemFactory:
         """
 
         if gmshId not in GroupElemFactory.DICT_GMSH_DATA:
-            raise KeyError("gmshId is unknown.")
+            raise KeyError(
+                f"gmshId {gmshId} is not supported yet, but it can be added to DICT_GMSH_DATA."
+            )
 
         return GroupElemFactory.DICT_GMSH_DATA[gmshId]
 

{easyfea-3.2.2 → easyfea-3.4.0}/EasyFEA/FEM/_linalg.py

@@ -11,10 +11,81 @@ from typing import Union, Optional, Iterable
 from ..Utilities import _types
 
 
+def _Evaluate(operand):
+    """A Field evaluates to its finite element array; anything else is passed through."""
+    return operand() if getattr(operand, "_isFeField", False) else operand
+
+
+def _Base(operand):
+    """Drops the FeArray view, so numpy's own machinery handles the operand."""
+    if isinstance(operand, FeArray):
+        return operand.view(np.ndarray)
+    elif isinstance(operand, (list, tuple)):
+        return type(operand)(_Base(item) for item in operand)
+    else:
+        return operand
+
+
+def _KeepsFeAxes(axis, ndim: int) -> bool:
+    """True when a reduction consumes tensor axes only, so the (Ne, nPg) axes survive."""
+    if axis is None:
+        return False
+    axes = axis if isinstance(axis, tuple) else (axis,)
+    return all(a >= 2 if a >= 0 else a >= 2 - ndim for a in axes)
+
+
+_REDUCERS = frozenset(
+    {
+        np.sum,
+        np.prod,
+        np.mean,
+        np.std,
+        np.var,
+        np.median,
+        np.average,
+        np.max,
+        np.min,
+        np.amax,
+        np.amin,
+        np.all,
+        np.any,
+        np.argmax,
+        np.argmin,
+    }
+)
+
+
+def _FeShape(operands) -> tuple:
+    """The (Ne, nPg) an operation runs at: the broadcast of its FeArray operands'."""
+    shapes = set()
+    stack = list(operands)
+    while stack:
+        operand = stack.pop()
+        if isinstance(operand, FeArray):
+            shapes.add(operand.shape[:2])
+        elif isinstance(operand, (list, tuple)):
+            stack.extend(operand)
+    if len(shapes) == 1:
+        return shapes.pop()
+    return np.broadcast_shapes(*shapes) if shapes else ()
+
+
 class FeArray(np.ndarray):
     """Finite Element array.\n
 
     FeArray is a Python class designed to optimize finite element simulations by leveraging NumPy arrays with a shape of `(Ne, nPg, ...)`. This structure enables vectorized operations, eliminating the need for slow loops over elements and integration points. By using np.einsum, it efficiently handles tensor computations, significantly improving performance and code clarity for finite element analyses.
+
+    Two rules govern how it mixes with other arrays:
+
+    - **Rank.** A FeArray's tensor rank is ``ndim - 2`` and a plain array's is its own ``ndim``
+      -- always, with no exception and nothing inferred from a shape coincidence. So a
+      ``(Ne, nPg)`` FeArray is a scalar field even where ``Ne`` and ``nPg`` match a tensor's
+      dimensions, and a plain array is a constant tensor held at every Gauss point. Fields are
+      padded to the widest rank, then broadcast once. A plain array that is really a field must
+      say so with :meth:`asfearray`, or it multiplies out as a constant tensor.
+    - **Type.** An operation stays a FeArray exactly when the ``(Ne, nPg)`` axes come out
+      unchanged. ``np.einsum``, ``np.where`` and ``np.linalg.solve`` keep them; ``reshape``,
+      ``ravel`` and a sum over elements do not.
     """
 
     FeArrayALike = Union["FeArray", _types.AnyArray]
@@ -33,110 +104,134 @@ class FeArray(np.ndarray):
         if obj is None:
             return
 
+    def __check_fe_dims(self) -> None:
+        """A FeArray must keep its leading (Ne, nPg) axes.
+
+        ``__new__`` enforces that, but indexing and reshaping do not go through it: ``fe[0]``
+        returns a FeArray of one dimension, whose finite element rank would be -1. Nothing
+        downstream expects that, so it is caught here rather than surfacing later as a
+        confusing shape error.
+        """
+        if self.ndim < 2:
+            raise ValueError(
+                f"this FeArray has shape {self.shape}, which has lost the leading "
+                "(Ne, nPg) axes -- indexing or reshaping dropped them. Use np.asarray(...) "
+                "if plain array semantics are what is wanted here."
+            )
+
     @property
     def _shape(self) -> tuple:
         """finite element shape"""
+        self.__check_fe_dims()
         return self.shape[2:]
 
     @property
     def _ndim(self) -> int:
         """finite element ndim"""
+        self.__check_fe_dims()
         return self.ndim - 2
 
-    @property
-    def _idx(self) -> str:
-        """einsum indicator (e.g "", "i", "ij") used in `np.einsum()` function.\n
-        see https://numpy.org/doc/stable/reference/generated/numpy.einsum.html
-        """
-        if self._ndim == 0:
-            return ""
-        elif self._ndim == 1:
-            return "i"
-        elif self._ndim == 2:
-            return "ij"
-        elif self._ndim == 4:
-            return "ijkl"
-        else:
-            raise ValueError("wrong dimension")
-
-    @property
-    def _type(self) -> str:
-        if self._ndim == 0:
-            return "scalar"
-        elif self._ndim == 1:
-            return "vector"
-        elif self._ndim == 2:
-            return "matrix"
-        elif self._ndim == 4:
-            return "tensor"
-        else:
-            raise ValueError("wrong dimension")
-
-    def __get_array1_array2(self, other) -> tuple[_types.AnyArray, _types.AnyArray]:
-        array1 = np.asarray(self)
-        ndim1 = self._ndim
-        shape1 = self._shape
+    @staticmethod
+    def _align(operands: tuple) -> tuple:
+        """Pads each field's tensor rank up to the widest, so one numpy broadcast is correct.
 
-        array2 = np.asarray(other)
-        if isinstance(other, FeArray):
-            ndim2 = other._ndim
-            shape2 = other._shape
-        elif isinstance(other, (np.ndarray, float, int)):
-            ndim2 = array2.ndim
-            shape2 = array2.shape
-        elif type(other).__name__ == "Field":
-            other: FeArray = other()  # type: ignore [no-redef]
-            array2 = np.asarray(other)
-            ndim2 = other._ndim
-            shape2 = other._shape
+        The finite element axes then line up on the left and the tensor axes on the right,
+        which is numpy's own rule.
+        """
+        # by far the commonest case: all fields of the same shape, nothing to line up
+        shape = operands[0].shape if isinstance(operands[0], FeArray) else None
+        for op in operands:
+            if not isinstance(op, FeArray) or op.shape != shape:
+                break
         else:
-            raise TypeError("other must be a FeArray, ndarray, float, int or a Field.")
+            return operands
 
-        if ndim1 == 0:
-            # array1(Ne, nPg)  array2(...) => (Ne, nPg, ...)
-            # or
-            # array1(Ne, nPg)  array2(Ne, nPg, ...) => (Ne, nPg, ...)
-            array1 = array1[(Ellipsis,) + (np.newaxis,) * ndim2]
-        elif ndim2 == 0:
-            if array2.size == 1:
-                # array1(Ne, nPg, ...)  array2() => (Ne, nPg, ...)
-                pass
-            else:
-                # array1(Ne, nPg, ...)  array2(Ne, nPg) => (Ne, nPg, ...)
-                array2 = array2[(Ellipsis,) + (np.newaxis,) * ndim1]
-        elif shape1 == shape2:
-            pass
-        else:
-            type_str = "FeArray" if isinstance(other, FeArray) else "np.array"
-            raise ValueError(
-                f"The {type_str} `other` with shape {shape2} must be either a {self.shape} np.array or a {shape1} FeArray."
+        operands = tuple(_Evaluate(op) for op in operands)
+        ranks = [
+            op.ndim - 2 if isinstance(op, FeArray) else np.ndim(op) for op in operands
+        ]
+        nt = max(ranks)
+        return tuple(
+            (
+                op[(slice(None), slice(None)) + (None,) * (nt - rank)]
+                if isinstance(op, FeArray) and rank < nt
+                else op
             )
+            for op, rank in zip(operands, ranks)
+        )
 
-        return array1, array2
-
-    def __add__(self, other) -> FeArrayALike:
-        if isinstance(other, FeArray) and self.shape == other.shape:
-            return super().__add__(other)
-        array1, array2 = self.__get_array1_array2(other)
-        return FeArray.asfearray(array1 + array2)
-
-    def __sub__(self, other) -> FeArrayALike:  # type: ignore [override]
-        if isinstance(other, FeArray) and self.shape == other.shape:
-            return super().__sub__(other)
-        array1, array2 = self.__get_array1_array2(other)
-        return FeArray.asfearray(array1 - array2)
+    @staticmethod
+    def __wrap(res, feShape: tuple):
+        """A result is a field exactly when it came out on the operation's (Ne, nPg) axes."""
+        if not isinstance(res, np.ndarray):
+            return res
+        elif res.ndim >= 2 and res.shape[:2] == feShape:
+            return res.view(FeArray)
+        else:
+            return np.asarray(res)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        # numpy asks that a subclass put all its override logic here rather than also defining
+        # __add__ and friends, so that the type hierarchy is decided in one place
+        elementwise = method == "__call__" and ufunc.signature is None
+
+        # two fields of the same shape need no alignment and no rewrapping decision; this is
+        # the overwhelming majority of calls, and it is what keeps small arrays cheap
+        if elementwise and not kwargs and len(inputs) == 2:
+            left, right = inputs
+            if (
+                type(left) is FeArray
+                and type(right) is FeArray
+                and left.shape == right.shape
+            ):
+                return ufunc(left.view(np.ndarray), right.view(np.ndarray)).view(
+                    FeArray
+                )
 
-    def __mul__(self, other) -> FeArrayALike:
-        if isinstance(other, FeArray) and self.shape == other.shape:
-            return super().__mul__(other)
-        array1, array2 = self.__get_array1_array2(other)
-        return FeArray.asfearray(array1 * array2)
+        if elementwise:
+            inputs = FeArray._align(inputs)
+
+        # ndarray refuses to run a ufunc on a subclass that overrides __array_ufunc__, so hand
+        # it plain views -- of the `out` and `where` operands too, or the call comes straight
+        # back here -- and put the type back afterwards
+        out = kwargs.pop("out", None) if kwargs else None
+        if kwargs:
+            kwargs = {key: _Base(value) for key, value in kwargs.items()}
+        if out is not None:
+            kwargs["out"] = _Base(out)
+
+        args = [_Base(array) for array in inputs]
+        res = (
+            ufunc(*args, **kwargs)
+            if elementwise
+            else getattr(ufunc, method)(*args, **kwargs)
+        )
 
-    def __truediv__(self, other) -> FeArrayALike:  # type: ignore [override]
-        if isinstance(other, FeArray) and self.shape == other.shape:
-            return super().__truediv__(other)
-        array1, array2 = self.__get_array1_array2(other)
-        return FeArray.asfearray(array1 / array2)
+        if out is not None:
+            return out[0] if len(out) == 1 else out
+        elif elementwise and type(res) is np.ndarray:
+            # broadcasting against a FeArray always keeps the (Ne, nPg) axes
+            return res.view(FeArray)
+        feShape = _FeShape(inputs)
+        if isinstance(res, tuple):
+            return tuple(FeArray.__wrap(array, feShape) for array in res)
+        return FeArray.__wrap(res, feShape)
+
+    def __array_function__(self, func, types, args, kwargs):
+        # numpy's own implementations broadcast the plain way and must keep doing so: einsum
+        # with optimize= reaches for np.multiply internally, which would otherwise come back
+        # through __array_ufunc__ and be aligned a second time
+        feShape = _FeShape(args) or _FeShape(kwargs.values())
+        # numpy calls a dispatched reduction on the stripped array, so the method wrapper never
+        # sees it and the axis has to be read here instead
+        if func in _REDUCERS:
+            axis = kwargs.get("axis", args[1] if len(args) > 1 else None)
+            if not _KeepsFeAxes(axis, np.ndim(args[0])):
+                feShape = ()
+        args = tuple(_Base(arg) for arg in args)
+        kwargs = {key: _Base(value) for key, value in kwargs.items()}
+        res = super().__array_function__(func, types, args, kwargs)
+        return FeArray.__wrap(res, feShape)
 
     @property
     def T(self) -> FeArrayALike:  # type: ignore [override]
@@ -158,7 +253,7 @@ class FeArray(np.ndarray):
             ndim2 = other._ndim
         elif isinstance(other, np.ndarray):
             ndim2 = other.ndim
-        elif type(other).__name__ == "Field":
+        elif getattr(other, "_isFeField", False):
             other: FeArray = other()  # type: ignore [no-redef]
             ndim2 = other._ndim
         else:
@@ -204,7 +299,7 @@ class FeArray(np.ndarray):
             ndim2 = other._ndim
         elif isinstance(other, np.ndarray):
             ndim2 = other.ndim
-        elif type(other).__name__ == "Field":
+        elif getattr(other, "_isFeField", False):
             other: FeArray = other()  # type: ignore [no-redef]
             ndim2 = other._ndim
         else:
@@ -230,7 +325,7 @@ class FeArray(np.ndarray):
             ndim2 = other._ndim
         elif isinstance(other, np.ndarray):
             ndim2 = other.ndim
-        elif type(other).__name__ == "Field":
+        elif getattr(other, "_isFeField", False):
             other: FeArray = other()  # type: ignore [no-redef]
             ndim2 = other._ndim
         else:
@@ -245,17 +340,23 @@ class FeArray(np.ndarray):
 
         return result.view(FeArray)
 
-    # Reduction methods that consume an axis — always return a plain ndarray,
-    # since the (Ne, nPg) framing is no longer meaningful after the reduction.
+    # A reduction over a tensor axis is still a field; one over elements or Gauss points is
+    # not. Which axes were consumed is read from `axis`, never guessed from the result shape.
     def _make_reducer(_name: str):
         _parent = getattr(np.ndarray, _name)
 
         def _reducer(self, *args, **kwargs):
-            return np.asarray(_parent(self, *args, **kwargs))
+            res = _parent(self, *args, **kwargs)
+            axis = kwargs.get("axis", args[0] if args else None)
+            if _KeepsFeAxes(axis, self.ndim) and getattr(res, "ndim", 0) >= 2:
+                return res.view(FeArray)
+            return np.asarray(res)
 
         _reducer.__name__ = _name
         _reducer.__qualname__ = f"FeArray.{_name}"
-        _reducer.__doc__ = f"``np.{_name}()`` wrapper — returns ``ndarray``."
+        _reducer.__doc__ = (
+            f"``np.{_name}()`` wrapper — ``ndarray`` unless (Ne, nPg) survives."
+        )
         return _reducer
 
     for _name in (
@@ -276,12 +377,10 @@ class FeArray(np.ndarray):
     del _name, _make_reducer
 
     def reshape(self, *args, **kwargs):
-        Ne, nPg = self.shape[:2]
         new = super().reshape(*args, **kwargs)
-        if new.shape[:2] == (Ne, nPg):
+        if self.ndim >= 2 and new.shape[:2] == self.shape[:2]:
             return new
-        else:
-            return np.asarray(new)
+        return np.asarray(new)
 
     def integrate(self) -> np.ndarray:
         """Integrate over the Gauss-point axis (axis 1). Returns ``(Ne, ...)`` ndarray."""
@@ -310,15 +409,19 @@ class FeArray(np.ndarray):
         self[tuple(idx)] = value
 
     @staticmethod
-    def asfearray(array, broadcastFeArrays=False) -> FeArrayALike:
+    def asfearray(array, broadcastFeArrays=False) -> "FeArray":
+        """Views ``array`` as a FeArray. Refuses anything without the (Ne, nPg) axes."""
         if not isinstance(array, np.ndarray):
             array = np.asarray(array)
         if broadcastFeArrays:
             return FeArray(array, broadcastFeArrays=broadcastFeArrays)
-        elif array.ndim >= 2:
-            return array.view(FeArray)
-        else:
-            return array
+        elif array.ndim < 2:
+            raise ValueError(
+                f"cannot view a {array.shape} array as a FeArray: it has no (Ne, nPg) axes. "
+                "Pass broadcastFeArrays=True to hold it at every Gauss point, or keep it a "
+                "plain array."
+            )
+        return array.view(FeArray)
 
     @staticmethod
     def broadcast(
@@ -380,13 +483,20 @@ class FeArray(np.ndarray):
             for array in arrays
         ]
 
+    @staticmethod
+    def __shape(shape: tuple) -> tuple:
+        """Accepts both ``zeros(Ne, nPg, 6)`` and ``zeros((Ne, nPg, 6))``."""
+        if len(shape) == 1 and isinstance(shape[0], (tuple, list)):
+            return tuple(shape[0])
+        return shape
+
     @staticmethod
     def zeros(*shape, dtype=None) -> FeArrayALike:
-        return FeArray.asfearray(np.zeros(shape=shape, dtype=dtype))
+        return FeArray.asfearray(np.zeros(FeArray.__shape(shape), dtype=dtype))
 
     @staticmethod
     def ones(*shape, dtype=None) -> FeArrayALike:
-        return FeArray.asfearray(np.ones(shape=shape, dtype=dtype))
+        return FeArray.asfearray(np.ones(FeArray.__shape(shape), dtype=dtype))
 
 
 def __CheckMat(mat: FeArray.FeArrayALike) -> None: