InteractionIntegral Class Reference

This postprocessor computes the Interaction Integral. More...

#include <InteractionIntegral.h>

Inheritance diagram for InteractionIntegral:

Public Member Functions
	InteractionIntegral (const InputParameters &parameters)
virtual Real	getValue ()

Static Public Member Functions
static InputParameters	validParams ()
static MooseEnum	qFunctionType ()
static MooseEnum	sifModeType ()

Protected Member Functions
virtual void	initialSetup ()
virtual Real	computeQpIntegral ()
virtual Real	computeIntegral ()
void	computeAuxFields (RankTwoTensor &aux_stress, RankTwoTensor &grad_disp)
void	computeTFields (RankTwoTensor &aux_stress, RankTwoTensor &grad_disp)

Protected Attributes
unsigned int	_ndisp
const CrackFrontDefinition *const	_crack_front_definition
bool	_has_crack_front_point_index
const unsigned int	_crack_front_point_index
bool	_treat_as_2d
const MaterialProperty< RankTwoTensor > *	_stress
const MaterialProperty< RankTwoTensor > *	_strain
std::vector< const VariableGradient * >	_grad_disp
const bool	_has_temp
const VariableGradient &	_grad_temp
Real	_K_factor
bool	_has_symmetry_plane
Real	_poissons_ratio
Real	_youngs_modulus
unsigned int	_ring_index
const MaterialProperty< RankTwoTensor > *	_total_deigenstrain_dT
std::vector< Real >	_q_curr_elem
const std::vector< std::vector< Real > > *	_phi_curr_elem
const std::vector< std::vector< RealGradient > > *	_dphi_curr_elem
Real	_kappa
Real	_shear_modulus
Real	_r
Real	_theta

Private Types
enum	QMethod { QMethod::Geometry, QMethod::Topology }
enum	SifMethod { SifMethod::KI, SifMethod::KII, SifMethod::KIII, SifMethod::T }

Private Attributes
const QMethod	_q_function_type
const SifMethod	_sif_mode

Detailed Description

This postprocessor computes the Interaction Integral.

Definition at line 28 of file InteractionIntegral.h.

Member Enumeration Documentation

QMethod

enum InteractionIntegral::QMethod

strongprivate

Enumerator
Geometry
Topology

Definition at line 71 of file InteractionIntegral.h.

  {
    Geometry,
    Topology
  };

SifMethod

enum InteractionIntegral::SifMethod

strongprivate

Enumerator
KI
KII
KIII
T

Definition at line 79 of file InteractionIntegral.h.

  {
    KI,
    KII,
    KIII,
    T
  };

Constructor & Destructor Documentation

InteractionIntegral()

InteractionIntegral::InteractionIntegral

(

const InputParameters &

parameters

)

Definition at line 76 of file InteractionIntegral.C.

  : ElementIntegralPostprocessor(parameters),
    _ndisp(coupledComponents("displacements")),
    _crack_front_definition(&getUserObject<CrackFrontDefinition>("crack_front_definition")),
    _has_crack_front_point_index(isParamValid("crack_front_point_index")),
    _crack_front_point_index(
        _has_crack_front_point_index ? getParam<unsigned int>("crack_front_point_index") : 0),
    _treat_as_2d(false),
    _stress(hasMaterialProperty<RankTwoTensor>("stress")
                ? &getMaterialPropertyByName<RankTwoTensor>("stress")
                : nullptr),
    _strain(hasMaterialProperty<RankTwoTensor>("elastic_strain")
                ? &getMaterialPropertyByName<RankTwoTensor>("elastic_strain")
                : nullptr),
    _grad_disp(3),
    _has_temp(isCoupled("temperature")),
    _grad_temp(_has_temp ? coupledGradient("temperature") : _grad_zero),
    _K_factor(getParam<Real>("K_factor")),
    _has_symmetry_plane(isParamValid("symmetry_plane")),
    _poissons_ratio(getParam<Real>("poissons_ratio")),
    _youngs_modulus(getParam<Real>("youngs_modulus")),
    _ring_index(getParam<unsigned int>("ring_index")),
    _total_deigenstrain_dT(hasMaterialProperty<RankTwoTensor>("total_deigenstrain_dT")
                               ? &getMaterialProperty<RankTwoTensor>("total_deigenstrain_dT")
                               : nullptr),
    _q_function_type(getParam<MooseEnum>("q_function_type").getEnum<QMethod>()),
    _sif_mode(getParam<MooseEnum>("sif_mode").getEnum<SifMethod>())
{
  if (!hasMaterialProperty<RankTwoTensor>("stress"))
    mooseError("InteractionIntegral Error: RankTwoTensor material property 'stress' not found. "
               "This may be because solid mechanics system is being used to calculate a SymmTensor "
               "'stress' material property. To use interaction integral calculation with solid "
               "mechanics application, please set 'solid_mechanics = true' in the DomainIntegral "
               "block.");
 
  if (!hasMaterialProperty<RankTwoTensor>("elastic_strain"))
    mooseError("InteractionIntegral Error: RankTwoTensor material property 'elastic_strain' not "
               "found. This may be because solid mechanics system is being used to calculate a "
               "SymmTensor 'elastic_strain' material property. To use interaction integral "
               "calculation with solid mechanics application, please set 'solid_mechanics = true' "
               "in the DomainIntegral block.");
 
  if (_has_temp && !_total_deigenstrain_dT)
    mooseError("InteractionIntegral Error: To include thermal strain term in interaction integral, "
               "must both couple temperature in DomainIntegral block and compute "
               "total_deigenstrain_dT using ThermalFractureIntegral material model.");
 
  // plane strain
  _kappa = 3.0 - 4.0 * _poissons_ratio;
  _shear_modulus = _youngs_modulus / (2.0 * (1.0 + _poissons_ratio));
 
  // Checking for consistency between mesh size and length of the provided displacements vector
  if (_ndisp != _mesh.dimension())
    mooseError("InteractionIntegral Error: number of variables supplied in 'displacements' must "
               "match the mesh dimension.");
 
  // fetch gradients of coupled variables
  for (unsigned int i = 0; i < _ndisp; ++i)
    _grad_disp[i] = &coupledGradient("displacements", i);
 
  // set unused dimensions to zero
  for (unsigned i = _ndisp; i < 3; ++i)
    _grad_disp[i] = &_grad_zero;
}

Member Function Documentation

computeAuxFields()

void InteractionIntegral::computeAuxFields ( RankTwoTensor &  aux_stress, RankTwoTensor &  grad_disp  )

protected

Definition at line 291 of file InteractionIntegral.C.

{
  RealVectorValue k(0.0);
  if (_sif_mode == SifMethod::KI)
    k(0) = 1.0;
  else if (_sif_mode == SifMethod::KII)
    k(1) = 1.0;
  else if (_sif_mode == SifMethod::KIII)
    k(2) = 1.0;
 
  Real t = _theta;
  Real t2 = _theta / 2.0;
  Real tt2 = 3.0 * _theta / 2.0;
  Real st = std::sin(t);
  Real ct = std::cos(t);
  Real st2 = std::sin(t2);
  Real ct2 = std::cos(t2);
  Real stt2 = std::sin(tt2);
  Real ctt2 = std::cos(tt2);
  Real ct2sq = Utility::pow<2>(ct2);
  Real ct2cu = Utility::pow<3>(ct2);
  Real sqrt2PiR = std::sqrt(2.0 * libMesh::pi * _r);
 
  // Calculate auxiliary stress tensor
  aux_stress.zero();
 
  aux_stress(0, 0) =
      1.0 / sqrt2PiR * (k(0) * ct2 * (1.0 - st2 * stt2) - k(1) * st2 * (2.0 + ct2 * ctt2));
  aux_stress(1, 1) = 1.0 / sqrt2PiR * (k(0) * ct2 * (1.0 + st2 * stt2) + k(1) * st2 * ct2 * ctt2);
  aux_stress(0, 1) = 1.0 / sqrt2PiR * (k(0) * ct2 * st2 * ctt2 + k(1) * ct2 * (1.0 - st2 * stt2));
  aux_stress(0, 2) = -1.0 / sqrt2PiR * k(2) * st2;
  aux_stress(1, 2) = 1.0 / sqrt2PiR * k(2) * ct2;
  // plane stress
  // Real s33 = 0;
  // plane strain
  aux_stress(2, 2) = _poissons_ratio * (aux_stress(0, 0) + aux_stress(1, 1));
 
  aux_stress(1, 0) = aux_stress(0, 1);
  aux_stress(2, 0) = aux_stress(0, 2);
  aux_stress(2, 1) = aux_stress(1, 2);
 
  // Calculate x1 derivative of auxiliary displacements
  grad_disp.zero();
 
  grad_disp(0, 0) = k(0) / (4.0 * _shear_modulus * sqrt2PiR) *
                        (ct * ct2 * _kappa + ct * ct2 - 2.0 * ct * ct2cu + st * st2 * _kappa +
                         st * st2 - 6.0 * st * st2 * ct2sq) +
                    k(1) / (4.0 * _shear_modulus * sqrt2PiR) *
                        (ct * st2 * _kappa + ct * st2 + 2.0 * ct * st2 * ct2sq - st * ct2 * _kappa +
                         3.0 * st * ct2 - 6.0 * st * ct2cu);
 
  grad_disp(0, 1) = k(0) / (4.0 * _shear_modulus * sqrt2PiR) *
                        (ct * st2 * _kappa + ct * st2 - 2.0 * ct * st2 * ct2sq - st * ct2 * _kappa -
                         5.0 * st * ct2 + 6.0 * st * ct2cu) +
                    k(1) / (4.0 * _shear_modulus * sqrt2PiR) *
                        (-ct * ct2 * _kappa + 3.0 * ct * ct2 - 2.0 * ct * ct2cu -
                         st * st2 * _kappa + 3.0 * st * st2 - 6.0 * st * st2 * ct2sq);
 
  grad_disp(0, 2) = k(2) / (_shear_modulus * sqrt2PiR) * (st2 * ct - ct2 * st);
}

Referenced by computeQpIntegral().

computeIntegral()

Real InteractionIntegral::computeIntegral ( )

protectedvirtual

Definition at line 252 of file InteractionIntegral.C.

{
  Real sum = 0.0;
 
  // calculate phi and dphi for this element
  FEType fe_type(Utility::string_to_enum<Order>("first"),
                 Utility::string_to_enum<FEFamily>("lagrange"));
  const unsigned int dim = _current_elem->dim();
  std::unique_ptr<FEBase> fe(FEBase::build(dim, fe_type));
  fe->attach_quadrature_rule(const_cast<QBase *>(_qrule));
  _phi_curr_elem = &fe->get_phi();
  _dphi_curr_elem = &fe->get_dphi();
  fe->reinit(_current_elem);
 
  // calculate q for all nodes in this element
  _q_curr_elem.clear();
  unsigned int ring_base = (_q_function_type == QMethod::Topology) ? 0 : 1;
 
  for (unsigned int i = 0; i < _current_elem->n_nodes(); ++i)
  {
    const Node * this_node = _current_elem->node_ptr(i);
    Real q_this_node;
 
    if (_q_function_type == QMethod::Geometry)
      q_this_node = _crack_front_definition->DomainIntegralQFunction(
          _crack_front_point_index, _ring_index - ring_base, this_node);
    else if (_q_function_type == QMethod::Topology)
      q_this_node = _crack_front_definition->DomainIntegralTopologicalQFunction(
          _crack_front_point_index, _ring_index - ring_base, this_node);
 
    _q_curr_elem.push_back(q_this_node);
  }
 
  for (_qp = 0; _qp < _qrule->n_points(); _qp++)
    sum += _JxW[_qp] * _coord[_qp] * computeQpIntegral();
  return sum;
}

computeQpIntegral()

Real InteractionIntegral::computeQpIntegral ( )

protectedvirtual

Definition at line 160 of file InteractionIntegral.C.

{
  Real scalar_q = 0.0;
  RealVectorValue grad_q(0.0, 0.0, 0.0);
 
  const std::vector<std::vector<Real>> & phi_curr_elem = *_phi_curr_elem;
  const std::vector<std::vector<RealGradient>> & dphi_curr_elem = *_dphi_curr_elem;
 
  for (unsigned int i = 0; i < _current_elem->n_nodes(); ++i)
  {
    scalar_q += phi_curr_elem[i][_qp] * _q_curr_elem[i];
 
    for (unsigned int j = 0; j < _current_elem->dim(); ++j)
      grad_q(j) += dphi_curr_elem[i][_qp](j) * _q_curr_elem[i];
  }
 
  // In the crack front coordinate system, the crack direction is (1,0,0)
  RealVectorValue crack_direction(0.0);
  crack_direction(0) = 1.0;
 
  // Calculate (r,theta) position of qp relative to crack front
  Point p(_q_point[_qp]);
  _crack_front_definition->calculateRThetaToCrackFront(p, _crack_front_point_index, _r, _theta);
 
  RankTwoTensor aux_stress;
  RankTwoTensor aux_du;
 
  if (_sif_mode == SifMethod::KI || _sif_mode == SifMethod::KII || _sif_mode == SifMethod::KIII)
    computeAuxFields(aux_stress, aux_du);
  else if (_sif_mode == SifMethod::T)
    computeTFields(aux_stress, aux_du);
 
  RankTwoTensor grad_disp((*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]);
 
  // Rotate stress, strain, displacement and temperature to crack front coordinate system
  RealVectorValue grad_q_cf =
      _crack_front_definition->rotateToCrackFrontCoords(grad_q, _crack_front_point_index);
  RankTwoTensor grad_disp_cf =
      _crack_front_definition->rotateToCrackFrontCoords(grad_disp, _crack_front_point_index);
  RankTwoTensor stress_cf =
      _crack_front_definition->rotateToCrackFrontCoords((*_stress)[_qp], _crack_front_point_index);
  RankTwoTensor strain_cf =
      _crack_front_definition->rotateToCrackFrontCoords((*_strain)[_qp], _crack_front_point_index);
  RealVectorValue grad_temp_cf =
      _crack_front_definition->rotateToCrackFrontCoords(_grad_temp[_qp], _crack_front_point_index);
 
  RankTwoTensor dq;
  dq(0, 0) = crack_direction(0) * grad_q_cf(0);
  dq(0, 1) = crack_direction(0) * grad_q_cf(1);
  dq(0, 2) = crack_direction(0) * grad_q_cf(2);
 
  // Calculate interaction integral terms
 
  // Term1 = stress * x1-derivative of aux disp * dq
  RankTwoTensor tmp1 = dq * stress_cf;
  Real term1 = aux_du.doubleContraction(tmp1);
 
  // Term2 = aux stress * x1-derivative of disp * dq
  RankTwoTensor tmp2 = dq * aux_stress;
  Real term2 = grad_disp_cf(0, 0) * tmp2(0, 0) + grad_disp_cf(1, 0) * tmp2(0, 1) +
               grad_disp_cf(2, 0) * tmp2(0, 2);
 
  // Term3 = aux stress * strain * dq_x   (= stress * aux strain * dq_x)
  Real term3 = dq(0, 0) * aux_stress.doubleContraction(strain_cf);
 
  // Term4 (thermal strain term) = q * aux_stress * alpha * dtheta_x
  // - the term including the derivative of alpha is not implemented
  Real term4 = 0.0;
  if (_has_temp)
  {
    Real sigma_alpha = aux_stress.doubleContraction((*_total_deigenstrain_dT)[_qp]);
    term4 = scalar_q * sigma_alpha * grad_temp_cf(0);
  }
 
  Real q_avg_seg = 1.0;
  if (!_crack_front_definition->treatAs2D())
  {
    q_avg_seg =
        (_crack_front_definition->getCrackFrontForwardSegmentLength(_crack_front_point_index) +
         _crack_front_definition->getCrackFrontBackwardSegmentLength(_crack_front_point_index)) /
        2.0;
  }
 
  Real eq = term1 + term2 - term3 + term4;
 
  if (_has_symmetry_plane)
    eq *= 2.0;
 
  return eq / q_avg_seg;
}

Referenced by computeIntegral().

computeTFields()

void InteractionIntegral::computeTFields ( RankTwoTensor &  aux_stress, RankTwoTensor &  grad_disp  )

protected

Definition at line 353 of file InteractionIntegral.C.

{
 
  Real t = _theta;
  Real st = std::sin(t);
  Real ct = std::cos(t);
  Real stsq = Utility::pow<2>(st);
  Real ctsq = Utility::pow<2>(ct);
  Real ctcu = Utility::pow<3>(ct);
  Real oneOverPiR = 1.0 / (libMesh::pi * _r);
 
  aux_stress.zero();
  aux_stress(0, 0) = -oneOverPiR * ctcu;
  aux_stress(0, 1) = -oneOverPiR * st * ctsq;
  aux_stress(1, 0) = -oneOverPiR * st * ctsq;
  aux_stress(1, 1) = -oneOverPiR * ct * stsq;
  aux_stress(2, 2) = -oneOverPiR * _poissons_ratio * (ctcu + ct * stsq);
 
  grad_disp.zero();
  grad_disp(0, 0) = oneOverPiR / (4.0 * _youngs_modulus) *
                    (ct * (4.0 * Utility::pow<2>(_poissons_ratio) - 3.0 + _poissons_ratio) -
                     std::cos(3.0 * t) * (1.0 + _poissons_ratio));
  grad_disp(0, 1) = -oneOverPiR / (4.0 * _youngs_modulus) *
                    (st * (4.0 * Utility::pow<2>(_poissons_ratio) - 3.0 + _poissons_ratio) +
                     std::sin(3.0 * t) * (1.0 + _poissons_ratio));
}

Referenced by computeQpIntegral().

getValue()

Real InteractionIntegral::getValue ( )

virtual

Definition at line 148 of file InteractionIntegral.C.

{
  gatherSum(_integral_value);
 
  if (_sif_mode == SifMethod::T && !_treat_as_2d)
    _integral_value += _poissons_ratio * _crack_front_definition->getCrackFrontTangentialStrain(
                                             _crack_front_point_index);
 
  return _K_factor * _integral_value;
}

initialSetup()

void InteractionIntegral::initialSetup ( )

protectedvirtual

Definition at line 142 of file InteractionIntegral.C.

{
  _treat_as_2d = _crack_front_definition->treatAs2D();
}

qFunctionType()

MooseEnum InteractionIntegral::qFunctionType ( )

static

Definition at line 21 of file InteractionIntegral.C.

{
  return MooseEnum("Geometry Topology", "Geometry");
}

Referenced by validParams().

sifModeType()

MooseEnum InteractionIntegral::sifModeType ( )

static

Definition at line 27 of file InteractionIntegral.C.

{
  return MooseEnum("KI KII KIII T", "KI");
}

Referenced by validParams().

validParams()

InputParameters InteractionIntegral::validParams ( )

static

Definition at line 37 of file InteractionIntegral.C.

{
  InputParameters params = ElementIntegralPostprocessor::validParams();
  params.addClassDescription("Computes the interaction integral for fracture");
  params.addRequiredCoupledVar(
      "displacements",
      "The displacements appropriate for the simulation geometry and coordinate system");
  params.addCoupledVar("temperature",
                       "The temperature (optional). Must be provided to correctly compute "
                       "stress intensity factors in models with thermal strain gradients.");
  params.addRequiredParam<UserObjectName>("crack_front_definition",
                                          "The CrackFrontDefinition user object name");
  params.addParam<unsigned int>(
      "crack_front_point_index",
      "The index of the point on the crack front corresponding to this q function");
  params.addParam<Real>(
      "K_factor", "Conversion factor between interaction integral and stress intensity factor K");
  params.addParam<unsigned int>("symmetry_plane",
                                "Account for a symmetry plane passing through "
                                "the plane of the crack, normal to the specified "
                                "axis (0=x, 1=y, 2=z)");
  params.addParam<Real>("poissons_ratio", "Poisson's ratio for the material.");
  params.addParam<Real>("youngs_modulus", "Young's modulus of the material.");
  params.set<bool>("use_displaced_mesh") = false;
  params.addParam<unsigned int>("ring_first",
                                "The first ring of elements for volume integral domain");
  params.addParam<unsigned int>("ring_index", "Ring ID");
  params.addParam<MooseEnum>("q_function_type",
                             InteractionIntegral::qFunctionType(),
                             "The method used to define the integration domain. Options are: " +
                                 InteractionIntegral::qFunctionType().getRawNames());
  params.addRequiredParam<MooseEnum>("sif_mode",
                                     InteractionIntegral::sifModeType(),
                                     "Stress intensity factor to calculate. Choices are: " +
                                         InteractionIntegral::sifModeType().getRawNames());
 
  return params;
}

Member Data Documentation

_crack_front_definition

const CrackFrontDefinition* const InteractionIntegral::_crack_front_definition

protected

Definition at line 47 of file InteractionIntegral.h.

Referenced by computeIntegral(), computeQpIntegral(), getValue(), and initialSetup().

_crack_front_point_index

const unsigned int InteractionIntegral::_crack_front_point_index

protected

Definition at line 49 of file InteractionIntegral.h.

Referenced by computeIntegral(), computeQpIntegral(), and getValue().

_dphi_curr_elem

const std::vector<std::vector<RealGradient> >* InteractionIntegral::_dphi_curr_elem

protected

Definition at line 64 of file InteractionIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

_grad_disp

std::vector<const VariableGradient *> InteractionIntegral::_grad_disp

protected

Definition at line 53 of file InteractionIntegral.h.

Referenced by computeQpIntegral(), and InteractionIntegral().

_grad_temp

const VariableGradient& InteractionIntegral::_grad_temp

protected

Definition at line 55 of file InteractionIntegral.h.

Referenced by computeQpIntegral().

_has_crack_front_point_index

bool InteractionIntegral::_has_crack_front_point_index

protected

Definition at line 48 of file InteractionIntegral.h.

_has_symmetry_plane

bool InteractionIntegral::_has_symmetry_plane

protected

Definition at line 57 of file InteractionIntegral.h.

Referenced by computeQpIntegral().

_has_temp

const bool InteractionIntegral::_has_temp

protected

Definition at line 54 of file InteractionIntegral.h.

Referenced by computeQpIntegral(), and InteractionIntegral().

_K_factor

Real InteractionIntegral::_K_factor

protected

Definition at line 56 of file InteractionIntegral.h.

Referenced by getValue().

_kappa

Real InteractionIntegral::_kappa

protected

Definition at line 65 of file InteractionIntegral.h.

Referenced by computeAuxFields(), and InteractionIntegral().

_ndisp

unsigned int InteractionIntegral::_ndisp

protected

Definition at line 46 of file InteractionIntegral.h.

Referenced by InteractionIntegral().

_phi_curr_elem

const std::vector<std::vector<Real> >* InteractionIntegral::_phi_curr_elem

protected

Definition at line 63 of file InteractionIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

_poissons_ratio

Real InteractionIntegral::_poissons_ratio

protected

Definition at line 58 of file InteractionIntegral.h.

Referenced by computeAuxFields(), computeTFields(), getValue(), and InteractionIntegral().

_q_curr_elem

std::vector<Real> InteractionIntegral::_q_curr_elem

protected

Definition at line 62 of file InteractionIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

_q_function_type

const QMethod InteractionIntegral::_q_function_type

private

Definition at line 77 of file InteractionIntegral.h.

Referenced by computeIntegral().

_r

Real InteractionIntegral::_r

protected

Definition at line 67 of file InteractionIntegral.h.

Referenced by computeAuxFields(), computeQpIntegral(), and computeTFields().

_ring_index

unsigned int InteractionIntegral::_ring_index

protected

Definition at line 60 of file InteractionIntegral.h.

Referenced by computeIntegral().

_shear_modulus

Real InteractionIntegral::_shear_modulus

protected

Definition at line 66 of file InteractionIntegral.h.

Referenced by computeAuxFields(), and InteractionIntegral().

_sif_mode

const SifMethod InteractionIntegral::_sif_mode

private

Definition at line 87 of file InteractionIntegral.h.

Referenced by computeAuxFields(), computeQpIntegral(), and getValue().

_strain

const MaterialProperty<RankTwoTensor>* InteractionIntegral::_strain

protected

Definition at line 52 of file InteractionIntegral.h.

Referenced by computeQpIntegral().

_stress

const MaterialProperty<RankTwoTensor>* InteractionIntegral::_stress

protected

Definition at line 51 of file InteractionIntegral.h.

Referenced by computeQpIntegral().

_theta

Real InteractionIntegral::_theta

protected

Definition at line 68 of file InteractionIntegral.h.

Referenced by computeAuxFields(), computeQpIntegral(), and computeTFields().

_total_deigenstrain_dT

const MaterialProperty<RankTwoTensor>* InteractionIntegral::_total_deigenstrain_dT

protected

Definition at line 61 of file InteractionIntegral.h.

Referenced by computeQpIntegral(), and InteractionIntegral().

_treat_as_2d

bool InteractionIntegral::_treat_as_2d

protected

Definition at line 50 of file InteractionIntegral.h.

Referenced by getValue(), and initialSetup().

_youngs_modulus

Real InteractionIntegral::_youngs_modulus

protected

Definition at line 59 of file InteractionIntegral.h.

Referenced by computeTFields(), and InteractionIntegral().

---

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

• tensor_mechanics/include/postprocessors/InteractionIntegral.h
• tensor_mechanics/src/postprocessors/InteractionIntegral.C