Action to set up all objects used in computation of fracture domain integrals. More...

#include <DomainIntegralAction.h>

Inheritance diagram for DomainIntegralAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	DomainIntegralAction (const InputParameters &params)

	~DomainIntegralAction ()

virtual void	act () override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType input_rm_type) override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	timedAct ()

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Types
enum	INTEGRAL { J_INTEGRAL , C_INTEGRAL , K_FROM_J_INTEGRAL , INTERACTION_INTEGRAL_KI , INTERACTION_INTEGRAL_KII , INTERACTION_INTEGRAL_KIII , INTERACTION_INTEGRAL_T }
	Enum used to select the type of integral to be performed. More...

enum	Q_FUNCTION_TYPE { GEOMETRY , TOPOLOGY }
	Enum used to select the method used to compute the Q function used in the fracture integrals. More...

Protected Member Functions
unsigned int	calcNumCrackFrontPoints ()
	Compute the number of points on the crack front.

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::set< INTEGRAL >	_integrals
	Container for enumerations describing the individual integrals computed.

const std::vector< BoundaryName > &	_boundary_names
	Boundaries containing the crack front points.

std::vector< Point >	_crack_front_points
	User-defined vector of crack front points.

bool	_closed_loop
	Indicates whether the crack forms a closed loop.

UserObjectName	_crack_front_points_provider
	Name of crack front points provider user object used to optionally define the crack points.

bool	_use_crack_front_points_provider
	Whether to use a crack front points provider.

MooseEnum	_direction_method_moose_enum
	Enum used to define the method to compute crack front direction.

MooseEnum	_end_direction_method_moose_enum
	Enum used to define the method to compute crack front direction at ends of crack front.

const bool	_have_crack_direction_vector
	Whether the crack direction vector has been provided.

const RealVectorValue	_crack_direction_vector
	Vector optionally used to prescribe direction of crack extension.

const bool	_have_crack_direction_vector_end_1
	Whether the crack direction vector at the 1st end of the crack has been provided.

const RealVectorValue	_crack_direction_vector_end_1
	Vector optionally used to prescribe direction of crack extension at the 1st end of the crack.

const bool	_have_crack_direction_vector_end_2
	Whether the crack direction vector at the 2nd end of the crack has been provided.

const RealVectorValue	_crack_direction_vector_end_2
	Vector optionally used to prescribe direction of crack extension at the 2nd end of the crack.

std::vector< BoundaryName >	_crack_mouth_boundary_names
	Names of boundaries optionally used to define the crack mouth location.

std::vector< BoundaryName >	_intersecting_boundary_names
	Names of boundaries optionally used for improved computation of crack extension direction at ends of the crack where it intersects the prescribed boundaries.

bool	_treat_as_2d
	Whether fracture computations for a 3D model should be treated as though it were a 2D model.

unsigned int	_axis_2d
	Out-of-plane axis for 3D models treated as 2D.

unsigned int	_ring_first
	Number of elements away from the crack tip to inside of inner ring with the topological q function.

unsigned int	_ring_last
	Number of elements away from the crack tip to outside of outer ring with the topological q function.

std::vector< VariableName >	_output_variables
	List of variables for which values are to be sampled and output at the crack front points.

Real	_poissons_ratio
	Poisson's ratio of material.

Real	_youngs_modulus
	Young's modulus of material.

std::vector< SubdomainName >	_blocks
	Blocks for which the domain integrals are to be computed.

std::vector< VariableName >	_displacements
	Vector of displacement variables.

VariableName	_temp
	Temperature variable.

bool	_has_symmetry_plane
	Whether the model has a symmetry plane passing through the plane of the crack.

unsigned int	_symmetry_plane
	Identifier for which plane is the symmetry plane.

MooseEnum	_position_type
	How the distance along the crack front is measured (angle or distance)

MooseEnum	_q_function_type
	How the q function is evaluated (geometric distance from crack front or ring of elements)

bool	_get_equivalent_k
	Whether to compute the equivalent K from the individual fracture integrals for mixed-mode fracture.

bool	_use_displaced_mesh
	Whether to compute the fracture integrals on the displaced mesh.

bool	_output_q
	Whether to ouput the q function as a set of AuxVariables.

std::vector< unsigned int >	_ring_vec
	Vector of ids for the individual rings on which the fracture integral is computed.

bool	_incremental
	Whether the constitutive models for the mechanics calculations use an incremental form.

bool	_convert_J_to_K
	Whether to convert the J-integral to a stress intensity factor (K) –deprecated.

bool	_fgm_crack
	Whether the crack lives in a functionally-graded material.

MaterialPropertyName	_functionally_graded_youngs_modulus_crack_dir_gradient
	Material property name for the Youngs modulus derivative for functionally graded materials.

MaterialPropertyName	_functionally_graded_youngs_modulus
	Material property name for spatially-dependent Youngs modulus for functionally graded materials.

const bool	_use_ad
	Whether to create automatic differentiation objects from the action.

std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator


const std::string	_order
	Order and family of the AuxVariables optionally created to output the values of q.

const std::string	_family


std::vector< Real >	_radius_inner
	Sets of inner and outer radii of the rings used for the domain form of the fracture integrals.

std::vector< Real >	_radius_outer

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Action to set up all objects used in computation of fracture domain integrals.

Definition at line 22 of file DomainIntegralAction.h.

Member Enumeration Documentation

◆ INTEGRAL

enum DomainIntegralAction::INTEGRAL

protected

Enum used to select the type of integral to be performed.

Enumerator
J_INTEGRAL
C_INTEGRAL
K_FROM_J_INTEGRAL
INTERACTION_INTEGRAL_KI
INTERACTION_INTEGRAL_KII
INTERACTION_INTEGRAL_KIII
INTERACTION_INTEGRAL_T

Definition at line 38 of file DomainIntegralAction.h.

  {
    J_INTEGRAL,
    C_INTEGRAL,
    K_FROM_J_INTEGRAL,
    INTERACTION_INTEGRAL_KI,
    INTERACTION_INTEGRAL_KII,
    INTERACTION_INTEGRAL_KIII,
    INTERACTION_INTEGRAL_T
  };

◆ Q_FUNCTION_TYPE

enum DomainIntegralAction::Q_FUNCTION_TYPE

protected

Enum used to select the method used to compute the Q function used in the fracture integrals.

Enumerator
GEOMETRY
TOPOLOGY

Definition at line 51 of file DomainIntegralAction.h.

  {
    GEOMETRY,
    TOPOLOGY
  };

Constructor & Destructor Documentation

◆ DomainIntegralAction()

DomainIntegralAction::DomainIntegralAction ( const InputParameters & params )

Definition at line 143 of file DomainIntegralAction.C.

  : Action(params),
    _boundary_names(getParam<std::vector<BoundaryName>>("boundary")),
    _closed_loop(getParam<bool>("closed_loop")),
    _use_crack_front_points_provider(false),
    _order(getParam<std::string>("order")),
    _family(getParam<std::string>("family")),
    _direction_method_moose_enum(getParam<MooseEnum>("crack_direction_method")),
    _end_direction_method_moose_enum(getParam<MooseEnum>("crack_end_direction_method")),
    _have_crack_direction_vector(isParamValid("crack_direction_vector")),
    _crack_direction_vector(
        _have_crack_direction_vector ? getParam<RealVectorValue>("crack_direction_vector") : 0.0),
    _have_crack_direction_vector_end_1(isParamValid("crack_direction_vector_end_1")),
    _crack_direction_vector_end_1(_have_crack_direction_vector_end_1
                                      ? getParam<RealVectorValue>("crack_direction_vector_end_1")
                                      : 0.0),
    _have_crack_direction_vector_end_2(isParamValid("crack_direction_vector_end_2")),
    _crack_direction_vector_end_2(_have_crack_direction_vector_end_2
                                      ? getParam<RealVectorValue>("crack_direction_vector_end_2")
                                      : 0.0),
    _treat_as_2d(getParam<bool>("2d")),
    _axis_2d(getParam<unsigned int>("axis_2d")),
    _has_symmetry_plane(isParamValid("symmetry_plane")),
    _symmetry_plane(_has_symmetry_plane ? getParam<unsigned int>("symmetry_plane")
                                        : std::numeric_limits<unsigned int>::max()),
    _position_type(getParam<MooseEnum>("position_type")),
    _q_function_type(getParam<MooseEnum>("q_function_type")),
    _get_equivalent_k(getParam<bool>("equivalent_k")),
    _use_displaced_mesh(false),
    _output_q(getParam<bool>("output_q")),
    _incremental(getParam<bool>("incremental")),
    _convert_J_to_K(isParamValid("convert_J_to_K") ? getParam<bool>("convert_J_to_K") : false),
    _fgm_crack(false),
    _use_ad(getParam<bool>("use_automatic_differentiation"))
{
 
  if (isParamValid("functionally_graded_youngs_modulus_crack_dir_gradient") !=
      isParamValid("functionally_graded_youngs_modulus"))
    paramError("functionally_graded_youngs_modulus_crack_dir_gradient",
               "You have selected to compute the interaction integral for a crack in FGM. That "
               "selection requires the user to provide a spatially varying elasticity modulus that "
               "defines the transition of material properties (i.e. "
               "'functionally_graded_youngs_modulus') and its "
               "spatial derivative in the crack direction (i.e. "
               "'functionally_graded_youngs_modulus_crack_dir_gradient').");
 
  if (isParamValid("functionally_graded_youngs_modulus_crack_dir_gradient") &&
      isParamValid("functionally_graded_youngs_modulus"))
  {
    _fgm_crack = true;
    _functionally_graded_youngs_modulus_crack_dir_gradient =
        getParam<MaterialPropertyName>("functionally_graded_youngs_modulus_crack_dir_gradient");
    _functionally_graded_youngs_modulus =
        getParam<MaterialPropertyName>("functionally_graded_youngs_modulus");
  }
 
  if (_q_function_type == GEOMETRY)
  {
    if (isParamValid("radius_inner") && isParamValid("radius_outer"))
    {
      _radius_inner = getParam<std::vector<Real>>("radius_inner");
      _radius_outer = getParam<std::vector<Real>>("radius_outer");
    }
    else
      mooseError("DomainIntegral error: must set radius_inner and radius_outer.");
    for (unsigned int i = 0; i < _radius_inner.size(); ++i)
      _ring_vec.push_back(i + 1);
  }
  else if (_q_function_type == TOPOLOGY)
  {
    if (isParamValid("ring_first") && isParamValid("ring_last"))
    {
      _ring_first = getParam<unsigned int>("ring_first");
      _ring_last = getParam<unsigned int>("ring_last");
    }
    else
      mooseError(
          "DomainIntegral error: must set ring_first and ring_last if q_function_type = Topology.");
    for (unsigned int i = _ring_first; i <= _ring_last; ++i)
      _ring_vec.push_back(i);
  }
  else
    paramError("q_function_type", "DomainIntegral error: invalid q_function_type.");
 
  if (isParamValid("crack_front_points"))
    _crack_front_points = getParam<std::vector<Point>>("crack_front_points");
 
  if (isParamValid("crack_front_points_provider"))
  {
    _use_crack_front_points_provider = true;
    _crack_front_points_provider = getParam<UserObjectName>("crack_front_points_provider");
  }
  else if (isParamValid("number_points_from_provider"))
    paramError("crack_front_points_provider",
               "DomainIntegral error: number_points_from_provider is provided but "
               "crack_front_points_provider cannot be found.");
  if (isParamValid("crack_mouth_boundary"))
    _crack_mouth_boundary_names = getParam<std::vector<BoundaryName>>("crack_mouth_boundary");
  if (isParamValid("intersecting_boundary"))
    _intersecting_boundary_names = getParam<std::vector<BoundaryName>>("intersecting_boundary");
  if (_radius_inner.size() != _radius_outer.size())
    mooseError("Number of entries in 'radius_inner' and 'radius_outer' must match.");
 
  bool youngs_modulus_set(false);
  bool poissons_ratio_set(false);
 
  // All domain integral types block restrict the objects created by this action.
  _blocks = getParam<std::vector<SubdomainName>>("block");
 
  MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>("integrals");
  for (unsigned int i = 0; i < integral_moose_enums.size(); ++i)
  {
    _displacements = getParam<std::vector<VariableName>>("displacements");
 
    if (_displacements.size() < 2)
      paramError(
          "displacements",
          "DomainIntegral error: The size of the displacements vector should at least be 2.");
 
    if (integral_moose_enums[i] != "JIntegral" && integral_moose_enums[i] != "CIntegral" &&
        integral_moose_enums[i] != "KFromJIntegral")
    {
      // Check that parameters required for interaction integrals are defined
      if (!(isParamValid("poissons_ratio")) || !(isParamValid("youngs_modulus")))
        mooseError(
            "DomainIntegral error: must set Poisson's ratio and Young's modulus for integral: ",
            integral_moose_enums[i]);
 
      _poissons_ratio = getParam<Real>("poissons_ratio");
      poissons_ratio_set = true;
      _youngs_modulus = getParam<Real>("youngs_modulus");
      youngs_modulus_set = true;
    }
 
    _integrals.insert(INTEGRAL(int(integral_moose_enums.get(i))));
  }
 
  if ((_integrals.count(J_INTEGRAL) != 0 && _integrals.count(C_INTEGRAL) != 0) ||
      (_integrals.count(J_INTEGRAL) != 0 && _integrals.count(K_FROM_J_INTEGRAL) != 0) ||
      (_integrals.count(C_INTEGRAL) != 0 && _integrals.count(K_FROM_J_INTEGRAL) != 0))
    paramError("integrals",
               "JIntegral, CIntegral, and KFromJIntegral options are mutually exclusive");
 
  // Acommodate deprecated parameter convert_J_to_K
  if (_convert_J_to_K && _integrals.count(K_FROM_J_INTEGRAL) != 0)
  {
    _integrals.insert(K_FROM_J_INTEGRAL);
    _integrals.erase(J_INTEGRAL);
  }
 
  if (isParamValid("temperature"))
    _temp = getParam<VariableName>("temperature");
 
  if (_temp != "" && !isParamValid("eigenstrain_names"))
    paramError(
        "eigenstrain_names",
        "DomainIntegral error: must provide `eigenstrain_names` when temperature is coupled.");
 
  if (_get_equivalent_k && (_integrals.count(INTERACTION_INTEGRAL_KI) == 0 ||
                            _integrals.count(INTERACTION_INTEGRAL_KII) == 0 ||
                            _integrals.count(INTERACTION_INTEGRAL_KIII) == 0))
    paramError("integrals",
               "DomainIntegral error: must calculate KI, KII and KIII to get equivalent K.");
 
  if (isParamValid("output_variable"))
  {
    _output_variables = getParam<std::vector<VariableName>>("output_variable");
    if (_crack_front_points.size() > 0)
      paramError("output_variables",
                 "'output_variables' not yet supported with 'crack_front_points'");
  }
 
  if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
  {
    if (!isParamValid("youngs_modulus") || !isParamValid("poissons_ratio"))
      mooseError("DomainIntegral error: must set Young's modulus and Poisson's ratio "
                 "if K_FROM_J_INTEGRAL is selected.");
    if (!youngs_modulus_set)
      _youngs_modulus = getParam<Real>("youngs_modulus");
    if (!poissons_ratio_set)
      _poissons_ratio = getParam<Real>("poissons_ratio");
  }
 
  if (_integrals.count(J_INTEGRAL) != 0 || _integrals.count(C_INTEGRAL) != 0 ||
      _integrals.count(K_FROM_J_INTEGRAL) != 0)
  {
    if (isParamValid("eigenstrain_gradient"))
      paramError("eigenstrain_gradient",
                 "'eigenstrain_gradient' cannot be specified when the computed integrals include "
                 "JIntegral, CIntegral, or KFromJIntegral");
    if (isParamValid("body_force"))
      paramError("body_force",
                 "'body_force' cannot be specified when the computed integrals include JIntegral, "
                 "CIntegral, or KFromJIntegral");
  }
  if (isParamValid("eigenstrain_gradient") && (_temp != "" || isParamValid("eigenstrain_names")))
    paramError("eigenstrain_gradient",
               "'eigenstrain_gradient' cannot be specified together with 'temperature' or "
               "'eigenstrain_names'. These are for separate, mutually exclusive systems for "
               "including the effect of eigenstrains");
}

◆ ~DomainIntegralAction()

DomainIntegralAction::~DomainIntegralAction ( )

Definition at line 345 of file DomainIntegralAction.C.

345{}

Member Function Documentation

◆ act()

void DomainIntegralAction::act ( )

overridevirtual

Implements Action.

Definition at line 348 of file DomainIntegralAction.C.

{
  const std::string uo_name("crackFrontDefinition");
  const std::string ak_base_name("q");
  const std::string av_base_name("q");
  const unsigned int num_crack_front_points = calcNumCrackFrontPoints();
  const std::string aux_stress_base_name("aux_stress");
  const std::string aux_grad_disp_base_name("aux_grad_disp");
 
  // checking if built with xfem and setting flags for vpps used by xfem
  std::vector<std::string> xfem_exec_flags = {EXEC_XFEM_MARK, EXEC_TIMESTEP_END};
 
  std::string ad_prepend = "";
  if (_use_ad)
    ad_prepend = "AD";
 
  if (_current_task == "add_user_object")
  {
    const std::string uo_type_name("CrackFrontDefinition");
 
    InputParameters params = _factory.getValidParams(uo_type_name);
    // The CrackFrontDefinition updates the vpps and MUST execute before them
    params.set<int>("execution_order_group") = -1;
    if (_use_crack_front_points_provider)
      params.set<ExecFlagEnum>("execute_on") = xfem_exec_flags;
    else
      params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
 
    params.set<MooseEnum>("crack_direction_method") = _direction_method_moose_enum;
    params.set<MooseEnum>("crack_end_direction_method") = _end_direction_method_moose_enum;
    if (_have_crack_direction_vector)
      params.set<RealVectorValue>("crack_direction_vector") = _crack_direction_vector;
    if (_have_crack_direction_vector_end_1)
      params.set<RealVectorValue>("crack_direction_vector_end_1") = _crack_direction_vector_end_1;
    if (_have_crack_direction_vector_end_2)
      params.set<RealVectorValue>("crack_direction_vector_end_2") = _crack_direction_vector_end_2;
    if (_crack_mouth_boundary_names.size() != 0)
      params.set<std::vector<BoundaryName>>("crack_mouth_boundary") = _crack_mouth_boundary_names;
    if (_intersecting_boundary_names.size() != 0)
      params.set<std::vector<BoundaryName>>("intersecting_boundary") = _intersecting_boundary_names;
    params.set<bool>("2d") = _treat_as_2d;
    params.set<unsigned int>("axis_2d") = _axis_2d;
    if (_has_symmetry_plane)
      params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
    if (_boundary_names.size() != 0)
      params.set<std::vector<BoundaryName>>("boundary") = _boundary_names;
    if (_crack_front_points.size() != 0)
      params.set<std::vector<Point>>("crack_front_points") = _crack_front_points;
    if (_use_crack_front_points_provider)
    {
      params.set<UserObjectName>("crack_front_points_provider") = _crack_front_points_provider;
      if (isParamValid("number_points_from_provider"))
        params.set<unsigned int>("number_points_from_provider") =
            getParam<unsigned int>("number_points_from_provider");
    }
    if (_closed_loop)
      params.set<bool>("closed_loop") = _closed_loop;
    params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
    if (_integrals.count(INTERACTION_INTEGRAL_T) != 0)
    {
      params.set<VariableName>("disp_x") = _displacements[0];
      params.set<VariableName>("disp_y") = _displacements[1];
      if (_displacements.size() == 3)
        params.set<VariableName>("disp_z") = _displacements[2];
      params.set<bool>("t_stress") = true;
    }
 
    unsigned int nrings = 0;
    if (_q_function_type == TOPOLOGY)
    {
      params.set<bool>("q_function_rings") = true;
      params.set<unsigned int>("last_ring") = _ring_last;
      params.set<unsigned int>("first_ring") = _ring_first;
      nrings = _ring_last - _ring_first + 1;
    }
    else if (_q_function_type == GEOMETRY)
    {
      params.set<std::vector<Real>>("j_integral_radius_inner") = _radius_inner;
      params.set<std::vector<Real>>("j_integral_radius_outer") = _radius_outer;
      nrings = _ring_vec.size();
    }
 
    params.set<unsigned int>("nrings") = nrings;
    params.set<MooseEnum>("q_function_type") = _q_function_type;
 
    _problem->addUserObject(uo_type_name, uo_name, params);
  }
  else if (_current_task == "add_aux_variable" && _output_q)
  {
    if (isParamValid("number_points_from_provider") && num_crack_front_points == 0)
    {
      paramError("output_q",
                 "Requesting AuxVariable output of q functions but the number of crack fronts for "
                 "output is zero.  AuxVariable output for XFEM cutter objects requires "
                 "number_points_from_provider to be set.");
    }
 
    for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
    {
      std::string aux_var_type;
      if (_family == "LAGRANGE")
        aux_var_type = "MooseVariable";
      else if (_family == "MONOMIAL")
        aux_var_type = "MooseVariableConstMonomial";
      else if (_family == "SCALAR")
        aux_var_type = "MooseVariableScalar";
      else
        mooseError("Unsupported finite element family in, " + name() +
                   ".  Please use LAGRANGE, MONOMIAL, or SCALAR");
 
      auto params = _factory.getValidParams(aux_var_type);
      params.set<MooseEnum>("order") = _order;
      params.set<MooseEnum>("family") = _family;
 
      if (_treat_as_2d && _use_crack_front_points_provider == false)
      {
        std::ostringstream av_name_stream;
        av_name_stream << av_base_name << "_" << _ring_vec[ring_index];
        _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
      }
      else
      {
        for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
        {
          std::ostringstream av_name_stream;
          av_name_stream << av_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
          _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
        }
      }
    }
  }
 
  else if (_current_task == "add_aux_kernel" && _output_q)
  {
    std::string ak_type_name;
    unsigned int nrings = 0;
    if (_q_function_type == GEOMETRY)
    {
      ak_type_name = "DomainIntegralQFunction";
      nrings = _ring_vec.size();
    }
    else if (_q_function_type == TOPOLOGY)
    {
      ak_type_name = "DomainIntegralTopologicalQFunction";
      nrings = _ring_last - _ring_first + 1;
    }
 
    InputParameters params = _factory.getValidParams(ak_type_name);
    params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
    params.set<UserObjectName>("crack_front_definition") = uo_name;
    params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
 
    for (unsigned int ring_index = 0; ring_index < nrings; ++ring_index)
    {
      if (_q_function_type == GEOMETRY)
      {
        params.set<Real>("j_integral_radius_inner") = _radius_inner[ring_index];
        params.set<Real>("j_integral_radius_outer") = _radius_outer[ring_index];
      }
      else if (_q_function_type == TOPOLOGY)
      {
        params.set<unsigned int>("ring_index") = _ring_first + ring_index;
      }
 
      if (_treat_as_2d && _use_crack_front_points_provider == false)
      {
        std::ostringstream ak_name_stream;
        ak_name_stream << ak_base_name << "_" << _ring_vec[ring_index];
        std::ostringstream av_name_stream;
        av_name_stream << av_base_name << "_" << _ring_vec[ring_index];
        params.set<AuxVariableName>("variable") = av_name_stream.str();
        _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
      }
      else
      {
        for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
        {
          std::ostringstream ak_name_stream;
          ak_name_stream << ak_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
          std::ostringstream av_name_stream;
          av_name_stream << av_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
          params.set<AuxVariableName>("variable") = av_name_stream.str();
          params.set<unsigned int>("crack_front_point_index") = cfp_index;
          _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
        }
      }
    }
  }
 
  else if (_current_task == "add_postprocessor")
  {
    // Check that the number specified by the XFEM cutter object matches the number of points
    // specified in the DomainIntegralAction block.  This is being done in teh add_postprocessor
    // block because it must be done after all userObjects have been created.
    if (_use_crack_front_points_provider && isParamValid("number_points_from_provider"))
    {
      auto crack_front_points_provider = &_problem->getUserObject<CrackFrontPointsProvider>(
          getParam<UserObjectName>("crack_front_points_provider"));
      if (crack_front_points_provider->usesMesh())
      {
        auto xfem_cutter_points = crack_front_points_provider->getNumberOfCrackFrontPoints();
        if (xfem_cutter_points != num_crack_front_points)
          paramError("number_points_from_provider",
                     "This must match the number of points provided by the XFEM mesh cutter "
                     "object."
                     "\n   number_points_from_provider:",
                     num_crack_front_points,
                     "\n   XFEM Crack Front Points: ",
                     xfem_cutter_points);
      }
    }
    for (std::set<INTEGRAL>::iterator sit = _integrals.begin(); sit != _integrals.end(); ++sit)
    {
      std::string pp_base_name;
      switch (*sit)
      {
        case J_INTEGRAL:
          pp_base_name = "J";
          break;
 
        case C_INTEGRAL:
          pp_base_name = "C";
          break;
 
        case K_FROM_J_INTEGRAL:
          pp_base_name = "K";
          break;
 
        case INTERACTION_INTEGRAL_KI:
          pp_base_name = "II_KI";
          break;
 
        case INTERACTION_INTEGRAL_KII:
          pp_base_name = "II_KII";
          break;
 
        case INTERACTION_INTEGRAL_KIII:
          pp_base_name = "II_KIII";
          break;
 
        case INTERACTION_INTEGRAL_T:
          pp_base_name = "II_T";
          break;
      }
      const std::string pp_type_name("VectorPostprocessorComponent");
      InputParameters params = _factory.getValidParams(pp_type_name);
      for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
      {
        if (_treat_as_2d && _use_crack_front_points_provider == false)
        {
          params.set<VectorPostprocessorName>("vectorpostprocessor") =
              pp_base_name + "_2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
          std::string pp_name = pp_base_name + +"_" + Moose::stringify(_ring_vec[ring_index]);
          params.set<unsigned int>("index") = 0;
          params.set<std::string>("vector_name") =
              pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
          _problem->addPostprocessor(pp_type_name, pp_name, params);
        }
        else
        {
          for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
          {
            params.set<VectorPostprocessorName>("vectorpostprocessor") =
                pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
            std::string pp_name = pp_base_name + "_" + Moose::stringify(cfp_index + 1) + "_" +
                                  Moose::stringify(_ring_vec[ring_index]);
            params.set<unsigned int>("index") = cfp_index;
            params.set<std::string>("vector_name") =
                pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
            _problem->addPostprocessor(pp_type_name, pp_name, params);
          }
        }
      }
    }
 
    if (_get_equivalent_k)
    {
      std::string pp_base_name("Keq");
      const std::string pp_type_name("VectorPostprocessorComponent");
      InputParameters params = _factory.getValidParams(pp_type_name);
      for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
      {
        if (_treat_as_2d && _use_crack_front_points_provider == false)
        {
          params.set<VectorPostprocessorName>("vectorpostprocessor") =
              pp_base_name + "_2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
          std::string pp_name = pp_base_name + +"_" + Moose::stringify(_ring_vec[ring_index]);
          params.set<unsigned int>("index") = 0;
          params.set<std::string>("vector_name") =
              pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
          _problem->addPostprocessor(pp_type_name, pp_name, params);
        }
        else
        {
          for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
          {
            params.set<VectorPostprocessorName>("vectorpostprocessor") =
                pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
            std::string pp_name = pp_base_name + "_" + Moose::stringify(cfp_index + 1) + "_" +
                                  Moose::stringify(_ring_vec[ring_index]);
            params.set<unsigned int>("index") = cfp_index;
            params.set<std::string>("vector_name") =
                pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
            _problem->addPostprocessor(pp_type_name, pp_name, params);
          }
        }
      }
    }
 
    for (unsigned int i = 0; i < _output_variables.size(); ++i)
    {
      const std::string ov_base_name(_output_variables[i]);
      const std::string pp_type_name("CrackFrontData");
      InputParameters params = _factory.getValidParams(pp_type_name);
      params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      params.set<UserObjectName>("crack_front_definition") = uo_name;
      if (_treat_as_2d && _use_crack_front_points_provider == false)
      {
        std::ostringstream pp_name_stream;
        pp_name_stream << ov_base_name << "_crack";
        params.set<VariableName>("variable") = _output_variables[i];
        _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
      }
      else
      {
        for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
        {
          std::ostringstream pp_name_stream;
          pp_name_stream << ov_base_name << "_crack_" << cfp_index + 1;
          params.set<VariableName>("variable") = _output_variables[i];
          params.set<unsigned int>("crack_front_point_index") = cfp_index;
          _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
        }
      }
    }
  }
 
  else if (_current_task == "add_vector_postprocessor")
  {
    if (_integrals.count(J_INTEGRAL) != 0 || _integrals.count(C_INTEGRAL) != 0 ||
        _integrals.count(K_FROM_J_INTEGRAL) != 0)
    {
      std::string vpp_base_name;
      std::string jintegral_selection = "JIntegral";
 
      if (_integrals.count(J_INTEGRAL) != 0)
      {
        vpp_base_name = "J";
        jintegral_selection = "JIntegral";
      }
      else if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
      {
        vpp_base_name = "K";
        jintegral_selection = "KFromJIntegral";
      }
      else if (_integrals.count(C_INTEGRAL) != 0)
      {
        vpp_base_name = "C";
        jintegral_selection = "CIntegral";
      }
 
      if (_treat_as_2d && _use_crack_front_points_provider == false)
        vpp_base_name += "_2DVPP";
 
      const std::string vpp_type_name("JIntegral");
      InputParameters params = _factory.getValidParams(vpp_type_name);
      if (!getParam<bool>("output_vpp"))
        params.set<std::vector<OutputName>>("outputs") = {"none"};
 
      params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      params.set<UserObjectName>("crack_front_definition") = uo_name;
      params.set<std::vector<SubdomainName>>("block") = {_blocks};
      params.set<MooseEnum>("position_type") = _position_type;
 
      if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
      {
        params.set<Real>("youngs_modulus") = _youngs_modulus;
        params.set<Real>("poissons_ratio") = _poissons_ratio;
      }
 
      if (_has_symmetry_plane)
        params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
 
      // Select the integral type to be computed in JIntegral vector postprocessor
      params.set<MooseEnum>("integral") = jintegral_selection;
 
      params.set<std::vector<VariableName>>("displacements") = _displacements;
      params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
      for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
      {
        params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
        params.set<MooseEnum>("q_function_type") = _q_function_type;
 
        std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
        _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
      }
    }
 
    if (_integrals.count(INTERACTION_INTEGRAL_KI) != 0 ||
        _integrals.count(INTERACTION_INTEGRAL_KII) != 0 ||
        _integrals.count(INTERACTION_INTEGRAL_KIII) != 0 ||
        _integrals.count(INTERACTION_INTEGRAL_T) != 0)
    {
      if (_has_symmetry_plane && (_integrals.count(INTERACTION_INTEGRAL_KII) != 0 ||
                                  _integrals.count(INTERACTION_INTEGRAL_KIII) != 0))
        paramError("symmetry_plane",
                   "In DomainIntegral, symmetry_plane option cannot be used with mode-II or "
                   "mode-III interaction integral");
 
      std::string vpp_base_name;
      std::string vpp_type_name(ad_prepend + "InteractionIntegral");
 
      InputParameters params = _factory.getValidParams(vpp_type_name);
      if (!getParam<bool>("output_vpp"))
        params.set<std::vector<OutputName>>("outputs") = {"none"};
 
      if (_use_crack_front_points_provider)
        params.set<ExecFlagEnum>("execute_on") = xfem_exec_flags;
      else
        params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
 
      if (isParamValid("additional_eigenstrain_00") && isParamValid("additional_eigenstrain_01") &&
          isParamValid("additional_eigenstrain_11") && isParamValid("additional_eigenstrain_22"))
      {
        params.set<CoupledName>("additional_eigenstrain_00") =
            getParam<CoupledName>("additional_eigenstrain_00");
        params.set<CoupledName>("additional_eigenstrain_01") =
            getParam<CoupledName>("additional_eigenstrain_01");
        params.set<CoupledName>("additional_eigenstrain_11") =
            getParam<CoupledName>("additional_eigenstrain_11");
        params.set<CoupledName>("additional_eigenstrain_22") =
            getParam<CoupledName>("additional_eigenstrain_22");
      }
 
      params.set<UserObjectName>("crack_front_definition") = uo_name;
      params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
      params.set<std::vector<SubdomainName>>("block") = {_blocks};
 
      if (_has_symmetry_plane)
        params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
 
      if (_fgm_crack)
      {
        params.set<MaterialPropertyName>(
            "functionally_graded_youngs_modulus_crack_dir_gradient") = {
            _functionally_graded_youngs_modulus_crack_dir_gradient};
        params.set<MaterialPropertyName>("functionally_graded_youngs_modulus") = {
            _functionally_graded_youngs_modulus};
      }
 
      params.set<Real>("poissons_ratio") = _poissons_ratio;
      params.set<Real>("youngs_modulus") = _youngs_modulus;
      params.set<std::vector<VariableName>>("displacements") = _displacements;
      if (_temp != "")
        params.set<std::vector<VariableName>>("temperature") = {_temp};
 
      if (parameters().isParamValid("eigenstrain_gradient"))
        params.set<MaterialPropertyName>("eigenstrain_gradient") =
            parameters().get<MaterialPropertyName>("eigenstrain_gradient");
      if (parameters().isParamValid("body_force"))
        params.set<MaterialPropertyName>("body_force") =
            parameters().get<MaterialPropertyName>("body_force");
 
      for (std::set<INTEGRAL>::iterator sit = _integrals.begin(); sit != _integrals.end(); ++sit)
      {
        switch (*sit)
        {
          case J_INTEGRAL:
            continue;
 
          case C_INTEGRAL:
            continue;
 
          case K_FROM_J_INTEGRAL:
            continue;
 
          case INTERACTION_INTEGRAL_KI:
            vpp_base_name = "II_KI";
            params.set<Real>("K_factor") =
                0.5 * _youngs_modulus / (1.0 - std::pow(_poissons_ratio, 2.0));
            params.set<MooseEnum>("sif_mode") = "KI";
            break;
 
          case INTERACTION_INTEGRAL_KII:
            vpp_base_name = "II_KII";
            params.set<Real>("K_factor") =
                0.5 * _youngs_modulus / (1.0 - std::pow(_poissons_ratio, 2.0));
            params.set<MooseEnum>("sif_mode") = "KII";
            break;
 
          case INTERACTION_INTEGRAL_KIII:
            vpp_base_name = "II_KIII";
            params.set<Real>("K_factor") = 0.5 * _youngs_modulus / (1.0 + _poissons_ratio);
            params.set<MooseEnum>("sif_mode") = "KIII";
            break;
 
          case INTERACTION_INTEGRAL_T:
            vpp_base_name = "II_T";
            params.set<Real>("K_factor") = _youngs_modulus / (1 - std::pow(_poissons_ratio, 2));
            params.set<MooseEnum>("sif_mode") = "T";
            break;
        }
        if (_treat_as_2d && _use_crack_front_points_provider == false)
          vpp_base_name += "_2DVPP";
        for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
        {
          params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
          params.set<MooseEnum>("q_function_type") = _q_function_type;
 
          std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
          _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
        }
      }
    }
 
    if (_get_equivalent_k)
    {
      std::string vpp_base_name("Keq");
      if (_treat_as_2d && _use_crack_front_points_provider == false)
        vpp_base_name += "_2DVPP";
      const std::string vpp_type_name("MixedModeEquivalentK");
      InputParameters params = _factory.getValidParams(vpp_type_name);
      params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      params.set<Real>("poissons_ratio") = _poissons_ratio;
 
      for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
      {
        std::string ki_name = "II_KI_";
        std::string kii_name = "II_KII_";
        std::string kiii_name = "II_KIII_";
        params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
        if (_treat_as_2d && _use_crack_front_points_provider == false)
        {
          params.set<VectorPostprocessorName>("KI_vectorpostprocessor") =
              ki_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
          params.set<VectorPostprocessorName>("KII_vectorpostprocessor") =
              kii_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
          params.set<VectorPostprocessorName>("KIII_vectorpostprocessor") =
              kiii_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
        }
        else
        {
          params.set<VectorPostprocessorName>("KI_vectorpostprocessor") =
              ki_name + Moose::stringify(_ring_vec[ring_index]);
          params.set<VectorPostprocessorName>("KII_vectorpostprocessor") =
              kii_name + Moose::stringify(_ring_vec[ring_index]);
          params.set<VectorPostprocessorName>("KIII_vectorpostprocessor") =
              kiii_name + Moose::stringify(_ring_vec[ring_index]);
        }
        params.set<std::string>("KI_vector_name") =
            ki_name + Moose::stringify(_ring_vec[ring_index]);
        params.set<std::string>("KII_vector_name") =
            kii_name + Moose::stringify(_ring_vec[ring_index]);
        params.set<std::string>("KIII_vector_name") =
            kiii_name + Moose::stringify(_ring_vec[ring_index]);
        std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
        _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
      }
    }
 
    if (!_treat_as_2d || _use_crack_front_points_provider == true)
    {
      for (unsigned int i = 0; i < _output_variables.size(); ++i)
      {
        const std::string vpp_type_name("VectorOfPostprocessors");
        InputParameters params = _factory.getValidParams(vpp_type_name);
        params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
        std::ostringstream vpp_name_stream;
        vpp_name_stream << _output_variables[i] << "_crack";
        std::vector<PostprocessorName> postprocessor_names;
        for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
        {
          std::ostringstream pp_name_stream;
          pp_name_stream << vpp_name_stream.str() << "_" << cfp_index + 1;
          postprocessor_names.push_back(pp_name_stream.str());
        }
        params.set<std::vector<PostprocessorName>>("postprocessors") = postprocessor_names;
        _problem->addVectorPostprocessor(vpp_type_name, vpp_name_stream.str(), params);
      }
    }
  }
 
  else if (_current_task == "add_material")
  {
    if (_temp != "")
    {
      std::string mater_name;
      const std::string mater_type_name("ThermalFractureIntegral");
      mater_name = "ThermalFractureIntegral";
 
      InputParameters params = _factory.getValidParams(mater_type_name);
      params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") =
          getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
      params.set<std::vector<VariableName>>("temperature") = {_temp};
      params.set<std::vector<SubdomainName>>("block") = {_blocks};
      _problem->addMaterial(mater_type_name, mater_name, params);
    }
    MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>("integrals");
    bool have_j_integral = false;
    bool have_c_integral = false;
 
    for (auto ime : integral_moose_enums)
    {
      if (ime == "JIntegral" || ime == "CIntegral" || ime == "KFromJIntegral" ||
          ime == "InteractionIntegralKI" || ime == "InteractionIntegralKII" ||
          ime == "InteractionIntegralKIII" || ime == "InteractionIntegralT")
        have_j_integral = true;
 
      if (ime == "CIntegral")
        have_c_integral = true;
    }
    if (have_j_integral)
    {
      std::string mater_name;
      const std::string mater_type_name(ad_prepend + "StrainEnergyDensity");
      mater_name = ad_prepend + "StrainEnergyDensity";
 
      InputParameters params = _factory.getValidParams(mater_type_name);
      _incremental = getParam<bool>("incremental");
      params.set<bool>("incremental") = _incremental;
      params.set<std::vector<SubdomainName>>("block") = {_blocks};
      _problem->addMaterial(mater_type_name, mater_name, params);
 
      {
        std::string mater_name;
        const std::string mater_type_name(ad_prepend + "EshelbyTensor");
        mater_name = ad_prepend + "EshelbyTensor";
 
        InputParameters params = _factory.getValidParams(mater_type_name);
        _displacements = getParam<std::vector<VariableName>>("displacements");
        params.set<std::vector<VariableName>>("displacements") = _displacements;
        params.set<std::vector<SubdomainName>>("block") = {_blocks};
 
        if (have_c_integral)
          params.set<bool>("compute_dissipation") = true;
 
        if (_temp != "")
          params.set<std::vector<VariableName>>("temperature") = {_temp};
 
        _problem->addMaterial(mater_type_name, mater_name, params);
      }
      // Strain energy rate density needed for C(t)/C* integral
      if (have_c_integral)
      {
        std::string mater_name;
        const std::string mater_type_name(ad_prepend + "StrainEnergyRateDensity");
        mater_name = ad_prepend + "StrainEnergyRateDensity";
 
        InputParameters params = _factory.getValidParams(mater_type_name);
        params.set<std::vector<SubdomainName>>("block") = {_blocks};
        params.set<std::vector<MaterialName>>("inelastic_models") =
            getParam<std::vector<MaterialName>>("inelastic_models");
 
        _problem->addMaterial(mater_type_name, mater_name, params);
      }
    }
  }
}

◆ addRelationshipManagers() [1/3]

void DomainIntegralAction::addRelationshipManagers ( Moose::RelationshipManagerType input_rm_type )

overridevirtual

Reimplemented from Action.

Definition at line 1053 of file DomainIntegralAction.C.

{
  if (_integrals.count(INTERACTION_INTEGRAL_T) != 0)
  {
    InputParameters params = _factory.getValidParams("CrackFrontDefinition");
    addRelationshipManagers(input_rm_type, params);
  }
}

Referenced by addRelationshipManagers().

◆ addRelationshipManagers() [2/3]

virtual void Action::addRelationshipManagers ( Moose::RelationshipManagerType when_type )

virtual

Reimplemented from Action.

◆ addRelationshipManagers() [3/3]

bool Action::addRelationshipManagers	(	Moose::RelationshipManagerType	when_type,
		const InputParameters &	moose_object_pars
	)

◆ calcNumCrackFrontPoints()

unsigned int DomainIntegralAction::calcNumCrackFrontPoints ( )

protected

Compute the number of points on the crack front.

This is either the number of points in the crack front nodeset, or the number of points from the crack front points provider.

Returns: Number of points on the crack front

Definition at line 1008 of file DomainIntegralAction.C.

{
  unsigned int num_points = 0;
  if (_boundary_names.size() != 0)
  {
    std::vector<BoundaryID> bids = _mesh->getBoundaryIDs(_boundary_names, true);
    std::set<unsigned int> nodes;
 
    ConstBndNodeRange & bnd_nodes = *_mesh->getBoundaryNodeRange();
    for (ConstBndNodeRange::const_iterator nd = bnd_nodes.begin(); nd != bnd_nodes.end(); ++nd)
    {
      const BndNode * bnode = *nd;
      BoundaryID boundary_id = bnode->_bnd_id;
 
      for (unsigned int ibid = 0; ibid < bids.size(); ++ibid)
      {
        if (boundary_id == bids[ibid])
        {
          nodes.insert(bnode->_node->id());
          break;
        }
      }
    }
    num_points = nodes.size();
  }
  else if (_crack_front_points.size() != 0)
    num_points = _crack_front_points.size();
  else if (_use_crack_front_points_provider)
  {
    if (isParamValid("number_points_from_provider"))
      num_points = getParam<unsigned int>("number_points_from_provider");
    else
      // Actual count determined at runtime by CrackFrontDefinition::initialSetup()
      // which calls provider->getNumberOfCrackFrontPoints(). Use 0 here so the
      // action does not create per-point objects that would access crack front data
      // before it exists. The VectorPostprocessors (JIntegral, InteractionIntegral,
      // etc.) dynamically size based on the runtime count.
      num_points = 0;
  }
  else
    mooseError("Must define either 'boundary' or 'crack_front_points'");
  return num_points;
}

Referenced by act().

◆ validParams()

InputParameters DomainIntegralAction::validParams ( )

static

Definition at line 34 of file DomainIntegralAction.C.

{
  InputParameters params = Action::validParams();
  CrackFrontDefinition::includeCrackFrontDefinitionParams(params);
  MultiMooseEnum integral_vec(
      "JIntegral CIntegral KFromJIntegral InteractionIntegralKI InteractionIntegralKII "
      "InteractionIntegralKIII InteractionIntegralT");
  params.addClassDescription(
      "Creates the MOOSE objects needed to compute fraction domain integrals");
  params.addRequiredParam<MultiMooseEnum>("integrals",
                                          integral_vec,
                                          "Domain integrals to calculate.  Choices are: " +
                                              integral_vec.getRawNames());
  params.addParam<std::vector<BoundaryName>>(
      "boundary", {}, "Boundary containing the crack front points");
  params.addParam<std::vector<Point>>("crack_front_points", "Set of points to define crack front");
  params.addParam<std::string>(
      "order", "FIRST", "Specifies the order of the FE shape function to use for q AuxVariables");
  params.addParam<std::string>(
      "family", "LAGRANGE", "Specifies the family of FE shape functions to use for q AuxVariables");
  params.addParam<std::vector<Real>>("radius_inner", "Inner radius for volume integral domain");
  params.addParam<std::vector<Real>>("radius_outer", "Outer radius for volume integral domain");
  params.addParam<unsigned int>("ring_first",
                                "The first ring of elements for volume integral domain");
  params.addParam<unsigned int>("ring_last",
                                "The last ring of elements for volume integral domain");
  params.addParam<std::vector<VariableName>>(
      "output_variable", "Variable values to be reported along the crack front");
  params.addParam<Real>("poissons_ratio", "Poisson's ratio");
  params.addParam<Real>("youngs_modulus", "Young's modulus");
  params.addParam<std::vector<SubdomainName>>(
      "block", {}, "The block ids where integrals are defined");
  params.addParam<std::vector<VariableName>>(
      "displacements",
      {},
      "The displacements appropriate for the simulation geometry and coordinate system");
  params.addParam<VariableName>("temperature", "", "The temperature");
  params.addParam<MaterialPropertyName>(
      "functionally_graded_youngs_modulus_crack_dir_gradient",
      "Gradient of the spatially varying Young's modulus provided in "
      "'functionally_graded_youngs_modulus' in the direction of crack extension.");
  params.addParam<MaterialPropertyName>(
      "functionally_graded_youngs_modulus",
      "Spatially varying elasticity modulus variable. This input is required when "
      "using the functionally graded material capability.");
  params.addCoupledVar("additional_eigenstrain_00",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 00 or XX).");
  params.addCoupledVar("additional_eigenstrain_01",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 01 or XY).");
  params.addCoupledVar("additional_eigenstrain_11",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 11 or YY).");
  params.addCoupledVar("additional_eigenstrain_22",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 22 or ZZ).");
  params.addCoupledVar("additional_eigenstrain_02",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 02 or XZ).");
  params.addCoupledVar("additional_eigenstrain_12",
                       "Optional additional eigenstrain variable that will be accounted for in the "
                       "interaction integral (component 12 or XZ).");
  params.addParamNamesToGroup(
      "additional_eigenstrain_00 additional_eigenstrain_01 additional_eigenstrain_11 "
      "additional_eigenstrain_22 additional_eigenstrain_02 additional_eigenstrain_12",
      "Generic eigenstrains for the computation of the interaction integral.");
  MooseEnum position_type("Angle Distance", "Distance");
  params.addParam<MooseEnum>(
      "position_type",
      position_type,
      "The method used to calculate position along crack front.  Options are: " +
          position_type.getRawNames());
  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());
  params.addParam<bool>(
      "equivalent_k",
      false,
      "Calculate an equivalent K from KI, KII and KIII, assuming self-similar crack growth.");
  params.addParam<bool>("output_q", false, "Output q");
  params.addRequiredParam<bool>(
      "incremental", "Flag to indicate whether an incremental or total model is being used.");
  params.addParam<std::vector<MaterialPropertyName>>(
      "eigenstrain_names", "List of eigenstrains applied in the strain calculation");
  params.addDeprecatedParam<bool>("convert_J_to_K",
                                  false,
                                  "Convert J-integral to stress intensity factor K.",
                                  "This input parameter is deprecated and will be removed soon. "
                                  "Use 'integrals = KFromJIntegral' to request output of the "
                                  "conversion from the J-integral to stress intensity factors");
  params.addParam<std::vector<MaterialName>>(
      "inelastic_models",
      "The material objects to use to calculate the strain energy rate density.");
  params.addParam<MaterialPropertyName>("eigenstrain_gradient",
                                        "Material defining gradient of eigenstrain tensor");
  params.addParam<MaterialPropertyName>("body_force", "Material defining body force");
  params.addParam<bool>("use_automatic_differentiation",
                        false,
                        "Flag to use automatic differentiation (AD) objects when possible");
  params.addParam<bool>("output_vpp",
                        true,
                        "Flag to control the vector postprocessor outputs. Select false to "
                        "suppress the redundant csv files for each time step and ring");
  return params;
}

Member Data Documentation

◆ _axis_2d

unsigned int DomainIntegralAction::_axis_2d

protected

Out-of-plane axis for 3D models treated as 2D.

Definition at line 106 of file DomainIntegralAction.h.

Referenced by act().

◆ _blocks

std::vector<SubdomainName> DomainIntegralAction::_blocks

protected

Blocks for which the domain integrals are to be computed.

Definition at line 124 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _boundary_names

const std::vector<BoundaryName>& DomainIntegralAction::_boundary_names

protected

Boundaries containing the crack front points.

Definition at line 68 of file DomainIntegralAction.h.

Referenced by act(), and calcNumCrackFrontPoints().

◆ _closed_loop

bool DomainIntegralAction::_closed_loop

protected

Indicates whether the crack forms a closed loop.

Definition at line 72 of file DomainIntegralAction.h.

Referenced by act().

◆ _convert_J_to_K

bool DomainIntegralAction::_convert_J_to_K

protected

Whether to convert the J-integral to a stress intensity factor (K) –deprecated.

Definition at line 148 of file DomainIntegralAction.h.

Referenced by DomainIntegralAction().

◆ _crack_direction_vector

const RealVectorValue DomainIntegralAction::_crack_direction_vector

protected

Vector optionally used to prescribe direction of crack extension.

Definition at line 89 of file DomainIntegralAction.h.

Referenced by act().

◆ _crack_direction_vector_end_1

const RealVectorValue DomainIntegralAction::_crack_direction_vector_end_1

protected

Vector optionally used to prescribe direction of crack extension at the 1st end of the crack.

Definition at line 93 of file DomainIntegralAction.h.

Referenced by act().

◆ _crack_direction_vector_end_2

const RealVectorValue DomainIntegralAction::_crack_direction_vector_end_2

protected

Vector optionally used to prescribe direction of crack extension at the 2nd end of the crack.

Definition at line 97 of file DomainIntegralAction.h.

Referenced by act().

◆ _crack_front_points

std::vector<Point> DomainIntegralAction::_crack_front_points

protected

User-defined vector of crack front points.

Definition at line 70 of file DomainIntegralAction.h.

Referenced by act(), calcNumCrackFrontPoints(), and DomainIntegralAction().

◆ _crack_front_points_provider

UserObjectName DomainIntegralAction::_crack_front_points_provider

protected

Name of crack front points provider user object used to optionally define the crack points.

Definition at line 74 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _crack_mouth_boundary_names

std::vector<BoundaryName> DomainIntegralAction::_crack_mouth_boundary_names

protected

Names of boundaries optionally used to define the crack mouth location.

Definition at line 99 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _direction_method_moose_enum

MooseEnum DomainIntegralAction::_direction_method_moose_enum

protected

Enum used to define the method to compute crack front direction.

Definition at line 83 of file DomainIntegralAction.h.

Referenced by act().

◆ _displacements

std::vector<VariableName> DomainIntegralAction::_displacements

protected

Vector of displacement variables.

Definition at line 126 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _end_direction_method_moose_enum

MooseEnum DomainIntegralAction::_end_direction_method_moose_enum

protected

Enum used to define the method to compute crack front direction at ends of crack front.

Definition at line 85 of file DomainIntegralAction.h.

Referenced by act().

◆ _family

const std::string DomainIntegralAction::_family

protected

Definition at line 80 of file DomainIntegralAction.h.

Referenced by act().

◆ _fgm_crack

bool DomainIntegralAction::_fgm_crack

protected

Whether the crack lives in a functionally-graded material.

Definition at line 150 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _functionally_graded_youngs_modulus

MaterialPropertyName DomainIntegralAction::_functionally_graded_youngs_modulus

protected

Material property name for spatially-dependent Youngs modulus for functionally graded materials.

Definition at line 154 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _functionally_graded_youngs_modulus_crack_dir_gradient

MaterialPropertyName DomainIntegralAction::_functionally_graded_youngs_modulus_crack_dir_gradient

protected

Material property name for the Youngs modulus derivative for functionally graded materials.

Definition at line 152 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _get_equivalent_k

bool DomainIntegralAction::_get_equivalent_k

protected

Whether to compute the equivalent K from the individual fracture integrals for mixed-mode fracture.

Definition at line 138 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _has_symmetry_plane

bool DomainIntegralAction::_has_symmetry_plane

protected

Whether the model has a symmetry plane passing through the plane of the crack.

Definition at line 130 of file DomainIntegralAction.h.

Referenced by act().

◆ _have_crack_direction_vector

const bool DomainIntegralAction::_have_crack_direction_vector

protected

Whether the crack direction vector has been provided.

Definition at line 87 of file DomainIntegralAction.h.

Referenced by act().

◆ _have_crack_direction_vector_end_1

const bool DomainIntegralAction::_have_crack_direction_vector_end_1

protected

Whether the crack direction vector at the 1st end of the crack has been provided.

Definition at line 91 of file DomainIntegralAction.h.

Referenced by act().

◆ _have_crack_direction_vector_end_2

const bool DomainIntegralAction::_have_crack_direction_vector_end_2

protected

Whether the crack direction vector at the 2nd end of the crack has been provided.

Definition at line 95 of file DomainIntegralAction.h.

Referenced by act().

◆ _incremental

bool DomainIntegralAction::_incremental

protected

Whether the constitutive models for the mechanics calculations use an incremental form.

Definition at line 146 of file DomainIntegralAction.h.

Referenced by act().

◆ _integrals

std::set<INTEGRAL> DomainIntegralAction::_integrals

protected

Container for enumerations describing the individual integrals computed.

Definition at line 66 of file DomainIntegralAction.h.

Referenced by act(), addRelationshipManagers(), and DomainIntegralAction().

◆ _intersecting_boundary_names

std::vector<BoundaryName> DomainIntegralAction::_intersecting_boundary_names

protected

Names of boundaries optionally used for improved computation of crack extension direction at ends of the crack where it intersects the prescribed boundaries.

Definition at line 102 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _order

const std::string DomainIntegralAction::_order

protected

Order and family of the AuxVariables optionally created to output the values of q.

Definition at line 79 of file DomainIntegralAction.h.

Referenced by act().

◆ _output_q

bool DomainIntegralAction::_output_q

protected

Whether to ouput the q function as a set of AuxVariables.

Definition at line 142 of file DomainIntegralAction.h.

Referenced by act().

◆ _output_variables

std::vector<VariableName> DomainIntegralAction::_output_variables

protected

List of variables for which values are to be sampled and output at the crack front points.

Definition at line 118 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _poissons_ratio

Real DomainIntegralAction::_poissons_ratio

protected

Poisson's ratio of material.

Definition at line 120 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _position_type

MooseEnum DomainIntegralAction::_position_type

protected

How the distance along the crack front is measured (angle or distance)

Definition at line 134 of file DomainIntegralAction.h.

Referenced by act().

◆ _q_function_type

MooseEnum DomainIntegralAction::_q_function_type

protected

How the q function is evaluated (geometric distance from crack front or ring of elements)

Definition at line 136 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _radius_inner

std::vector<Real> DomainIntegralAction::_radius_inner

protected

Sets of inner and outer radii of the rings used for the domain form of the fracture integrals.

These are defined in corresponding pairs for each ring.

Definition at line 110 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _radius_outer

std::vector<Real> DomainIntegralAction::_radius_outer

protected

Definition at line 111 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _ring_first

unsigned int DomainIntegralAction::_ring_first

protected

Number of elements away from the crack tip to inside of inner ring with the topological q function.

Definition at line 114 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _ring_last

unsigned int DomainIntegralAction::_ring_last

protected

Number of elements away from the crack tip to outside of outer ring with the topological q function.

Definition at line 116 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _ring_vec

std::vector<unsigned int> DomainIntegralAction::_ring_vec

protected

Vector of ids for the individual rings on which the fracture integral is computed.

Definition at line 144 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _symmetry_plane

unsigned int DomainIntegralAction::_symmetry_plane

protected

Identifier for which plane is the symmetry plane.

Definition at line 132 of file DomainIntegralAction.h.

Referenced by act().

◆ _temp

VariableName DomainIntegralAction::_temp

protected

Temperature variable.

Definition at line 128 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

◆ _treat_as_2d

bool DomainIntegralAction::_treat_as_2d

protected

Whether fracture computations for a 3D model should be treated as though it were a 2D model.

Definition at line 104 of file DomainIntegralAction.h.

Referenced by act().

◆ _use_ad

const bool DomainIntegralAction::_use_ad

protected

Whether to create automatic differentiation objects from the action.

Definition at line 156 of file DomainIntegralAction.h.

Referenced by act().

◆ _use_crack_front_points_provider

bool DomainIntegralAction::_use_crack_front_points_provider

protected

Whether to use a crack front points provider.

Definition at line 76 of file DomainIntegralAction.h.

Referenced by act(), calcNumCrackFrontPoints(), and DomainIntegralAction().

◆ _use_displaced_mesh

bool DomainIntegralAction::_use_displaced_mesh

protected

Whether to compute the fracture integrals on the displaced mesh.

Definition at line 140 of file DomainIntegralAction.h.

Referenced by act().

◆ _youngs_modulus

Real DomainIntegralAction::_youngs_modulus

protected

Young's modulus of material.

Definition at line 122 of file DomainIntegralAction.h.

Referenced by act(), and DomainIntegralAction().

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

solid_mechanics/include/actions/DomainIntegralAction.h
solid_mechanics/src/actions/DomainIntegralAction.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ INTEGRAL

◆ Q_FUNCTION_TYPE

Constructor & Destructor Documentation

◆ DomainIntegralAction()

◆ ~DomainIntegralAction()

Member Function Documentation

◆ act()

◆ addRelationshipManagers() [1/3]

◆ addRelationshipManagers() [2/3]

◆ addRelationshipManagers() [3/3]

◆ calcNumCrackFrontPoints()

◆ validParams()

Member Data Documentation

◆ _axis_2d

◆ _blocks

◆ _boundary_names

◆ _closed_loop

◆ _convert_J_to_K

◆ _crack_direction_vector

◆ _crack_direction_vector_end_1

◆ _crack_direction_vector_end_2

◆ _crack_front_points

◆ _crack_front_points_provider

◆ _crack_mouth_boundary_names

◆ _direction_method_moose_enum

◆ _displacements

◆ _end_direction_method_moose_enum

◆ _family

◆ _fgm_crack

◆ _functionally_graded_youngs_modulus

◆ _functionally_graded_youngs_modulus_crack_dir_gradient

◆ _get_equivalent_k

◆ _has_symmetry_plane

◆ _have_crack_direction_vector

◆ _have_crack_direction_vector_end_1

◆ _have_crack_direction_vector_end_2

◆ _incremental

◆ _integrals

◆ _intersecting_boundary_names

◆ _order

◆ _output_q

◆ _output_variables

◆ _poissons_ratio

◆ _position_type

◆ _q_function_type

◆ _radius_inner

◆ _radius_outer

◆ _ring_first

◆ _ring_last

◆ _ring_vec

◆ _symmetry_plane

◆ _temp

◆ _treat_as_2d

◆ _use_ad

◆ _use_crack_front_points_provider

◆ _use_displaced_mesh

◆ _youngs_modulus