easyfea 3.2.1__tar.gz → 3.2.2__tar.gz

{easyfea-3.2.1 → 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Ω``, 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 makes each side a genuine *integral over the element*, **not** a pointwise energy-density comparison. This L1 (absolute) form is the tightest simple bound on the element's actual per-step energy drift ``|∫_Ωe (S:Δe − ΔW) dΩ|`` (triangle inequality, no volume factor), and taking ``|·|`` before summing makes it safe against sign cancellation between Gauss points — a well-resolved region cannot mask a coarse one. Energy-safe because ``S:Δe = ΔW`` holds per Gauss point.
-
-    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 ``nPts_e``, the point count each element accepted.
+    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
@@ -449,10 +448,10 @@ def __AdaptiveTimeQuadratureStressTensor(
         if isAccepted.any():
             acceptedElems = activeElements[isAccepted]  # elements accepting this rule
             dWde_quad[acceptedElems] = S[isAccepted]
-            # their tangent only: Σ_k 2 w_k s_k d2Wde, s=0 drops out (∂e/∂u = s B)
+            # 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, acceptedElems))
+                    (w * s / coefK) * material.Compute_d2Wde(at(s, acceptedElems))
                     for s, w in zip(nodes, weights)
                     if s
                 ),
@@ -468,46 +467,46 @@ def __AdaptiveTimeQuadratureStressTensor(
 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.
-
-    **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". Taking the absolute value before summing bounds the element's actual energy drift directly and guards against sign cancellation between Gauss points. Since each level is scored on its own (no comparison to a coarser one) 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.
+        R_e    = ∫ B(u_t)ᵀ · S_quad dΩ
 
-    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`.
+    ``(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`.
 
-    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::
+    Tangent — only ``e_{n+1}`` depends on ``u_{n+1}`` (``∂e(s_k)/∂u_{n+1} = s_k B_{n+1}``), so::
 
-        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
+        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Ω
 
-    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
@@ -516,7 +515,7 @@ 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_e : ndarray of shape ``(Ne,)``
@@ -524,12 +523,12 @@ def TimeQuadratureStressTensor(
         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:
@@ -547,7 +546,7 @@ 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)
+                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
@@ -557,15 +556,15 @@ def TimeQuadratureStressTensor(
         # 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_e = __AdaptiveTimeQuadratureStressTensor(
-            material, state_n, state_np1, tol, int(maxPoints)
+            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

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

@@ -181,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
         ----------
@@ -209,12 +211,15 @@ class HyperElastic(_Simu):
         """
         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, energyTol)
@@ -254,18 +259,26 @@ class HyperElastic(_Simu):
         # (Kelvin–Voigt viscosity) and the acceleration (inertia), both needed by F_e.
         displacement = self._Solver_Get_Newton_Raphson_current_solution()
         velocity = accel = 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.
+        # 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, accel = self._Solver_Evaluate_u_v_a_for_time_scheme(
@@ -305,10 +318,13 @@ class HyperElastic(_Simu):
                         useConsistentTangent,
                     )
                 elif stressType == HyperElastic.StressType.quadrature:
+                    # 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,
                             energyTol,
                         )
@@ -513,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.1 → 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"]:

{easyfea-3.2.1 → easyfea-3.2.2}/EasyFEA/Simulations/_simu.py

@@ -1189,10 +1189,15 @@ class _Simu(_IObserver, _params.Updatable, ABC):
 
         return u_t, v_t, a_t
 
-    def __Solver_Get_K_C_M_coefs_for_time_scheme(
+    def _Solver_Get_K_C_M_coefs_for_time_scheme(
         self,
     ) -> tuple[float, float, float]:
-        """Returns coefK, coefC, coefM."""
+        r"""The time scheme's ``(coefK, coefC, coefM)`` for ``A = coefK·K + coefC·C + coefM·M``.
+
+        Each is a chain-rule factor w.r.t. the step unknown ``u_{n+1}``: ``coefK = ∂u_t/∂u_{n+1}``,
+        ``coefC = ∂v_t/∂u_{n+1}``, ``coefM = ∂a_t/∂u_{n+1}`` (states from
+        :meth:`_Solver_Evaluate_u_v_a_for_time_scheme`).
+        """
 
         algotypes = AlgoType.Get_Hyperbolic_and_Parabolic_Types()
         assert self.algo in algotypes, f"the current algo is not in {algotypes}."
@@ -1656,7 +1661,7 @@ class _Simu(_IObserver, _params.Updatable, ABC):
         if self.algo is AlgoType.elliptic:
             A = K
         else:
-            coefK, coefC, coefM = self.__Solver_Get_K_C_M_coefs_for_time_scheme()
+            coefK, coefC, coefM = self._Solver_Get_K_C_M_coefs_for_time_scheme()
             A = coefK * K + coefC * C + coefM * M
 
         tic.Tac("Solver", f"Construct A ({problemType}, {algo})", self._verbosity)

{easyfea-3.2.1/easyfea.egg-info → easyfea-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyfea
-Version: 3.2.1
+Version: 3.2.2
 Summary: User-friendly Python library that simplifies finite element analysis.
 Author-email: Matthieu Noel <matthieu.noel7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{easyfea-3.2.1 → easyfea-3.2.2/easyfea.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyfea
-Version: 3.2.1
+Version: 3.2.2
 Summary: User-friendly Python library that simplifies finite element analysis.
 Author-email: Matthieu Noel <matthieu.noel7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{easyfea-3.2.1 → easyfea-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "easyfea"
-version = "3.2.1"
+version = "3.2.2"
 description = "User-friendly Python library that simplifies finite element analysis."
 authors = [{ name = "Matthieu Noel", email = "matthieu.noel7@gmail.com" }]
 readme = "README.md"