21 #include "libmesh/string_to_enum.h" 39 "JIntegral CIntegral KFromJIntegral InteractionIntegralKI InteractionIntegralKII " 40 "InteractionIntegralKIII InteractionIntegralT");
42 "Creates the MOOSE objects needed to compute fraction domain integrals");
45 "Domain integrals to calculate. Choices are: " +
47 params.
addParam<std::vector<BoundaryName>>(
48 "boundary", {},
"Boundary containing the crack front points");
49 params.
addParam<std::vector<Point>>(
"crack_front_points",
"Set of points to define crack front");
51 "order",
"FIRST",
"Specifies the order of the FE shape function to use for q AuxVariables");
53 "family",
"LAGRANGE",
"Specifies the family of FE shape functions to use for q AuxVariables");
54 params.
addParam<std::vector<Real>>(
"radius_inner",
"Inner radius for volume integral domain");
55 params.
addParam<std::vector<Real>>(
"radius_outer",
"Outer radius for volume integral domain");
56 params.
addParam<
unsigned int>(
"ring_first",
57 "The first ring of elements for volume integral domain");
58 params.
addParam<
unsigned int>(
"ring_last",
59 "The last ring of elements for volume integral domain");
60 params.
addParam<std::vector<VariableName>>(
61 "output_variable",
"Variable values to be reported along the crack front");
62 params.
addParam<
Real>(
"poissons_ratio",
"Poisson's ratio");
63 params.
addParam<
Real>(
"youngs_modulus",
"Young's modulus");
64 params.
addParam<std::vector<SubdomainName>>(
65 "block", {},
"The block ids where integrals are defined");
66 params.
addParam<std::vector<VariableName>>(
69 "The displacements appropriate for the simulation geometry and coordinate system");
70 params.
addParam<VariableName>(
"temperature",
"",
"The temperature");
71 params.
addParam<MaterialPropertyName>(
72 "functionally_graded_youngs_modulus_crack_dir_gradient",
73 "Gradient of the spatially varying Young's modulus provided in " 74 "'functionally_graded_youngs_modulus' in the direction of crack extension.");
75 params.
addParam<MaterialPropertyName>(
76 "functionally_graded_youngs_modulus",
77 "Spatially varying elasticity modulus variable. This input is required when " 78 "using the functionally graded material capability.");
80 "Optional additional eigenstrain variable that will be accounted for in the " 81 "interaction integral (component 00 or XX).");
83 "Optional additional eigenstrain variable that will be accounted for in the " 84 "interaction integral (component 01 or XY).");
86 "Optional additional eigenstrain variable that will be accounted for in the " 87 "interaction integral (component 11 or YY).");
89 "Optional additional eigenstrain variable that will be accounted for in the " 90 "interaction integral (component 22 or ZZ).");
92 "Optional additional eigenstrain variable that will be accounted for in the " 93 "interaction integral (component 02 or XZ).");
95 "Optional additional eigenstrain variable that will be accounted for in the " 96 "interaction integral (component 12 or XZ).");
98 "additional_eigenstrain_00 additional_eigenstrain_01 additional_eigenstrain_11 " 99 "additional_eigenstrain_22 additional_eigenstrain_02 additional_eigenstrain_12",
100 "Generic eigenstrains for the computation of the interaction integral.");
101 MooseEnum position_type(
"Angle Distance",
"Distance");
105 "The method used to calculate position along crack front. Options are: " +
107 MooseEnum q_function_type(
"Geometry Topology",
"Geometry");
110 "The method used to define the integration domain. Options are: " +
115 "Calculate an equivalent K from KI, KII and KIII, assuming self-similar crack growth.");
116 params.
addParam<
bool>(
"output_q",
true,
"Output q");
118 "incremental",
"Flag to indicate whether an incremental or total model is being used.");
119 params.
addParam<std::vector<MaterialPropertyName>>(
120 "eigenstrain_names",
"List of eigenstrains applied in the strain calculation");
123 "Convert J-integral to stress intensity factor K.",
124 "This input parameter is deprecated and will be removed soon. " 125 "Use 'integrals = KFromJIntegral' to request output of the " 126 "conversion from the J-integral to stress intensity factors");
127 params.
addParam<std::vector<MaterialName>>(
129 "The material objects to use to calculate the strain energy rate density.");
130 params.
addParam<MaterialPropertyName>(
"eigenstrain_gradient",
131 "Material defining gradient of eigenstrain tensor");
132 params.
addParam<MaterialPropertyName>(
"body_force",
"Material defining body force");
133 params.
addParam<
bool>(
"use_automatic_differentiation",
135 "Flag to use automatic differentiation (AD) objects when possible");
138 "Flag to control the vector postprocessor outputs. Select false to " 139 "suppress the redundant csv files for each time step and ring");
145 _boundary_names(getParam<
std::vector<BoundaryName>>(
"boundary")),
146 _closed_loop(getParam<bool>(
"closed_loop")),
147 _use_crack_front_points_provider(false),
148 _order(getParam<
std::string>(
"order")),
149 _family(getParam<
std::string>(
"family")),
150 _direction_method_moose_enum(getParam<
MooseEnum>(
"crack_direction_method")),
151 _end_direction_method_moose_enum(getParam<
MooseEnum>(
"crack_end_direction_method")),
152 _have_crack_direction_vector(isParamValid(
"crack_direction_vector")),
153 _crack_direction_vector(
154 _have_crack_direction_vector ? getParam<
RealVectorValue>(
"crack_direction_vector") : 0.0),
155 _have_crack_direction_vector_end_1(isParamValid(
"crack_direction_vector_end_1")),
156 _crack_direction_vector_end_1(_have_crack_direction_vector_end_1
159 _have_crack_direction_vector_end_2(isParamValid(
"crack_direction_vector_end_2")),
160 _crack_direction_vector_end_2(_have_crack_direction_vector_end_2
163 _treat_as_2d(getParam<bool>(
"2d")),
164 _axis_2d(getParam<unsigned
int>(
"axis_2d")),
165 _has_symmetry_plane(isParamValid(
"symmetry_plane")),
166 _symmetry_plane(_has_symmetry_plane ? getParam<unsigned
int>(
"symmetry_plane")
167 :
std::numeric_limits<unsigned
int>::
max()),
168 _position_type(getParam<
MooseEnum>(
"position_type")),
169 _q_function_type(getParam<
MooseEnum>(
"q_function_type")),
170 _get_equivalent_k(getParam<bool>(
"equivalent_k")),
171 _use_displaced_mesh(false),
172 _output_q(getParam<bool>(
"output_q")),
173 _incremental(getParam<bool>(
"incremental")),
174 _convert_J_to_K(isParamValid(
"convert_J_to_K") ? getParam<bool>(
"convert_J_to_K") : false),
176 _use_ad(getParam<bool>(
"use_automatic_differentiation"))
179 if (
isParamValid(
"functionally_graded_youngs_modulus_crack_dir_gradient") !=
181 paramError(
"functionally_graded_youngs_modulus_crack_dir_gradient",
182 "You have selected to compute the interaction integral for a crack in FGM. That " 183 "selection requires the user to provide a spatially varying elasticity modulus that " 184 "defines the transition of material properties (i.e. " 185 "'functionally_graded_youngs_modulus') and its " 186 "spatial derivative in the crack direction (i.e. " 187 "'functionally_graded_youngs_modulus_crack_dir_gradient').");
189 if (
isParamValid(
"functionally_graded_youngs_modulus_crack_dir_gradient") &&
194 getParam<MaterialPropertyName>(
"functionally_graded_youngs_modulus_crack_dir_gradient");
196 getParam<MaterialPropertyName>(
"functionally_graded_youngs_modulus");
207 mooseError(
"DomainIntegral error: must set radius_inner and radius_outer.");
215 _ring_first = getParam<unsigned int>(
"ring_first");
216 _ring_last = getParam<unsigned int>(
"ring_last");
220 "DomainIntegral error: must set ring_first and ring_last if q_function_type = Topology.");
225 paramError(
"q_function_type",
"DomainIntegral error: invalid q_function_type.");
234 "DomainIntegral error: when crack_front_points_provider is used, " 235 "number_points_from_provider must be provided.");
241 "DomainIntegral error: number_points_from_provider is provided but " 242 "crack_front_points_provider cannot be found.");
248 mooseError(
"Number of entries in 'radius_inner' and 'radius_outer' must match.");
250 bool youngs_modulus_set(
false);
251 bool poissons_ratio_set(
false);
254 _blocks = getParam<std::vector<SubdomainName>>(
"block");
256 MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>(
"integrals");
257 for (
unsigned int i = 0; i < integral_moose_enums.size(); ++i)
259 _displacements = getParam<std::vector<VariableName>>(
"displacements");
264 "DomainIntegral error: The size of the displacements vector should at least be 2.");
266 if (integral_moose_enums[i] !=
"JIntegral" && integral_moose_enums[i] !=
"CIntegral" &&
267 integral_moose_enums[i] !=
"KFromJIntegral")
272 "DomainIntegral error: must set Poisson's ratio and Young's modulus for integral: ",
273 integral_moose_enums[i]);
276 poissons_ratio_set =
true;
278 youngs_modulus_set =
true;
288 "JIntegral, CIntegral, and KFromJIntegral options are mutually exclusive");
298 _temp = getParam<VariableName>(
"temperature");
303 "DomainIntegral error: must provide `eigenstrain_names` when temperature is coupled.");
309 "DomainIntegral error: must calculate KI, KII and KIII to get equivalent K.");
316 "'output_variables' not yet supported with 'crack_front_points'");
322 mooseError(
"DomainIntegral error: must set Young's modulus and Poisson's ratio " 323 "if K_FROM_J_INTEGRAL is selected.");
324 if (!youngs_modulus_set)
326 if (!poissons_ratio_set)
335 "'eigenstrain_gradient' cannot be specified when the computed integrals include " 336 "JIntegral, CIntegral, or KFromJIntegral");
339 "'body_force' cannot be specified when the computed integrals include JIntegral, " 340 "CIntegral, or KFromJIntegral");
344 "'eigenstrain_gradient' cannot be specified together with 'temperature' or " 345 "'eigenstrain_names'. These are for separate, mutually exclusive systems for " 346 "including the effect of eigenstrains");
354 const std::string uo_name(
"crackFrontDefinition");
355 const std::string ak_base_name(
"q");
356 const std::string av_base_name(
"q");
358 const std::string aux_stress_base_name(
"aux_stress");
359 const std::string aux_grad_disp_base_name(
"aux_grad_disp");
362 std::vector<std::string> xfem_exec_flags;
363 for (
const auto & item :
366 if (item.name() ==
"XFEM_MARK")
375 std::string ad_prepend =
"";
381 const std::string uo_type_name(
"CrackFrontDefinition");
387 params.
set<
int>(
"execution_order_group") = -1;
415 {
"crack_front_points_provider, number_points_from_provider"});
425 params.
set<
bool>(
"t_stress") =
true;
428 unsigned int nrings = 0;
431 params.
set<
bool>(
"q_function_rings") =
true;
443 params.
set<
unsigned int>(
"nrings") = nrings;
446 _problem->addUserObject(uo_type_name, uo_name, params);
450 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
452 std::string aux_var_type;
454 aux_var_type =
"MooseVariable";
455 else if (
_family ==
"MONOMIAL")
456 aux_var_type =
"MooseVariableConstMonomial";
458 aux_var_type =
"MooseVariableScalar";
461 ". Please use LAGRANGE, MONOMIAL, or SCALAR");
469 std::ostringstream av_name_stream;
470 av_name_stream << av_base_name <<
"_" <<
_ring_vec[ring_index];
471 _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
475 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
477 std::ostringstream av_name_stream;
478 av_name_stream << av_base_name <<
"_" << cfp_index + 1 <<
"_" <<
_ring_vec[ring_index];
479 _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
487 std::string ak_type_name;
488 unsigned int nrings = 0;
491 ak_type_name =
"DomainIntegralQFunction";
496 ak_type_name =
"DomainIntegralTopologicalQFunction";
502 params.
set<UserObjectName>(
"crack_front_definition") = uo_name;
505 for (
unsigned int ring_index = 0; ring_index < nrings; ++ring_index)
514 params.
set<
unsigned int>(
"ring_index") =
_ring_first + ring_index;
519 std::ostringstream ak_name_stream;
520 ak_name_stream << ak_base_name <<
"_" <<
_ring_vec[ring_index];
521 std::ostringstream av_name_stream;
522 av_name_stream << av_base_name <<
"_" <<
_ring_vec[ring_index];
523 params.
set<AuxVariableName>(
"variable") = av_name_stream.str();
524 _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
528 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
530 std::ostringstream ak_name_stream;
531 ak_name_stream << ak_base_name <<
"_" << cfp_index + 1 <<
"_" <<
_ring_vec[ring_index];
532 std::ostringstream av_name_stream;
533 av_name_stream << av_base_name <<
"_" << cfp_index + 1 <<
"_" <<
_ring_vec[ring_index];
534 params.
set<AuxVariableName>(
"variable") = av_name_stream.str();
535 params.
set<
unsigned int>(
"crack_front_point_index") = cfp_index;
536 _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
546 std::string pp_base_name;
562 pp_base_name =
"II_KI";
566 pp_base_name =
"II_KII";
570 pp_base_name =
"II_KIII";
574 pp_base_name =
"II_T";
577 const std::string pp_type_name(
"VectorPostprocessorComponent");
579 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
583 params.
set<VectorPostprocessorName>(
"vectorpostprocessor") =
586 params.
set<
unsigned int>(
"index") = 0;
587 params.
set<std::string>(
"vector_name") =
589 _problem->addPostprocessor(pp_type_name, pp_name, params);
593 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
595 params.
set<VectorPostprocessorName>(
"vectorpostprocessor") =
597 std::string pp_name = pp_base_name +
"_" +
Moose::stringify(cfp_index + 1) +
"_" +
599 params.
set<
unsigned int>(
"index") = cfp_index;
600 params.
set<std::string>(
"vector_name") =
602 _problem->addPostprocessor(pp_type_name, pp_name, params);
610 std::string pp_base_name(
"Keq");
611 const std::string pp_type_name(
"VectorPostprocessorComponent");
613 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
617 params.
set<VectorPostprocessorName>(
"vectorpostprocessor") =
620 params.
set<
unsigned int>(
"index") = 0;
621 params.
set<std::string>(
"vector_name") =
623 _problem->addPostprocessor(pp_type_name, pp_name, params);
627 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
629 params.
set<VectorPostprocessorName>(
"vectorpostprocessor") =
631 std::string pp_name = pp_base_name +
"_" +
Moose::stringify(cfp_index + 1) +
"_" +
633 params.
set<
unsigned int>(
"index") = cfp_index;
634 params.
set<std::string>(
"vector_name") =
636 _problem->addPostprocessor(pp_type_name, pp_name, params);
645 const std::string pp_type_name(
"CrackFrontData");
648 params.
set<UserObjectName>(
"crack_front_definition") = uo_name;
651 std::ostringstream pp_name_stream;
652 pp_name_stream << ov_base_name <<
"_crack";
654 _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
658 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
660 std::ostringstream pp_name_stream;
661 pp_name_stream << ov_base_name <<
"_crack_" << cfp_index + 1;
663 params.
set<
unsigned int>(
"crack_front_point_index") = cfp_index;
664 _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
675 std::string vpp_base_name;
676 std::string jintegral_selection =
"JIntegral";
681 jintegral_selection =
"JIntegral";
686 jintegral_selection =
"KFromJIntegral";
691 jintegral_selection =
"CIntegral";
695 vpp_base_name +=
"_2DVPP";
697 const std::string vpp_type_name(
"JIntegral");
699 if (!getParam<bool>(
"output_vpp"))
700 params.
set<std::vector<OutputName>>(
"outputs") = {
"none"};
703 params.
set<UserObjectName>(
"crack_front_definition") = uo_name;
704 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
717 params.
set<
MooseEnum>(
"integral") = jintegral_selection;
721 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
723 params.
set<
unsigned int>(
"ring_index") =
_ring_vec[ring_index];
727 _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
739 "In DomainIntegral, symmetry_plane option cannot be used with mode-II or " 740 "mode-III interaction integral");
742 std::string vpp_base_name;
743 std::string vpp_type_name(ad_prepend +
"InteractionIntegral");
746 if (!getParam<bool>(
"output_vpp"))
747 params.
set<std::vector<OutputName>>(
"outputs") = {
"none"};
758 getParam<CoupledName>(
"additional_eigenstrain_00");
760 getParam<CoupledName>(
"additional_eigenstrain_01");
762 getParam<CoupledName>(
"additional_eigenstrain_11");
764 getParam<CoupledName>(
"additional_eigenstrain_22");
767 params.
set<UserObjectName>(
"crack_front_definition") = uo_name;
769 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
776 params.
set<MaterialPropertyName>(
777 "functionally_graded_youngs_modulus_crack_dir_gradient") = {
779 params.
set<MaterialPropertyName>(
"functionally_graded_youngs_modulus") = {
787 params.
set<std::vector<VariableName>>(
"temperature") = {
_temp};
790 params.
set<MaterialPropertyName>(
"eigenstrain_gradient") =
791 parameters().
get<MaterialPropertyName>(
"eigenstrain_gradient");
793 params.
set<MaterialPropertyName>(
"body_force") =
810 vpp_base_name =
"II_KI";
817 vpp_base_name =
"II_KII";
824 vpp_base_name =
"II_KIII";
830 vpp_base_name =
"II_T";
836 vpp_base_name +=
"_2DVPP";
837 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
839 params.
set<
unsigned int>(
"ring_index") =
_ring_vec[ring_index];
843 _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
850 std::string vpp_base_name(
"Keq");
852 vpp_base_name +=
"_2DVPP";
853 const std::string vpp_type_name(
"MixedModeEquivalentK");
858 for (
unsigned int ring_index = 0; ring_index <
_ring_vec.size(); ++ring_index)
860 std::string ki_name =
"II_KI_";
861 std::string kii_name =
"II_KII_";
862 std::string kiii_name =
"II_KIII_";
863 params.
set<
unsigned int>(
"ring_index") =
_ring_vec[ring_index];
866 params.
set<VectorPostprocessorName>(
"KI_vectorpostprocessor") =
868 params.
set<VectorPostprocessorName>(
"KII_vectorpostprocessor") =
870 params.
set<VectorPostprocessorName>(
"KIII_vectorpostprocessor") =
875 params.
set<VectorPostprocessorName>(
"KI_vectorpostprocessor") =
877 params.
set<VectorPostprocessorName>(
"KII_vectorpostprocessor") =
879 params.
set<VectorPostprocessorName>(
"KIII_vectorpostprocessor") =
882 params.
set<std::string>(
"KI_vector_name") =
884 params.
set<std::string>(
"KII_vector_name") =
886 params.
set<std::string>(
"KIII_vector_name") =
889 _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
897 const std::string vpp_type_name(
"VectorOfPostprocessors");
900 std::ostringstream vpp_name_stream;
902 std::vector<PostprocessorName> postprocessor_names;
903 for (
unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
905 std::ostringstream pp_name_stream;
906 pp_name_stream << vpp_name_stream.str() <<
"_" << cfp_index + 1;
907 postprocessor_names.push_back(pp_name_stream.str());
909 params.
set<std::vector<PostprocessorName>>(
"postprocessors") = postprocessor_names;
910 _problem->addVectorPostprocessor(vpp_type_name, vpp_name_stream.str(), params);
919 std::string mater_name;
920 const std::string mater_type_name(
"ThermalFractureIntegral");
921 mater_name =
"ThermalFractureIntegral";
924 params.
set<std::vector<MaterialPropertyName>>(
"eigenstrain_names") =
925 getParam<std::vector<MaterialPropertyName>>(
"eigenstrain_names");
926 params.
set<std::vector<VariableName>>(
"temperature") = {
_temp};
927 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
928 _problem->addMaterial(mater_type_name, mater_name, params);
930 MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>(
"integrals");
931 bool have_j_integral =
false;
932 bool have_c_integral =
false;
934 for (
auto ime : integral_moose_enums)
936 if (ime ==
"JIntegral" || ime ==
"CIntegral" || ime ==
"KFromJIntegral" ||
937 ime ==
"InteractionIntegralKI" || ime ==
"InteractionIntegralKII" ||
938 ime ==
"InteractionIntegralKIII" || ime ==
"InteractionIntegralT")
939 have_j_integral =
true;
941 if (ime ==
"CIntegral")
942 have_c_integral =
true;
946 std::string mater_name;
947 const std::string mater_type_name(ad_prepend +
"StrainEnergyDensity");
948 mater_name = ad_prepend +
"StrainEnergyDensity";
953 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
954 _problem->addMaterial(mater_type_name, mater_name, params);
957 std::string mater_name;
958 const std::string mater_type_name(ad_prepend +
"EshelbyTensor");
959 mater_name = ad_prepend +
"EshelbyTensor";
962 _displacements = getParam<std::vector<VariableName>>(
"displacements");
964 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
967 params.
set<
bool>(
"compute_dissipation") =
true;
970 params.
set<std::vector<VariableName>>(
"temperature") = {
_temp};
972 _problem->addMaterial(mater_type_name, mater_name, params);
977 std::string mater_name;
978 const std::string mater_type_name(ad_prepend +
"StrainEnergyRateDensity");
979 mater_name = ad_prepend +
"StrainEnergyRateDensity";
982 params.
set<std::vector<SubdomainName>>(
"block") = {
_blocks};
983 params.
set<std::vector<MaterialName>>(
"inelastic_models") =
984 getParam<std::vector<MaterialName>>(
"inelastic_models");
986 _problem->addMaterial(mater_type_name, mater_name, params);
995 unsigned int num_points = 0;
999 std::set<unsigned int> nodes;
1007 for (
unsigned int ibid = 0; ibid < bids.size(); ++ibid)
1009 if (boundary_id == bids[ibid])
1011 nodes.insert(bnode->
_node->
id());
1016 num_points = nodes.size();
1021 num_points = getParam<unsigned int>(
"number_points_from_provider");
1023 mooseError(
"Must define either 'boundary' or 'crack_front_points'");
const RealVectorValue _crack_direction_vector
Vector optionally used to prescribe direction of crack extension.
unsigned int _symmetry_plane
Identifier for which plane is the symmetry plane.
VariableName _temp
Temperature variable.
std::vector< VariableName > _output_variables
List of variables for which values are to be sampled and output at the crack front points...
const std::vector< BoundaryName > & _boundary_names
Boundaries containing the crack front points.
virtual void act() override
UserObjectName _crack_front_points_provider
Name of crack front points provider user object used to optionally define the crack points...
const std::string _order
Order and family of the AuxVariables optionally created to output the values of q.
const bool _have_crack_direction_vector_end_2
Whether the crack direction vector at the 2nd end of the crack has been provided. ...
MaterialPropertyName _functionally_graded_youngs_modulus
Material property name for spatially-dependent Youngs modulus for functionally graded materials...
void addCrackFrontDefinitionParams(InputParameters ¶ms)
const bool _have_crack_direction_vector
Whether the crack direction vector has been provided.
std::vector< BoundaryName > _intersecting_boundary_names
Names of boundaries optionally used for improved computation of crack extension direction at ends of ...
InputParameters getValidParams(const std::string &name) const
unsigned int calcNumCrackFrontPoints()
Compute the number of points on the crack front.
Action to set up all objects used in computation of fracture domain integrals.
const ExecFlagType EXEC_TIMESTEP_END
const bool _use_ad
Whether to create automatic differentiation objects from the action.
std::vector< Real > _radius_inner
Sets of inner and outer radii of the rings used for the domain form of the fracture integrals...
std::string getRawNames() const
static ExecFlagRegistry & getExecFlagRegistry()
bool _has_symmetry_plane
Whether the model has a symmetry plane passing through the plane of the crack.
bool _use_crack_front_points_provider
Whether to use a crack front points provider.
virtual const std::string & name() const
auto max(const L &left, const R &right)
bool isParamValid(const std::string &name) const
DomainIntegralAction(const InputParameters ¶ms)
bool _treat_as_2d
Whether fracture computations for a 3D model should be treated as though it were a 2D model...
Real _poissons_ratio
Poisson's ratio of material.
const std::string _family
static InputParameters validParams()
MooseEnum _direction_method_moose_enum
Enum used to define the method to compute crack front direction.
boundary_id_type BoundaryID
static InputParameters validParams()
std::vector< VariableName > _displacements
Vector of displacement variables.
std::vector< BoundaryName > _crack_mouth_boundary_names
Names of boundaries optionally used to define the crack mouth location.
const T & getParam(const std::string &name) const
const std::string & _current_task
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override
void paramError(const std::string ¶m, Args... args) const
std::vector< SubdomainName > _blocks
Blocks for which the domain integrals are to be computed.
std::string stringify(const T &t)
MooseEnum _end_direction_method_moose_enum
Enum used to define the method to compute crack front direction at ends of crack front.
std::vector< unsigned int > _ring_vec
Vector of ids for the individual rings on which the fracture integral is computed.
const_iterator end() const
bool _incremental
Whether the constitutive models for the mechanics calculations use an incremental form...
const ExecFlagType EXEC_NONLINEAR
std::vector< Real > _radius_outer
MooseEnum _q_function_type
How the q function is evaluated (geometric distance from crack front or ring of elements) ...
const bool _have_crack_direction_vector_end_1
Whether the crack direction vector at the 1st end of the crack has been provided. ...
std::shared_ptr< MooseMesh > & _mesh
bool _convert_J_to_K
Whether to convert the J-integral to a stress intensity factor (K) –deprecated.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
MaterialPropertyName _functionally_graded_youngs_modulus_crack_dir_gradient
Material property name for the Youngs modulus derivative for functionally graded materials.
bool _use_displaced_mesh
Whether to compute the fracture integrals on the displaced mesh.
vec_type::const_iterator const_iterator
std::vector< VariableName > CoupledName
const RealVectorValue _crack_direction_vector_end_1
Vector optionally used to prescribe direction of crack extension at the 1st end of the crack...
const_iterator begin() const
INTEGRAL
Enum used to select the type of integral to be performed.
void mooseError(Args &&... args) const
bool _output_q
Whether to ouput the q function as a set of AuxVariables.
std::shared_ptr< FEProblemBase > & _problem
const InputParameters & parameters() const
bool _get_equivalent_k
Whether to compute the equivalent K from the individual fracture integrals for mixed-mode fracture...
MooseEnum _position_type
How the distance along the crack front is measured (angle or distance)
std::vector< Point > _crack_front_points
User-defined vector of crack front points.
unsigned int _ring_last
Number of elements away from the crack tip to outside of outer ring with the topological q function...
unsigned int _ring_first
Number of elements away from the crack tip to inside of inner ring with the topological q function...
bool _fgm_crack
Whether the crack lives in a functionally-graded material.
const RealVectorValue _crack_direction_vector_end_2
Vector optionally used to prescribe direction of crack extension at the 2nd end of the crack...
MooseUnits pow(const MooseUnits &, int)
unsigned int _axis_2d
Out-of-plane axis for 3D models treated as 2D.
bool _closed_loop
Indicates whether the crack forms a closed loop.
void ErrorVector unsigned int
Real _youngs_modulus
Young's modulus of material.
std::set< INTEGRAL > _integrals
Container for enumerations describing the individual integrals computed.
registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_user_object")
const ExecFlagType EXEC_INITIAL