Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
3 : //*
4 : //* All rights reserved, see COPYRIGHT for full restrictions
5 : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 : //*
7 : //* Licensed under LGPL 2.1, please see LICENSE for details
8 : //* https://www.gnu.org/licenses/lgpl-2.1.html
9 :
10 : // MOOSE includes
11 : #include "DomainIntegralAction.h"
12 : #include "ExecFlagRegistry.h"
13 : #include "Factory.h"
14 : #include "FEProblem.h"
15 : #include "Moose.h"
16 : #include "Parser.h"
17 : #include "CrackFrontDefinition.h"
18 : #include "MooseMesh.h"
19 : #include "Conversion.h"
20 :
21 : #include "libmesh/string_to_enum.h"
22 :
23 : registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_user_object");
24 :
25 : registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_aux_variable");
26 :
27 : registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_aux_kernel");
28 :
29 : registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_postprocessor");
30 :
31 : registerMooseAction("SolidMechanicsApp", DomainIntegralAction, "add_material");
32 :
33 : InputParameters
34 2156 : DomainIntegralAction::validParams()
35 : {
36 2156 : InputParameters params = Action::validParams();
37 2156 : CrackFrontDefinition::includeCrackFrontDefinitionParams(params);
38 : MultiMooseEnum integral_vec(
39 : "JIntegral CIntegral KFromJIntegral InteractionIntegralKI InteractionIntegralKII "
40 2156 : "InteractionIntegralKIII InteractionIntegralT");
41 2156 : params.addClassDescription(
42 : "Creates the MOOSE objects needed to compute fraction domain integrals");
43 4312 : params.addRequiredParam<MultiMooseEnum>("integrals",
44 : integral_vec,
45 2156 : "Domain integrals to calculate. Choices are: " +
46 2156 : integral_vec.getRawNames());
47 4312 : params.addParam<std::vector<BoundaryName>>(
48 : "boundary", {}, "Boundary containing the crack front points");
49 4312 : params.addParam<std::vector<Point>>("crack_front_points", "Set of points to define crack front");
50 4312 : params.addParam<std::string>(
51 : "order", "FIRST", "Specifies the order of the FE shape function to use for q AuxVariables");
52 4312 : params.addParam<std::string>(
53 : "family", "LAGRANGE", "Specifies the family of FE shape functions to use for q AuxVariables");
54 4312 : params.addParam<std::vector<Real>>("radius_inner", "Inner radius for volume integral domain");
55 4312 : params.addParam<std::vector<Real>>("radius_outer", "Outer radius for volume integral domain");
56 4312 : params.addParam<unsigned int>("ring_first",
57 : "The first ring of elements for volume integral domain");
58 4312 : params.addParam<unsigned int>("ring_last",
59 : "The last ring of elements for volume integral domain");
60 4312 : params.addParam<std::vector<VariableName>>(
61 : "output_variable", "Variable values to be reported along the crack front");
62 4312 : params.addParam<Real>("poissons_ratio", "Poisson's ratio");
63 4312 : params.addParam<Real>("youngs_modulus", "Young's modulus");
64 4312 : params.addParam<std::vector<SubdomainName>>(
65 : "block", {}, "The block ids where integrals are defined");
66 4312 : params.addParam<std::vector<VariableName>>(
67 : "displacements",
68 : {},
69 : "The displacements appropriate for the simulation geometry and coordinate system");
70 4312 : params.addParam<VariableName>("temperature", "", "The temperature");
71 4312 : 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 4312 : 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.");
79 4312 : params.addCoupledVar("additional_eigenstrain_00",
80 : "Optional additional eigenstrain variable that will be accounted for in the "
81 : "interaction integral (component 00 or XX).");
82 4312 : params.addCoupledVar("additional_eigenstrain_01",
83 : "Optional additional eigenstrain variable that will be accounted for in the "
84 : "interaction integral (component 01 or XY).");
85 4312 : params.addCoupledVar("additional_eigenstrain_11",
86 : "Optional additional eigenstrain variable that will be accounted for in the "
87 : "interaction integral (component 11 or YY).");
88 4312 : params.addCoupledVar("additional_eigenstrain_22",
89 : "Optional additional eigenstrain variable that will be accounted for in the "
90 : "interaction integral (component 22 or ZZ).");
91 4312 : params.addCoupledVar("additional_eigenstrain_02",
92 : "Optional additional eigenstrain variable that will be accounted for in the "
93 : "interaction integral (component 02 or XZ).");
94 4312 : params.addCoupledVar("additional_eigenstrain_12",
95 : "Optional additional eigenstrain variable that will be accounted for in the "
96 : "interaction integral (component 12 or XZ).");
97 4312 : params.addParamNamesToGroup(
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 4312 : MooseEnum position_type("Angle Distance", "Distance");
102 4312 : params.addParam<MooseEnum>(
103 : "position_type",
104 : position_type,
105 2156 : "The method used to calculate position along crack front. Options are: " +
106 2156 : position_type.getRawNames());
107 4312 : MooseEnum q_function_type("Geometry Topology", "Geometry");
108 4312 : params.addParam<MooseEnum>("q_function_type",
109 : q_function_type,
110 2156 : "The method used to define the integration domain. Options are: " +
111 2156 : q_function_type.getRawNames());
112 4312 : params.addParam<bool>(
113 : "equivalent_k",
114 4312 : false,
115 : "Calculate an equivalent K from KI, KII and KIII, assuming self-similar crack growth.");
116 4312 : params.addParam<bool>("output_q", true, "Output q");
117 4312 : params.addRequiredParam<bool>(
118 : "incremental", "Flag to indicate whether an incremental or total model is being used.");
119 4312 : params.addParam<std::vector<MaterialPropertyName>>(
120 : "eigenstrain_names", "List of eigenstrains applied in the strain calculation");
121 6468 : params.addDeprecatedParam<bool>("convert_J_to_K",
122 4312 : false,
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 4312 : params.addParam<std::vector<MaterialName>>(
128 : "inelastic_models",
129 : "The material objects to use to calculate the strain energy rate density.");
130 4312 : params.addParam<MaterialPropertyName>("eigenstrain_gradient",
131 : "Material defining gradient of eigenstrain tensor");
132 4312 : params.addParam<MaterialPropertyName>("body_force", "Material defining body force");
133 4312 : params.addParam<bool>("use_automatic_differentiation",
134 4312 : false,
135 : "Flag to use automatic differentiation (AD) objects when possible");
136 4312 : params.addParam<bool>("output_vpp",
137 4312 : true,
138 : "Flag to control the vector postprocessor outputs. Select false to "
139 : "suppress the redundant csv files for each time step and ring");
140 2156 : return params;
141 2156 : }
142 :
143 2156 : DomainIntegralAction::DomainIntegralAction(const InputParameters & params)
144 : : Action(params),
145 4312 : _boundary_names(getParam<std::vector<BoundaryName>>("boundary")),
146 4312 : _closed_loop(getParam<bool>("closed_loop")),
147 2156 : _use_crack_front_points_provider(false),
148 4312 : _order(getParam<std::string>("order")),
149 4312 : _family(getParam<std::string>("family")),
150 4312 : _direction_method_moose_enum(getParam<MooseEnum>("crack_direction_method")),
151 4312 : _end_direction_method_moose_enum(getParam<MooseEnum>("crack_end_direction_method")),
152 4312 : _have_crack_direction_vector(isParamValid("crack_direction_vector")),
153 1752 : _crack_direction_vector(
154 2156 : _have_crack_direction_vector ? getParam<RealVectorValue>("crack_direction_vector") : 0.0),
155 4312 : _have_crack_direction_vector_end_1(isParamValid("crack_direction_vector_end_1")),
156 320 : _crack_direction_vector_end_1(_have_crack_direction_vector_end_1
157 2156 : ? getParam<RealVectorValue>("crack_direction_vector_end_1")
158 : : 0.0),
159 4312 : _have_crack_direction_vector_end_2(isParamValid("crack_direction_vector_end_2")),
160 320 : _crack_direction_vector_end_2(_have_crack_direction_vector_end_2
161 4312 : ? getParam<RealVectorValue>("crack_direction_vector_end_2")
162 : : 0.0),
163 4312 : _treat_as_2d(getParam<bool>("2d")),
164 4312 : _axis_2d(getParam<unsigned int>("axis_2d")),
165 4312 : _has_symmetry_plane(isParamValid("symmetry_plane")),
166 3628 : _symmetry_plane(_has_symmetry_plane ? getParam<unsigned int>("symmetry_plane")
167 : : std::numeric_limits<unsigned int>::max()),
168 4312 : _position_type(getParam<MooseEnum>("position_type")),
169 4312 : _q_function_type(getParam<MooseEnum>("q_function_type")),
170 4312 : _get_equivalent_k(getParam<bool>("equivalent_k")),
171 2156 : _use_displaced_mesh(false),
172 4312 : _output_q(getParam<bool>("output_q")),
173 4312 : _incremental(getParam<bool>("incremental")),
174 8624 : _convert_J_to_K(isParamValid("convert_J_to_K") ? getParam<bool>("convert_J_to_K") : false),
175 2156 : _fgm_crack(false),
176 6468 : _use_ad(getParam<bool>("use_automatic_differentiation"))
177 : {
178 :
179 4312 : if (isParamValid("functionally_graded_youngs_modulus_crack_dir_gradient") !=
180 4312 : isParamValid("functionally_graded_youngs_modulus"))
181 2 : 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').");
188 :
189 6462 : if (isParamValid("functionally_graded_youngs_modulus_crack_dir_gradient") &&
190 2322 : isParamValid("functionally_graded_youngs_modulus"))
191 : {
192 84 : _fgm_crack = true;
193 : _functionally_graded_youngs_modulus_crack_dir_gradient =
194 84 : getParam<MaterialPropertyName>("functionally_graded_youngs_modulus_crack_dir_gradient");
195 : _functionally_graded_youngs_modulus =
196 168 : getParam<MaterialPropertyName>("functionally_graded_youngs_modulus");
197 : }
198 :
199 2154 : if (_q_function_type == GEOMETRY)
200 : {
201 7776 : if (isParamValid("radius_inner") && isParamValid("radius_outer"))
202 : {
203 3888 : _radius_inner = getParam<std::vector<Real>>("radius_inner");
204 3888 : _radius_outer = getParam<std::vector<Real>>("radius_outer");
205 : }
206 : else
207 0 : mooseError("DomainIntegral error: must set radius_inner and radius_outer.");
208 9048 : for (unsigned int i = 0; i < _radius_inner.size(); ++i)
209 7104 : _ring_vec.push_back(i + 1);
210 : }
211 210 : else if (_q_function_type == TOPOLOGY)
212 : {
213 840 : if (isParamValid("ring_first") && isParamValid("ring_last"))
214 : {
215 420 : _ring_first = getParam<unsigned int>("ring_first");
216 420 : _ring_last = getParam<unsigned int>("ring_last");
217 : }
218 : else
219 0 : mooseError(
220 : "DomainIntegral error: must set ring_first and ring_last if q_function_type = Topology.");
221 924 : for (unsigned int i = _ring_first; i <= _ring_last; ++i)
222 714 : _ring_vec.push_back(i);
223 : }
224 : else
225 0 : paramError("q_function_type", "DomainIntegral error: invalid q_function_type.");
226 :
227 4308 : if (isParamValid("crack_front_points"))
228 612 : _crack_front_points = getParam<std::vector<Point>>("crack_front_points");
229 :
230 4308 : if (isParamValid("crack_front_points_provider"))
231 : {
232 0 : if (!isParamValid("number_points_from_provider"))
233 0 : paramError("number_points_from_provider",
234 : "DomainIntegral error: when crack_front_points_provider is used, "
235 : "number_points_from_provider must be provided.");
236 0 : _use_crack_front_points_provider = true;
237 0 : _crack_front_points_provider = getParam<UserObjectName>("crack_front_points_provider");
238 : }
239 4308 : else if (isParamValid("number_points_from_provider"))
240 0 : paramError("crack_front_points_provider",
241 : "DomainIntegral error: number_points_from_provider is provided but "
242 : "crack_front_points_provider cannot be found.");
243 4308 : if (isParamValid("crack_mouth_boundary"))
244 648 : _crack_mouth_boundary_names = getParam<std::vector<BoundaryName>>("crack_mouth_boundary");
245 4308 : if (isParamValid("intersecting_boundary"))
246 828 : _intersecting_boundary_names = getParam<std::vector<BoundaryName>>("intersecting_boundary");
247 2154 : if (_radius_inner.size() != _radius_outer.size())
248 0 : mooseError("Number of entries in 'radius_inner' and 'radius_outer' must match.");
249 :
250 : bool youngs_modulus_set(false);
251 : bool poissons_ratio_set(false);
252 :
253 : // All domain integral types block restrict the objects created by this action.
254 4308 : _blocks = getParam<std::vector<SubdomainName>>("block");
255 :
256 4308 : MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>("integrals");
257 5554 : for (unsigned int i = 0; i < integral_moose_enums.size(); ++i)
258 : {
259 10200 : _displacements = getParam<std::vector<VariableName>>("displacements");
260 :
261 3400 : if (_displacements.size() < 2)
262 0 : paramError(
263 : "displacements",
264 : "DomainIntegral error: The size of the displacements vector should at least be 2.");
265 :
266 5248 : if (integral_moose_enums[i] != "JIntegral" && integral_moose_enums[i] != "CIntegral" &&
267 1848 : integral_moose_enums[i] != "KFromJIntegral")
268 : {
269 : // Check that parameters required for interaction integrals are defined
270 7224 : if (!(isParamValid("poissons_ratio")) || !(isParamValid("youngs_modulus")))
271 0 : mooseError(
272 : "DomainIntegral error: must set Poisson's ratio and Young's modulus for integral: ",
273 0 : integral_moose_enums[i]);
274 :
275 3612 : _poissons_ratio = getParam<Real>("poissons_ratio");
276 : poissons_ratio_set = true;
277 3612 : _youngs_modulus = getParam<Real>("youngs_modulus");
278 : youngs_modulus_set = true;
279 : }
280 :
281 3400 : _integrals.insert(INTEGRAL(int(integral_moose_enums.get(i))));
282 : }
283 :
284 2154 : if ((_integrals.count(J_INTEGRAL) != 0 && _integrals.count(C_INTEGRAL) != 0) ||
285 2154 : (_integrals.count(J_INTEGRAL) != 0 && _integrals.count(K_FROM_J_INTEGRAL) != 0) ||
286 2154 : (_integrals.count(C_INTEGRAL) != 0 && _integrals.count(K_FROM_J_INTEGRAL) != 0))
287 0 : paramError("integrals",
288 : "JIntegral, CIntegral, and KFromJIntegral options are mutually exclusive");
289 :
290 : // Acommodate deprecated parameter convert_J_to_K
291 2154 : if (_convert_J_to_K && _integrals.count(K_FROM_J_INTEGRAL) != 0)
292 : {
293 0 : _integrals.insert(K_FROM_J_INTEGRAL);
294 0 : _integrals.erase(J_INTEGRAL);
295 : }
296 :
297 4308 : if (isParamValid("temperature"))
298 4308 : _temp = getParam<VariableName>("temperature");
299 :
300 2916 : if (_temp != "" && !isParamValid("eigenstrain_names"))
301 0 : paramError(
302 : "eigenstrain_names",
303 : "DomainIntegral error: must provide `eigenstrain_names` when temperature is coupled.");
304 :
305 2154 : if (_get_equivalent_k && (_integrals.count(INTERACTION_INTEGRAL_KI) == 0 ||
306 390 : _integrals.count(INTERACTION_INTEGRAL_KII) == 0 ||
307 390 : _integrals.count(INTERACTION_INTEGRAL_KIII) == 0))
308 0 : paramError("integrals",
309 : "DomainIntegral error: must calculate KI, KII and KIII to get equivalent K.");
310 :
311 4308 : if (isParamValid("output_variable"))
312 : {
313 630 : _output_variables = getParam<std::vector<VariableName>>("output_variable");
314 210 : if (_crack_front_points.size() > 0)
315 0 : paramError("output_variables",
316 : "'output_variables' not yet supported with 'crack_front_points'");
317 : }
318 :
319 2154 : if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
320 : {
321 168 : if (!isParamValid("youngs_modulus") || !isParamValid("poissons_ratio"))
322 0 : mooseError("DomainIntegral error: must set Young's modulus and Poisson's ratio "
323 : "if K_FROM_J_INTEGRAL is selected.");
324 42 : if (!youngs_modulus_set)
325 0 : _youngs_modulus = getParam<Real>("youngs_modulus");
326 42 : if (!poissons_ratio_set)
327 0 : _poissons_ratio = getParam<Real>("poissons_ratio");
328 : }
329 :
330 2154 : if (_integrals.count(J_INTEGRAL) != 0 || _integrals.count(C_INTEGRAL) != 0 ||
331 602 : _integrals.count(K_FROM_J_INTEGRAL) != 0)
332 : {
333 3188 : if (isParamValid("eigenstrain_gradient"))
334 2 : paramError("eigenstrain_gradient",
335 : "'eigenstrain_gradient' cannot be specified when the computed integrals include "
336 : "JIntegral, CIntegral, or KFromJIntegral");
337 3184 : if (isParamValid("body_force"))
338 2 : paramError("body_force",
339 : "'body_force' cannot be specified when the computed integrals include JIntegral, "
340 : "CIntegral, or KFromJIntegral");
341 : }
342 4384 : if (isParamValid("eigenstrain_gradient") && (_temp != "" || isParamValid("eigenstrain_names")))
343 2 : paramError("eigenstrain_gradient",
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");
347 2148 : }
348 :
349 10680 : DomainIntegralAction::~DomainIntegralAction() {}
350 :
351 : void
352 2142 : DomainIntegralAction::act()
353 : {
354 2142 : const std::string uo_name("crackFrontDefinition");
355 2142 : const std::string ak_base_name("q");
356 2142 : const std::string av_base_name("q");
357 2142 : const unsigned int num_crack_front_points = calcNumCrackFrontPoints();
358 2142 : const std::string aux_stress_base_name("aux_stress");
359 2142 : const std::string aux_grad_disp_base_name("aux_grad_disp");
360 :
361 : // checking if built with xfem and setting flags for vpps used by xfem
362 6426 : std::vector<std::string> xfem_exec_flags = {EXEC_XFEM_MARK, EXEC_TIMESTEP_END};
363 :
364 2142 : std::string ad_prepend = "";
365 2142 : if (_use_ad)
366 : ad_prepend = "AD";
367 :
368 2142 : if (_current_task == "add_user_object")
369 : {
370 358 : const std::string uo_type_name("CrackFrontDefinition");
371 :
372 358 : InputParameters params = _factory.getValidParams(uo_type_name);
373 358 : if (_use_crack_front_points_provider)
374 : {
375 : // The CrackFrontDefinition updates the vpps and MUST execute before them
376 0 : params.set<int>("execution_order_group") = -1;
377 0 : params.set<ExecFlagEnum>("execute_on") = xfem_exec_flags;
378 : }
379 : else
380 1432 : params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
381 :
382 358 : params.set<MooseEnum>("crack_direction_method") = _direction_method_moose_enum;
383 358 : params.set<MooseEnum>("crack_end_direction_method") = _end_direction_method_moose_enum;
384 358 : if (_have_crack_direction_vector)
385 291 : params.set<RealVectorValue>("crack_direction_vector") = _crack_direction_vector;
386 358 : if (_have_crack_direction_vector_end_1)
387 53 : params.set<RealVectorValue>("crack_direction_vector_end_1") = _crack_direction_vector_end_1;
388 358 : if (_have_crack_direction_vector_end_2)
389 53 : params.set<RealVectorValue>("crack_direction_vector_end_2") = _crack_direction_vector_end_2;
390 358 : if (_crack_mouth_boundary_names.size() != 0)
391 72 : params.set<std::vector<BoundaryName>>("crack_mouth_boundary") = _crack_mouth_boundary_names;
392 358 : if (_intersecting_boundary_names.size() != 0)
393 92 : params.set<std::vector<BoundaryName>>("intersecting_boundary") = _intersecting_boundary_names;
394 358 : params.set<bool>("2d") = _treat_as_2d;
395 358 : params.set<unsigned int>("axis_2d") = _axis_2d;
396 358 : if (_has_symmetry_plane)
397 244 : params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
398 358 : if (_boundary_names.size() != 0)
399 648 : params.set<std::vector<BoundaryName>>("boundary") = _boundary_names;
400 358 : if (_crack_front_points.size() != 0)
401 68 : params.set<std::vector<Point>>("crack_front_points") = _crack_front_points;
402 358 : if (_use_crack_front_points_provider)
403 0 : params.applyParameters(parameters(),
404 : {"crack_front_points_provider, number_points_from_provider"});
405 358 : if (_closed_loop)
406 0 : params.set<bool>("closed_loop") = _closed_loop;
407 358 : params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
408 358 : if (_integrals.count(INTERACTION_INTEGRAL_T) != 0)
409 : {
410 42 : params.set<VariableName>("disp_x") = _displacements[0];
411 42 : params.set<VariableName>("disp_y") = _displacements[1];
412 21 : if (_displacements.size() == 3)
413 28 : params.set<VariableName>("disp_z") = _displacements[2];
414 21 : params.set<bool>("t_stress") = true;
415 : }
416 :
417 : unsigned int nrings = 0;
418 358 : if (_q_function_type == TOPOLOGY)
419 : {
420 35 : params.set<bool>("q_function_rings") = true;
421 35 : params.set<unsigned int>("last_ring") = _ring_last;
422 35 : params.set<unsigned int>("first_ring") = _ring_first;
423 35 : nrings = _ring_last - _ring_first + 1;
424 : }
425 323 : else if (_q_function_type == GEOMETRY)
426 : {
427 323 : params.set<std::vector<Real>>("j_integral_radius_inner") = _radius_inner;
428 646 : params.set<std::vector<Real>>("j_integral_radius_outer") = _radius_outer;
429 323 : nrings = _ring_vec.size();
430 : }
431 :
432 358 : params.set<unsigned int>("nrings") = nrings;
433 358 : params.set<MooseEnum>("q_function_type") = _q_function_type;
434 :
435 358 : _problem->addUserObject(uo_type_name, uo_name, params);
436 358 : }
437 1784 : else if (_current_task == "add_aux_variable" && _output_q)
438 : {
439 921 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
440 : {
441 : std::string aux_var_type;
442 719 : if (_family == "LAGRANGE")
443 : aux_var_type = "MooseVariable";
444 0 : else if (_family == "MONOMIAL")
445 : aux_var_type = "MooseVariableConstMonomial";
446 0 : else if (_family == "SCALAR")
447 : aux_var_type = "MooseVariableScalar";
448 : else
449 0 : mooseError("Unsupported finite element family in, " + name() +
450 : ". Please use LAGRANGE, MONOMIAL, or SCALAR");
451 :
452 719 : auto params = _factory.getValidParams(aux_var_type);
453 719 : params.set<MooseEnum>("order") = _order;
454 719 : params.set<MooseEnum>("family") = _family;
455 :
456 719 : if (_treat_as_2d && _use_crack_front_points_provider == false)
457 : {
458 516 : std::ostringstream av_name_stream;
459 516 : av_name_stream << av_base_name << "_" << _ring_vec[ring_index];
460 516 : _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
461 516 : }
462 : else
463 : {
464 1280 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
465 : {
466 1077 : std::ostringstream av_name_stream;
467 1077 : av_name_stream << av_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
468 1077 : _problem->addAuxVariable(aux_var_type, av_name_stream.str(), params);
469 1077 : }
470 : }
471 719 : }
472 : }
473 :
474 1582 : else if (_current_task == "add_aux_kernel" && _output_q)
475 : {
476 : std::string ak_type_name;
477 : unsigned int nrings = 0;
478 202 : if (_q_function_type == GEOMETRY)
479 : {
480 : ak_type_name = "DomainIntegralQFunction";
481 188 : nrings = _ring_vec.size();
482 : }
483 14 : else if (_q_function_type == TOPOLOGY)
484 : {
485 : ak_type_name = "DomainIntegralTopologicalQFunction";
486 14 : nrings = _ring_last - _ring_first + 1;
487 : }
488 :
489 202 : InputParameters params = _factory.getValidParams(ak_type_name);
490 808 : params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
491 404 : params.set<UserObjectName>("crack_front_definition") = uo_name;
492 202 : params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
493 :
494 921 : for (unsigned int ring_index = 0; ring_index < nrings; ++ring_index)
495 : {
496 719 : if (_q_function_type == GEOMETRY)
497 : {
498 670 : params.set<Real>("j_integral_radius_inner") = _radius_inner[ring_index];
499 670 : params.set<Real>("j_integral_radius_outer") = _radius_outer[ring_index];
500 : }
501 49 : else if (_q_function_type == TOPOLOGY)
502 : {
503 49 : params.set<unsigned int>("ring_index") = _ring_first + ring_index;
504 : }
505 :
506 719 : if (_treat_as_2d && _use_crack_front_points_provider == false)
507 : {
508 516 : std::ostringstream ak_name_stream;
509 516 : ak_name_stream << ak_base_name << "_" << _ring_vec[ring_index];
510 516 : std::ostringstream av_name_stream;
511 516 : av_name_stream << av_base_name << "_" << _ring_vec[ring_index];
512 1032 : params.set<AuxVariableName>("variable") = av_name_stream.str();
513 516 : _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
514 516 : }
515 : else
516 : {
517 1280 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
518 : {
519 1077 : std::ostringstream ak_name_stream;
520 1077 : ak_name_stream << ak_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
521 1077 : std::ostringstream av_name_stream;
522 2154 : av_name_stream << av_base_name << "_" << cfp_index + 1 << "_" << _ring_vec[ring_index];
523 2154 : params.set<AuxVariableName>("variable") = av_name_stream.str();
524 1077 : params.set<unsigned int>("crack_front_point_index") = cfp_index;
525 1077 : _problem->addAuxKernel(ak_type_name, ak_name_stream.str(), params);
526 1077 : }
527 : }
528 : }
529 202 : }
530 :
531 1380 : else if (_current_task == "add_postprocessor")
532 : {
533 919 : for (std::set<INTEGRAL>::iterator sit = _integrals.begin(); sit != _integrals.end(); ++sit)
534 : {
535 : std::string pp_base_name;
536 563 : switch (*sit)
537 : {
538 : case J_INTEGRAL:
539 : pp_base_name = "J";
540 : break;
541 :
542 : case C_INTEGRAL:
543 : pp_base_name = "C";
544 : break;
545 :
546 : case K_FROM_J_INTEGRAL:
547 : pp_base_name = "K";
548 : break;
549 :
550 : case INTERACTION_INTEGRAL_KI:
551 : pp_base_name = "II_KI";
552 : break;
553 :
554 : case INTERACTION_INTEGRAL_KII:
555 : pp_base_name = "II_KII";
556 : break;
557 :
558 : case INTERACTION_INTEGRAL_KIII:
559 : pp_base_name = "II_KIII";
560 : break;
561 :
562 : case INTERACTION_INTEGRAL_T:
563 : pp_base_name = "II_T";
564 : break;
565 : }
566 563 : const std::string pp_type_name("VectorPostprocessorComponent");
567 1126 : InputParameters params = _factory.getValidParams(pp_type_name);
568 2544 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
569 : {
570 1981 : if (_treat_as_2d && _use_crack_front_points_provider == false)
571 : {
572 2804 : params.set<VectorPostprocessorName>("vectorpostprocessor") =
573 2804 : pp_base_name + "_2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
574 2804 : std::string pp_name = pp_base_name + +"_" + Moose::stringify(_ring_vec[ring_index]);
575 1402 : params.set<unsigned int>("index") = 0;
576 2804 : params.set<std::string>("vector_name") =
577 4206 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
578 1402 : _problem->addPostprocessor(pp_type_name, pp_name, params);
579 1402 : }
580 : else
581 : {
582 3120 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
583 : {
584 5082 : params.set<VectorPostprocessorName>("vectorpostprocessor") =
585 5082 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
586 5082 : std::string pp_name = pp_base_name + "_" + Moose::stringify(cfp_index + 1) + "_" +
587 5082 : Moose::stringify(_ring_vec[ring_index]);
588 2541 : params.set<unsigned int>("index") = cfp_index;
589 5082 : params.set<std::string>("vector_name") =
590 7623 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
591 2541 : _problem->addPostprocessor(pp_type_name, pp_name, params);
592 : }
593 : }
594 : }
595 : }
596 :
597 356 : if (_get_equivalent_k)
598 : {
599 65 : std::string pp_base_name("Keq");
600 65 : const std::string pp_type_name("VectorPostprocessorComponent");
601 65 : InputParameters params = _factory.getValidParams(pp_type_name);
602 285 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
603 : {
604 220 : if (_treat_as_2d && _use_crack_front_points_provider == false)
605 : {
606 300 : params.set<VectorPostprocessorName>("vectorpostprocessor") =
607 300 : pp_base_name + "_2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
608 300 : std::string pp_name = pp_base_name + +"_" + Moose::stringify(_ring_vec[ring_index]);
609 150 : params.set<unsigned int>("index") = 0;
610 300 : params.set<std::string>("vector_name") =
611 450 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
612 150 : _problem->addPostprocessor(pp_type_name, pp_name, params);
613 150 : }
614 : else
615 : {
616 280 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
617 : {
618 420 : params.set<VectorPostprocessorName>("vectorpostprocessor") =
619 420 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
620 420 : std::string pp_name = pp_base_name + "_" + Moose::stringify(cfp_index + 1) + "_" +
621 420 : Moose::stringify(_ring_vec[ring_index]);
622 210 : params.set<unsigned int>("index") = cfp_index;
623 420 : params.set<std::string>("vector_name") =
624 630 : pp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
625 210 : _problem->addPostprocessor(pp_type_name, pp_name, params);
626 : }
627 : }
628 : }
629 65 : }
630 :
631 391 : for (unsigned int i = 0; i < _output_variables.size(); ++i)
632 : {
633 35 : const std::string ov_base_name(_output_variables[i]);
634 35 : const std::string pp_type_name("CrackFrontData");
635 35 : InputParameters params = _factory.getValidParams(pp_type_name);
636 70 : params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
637 70 : params.set<UserObjectName>("crack_front_definition") = uo_name;
638 35 : if (_treat_as_2d && _use_crack_front_points_provider == false)
639 : {
640 0 : std::ostringstream pp_name_stream;
641 0 : pp_name_stream << ov_base_name << "_crack";
642 0 : params.set<VariableName>("variable") = _output_variables[i];
643 0 : _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
644 0 : }
645 : else
646 : {
647 140 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
648 : {
649 105 : std::ostringstream pp_name_stream;
650 105 : pp_name_stream << ov_base_name << "_crack_" << cfp_index + 1;
651 105 : params.set<VariableName>("variable") = _output_variables[i];
652 105 : params.set<unsigned int>("crack_front_point_index") = cfp_index;
653 105 : _problem->addPostprocessor(pp_type_name, pp_name_stream.str(), params);
654 105 : }
655 : }
656 35 : }
657 : }
658 :
659 1024 : else if (_current_task == "add_vector_postprocessor")
660 : {
661 356 : if (_integrals.count(J_INTEGRAL) != 0 || _integrals.count(C_INTEGRAL) != 0 ||
662 363 : _integrals.count(K_FROM_J_INTEGRAL) != 0)
663 : {
664 : std::string vpp_base_name;
665 263 : std::string jintegral_selection = "JIntegral";
666 :
667 263 : if (_integrals.count(J_INTEGRAL) != 0)
668 : {
669 : vpp_base_name = "J";
670 : jintegral_selection = "JIntegral";
671 : }
672 21 : else if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
673 : {
674 : vpp_base_name = "K";
675 : jintegral_selection = "KFromJIntegral";
676 : }
677 14 : else if (_integrals.count(C_INTEGRAL) != 0)
678 : {
679 : vpp_base_name = "C";
680 : jintegral_selection = "CIntegral";
681 : }
682 :
683 263 : if (_treat_as_2d && _use_crack_front_points_provider == false)
684 : vpp_base_name += "_2DVPP";
685 :
686 263 : const std::string vpp_type_name("JIntegral");
687 263 : InputParameters params = _factory.getValidParams(vpp_type_name);
688 526 : if (!getParam<bool>("output_vpp"))
689 42 : params.set<std::vector<OutputName>>("outputs") = {"none"};
690 :
691 526 : params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
692 526 : params.set<UserObjectName>("crack_front_definition") = uo_name;
693 263 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
694 263 : params.set<MooseEnum>("position_type") = _position_type;
695 :
696 263 : if (_integrals.count(K_FROM_J_INTEGRAL) != 0)
697 : {
698 7 : params.set<Real>("youngs_modulus") = _youngs_modulus;
699 7 : params.set<Real>("poissons_ratio") = _poissons_ratio;
700 : }
701 :
702 263 : if (_has_symmetry_plane)
703 214 : params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
704 :
705 : // Select the integral type to be computed in JIntegral vector postprocessor
706 263 : params.set<MooseEnum>("integral") = jintegral_selection;
707 :
708 263 : params.set<std::vector<VariableName>>("displacements") = _displacements;
709 263 : params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
710 1220 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
711 : {
712 957 : params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
713 1914 : params.set<MooseEnum>("q_function_type") = _q_function_type;
714 :
715 1914 : std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
716 957 : _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
717 : }
718 263 : }
719 :
720 356 : if (_integrals.count(INTERACTION_INTEGRAL_KI) != 0 ||
721 207 : _integrals.count(INTERACTION_INTEGRAL_KII) != 0 ||
722 207 : _integrals.count(INTERACTION_INTEGRAL_KIII) != 0 ||
723 207 : _integrals.count(INTERACTION_INTEGRAL_T) != 0)
724 : {
725 149 : if (_has_symmetry_plane && (_integrals.count(INTERACTION_INTEGRAL_KII) != 0 ||
726 233 : _integrals.count(INTERACTION_INTEGRAL_KIII) != 0))
727 0 : paramError("symmetry_plane",
728 : "In DomainIntegral, symmetry_plane option cannot be used with mode-II or "
729 : "mode-III interaction integral");
730 :
731 : std::string vpp_base_name;
732 149 : std::string vpp_type_name(ad_prepend + "InteractionIntegral");
733 :
734 149 : InputParameters params = _factory.getValidParams(vpp_type_name);
735 298 : if (!getParam<bool>("output_vpp"))
736 0 : params.set<std::vector<OutputName>>("outputs") = {"none"};
737 :
738 149 : if (_use_crack_front_points_provider)
739 0 : params.set<ExecFlagEnum>("execute_on") = xfem_exec_flags;
740 : else
741 447 : params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
742 :
743 319 : if (isParamValid("additional_eigenstrain_00") && isParamValid("additional_eigenstrain_01") &&
744 184 : isParamValid("additional_eigenstrain_11") && isParamValid("additional_eigenstrain_22"))
745 : {
746 14 : params.set<CoupledName>("additional_eigenstrain_00") =
747 14 : getParam<CoupledName>("additional_eigenstrain_00");
748 14 : params.set<CoupledName>("additional_eigenstrain_01") =
749 14 : getParam<CoupledName>("additional_eigenstrain_01");
750 14 : params.set<CoupledName>("additional_eigenstrain_11") =
751 14 : getParam<CoupledName>("additional_eigenstrain_11");
752 14 : params.set<CoupledName>("additional_eigenstrain_22") =
753 21 : getParam<CoupledName>("additional_eigenstrain_22");
754 : }
755 :
756 298 : params.set<UserObjectName>("crack_front_definition") = uo_name;
757 149 : params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
758 149 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
759 :
760 149 : if (_has_symmetry_plane)
761 84 : params.set<unsigned int>("symmetry_plane") = _symmetry_plane;
762 :
763 149 : if (_fgm_crack)
764 : {
765 14 : params.set<MaterialPropertyName>(
766 : "functionally_graded_youngs_modulus_crack_dir_gradient") = {
767 : _functionally_graded_youngs_modulus_crack_dir_gradient};
768 28 : params.set<MaterialPropertyName>("functionally_graded_youngs_modulus") = {
769 : _functionally_graded_youngs_modulus};
770 : }
771 :
772 149 : params.set<Real>("poissons_ratio") = _poissons_ratio;
773 149 : params.set<Real>("youngs_modulus") = _youngs_modulus;
774 149 : params.set<std::vector<VariableName>>("displacements") = _displacements;
775 149 : if (_temp != "")
776 42 : params.set<std::vector<VariableName>>("temperature") = {_temp};
777 :
778 298 : if (parameters().isParamValid("eigenstrain_gradient"))
779 7 : params.set<MaterialPropertyName>("eigenstrain_gradient") =
780 14 : parameters().get<MaterialPropertyName>("eigenstrain_gradient");
781 298 : if (parameters().isParamValid("body_force"))
782 7 : params.set<MaterialPropertyName>("body_force") =
783 14 : parameters().get<MaterialPropertyName>("body_force");
784 :
785 505 : for (std::set<INTEGRAL>::iterator sit = _integrals.begin(); sit != _integrals.end(); ++sit)
786 : {
787 356 : switch (*sit)
788 : {
789 42 : case J_INTEGRAL:
790 42 : continue;
791 :
792 7 : case C_INTEGRAL:
793 7 : continue;
794 :
795 7 : case K_FROM_J_INTEGRAL:
796 7 : continue;
797 :
798 : case INTERACTION_INTEGRAL_KI:
799 : vpp_base_name = "II_KI";
800 149 : params.set<Real>("K_factor") =
801 149 : 0.5 * _youngs_modulus / (1.0 - std::pow(_poissons_ratio, 2.0));
802 298 : params.set<MooseEnum>("sif_mode") = "KI";
803 149 : break;
804 :
805 : case INTERACTION_INTEGRAL_KII:
806 : vpp_base_name = "II_KII";
807 65 : params.set<Real>("K_factor") =
808 65 : 0.5 * _youngs_modulus / (1.0 - std::pow(_poissons_ratio, 2.0));
809 130 : params.set<MooseEnum>("sif_mode") = "KII";
810 65 : break;
811 :
812 : case INTERACTION_INTEGRAL_KIII:
813 : vpp_base_name = "II_KIII";
814 65 : params.set<Real>("K_factor") = 0.5 * _youngs_modulus / (1.0 + _poissons_ratio);
815 130 : params.set<MooseEnum>("sif_mode") = "KIII";
816 65 : break;
817 :
818 : case INTERACTION_INTEGRAL_T:
819 : vpp_base_name = "II_T";
820 21 : params.set<Real>("K_factor") = _youngs_modulus / (1 - std::pow(_poissons_ratio, 2));
821 42 : params.set<MooseEnum>("sif_mode") = "T";
822 21 : break;
823 : }
824 300 : if (_treat_as_2d && _use_crack_front_points_provider == false)
825 : vpp_base_name += "_2DVPP";
826 1324 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
827 : {
828 1024 : params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
829 2048 : params.set<MooseEnum>("q_function_type") = _q_function_type;
830 :
831 2048 : std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
832 1024 : _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
833 : }
834 : }
835 149 : }
836 :
837 356 : if (_get_equivalent_k)
838 : {
839 65 : std::string vpp_base_name("Keq");
840 65 : if (_treat_as_2d && _use_crack_front_points_provider == false)
841 : vpp_base_name += "_2DVPP";
842 65 : const std::string vpp_type_name("MixedModeEquivalentK");
843 65 : InputParameters params = _factory.getValidParams(vpp_type_name);
844 65 : params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
845 65 : params.set<Real>("poissons_ratio") = _poissons_ratio;
846 :
847 285 : for (unsigned int ring_index = 0; ring_index < _ring_vec.size(); ++ring_index)
848 : {
849 220 : std::string ki_name = "II_KI_";
850 220 : std::string kii_name = "II_KII_";
851 220 : std::string kiii_name = "II_KIII_";
852 220 : params.set<unsigned int>("ring_index") = _ring_vec[ring_index];
853 220 : if (_treat_as_2d && _use_crack_front_points_provider == false)
854 : {
855 300 : params.set<VectorPostprocessorName>("KI_vectorpostprocessor") =
856 300 : ki_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
857 300 : params.set<VectorPostprocessorName>("KII_vectorpostprocessor") =
858 300 : kii_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
859 300 : params.set<VectorPostprocessorName>("KIII_vectorpostprocessor") =
860 300 : kiii_name + "2DVPP_" + Moose::stringify(_ring_vec[ring_index]);
861 : }
862 : else
863 : {
864 140 : params.set<VectorPostprocessorName>("KI_vectorpostprocessor") =
865 140 : ki_name + Moose::stringify(_ring_vec[ring_index]);
866 140 : params.set<VectorPostprocessorName>("KII_vectorpostprocessor") =
867 140 : kii_name + Moose::stringify(_ring_vec[ring_index]);
868 140 : params.set<VectorPostprocessorName>("KIII_vectorpostprocessor") =
869 140 : kiii_name + Moose::stringify(_ring_vec[ring_index]);
870 : }
871 440 : params.set<std::string>("KI_vector_name") =
872 660 : ki_name + Moose::stringify(_ring_vec[ring_index]);
873 440 : params.set<std::string>("KII_vector_name") =
874 660 : kii_name + Moose::stringify(_ring_vec[ring_index]);
875 440 : params.set<std::string>("KIII_vector_name") =
876 660 : kiii_name + Moose::stringify(_ring_vec[ring_index]);
877 440 : std::string vpp_name = vpp_base_name + "_" + Moose::stringify(_ring_vec[ring_index]);
878 220 : _problem->addVectorPostprocessor(vpp_type_name, vpp_name, params);
879 : }
880 65 : }
881 :
882 356 : if (!_treat_as_2d || _use_crack_front_points_provider == true)
883 : {
884 172 : for (unsigned int i = 0; i < _output_variables.size(); ++i)
885 : {
886 35 : const std::string vpp_type_name("VectorOfPostprocessors");
887 35 : InputParameters params = _factory.getValidParams(vpp_type_name);
888 35 : params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
889 35 : std::ostringstream vpp_name_stream;
890 35 : vpp_name_stream << _output_variables[i] << "_crack";
891 : std::vector<PostprocessorName> postprocessor_names;
892 140 : for (unsigned int cfp_index = 0; cfp_index < num_crack_front_points; ++cfp_index)
893 : {
894 105 : std::ostringstream pp_name_stream;
895 210 : pp_name_stream << vpp_name_stream.str() << "_" << cfp_index + 1;
896 105 : postprocessor_names.push_back(pp_name_stream.str());
897 105 : }
898 35 : params.set<std::vector<PostprocessorName>>("postprocessors") = postprocessor_names;
899 35 : _problem->addVectorPostprocessor(vpp_type_name, vpp_name_stream.str(), params);
900 35 : }
901 : }
902 : }
903 :
904 668 : else if (_current_task == "add_material")
905 : {
906 358 : if (_temp != "")
907 : {
908 : std::string mater_name;
909 42 : const std::string mater_type_name("ThermalFractureIntegral");
910 : mater_name = "ThermalFractureIntegral";
911 :
912 42 : InputParameters params = _factory.getValidParams(mater_type_name);
913 84 : params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") =
914 126 : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
915 126 : params.set<std::vector<VariableName>>("temperature") = {_temp};
916 42 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
917 42 : _problem->addMaterial(mater_type_name, mater_name, params);
918 42 : }
919 1074 : MultiMooseEnum integral_moose_enums = getParam<MultiMooseEnum>("integrals");
920 : bool have_j_integral = false;
921 : bool have_c_integral = false;
922 :
923 923 : for (auto ime : integral_moose_enums)
924 : {
925 1186 : if (ime == "JIntegral" || ime == "CIntegral" || ime == "KFromJIntegral" ||
926 537 : ime == "InteractionIntegralKI" || ime == "InteractionIntegralKII" ||
927 672 : ime == "InteractionIntegralKIII" || ime == "InteractionIntegralT")
928 : have_j_integral = true;
929 :
930 565 : if (ime == "CIntegral")
931 : have_c_integral = true;
932 : }
933 358 : if (have_j_integral)
934 : {
935 : std::string mater_name;
936 358 : const std::string mater_type_name(ad_prepend + "StrainEnergyDensity");
937 358 : mater_name = ad_prepend + "StrainEnergyDensity";
938 :
939 358 : InputParameters params = _factory.getValidParams(mater_type_name);
940 716 : _incremental = getParam<bool>("incremental");
941 358 : params.set<bool>("incremental") = _incremental;
942 358 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
943 358 : _problem->addMaterial(mater_type_name, mater_name, params);
944 :
945 : {
946 : std::string mater_name;
947 358 : const std::string mater_type_name(ad_prepend + "EshelbyTensor");
948 358 : mater_name = ad_prepend + "EshelbyTensor";
949 :
950 358 : InputParameters params = _factory.getValidParams(mater_type_name);
951 716 : _displacements = getParam<std::vector<VariableName>>("displacements");
952 358 : params.set<std::vector<VariableName>>("displacements") = _displacements;
953 358 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
954 :
955 358 : if (have_c_integral)
956 14 : params.set<bool>("compute_dissipation") = true;
957 :
958 358 : if (_temp != "")
959 126 : params.set<std::vector<VariableName>>("temperature") = {_temp};
960 :
961 358 : _problem->addMaterial(mater_type_name, mater_name, params);
962 356 : }
963 : // Strain energy rate density needed for C(t)/C* integral
964 356 : if (have_c_integral)
965 : {
966 : std::string mater_name;
967 14 : const std::string mater_type_name(ad_prepend + "StrainEnergyRateDensity");
968 14 : mater_name = ad_prepend + "StrainEnergyRateDensity";
969 :
970 14 : InputParameters params = _factory.getValidParams(mater_type_name);
971 14 : params.set<std::vector<SubdomainName>>("block") = {_blocks};
972 28 : params.set<std::vector<MaterialName>>("inelastic_models") =
973 28 : getParam<std::vector<MaterialName>>("inelastic_models");
974 :
975 14 : _problem->addMaterial(mater_type_name, mater_name, params);
976 14 : }
977 356 : }
978 356 : }
979 4989 : }
980 :
981 : unsigned int
982 2142 : DomainIntegralAction::calcNumCrackFrontPoints()
983 : {
984 : unsigned int num_points = 0;
985 2142 : if (_boundary_names.size() != 0)
986 : {
987 1938 : std::vector<BoundaryID> bids = _mesh->getBoundaryIDs(_boundary_names, true);
988 : std::set<unsigned int> nodes;
989 :
990 1938 : ConstBndNodeRange & bnd_nodes = *_mesh->getBoundaryNodeRange();
991 207978 : for (ConstBndNodeRange::const_iterator nd = bnd_nodes.begin(); nd != bnd_nodes.end(); ++nd)
992 : {
993 206040 : const BndNode * bnode = *nd;
994 206040 : BoundaryID boundary_id = bnode->_bnd_id;
995 :
996 407982 : for (unsigned int ibid = 0; ibid < bids.size(); ++ibid)
997 : {
998 206040 : if (boundary_id == bids[ibid])
999 : {
1000 4098 : nodes.insert(bnode->_node->id());
1001 4098 : break;
1002 : }
1003 : }
1004 : }
1005 1938 : num_points = nodes.size();
1006 1938 : }
1007 204 : else if (_crack_front_points.size() != 0)
1008 204 : num_points = _crack_front_points.size();
1009 0 : else if (_use_crack_front_points_provider)
1010 0 : num_points = getParam<unsigned int>("number_points_from_provider");
1011 : else
1012 0 : mooseError("Must define either 'boundary' or 'crack_front_points'");
1013 2142 : return num_points;
1014 : }
1015 :
1016 : void
1017 6420 : DomainIntegralAction::addRelationshipManagers(Moose::RelationshipManagerType input_rm_type)
1018 : {
1019 6420 : if (_integrals.count(INTERACTION_INTEGRAL_T) != 0)
1020 : {
1021 378 : InputParameters params = _factory.getValidParams("CrackFrontDefinition");
1022 378 : addRelationshipManagers(input_rm_type, params);
1023 378 : }
1024 6420 : }
|
