The IsotropicHardening class manages all isotropic hardening laws in Metafor, which are described below.

Linear isotropic hardening

$$\sigma_{vm} = \sigma^{el} + h\, \bar{\varepsilon}^{vp}$$

NB: the plastic modulus is defined as $h = \frac{E E_T}{E - E_T}$, where $E$ is the Young's modulus and $E_T$ the tangent modulus.

Saturated isotropic hardening

$$\sigma_{vm} = \sigma^{el} + Q\left(1-\exp\left(-\xi \bar{\varepsilon}^{vp}\right)\right)$$

Double saturated isotropic hardening

$$\sigma_{vm} = \sigma^{el} + Q_1\left(1-\exp\left(-\xi_1 \bar{\varepsilon}^{vp}\right)\right) + Q_2\left(1-\exp\left(-\xi_2 \bar{\varepsilon}^{vp}\right)\right)$$

Ramberg-Osgood isotropic hardening

$$\sigma_{vm} = \sigma^{el} \left(1+A\, \bar{\varepsilon}^{vp}\right)^{\frac{1}{n}}$$

Swift isotropic hardening (a more common formulation of Ramberg - Osgood)

$$\sigma_{vm} = \sigma^{el} +B \left(\bar{\varepsilon}^{vp}\right)^{n}$$

Krupkowski isotropic hardening

$$\sigma_{vm} = K \left(\bar{\varepsilon}^{vp}_{0} + \bar{\varepsilon}^{vp}\right)^{n}$$

Nonlinear isotropic hardening with 8 parameters. First one implemented, can be used to do almost everything.

$$\sigma_{vm} = \left(P_2-P_1\right) \left(1-\exp\left(-P_3\bar{\varepsilon}^{vp}\right)\right) + P_4\left(\bar{\varepsilon}^{vp}\right)^{P_5} +$$ $$+ P_1\left(1+P_6\bar{\varepsilon}^{vp}\right)^{P_7} + P_8\bar{\varepsilon}^{vp}$$

Piecewise linear isotropic hardening. A function is associated to the yield stress.

$$\sigma_{vm} = \sigma^{el} \, * \, f\left(\bar{\varepsilon}^{vp}\right)$$

An Functions y=f(t) must be associated to IH_SIGEL (depending on Field(IF_EPL)).

$$\sigma_{vm}= P_1 \left[ P_2 \sigma_{vm} + P_3 \overline{\varepsilon}^{vp} \right] ^{P_4}$$

This law is integrated with an iterative method.

“Smatch” isotropic hardening.

$$\sigma_{vm}= \left( P_1 + P_2 \overline{\varepsilon}^{vp} \right) \left( 1 - P_3 \exp \left( -P_4 \overline{\varepsilon}^{vp} \right) \right) + P_5$$

“Goijaerts” isotropic hardening

$$\sigma_{vm}= \sigma_{el} + M_1 \left( 1-\exp(-\frac{\overline{\varepsilon}^{vp}}{M_2})\right) + M_3 \sqrt{\overline{\varepsilon}^{vp}} + M_4 \overline{\varepsilon}^{vp}$$

“Kocks-Mecking” isotropic hardening

$$\sigma_{y} = \sigma_{y}^{0} + \frac{\Theta_{0}}{\beta} [ 1-exp(-\beta \bar{\varepsilon}^{vp}) ] \;\;\; si \;\;\; \bar{\varepsilon}^{vp} < \bar{\varepsilon}^{vp}_{tr}$$

$$\sigma_{y} = \sigma_{y}^{tr} + \Theta_{IV} \left( \bar{\varepsilon}^{vp} - \bar{\varepsilon}^{vp}_{tr}\right) \;\;\; si \;\;\; \bar{\varepsilon}^{vp} >\bar{\varepsilon}^{vp}_{tr}$$

where the transition yield stress between stages 3 and 4 is defined as

$$\sigma_{y}^{tr} = \sigma_{y}^{0} + \frac{\Theta_{0}-\Theta_{IV}}{\beta}$$

and the corresponding yield strain as

$$\bar{\varepsilon}^{vp}_{tr} = \frac{1}{\beta} \ln \left(\frac{\Theta_{0}}{\Theta_{IV}}\right)$$

User defined Isotropic Hardening by a pythonDirector :

Python Director allows user to define their own Isotropic Hardening law. Five functions has to be defined in the Python Class :

• a constructor (

  __init__

  ),

• a destructor (

  __del__

  ) that must never be called,

• computeSvm (epl, pLaw)
• computeH (epl, pLaw)
• computePotential (epl, pLaw) for hyperElastics models

See the example below of a Linear Isotropic Hardening :

class MyIsoH(PythonIsotropicHardening):
    def __init__(self, _no, _svm0, _h):
        print("MyIsoH : __init__")
        PythonIsotropicHardening.__init__(self,_no)
        self.svm0 = _svm0
        self.h    = _h
        print("no = ", _no)
        print("self.svm0 = ", self.svm0)
        print("self.h = ", self.h)
        print("MyIsoH : __init__ finished")
        print("computeSvm(0.0) = " , self.computeSvm(0.0, None))
    def __del__(self):
        print("MyIsoH : __del__")
        print("callToDestructor of MyIsoH not allowed. Add MyIsoH.__disown__()")
        input('')
        exit(1)
    def computeSvm(self, epl, pLaw) :
        #print "MyIsoH compute SVM"
        return self.svm0+epl*self.h
    def computeH(self, epl, pLaw) :
        #print "MyIsoH compute H"
        return self.h
    def computePotential(self, epl, pLaw) :
        #print "MyIsoH compute Potential"
        return (self.svm0+self.h*epl*0.5)*epl