jaxmat.materials package

Contents

jaxmat.materials package#

Behaviors#

These modules define various material behaviors and state update rules.

Models#

These modules provide specific constitutive models or building blocks used in behaviors (e.g., elasticity laws, plastic surfaces, or damage laws).

Module contents#

class AbstractKinematicHardening[source]#

Bases: Module

An abstract module for Armstrong-Frederic type kinematic hardening.

nvars: AbstractVar[int]#

The number of kinematic hardening variables

sig_eff(sig, X)[source]#

Effective stress \(\bsig-\sum_i \bX_i\) where \(\bX_i\) is the \(i\)-th backstress.

class AbstractLinearElastic[source]#

Bases: Module

Small-strain elastic model.

abstract property C#
property S#

4th-rank isotropic compliance tensor

\[\mathbb{S}=\mathbb{C}^{-1}\]

strain_energy(eps)[source]#

Strain energy density

\[\psi(\beps)=\dfrac{1}{2}\beps:\mathbb{C}:\beps\]

Parameters:

eps (SymmetricTensor2) – Strain tensor

class AbstractPlasticSurface[source]#

Bases: Module

Abstract plastic surface class.

normal(sig, *args)[source]#

Normal to the yield surface. Computed automatically using forward AD on __call__().

Parameters:

  • sig (SymmetricTensor2) – Stress tensor.

  • args – Additional thermodynamic forces entering the yield surface definition.

class ArmstrongFrederickHardening[source]#

Bases: AbstractKinematicHardening

Armstrong-Frederick kinematic hardening model.

References

  • Armstrong, P. J., & Frederick, C. O. (1966).

    “A Mathematical Representation of the Multiaxial Bauschinger Effect for Hardening Materials.” CEGB Report RD/B/N731.

  • Chaboche, J. L. (1991). On some modifications of kinematic hardening to

    improve the description of ratchetting effects. International journal of plasticity, 7(7), 661-678.

C: Array#

Kinematic hardening modulus

gamma: Array#

Nonlinear recall modulus

nvars: AbstractVar[int] = 2#

The number of kinematic hardening variables

sig_eff(sig, X)[source]#

Effective stress is here:

\[\bsig-\frac{2}{3}C\sum_{i=1}^\text{nvars}a_i\]

class ArmstrongFrederickViscoplasticity[source]#

Bases: SmallStrainBehavior

Small-strain viscoplastic constitutive model with Armstrong-Frederick kinematic hardening, Voce isotropic hardening, and Norton-type viscous flow.

This model represents a rate-dependent J2 (von Mises) viscoplastic material combining isotropic and kinematic hardening mechanisms under small strain assumptions. The total strain is additively decomposed into elastic and viscoplastic parts, and the evolution of the backstress follows the nonlinear Armstrong-Frederick law.

Note

  • The model is suitable for cyclic loading and ratcheting simulations.

  • When the viscous exponent tends to infinity, the model approaches the rate-independent limit.

  • The formulation assumes small strains and isotropic material symmetry.

References

  • Armstrong, P. J., & Frederick, C. O. (1966).

    “A Mathematical Representation of the Multiaxial Bauschinger Effect for Hardening Materials.” CEGB Report RD/B/N731.

  • Norton, F. H. (1929).

    “The Creep of Steel at High Temperatures.” McGraw-Hill.

elasticity: LinearElasticIsotropic#

Linear isotropic elasticity defined by Young modulus and Poisson ratio.

yield_stress: Module#

Isotropic hardening law controlling the evolution of the yield surface size.

viscous_flow: NortonFlow#

Viscoplastic flow rule following Norton (power-law) viscosity formulation.

kinematic_hardening: ArmstrongFrederickHardening#

Kinematic hardening model defining the backstress evolution rate with dynamic recovery (Armstrong-Frederick formulation).

plastic_surface = vonMises()#

J2-type yield (or loading) surface based on the deviatoric stress invariant.

internal_type#

alias of AFInternalState

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class CompressibleGhentMooneyRivlin[source]#

Bases: HyperelasticPotential

CompressibleGhentMooneyRivlin(c1: float, c2: float, Jm: float, kappa: float, volumetric: equinox._module._module.Module = VolumetricPart())

c1: float#
c2: float#
Jm: float#
kappa: float#
volumetric: Module = VolumetricPart()#
class CompressibleMooneyRivlin[source]#

Bases: HyperelasticPotential

CompressibleMooneyRivlin(c1: float, c2: float, kappa: float, volumetric: equinox._module._module.Module = VolumetricPart())

c1: float#
c2: float#
kappa: float#
volumetric: Module = VolumetricPart()#
class CompressibleNeoHookean[source]#

Bases: HyperelasticPotential

CompressibleNeoHookean(mu: float, kappa: float, volumetric: equinox._module._module.Module = VolumetricPart())

mu: float#
kappa: float#
volumetric: Module = VolumetricPart()#
class CompressibleOgden[source]#

Bases: HyperelasticPotential

CompressibleOgden(mu: jax.Array, alpha: jax.Array, kappa: float, volumetric: equinox._module._module.Module = VolumetricPart())

mu: Array#
alpha: Array#
kappa: float#
volumetric: Module = VolumetricPart()#
W_lamb(lambCb)[source]#
class DruckerPrager[source]#

Bases: AbstractPlasticSurface

Drucker-Prager yield surface

\[\alpha I_1 + \sqrt{J_2}\]

where \(I_1=\tr(\bsig)\) is the first stress invariant, \(J_2=\dfrac{1}{2}\bs:\bs\) is the second deviatoric invariant and \(\alpha\) a material constant describing the slope of the conic yield surface (friction effects).

Parameters:

alpha (float) – Pressure sensitivity parameter

alpha: float#
class ElasticBehavior[source]#

Bases: SmallStrainBehavior

A small strain linear elastic behavior.

elasticity: Module#

The corresponding linear elastic model.

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class FeFpJ2Plasticity[source]#

Bases: FiniteStrainBehavior

Material model based on https://onlinelibrary.wiley.com/doi/epdf/10.1002/nme.6843

elasticity: LinearElasticIsotropic#

Isotropic elastic model.

yield_stress: Module#

Isotropic hardening law controlling the evolution of the yield surface size.

plastic_surface: AbstractPlasticSurface = vonMises()#

von Mises plastic surface.

internal_type#

alias of InternalState

constitutive_update(F, state, dt)[source]#

Perform the constitutive update for a given deformation gradient increment for a finite-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • F (array_like) – Deformation gradient tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • PK1 (array_like) – Updated first Piola-Kirchhoff stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class FiniteStrainBehavior[source]#

Bases: AbstractBehavior

Abstract finite strain behavior.

init_state(Nbatch=None)[source]#

Initialize the mechanical finite strain state.

abstract constitutive_update(F, state, dt)[source]#

Perform the constitutive update for a given deformation gradient increment for a finite-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • F (array_like) – Deformation gradient tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • PK1 (array_like) – Updated first Piola-Kirchhoff stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class GeneralHardening[source]#

Bases: SmallStrainBehavior

Small-strain rate-independent elastoplastic constitutive model with general combined isotropic and kinematic hardening and generic plastic surface. The model accounts for a single plastic surface but several kinematic hardening variables.

Return-mapping requires solving a non-linear system in terms of \(p\), \(\bepsp\) and the \(\balpha_i\).

elasticity: AbstractLinearElastic#

Linear elastic model.

yield_stress: float#

Initial yield stress.

plastic_surface: AbstractPlasticSurface#

Generic plastic surface.

combined_hardening: Module#

Combined hardening module representing a hardening potential \(\psi_\textrm{h}(\balpha,p)\). Should provide two methods:

  • combined_hardening.dalpha(alpha, p) returning \(\dfrac{\partial \psi_\textrm{h}}{\partial \balpha}(\balpha,p)\)

  • combined_hardening.dp(alpha, p) returning \(\dfrac{\partial \psi_\textrm{h}}{\partial p}(\balpha,p)\)

nvar: int = 1#
make_internal_state()[source]#

Return a freshly constructed internal state instance.

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class GeneralIsotropicHardening[source]#

Bases: SmallStrainBehavior

Small-strain rate-independent elastoplastic constitutive model with isotropic hardening and generic plastic surface. The model does not assume isotropic elasticity.

Return-mapping requires solving a non-linear system in terms of \(p\) and \(\bepsp\).

elasticity: AbstractLinearElastic#

Linear elastic model.

yield_stress: Module#

Isotropic hardening law controlling the evolution of the yield surface size.

plastic_surface: AbstractPlasticSurface#

Generic plastic surface.

internal_type#

alias of InternalState

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class GeneralizedMaxwell[source]#

Bases: SmallStrainBehavior

Generalized Maxwell viscoelastic model (N-branch).

Represents the stress relaxation behavior of viscoelastic materials using a series of Maxwell elements (spring + dashpot), each with its own relaxation time \(\tau_i\).

The model can be seen as a Prony series representation of stress relaxation function.

Notes

The total stress is computed as:

\[\bsig = \bsig_\infty + \sum_{i=1}^N \bsig^\text{v}_i\]

where in each viscous branch evolves as:

\[\begin{split}\begin{align*} \bsig^\text{v}_i &= \CC_i:(\beps-\beps^\text{v}_i)\\ \dot\beps^\text{v}_i &= \dfrac{1}{\tau_i}(\beps-\beps^\text{v}_i) \end{align*} \end{split}\]

elasticity: AbstractLinearElastic#

Elastic model of the equilibrium (instantaneous) branch.

viscous_branches: AbstractLinearElastic#

Elastic stiffness models for the Maxwell branches.

relaxation_times: Array#

Array of relaxation times \((\tau_i)\) for the Maxwell branches.

make_internal_state()[source]#

Return a freshly constructed internal state instance.

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class GeneralizedStandardMaterial[source]#

Bases: SmallStrainBehavior

Generalized Standard Material (GSM) in small strain formulation.

The GSM framework provides a unified thermodynamic formulation for viscoelastic, viscoplastic, and other dissipative material behaviors. It is characterized by two potentials:

  • A free energy \(\Psi(\beps,\balpha)\) defining the elastic (reversible) response.

  • A dissipation pseudo-potential \(\Phi(\dot{\balpha})\) defining the evolution of the internal variables (irreversible processes).

The state variable evolution is obtained by minimizing the incremental potential:

$$min_{Delta balpha} J(Deltabalpha ;beps_{n+1},balpha_n)

= min_{Delta balpha} Psi(beps_{n+1}, balpha_n + Delta balpha) + Delta t Phileft(dfrac{Delta balpha}{Delta t}right)

$$

subject to the current strain \(\beps_{n+1} = \beps_n+\Delta\beps\) and time increment \(\Delta t\).

The minimization is performed numerically using a Newton line-search solver.

Important

This is an abstract behavior which must concretely implement make_internal_state as the structure of internal state variables is not known before hand.

Notes

The stress is automatically computed via

\[\bsig = \dfrac{\partial \Psi}{\partial \beps}\]
.

References

  • Halphen, B., & Nguyen, Q. S. (1975). Sur les matériaux standard généralisés. Journal de mécanique, 14(1), 39-63.

  • Ortiz, M., & Stainier, L. (1999). The variational formulation of viscoplastic constitutive updates. Computer methods in applied mechanics and engineering, 171(3-4), 419-444.

free_energy: Module#

Module defining the Helmholtz free energy $Psi(beps,balpha)

dissipation_potential: Module#

Module defining the dissipation pseudo-potential \(\Phi(\dot\balpha)\)

minimisation_solver = NewtonTrustRegion(   rtol=1e-06,   atol=1e-06,   norm=<function max_norm>,   descent=NewtonDescent(linear_solver=AutoLinearSolver(well_posed=False)),   search=ClassicalTrustRegion(),   verbose=frozenset() )#

Minimisation solver used to minimize the incremental potential.

abstract make_internal_state()[source]#

Create internal state variables.

incremental_potential(d_isv, args)[source]#

Compute the incremental potential for a given internal variable increment.

Parameters:

  • d_isv (PyTree) – Increment of internal state variables \(\Delta \balpha\).

  • args (tuple) –

    Tuple containing (eps, state, dt):

    • eps : total strain tensor.

    • state : current material state.

    • dt : time increment.

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class GenericViscoplasticity[source]#

Bases: SmallStrainBehavior

Small-strain viscoplastic constitutive model with generic yield surface, isotropic and kinematic hardening and viscoplastic flow rule.

elasticity: LinearElasticIsotropic#

Linear isotropic elasticity defined by Young modulus and Poisson ratio.

plastic_surface: AbstractPlasticSurface#

A generic plastic yield surface.

yield_stress: Module#

Isotropic hardening law controlling the evolution of the yield surface size.

viscous_flow: Module#

A generic viscoplastic flow rule.

kinematic_hardening: AbstractKinematicHardening#

A generic kinematic hardening law.

make_internal_state()[source]#

Return a freshly constructed internal state instance.

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class Hosford[source]#

Bases: AbstractPlasticSurface

Hosford yield surface

\[\left(\dfrac{1}{2}(\lvert\sigma_\text{I}-\sigma_\text{II}\rvert^a + \lvert\sigma_\text{II}-\sigma_\text{III}\rvert^a + \lvert\sigma_\text{I}-\sigma_\text{III}\rvert^a)\right)^{1/a}\]

with \(\sigma_\text{I}\) being the stress principal values.

Parameters:

a (float) – Hosford shape parameter

a: float = 2.0#
class HyperelasticPotential[source]#

Bases: Module

HyperelasticPotential()

PK1(F)[source]#
PK2(F)[source]#
Cauchy(F)[source]#
class Hyperelasticity[source]#

Bases: FiniteStrainBehavior

Hyperelasticity(potential: jaxmat.materials.hyperelasticity.HyperelasticPotential)

potential: HyperelasticPotential#
constitutive_update(F, state, dt)[source]#

Perform the constitutive update for a given deformation gradient increment for a finite-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • F (array_like) – Deformation gradient tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • PK1 (array_like) – Updated first Piola-Kirchhoff stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class LinearElastic[source]#

Bases: AbstractLinearElastic

A generic linear elastic model with custom stiffness tensor.

stiffness: SymmetricTensor4#

4th-rank generic stiffness tensor

property C: SymmetricTensor4#

Return the stiffness tensor.

class LinearElasticIsotropic[source]#

Bases: AbstractLinearElastic

An isotropic linear elastic model.

E: float#

Young modulus \(E\)

nu: float#

Poisson ratio \(\nu\)

property C#

4th-rank isotropic stiffness tensor

\[\mathbb{C}=3\kappa\mathbb{J}+2\mu\mathbb{K}\]

where \(\mathbb{J}\) and \(\mathbb{K}\) are the hydrostatic and deviatoric projectors.

property kappa#

Bulk modulus

\[\kappa = \dfrac{E}{3(1-2\nu)} = \lambda +\frac{2}{3}\mu\]

property mu#

Shear modulus

\[\mu = \dfrac{E}{2(1+\nu)}\]

property lmbda#

Lamé modulus

\[\lambda = \dfrac{E\nu}{(1+\nu)(1-2\nu)}\]

class LinearElasticOrthotropic[source]#

Bases: AbstractLinearElastic

An orthotropic linear elastic model.

EL: float#

Longitudinal Young modulus \(E_{L}\)

ET: float#

Transverse Young modulus \(E_{T}\)

EN: float#

Normal Young modulus \(E_{N}\)

nuLT: float#

Longitudinal-transverse Poisson ratio \(\nu_{LT}\)

nuLN: float#

Longitudinal-normal Poisson ratio \(\nu_{LN}\)

nuTN: float#

Transverse-normal Poisson ratio \(\nu_{TN}\)

muLT: float#

Longitudinal-transverse shear modulus \(\mu_{LT}\)

muLN: float#

Longitudinal-normal shear modulus \(\mu_{LN}\)

muTN: float#

Transverse-normal shear modulus \(\mu_{TN}\)

property C#

Build stiffness matrix for orthotropic material.

Convention: \(L=x, T=y, N=z\) in Voigt notation \([xx, yy, zz, xy, xz, yz]\)

class LinearElasticTransverseIsotropic[source]#

Bases: AbstractLinearElastic

A transversely isotropic linear elastic model.

axis: Array#
EL: float#

Longitudinal Young modulus \(E_{L}\)

ET: float#

Transverse Young modulus \(E_{T}\)

nuL: float#

Longitudinal Poisson ratio \(\nu_{L}\)

nuT: float#

Transverse Poisson ratio \(\nu_{T}\)

muL: float#

Longitudinal shear modulus \(\mu_{L}\)

property C#

4th-rank transversely isotropic stiffness tensor

class NortonFlow[source]#

Bases: Module

A Norton viscoplastic flow with overstress.

\[\dot{\beps}^\text{vp} = \left\langle\dfrac{f(\bsig) - \sigma_y}{K}\right\rangle_+^m\]

where \(f(\bsig)-\sigma_y\) is the overstress, \(\langle \cdot\rangle_+\) is the positive part.

K: float#

Characteristic stress \(K\) of the Norton flow.

m: float#

Norton power-law exponent

class SmallStrainBehavior[source]#

Bases: AbstractBehavior

Abstract small strain behavior.

init_state(Nbatch=None)[source]#

Initialize the mechanical small strain state.

abstract constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class StandardLinearSolid[source]#

Bases: SmallStrainBehavior

Standard Linear Solid (Zener) viscoelastic model in Maxwell representation.

The model consists of two parallel branches:

  • A purely elastic branch with stiffness elasticity.

  • A Maxwell branch containing in series:

    • An elastic component with stiffness maxwell_stiffness.

    • A viscous component with viscosity maxwell_viscosity.

The total stress is given by the sum of the elastic branch and Maxwell branch stresses. The model captures both instantaneous and time-dependent (viscoelastic) responses.

Notes

The Maxwell branch defines a relaxation time \(\tau = \eta / E_1\), where \(\eta\) is the viscosity and \(E_1\) is the Maxwell spring modulus.

elasticity: AbstractLinearElastic#

Elastic model for the purely elastic branch.

maxwell_stiffness: AbstractLinearElastic#

Elastic model representing the spring in the Maxwell branch.

maxwell_viscosity: float#

Viscosity \(\eta\) of the dashpot in the Maxwell branch.

internal_type#

alias of SLSState

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

class Tresca[source]#

Bases: AbstractPlasticSurface

Tresca yield surface

\[\max_{\text{I},\text{J}}|\sigma_\text{I}-\sigma_\text{J}|\]

with \(\sigma_\text{I}\) being the stress principal values.

class VoceHardening[source]#

Bases: Module

Voce hardening model for stress-strain behavior.

\[ \sigma_Y(p)=\sigma_0 + (\sigma_\text{u}-\sigma_0)(1-\exp(-bp)) \]

References

  • Voce, E. (1955). “A Practical Strain-Hardening Function.” Metallurgia, 51, 219-226.

sig0: float#

Initial yield stress \(\sigma_0\).

sigu: float#

Saturation stress at large strains \(\sigma_\text{u}\).

b: float#

Rate of hardedning \(b\).

class VolumetricPart[source]#

Bases: Module

VolumetricPart(beta: float = 2.0)

beta: float = 2.0#
safe_zero(method)[source]#

Decorator for yield surfaces to avoid NaNs for zero stress in both fwd and bwd AD.

class vonMises[source]#

Bases: AbstractPlasticSurface

von Mises yield surface

\[\sqrt{\dfrac{3}{2}\bs:\bs}\]

where \(\bs = \dev(\bsig)\)

class vonMisesIsotropicHardening[source]#

Bases: SmallStrainBehavior

Small-strain rate-independent elastoplastic constitutive model with isotropic hardening and J2 (von Mises) plastic surface. The model assumes isotropic elasticity.

Return-mapping only requires solving a scalar non-linear equation in terms of \(p\).

elasticity: LinearElasticIsotropic#

Linear isotropic elasticity defined by Young modulus and Poisson ratio.

yield_stress: Module#

Isotropic hardening law controlling the evolution of the yield surface size.

plastic_surface: AbstractPlasticSurface = vonMises()#

von Mises plastic surface.

internal_type#

alias of InternalState

constitutive_update(eps, state, dt)[source]#

Perform the constitutive update for a given small strain increment for a small-strain behavior.

This abstract method defines the interface for advancing the material state over a time increment based on the provided strain tensor. Implementations should return the updated stress tensor and internal variables, along with any auxiliary information required for consistent tangent computation or subsequent analysis.

Parameters:

  • eps (array_like) – Small strain tensor at the current integration point.

  • state (PyTree) – PyTree containing the current state variables (stress, strain and internal) of the material.

  • dt (float) – Time increment over which the update is performed.

Returns:

  • stress (array_like) – Updated Cauchy stress tensor.

  • new_state (PyTree) – Updated state variables after the constitutive update.

Notes

This method should be implemented by subclasses defining specific constitutive behaviors (elastic, plastic, viscoplastic, etc.).

Contents