AbaqusUMATStress Class Reference

Coupling material to use Abaqus UMAT models in MOOSE. More...

#include <AbaqusUMATStress.h>

Inheritance diagram for AbaqusUMATStress:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	AbaqusUMATStress (const InputParameters &parameters)
void	initialSetup () override
	check optional material properties for consistency
void	computeProperties () override
	perform per-element computation/initialization
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)
void	validateDerivativeMaterialPropertyBase (const std::string &base)
const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
typedef void(*	umat_t) (Real STRESS[], Real STATEV[], Real DDSDDE[], Real *SSE, Real *SPD, Real *SCD, Real *RPL, Real DDSDDT[], Real DRPLDE[], Real *DRPLDT, Real STRAN[], Real DSTRAN[], Real TIME[], Real *DTIME, Real *TEMP, Real *DTEMP, Real PREDEF[], Real DPRED[], char *CMNAME, int *NDI, int *NSHR, int *NTENS, int *NSTATV, Real PROPS[], int *NPROPS, Real COORDS[], Real DROT[], Real *PNEWDT, Real *CELENT, Real DFGRD0[], Real DFGRD1[], int *NOEL, unsigned int *NPT, int *LAYER, int *KSPT, int *KSTEP, int *KINC)
	function type for the external UMAT function

Protected Member Functions
void	initQpStatefulProperties () override
void	computeQpStress () override
	Compute the stress and store it in the _stress material property for the current quadrature point.
virtual void	computeQpProperties () override
virtual void	getAnalysisStepUserObject (const FEProblemBase &fe_problem, const AnalysisStepUserObject *&step_user_object, const std::string &name)

Protected Attributes
FileName	_plugin
DynamicLibraryLoader	_library
umat_t	_umat
Real	_aqRPL
	Volumetric heat generation per unit time at the end of the increment caused by mechanical working of the material.
Real	_aqDRPLDT
	Variation of the volumetric heat generation (RPL) with respect to the temperature.
Real	_aqPNEWDT
	Ratio of suggested new time increment to the time increment being used (out)
Real	_aqDTIME
	Time increment.
Real	_aqTEMP
	Temperature at the start of the increment.
Real	_aqDTEMP
	Increment of temperature.
Real	_aqCELENT
	Characteristic element length, which is a typical length of a line across an element for a first-order element (unused, set to 1)
char	_aqCMNAME [80]
	Model name buffer.
int	_aqNDI
	Number of direct stress components at this point.
int	_aqNSHR
	Number of engineering shear stress components at this point.
int	_aqNTENS
	Size of the stress or strain component array (NDI + NSHR).
int	_aqNSTATV
	Number of solution-dependent state variables that are associated with this material type.
int	_aqNOEL
	Element number.
unsigned int	_aqNPT
	Integration point number.
int	_aqLAYER
	Layer number (for composite shells and layered solids). (not supported)
int	_aqKSPT
	Section point number within the current layer. (not supported)
int	_aqKSTEP
	The step number (as per Abaqus definition) can be set by the user.
int	_aqKINC
	Increment number (_t_step).
std::vector< Real >	_aqSTATEV
std::vector< Real >	_aqDDSDDT
	Variation of the stress increments with respect to the temperature.
std::vector< Real >	_aqDRPLDE
	Variation of RPL with respect to the strain increments.
std::vector< Real >	_aqSTRAN
	An array containing the total strains at the beginning of the increment.
std::vector< Real >	_aqDFGRD0
	Array containing the deformation gradient at the beginning of the increment.
std::vector< Real >	_aqDFGRD1
	Array containing the deformation gradient at the end of the increment.
std::vector< Real >	_aqSTRESS
	Stress tensor (in: old stress, out: updated stress)
std::vector< Real >	_aqDDSDDE
	Jacobian matrix of the model (out)
std::vector< Real >	_aqDSTRAN
	Array of strain increments.
std::vector< Real >	_aqPROPS
	User-specified array of material constants associated with this user material.
std::array< Real, 2 >	_aqTIME
	Value of step time at the beginning of the current increment, total time at the beginning of the current increment.
std::array< Real, 3 >	_aqCOORDS
	An array containing the coordinates of this point.
std::vector< Real >	_aqDROT
	Rotation increment matrix.
int	_aqNPROPS
	User-defined number of material constants associated with this user material.
std::vector< Real >	_aqPREDEF
	Array of interpolated values of predefined field variables at this point at the start of the increment, based on the values read in at the nodes.
std::vector< Real >	_aqDPRED
	Array of increments of predefined field variables.
const MaterialProperty< RankTwoTensor > &	_stress_old
const MaterialProperty< RankTwoTensor > &	_total_strain_old
const OptionalMaterialProperty< RankTwoTensor > &	_strain_increment
MaterialProperty< RankFourTensor > &	_jacobian_mult
	Jacobian multiplier.
const OptionalMaterialProperty< RankTwoTensor > &	_Fbar
const OptionalMaterialProperty< RankTwoTensor > &	_Fbar_old
MaterialProperty< std::vector< Real > > &	_state_var
const MaterialProperty< std::vector< Real > > &	_state_var_old
MaterialProperty< Real > &	_elastic_strain_energy
const MaterialProperty< Real > &	_elastic_strain_energy_old
MaterialProperty< Real > &	_plastic_dissipation
const MaterialProperty< Real > &	_plastic_dissipation_old
MaterialProperty< Real > &	_creep_dissipation
const MaterialProperty< Real > &	_creep_dissipation_old
MaterialProperty< Real > &	_material_timestep
	recommended maximum timestep for this model under the current conditions
const OptionalMaterialProperty< RankTwoTensor > &	_rotation_increment
const OptionalMaterialProperty< RankTwoTensor > &	_rotation_increment_old
const VariableValue &	_temperature
const VariableValue &	_temperature_old
const std::vector< const VariableValue * >	_external_fields
const std::vector< const VariableValue * >	_external_fields_old
std::vector< VariableName >	_external_field_names
const std::size_t	_number_external_fields
const std::vector< MaterialPropertyName >	_external_property_names
const std::size_t	_number_external_properties
std::vector< const MaterialProperty< Real > * >	_external_properties
std::vector< const MaterialProperty< Real > * >	_external_properties_old
const bool	_use_one_based_indexing
	parameter to assist with the transition to 1-based indexing
const bool	_use_orientation
	Rotation information.
const RotationTensor	_R
MaterialProperty< RankTwoTensor > &	_total_rotation
const MaterialProperty< RankTwoTensor > &	_total_rotation_old
const std::string	_base_name
	Base name prepended to all material property names to allow for multi-material systems.
const MaterialProperty< RankTwoTensor > &	_mechanical_strain
	Mechanical strain material property.
MaterialProperty< RankTwoTensor > &	_stress
	Stress material property.
MaterialProperty< RankTwoTensor > &	_elastic_strain
	Elastic strain material property.
const MaterialProperty< RankTwoTensor > &	_extra_stress
	Extra stress tensor.
std::vector< const Function * >	_initial_stress_fcn
	initial stress components
MaterialProperty< RankFourTensor > &	_Jacobian_mult
	derivative of stress w.r.t. strain (_dstress_dstrain)

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)
std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)
void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)
bool	isNotObjectVariable (const VariableName &name)

Private Attributes
const ComputeFiniteStrain::DecompMethod	_decomposition_method
	Method being used to compute strain and rotation increments.
const AnalysisStepUserObject *	_step_user_object
	User object that determines step number.
FEProblemBase &	_dmi_fe_problem

Detailed Description

Coupling material to use Abaqus UMAT models in MOOSE.

Definition at line 23 of file AbaqusUMATStress.h.

Member Typedef Documentation

umat_t

typedef void(* AbaqusUMATStress::umat_t) (Real STRESS[], Real STATEV[], Real DDSDDE[], Real *SSE, Real *SPD, Real *SCD, Real *RPL, Real DDSDDT[], Real DRPLDE[], Real *DRPLDT, Real STRAN[], Real DSTRAN[], Real TIME[], Real *DTIME, Real *TEMP, Real *DTEMP, Real PREDEF[], Real DPRED[], char *CMNAME, int *NDI, int *NSHR, int *NTENS, int *NSTATV, Real PROPS[], int *NPROPS, Real COORDS[], Real DROT[], Real *PNEWDT, Real *CELENT, Real DFGRD0[], Real DFGRD1[], int *NOEL, unsigned int *NPT, int *LAYER, int *KSPT, int *KSTEP, int *KINC)

protected

function type for the external UMAT function

Definition at line 38 of file AbaqusUMATStress.h.

Constructor & Destructor Documentation

AbaqusUMATStress()

AbaqusUMATStress::AbaqusUMATStress

(

const InputParameters &

parameters

)

Definition at line 65 of file AbaqusUMATStress.C.

  : ComputeGeneralStressBase(parameters),
    _plugin(getParam<FileName>("plugin")),
    _library(_plugin + std::string("-") + QUOTE(METHOD) + ".plugin"),
    _umat(_library.getFunction<umat_t>("umat_")),
    _aqNSTATV(getParam<unsigned int>("num_state_vars")),
    _aqSTATEV(_aqNSTATV),
    _aqPROPS(getParam<std::vector<Real>>("constant_properties")),
    _aqNPROPS(_aqPROPS.size()),
    _stress_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "stress")),
    _total_strain_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "total_strain")),
    _strain_increment(getOptionalMaterialProperty<RankTwoTensor>(_base_name + "strain_increment")),
    _jacobian_mult(declareProperty<RankFourTensor>(_base_name + "Jacobian_mult")),
    _Fbar(getOptionalMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
    _Fbar_old(getOptionalMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
    _state_var(declareProperty<std::vector<Real>>(_base_name + "state_var")),
    _state_var_old(getMaterialPropertyOld<std::vector<Real>>(_base_name + "state_var")),
    _elastic_strain_energy(declareProperty<Real>(_base_name + "elastic_strain_energy")),
    _elastic_strain_energy_old(getMaterialPropertyOld<Real>(_base_name + "elastic_strain_energy")),
    _plastic_dissipation(declareProperty<Real>(_base_name + "plastic_dissipation")),
    _plastic_dissipation_old(getMaterialPropertyOld<Real>(_base_name + "plastic_dissipation")),
    _creep_dissipation(declareProperty<Real>(_base_name + "creep_dissipation")),
    _creep_dissipation_old(getMaterialPropertyOld<Real>(_base_name + "creep_dissipation")),
    _material_timestep(declareProperty<Real>(_base_name + "material_timestep_limit")),
    _rotation_increment(
        getOptionalMaterialProperty<RankTwoTensor>(_base_name + "rotation_increment")),
    _rotation_increment_old(
        getOptionalMaterialPropertyOld<RankTwoTensor>(_base_name + "rotation_increment")),
    _temperature(coupledValue("temperature")),
    _temperature_old(coupledValueOld("temperature")),
    _external_fields(isCoupled("external_fields") ? coupledValues("external_fields")
                                                  : std::vector<const VariableValue *>{}),
    _external_fields_old(isCoupled("external_fields") ? coupledValuesOld("external_fields")
                                                      : std::vector<const VariableValue *>{}),
    _number_external_fields(_external_fields.size()),
    _external_property_names(getParam<std::vector<MaterialPropertyName>>("external_properties")),
    _number_external_properties(_external_property_names.size()),
    _external_properties(_number_external_properties),
    _external_properties_old(_number_external_properties),
    _use_one_based_indexing(getParam<bool>("use_one_based_indexing")),
    _use_orientation(isParamValid("orientation")),
    _R(_use_orientation ? getParam<RealVectorValue>("orientation") : RealVectorValue(0.0)),
    _total_rotation(declareProperty<RankTwoTensor>("total_rotation")),
    _total_rotation_old(getMaterialPropertyOld<RankTwoTensor>("total_rotation")),
    _decomposition_method(
        getParam<MooseEnum>("decomposition_method").getEnum<ComputeFiniteStrain::DecompMethod>())
{
  if (!_use_one_based_indexing)
    mooseDeprecated(
        "AbaqusUMATStress has transitioned to 1-based indexing in the element (NOEL) and "
        "integration point (NPT) numbers to ensure maximum compatibility with legacy UMAT files. "
        "Please ensure that any new UMAT plugins using these quantities are using the correct "
        "indexing. 0-based indexing will be deprecated soon.");
 
  // get material properties
  for (std::size_t i = 0; i < _number_external_properties; ++i)
  {
    _external_properties[i] = &getMaterialProperty<Real>(_external_property_names[i]);
    _external_properties_old[i] = &getMaterialPropertyOld<Real>(_external_property_names[i]);
  }
 
  // Read mesh dimension and size UMAT arrays (we always size for full 3D)
  _aqNTENS = 6; // Size of the stress or strain component array (NDI+NSHR)
  _aqNSHR = 3;  // Number of engineering shear stress components
  _aqNDI = 3;   // Number of direct stress components (always 3)
 
  _aqDDSDDT.resize(_aqNTENS);
  _aqDRPLDE.resize(_aqNTENS);
  _aqSTRAN.resize(_aqNTENS);
  _aqDFGRD0.resize(9);
  _aqDFGRD1.resize(9);
  _aqDROT.resize(9);
  _aqSTRESS.resize(_aqNTENS);
  _aqDDSDDE.resize(_aqNTENS * _aqNTENS);
  _aqDSTRAN.resize(_aqNTENS);
  _aqPREDEF.resize(_number_external_fields + _number_external_properties);
  _aqDPRED.resize(_number_external_fields + _number_external_properties);
}

Member Function Documentation

computeProperties()

void AbaqusUMATStress::computeProperties ( )

override

perform per-element computation/initialization

Definition at line 180 of file AbaqusUMATStress.C.

{
  // current element "number"
  _aqNOEL = _current_elem->id() + (_use_one_based_indexing ? 1 : 0);
 
  // characteristic element length
  _aqCELENT = std::pow(_current_elem->volume(), 1.0 / _current_elem->dim());
 
  if (!_step_user_object)
  {
    // Value of total time at the beginning of the current increment
    _aqTIME[0] = _t - _dt;
  }
  else
  {
    const unsigned int start_time_step = _step_user_object->getStep(_t - _dt);
    const Real step_time = _step_user_object->getStartTime(start_time_step);
    // Value of step time at the beginning of the current increment
    _aqTIME[0] = step_time;
  }
  // Value of total time at the beginning of the current increment
  _aqTIME[1] = _t - _dt;
 
  // Time increment
  _aqDTIME = _dt;
 
  // Fill unused characters with spaces (Fortran)
  std::fill(_aqCMNAME, _aqCMNAME + 80, ' ');
  std::memcpy(_aqCMNAME, name().c_str(), name().size());
 
  ComputeGeneralStressBase::computeProperties();
}

computeQpProperties()

void ComputeGeneralStressBase::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 44 of file ComputeGeneralStressBase.C.

{
  computeQpStress();
 
  // Add in extra stress
  _stress[_qp] += _extra_stress[_qp];
}

computeQpStress()

void AbaqusUMATStress::computeQpStress ( )

overrideprotectedvirtual

Compute the stress and store it in the _stress material property for the current quadrature point.

Implements ComputeGeneralStressBase.

Definition at line 214 of file AbaqusUMATStress.C.

{
  // C uses row-major, whereas Fortran uses column major
  // therefore, all unsymmetric matrices must be transposed before passing them to Fortran
  RankTwoTensor FBar_old_fortran = _Fbar_old[_qp].transpose();
  RankTwoTensor FBar_fortran = _Fbar[_qp].transpose();
 
  // DROT needed by UMAT will depend on kinematics and whether or not an intermediate configuration
  // is used
  RankTwoTensor DROT_fortran;
  if (_use_orientation)
  {
    DROT_fortran = RankTwoTensor::Identity();
  }
  else
  {
    if (_decomposition_method == ComputeFiniteStrain::DecompMethod::HughesWinget)
      DROT_fortran = _rotation_increment[_qp].transpose();
    else
      DROT_fortran = _rotation_increment_old[_qp].transpose();
  }
 
  const Real * myDFGRD0 = &(FBar_old_fortran(0, 0));
  const Real * myDFGRD1 = &(FBar_fortran(0, 0));
  const Real * myDROT = &(DROT_fortran(0, 0));
 
  // More local copies of materials so we can (optionally) rotate
  RankTwoTensor stress_old = _stress_old[_qp];
  RankTwoTensor total_strain_old = _total_strain_old[_qp];
  RankTwoTensor strain_increment = _strain_increment[_qp];
 
  // check if we need to rotate to intermediate configuration
  if (_use_orientation)
  {
    // keep track of total rotation
    _total_rotation[_qp] = _rotation_increment[_qp] * _total_rotation_old[_qp];
    // rotate stress/strain/increment from reference configuration to intermediate configuration
    stress_old.rotate(_total_rotation_old[_qp].transpose());
    total_strain_old.rotate(_total_rotation_old[_qp].transpose());
 
    if (_decomposition_method == ComputeFiniteStrain::DecompMethod::HughesWinget)
      strain_increment.rotate(_total_rotation[_qp].transpose());
    else
      strain_increment.rotate(_total_rotation_old[_qp].transpose());
  }
  else if (_decomposition_method == ComputeFiniteStrain::DecompMethod::HughesWinget)
    // rotate old stress to reference configuration
    stress_old.rotate(_rotation_increment[_qp]);
 
  // copy because UMAT does not guarantee constness
  for (const auto i : make_range(9))
  {
    _aqDFGRD0[i] = myDFGRD0[i];
    _aqDFGRD1[i] = myDFGRD1[i];
    _aqDROT[i] = myDROT[i];
  }
 
  // Recover "old" state variables
  for (const auto i : make_range(_aqNSTATV))
    _aqSTATEV[i] = _state_var_old[_qp][i];
 
  // Recover "old" energy quantities
  _elastic_strain_energy[_qp] = _elastic_strain_energy_old[_qp];
  _plastic_dissipation[_qp] = _plastic_dissipation_old[_qp];
  _creep_dissipation[_qp] = _creep_dissipation_old[_qp];
 
  // Pass through updated stress, total strain, and strain increment arrays
  static const std::array<Real, 6> strain_factor{{1, 1, 1, 2, 2, 2}};
  // Account for difference in vector order convention: yz, xz, xy (MOOSE)  vs xy, xz, yz
  // (commercial software)
  static const std::array<std::pair<unsigned int, unsigned int>, 6> component{
      {{0, 0}, {1, 1}, {2, 2}, {0, 1}, {0, 2}, {1, 2}}};
 
  for (const auto i : make_range(_aqNTENS))
  {
    const auto a = component[i].first;
    const auto b = component[i].second;
    _aqSTRESS[i] = stress_old(a, b);
    _aqSTRAN[i] = total_strain_old(a, b) * strain_factor[i];
    _aqDSTRAN[i] = strain_increment(a, b) * strain_factor[i];
  }
 
  // current coordinates
  for (const auto i : make_range(Moose::dim))
    _aqCOORDS[i] = _q_point[_qp](i);
 
  // zero out Jacobian contribution
  for (const auto i : make_range(_aqNTENS * _aqNTENS))
    _aqDDSDDE[i] = 0.0;
 
  // Set PNEWDT initially to a large value
  _aqPNEWDT = std::numeric_limits<Real>::max();
 
  // Temperature
  _aqTEMP = _temperature_old[_qp];
 
  // Temperature increment
  _aqDTEMP = _temperature[_qp] - _temperature_old[_qp];
 
  for (const auto i : make_range(_number_external_fields))
  {
    // External field at this step
    _aqPREDEF[i] = (*_external_fields_old[i])[_qp];
 
    // External field increments
    _aqDPRED[i] = (*_external_fields[i])[_qp] - (*_external_fields_old[i])[_qp];
  }
 
  for (const auto i : make_range(_number_external_properties))
  {
    // External property at this step
    _aqPREDEF[i + _number_external_fields] = (*_external_properties_old[i])[_qp];
 
    // External property increments
    _aqDPRED[i + _number_external_fields] =
        (*_external_properties[i])[_qp] - (*_external_properties_old[i])[_qp];
  }
 
  // Layer number (not supported)
  _aqLAYER = -1;
 
  // Section point number within the layer (not supported)
  _aqKSPT = -1;
 
  // Increment number
  _aqKINC = _t_step;
  _aqKSTEP = 1;
 
  // integration point number
  _aqNPT = _qp + (_use_one_based_indexing ? 1 : 0);
 
  // Connection to extern statement
  _umat(_aqSTRESS.data(),
        _aqSTATEV.data(),
        _aqDDSDDE.data(),
        &_elastic_strain_energy[_qp],
        &_plastic_dissipation[_qp],
        &_creep_dissipation[_qp],
        &_aqRPL,
        _aqDDSDDT.data(),
        _aqDRPLDE.data(),
        &_aqDRPLDT,
        _aqSTRAN.data(),
        _aqDSTRAN.data(),
        _aqTIME.data(),
        &_aqDTIME,
        &_aqTEMP,
        &_aqDTEMP,
        _aqPREDEF.data(),
        _aqDPRED.data(),
        _aqCMNAME,
        &_aqNDI,
        &_aqNSHR,
        &_aqNTENS,
        &_aqNSTATV,
        _aqPROPS.data(),
        &_aqNPROPS,
        _aqCOORDS.data(),
        _aqDROT.data(),
        &_aqPNEWDT,
        &_aqCELENT,
        _aqDFGRD0.data(),
        _aqDFGRD1.data(),
        &_aqNOEL,
        &_aqNPT,
        &_aqLAYER,
        &_aqKSPT,
        &_aqKSTEP,
        &_aqKINC);
 
  // Update state variables
  for (int i = 0; i < _aqNSTATV; ++i)
    _state_var[_qp][i] = _aqSTATEV[i];
 
  // Here, we apply UMAT convention: Always multiply _dt by PNEWDT to determine the material time
  // step MOOSE time stepper will choose the most limiting of all material time step increments
  // provided
  _material_timestep[_qp] = _aqPNEWDT * _dt;
 
  // Get new stress tensor - UMAT should update stress
  // Account for difference in vector order convention: yz, xz, xy (MOOSE)  vs xy, xz, yz
  // (commercial software)
  _stress[_qp] = RankTwoTensor(
      _aqSTRESS[0], _aqSTRESS[1], _aqSTRESS[2], _aqSTRESS[5], _aqSTRESS[4], _aqSTRESS[3]);
 
  // Build Jacobian matrix from UMAT's Voigt non-standard order to fourth order tensor.
  const unsigned int N = Moose::dim;
  const unsigned int ntens = N * (N + 1) / 2;
  const int nskip = N - 1;
 
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        for (const auto l : make_range(N))
        {
          if (i == j)
            _jacobian_mult[_qp](i, j, k, l) =
                k == l ? _aqDDSDDE[i * ntens + k] : _aqDDSDDE[i * ntens + k + nskip + l];
          else
            // i!=j
            _jacobian_mult[_qp](i, j, k, l) =
                k == l ? _aqDDSDDE[(nskip + i + j) * ntens + k]
                       : _aqDDSDDE[(nskip + i + j) * ntens + k + nskip + l];
        }
 
  // check if we need to rotate from intermediate reference frame
  if (_use_orientation)
  {
    // rotate to current configuration
    _stress[_qp].rotate(_total_rotation[_qp]);
    _jacobian_mult[_qp].rotate(_total_rotation[_qp]);
  }
  else if (_decomposition_method != ComputeFiniteStrain::DecompMethod::HughesWinget)
    _stress[_qp].rotate(_rotation_increment[_qp]);
}

getAnalysisStepUserObject()

void AnalysisStepUOInterface::getAnalysisStepUserObject ( const FEProblemBase &  fe_problem, const AnalysisStepUserObject *&  step_user_object, const std::string &  name  )

protectedvirtualinherited

Definition at line 15 of file AnalysisStepUOInterface.C.

{
  std::vector<const UserObject *> uos;
  fe_problem.theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(uos);
 
  std::vector<const AnalysisStepUserObject *> step_uos;
  for (const auto & uo : uos)
  {
    const AnalysisStepUserObject * possible_step_uo =
        dynamic_cast<const AnalysisStepUserObject *>(uo);
    if (possible_step_uo)
      step_uos.push_back(possible_step_uo);
  }
 
  if (step_uos.size() > 1)
    mooseError("Your input file has multiple AnalysisStepUserObjects. MOOSE currently only support "
               "one in ",
               name,
               ". \n");
  else if (step_uos.size() == 1)
    mooseInfo("A AnalysisStepUserObject, has been identified and will be used to drive stepping "
              "behavior in ",
              name,
              ".");
 
  step_user_object = step_uos.size() == 1 ? step_uos[0] : nullptr;
}

Referenced by AnalysisStepPeriod::initialSetup(), initialSetup(), and AbaqusUExternalDB::initialSetup().

initialSetup()

void AbaqusUMATStress::initialSetup ( )

override

check optional material properties for consistency

Definition at line 145 of file AbaqusUMATStress.C.

{
  // The _Fbar, _Fbar_old, and _rotation_increment optional properties are only available when an
  // incremental strain formulation is used. If they are not avaliable we advide the user to
  // select an incremental formulation.
  if (!_strain_increment || !_Fbar || !_Fbar_old || !_rotation_increment)
    mooseError("AbaqusUMATStress '",
               name(),
               "': Incremental strain quantities are not available. You likely are using a total "
               "strain formulation. Specify `incremental = true` in the tensor mechanics action, "
               "or use ComputeIncrementalStrain in your input file.");
 
  // Let's automatically detect uos and identify the one we are interested in.
  // If there is more than one, we assume something is off and error out.
  if (!isParamSetByUser("analysis_step_user_object"))
    getAnalysisStepUserObject(_fe_problem, _step_user_object, name());
  else
    _step_user_object = &getUserObject<AnalysisStepUserObject>("analysis_step_user_object");
}

initQpStatefulProperties()

void AbaqusUMATStress::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented from ComputeGeneralStressBase.

Definition at line 166 of file AbaqusUMATStress.C.

{
  ComputeGeneralStressBase::initQpStatefulProperties();
 
  // Initialize state variable vector
  _state_var[_qp].resize(_aqNSTATV);
  for (const auto i : make_range(_aqNSTATV))
    _state_var[_qp][i] = 0.0;
 
  // Initialize total rotation tensor
  _total_rotation[_qp] = _R;
}

validParams()

InputParameters AbaqusUMATStress::validParams ( )

static

Definition at line 25 of file AbaqusUMATStress.C.

{
  InputParameters params = ComputeGeneralStressBase::validParams();
  params.addClassDescription("Coupling material to use Abaqus UMAT models in MOOSE");
  params.addRequiredParam<FileName>(
      "plugin", "The path to the compiled dynamic library for the plugin you want to use");
  params.addRequiredParam<bool>(
      "use_one_based_indexing",
      "Parameter to control whether indexing for element and integration points as presented to "
      "UMAT models is based on 1 (true) or 0 (false). This does not affect internal MOOSE "
      "numbering. The option to use 0-based numbering is deprecated and will be removed soon.");
  params.addRequiredParam<std::vector<Real>>(
      "constant_properties", "Constant mechanical and thermal material properties (PROPS)");
  params.addRequiredParam<unsigned int>("num_state_vars",
                                        "The number of state variables this UMAT is going to use");
  params.addCoupledVar("temperature", 0.0, "Coupled temperature");
  params.addCoupledVar("external_fields",
                       "The external fields that can be used in the UMAT subroutine");
  params.addParam<std::vector<MaterialPropertyName>>("external_properties", {}, "");
  params.addParam<MooseEnum>("decomposition_method",
                             ComputeFiniteStrain::decompositionType(),
                             "Method to calculate the strain kinematics.");
  params.addParam<bool>(
      "use_displaced_mesh",
      false,
      "Whether or not this object should use the "
      "displaced mesh for computing displacements and quantities based on the deformed state.");
  params.addParam<UserObjectName>(
      "analysis_step_user_object",
      "The AnalysisStepUserObject that provides times from simulation loading steps.");
  params.addParam<RealVectorValue>(
      "orientation",
      "Euler angles that describe the orientation of the local material coordinate system.");
  return params;
}

Member Data Documentation

_aqCELENT

Real AbaqusUMATStress::_aqCELENT

protected

Characteristic element length, which is a typical length of a line across an element for a first-order element (unused, set to 1)

Definition at line 107 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_aqCMNAME

char AbaqusUMATStress::_aqCMNAME[80]

protected

Model name buffer.

Definition at line 110 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_aqCOORDS

std::array<Real, 3> AbaqusUMATStress::_aqCOORDS

protected

An array containing the coordinates of this point.

Definition at line 181 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDDSDDE

std::vector<Real> AbaqusUMATStress::_aqDDSDDE

protected

Jacobian matrix of the model (out)

Definition at line 165 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDDSDDT

std::vector<Real> AbaqusUMATStress::_aqDDSDDT

protected

Variation of the stress increments with respect to the temperature.

Definition at line 147 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDFGRD0

std::vector<Real> AbaqusUMATStress::_aqDFGRD0

protected

Array containing the deformation gradient at the beginning of the increment.

Definition at line 156 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDFGRD1

std::vector<Real> AbaqusUMATStress::_aqDFGRD1

protected

Array containing the deformation gradient at the end of the increment.

Definition at line 159 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDPRED

std::vector<Real> AbaqusUMATStress::_aqDPRED

protected

Array of increments of predefined field variables.

Definition at line 193 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDROT

std::vector<Real> AbaqusUMATStress::_aqDROT

protected

Rotation increment matrix.

Definition at line 184 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDRPLDE

std::vector<Real> AbaqusUMATStress::_aqDRPLDE

protected

Variation of RPL with respect to the strain increments.

Definition at line 150 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDRPLDT

Real AbaqusUMATStress::_aqDRPLDT

protected

Variation of the volumetric heat generation (RPL) with respect to the temperature.

Definition at line 92 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDSTRAN

std::vector<Real> AbaqusUMATStress::_aqDSTRAN

protected

Array of strain increments.

If thermal expansion is included in the same material definition, these are the mechanical strain increments (the total strain increments minus the thermal strain increments).

Definition at line 172 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDTEMP

Real AbaqusUMATStress::_aqDTEMP

protected

Increment of temperature.

Definition at line 104 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqDTIME

Real AbaqusUMATStress::_aqDTIME

protected

Time increment.

Definition at line 98 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_aqKINC

int AbaqusUMATStress::_aqKINC

protected

Increment number (_t_step).

This can be supported. The step number (as per Abaqus definition) is not supported by MOOSE.

Definition at line 141 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqKSPT

int AbaqusUMATStress::_aqKSPT

protected

Section point number within the current layer. (not supported)

Definition at line 134 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqKSTEP

int AbaqusUMATStress::_aqKSTEP

protected

The step number (as per Abaqus definition) can be set by the user.

Definition at line 137 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqLAYER

int AbaqusUMATStress::_aqLAYER

protected

Layer number (for composite shells and layered solids). (not supported)

Definition at line 131 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqNDI

int AbaqusUMATStress::_aqNDI

protected

Number of direct stress components at this point.

Definition at line 113 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqNOEL

int AbaqusUMATStress::_aqNOEL

protected

Element number.

Definition at line 125 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_aqNPROPS

int AbaqusUMATStress::_aqNPROPS

protected

User-defined number of material constants associated with this user material.

Definition at line 187 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqNPT

unsigned int AbaqusUMATStress::_aqNPT

protected

Integration point number.

Definition at line 128 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqNSHR

int AbaqusUMATStress::_aqNSHR

protected

Number of engineering shear stress components at this point.

Definition at line 116 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqNSTATV

int AbaqusUMATStress::_aqNSTATV

protected

Number of solution-dependent state variables that are associated with this material type.

Definition at line 122 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initQpStatefulProperties().

_aqNTENS

int AbaqusUMATStress::_aqNTENS

protected

Size of the stress or strain component array (NDI + NSHR).

Definition at line 119 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqPNEWDT

Real AbaqusUMATStress::_aqPNEWDT

protected

Ratio of suggested new time increment to the time increment being used (out)

Definition at line 95 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqPREDEF

std::vector<Real> AbaqusUMATStress::_aqPREDEF

protected

Array of interpolated values of predefined field variables at this point at the start of the increment, based on the values read in at the nodes.

Definition at line 190 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqPROPS

std::vector<Real> AbaqusUMATStress::_aqPROPS

protected

User-specified array of material constants associated with this user material.

Definition at line 175 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqRPL

Real AbaqusUMATStress::_aqRPL

protected

Volumetric heat generation per unit time at the end of the increment caused by mechanical working of the material.

Definition at line 89 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqSTATEV

std::vector<Real> AbaqusUMATStress::_aqSTATEV

protected

Definition at line 144 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqSTRAN

std::vector<Real> AbaqusUMATStress::_aqSTRAN

protected

An array containing the total strains at the beginning of the increment.

Definition at line 153 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqSTRESS

std::vector<Real> AbaqusUMATStress::_aqSTRESS

protected

Stress tensor (in: old stress, out: updated stress)

Definition at line 162 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqTEMP

Real AbaqusUMATStress::_aqTEMP

protected

Temperature at the start of the increment.

Definition at line 101 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_aqTIME

std::array<Real, 2> AbaqusUMATStress::_aqTIME

protected

Value of step time at the beginning of the current increment, total time at the beginning of the current increment.

Definition at line 178 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_base_name

const std::string ComputeGeneralStressBase::_base_name

protectedinherited

Base name prepended to all material property names to allow for multi-material systems.

Definition at line 43 of file ComputeGeneralStressBase.h.

Referenced by ComputeCosseratLinearElasticStress::initialSetup(), and ComputeLinearElasticStress::initialSetup().

_creep_dissipation

MaterialProperty<Real>& AbaqusUMATStress::_creep_dissipation

protected

Definition at line 216 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_creep_dissipation_old

const MaterialProperty<Real>& AbaqusUMATStress::_creep_dissipation_old

protected

Definition at line 217 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_decomposition_method

const ComputeFiniteStrain::DecompMethod AbaqusUMATStress::_decomposition_method

private

Method being used to compute strain and rotation increments.

Definition at line 256 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_elastic_strain

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_elastic_strain

protectedinherited

Elastic strain material property.

Definition at line 50 of file ComputeGeneralStressBase.h.

Referenced by ComputeSmearedCrackingStress::computeCrackStrainAndOrientation(), ComputeMultiPlasticityStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), and ComputeGeneralStressBase::initQpStatefulProperties().

_elastic_strain_energy

MaterialProperty<Real>& AbaqusUMATStress::_elastic_strain_energy

protected

Definition at line 212 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_elastic_strain_energy_old

const MaterialProperty<Real>& AbaqusUMATStress::_elastic_strain_energy_old

protected

Definition at line 213 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_external_field_names

std::vector<VariableName> AbaqusUMATStress::_external_field_names

protected

Definition at line 235 of file AbaqusUMATStress.h.

_external_fields

const std::vector<const VariableValue *> AbaqusUMATStress::_external_fields

protected

Definition at line 231 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_external_fields_old

const std::vector<const VariableValue *> AbaqusUMATStress::_external_fields_old

protected

Definition at line 232 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_external_properties

std::vector<const MaterialProperty<Real> *> AbaqusUMATStress::_external_properties

protected

Definition at line 242 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_external_properties_old

std::vector<const MaterialProperty<Real> *> AbaqusUMATStress::_external_properties_old

protected

Definition at line 243 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_external_property_names

const std::vector<MaterialPropertyName> AbaqusUMATStress::_external_property_names

protected

Definition at line 240 of file AbaqusUMATStress.h.

_extra_stress

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_extra_stress

protectedinherited

Extra stress tensor.

Definition at line 53 of file ComputeGeneralStressBase.h.

Referenced by ComputeGeneralStressBase::computeQpProperties().

_Fbar

const OptionalMaterialProperty<RankTwoTensor>& AbaqusUMATStress::_Fbar

protected

Definition at line 205 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initialSetup().

_Fbar_old

const OptionalMaterialProperty<RankTwoTensor>& AbaqusUMATStress::_Fbar_old

protected

Definition at line 206 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initialSetup().

_initial_stress_fcn

std::vector<const Function *> ComputeGeneralStressBase::_initial_stress_fcn

protectedinherited

initial stress components

Definition at line 56 of file ComputeGeneralStressBase.h.

_jacobian_mult

MaterialProperty<RankFourTensor>& AbaqusUMATStress::_jacobian_mult

protected

Jacobian multiplier.

Definition at line 203 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_Jacobian_mult

MaterialProperty<RankFourTensor>& ComputeGeneralStressBase::_Jacobian_mult

protectedinherited

derivative of stress w.r.t. strain (_dstress_dstrain)

Definition at line 59 of file ComputeGeneralStressBase.h.

Referenced by ComputeStrainIncrementBasedStress::computeQpJacobian(), FiniteStrainHyperElasticViscoPlastic::computeQpJacobian(), ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultiPlasticityStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), ComputeMultipleCrystalPlasticityStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), FiniteStrainUObasedCP::elasticTangentModuli(), FiniteStrainUObasedCP::elastoPlasticTangentModuli(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainCrystalPlasticity::preSolveQp(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_library

DynamicLibraryLoader AbaqusUMATStress::_library

protected

Definition at line 80 of file AbaqusUMATStress.h.

_material_timestep

MaterialProperty<Real>& AbaqusUMATStress::_material_timestep

protected

recommended maximum timestep for this model under the current conditions

Definition at line 220 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_mechanical_strain

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_mechanical_strain

protectedinherited

Mechanical strain material property.

Definition at line 46 of file ComputeGeneralStressBase.h.

Referenced by ComputeStrainIncrementBasedStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), and ComputeLinearElasticPFFractureStress::computeStressSpectral().

_number_external_fields

const std::size_t AbaqusUMATStress::_number_external_fields

protected

Definition at line 238 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_number_external_properties

const std::size_t AbaqusUMATStress::_number_external_properties

protected

Definition at line 241 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_plastic_dissipation

MaterialProperty<Real>& AbaqusUMATStress::_plastic_dissipation

protected

Definition at line 214 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_plastic_dissipation_old

const MaterialProperty<Real>& AbaqusUMATStress::_plastic_dissipation_old

protected

Definition at line 215 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_plugin

FileName AbaqusUMATStress::_plugin

protected

Definition at line 77 of file AbaqusUMATStress.h.

_R

const RotationTensor AbaqusUMATStress::_R

protected

Definition at line 250 of file AbaqusUMATStress.h.

Referenced by initQpStatefulProperties().

_rotation_increment

const OptionalMaterialProperty<RankTwoTensor>& AbaqusUMATStress::_rotation_increment

protected

Definition at line 223 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initialSetup().

_rotation_increment_old

const OptionalMaterialProperty<RankTwoTensor>& AbaqusUMATStress::_rotation_increment_old

protected

Definition at line 224 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_state_var

MaterialProperty<std::vector<Real> >& AbaqusUMATStress::_state_var

protected

Definition at line 208 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initQpStatefulProperties().

_state_var_old

const MaterialProperty<std::vector<Real> >& AbaqusUMATStress::_state_var_old

protected

Definition at line 209 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_step_user_object

const AnalysisStepUserObject* AbaqusUMATStress::_step_user_object

private

User object that determines step number.

Definition at line 259 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and initialSetup().

_strain_increment

const OptionalMaterialProperty<RankTwoTensor>& AbaqusUMATStress::_strain_increment

protected

Definition at line 200 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initialSetup().

_stress

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_stress

protectedinherited

Stress material property.

Definition at line 48 of file ComputeGeneralStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticCosseratStress::computeAdmissibleState(), ComputeGeneralStressBase::computeQpProperties(), ComputeMultiPlasticityStress::computeQpStress(), ComputeStrainIncrementBasedStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), ComputeMultipleCrystalPlasticityStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), ComputeCreepPlasticityStress::computeTangentOperators(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), FiniteStrainCrystalPlasticity::initQpStatefulProperties(), FiniteStrainUObasedCP::initQpStatefulProperties(), FiniteStrainHyperElasticViscoPlastic::initQpStatefulProperties(), ComputeGeneralStressBase::initQpStatefulProperties(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainUObasedCP::postSolveQp(), FiniteStrainHyperElasticViscoPlastic::postSolveQp(), ComputeSmearedCrackingStress::updateCrackingStateAndStress(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_stress_old

const MaterialProperty<RankTwoTensor>& AbaqusUMATStress::_stress_old

protected

Definition at line 198 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_temperature

const VariableValue& AbaqusUMATStress::_temperature

protected

Definition at line 227 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_temperature_old

const VariableValue& AbaqusUMATStress::_temperature_old

protected

Definition at line 228 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_total_rotation

MaterialProperty<RankTwoTensor>& AbaqusUMATStress::_total_rotation

protected

Definition at line 251 of file AbaqusUMATStress.h.

Referenced by computeQpStress(), and initQpStatefulProperties().

_total_rotation_old

const MaterialProperty<RankTwoTensor>& AbaqusUMATStress::_total_rotation_old

protected

Definition at line 252 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_total_strain_old

const MaterialProperty<RankTwoTensor>& AbaqusUMATStress::_total_strain_old

protected

Definition at line 199 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_umat

umat_t AbaqusUMATStress::_umat

protected

Definition at line 83 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

_use_one_based_indexing

const bool AbaqusUMATStress::_use_one_based_indexing

protected

parameter to assist with the transition to 1-based indexing

Definition at line 246 of file AbaqusUMATStress.h.

Referenced by computeProperties(), and computeQpStress().

_use_orientation

const bool AbaqusUMATStress::_use_orientation

protected

Rotation information.

Definition at line 249 of file AbaqusUMATStress.h.

Referenced by computeQpStress().

---

The documentation for this class was generated from the following files:

• solid_mechanics/include/materials/abaqus/AbaqusUMATStress.h
• solid_mechanics/src/materials/abaqus/AbaqusUMATStress.C