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 "MaterialOutputAction.h"
12 : #include "FEProblem.h"
13 : #include "FEProblemBase.h"
14 : #include "MooseApp.h"
15 : #include "AddOutputAction.h"
16 : #include "MaterialBase.h"
17 : #include "RankTwoTensor.h"
18 : #include "SymmetricRankTwoTensor.h"
19 : #include "RankFourTensor.h"
20 : #include "SymmetricRankFourTensor.h"
21 : #include "MooseEnum.h"
22 : #include "MooseVariableConstMonomial.h"
23 : #include "FunctorMaterial.h"
24 : #include "VariableSizeMaterialPropertiesInterface.h"
25 :
26 : #include "libmesh/utility.h"
27 :
28 : registerMooseAction("MooseApp", MaterialOutputAction, "add_output_aux_variables");
29 : registerMooseAction("MooseApp", MaterialOutputAction, "add_aux_kernel");
30 :
31 : InputParameters
32 66081 : MaterialOutputAction::validParams()
33 : {
34 66081 : InputParameters params = Action::validParams();
35 132162 : params.addClassDescription("Outputs material properties to various Outputs objects, based on the "
36 : "parameters set in each Material");
37 198243 : params.addParam<bool>(
38 : "print_unsupported_prop_names",
39 132162 : true,
40 : "Flag to tell this action whether or not to print the unsupported properties.");
41 132162 : params.addParam<bool>("print_automatic_aux_variable_creation",
42 132162 : true,
43 : "Flag to print list of aux variables created for automatic output by "
44 : "MaterialOutputAction.");
45 66081 : return params;
46 0 : }
47 :
48 66031 : MaterialOutputAction::MaterialOutputAction(const InputParameters & params)
49 : : Action(params),
50 66031 : _block_material_data(nullptr),
51 66031 : _boundary_material_data(nullptr),
52 66031 : _output_warehouse(_app.getOutputWarehouse()),
53 132062 : _output_only_on_timestep_end(_app.parameters().get<bool>("use_legacy_material_output"))
54 : {
55 66031 : }
56 :
57 : void
58 120562 : MaterialOutputAction::act()
59 : {
60 : mooseAssert(_problem,
61 : "FEProblemBase pointer is nullptr, it is needed for auto material property output");
62 :
63 : // Do nothing if the application does not have output
64 361686 : if (!_app.actionWarehouse().hasActions("add_output"))
65 0 : return;
66 :
67 120562 : bool get_names_only = _current_task == "add_output_aux_variables" ? true : false;
68 :
69 : // Set the pointers to the MaterialData objects (Note, these pointers are not available at
70 : // construction)
71 120562 : _block_material_data = &_problem->getMaterialData(Moose::BLOCK_MATERIAL_DATA);
72 120562 : _boundary_material_data = &_problem->getMaterialData(Moose::BOUNDARY_MATERIAL_DATA);
73 :
74 : // A complete list of all MaterialBase objects
75 120562 : const auto & material_ptrs = _problem->getMaterialWarehouse().getObjects();
76 :
77 : // Handle setting of material property output in [Outputs] sub-blocks
78 : // Output objects can enable material property output, the following code examines the parameters
79 : // for each Output object and sets a flag if any Output object has output set and also builds a
80 : // list if the
81 : // properties are limited via the 'show_material_properties' parameters
82 120562 : bool outputs_has_properties = false;
83 120562 : std::set<std::string> output_object_properties;
84 :
85 241124 : const auto & output_actions = _app.actionWarehouse().getActionListByName("add_output");
86 715137 : for (const auto & act : output_actions)
87 : {
88 : // Extract the Output action
89 594575 : AddOutputAction * action = dynamic_cast<AddOutputAction *>(act);
90 594575 : if (!action)
91 123877 : continue;
92 :
93 : // Add the material property names from the output object parameters to the list of properties
94 : // to output
95 470698 : InputParameters & params = action->getObjectParams();
96 1956310 : if (params.isParamValid("output_material_properties") &&
97 544216 : params.get<bool>("output_material_properties"))
98 : {
99 124 : outputs_has_properties = true;
100 : std::vector<std::string> prop_names =
101 124 : params.get<std::vector<std::string>>("show_material_properties");
102 124 : output_object_properties.insert(prop_names.begin(), prop_names.end());
103 124 : }
104 : }
105 :
106 : // Loop through each material object
107 120562 : std::set<std::string> material_names;
108 120562 : std::set<std::string> unsupported_names;
109 148863 : for (const auto & mat : material_ptrs)
110 : {
111 : // Extract the names of the output objects to which the material properties will be exported
112 28304 : std::set<OutputName> outputs = mat->getOutputs();
113 :
114 : // Extract the property names that will actually be output
115 : std::vector<std::string> output_properties =
116 56608 : mat->getParam<std::vector<std::string>>("output_properties");
117 :
118 : // Append the properties listed in the Outputs block
119 28304 : if (outputs_has_properties)
120 148 : output_properties.insert(output_properties.end(),
121 : output_object_properties.begin(),
122 : output_object_properties.end());
123 :
124 : // Clear the list of variable names for the current material object, this list will be populated
125 : // with all the
126 : // variables names for the current material object and is needed for purposes of controlling the
127 : // which output objects
128 : // show the material property data
129 28304 : _material_variable_names.clear();
130 :
131 : // Create necessary outputs for the properties if:
132 : // (1) The Outputs block has material output enabled
133 : // (2) If the MaterialBase object itself has set the 'outputs' parameter
134 28304 : if (outputs_has_properties || outputs.find("none") == outputs.end())
135 : {
136 : // Get all material properties supplied by this material as a starting point
137 4159 : std::set<std::string> names = mat->getSuppliedItems();
138 4159 : if (const auto fmat_ptr = dynamic_cast<const FunctorMaterial *>(mat.get()))
139 96 : names.insert(fmat_ptr->getSuppliedFunctors().begin(),
140 96 : fmat_ptr->getSuppliedFunctors().end());
141 :
142 16662 : for (const auto & name : names)
143 : {
144 : // Output the property only if the name is contained in the 'output_properties'
145 : // list or if the list is empty (all properties)
146 16980 : if (output_properties.empty() ||
147 4477 : std::find(output_properties.begin(), output_properties.end(), name) !=
148 16980 : output_properties.end())
149 : {
150 : // Add the material property for output
151 9783 : auto curr_material_names = materialOutput(name, *mat, get_names_only);
152 9783 : if (curr_material_names.size() == 0)
153 72 : unsupported_names.insert(name);
154 9783 : material_names.insert(curr_material_names.begin(), curr_material_names.end());
155 9783 : }
156 : }
157 : // If the material object has explicitly defined outputs, store the variables associated with
158 : // the output objects
159 4159 : if (outputs.find("none") == outputs.end())
160 : {
161 : // Get all available output names from OutputWarehouse that support material output
162 4011 : const auto & all_output_names = _output_warehouse.getAllMaterialPropertyOutputNames();
163 :
164 : // For reserved name "all", set outputs to match all available output names
165 4011 : if (outputs.find("all") != outputs.end())
166 1893 : outputs = all_output_names;
167 :
168 : // Iterate through all available output names and update _material_variable_names_map
169 : // based on which of these output names are found in 'outputs' parameter
170 7959 : for (const auto & output_name : all_output_names)
171 : {
172 3948 : if (outputs.find(output_name) != outputs.end())
173 2775 : _material_variable_names_map[output_name].insert(_material_variable_names.begin(),
174 : _material_variable_names.end());
175 : else
176 1173 : _material_variable_names_map[output_name].insert({});
177 : }
178 4011 : }
179 4159 : }
180 24145 : else if (output_properties.size())
181 75 : mooseWarning("Material properties output specified is not created because 'outputs' is not "
182 : "set in the Material, and neither is output_material_properties in any of the "
183 : "outputs in the [Outputs] block");
184 28301 : }
185 120595 : if (unsupported_names.size() > 0 && get_names_only &&
186 120667 : getParam<bool>("print_unsupported_prop_names"))
187 : {
188 27 : std::ostringstream oss;
189 54 : for (const auto & name : unsupported_names)
190 27 : oss << "\n " << name;
191 54 : mooseWarning("The types for total ",
192 27 : unsupported_names.size(),
193 : " material properties:",
194 54 : oss.str(),
195 : "\nare not supported for automatic output by ",
196 27 : type(),
197 : ".");
198 27 : }
199 :
200 120559 : if (_current_task == "add_output_aux_variables")
201 : {
202 181197 : auto params = _factory.getValidParams("MooseVariableConstMonomial");
203 : // currently only elemental variables are supported for material property output
204 241596 : params.set<MooseEnum>("order") = "CONSTANT";
205 181197 : params.set<MooseEnum>("family") = "MONOMIAL";
206 :
207 : // Create the AuxVariables
208 60399 : std::ostringstream oss;
209 87924 : for (const auto & var_name : material_names)
210 : {
211 27528 : oss << "\n " << var_name;
212 27528 : if (_problem->hasVariable(var_name))
213 3 : mooseError("The material property output " + var_name +
214 : " has the same name as an existing variable, either use the material"
215 : " declare_suffix parameter to disambiguate or the output_properties parameter"
216 : " to restrict the material properties to output");
217 82575 : _problem->addAuxVariable("MooseVariableConstMonomial", var_name, params);
218 : }
219 :
220 63054 : if (material_names.size() > 0 && getParam<bool>("print_automatic_aux_variable_creation"))
221 1320 : _console << COLOR_CYAN << "The following total " << material_names.size()
222 2640 : << " aux variables:" << oss.str() << "\nare added for automatic output by " << type()
223 1320 : << "." << COLOR_DEFAULT << std::endl;
224 60396 : }
225 : else
226 : {
227 : // When a MaterialBase object has 'output_properties' defined all other properties not listed
228 : // must be added to the hide list for the output objects so that properties that are not desired
229 : // do not appear.
230 62674 : for (const auto & it : _material_variable_names_map)
231 : {
232 2514 : std::set<std::string> hide;
233 2514 : std::set_difference(material_names.begin(),
234 : material_names.end(),
235 : it.second.begin(),
236 : it.second.end(),
237 : std::inserter(hide, hide.begin()));
238 :
239 2514 : _output_warehouse.addInterfaceHideVariables(it.first, hide);
240 2514 : }
241 : }
242 120556 : }
243 :
244 : std::vector<std::string>
245 9783 : MaterialOutputAction::materialOutput(const std::string & property_name,
246 : const MaterialBase & material,
247 : bool get_names_only)
248 : {
249 9783 : std::vector<std::string> names;
250 :
251 : // Material Properties
252 9783 : if (hasProperty<Real>(property_name))
253 9386 : names = outputHelper(
254 4693 : {"MaterialRealAux", "", {}}, property_name, property_name, material, get_names_only);
255 :
256 5090 : else if (hasADProperty<Real>(property_name))
257 4240 : names = outputHelper(
258 2120 : {"ADMaterialRealAux", "", {}}, property_name, property_name, material, get_names_only);
259 :
260 2970 : else if (hasProperty<RealVectorValue>(property_name))
261 645 : names = outputHelper({"MaterialRealVectorValueAux", "xyz", {"component"}},
262 : property_name,
263 1290 : property_name + "_",
264 : material,
265 645 : get_names_only);
266 :
267 2325 : else if (hasADProperty<RealVectorValue>(property_name))
268 192 : names = outputHelper({"ADMaterialRealVectorValueAux", "xyz", {"component"}},
269 : property_name,
270 384 : property_name + "_",
271 : material,
272 192 : get_names_only);
273 :
274 2133 : else if (hasProperty<std::vector<Real>>(property_name))
275 144 : names = outputHelper({"MaterialStdVectorAux", "variable_size", {"index"}},
276 : property_name,
277 288 : property_name + "_",
278 : material,
279 144 : get_names_only);
280 :
281 1989 : else if (hasADProperty<std::vector<Real>>(property_name))
282 48 : names = outputHelper({"ADMaterialStdVectorAux", "variable_size", {"index"}},
283 : property_name,
284 96 : property_name + "_",
285 : material,
286 48 : get_names_only);
287 :
288 1941 : else if (hasProperty<RealTensorValue>(property_name))
289 429 : names = outputHelper({"MaterialRealTensorValueAux", "012", {"row", "column"}},
290 : property_name,
291 858 : property_name + "_",
292 : material,
293 429 : get_names_only);
294 :
295 1512 : else if (hasADProperty<RealTensorValue>(property_name))
296 24 : names = outputHelper({"ADMaterialRealTensorValueAux", "012", {"row", "column"}},
297 : property_name,
298 48 : property_name + "_",
299 : material,
300 24 : get_names_only);
301 :
302 1488 : else if (hasProperty<RankTwoTensor>(property_name))
303 354 : names = outputHelper({"MaterialRankTwoTensorAux", "012", {"i", "j"}},
304 : property_name,
305 708 : property_name + "_",
306 : material,
307 354 : get_names_only);
308 :
309 1134 : else if (hasADProperty<RankTwoTensor>(property_name))
310 72 : names = outputHelper({"ADMaterialRankTwoTensorAux", "012", {"i", "j"}},
311 : property_name,
312 144 : property_name + "_",
313 : material,
314 72 : get_names_only);
315 :
316 1062 : else if (hasProperty<RankFourTensor>(property_name))
317 282 : names = outputHelper({"MaterialRankFourTensorAux", "012", {"i", "j", "k", "l"}},
318 : property_name,
319 564 : property_name + "_",
320 : material,
321 282 : get_names_only);
322 :
323 780 : else if (hasADProperty<RankFourTensor>(property_name))
324 24 : names = outputHelper({"ADMaterialRankFourTensorAux", "012", {"i", "j", "k", "l"}},
325 : property_name,
326 48 : property_name + "_",
327 : material,
328 24 : get_names_only);
329 :
330 756 : else if (hasProperty<SymmetricRankTwoTensor>(property_name))
331 306 : names = outputHelper({"MaterialSymmetricRankTwoTensorAux", "012345", {"component"}},
332 : property_name,
333 612 : property_name + "_",
334 : material,
335 306 : get_names_only);
336 :
337 450 : else if (hasADProperty<SymmetricRankTwoTensor>(property_name))
338 48 : names = outputHelper({"ADMaterialSymmetricRankTwoTensorAux", "012345", {"component"}},
339 : property_name,
340 96 : property_name + "_",
341 : material,
342 48 : get_names_only);
343 :
344 402 : else if (hasProperty<SymmetricRankFourTensor>(property_name))
345 282 : names = outputHelper({"MaterialSymmetricRankFourTensorAux", "012345", {"i", "j"}},
346 : property_name,
347 564 : property_name + "_",
348 : material,
349 282 : get_names_only);
350 :
351 120 : else if (hasADProperty<SymmetricRankFourTensor>(property_name))
352 24 : names = outputHelper({"ADMaterialSymmetricRankFourTensorAux", "012345", {"i", "j"}},
353 : property_name,
354 48 : property_name + "_",
355 : material,
356 24 : get_names_only);
357 :
358 : // Functors
359 96 : else if (hasFunctorProperty<Real>(property_name))
360 48 : names = outputHelper({"FunctorMaterialRealAux", "", {}},
361 : property_name,
362 96 : property_name + "_out",
363 : material,
364 48 : get_names_only);
365 :
366 48 : else if (hasFunctorProperty<ADReal>(property_name))
367 0 : names = outputHelper({"ADFunctorMaterialRealAux", "", {}},
368 : property_name,
369 0 : property_name + "_out",
370 : material,
371 0 : get_names_only);
372 :
373 48 : else if (hasFunctorProperty<RealVectorValue>(property_name))
374 48 : names = outputHelper({"FunctorMaterialRealVectorValueAux", "xyz", {"component"}},
375 : property_name,
376 96 : property_name + "_out_",
377 : material,
378 48 : get_names_only);
379 :
380 0 : else if (hasFunctorProperty<ADRealVectorValue>(property_name))
381 0 : names = outputHelper({"ADFunctorMaterialRealVectorValueAux", "xyz", {"component"}},
382 : property_name,
383 0 : property_name + "_out_",
384 : material,
385 0 : get_names_only);
386 :
387 9783 : return names;
388 32271 : }
389 :
390 : std::vector<std::string>
391 9783 : MaterialOutputAction::outputHelper(const MaterialOutputAction::OutputMetaData & metadata,
392 : const std::string & property_name,
393 : const std::string & var_name_base,
394 : const MaterialBase & material,
395 : bool get_names_only)
396 : {
397 9783 : const auto & [kernel_name, index_symbols, param_names] = metadata;
398 9783 : const auto dim = param_names.size();
399 9783 : const auto size = index_symbols.size();
400 9783 : auto size_inner = size;
401 :
402 : // Handle the case the material property is of a variable input-defined size
403 9783 : bool variable_size = false;
404 9783 : if (index_symbols == "variable_size")
405 : {
406 192 : variable_size = true;
407 192 : size_inner = 0;
408 192 : const auto * const vsmi =
409 192 : dynamic_cast<const VariableSizeMaterialPropertiesInterface *>(&material);
410 192 : if (vsmi)
411 120 : size_inner = vsmi->getVectorPropertySize(property_name);
412 :
413 192 : if (!size_inner)
414 : {
415 72 : mooseWarning("Vector material property '" + property_name + "' will not be output as we " +
416 : (vsmi ? "have a 0-size vector during the simulation setup."
417 : : "do not know the size of the vector at initialization. Add the "
418 : "'VariableSizeMaterialPropertiesInterface' as a base class of the "
419 : "Material defining the vector property and implement the "
420 : "get...Size(property_name) routine. Note that "
421 : "the size must be known during the simulation setup phase."));
422 72 : return {};
423 : }
424 : }
425 :
426 9711 : std::vector<std::string> names;
427 : // general 0 to 4 dimensional loop
428 : std::array<std::size_t, 4> i;
429 20034 : for (i[3] = 0; i[3] < (dim < 4 ? 1 : size); ++i[3])
430 22482 : for (i[2] = 0; i[2] < (dim < 3 ? 1 : size); ++i[2])
431 33114 : for (i[1] = 0; i[1] < (dim < 2 ? 1 : size); ++i[1])
432 76836 : for (i[0] = 0; i[0] < (dim < 1 ? 1 : size_inner); ++i[0])
433 : {
434 55881 : std::string var_name = var_name_base;
435 198186 : for (const auto j : make_range(dim))
436 142305 : if (variable_size)
437 528 : var_name += Moose::stringify(i[j]);
438 : else
439 141777 : var_name += Moose::stringify(index_symbols[i[j]]);
440 :
441 55881 : names.push_back(var_name);
442 :
443 55881 : if (!get_names_only)
444 : {
445 27921 : auto params = getParams(kernel_name, property_name, var_name, material);
446 99042 : for (const auto j : make_range(dim))
447 71121 : params.template set<unsigned int>(param_names[j]) = i[j];
448 27921 : _problem->addAuxKernel(kernel_name, material.name() + "_" + var_name, params);
449 27921 : }
450 55881 : }
451 9711 : return names;
452 9711 : }
453 :
454 : InputParameters
455 27921 : MaterialOutputAction::getParams(const std::string & type,
456 : const std::string & property_name,
457 : const std::string & variable_name,
458 : const MaterialBase & material)
459 : {
460 : // Append the list of output variables for the current material
461 27921 : _material_variable_names.insert(variable_name);
462 :
463 : // Set the action parameters
464 27921 : InputParameters params = _factory.getValidParams(type);
465 27921 : if (params.have_parameter<MaterialPropertyName>("property"))
466 83475 : params.set<MaterialPropertyName>("property") = property_name;
467 96 : else if (params.have_parameter<MooseFunctorName>("functor"))
468 288 : params.set<MooseFunctorName>("functor") = property_name;
469 : else
470 0 : mooseError("Internal error. AuxKernel has neither a `functor` nor a `property` parameter.");
471 :
472 83763 : params.set<AuxVariableName>("variable") = variable_name;
473 27921 : if (_output_only_on_timestep_end)
474 0 : params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
475 : else
476 111684 : params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
477 :
478 27921 : if (material.boundaryRestricted())
479 495 : params.set<std::vector<BoundaryName>>("boundary") = material.boundaryNames();
480 : else
481 83268 : params.set<std::vector<SubdomainName>>("block") = material.blocks();
482 :
483 27921 : return params;
484 27921 : }
|
