ComputeInterfaceStress Class Reference

Calculates an Extra-Stress tensor that lies in the plane of an interface defined by the gradient of an order parameter. More...

#include <ComputeInterfaceStress.h>

Inheritance diagram for ComputeInterfaceStress:

Public Member Functions
	ComputeInterfaceStress (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpProperties () override

Protected Attributes
std::size_t	_nvar
std::vector< const VariableGradient * >	_grad_v
std::vector< Real >	_op_range
std::vector< Real >	_stress
MaterialProperty< RankTwoTensor > &	_planar_stress

Detailed Description

Calculates an Extra-Stress tensor that lies in the plane of an interface defined by the gradient of an order parameter.

Definition at line 26 of file ComputeInterfaceStress.h.

Constructor & Destructor Documentation

ComputeInterfaceStress()

ComputeInterfaceStress::ComputeInterfaceStress

(

const InputParameters &

parameters

)

Definition at line 43 of file ComputeInterfaceStress.C.

  : Material(parameters),
    _nvar(coupledComponents("v")),
    _grad_v(_nvar),
    _op_range(getParam<std::vector<Real>>("op_range")),
    _stress(getParam<std::vector<Real>>("stress")),
    _planar_stress(
        declareProperty<RankTwoTensor>(getParam<MaterialPropertyName>("planar_stress_name")))
{
  if (_stress.size() == 1)
    _stress.assign(_nvar, _stress[0]);
  if (_stress.size() != _nvar)
    paramError("stress", "Supply either one single stress or one per order parameter");
 
  if (_op_range.size() == 1)
    _op_range.assign(_nvar, _op_range[0]);
  if (_op_range.size() != _nvar)
    paramError("op_range", "Supply either one single op_range or one per order parameter");
 
  for (MooseIndex(_grad_v) i = 0; i < _nvar; ++i)
  {
    _grad_v[i] = &coupledGradient("v", i);
    _stress[i] /= _op_range[i];
  }
}

Member Function Documentation

computeQpProperties()

void ComputeInterfaceStress::computeQpProperties ( )

overrideprotectedvirtual

Definition at line 70 of file ComputeInterfaceStress.C.

{
  auto & S = _planar_stress[_qp];
  S.zero();
 
  // loop over interface variables
  for (MooseIndex(_grad_v) i = 0; i < _nvar; ++i)
  {
    // compute norm square of the order parameter gradient
    const Real grad_norm_sq = (*_grad_v[i])[_qp].norm_sq();
 
    // gradient square is zero -> no interface -> no interfacial stress contribution
    if (grad_norm_sq < libMesh::TOLERANCE)
      continue;
 
    const Real nx = (*_grad_v[i])[_qp](0);
    const Real ny = (*_grad_v[i])[_qp](1);
    const Real nz = (*_grad_v[i])[_qp](2);
    const Real s = _stress[i] / std::sqrt(grad_norm_sq);
 
    S(0, 0) += (ny * ny + nz * nz) * s;
    S(0, 1) += -nx * ny * s;
    S(1, 1) += (nx * nx + nz * nz) * s;
    S(0, 2) += -nx * nz * s;
    S(1, 2) += -ny * nz * s;
    S(2, 2) += (nx * nx + ny * ny) * s;
  }
 
  // fill in symmetrically
  S(1, 0) = S(0, 1);
  S(2, 0) = S(0, 2);
  S(2, 1) = S(1, 2);
}

validParams()

InputParameters ComputeInterfaceStress::validParams ( )

static

Definition at line 18 of file ComputeInterfaceStress.C.

{
  InputParameters params = Material::validParams();
  params.addClassDescription(
      "Stress in the plane of an interface defined by the gradient of an order parameter");
  params.addCoupledVar("v",
                       "Order parameters that define the interface. The interface is the region "
                       "where the gradient of this order parameter is non-zero.");
  params.addRequiredParam<std::vector<Real>>("stress",
                                             "Interfacial planar stress magnitude (one "
                                             "value to apply to all order parameters or one value "
                                             "per order parameter listed in 'v')");
  params.addRangeCheckedParam<std::vector<Real>>(
      "op_range",
      {1.0},
      "op_range > 0.0",
      "Range over which order parameters change across an "
      "interface. By default order parameters are assumed to "
      "vary from 0 to 1");
  params.addParam<MaterialPropertyName>("planar_stress_name",
                                        "extra_stress",
                                        "Material property name for the interfacial planar stress");
  return params;
}

Member Data Documentation

_grad_v

std::vector<const VariableGradient *> ComputeInterfaceStress::_grad_v

protected

Definition at line 37 of file ComputeInterfaceStress.h.

Referenced by ComputeInterfaceStress(), and computeQpProperties().

_nvar

std::size_t ComputeInterfaceStress::_nvar

protected

Definition at line 36 of file ComputeInterfaceStress.h.

Referenced by ComputeInterfaceStress(), and computeQpProperties().

_op_range

std::vector<Real> ComputeInterfaceStress::_op_range

protected

Definition at line 38 of file ComputeInterfaceStress.h.

Referenced by ComputeInterfaceStress().

_planar_stress

MaterialProperty<RankTwoTensor>& ComputeInterfaceStress::_planar_stress

protected

Definition at line 41 of file ComputeInterfaceStress.h.

Referenced by computeQpProperties().

_stress

std::vector<Real> ComputeInterfaceStress::_stress

protected

Definition at line 39 of file ComputeInterfaceStress.h.

Referenced by ComputeInterfaceStress(), and computeQpProperties().

---

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

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