NonlinearJ2
Nonlinear General J2 Plasticity Model
Summary
This is an abstract material class thus cannot be used directly. This class defines a general plasticity model using J2 yielding criterion with associated flow rule and mixed hardening rule. The isotropic/kinematic hardening response can be customized.
To use this model, a derived class shall be defined first.
class YourJ2 final : public NonlinearJ2 {
// class definition
}
The derived class only needs to implement four pure virtual methods that define the isotropic and kinematic hardening rules.
virtual double compute_k(double) const = 0; // isotropic hardening
virtual double compute_dk(double) const = 0; // derivative isotropic
virtual double compute_h(double) const = 0; // kinematic hardening
virtual double compute_dh(double) const = 0; // derivative kinematic
All four methods take equivalent plastic strain as the input argument, on output, the corresponding quantities shall be provided.
The isotropic hardening function defines the isotropic hardening rule, there are some requirements:
should be non-negative,
where is the initial yielding stress.
There is no requirement for the kinematic hardening function . Both hardening rules can coexist. However, to successfully solve the trial status, there is an additional constraint that shall be applied on the model:
Otherwise, the local Newton iteration will fail.
Brief On Theory
The NonlinearJ2
abstract class defines an associative plasticity framework using the von Mises yield criterion, which
is defined as follows.
where is the back stress depends on the equivalent plastic strain and is the yield stress. Note
It is also called J2 plasticity model. A detailed discussion can be seen elsewhere. and .
History Layout
initial_history(0)
accumulated plastic strain
initial_history(1-6)
back stress
Kinematic Hardening
The back stress defines a kinematic hardening response. For example a linear kinematic hardening could be defined as:
and the derivative
in which is the kinematic hardening stiffness.
In this case, user shall override the corresponding two methods with such an implmentation.
double SampleJ2::compute_h(const double p_strain) const { return e_kin * p_strain; }
double SampleJ2::compute_dh(const double) const { return e_kin; }
Of course, a nonlinear relationship could also be defined.
Isotropic Hardening
The isotropic hardening is defined by function . The value should be the initial yield stress. Also, for a bilinear isotropic hardening response, user shall override the following two methods.
double SampleJ2::compute_k(const double p_strain) const { return e_iso * p_strain + yield_stress; }
double SampleJ2::compute_dk(const double) const { return e_iso; }
Here another polynomial based isotropic hardening function is shown as an additional example. The function is defined as
where are material constants. It is easy to see . The derivative is
To define such a hardening behavior, a vector shall be used to store all constants.
// PolyJ2.h
const vec poly_para; // poly_para is a vector stores a_i
The methods could be written as follows.
// PolyJ2.cpp
double PolyJ2::compute_k(const double p_strain) const {
vec t_vec(poly_para.n_elem);
t_vec(0) = 1.;
for(uword I = 1; I < t_vec.n_elem; ++I) t_vec(I) = t_vec(I - 1) * p_strain;
return yield_stress * dot(poly_para, t_vec);
}
double PolyJ2::compute_dk(const double p_strain) const {
vec t_vec(poly_para.n_elem);
t_vec(0) = 0.;
t_vec(1) = 1.;
for(uword I = 2; I < t_vec.n_elem; ++I) t_vec(I) = (double(I) + 1.) * pow(p_strain, double(I));
return yield_stress * dot(poly_para, t_vec);
}
Example
A few different models are shown as examples. User can define arbitrary models.
Iso-error Map
The following example iso-error maps are obtained via the following script.
from plugins import ErrorMap
# note: the dependency `ErrorMap` can be found in the following link
# https://github.com/TLCFEM/suanPan-manual/blob/dev/plugins/scripts/ErrorMap.py
young_modulus = 1e5
yield_stress = 100.0
hardening_ratio = 0.05
with ErrorMap(
f"material BilinearJ2 1 {young_modulus} .2 {yield_stress} {hardening_ratio} 0.5",
ref_strain=yield_stress / young_modulus,
ref_stress=yield_stress,
contour_samples=30,
) as error_map:
error_map.contour("j2.uniaxial", center=(-4, 0), size=5, type={"rel", "abs"})
error_map.contour("j2.biaxial", center=(-4, -4), size=5, type={"rel", "abs"})
Last updated