This postprocessor computes the J-Integral. More...

#include <JIntegral.h>

Inheritance diagram for JIntegral:

Public Member Functions
	JIntegral (const InputParameters &parameters)

virtual Real	getValue ()

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initialSetup ()

virtual Real	computeQpIntegral ()

virtual Real	computeIntegral ()

Protected Attributes
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 > &	_Eshelby_tensor

const MaterialProperty< RealVectorValue > *	_J_thermal_term_vec

bool	_convert_J_to_K

bool	_has_symmetry_plane

Real	_poissons_ratio

Real	_youngs_modulus

unsigned int	_ring_index

unsigned int	_ring_first

MooseEnum	_q_function_type

std::vector< Real >	_q_curr_elem

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

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

Detailed Description

This postprocessor computes the J-Integral.

Definition at line 28 of file JIntegral.h.

Constructor & Destructor Documentation

◆ JIntegral()

JIntegral::JIntegral ( const InputParameters & parameters )

Definition at line 51 of file JIntegral.C.

   : ElementIntegralPostprocessor(parameters),
     _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),
     _Eshelby_tensor(getMaterialProperty<RankTwoTensor>("Eshelby_tensor")),
     _J_thermal_term_vec(hasMaterialProperty<RealVectorValue>("J_thermal_term_vec")
                             ? &getMaterialProperty<RealVectorValue>("J_thermal_term_vec")
                             : NULL),
     _convert_J_to_K(getParam<bool>("convert_J_to_K")),
     _has_symmetry_plane(isParamValid("symmetry_plane")),
     _poissons_ratio(isParamValid("poissons_ratio") ? getParam<Real>("poissons_ratio") : 0),
     _youngs_modulus(isParamValid("youngs_modulus") ? getParam<Real>("youngs_modulus") : 0),
     _ring_index(getParam<unsigned int>("ring_index")),
     _q_function_type(getParam<MooseEnum>("q_function_type"))
 {
   if (_q_function_type == "TOPOLOGY")
     _ring_first = getParam<unsigned int>("ring_first");
 }

Member Function Documentation

◆ computeIntegral()

Real JIntegral::computeIntegral ( )

protectedvirtual

Definition at line 137 of file JIntegral.C.

 {
   Real sum = 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 == "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 == "GEOMETRY")
       q_this_node = _crack_front_definition->DomainIntegralQFunction(
           _crack_front_point_index, _ring_index - ring_base, this_node);
     else if (_q_function_type == "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 JIntegral::computeQpIntegral ( )

protectedvirtual

Definition at line 83 of file JIntegral.C.

 {
   Real scalar_q = 0.0;
   RealVectorValue grad_of_scalar_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_of_scalar_q(j) += dphi_curr_elem[i][_qp](j) * _q_curr_elem[i];
   }
  
   RankTwoTensor grad_of_vector_q;
   const RealVectorValue & crack_direction =
       _crack_front_definition->getCrackDirection(_crack_front_point_index);
   grad_of_vector_q(0, 0) = crack_direction(0) * grad_of_scalar_q(0);
   grad_of_vector_q(0, 1) = crack_direction(0) * grad_of_scalar_q(1);
   grad_of_vector_q(0, 2) = crack_direction(0) * grad_of_scalar_q(2);
   grad_of_vector_q(1, 0) = crack_direction(1) * grad_of_scalar_q(0);
   grad_of_vector_q(1, 1) = crack_direction(1) * grad_of_scalar_q(1);
   grad_of_vector_q(1, 2) = crack_direction(1) * grad_of_scalar_q(2);
   grad_of_vector_q(2, 0) = crack_direction(2) * grad_of_scalar_q(0);
   grad_of_vector_q(2, 1) = crack_direction(2) * grad_of_scalar_q(1);
   grad_of_vector_q(2, 2) = crack_direction(2) * grad_of_scalar_q(2);
  
   Real eq = _Eshelby_tensor[_qp].doubleContraction(grad_of_vector_q);
  
   // Thermal component
   Real eq_thermal = 0.0;
   if (_J_thermal_term_vec)
   {
     for (unsigned int i = 0; i < 3; i++)
       eq_thermal += crack_direction(i) * scalar_q * (*_J_thermal_term_vec)[_qp](i);
   }
  
   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 etot = -eq + eq_thermal;
  
   return etot / q_avg_seg;
 }

Referenced by computeIntegral().

◆ getValue()

Real JIntegral::getValue ( )

virtual

Definition at line 176 of file JIntegral.C.

 {
   gatherSum(_integral_value);
   if (_has_symmetry_plane)
     _integral_value *= 2.0;
  
   Real sign = (_integral_value > 0.0) ? 1.0 : ((_integral_value < 0.0) ? -1.0 : 0.0);
   if (_convert_J_to_K)
     _integral_value = sign * std::sqrt(std::abs(_integral_value) * _youngs_modulus /
                                        (1 - std::pow(_poissons_ratio, 2)));
  
   return _integral_value;
 }

◆ initialSetup()

void JIntegral::initialSetup ( )

protectedvirtual

Definition at line 74 of file JIntegral.C.

 {
   _treat_as_2d = _crack_front_definition->treatAs2D();
  
   if (_convert_J_to_K && (!isParamValid("youngs_modulus") || !isParamValid("poissons_ratio")))
     mooseError("youngs_modulus and poissons_ratio must be specified if convert_J_to_K = true");
 }

◆ validParams()

InputParameters JIntegral::validParams ( )

static

Definition at line 22 of file JIntegral.C.

 {
   InputParameters params = ElementIntegralPostprocessor::validParams();
   params.addClassDescription("Calculates the J-integral at a specified point "
                              " along the crack front");
   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<bool>(
       "convert_J_to_K", false, "Convert J-integral to 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");
   params.addParam<Real>("youngs_modulus", "Young's modulus of the material.");
   params.set<bool>("use_displaced_mesh") = false;
   params.addParam<unsigned int>("ring_index", "Ring ID");
   params.addParam<unsigned int>("ring_first", "First Ring ID");
   MooseEnum q_function_type("Geometry Topology", "Geometry");
   params.addParam<MooseEnum>("q_function_type",
                              q_function_type,
                              "The method used to define the integration domain. Options are: " +
                                  q_function_type.getRawNames());
   return params;
 }

Member Data Documentation

◆ _convert_J_to_K

bool JIntegral::_convert_J_to_K

protected

Definition at line 46 of file JIntegral.h.

Referenced by getValue(), and initialSetup().

◆ _crack_front_definition

const CrackFrontDefinition* const JIntegral::_crack_front_definition

protected

Definition at line 40 of file JIntegral.h.

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

◆ _crack_front_point_index

const unsigned int JIntegral::_crack_front_point_index

protected

Definition at line 42 of file JIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

◆ _dphi_curr_elem

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

protected

Definition at line 55 of file JIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

◆ _Eshelby_tensor

const MaterialProperty<RankTwoTensor>& JIntegral::_Eshelby_tensor

protected

Definition at line 44 of file JIntegral.h.

Referenced by computeQpIntegral().

◆ _has_crack_front_point_index

bool JIntegral::_has_crack_front_point_index

protected

Definition at line 41 of file JIntegral.h.

◆ _has_symmetry_plane

bool JIntegral::_has_symmetry_plane

protected

Definition at line 47 of file JIntegral.h.

Referenced by getValue().

◆ _J_thermal_term_vec

const MaterialProperty<RealVectorValue>* JIntegral::_J_thermal_term_vec

protected

Definition at line 45 of file JIntegral.h.

Referenced by computeQpIntegral().

◆ _phi_curr_elem

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

protected

Definition at line 54 of file JIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

◆ _poissons_ratio

Real JIntegral::_poissons_ratio

protected

Definition at line 48 of file JIntegral.h.

Referenced by getValue().

◆ _q_curr_elem

std::vector<Real> JIntegral::_q_curr_elem

protected

Definition at line 53 of file JIntegral.h.

Referenced by computeIntegral(), and computeQpIntegral().

◆ _q_function_type

MooseEnum JIntegral::_q_function_type

protected

Definition at line 52 of file JIntegral.h.

Referenced by computeIntegral(), and JIntegral().

◆ _ring_first

unsigned int JIntegral::_ring_first

protected

Definition at line 51 of file JIntegral.h.

Referenced by JIntegral().

◆ _ring_index

unsigned int JIntegral::_ring_index

protected

Definition at line 50 of file JIntegral.h.

Referenced by computeIntegral().

◆ _treat_as_2d

bool JIntegral::_treat_as_2d

protected

Definition at line 43 of file JIntegral.h.

Referenced by initialSetup().

◆ _youngs_modulus

Real JIntegral::_youngs_modulus

protected

Definition at line 49 of file JIntegral.h.

Referenced by getValue().

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

tensor_mechanics/include/postprocessors/JIntegral.h
tensor_mechanics/src/postprocessors/JIntegral.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ JIntegral()

Member Function Documentation

◆ computeIntegral()

◆ computeQpIntegral()

◆ getValue()

◆ initialSetup()

◆ validParams()

Member Data Documentation

◆ _convert_J_to_K

◆ _crack_front_definition

◆ _crack_front_point_index

◆ _dphi_curr_elem

◆ _Eshelby_tensor

◆ _has_crack_front_point_index

◆ _has_symmetry_plane

◆ _J_thermal_term_vec

◆ _phi_curr_elem

◆ _poissons_ratio

◆ _q_curr_elem

◆ _q_function_type

◆ _ring_first

◆ _ring_index

◆ _treat_as_2d

◆ _youngs_modulus