EasyFEA 3.3.0__tar.gz → 3.4.0__tar.gz

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Models/Beam/_beam.py

@@ -4,6 +4,7 @@
 # EasyFEA is distributed under the terms of the GNU General Public License v3, see LICENSE.txt and CREDITS.md for more information.
 
 from abc import abstractmethod
+from typing import TYPE_CHECKING
 
 # utilities
 import numpy as np
@@ -12,10 +13,13 @@ import numpy as np
 from ...Geoms import Line, AsCoords, Normalize
 
 # fem
-from ...FEM import Mesh, _GroupElem, FeArray, MatrixType, ElemType
+from ...FEM import FeArray, MatrixType, ElemType
 from ...FEM import Field, BiLinearForm, LinearForm
 from ...FEM.Elems._beam import _Timoshenko, _EulerBernoulli
 
+if TYPE_CHECKING:
+    from ...FEM import Mesh, _GroupElem
+
 # simulations / models — used by _shear_kappa (Saint-Venant Poisson solve)
 from ... import Models, Simulations
 
@@ -127,7 +131,7 @@ class _Beam(_IModel):
         self,
         dim: int,
         line: Line,
-        section: Mesh,
+        section: "Mesh",
         yAxis: _types.Coords = (0, 1, 0),
     ):
         """Creates a beam.
@@ -165,12 +169,12 @@ class _Beam(_IModel):
         return self.__line
 
     @property
-    def section(self) -> Mesh:
+    def section(self) -> "Mesh":
         """beam cross-section in (x,y) plane"""
         return self.__section
 
     @section.setter
-    def section(self, section: Mesh) -> None:
+    def section(self, section: "Mesh") -> None:
         assert (
             section.inDim == 2
         ), "The cross-beam section must be contained in the (x,y) plane."
@@ -179,7 +183,7 @@ class _Beam(_IModel):
         Iyz = section.groupElem.Integrate_e(lambda x, y, z: x * y).sum()
         assert np.abs(Iyz) <= 1e-9, "The section must have at least 1 symetry axis."
         self.Need_Update()
-        self.__section: Mesh = section
+        self.__section: "Mesh" = section
 
     @property
     def xAxis(self) -> _types.FloatArray:
@@ -365,7 +369,7 @@ class Isotropic(_Beam):
         self,
         dim: int,
         line: Line,
-        section: Mesh,
+        section: "Mesh",
         E: float,
         v: float,
         yAxis: _types.Coords = (0, 1, 0),
@@ -531,7 +535,7 @@ class BeamStructure(_IModel):
 
     def Calc_D_e_pg(
         self,
-        groupElem: _GroupElem,
+        groupElem: "_GroupElem",
         matrixType: MatrixType = MatrixType.beam,
     ) -> FeArray.FeArrayALike:
         """Returns a matrix characterizing the beams's stiffness behavior."""
@@ -556,7 +560,7 @@ class BeamStructure(_IModel):
 
         return D_e_pg
 
-    def Calc_M_e_pg(self, groupElem: _GroupElem) -> FeArray.FeArrayALike:
+    def Calc_M_e_pg(self, groupElem: "_GroupElem") -> FeArray.FeArrayALike:
         """Returns a matrix characterizing the beams's stiffness behavior."""
 
         assert isinstance(groupElem, (_Timoshenko, _EulerBernoulli))
@@ -579,7 +583,7 @@ class BeamStructure(_IModel):
         return M_e_pg
 
     def Get_axis_e(
-        self, groupElem: _GroupElem
+        self, groupElem: "_GroupElem"
     ) -> tuple[_types.FloatArray, _types.FloatArray]:
         """Returns the fiber and cross bar vertical axis on every elements.\n
         return xAxis_e, yAxis_e"""

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/IsotropicHardening.py

@@ -20,7 +20,7 @@ from typing import Callable, NamedTuple
 
 import numpy as np
 
-from ..FEM._linalg import FeArray
+from ...FEM._linalg import FeArray
 
 
 class IsotropicHardening(NamedTuple):

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/KinematicHardening.py

@@ -17,12 +17,12 @@ That is the Bauschinger effect: yielding in tension lowers the stress at which t
 yields in compression. It is why cyclic plasticity needs this and not isotropic hardening alone.
 
 The internal variable is a **tensor**, which is why this is a separate piece rather than an
-option on :class:`~EasyFEA.Models.IsotropicHardening.Hardening`.
+option on :class:`~EasyFEA.Models.InElastic.IsotropicHardening.Hardening`.
 """
 
 from typing import Callable, NamedTuple
 
-from ..FEM._linalg import FeArray
+from ...FEM._linalg import FeArray
 
 
 class KinematicHardening(NamedTuple):

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/ViscoPlastic.py

@@ -20,7 +20,7 @@ from typing import Callable, NamedTuple
 
 import numpy as np
 
-from ..FEM._linalg import FeArray
+from ...FEM._linalg import FeArray
 
 _TINY = 1e-300
 """Floor on the rate, so the inverse and its slope stay finite at zero flow."""

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/Yield.py

@@ -14,9 +14,9 @@ from typing import Callable, NamedTuple, Optional
 
 import numpy as np
 
-from . import _kelvin
-from ..FEM._linalg import FeArray, Norm, TensorProd
-from ..Utilities import _types
+from .. import _kelvin
+from ...FEM._linalg import FeArray, Norm, TensorProd
+from ...Utilities import _types
 
 
 class YieldSurface(NamedTuple):
@@ -30,7 +30,7 @@ class YieldSurface(NamedTuple):
       needs. Written by hand here, as the derivatives of the hyperelastic potentials are.
     - ``P`` — the ``(6, 6)`` quadratic form when :math:`\phi^2 = \Sig : \Prm : \Sig`, else
       ``None``. Only that shape lets the local solve collapse to one scalar unknown, so it is
-      what :class:`.Behaviour` dispatches on.
+      what :class:`.Behavior` dispatches on.
 
     To add a surface, write ``phi`` and differentiate it twice. Yield functions are linear in
     the stress invariants, so the chain rule is a line or two.

easyfea-3.4.0/EasyFEA/Models/InElastic/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (C) 2021-2024 Université Gustave Eiffel.
+# Copyright (C) 2025-2026 Université Gustave Eiffel, INRIA.
+# This file is part of the EasyFEA project.
+# EasyFEA is distributed under the terms of the GNU General Public License v3, see LICENSE.txt and CREDITS.md for more information.
+
+"""Module implementing constitutive laws used in simulations."""
+
+from ._behavior import Behavior
+from ._materialpoint import MaterialPoint
+from . import IsotropicHardening
+from . import KinematicHardening
+from . import ViscoPlastic
+from . import ViscoElastic
+from . import Yield
+from .Yield import YieldSurface

easyfea-3.3.0/EasyFEA/Models/_behaviour.py → easyfea-3.4.0/EasyFEA/Models/InElastic/_behavior.py

@@ -5,7 +5,7 @@
 
 r"""Materials whose stress depends on the strain history.
 
-A :class:`Behaviour` is declared by a free energy and, once it can flow, a yield surface:
+A :class:`Behavior` is declared by a free energy and, once it can flow, a yield surface:
 
 .. math::
     \Sig = \dpartial{\psi}{\Eps} \qquad A = -\dpartial{\psi}{z}
@@ -13,7 +13,7 @@ A :class:`Behaviour` is declared by a free energy and, once it can flow, a yield
 where ``z`` holds the internal variables. Everything the solver needs — the stress, the
 consistent tangent, the evolution of ``z`` — follows from ``psi`` and ``f``.
 
-``Models.Elastic`` is closed-form and total; a ``Behaviour`` is incremental and carries state.
+``Models.Elastic`` is closed-form and total; a ``Behavior`` is incremental and carries state.
 With no internal variables it degenerates to :math:`\Sig = \Crm : \Eps`, which is the same
 answer ``Models.Elastic`` gives.
 """
@@ -23,16 +23,16 @@ from typing import NamedTuple, Optional, Sequence, Union
 
 import numpy as np
 
-from ._utils import _IModel, ModelType
-from .Elastic._laws import _Elastic
+from .._utils import _IModel, ModelType
+from ..Elastic._laws import _Elastic
 from .IsotropicHardening import IsotropicHardening, Linear
 from .KinematicHardening import KinematicHardening
 from .ViscoPlastic import RateLaw
 from .ViscoElastic import Maxwell
 from .Yield import YieldSurface
 from . import _spectral
-from ..FEM._linalg import FeArray, TensorProd
-from ..Utilities import _params, _types, Tic
+from ...FEM._linalg import FeArray, TensorProd
+from ...Utilities import _params, _types, Tic
 
 # in-plane components [xx, yy, xy] of a 2D field inside the 3D (6,) Kelvin vector, and the
 # out-of-plane index condensed out under plane stress
@@ -41,7 +41,7 @@ ZZ = 2
 
 
 class Slot(str, Enum):
-    """Names of the internal variables a behaviour can carry.
+    """Names of the internal variables a behavior can carry.
 
     A ``str`` enum, so ``simu.Result(Slot.p)`` and ``simu.Result("alpha")`` are the same
     call. A repeated mechanism appends an index: the second Maxwell branch is ``eps_v1``.
@@ -75,7 +75,7 @@ class StateLayout(NamedTuple):
         return StateLayout(slots, start)
 
 
-class Behaviour(_IModel):
+class Behavior(_IModel):
     """Elasticity, and later a yield surface, hardening and a rate law.
 
     The elastic model must be 3D: the state lives in 6D Kelvin whatever the problem dimension,
@@ -109,7 +109,7 @@ class Behaviour(_IModel):
         planeStress: bool = False,
         solver: str = "auto",
     ):
-        """Creates a behaviour.
+        """Creates a behavior.
 
         Parameters
         ----------
@@ -136,12 +136,12 @@ class Behaviour(_IModel):
         """
         # what each piece must be
         assert isinstance(elastic, _Elastic), "elastic must be an elastic model"
-        assert yieldSurface is None or isinstance(yieldSurface, YieldSurface), (
-            "yieldSurface must be a YieldSurface"
-        )
-        assert hardening is None or isinstance(hardening, IsotropicHardening), (
-            "hardening must be an IsotropicHardening"
-        )
+        assert yieldSurface is None or isinstance(
+            yieldSurface, YieldSurface
+        ), "yieldSurface must be a YieldSurface"
+        assert hardening is None or isinstance(
+            hardening, IsotropicHardening
+        ), "hardening must be an IsotropicHardening"
         kinematics: tuple[KinematicHardening, ...] = (
             ()
             if kinematic is None
@@ -155,9 +155,9 @@ class Behaviour(_IModel):
             isinstance(component, KinematicHardening) for component in kinematics
         ), "kinematic must be a KinematicHardening, or a sequence of them"
         assert rate is None or isinstance(rate, RateLaw), "rate must be a RateLaw"
-        assert all(isinstance(branch, Maxwell) for branch in branches), (
-            "branches must be Maxwell branches"
-        )
+        assert all(
+            isinstance(branch, Maxwell) for branch in branches
+        ), "branches must be Maxwell branches"
 
         # nothing evolves until the material yields
         needsSurface = {"hardening": hardening, "kinematic": kinematic, "rate": rate}
@@ -170,13 +170,13 @@ class Behaviour(_IModel):
         # parameter ranges
         assert elastic.dim == 3, "the elastic model must be 3D (the state is 6D Kelvin)"
         assert not (planeStress and dim == 3), "plane stress is a 2D-only assumption"
-        assert all(branch.tau > 0 for branch in branches), (
-            "every branch tau must be > 0"
-        )
+        assert all(
+            branch.tau > 0 for branch in branches
+        ), "every branch tau must be > 0"
         assert all(branch.g > 0 for branch in branches), "every branch g must be > 0"
-        assert sum(branch.g for branch in branches) < 1.0, (
-            "the branch stiffness fractions must sum to less than 1"
-        )
+        assert (
+            sum(branch.g for branch in branches) < 1.0
+        ), "the branch stiffness fractions must sum to less than 1"
 
         self.dim = dim
         self.__elastic = elastic
@@ -224,7 +224,7 @@ class Behaviour(_IModel):
 
     @property
     def modelType(self) -> ModelType:
-        # a Behaviour solves for displacement, so it reports the displacement problem type
+        # a Behavior solves for displacement, so it reports the displacement problem type
         return ModelType.elastic
 
     @property
@@ -767,14 +767,15 @@ class Behaviour(_IModel):
 
         Parameters
         ----------
-        eps_e_pg : FeArray (Ne, nPg, nstrain)
-            Total strain, Kelvin-Mandel, in the model dimension.
-        zOld_e_pg : FeArray (Ne, nPg, n), optional
-            Packed state committed at the last converged step; zeros by default.
+        eps_e_pg : FeArray
+            Total strain ``(Ne, nPg, nstrain)``, Kelvin-Mandel, in the model dimension.
+        zOld_e_pg : FeArray, optional
+            Packed state ``(Ne, nPg, n)`` committed at the last converged step; zeros by default.
         dt : float, optional
-            Time increment; required by a rate-dependent behaviour, ignored otherwise.
-        epsOld_e_pg : FeArray (Ne, nPg, nstrain), optional
-            Total strain at the last converged step, supplied by the solver and never stored --
+            Time increment; required by a rate-dependent behavior, ignored otherwise.
+        epsOld_e_pg : FeArray, optional
+            Total strain ``(Ne, nPg, nstrain)`` at the last converged step, supplied by the
+            solver and never stored --
             the state stays exactly the history variables. Only local sub-stepping needs it, so
             leaving it out costs that and nothing else. See MFront's `eto`/`deto`, Abaqus'
             STRAN/DSTRAN and NEML's `e_n`.
@@ -786,17 +787,21 @@ class Behaviour(_IModel):
 
         Returns
         -------
-        sigma : FeArray (Ne, nPg, nstrain)
-        C_alg : FeArray (Ne, nPg, nstrain, nstrain) or None
-        z : FeArray (Ne, nPg, n)
-            Trial state — the caller commits it only once the global step converges.
-        converged : FeArray (Ne, nPg) of bool
+        sigma : FeArray
+            Stress ``(Ne, nPg, nstrain)``, Kelvin-Mandel.
+        C_alg : FeArray or None
+            Consistent tangent ``(Ne, nPg, nstrain, nstrain)``; None if withTangent is False.
+        z : FeArray
+            Trial state ``(Ne, nPg, n)`` — the caller commits it only once the global step
+            converges.
+        converged : FeArray
+            Boolean ``(Ne, nPg)``.
         """
-        assert not fields, (
-            "external fields are not read yet (thermo-mechanical coupling)"
-        )
+        assert (
+            not fields
+        ), "external fields are not read yet (thermo-mechanical coupling)"
         assert self.__rate is None or dt > 0.0, (
-            "a rate-dependent behaviour needs a positive time increment; "
+            "a rate-dependent behavior needs a positive time increment; "
             "set `simu.dt` or pass `dt=` to Integrate"
         )
 
@@ -823,5 +828,5 @@ class Behaviour(_IModel):
                     else C6alg_e_pg[..., IDX_2D, :][..., :, IDX_2D]
                 )
 
-        tic.Tac("Matrix", "Behaviour integrate", False)
+        tic.Tac("Matrix", "Behavior integrate", False)
         return sig_e_pg, C_e_pg, z_e_pg, converged_e_pg

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/_materialpoint.py

@@ -3,22 +3,22 @@
 # This file is part of the EasyFEA project.
 # EasyFEA is distributed under the terms of the GNU General Public License v3, see LICENSE.txt and CREDITS.md for more information.
 
-"""Driving a behaviour at a single material point, with no mesh and no solver."""
+"""Driving a behavior at a single material point, with no mesh and no solver."""
 
 from typing import Optional
 
 import numpy as np
 
-from ._behaviour import Behaviour
-from ..FEM._linalg import FeArray
-from ..Utilities import _types
+from ._behavior import Behavior
+from ...FEM._linalg import FeArray
+from ...Utilities import _types
 
 COMPONENTS = {"xx": 0, "yy": 1, "zz": 2, "yz": 3, "xz": 4, "xy": 5}
 """Kelvin-Mandel component names. The shear entries carry a sqrt(2)."""
 
 
 class MaterialPoint:
-    r"""Runs a :class:`~EasyFEA.Models.Behaviour` on one Gauss point.
+    r"""Runs a :class:`~EasyFEA.Models.Behavior` on one Gauss point.
 
     Each component is either **strain-controlled** — you give its history — or
     **stress-controlled**, where the strain is solved for until the stress reaches its target
@@ -27,15 +27,15 @@ class MaterialPoint:
     contraction comes out of the solve rather than being assumed.
 
     It runs the law on a ``(1, 1)`` :class:`~EasyFEA.FEM.FeArray`, which is the same code path
-    assembly uses — so this is the real behaviour, not a second implementation of it.
+    assembly uses — so this is the real behavior, not a second implementation of it.
 
     Examples
     --------
     Uniaxial tension, load then unload::
 
-        law = Models.Behaviour(3, Isotropic(3, E=210e3, v=0.3),
-                               hardening=Models.IsotropicHardening.Linear(2000.0),
-                               yieldSurface=Models.Yield.VonMises(250.0))
+        law = Models.Behavior(3, Isotropic(3, E=210e3, v=0.3),
+                               hardening=Models.InElastic.IsotropicHardening.Linear(2000.0),
+                               yieldSurface=Models.InElastic.Yield.VonMises(250.0))
         path = np.concatenate([np.linspace(0, 5e-3, 40), np.linspace(5e-3, 0, 40)[1:]])
         res = MaterialPoint(law).Run(strain={"xx": path})
         sigma_xx, eps_xx = res["stress"][:, 0], res["strain"][:, 0]
@@ -44,15 +44,15 @@ class MaterialPoint:
     _tol: float = 1e-9
     _maxIter: int = 50
 
-    def __init__(self, behaviour: Behaviour):
-        assert isinstance(behaviour, Behaviour), "behaviour must be a Behaviour"
-        assert behaviour.dim == 3, "a material point runs the 3D behaviour"
-        self.__behaviour = behaviour
+    def __init__(self, behavior: Behavior):
+        assert isinstance(behavior, Behavior), "behavior must be a Behavior"
+        assert behavior.dim == 3, "a material point runs the 3D behavior"
+        self.__behavior = behavior
 
     @property
-    def behaviour(self) -> Behaviour:
+    def behavior(self) -> Behavior:
         """The material being driven."""
-        return self.__behaviour
+        return self.__behavior
 
     @staticmethod
     def __fe(vec: _types.FloatArray) -> FeArray.FeArrayALike:
@@ -73,7 +73,7 @@ class MaterialPoint:
         stress : dict[str, FloatArray], optional
             stress targets for the remaining components; those left out are held at zero
         dt : float, optional
-            time increment per step, needed by rate-dependent behaviours
+            time increment per step, needed by rate-dependent behaviors
 
         Returns
         -------
@@ -109,7 +109,7 @@ class MaterialPoint:
             # one point, so the fields are read back as plain 6-vectors
             sig = zNew = ok = None
             for _ in range(self._maxIter):
-                sig_e_pg, C_e_pg, zNew, ok = self.__behaviour.Integrate(
+                sig_e_pg, C_e_pg, zNew, ok = self.__behavior.Integrate(
                     self.__fe(eps), z, dt
                 )
                 sig = np.asarray(sig_e_pg)[0, 0]
@@ -123,7 +123,7 @@ class MaterialPoint:
 
             assert (
                 ok is not None and ok.all()
-            ), f"the behaviour did not converge at step {k} - reduce the step size"
+            ), f"the behavior did not converge at step {k} - reduce the step size"
             z = zNew
             history.append((eps.copy(), sig.copy(), np.asarray(z)[0, 0].copy()))
 
@@ -132,7 +132,7 @@ class MaterialPoint:
             "stress": np.array([h[1] for h in history]),
             "state": np.array([h[2] for h in history]),
         }
-        for name, slot in self.__behaviour.layout.slots.items():
+        for name, slot in self.__behavior.layout.slots.items():
             values = out["state"][:, slot]
             # str(), so callers get a plain-string dict whatever the layout keys are
             out[str(name)] = values[:, 0] if values.shape[1] == 1 else values

{easyfea-3.3.0/EasyFEA/Models → easyfea-3.4.0/EasyFEA/Models/InElastic}/_spectral.py

@@ -31,8 +31,8 @@ from typing import NamedTuple
 
 import numpy as np
 
-from ..FEM._linalg import FeArray, TensorProd
-from ..Utilities import _types
+from ...FEM._linalg import FeArray, TensorProd
+from ...Utilities import _types
 
 
 class Return(NamedTuple):
@@ -174,7 +174,10 @@ def Tangent(eigen: Eigenspace, res: Return, C_e_pg: FeArray) -> FeArray:
     dsig_e_pg = _Field(eigen.T, y_e_pg) @ -w_e_pg
     safe_e_pg = np.where(res.phi > 0, res.phi, 1.0)
     n_e_pg = (_Field(eigen.Ti.T, y_e_pg) @ w_e_pg) / safe_e_pg
-    dtheta_e_pg = -(1.0 - res.theta * res.slope) / res.drdtheta
+    # drdtheta is zero where nothing flowed, and those points keep the elastic stiffness below;
+    # guard the division rather than let inf reach the tensor product and come back as nan
+    slope_e_pg = np.where(res.active, res.drdtheta, 1.0)
+    dtheta_e_pg = -(1.0 - res.theta * res.slope) / slope_e_pg
 
     C_alg = elastic_e_pg + TensorProd(dtheta_e_pg * dsig_e_pg, C_e_pg @ n_e_pg)
     # a point that never yielded keeps the elastic stiffness, whatever the algebra says

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Models/__init__.py

@@ -8,14 +8,7 @@
 from . import Beam
 from . import Elastic
 from . import HyperElastic
-from . import IsotropicHardening
-from . import KinematicHardening
-from . import ViscoPlastic
-from . import ViscoElastic
-from . import Yield
-from ._behaviour import Behaviour
-from ._materialpoint import MaterialPoint
-from .Yield import YieldSurface
+from . import InElastic
 from ._phasefield import PhaseField
 from ._thermal import Thermal
 from ._weakforms import WeakForms

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Simulations/__init__.py

@@ -11,7 +11,7 @@ from ._utils import Save_pickle, Load_pickle
 # ------------------------------------------------------------------------------
 # simulations
 # ------------------------------------------------------------------------------
-from ._behaviour import Behaviour
+from ._inelastic import InElastic
 from ._elastic import Elastic, Mesh_Optim_ZZ1
 from ._hyperelastic import HyperElastic
 from ._phasefield import PhaseField

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Simulations/_elastic.py

@@ -26,7 +26,7 @@ from .Solvers import AlgoType
 class Elastic(_Simu):
     r"""Linear (small-strain) elasticity simulation.
 
-    Solves the static, quasi-static or dynamic equilibrium of a linear-elastic body under body forces, surface tractions and Dirichlet conditions, in 1D/2D/3D. Transient and dynamic analyses use the available time schemes (Newmark, HHT, midpoint, …) and support Rayleigh damping. Material behaviour is supplied by an elastic model (isotropic, anisotropic, …).
+    Solves the static, quasi-static or dynamic equilibrium of a linear-elastic body under body forces, surface tractions and Dirichlet conditions, in 1D/2D/3D. Transient and dynamic analyses use the available time schemes (Newmark, HHT, midpoint, …) and support Rayleigh damping. Material behavior is supplied by an elastic model (isotropic, anisotropic, …).
 
     Strong form:
 

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Simulations/_hyperelastic.py

@@ -31,7 +31,7 @@ from ._simu import _Simu, AlgoType
 class HyperElastic(_Simu):
     r"""Finite-strain (large-deformation) hyperelastic simulation, total-Lagrangian framework.
 
-    Solves the nonlinear static or dynamic equilibrium of a hyperelastic body with a Newton-Raphson scheme, with optional Kelvin-Voigt viscosity and a fiber active stress (e.g. for cardiac mechanics). Material behaviour is supplied by a hyperelastic model (Saint-Venant-Kirchhoff, Neo-Hookean, Mooney-Rivlin, Holzapfel-Ogden, …).
+    Solves the nonlinear static or dynamic equilibrium of a hyperelastic body with a Newton-Raphson scheme, with optional Kelvin-Voigt viscosity and a fiber active stress (e.g. for cardiac mechanics). Material behavior is supplied by a hyperelastic model (Saint-Venant-Kirchhoff, Neo-Hookean, Mooney-Rivlin, Holzapfel-Ogden, …).
 
     Weak form:
 

easyfea-3.3.0/EasyFEA/Simulations/_behaviour.py → easyfea-3.4.0/EasyFEA/Simulations/_inelastic.py

@@ -15,16 +15,16 @@ if TYPE_CHECKING:
 from ..FEM import MatrixType, FeArray, Operators
 
 from ..Models import ModelType, Result_strain_or_stress_field_e
-from ..Models._behaviour import Behaviour as _Behaviour
+from ..Models.InElastic._behavior import Behavior
 
 from ._simu import _Simu
 
 
-class Behaviour(_Simu):
+class InElastic(_Simu):
     r"""Quasi-static mechanics with a history-dependent material.
 
     Solves :math:`\diver{\Sig} + \fb = 0` by Newton-Raphson, where the stress comes from
-    :meth:`~EasyFEA.Models.Behaviour.Integrate` rather than from a fixed :math:`\Crm`. The
+    :meth:`~EasyFEA.Models.Behavior.Integrate` rather than from a fixed :math:`\Crm`. The
     material owns the constitutive integration; this class owns the equilibrium iteration and
     the internal-variable history.
 
@@ -36,7 +36,7 @@ class Behaviour(_Simu):
     def __init__(
         self,
         mesh: "Mesh",
-        model: _Behaviour,
+        model: Behavior,
         folder: str = "",
         verbosity: bool = False,
         absTol: float = 1e-6,
@@ -44,13 +44,13 @@ class Behaviour(_Simu):
         incTol: float = 1e-11,
         maxIter: int = 20,
     ):
-        """Creates a behaviour simulation.
+        """Creates a behavior simulation.
 
         Parameters
         ----------
         mesh : Mesh
             The mesh used.
-        model : Behaviour
+        model : Behavior
             The material.
         folder : str, optional
             save folder, by default "".
@@ -61,7 +61,7 @@ class Behaviour(_Simu):
         maxIter : int, optional
             maximum Newton iterations, by default 20.
         """
-        assert isinstance(model, _Behaviour), "model must be a Behaviour"
+        assert isinstance(model, Behavior), "model must be a Behavior"
         super().__init__(mesh, model, folder, verbosity)
 
         self._Solver_Set_Newton_Raphson_Algorithm(absTol, relTol, incTol, maxIter)
@@ -81,7 +81,7 @@ class Behaviour(_Simu):
         self.__dt = value
 
     @property
-    def material(self) -> _Behaviour:
+    def material(self) -> Behavior:
         """The material."""
         return self.model  # type: ignore
 

{easyfea-3.3.0 → easyfea-3.4.0}/EasyFEA/Simulations/_thermal.py

@@ -26,7 +26,7 @@ from .Solvers import AlgoType
 class Thermal(_Simu):
     r"""Heat-transfer (thermal) simulation.
 
-    Solves the steady-state or transient temperature field driven by conduction, a volumetric source and Neumann/Dirichlet conditions, in 1D/2D/3D. Transient analyses use the parabolic time scheme. Material behaviour (conductivity ``k`` and heat capacity ``ρc``) is supplied by a thermal model.
+    Solves the steady-state or transient temperature field driven by conduction, a volumetric source and Neumann/Dirichlet conditions, in 1D/2D/3D. Transient analyses use the parabolic time scheme. Material behavior (conductivity ``k`` and heat capacity ``ρc``) is supplied by a thermal model.
 
     Strong form:
 

{easyfea-3.3.0/easyfea.egg-info → easyfea-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyfea
-Version: 3.3.0
+Version: 3.4.0
 Summary: User-friendly Python library that simplifies finite element analysis.
 Author-email: Matthieu Noel <matthieu.noel7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -737,7 +737,7 @@ Dynamic: license-file
 
 1. [Linear elastic simulations](https://easyfea.readthedocs.io/en/stable/examples/LinearizedElasticity/index.html): `static`, `dynamic`, `homogenization` and `mesh optimization`.
 2. [Hyperelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Hyperelasticity/index.html): `static` and `dynamic` in the ``Lagrangian`` framework..
-3. [Materials with history](https://easyfea.readthedocs.io/en/stable/examples/Behaviour/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
+3. [Inelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Inelasticity/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
 4. [Cardiac elasto-dynamics](https://easyfea.readthedocs.io/en/stable/examples/CardiacElastoDynamics/index.html): passive + active hyperelastic `mono-ventricular` left-ventricle benchmark.
 5. [Contact simulations](https://easyfea.readthedocs.io/en/stable/examples/Contact/index.html): frictionless ``penalty`` contact against a rigid obstacle 
 6. [Euler-Bernoulli and Timoshenko beam simulations](https://easyfea.readthedocs.io/en/stable/examples/Beam/index.html): `static` and `dynamic`.

{easyfea-3.3.0 → easyfea-3.4.0}/README.md

@@ -17,7 +17,7 @@
 
 1. [Linear elastic simulations](https://easyfea.readthedocs.io/en/stable/examples/LinearizedElasticity/index.html): `static`, `dynamic`, `homogenization` and `mesh optimization`.
 2. [Hyperelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Hyperelasticity/index.html): `static` and `dynamic` in the ``Lagrangian`` framework..
-3. [Materials with history](https://easyfea.readthedocs.io/en/stable/examples/Behaviour/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
+3. [Inelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Inelasticity/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
 4. [Cardiac elasto-dynamics](https://easyfea.readthedocs.io/en/stable/examples/CardiacElastoDynamics/index.html): passive + active hyperelastic `mono-ventricular` left-ventricle benchmark.
 5. [Contact simulations](https://easyfea.readthedocs.io/en/stable/examples/Contact/index.html): frictionless ``penalty`` contact against a rigid obstacle 
 6. [Euler-Bernoulli and Timoshenko beam simulations](https://easyfea.readthedocs.io/en/stable/examples/Beam/index.html): `static` and `dynamic`.

{easyfea-3.3.0 → easyfea-3.4.0/easyfea.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyfea
-Version: 3.3.0
+Version: 3.4.0
 Summary: User-friendly Python library that simplifies finite element analysis.
 Author-email: Matthieu Noel <matthieu.noel7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -737,7 +737,7 @@ Dynamic: license-file
 
 1. [Linear elastic simulations](https://easyfea.readthedocs.io/en/stable/examples/LinearizedElasticity/index.html): `static`, `dynamic`, `homogenization` and `mesh optimization`.
 2. [Hyperelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Hyperelasticity/index.html): `static` and `dynamic` in the ``Lagrangian`` framework..
-3. [Materials with history](https://easyfea.readthedocs.io/en/stable/examples/Behaviour/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
+3. [Inelastic simulations](https://easyfea.readthedocs.io/en/stable/examples/Inelasticity/index.html): small-strain `plasticity`, `viscoplasticity` and `viscoelasticity`, assembled from a yield surface, hardening, a back-stress, a rate law and Maxwell branches.
 4. [Cardiac elasto-dynamics](https://easyfea.readthedocs.io/en/stable/examples/CardiacElastoDynamics/index.html): passive + active hyperelastic `mono-ventricular` left-ventricle benchmark.
 5. [Contact simulations](https://easyfea.readthedocs.io/en/stable/examples/Contact/index.html): frictionless ``penalty`` contact against a rigid obstacle 
 6. [Euler-Bernoulli and Timoshenko beam simulations](https://easyfea.readthedocs.io/en/stable/examples/Beam/index.html): `static` and `dynamic`.

{easyfea-3.3.0 → easyfea-3.4.0}/easyfea.egg-info/SOURCES.txt

@@ -35,17 +35,9 @@ EasyFEA/Geoms/_geom.py
 EasyFEA/Geoms/_line.py
 EasyFEA/Geoms/_points.py
 EasyFEA/Geoms/_utils.py
-EasyFEA/Models/IsotropicHardening.py
-EasyFEA/Models/KinematicHardening.py
-EasyFEA/Models/ViscoElastic.py
-EasyFEA/Models/ViscoPlastic.py
-EasyFEA/Models/Yield.py
 EasyFEA/Models/__init__.py
-EasyFEA/Models/_behaviour.py
 EasyFEA/Models/_kelvin.py
-EasyFEA/Models/_materialpoint.py
 EasyFEA/Models/_phasefield.py
-EasyFEA/Models/_spectral.py
 EasyFEA/Models/_thermal.py
 EasyFEA/Models/_utils.py
 EasyFEA/Models/_weakforms.py
@@ -56,13 +48,22 @@ EasyFEA/Models/Elastic/_laws.py
 EasyFEA/Models/HyperElastic/__init__.py
 EasyFEA/Models/HyperElastic/_laws.py
 EasyFEA/Models/HyperElastic/_state.py
+EasyFEA/Models/InElastic/IsotropicHardening.py
+EasyFEA/Models/InElastic/KinematicHardening.py
+EasyFEA/Models/InElastic/ViscoElastic.py
+EasyFEA/Models/InElastic/ViscoPlastic.py
+EasyFEA/Models/InElastic/Yield.py
+EasyFEA/Models/InElastic/__init__.py
+EasyFEA/Models/InElastic/_behavior.py
+EasyFEA/Models/InElastic/_materialpoint.py
+EasyFEA/Models/InElastic/_spectral.py
 EasyFEA/Simulations/Solvers.py
 EasyFEA/Simulations/__init__.py
 EasyFEA/Simulations/_beam.py
-EasyFEA/Simulations/_behaviour.py
 EasyFEA/Simulations/_dic.py
 EasyFEA/Simulations/_elastic.py
 EasyFEA/Simulations/_hyperelastic.py
+EasyFEA/Simulations/_inelastic.py
 EasyFEA/Simulations/_phasefield.py
 EasyFEA/Simulations/_simu.py
 EasyFEA/Simulations/_thermal.py

{easyfea-3.3.0 → easyfea-3.4.0}/pyproject.toml

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