easyfea 3.2.0__tar.gz → 3.2.2__tar.gz

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

@@ -397,14 +397,13 @@ def __AdaptiveTimeQuadratureStressTensor(
     material: "_HyperElastic",
     state_n: "HyperElasticState",
     state_np1: "HyperElasticState",
+    coefK: float,
     tol: float,
     maxPoints: int,
 ) -> tuple["FeArray", "FeArray", int]:
     r"""Per-element adaptive strain-path quadrature — the ``tol``-driven path of :func:`TimeQuadratureStressTensor`.
 
-    Each element refines along the nested chain ``1, 3, 5, 9, …`` until *its own* energy defect is within ``tol``, then freezes — so a low-strain element stops at one point while a high-strain one keeps refining. The test is the **integrated** relative error over the element, ``∫_Ωe (S:Δe − ΔW)² dΩ ≤ tol² ∫_Ωe ΔW² dΩ``. It is evaluated as the Gauss-point sums ``Σ_p V_(ep)(S:Δe − ΔW)² ≤ tol² Σ_p V_(ep) ΔW²`` with ``V_(ep)`` the Gauss point's volume (weight × Jacobian) — so the ``V_(ep)`` factor is what makes each side a genuine *integral over the element*, **not** a pointwise energy-density comparison. Energy-safe because ``S:Δe = ΔW`` holds per Gauss point; the squared, volume-weighted form is safe against sign cancellation between Gauss points, and per element the well-resolved regions cannot mask a coarse one.
-
-    Only the still-active elements are evaluated at each level — the rule is applied to that subset via :meth:`_StrainPathState._sliced` — so the constitutive cost tracks the hard elements, not the mesh. (Nodes shared with a coarser level are re-evaluated rather than cached; the active set shrinks fast, so that stays cheap and keeps the loop plain.) Returns ``(dWde_quad, d2Wde_quad)`` — each row carrying its element's accepted rule — and the largest point count any element reached.
+    Each element refines along the nested chain ``1, 3, 5, 9, …`` (capped at ``maxPoints``) until *its own* integrated energy defect is within ``tol`` — ``Σ_p V_(ep) |S:Δe − ΔW| ≤ tol · Σ_p V_(ep) |ΔW|``, ``V_(ep)`` the Gauss-point volume — then freezes, so points are spent only where the step is nonlinear. The defect is the quadrature error of the exact identity ``S:Δe = ΔW`` (``ΔW`` known from the endpoints), so the test is absolute; taking ``|·|`` before summing bounds the element's real energy drift and is safe against Gauss-point sign cancellation. Only still-active elements are evaluated at each level (via :meth:`_StrainPathState._sliced`), so cost tracks the hard elements. Returns ``(dWde_quad, d2Wde_quad, nPts_e)``, each row carrying its element's accepted rule and point count.
     """
     groupElem = state_n.groupElem  # state_n and state_np1 share the group
     dim = groupElem.dim
@@ -417,7 +416,7 @@ def __AdaptiveTimeQuadratureStressTensor(
     dW = material.Compute_W(state_np1) - material.Compute_W(state_n)  # ΔW per point
     dE = state_np1.Compute_GreenLagrange() - state_n.Compute_GreenLagrange()
     dE_vec = Project_matrix_to_vector(dE[..., :dim, :dim])  # Δe (Kelvin-Mandel)
-    refW = einsum("ep,ep,ep->e", wJ_e_pg, dW, dW)  # Σ_p V ΔW²  (Ne,)
+    refW = einsum("ep,ep->e", wJ_e_pg, np.abs(dW))  #  Σ_p V |ΔW| (Ne,)
     Ne, nPg, ncomp = *wJ_e_pg.shape[:2], dE_vec.shape[-1]
 
     def at(
@@ -428,7 +427,8 @@ def __AdaptiveTimeQuadratureStressTensor(
     dWde_quad = FeArray.zeros(Ne, nPg, ncomp)
     d2Wde_quad = FeArray.zeros(Ne, nPg, ncomp, ncomp)
     activeElements = np.arange(Ne)  # elements still refining
-    nPts, nPts_used = 1, 1
+    nPts_e = np.zeros(Ne, dtype=int)  # accepted point count per element (diagnostic)
+    nPts = 1
     while activeElements.size:
         nodes, weights = __clenshaw_curtis(nPts)
         S = sum(
@@ -441,72 +441,72 @@ def __AdaptiveTimeQuadratureStressTensor(
         defect = einsum("epi,epi->ep", 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)
-        done = (next_nPts > max(maxPoints, 1)) | (
-            einsum("ep,ep,ep->e", wJ_e_pg[activeElements], defect, defect)
-            <= tol * tol * (refW[activeElements] + 1e-300)
+        isAccepted = (next_nPts > max(maxPoints, 1)) | (
+            einsum("ep,ep->e", wJ_e_pg[activeElements], np.abs(defect))
+            <= tol * refW[activeElements]
         )
-        if done.any():
-            e = activeElements[done]  # elements accepting this rule
-            dWde_quad[e] = S[done]
-            # their tangent only: Σ_k 2 w_k s_k d2Wde, s=0 drops out (∂e/∂u = s B)
-            d2Wde_quad[e] = sum(
+        if isAccepted.any():
+            acceptedElems = activeElements[isAccepted]  # elements accepting this rule
+            dWde_quad[acceptedElems] = S[isAccepted]
+            # their tangent only: Σ_k (w_k s_k / coefK) d2Wde, s=0 drops out (∂e/∂u = s B)
+            d2Wde_quad[acceptedElems] = sum(
                 (
-                    (2.0 * w * s) * material.Compute_d2Wde(at(s, e))
+                    (w * s / coefK) * material.Compute_d2Wde(at(s, acceptedElems))
                     for s, w in zip(nodes, weights)
                     if s
                 ),
                 0.0,
             )
-            nPts_used = max(nPts_used, nPts)
-            activeElements = activeElements[~done]
+            nPts_e[acceptedElems] = nPts  # record each frozen element's accepted rule
+            activeElements = activeElements[~isAccepted]
         nPts = next_nPts
 
-    return dWde_quad, d2Wde_quad, nPts_used
+    return dWde_quad, d2Wde_quad, nPts_e
 
 
 def TimeQuadratureStressTensor(
     material: "_HyperElastic",
     state_n: "HyperElasticState",
-    state_mid: "HyperElasticState",
+    state_t: "HyperElasticState",
     state_np1: "HyperElasticState",
+    coefK: float,
     nPoints: int,
     tol: Optional[float] = None,
     maxPoints: int = 33,
 ) -> tuple[np.ndarray, np.ndarray, int]:
     r"""Tangent and residual for the PK2 stress **averaged along the strain path** of the step.
 
-    Returns ``(K_e, R_e)`` in ``(xi,yi,zi,...,xn,yn,zn)``. Where :func:`SecondPiolaKirchhoffStressTensor` samples the stress at one configuration, this integrates it along the straight segment joining the two end strains and contracts the result with the **midpoint** operator::
+    Returns ``(K_e, R_e)`` in ``(xi,yi,zi,...,xn,yn,zn)``. Where :func:`SecondPiolaKirchhoffStressTensor` samples the stress at one configuration, this averages it along the segment between the two end strains and tests it against ``B(u_t)``::
 
         e(s) = e_n + s Δe ,   Δe = e_{n+1} - e_n ,   s ∈ [0, 1]
-
         S_quad = ∫₀¹ ∂W/∂e(e(s)) ds  ≈  Σ_k w_k ∂W/∂e(e(s_k))
-        R_e    = ∫ B(ū)ᵀ · S_quad dΩ
-
-    ``(s_k, w_k)`` is the Clenshaw-Curtis rule on ``nPoints`` points (:func:`__clenshaw_curtis`); ``1, 2, 3`` are the midpoint, trapezoid and Simpson rules. Intermediate nodes are :class:`_StrainPathState`; ``s = 0, 1`` reuse the end states.
+        R_e    = ∫ B(u_t)ᵀ · S_quad dΩ
 
-    **Adaptive (per-element) mode.** With ``tol`` set, the rule is chosen *element by element* by :func:`__AdaptiveTimeQuadratureStressTensor`: each element walks the nested chain ``1, 3, 5, 9, 17, 33`` (up to ``maxPoints``) and freezes once *its own* energy defect is within ``tol``, so points are spent only where the step is nonlinear — a low-strain element may stop at a single midpoint while a stiff one keeps refining. The defect ``S_quad:Δe − ΔW`` is the quadrature error of the discrete-gradient identity ``S_quad:Δe = ΔW`` (with ``ΔW`` *known* from the endpoints), so the test is absolute — no consecutive-difference guess. It is the **integrated** relative error over the element, ``∫_Ωe (S_quad:Δe − ΔW)² dΩ ≤ tol² ∫_Ωe ΔW² dΩ`` — the integrals are the volume-weighted Gauss-point sums ``Σ_p V_(ep)···``, *not* a pointwise energy-density comparison — so ``tol`` reads as "conserve energy to this relative tolerance". Squaring guards against sign cancellation between Gauss points, and being absolute the test accepts the coarsest rule directly: the ``1``-point midpoint is exact for a linear energy integrand, so a quadratic ``W`` converges at a single point. The tangent uses each element's accepted rule, so residual and tangent stay consistent.
+    ``(s_k, w_k)`` is the Clenshaw-Curtis rule on ``nPoints`` points; ``1, 2, 3`` are the midpoint, trapezoid and Simpson rules (``nPoints = 1`` is the *average-strain* stress, not the midpoint-displacement one). At midpoint ``Δe = B(ū)·Δu`` exactly, so ``S_quad:Δe = ΔW`` once the ``s``-integral is exact — a **discrete gradient** whose energy defect is just the quadrature error, driven down spectrally (a quadratic ``W`` is exact at every rule). With ``tol`` set the rule is refined *per element* by :func:`__AdaptiveTimeQuadratureStressTensor`.
 
-    Since ``Δe = B(ū)·Δu`` exactly and ``de/ds = Δe`` is constant along the segment, the fundamental theorem of calculus gives ``S_quad:Δe = ΔW`` once the ``s``-integral is exact — a **discrete gradient**. The energy defect is therefore just the quadrature error, which Clenshaw-Curtis drives down spectrally; a quadratic ``W`` is exact at every rule. Note ``nPoints = 1`` is the average-strain stress ``S(½(e_n + e_{n+1}))``, *not* the midpoint-displacement stress of :func:`SecondPiolaKirchhoffStressTensor`.
+    Tangent — only ``e_{n+1}`` depends on ``u_{n+1}`` (``∂e(s_k)/∂u_{n+1} = s_k B_{n+1}``), so::
 
-    Tangent — only ``e_{n+1}`` depends on ``u_{n+1}``, and ``∂e(s_k)/∂u_{n+1} = s_k B_{n+1}``, so every node contracts with the same ``B_{n+1}`` and the constitutive tensors collapse into one weighted sum::
+        coefK · K_e = coefK · A_geo(state_t, S_quad)  +  ∫ B(u_t)ᵀ [ Σ_k w_k s_k ℂ(e(s_k)) ] B_{n+1} dΩ
 
-        coefK · K_e = ½ A_geo(state_mid, S_quad)                    # raw
-                    + ∫ B(ū)ᵀ [ Σ_k w_k s_k ℂ(e(s_k)) ] B_{n+1} dΩ  # pre-doubled
-
-    Built for :attr:`~EasyFEA.AlgoType.midpoint`'s ``coefK = 0.5`` as in :func:`GonzalezStressTensor`; the doubled weights sum to 1 whatever ``nPoints``. Pairing ``B(ū)`` with ``B_{n+1}`` makes ``K_e`` non-symmetric.
+    The geometric block is raw so it rides the caller's ``coefK`` chain factor ``∂u_t/∂u_{n+1}``; the material term is pre-scaled by ``1/coefK`` to survive it. Pairing ``B(u_t)`` with ``B_{n+1}`` makes ``K_e`` non-symmetric.
 
     Parameters
     ----------
     material
         Hyperelastic constitutive law — supplies ``Compute_dWde(state)`` and ``Compute_d2Wde(state)``.
-    state_n, state_mid, state_np1
-        Hyperelastic states at ``u_n``, ``ū`` and ``u_{n+1}`` (same group / matrix type).
+    state_n, state_t, state_np1
+        Hyperelastic states at ``u_n``, the time-scheme base displacement ``u_t``, and ``u_{n+1}`` (same group / matrix type).
+    coefK
+        Time-scheme K-coefficient ``= ∂u_t/∂u_{n+1}`` for the base displacement ``u_t`` passed as
+        ``state_t`` — ``0.5`` for :attr:`~EasyFEA.AlgoType.midpoint` (the only value that conserves energy),
+        ``1`` for :attr:`~EasyFEA.AlgoType.newmark`, ``1−α`` for :attr:`~EasyFEA.AlgoType.hht`. Other schemes
+        give a consistent but non-conserving stress.
     nPoints
         Number of Clenshaw-Curtis points for the fixed rule (``tol is None``). Ignored when
         adaptive, which always starts from 1 (the midpoint).
     tol
         If set, refine adaptively (see above) until the relative energy defect
-        ``‖S_quad:Δe − ΔW‖ / ‖ΔW‖`` falls below ``tol``. ``None`` (default) keeps the fixed
+        ``|S_quad:Δe − ΔW| / |ΔW|`` falls below ``tol``. ``None`` (default) keeps the fixed
         ``nPoints`` rule.
     maxPoints
         Adaptive only: cap on the number of points, by default 33. Refinement stops here even
@@ -515,20 +515,20 @@ def TimeQuadratureStressTensor(
     Returns
     -------
     K_e : ndarray of shape ``(Ne, nPe·dim, nPe·dim)``
-        Consistent tangent, built for ``coefK = 0.5``.
+        Consistent tangent, built so ``coefK · K_e = ∂R_e/∂u_{n+1}``.
     R_e : ndarray of shape ``(Ne, nPe·dim)``
         Internal residual force.
-    nPts : int
-        Clenshaw-Curtis points used — ``nPoints`` when fixed; when adaptive, the *largest* level
-        any element reached (individual elements may use fewer). Lets the caller log the cost.
+    nPts_e : ndarray of shape ``(Ne,)``
+        Clenshaw-Curtis points each element used — constant ``nPoints`` when fixed, per-element
+        when adaptive.
     """
 
-    groupElem = state_mid.groupElem
-    wJ_e_pg = groupElem.Get_weightedJacobian_e_pg(state_mid.matrixType)
+    groupElem = state_t.groupElem
+    wJ_e_pg = groupElem.Get_weightedJacobian_e_pg(state_t.matrixType)
     nPe = groupElem.nPe
     dim = groupElem.dim
 
-    _, B_mid = __block_grad_B(state_mid)
+    _, B_t = __block_grad_B(state_t)
     _, B_np1 = __block_grad_B(state_np1)
 
     if tol is None:
@@ -546,8 +546,8 @@ def TimeQuadratureStressTensor(
                 state = _StrainPathState(state_n, state_np1, s)
             dWde_quad += w * material.Compute_dWde(state)
             if s != 0.0:
-                d2Wde_quad += (2.0 * w * s) * material.Compute_d2Wde(state)
-        nPts_used = int(nPoints)
+                d2Wde_quad += (w * s / coefK) * material.Compute_d2Wde(state)
+        nPts_e = np.full(groupElem.Ne, int(nPoints))  # every element uses the same rule
     else:
         # Adaptive: refine per element on the *energy defect*. This stress exists so that
         # S_quad : Δe = ΔW exactly (a discrete gradient, for energy conservation); the only error
@@ -555,16 +555,16 @@ def TimeQuadratureStressTensor(
         # is *known* from the endpoints — so the test is absolute (each level scored on its own).
         # Refining element-by-element rather than the whole block spends points only where the
         # material is nonlinear over the step (see __AdaptiveTimeQuadratureStressTensor).
-        dWde_quad, d2Wde_quad, nPts_used = __AdaptiveTimeQuadratureStressTensor(
-            material, state_n, state_np1, tol, int(maxPoints)
+        dWde_quad, d2Wde_quad, nPts_e = __AdaptiveTimeQuadratureStressTensor(
+            material, state_n, state_np1, coefK, tol, int(maxPoints)
         )
 
     # not __second_piola_block: that pairs one B with itself, while here the tangent is
-    # differentiated at u_{n+1} but tested against B(ū) — hence the non-symmetry.
-    residual_e = einsum("ep,epi,epij->ej", wJ_e_pg, dWde_quad, B_mid)
+    # differentiated at u_{n+1} but tested against B(u_t) — hence the non-symmetry.
+    residual_e = einsum("ep,epi,epij->ej", wJ_e_pg, dWde_quad, B_t)
     tangent_e = einsum(
-        "ep,epji,epjk,epkl->eil", wJ_e_pg, B_mid, d2Wde_quad, B_np1
-    ) + __geometric_tangent(wJ_e_pg, state_mid, dWde_quad)
+        "ep,epji,epjk,epkl->eil", wJ_e_pg, B_t, d2Wde_quad, B_np1
+    ) + __geometric_tangent(wJ_e_pg, state_t, dWde_quad)
 
     if dim == 2:
         thickness = material.thickness
@@ -572,7 +572,7 @@ def TimeQuadratureStressTensor(
         residual_e *= thickness
 
     K_e, R_e = __reorder_dofs(dim, nPe, tangent_e, residual_e)
-    return K_e, R_e, nPts_used
+    return K_e, R_e, nPts_e
 
 
 def ActiveStressTensor(
@@ -628,17 +628,20 @@ def KelvinVoigtDamping(
     material: "_HyperElastic",
     state: "HyperElasticState",
     velocity: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray]:
-    r"""Kelvin–Voigt viscous element contributions (C_e, Kgeo_e) for the
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    r"""Kelvin–Voigt viscous element contributions (Kgeo_e, R_e, C_e) for the
     large-strain viscous force F_visco(u) = C(u)·v, with Σ_visco = η·Ė
     (Green-Lagrange strain rate of velocity) and B = De(u)·grad.
 
-    - C_e = thickness · η · ∫ Bᵀ B dΩ — the damping matrix; the simulation puts
-      it in slot 2 of (K, C, M, F) (residual b -= C @ v_t, time-scheme history,
-      and the coefC·C tangent).
+    Ordered ``(tangent, residual, extra)`` like the rest of this module.
+
     - Kgeo_e — the configuration tangent ∂(C·v)/∂u at fixed velocity (geometric
       stiffening from Σ_visco plus the ∂Ė/∂u term); the simulation adds it to
       K_e so it rides coefK.
+    - R_e = thickness · η · ∫ Bᵀ Ė dΩ — the viscous residual, which the simulation
+      subtracts from F_e.
+    - C_e = thickness · η · ∫ Bᵀ B dΩ — the damping matrix; the simulation puts it
+      in slot 2 of (K, C, M, F), where it rides the coefC·C tangent.
 
     Parameters
     ----------
@@ -653,11 +656,12 @@ def KelvinVoigtDamping(
     Returns
     -------
     tuple
-        (None, None) when material.eta == 0 or velocity is None. Both matrices
-        are (Ne, nPe·dim, nPe·dim) reordered to (xi, yi, zi, ..., xn, yn, zn).
+        (None, None, None) when material.eta == 0 or velocity is None. Kgeo_e and C_e
+        are (Ne, nPe·dim, nPe·dim) and R_e is (Ne, nPe·dim), all reordered to
+        (xi, yi, zi, ..., xn, yn, zn).
     """
     if material.eta == 0.0 or velocity is None:
-        return None, None  # type: ignore [return-value]
+        return None, None, None  # type: ignore [return-value]
 
     groupElem = state.groupElem
     matrixType = state.matrixType
@@ -668,22 +672,22 @@ def KelvinVoigtDamping(
 
     grad_e_pg, B_e_pg = __block_grad_B(state)
     Beta_e_pg = state.Compute_Deta(velocity) @ grad_e_pg
+    sig_e_pg = material.eta * state.Compute_Edot_vec(velocity)  # Σ_visco = η·Ė
 
     # damping matrix C = thickness · η · ∫ Bᵀ B (fused einsum, see SPK above)
     subscripts = "ep,epji,epjl->eil"
     C_e = thickness * material.eta * einsum(subscripts, wJ_e_pg, B_e_pg, B_e_pg)
 
+    # viscous residual ∫ Bᵀ Σ_visco — same contraction as the active stress
+    residual_e = thickness * einsum("ep,epji,epj->ei", wJ_e_pg, B_e_pg, sig_e_pg)
+
     # configuration tangent ∂(C·v)/∂u = geometric (∫ gradᵀ Sig grad) + material-like
     # (η ∫ Bᵀ (∂Ė/∂u)) pieces
     A_mat = material.eta * einsum(subscripts, wJ_e_pg, B_e_pg, Beta_e_pg)
-    A_geo = __geometric_tangent(
-        wJ_e_pg,
-        state,
-        material.eta * state.Compute_Edot_vec(velocity),
-    )
+    A_geo = __geometric_tangent(wJ_e_pg, state, sig_e_pg)
     Kgeo_e = thickness * (A_mat + A_geo)
 
-    return __reorder_dofs(dim, nPe, C_e, Kgeo_e)
+    return __reorder_dofs(dim, nPe, Kgeo_e, residual_e, C_e)
 
 
 def __skew(v: np.ndarray) -> np.ndarray:

{easyfea-3.2.0 → easyfea-3.2.2}/EasyFEA/Simulations/_hyperelastic.py

@@ -15,6 +15,7 @@ from ..Utilities import Terminal, _types
 if TYPE_CHECKING:
     from ..FEM import Mesh
 from ..FEM import MatrixType, Operators
+from ..Utilities._cache import cache_computed_values
 
 # models
 from ..Models import ModelType, Project_Kelvin, Result_strain_or_stress_field_e
@@ -169,7 +170,7 @@ class HyperElastic(_Simu):
         stressType: "HyperElastic.StressType" = StressType.pointwise,
         nPoints: int = 3,
         useConsistentTangent: bool = True,
-        quadTol: Optional[float] = None,
+        energyTol: Optional[float] = None,
     ) -> None:
         r"""Selects the stress used by the internal force. Call **after** :py:meth:`~EasyFEA.Simulations._Simu.Solver_Set_Hyperbolic_Algorithm`.
 
@@ -180,9 +181,11 @@ class HyperElastic(_Simu):
         total energy :math:`\mathrm{KE} + W` is conserved. See :class:`StressType` for the three
         options and the operators for their construction.
 
-        Both non-default stresses are built on the midpoint base point :math:`\bar{\ub}` — the
-        identity :math:`\Delta \eb = \Brm(\bar{\ub}) \cdot \Delta \ub` is what makes their energy
-        proofs work — so they require :attr:`~EasyFEA.AlgoType.midpoint`.
+        Energy conservation for both non-default stresses rests on the midpoint identity
+        :math:`\Delta \eb = \Brm(\bar{\ub}) \cdot \Delta \ub`, so it holds only under
+        :attr:`~EasyFEA.AlgoType.midpoint`. ``gonzalez`` is intrinsically a midpoint discrete gradient and is
+        rejected off midpoint. ``quadrature`` also runs under any dynamic scheme — it scales its tangent by
+        that scheme's ``coefK`` and stays Newton-consistent, but conserves energy only at midpoint.
 
         Parameters
         ----------
@@ -192,37 +195,41 @@ class HyperElastic(_Simu):
         nPoints : int, optional
             ``quadrature`` only: number of Clenshaw-Curtis points, by default 3 (Simpson).
             ``1`` and ``2`` are the midpoint and trapezoid rules; more converges spectrally.
-            When ``quadTol`` is set this is the starting (minimum) level instead of a fixed count.
+            When ``energyTol`` is set this is the starting (minimum) level instead of a fixed count.
         useConsistentTangent : bool, optional
             ``gonzalez`` only: if False, drop the discrete-gradient corrections from the
             tangent. Same residual and same exact conservation, but Newton converges linearly
             — a diagnostic, to measure what the consistent tangent is worth.
-        quadTol : float, optional
+        energyTol : float, optional
             ``quadrature`` only: if set, the rule is refined adaptively *element by element*
             along the nested Clenshaw-Curtis chain ``1, 3, 5, 9, ...`` (capped at 33) — each
             element stops once its own **integrated** relative energy defect
-            ``∫(S_quad:Δe − ΔW)² dΩ ≤ quadTol² ∫ΔW² dΩ`` over that element is met (a volume
+            ``∫|S_quad:Δe − ΔW| dΩ ≤ energyTol · ∫|ΔW| dΩ`` over that element is met (a volume
             integral over its Gauss points, not a pointwise density). So energy is conserved to
-            ``quadTol`` while points are spent only where the step is nonlinear. ``None``
+            ``energyTol`` while points are spent only where the step is nonlinear. ``None``
             (default) keeps the fixed ``nPoints`` rule.
         """
         stressType = HyperElastic.StressType(stressType)
 
-        if stressType != HyperElastic.StressType.pointwise:
-            algo = self.algo
-            assert algo == AlgoType.midpoint, (
-                f"the '{stressType}' stress requires AlgoType.midpoint (got {algo}); it is built "
-                "on the midpoint base point ū. Call Solver_Set_Hyperbolic_Algorithm(dt, algo=AlgoType.midpoint) first."
+        if stressType == HyperElastic.StressType.gonzalez:
+            # gonzalez is the midpoint energy-momentum stress: its discrete gradient is built on ū and
+            # conserves energy only there — intrinsically midpoint-only.
+            assert self.algo == AlgoType.midpoint, (
+                f"the 'gonzalez' stress requires AlgoType.midpoint (got {self.algo}). "
+                "Call Solver_Set_Hyperbolic_Algorithm(dt, algo=AlgoType.midpoint) first."
             )
+        # quadrature works with any dynamic scheme (its tangent is scaled by coefK); the dynamic-scheme
+        # requirement is checked at assembly, so the algo need not be set before this call.
         assert nPoints >= 1, f"nPoints must be >= 1 (got {nPoints})."
 
-        self.__stressParams = (stressType, nPoints, useConsistentTangent, quadTol)
-        self.__quadNPoints = 0  # diagnostic: points the last assembly used
+        self.__stressParams = (stressType, nPoints, useConsistentTangent, energyTol)
+        # diagnostic: per-element quadrature-point counts, last assembly
+        self.__nPts_e = None
 
     def __Solver_Get_Stress_Params(
         self,
     ) -> tuple["HyperElastic.StressType", int, bool, Optional[float]]:
-        """Returns (stressType, nPoints, useConsistentTangent, quadTol) internal-force props."""
+        """Returns (stressType, nPoints, useConsistentTangent, energyTol) internal-force props."""
         return self.__stressParams
 
     @property
@@ -230,6 +237,11 @@ class HyperElastic(_Simu):
         """Stress used by the internal force — see :py:meth:`Solver_Set_Stress`."""
         return self.__Solver_Get_Stress_Params()[0]
 
+    @cache_computed_values
+    def __Mass_e(self, groupElem, rho, thickness, dim):
+        """Constant element mass matrix ``thickness · ∫ρ N·N``."""
+        return thickness * Operators.Bilinear.UV(groupElem, rho, dof_n=dim)
+
     def Construct_local_matrix_system(
         self,
         problemType,
@@ -237,31 +249,39 @@ class HyperElastic(_Simu):
     ):
         """Returns ``{groupElem: (K_e, C_e, M_e, F_e)}`` for the current Newton iterate.
 
-        Newton solves ``A(u)·Δu = -R(u)``; the simulation assembles ``A = coefK·K + coefC·C + coefM·M`` and ``b -= C @ v_t``. Per group of elements: ``K_e`` is the elastic tangent (plus the viscous configuration tangent ``Kgeo_e``), ``F_e = -R_e`` the residual, ``C_e`` the Kelvin–Voigt damping matrix and ``M_e`` the mass matrix (dynamic schemes only).
+        Newton solves ``A(u)·Δu = -R(u)`` with ``A = coefK·K + coefC·C + coefM·M``. Per group of elements: ``K_e`` is the elastic tangent (plus the viscous configuration tangent ``Kgeo_e``), ``C_e`` the Kelvin–Voigt damping matrix, ``M_e`` the mass matrix (dynamic schemes only) and ``F_e = -R_e`` the complete residual — internal force together with the ``C_e·v_t + M_e·a_t`` inertia and damping terms.
         """
         dim = self.dim
         thickness = self.material.thickness if dim == 2 else 1
         isDynamic = self.algo in AlgoType.Get_Hyperbolic_Types()
 
-        # current Newton-Raphson iterate; for dynamic schemes also capture the
-        # velocity, for Kelvin–Voigt viscosity.
+        # current Newton-Raphson iterate; for dynamic schemes also capture the velocity
+        # (Kelvin–Voigt viscosity) and the acceleration (inertia), both needed by F_e.
         displacement = self._Solver_Get_Newton_Raphson_current_solution()
-        velocity = None
-        # Both non-default stresses are built from the step endpoints (u_n, u_{n+1}) on top
-        # of the midpoint base point, so both need u_{n+1} kept before the midpoint
-        # evaluation overwrites `displacement` with ū. Re-checked here (not only in the
-        # setter) so that re-calling Solver_Set_Hyperbolic_Algorithm with another algo
-        # can't leave a stale selection.
-        stressType, nPoints, useConsistentTangent, quadTol = (
+        velocity = accel = None
+        # Both non-default stresses are built from the step endpoints (u_n, u_{n+1}) on top of the scheme's
+        # base point u_t (ū at midpoint), so both need u_{n+1} kept before the scheme evaluation overwrites
+        # `displacement` with u_t. Re-checked here (not only in the setter) so that re-calling
+        # Solver_Set_Hyperbolic_Algorithm with another algo can't leave a stale selection.
+        stressType, nPoints, useConsistentTangent, energyTol = (
             self.__Solver_Get_Stress_Params()
         )
         isPointwise = stressType == HyperElastic.StressType.pointwise
-        assert (
-            isPointwise or self.algo == AlgoType.midpoint
-        ), f"the '{stressType}' stress requires AlgoType.midpoint (got {self.algo})."
+        if stressType == HyperElastic.StressType.gonzalez:
+            # gonzalez is the midpoint energy-momentum stress: its discrete gradient Ŝ = S̄ + α Δe is built
+            # on ū and conserves energy only there — it is intrinsically midpoint-only.
+            assert (
+                self.algo == AlgoType.midpoint
+            ), f"the 'gonzalez' stress requires AlgoType.midpoint (got {self.algo})."
+        elif stressType == HyperElastic.StressType.quadrature:
+            # quadrature builds a consistent tangent for any dynamic scheme via its `coefK = ∂u_t/∂u_{n+1}`;
+            # energy is conserved only at midpoint (coefK = 0.5) — see TimeQuadratureStressTensor.
+            assert (
+                isDynamic
+            ), f"the 'quadrature' stress requires a dynamic (hyperbolic) time scheme (got {self.algo})."
         u_np1 = displacement
         if isDynamic:
-            displacement, velocity, _ = self._Solver_Evaluate_u_v_a_for_time_scheme(
+            displacement, velocity, accel = self._Solver_Evaluate_u_v_a_for_time_scheme(
                 problemType, displacement
             )
         if not isPointwise:
@@ -270,7 +290,7 @@ class HyperElastic(_Simu):
         errDetF = "det(F) < 0 - reduce load steps"
 
         out = {}
-        quadNPoints = 0  # max Clenshaw-Curtis points over groups this Newton iteration
+        list_nPts_e = []  # per-element point counts across groups (quadrature only)
         for groupElem in self.mesh.Get_list_groupElem():
             state = HyperElasticState(groupElem, displacement, matrixType)
 
@@ -298,15 +318,18 @@ class HyperElastic(_Simu):
                         useConsistentTangent,
                     )
                 elif stressType == HyperElastic.StressType.quadrature:
-                    K_e, residual_e, nPts = (
+                    # coefK = ∂u_t/∂u_{n+1} scales the tangent for the active scheme (0.5 at midpoint).
+                    coefK = self._Solver_Get_K_C_M_coefs_for_time_scheme()[0]
+                    K_e, residual_e, nPts_e = (
                         Operators.NonLinear.TimeQuadratureStressTensor(
                             self.material,
                             *hyperElasticStates,
+                            coefK,
                             nPoints,
-                            quadTol,
+                            energyTol,
                         )
                     )
-                    quadNPoints = max(quadNPoints, nPts)
+                    list_nPts_e.append(nPts_e)
                 else:
                     raise NotImplementedError
 
@@ -324,24 +347,41 @@ class HyperElastic(_Simu):
 
             F_e = -residual_e
 
-            # Kelvin–Voigt viscosity: C_e is the damping matrix (slot 2, rides
-            # coefC, carries the viscous residual b -= C @ v_t); Kgeo_e is the
-            # configuration tangent ∂(C·v)/∂u, added to K_e so it rides coefK.
+            # Kelvin–Voigt viscosity: C_e is the damping matrix (slot 2, so it rides coefC
+            # in A), R_visco_e its residual, and Kgeo_e the configuration tangent
+            # ∂(C·v)/∂u, added to K_e so it rides coefK.
             C_e = None
             if self.material.eta != 0 and velocity is not None:
-                C_e, Kgeo_e = Operators.NonLinear.KelvinVoigtDamping(
+                Kgeo_e, R_visco_e, C_e = Operators.NonLinear.KelvinVoigtDamping(
                     self.material, state, velocity
                 )
                 K_e += Kgeo_e
+                F_e -= R_visco_e
 
-            # mass matrix — only assembled for dynamic schemes
+            # mass matrix and the inertia residual — dynamic schemes only
             M_e = None
             if isDynamic:
-                M_e = thickness * Operators.Bilinear.UV(groupElem, self.rho, dof_n=dim)
+                # M_e = thickness · ∫ρ N·N is constant across the solve, so it is cached (see __Mass_e)
+                # instead of rebuilt every Newton iteration. An array ρ is unhashable, so it cannot key the
+                # cache and is recomputed directly.
+                if isinstance(self.rho, np.ndarray):
+                    M_e = thickness * Operators.Bilinear.UV(
+                        groupElem, self.rho, dof_n=dim
+                    )
+                else:
+                    M_e = self.__Mass_e(groupElem, self.rho, thickness, dim)
+                F_e -= np.einsum(
+                    "eij,ej->ei",
+                    M_e,
+                    groupElem.Locates_sol_e(accel, dim),
+                    optimize=True,
+                )
 
             out[groupElem] = (K_e, C_e, M_e, F_e)
 
-        self.__quadNPoints = quadNPoints  # 0 unless quadrature stress ran this assembly
+        # per-element Clenshaw-Curtis point counts this assembly, or None if the quadrature
+        # stress did not run (pointwise / gonzalez)
+        self.__nPts_e = np.concatenate(list_nPts_e) if list_nPts_e else None
 
         return out
 
@@ -358,10 +398,8 @@ class HyperElastic(_Simu):
         if self.algo in AlgoType.Get_Hyperbolic_Types():
             iter["speed"] = self._Get_v_n(self.problemType)
             iter["accel"] = self._Get_a_n(self.problemType)
-        if (
-            self.__quadNPoints
-        ):  # points the converged step used (quadrature stress only)
-            iter["quadNPoints"] = self.__quadNPoints
+        if self.__nPts_e is not None:  # per-element point counts, quadrature only
+            iter["nPts_e"] = self.__nPts_e
 
         return super().Save_Iter(iter)
 
@@ -491,10 +529,14 @@ class HyperElastic(_Simu):
         elif result == "W_e":
             values = self._Calc_W(False)
 
-        elif ("S" in result or "E" in result) and ("_norm" not in result):
-            # Green-Lagrange (E) and second Piola-Kirchhoff (S), group by group
+        elif result in ["Green-Lagrange", "Piola-Kirchhoff"] or (
+            ("S" in result or "E" in result) and ("_norm" not in result)
+        ):
+            # Green-Lagrange (E) and second Piola-Kirchhoff (S), group by group.
+            # "Green-Lagrange" and "Piola-Kirchhoff" carry no upper-case E or S, so they have to
+            # be matched by name: they are what Results_nodeFields_elementFields hands to Paraview.
 
-            isStress = "S" in result
+            isStress = result == "Piola-Kirchhoff" or "S" in result
             res = (
                 result
                 if result in ["Green-Lagrange", "Piola-Kirchhoff"]

{easyfea-3.2.0 → easyfea-3.2.2}/EasyFEA/Simulations/_phasefield.py

@@ -687,16 +687,22 @@ class PhaseField(_Simu):
             return self._Calc_Psi_Elas()
 
         elif result == "Wdef_e":
-            values = self._Calc_Psi_Elas()
+            values = self._Calc_Psi_Elas(returnScalar=False)
 
         elif result == "Psi_Crack":
             return self._Calc_Psi_Crack()
 
-        if result == "psiP":
-            values_e_pg = self.__Calc_psiPlus_e_pg()
-            values = np.mean(values_e_pg, axis=1)
+        elif result == "psiP":
+            # group by group, in Get_list_groupElem order, so the (Ne,) result lines up with
+            # Get_Node_Values on meshes carrying several element groups
+            values = np.concatenate(
+                [
+                    np.asarray(self.__Calc_psiPlus_e_pg(groupElem)).mean(1)
+                    for groupElem in self.mesh.Get_list_groupElem()
+                ]
+            )
 
-        if result == "damage":
+        elif result == "damage":
             values = self.damage  # type: ignore [assignment]
 
         elif result in ["ux", "uy", "uz"]: