ADComputeStrainBase< compute_stage > Class Template Reference

ADADComputeStrainBase is the base class for strain tensors. More...

#include <ADComputeStrainBase.h>

Inheritance diagram for ADComputeStrainBase< compute_stage >:

Public Member Functions
	ADComputeStrainBase (const InputParameters &parameters)
void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initQpStatefulProperties () override
virtual void	displacementIntegrityCheck ()
	ADMaterialProperty (RankTwoTensor) &_mechanical_strain
	ADMaterialProperty (RankTwoTensor) &_total_strain
const	ADMaterialProperty (RankTwoTensor) *_global_strain

Protected Attributes
const unsigned int	_ndisp
	Coupled displacement variables. More...
std::vector< const ADVariableValue * >	_disp
std::vector< const ADVariableGradient * >	_grad_disp
const std::string	_base_name
std::vector< MaterialPropertyName >	_eigenstrain_names
std::vector< const ADMaterialProperty(RankTwoTensor) * >	_eigenstrains
const bool	_volumetric_locking_correction
const Real &	_current_elem_volume
	usingMaterialMembers

Detailed Description

template<ComputeStage compute_stage>
class ADComputeStrainBase< compute_stage >

ADADComputeStrainBase is the base class for strain tensors.

Definition at line 30 of file ADComputeStrainBase.h.

Constructor & Destructor Documentation

ADComputeStrainBase()

template<ComputeStage compute_stage>

ADComputeStrainBase< compute_stage >::ADComputeStrainBase

(

const InputParameters &

parameters

)

Definition at line 41 of file ADComputeStrainBase.C.

  : ADMaterial<compute_stage>(parameters),
    _ndisp(coupledComponents("displacements")),
    _disp(3),
    _grad_disp(3),
    _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
    _mechanical_strain(declareADProperty<RankTwoTensor>(_base_name + "mechanical_strain")),
    _total_strain(declareADProperty<RankTwoTensor>(_base_name + "total_strain")),
    _eigenstrain_names(getParam<std::vector<MaterialPropertyName>>("eigenstrain_names")),
    _eigenstrains(_eigenstrain_names.size()),
    _global_strain(isParamValid("global_strain")
                       ? &getADMaterialProperty<RankTwoTensor>(_base_name + "global_strain")
                       : nullptr),
    _volumetric_locking_correction(getParam<bool>("volumetric_locking_correction") &&
                                   !this->isBoundaryMaterial()),
    _current_elem_volume(_assembly.elemVolume())
{
  for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
  {
    _eigenstrain_names[i] = _base_name + _eigenstrain_names[i];
    _eigenstrains[i] = &getADMaterialProperty<RankTwoTensor>(_eigenstrain_names[i]);
  }
 
  if (_ndisp == 1 && _volumetric_locking_correction)
    paramError("volumetric_locking_correction", "has to be set to false for 1-D problems.");
 
  if (getParam<bool>("use_displaced_mesh"))
    paramError("use_displaced_mesh", "The strain calculator needs to run on the undisplaced mesh.");
}

Member Function Documentation

ADMaterialProperty() [1/3]

template<ComputeStage compute_stage>

ADComputeStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor  ) &

protected

ADMaterialProperty() [2/3]

template<ComputeStage compute_stage>

ADComputeStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor  ) &

protected

ADMaterialProperty() [3/3]

template<ComputeStage compute_stage>

const ADComputeStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor  )

protected

displacementIntegrityCheck()

template<ComputeStage compute_stage>

void ADComputeStrainBase< compute_stage >::displacementIntegrityCheck ( )

protectedvirtual

Reimplemented in ADCompute2DFiniteStrain< compute_stage >, ADCompute2DIncrementalStrain< compute_stage >, and ADCompute2DSmallStrain< compute_stage >.

Definition at line 93 of file ADComputeStrainBase.C.

{
  // Checking for consistency between mesh size and length of the provided displacements vector
  if (_ndisp != _mesh.dimension())
    paramError(
        "displacements",
        "The number of variables supplied in 'displacements' must match the mesh dimension.");
}

initialSetup()

template<ComputeStage compute_stage>

void ADComputeStrainBase< compute_stage >::initialSetup ( )

override

Definition at line 73 of file ADComputeStrainBase.C.

{
  displacementIntegrityCheck();
  // fetch coupled variables and gradients (as stateful properties if necessary)
  for (unsigned int i = 0; i < _ndisp; ++i)
  {
    _disp[i] = &adCoupledValue("displacements", i);
    _grad_disp[i] = &adCoupledGradient("displacements", i);
  }
 
  // set unused dimensions to zero
  for (unsigned i = _ndisp; i < 3; ++i)
  {
    _disp[i] = &adZeroValue();
    _grad_disp[i] = &adZeroGradient();
  }
}

Referenced by ADComputeIncrementalStrainBase< compute_stage >::initialSetup().

initQpStatefulProperties()

template<ComputeStage compute_stage>

void ADComputeStrainBase< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented in ADComputeIncrementalStrainBase< compute_stage >.

Definition at line 104 of file ADComputeStrainBase.C.

{
  _mechanical_strain[_qp].zero();
  _total_strain[_qp].zero();
}

validParams()

template<ComputeStage compute_stage>

InputParameters ADComputeStrainBase< compute_stage >::validParams ( )

static

Definition at line 19 of file ADComputeStrainBase.C.

{
  InputParameters params = ADMaterial<compute_stage>::validParams();
  params.addRequiredCoupledVar(
      "displacements",
      "The displacements appropriate for the simulation geometry and coordinate system");
  params.addParam<std::string>("base_name",
                               "Optional parameter that allows the user to define "
                               "multiple mechanics material systems on the same "
                               "block, i.e. for multiple phases");
  params.addParam<bool>(
      "volumetric_locking_correction", false, "Flag to correct volumetric locking");
  params.addParam<std::vector<MaterialPropertyName>>(
      "eigenstrain_names", "List of eigenstrains to be applied in this strain calculation");
  params.addParam<MaterialPropertyName>("global_strain",
                                        "Optional material property holding a global strain "
                                        "tensor applied to the mesh as a whole");
  params.suppressParameter<bool>("use_displaced_mesh");
  return params;
}

Referenced by ADComputeGreenLagrangeStrain< compute_stage >::validParams(), ADComputeSmallStrain< compute_stage >::validParams(), and ADComputeIncrementalStrainBase< compute_stage >::validParams().

Member Data Documentation

_base_name

template<ComputeStage compute_stage>

const std::string ADComputeStrainBase< compute_stage >::_base_name

protected

Definition at line 60 of file ADComputeStrainBase.h.

Referenced by ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

_current_elem_volume

template<ComputeStage compute_stage>

const Real& ADComputeStrainBase< compute_stage >::_current_elem_volume

protected

Definition at line 71 of file ADComputeStrainBase.h.

_disp

template<ComputeStage compute_stage>

std::vector<const ADVariableValue *> ADComputeStrainBase< compute_stage >::_disp

protected

Definition at line 57 of file ADComputeStrainBase.h.

_eigenstrain_names

template<ComputeStage compute_stage>

std::vector<MaterialPropertyName> ADComputeStrainBase< compute_stage >::_eigenstrain_names

protected

Definition at line 65 of file ADComputeStrainBase.h.

Referenced by ADComputeIncrementalStrainBase< compute_stage >::ADComputeIncrementalStrainBase(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

_eigenstrains

template<ComputeStage compute_stage>

std::vector<const ADMaterialProperty(RankTwoTensor) *> ADComputeStrainBase< compute_stage >::_eigenstrains

protected

Definition at line 66 of file ADComputeStrainBase.h.

Referenced by ADComputeGreenLagrangeStrain< compute_stage >::ADComputeGreenLagrangeStrain(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

_grad_disp

template<ComputeStage compute_stage>

std::vector<const ADVariableGradient *> ADComputeStrainBase< compute_stage >::_grad_disp

protected

Definition at line 58 of file ADComputeStrainBase.h.

_ndisp

template<ComputeStage compute_stage>

const unsigned int ADComputeStrainBase< compute_stage >::_ndisp

protected

Coupled displacement variables.

Definition at line 56 of file ADComputeStrainBase.h.

Referenced by ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

_volumetric_locking_correction

template<ComputeStage compute_stage>

const bool ADComputeStrainBase< compute_stage >::_volumetric_locking_correction

protected

Definition at line 70 of file ADComputeStrainBase.h.

Referenced by ADComputeGreenLagrangeStrain< compute_stage >::ADComputeGreenLagrangeStrain(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

usingMaterialMembers

template<ComputeStage compute_stage>

ADComputeStrainBase< compute_stage >::usingMaterialMembers

protected

Definition at line 73 of file ADComputeStrainBase.h.

---

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

• tensor_mechanics/include/materials/ADComputeStrainBase.h
• tensor_mechanics/src/materials/ADComputeStrainBase.C