<MODIFIER>#

Description#

This class is used as a “behavior” wrapper in order to modify the integration method or the formulation in some way. Primarily, these modifiers are used to transform the domain of application for the behavior by providing some translation of the primal-dual variable combination, such as is found for corotational large strain modifications.

Modifiers	Description
`lagrange_polar`	formulation based on the Green-Naghdi rate of the Kirchhoff stress.
`lagrange_rotate`	formulation based on the Jaumann rate of Kirchhoff stress.
`lagrange_polar_no_J`	formulation based on the Green-Naghdi rate of the Cauchy stress.
`lagrange_rotate_no_J`	formulation based on the Jaumann rate of the Cauchy stress.
`bifurcation`	bifurcation of mechanical solution analysis
`auto_step`	activates automatic sub-stepping for implicit `theta_method_a` integration method
`runge_jacobian`	mixed integration method associating explicit (Runge-Kutta) integration of behavior differential equations with a final Jacobian call (as in `theta_method_a`) for the computation of the consistent tangent matrix
`runge_rollover`	allows to switch to mixed integration only when the initial `theta_method_a` integration fails
`plane_stress`	external wrapper enforcing the plane-stress condition for material behaviors that don’t handle this case internally
`perturbation`	activates calculation of a tangent matrix obtained by perturbation of the loading strain increment tensor

Global convergence may be inhibited by the addition of the finite-strain options, especially corotational frame ones. In this case, it is advised to use small increment steps or automatic time stepping options in the global calculation sequences.

Large deformation methods#

Large deformation formulations in Z-mat are available for the majority of material behaviors ¹ ¹excepting behaviors with explicitly different treatment of finite strain based on corotational transformation of the stress-strain problem into an “equivalent material referential.” Corotational formulations are implemented because they are applicable to material models with tensorial internal variables and anisotropic response without modifying the local evolution rules [M33]. Description of the models uses the following standard expressions:

\[\begin{split}\begin{aligned} &\ten L = \dot{\ten F} \ten F^{-1} \\ &\ten D = \frac{1}{2} ( \ten L + \ten L^T), \qquad \ten \Omega = \frac{1}{2}(\ten L-\ten L^T) \end{aligned}\end{split}\]

where $\ten F$ is the deformation gradient and $\ten L$ the rate of deformation. Both these tensors are non-symmetric. The stretch rate $\ten D$ and rotation rate $\ten \Omega$ are symmetric and non-symmetric respectively. These methods require elements of the type updated_lagrangian (specified with the option ***mesh in the .inp file).

<MODIFIER> lagrange_polar#

The lagrange_polar modifier is a corotational formulation for finite strain leading to an equivalent Green-Naghdi stress rate in elastic problems [M34, M35]. The stretch rate tensor is transformed into a local strain rate measure through the following expression:

\[\dot{\ten e} = \ten R^T\ten D\ten R\]

where the rotation tensor $\ten R$ is found by the polar decomposition of the deformation gradient:

\[\ten F = \ten R\ten U\]

with $\ten R$ being a pure rotation and $\ten U$ a pure stretch tensor.

Using the transformed “material” strain rate $\ten e$, the behavior may be evaluated as in small deformation. An conjugate stress results from the material behavior integration, $\ten S$ which is transformed to the global Cauchy stress as:

\[\ten \sigma = {\det}^{-1}(\ten F)\thinspace \ten R\thinspace \ten S \thinspace \ten R^T\]

Note

lagrange_polar_no_J modifier is based on the Green-Naghdi rate of the Cauchy stress $\ten \sigma =\dfrac{1}{J} \ten \tau$ ( $J=\det \ten F$ is the volume change).

\[\ten \sigma = \ten R\thinspace \ten S \thinspace \ten R^T\]

This means that for a loading with a negligible volume change, both lagrange_polar and lagrange_polar_no_J will yield similar results.

<MODIFIER> lagrange_rotate#

The lagrange_rotate modifier is a corotational finite strain formulation based on an integrated rotation tensor [M33]. This method yields an equivalent stress-strain response to a Jaumann-rate formulation but allows tensorial internal variables and anisotropic relations to be used as was in the polar decomposition case [M33].

The principle of this method is to always evaluate the material within a local “material” referential. Passing from the global to material referential is made using a rotation tensor in the following relations:

\[\begin{split}\begin{aligned} &\dot{\ten Q} = \ten \Omega \ten Q \qquad \ten Q_o= {\ten 1} \\ &\dot{\ten e}_{tot} = \ten Q^T\ten D\ten Q \qquad \text{(local strain)} \\ &\ten \sigma = {\det}^{-1}(\ten F)\thinspace \ten Q\thinspace \ten S \thinspace \ten Q^T \end{aligned}\end{split}\]

This method requires additional storage at each Gauss point for the non-symmetric rotation tensor, and the local material strain. The name of strain used in the material law is therefore changed to ETO## in place of eto##. This strain is also observed to be a logarithmic strain.

For the two methods, the nonlinear material tangent $\tenf D_{nl}$ describing the $\partial\Delta\ten S/\partial\Delta\ten e$ relationship is modified for the additional large strain non-linearities as follows:

\[\tenf D^\prime_{nl} = {\det}^{-1}(\ten F)\thinspace \ten A \tenf D_{nl}\ten A^T \hskip1cm A_{ijkl} = Q_{ik}Q_{jl}\]

which relates $\partial\Delta\ten \sigma/\partial\Delta t\ten D$. The polar decomposition method will of course use $\ten R$ in the place of $\ten Q$ in the above.

One may note an improved convergence for conditions where the material behavior calculation of $\tenf D_{nl}$ is best (i.e. implicit $\theta$-method integration with $\theta=1$). The calculation of the stress is also noted to depend on the determinant of the total value of the deformation gradient ($\ten F$ from time $t_0$ to the current time). Nonlinearity in this term (especially in trial solutions during iterations) may limit the convergence of the method.

Note

lagrange_rotate_no_J modifier is based on the Jaumann rate of the Cauchy stress.

\[\begin{split}\begin{aligned} &\dot{\ten Q} = \ten \Omega \ten Q \qquad \ten Q_o= {\ten 1} \\ &\dot{\ten e}_{tot} = \ten Q^T\ten D\ten Q \qquad \text{(local strain)} \\ &\ten \sigma = \ten Q\thinspace \ten S \thinspace \ten Q^T \end{aligned}\end{split}\]

<MODIFIER> plane_stress#

Description#

The plane_stress modifier allows any material behavior to be run in plane stress conditions without extra terms being added to the model. The behavoir is integrated several times until sig33 $<$ eps. This is at the cost of extra local iterations but with the benefit that extremely complex cases can be treated effectively (e.g. multi-mats, runge-kutta models, multi-potential deformations, multiplicative finite strain, etc).

Syntax#

The following options are available after the ***plane_stress_controls heading.

*skip_first: A flag to skip plane stress treatment during the first material integration of an increment. For instance, the code attempts to predict the plane strain effect ahead of time, which in some cases can push the nonlinear computation in the wrong direction.
*eps eps: default tolerance from theta method or $10^{-9}$
*iter nit: default from theta method or 200.
*target val: define a target value for sig33 (default value 0).

Example#

The modifier order is important for this object to be used properly. Some typical examples follow:

***behavior gen_evp plane_stress
***behavior gen_evp plane_stress auto_step
***behavior gen_evp lagrange_rotate auto_step plane_stress

The following example can be found in $Z7PATH/TESTS/LS_test/INP/irsid_2d.inp:

***behavior gen_evp plane_stress lagrange_rotate_no_J
 **elasticity isotropic
   young 2.e5
   poisson 0.3
 **potential gen_evp ep
  *criterion mises
  *flow plasticity
  *isotropic by_point
   sigeq epcum
   2000.00    0.
   2000.00    1.0
***plane_stress_controls
  *eps 1.e-5
  *iter 10
***return

<MODIFIER> auto_step#

Description#

The auto_step modifier applies a “local” method of substepping for any material behavior, in an attempt to pass divergences and improve accuracy without cutting back the global time step.

***behavior behavior [ other modifiers ] auto_step $~\,~\,~\,$ [material behavior definition] ***stepping_controls $~\,~\,$ *divergence div [ num ] $~\,~\,$ *security factor $~\,~\,$ *min_dtime min_dt $~\,~\,$ *limit vint1 val1 [ … vintN valN] $~\,~\,~\,$ [ condition <FUNCTION>; ] $~\,~\,$ *use_last_tangent $~\,~\,$ *re_solve $~\,~\,$ *forceit $~\,~\,$ *full_step_jacobian

*divergence div [ num ]: takes parameters div (real) for the division factor to make when a divergence occurs (default 2.0), and num (int) for the maximum number of successive divergences allowed (default 10).
*security factor: sets the maximum allowable increase for the step size (default 1.2).
*min_dtime min_dt: takes a real value to set the minimum dtime before giving up and calling for a global divergence (default $10^{-6}$).
*use_last_tangent: use the last computed tangent matrix instead of averaging the sub-step tangents.
*re_solve: re-solve the step initializing with the sub-step result increment, possibly leading to better global convergence.
*forceit: force sub-stepping, primarily for testing the process.
*limit: takes a list of integrated variable names (VINT) and their maximum allowable changes to ensure no sub-step exceeds the specified increment. The option condition allows to activate sub-stepping when the specified condition is true. The condition should be given as a comparative function in terms of internal variables.
*full_step_jacobian: use the resulting computed full-step variable increment to compute a new tangent matrix in place of the averaged sub-step tangents.

Example#

The following is a typical example.

***behavior gen_evp auto_step
**elasticity isotropic
   young 170000.0
   poisson 0.30
 **potential gen_evp ev
   *flow norton
       n  6.0
       K  800.
   *kinematic nonlinear  X1
       C  3000.0
       D  50.0
   *kinematic nonlinear  X2
       C  3000.0
       D  50.0
   *isotropic constant
       R0 10000.
***stepping_controls
   *divergence  2. 50
   *min_dtime   1.e-8
   *limit evcum 0.01
***return

Note

For finite strain applications this will only work in the order as in the following example:

***behavior gen_evp lagrange_rotate auto_step

<MODIFIER> runge_jacobian#

Description#

This modifier activates a mixed explicit-implicit integration scheme performed in 2 steps.

integration of the set of material integrated variables $V_i$ using an explicit runge-kutta method:

\[V_i^{t+\Delta t}~=~runge\_kutta(t,~\Delta t,~\Delta \epsilon,~V_i^t)\]

with $t$ the time at the beginning of the step, $\Delta t$ the time increment, and $\Delta \overline{\epsilon}$ the strain increment loading.
once known $V_i^{t+\Delta t}$ calculated during step (i), perform a single implicit iteration to obtain an evaluation of the consistent tangent matrix $\frac{\partial \Delta \sigma}{\partial \Delta \epsilon}$

\[\frac{\partial \Delta \sigma}{\partial \Delta \epsilon}~=~calc\_grad\_f(t,~\Delta t,~\Delta \epsilon,~V_i^{t+\Delta t},~\Delta V_i)\]

where $calc\_grad\_f()$ is the Jacobian calculation function called at each iteration of the implicit theta_method_a integration method.

This scheme then combines the benefits of the 2 base local integration methods:

automatic sub-stepping with error control (runge_kutta) efficient for stiff set of differential equations,
good-quality consistent tangent matrix as provided usually by one-step implicit methods.

and can be used when theta_method_a fails to converge, or in replacement of the previously described auto_step modifier.

Important

runge_jacobian modifier is intended for use with explicit integration methods, primarily with runge_kutta.

Syntax#

***material $~\,~\,$ *integration runge_kutta … ***behavior behavior_name runge_jacobian $~\,~\,~\,$ [material behavior definition] [ ***controls $~\,~\,$ *theta theta ] ***return

where the optional command:

*theta: theta allows to specify the $\theta$ value used for the tangent-matrix calculation of step (ii). $\theta=1$ correspond to the fully implicit case (default), while $\theta=0.5$ may be used to trigger semi-implicit integration.

Example#

***behavior gen_evp runge_jacobian
***behavior gen_evp runge_jacobian lagrange_rotate

<MODIFIER> runge_rollover#

Description#

This definition is an alternative to runge_jacobian (see runge_jacobian), where the mixed scheme described previously is only attempted when a single-step theta_method_a implicit integration fails to converge.

Syntax#

***material $~\,~\,$ *integration theta_method_a … ***behavior behavior_name runge_rollover $~\,~\,~\,$ [material behavior definition] [ ***runge_rollover $~\,~\,~\,$ *runge [ eps [ norm ] ] max_iter nit [min_dtime dtmin] ***return

where the optional command:

*runge

can be used to enter values for the runge_kutta 2nd-order method parameters (see integration).

eps is the the tolerance error (default value $10^{-3}$),
norm values are (default value $10^{-3}$ or norm = eps if eps is given),
nit is the maximum number of Runge-Kutta steps (No default value. This variable must be explicitly provided). Note that this value can be specified after any word starting with the prefix max (e.g. max_iter).
dtmin is the minimum step size during sub-stepping (By default, $10^{-14}$).

Example#

In this example eps is set to $10^{-3}$, norm = eps, nit = $10000$, and dtmin = $10^{-14}$.

***behavior gen_evp runge_rollover
 **elasticity isotropic
   young   76400.
   poisson  0.33
 **potential gen_evp ep
  *flow plasticity
  *kinematic nonlinear
   C       48500.
  *isotropic constant
   R0      105.
 **thermal_strain isotropic
   alpha  2.16e-05
   ref_value 20.
***runge_rollover
  *runge 1.e-3 max 10000
***return

This modifier can also be combined with finite strain modifers as

***behavior gen_evp runge_rollover lagrange_rotate

<MODIFIER> perturbation#

Description#

This modifier triggers the calculation of a tangent matrix $\displaystyle \left[ \frac{\partial \Delta \sigma}{\partial \Delta \epsilon} \right]$ obtained by perturbation of each component of the input strain increment tensor $\Delta \epsilon$ (or $\Delta F$ for finite-strain models).

This particular scheme may be used for material behaviors that don’t implement a proper calculation of a full consistent tangent operator (runge-kutta only ZebFront models for example). In this case, global convergence of FE equilibrium iterations may be greatly improved. However, the increase of global time-step allowed by this option, is somewhat counter-balanced by an increase of local integration cost: for small-strain 3D formulations, one additional integration is needed for each perturbation of the 6 individual components of the symmetric $\Delta \epsilon$ tensor.

Syntax#

***behavior behavior_name perturbation $~\,~\,~\,$ [material behavior definition] [ ***perturbation_controls $~\,~\,$ [ *perturb pert ] $~\,~\,$ [ *symmetrize ] $~\,~\,$ [ *one_sided | two_sided ] ]

where the previous optional command are described hereafter:

*perturb: can be used to set the value of the perturbation parameter (default value is pert=1.e-9)
*symmetrize: this-command activates symmetrization of the tangent operator (default is no)
*one_sided, *two_sided: those commands control the way the input strain tensor is perturbed to calculate each column of the tangent operator. In the two_sided mode (default), two integrations are needed to compute each column of the tangent (perturbation of each $\epsilon_i$ component by a value of +/-pert), while the one_sided option only needs one (perturbation by a value of $+pert$ in this case).

Example#

***behavior norton perturbation
...
***return

<MODIFIER> explicit#

Description#

This behavior modifier is used with ABAQUS/Explicit to provide the total integrated corotational strain. One may equally use the lagrange_polar and lagrange_rotate modifiers, but these duplicate many calculations already done by ABAQUS before entry into VUMAT, and therefore are costly.

<MODIFIER> bifurcation#

Description#

This behavior is used to make bifurcation analysis. At each iteration, it find the solution of the following minimization problem :

\[\min_{\vect{n}\in R^3} \left( \vect{n} : \tenf C : \vect{n} \right)\]

$\tenf C$ is usually the consistent tangent operator (which means that the solution to the previous problem depends on the time discretization), but may also be the tangent one. The solution vanish to zero when localization occurs. It works with any mechanical behavior, and add the following auxiliary variables :

`theta`	the first angle of $\vect{n}$
`phi`	the second angle of $\vect{n}$ (available only in 3D)
`det_min`	the minimum of the determinant.

Note that the coefficient of the underlying real behavior may depend on these auxiliary variables.

It is possible to specify

***bifurcation_controls
  **non_linear_bif

to take into account non linear geometry which induces new terms in the minimization, coming from the Jaumann derivative.

`theta`	the first angle of \(\vect{n}\)
`phi`	the second angle of \(\vect{n}\) (available only in 3D)
`det_min`	the minimum of the determinant.

On this page

<MODIFIER>#

Description#

Large deformation methods#

<MODIFIER> lagrange_polar#

<MODIFIER> lagrange_rotate#

<MODIFIER> plane_stress#

Description#

Syntax#

Example#

<MODIFIER> auto_step#

Description#

Example#

<MODIFIER> runge_jacobian#

Description#

Syntax#

Example#

<MODIFIER> runge_rollover#

Description#

Syntax#

Example#

<MODIFIER> perturbation#

Description#

Syntax#

Example#

<MODIFIER> explicit#

Description#

<MODIFIER> bifurcation#

Description#