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 : #include "SIMPLESolveBase.h"
11 : #include "FEProblem.h"
12 : #include "SegregatedSolverUtils.h"
13 :
14 : InputParameters
15 1794 : SIMPLESolveBase::validParams()
16 : {
17 1794 : InputParameters params = emptyInputParameters();
18 3588 : params.addRequiredParam<UserObjectName>("rhie_chow_user_object", "The rhie-chow user-object");
19 :
20 : /*
21 : * The names of the different systems in the segregated solver
22 : */
23 3588 : params.addRequiredParam<std::vector<SolverSystemName>>(
24 : "momentum_systems", "The solver system(s) for the momentum equation(s).");
25 3588 : params.addRequiredParam<SolverSystemName>("pressure_system",
26 : "The solver system for the pressure equation.");
27 3588 : params.addParam<SolverSystemName>("energy_system", "The solver system for the energy equation.");
28 3588 : params.addParam<SolverSystemName>("solid_energy_system",
29 : "The solver system for the solid energy equation.");
30 3588 : params.addParam<std::vector<SolverSystemName>>(
31 : "passive_scalar_systems", {}, "The solver system for each scalar advection equation.");
32 3588 : params.addParam<std::vector<SolverSystemName>>(
33 : "pm_radiation_systems",
34 : {},
35 : "The solver system for each participating media radiation equation.");
36 3588 : params.addParam<std::vector<SolverSystemName>>(
37 : "turbulence_systems", {}, "The solver system for each surrogate turbulence equation.");
38 :
39 : /*
40 : * Parameters to control the solution of the momentum equation
41 : */
42 :
43 5382 : params.addRangeCheckedParam<Real>(
44 : "momentum_equation_relaxation",
45 3588 : 1.0,
46 : "0.0<momentum_equation_relaxation<=1.0",
47 : "The relaxation which should be used for the momentum equation. (=1 for no relaxation, "
48 : "diagonal dominance will still be enforced)");
49 :
50 3588 : params.addParam<MultiMooseEnum>("momentum_petsc_options",
51 3588 : Moose::PetscSupport::getCommonPetscFlags(),
52 : "Singleton PETSc options for the momentum equation");
53 3588 : params.addParam<MultiMooseEnum>("momentum_petsc_options_iname",
54 3588 : Moose::PetscSupport::getCommonPetscKeys(),
55 : "Names of PETSc name/value pairs for the momentum equation");
56 3588 : params.addParam<std::vector<std::string>>(
57 : "momentum_petsc_options_value",
58 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
59 : "momentum equation");
60 :
61 5382 : params.addRangeCheckedParam<Real>(
62 : "momentum_absolute_tolerance",
63 3588 : 1e-5,
64 : "0.0<momentum_absolute_tolerance",
65 : "The absolute tolerance on the normalized residual of the momentum equation.");
66 :
67 5382 : params.addRangeCheckedParam<Real>("momentum_l_tol",
68 3588 : 1e-5,
69 : "0.0<=momentum_l_tol & momentum_l_tol<1.0",
70 : "The relative tolerance on the normalized residual in the "
71 : "linear solver of the momentum equation.");
72 5382 : params.addRangeCheckedParam<Real>("momentum_l_abs_tol",
73 3588 : 1e-50,
74 : "0.0<momentum_l_abs_tol",
75 : "The absolute tolerance on the normalized residual in the "
76 : "linear solver of the momentum equation.");
77 3588 : params.addParam<unsigned int>(
78 : "momentum_l_max_its",
79 3588 : 10000,
80 : "The maximum allowed iterations in the linear solver of the momentum equation.");
81 :
82 3588 : params.addParamNamesToGroup(
83 : "momentum_equation_relaxation momentum_petsc_options momentum_petsc_options_iname "
84 : "momentum_petsc_options_value momentum_petsc_options_value momentum_absolute_tolerance "
85 : "momentum_l_tol momentum_l_abs_tol momentum_l_max_its momentum_systems",
86 : "Momentum Equation");
87 :
88 : /*
89 : * Parameters to control the solution of the pressure equation
90 : */
91 5382 : params.addRangeCheckedParam<Real>(
92 : "pressure_variable_relaxation",
93 3588 : 1.0,
94 : "0.0<pressure_variable_relaxation<=1.0",
95 : "The relaxation which should be used for the pressure variable (=1 for no relaxation).");
96 :
97 3588 : params.addParam<MultiMooseEnum>("pressure_petsc_options",
98 3588 : Moose::PetscSupport::getCommonPetscFlags(),
99 : "Singleton PETSc options for the pressure equation");
100 3588 : params.addParam<MultiMooseEnum>("pressure_petsc_options_iname",
101 3588 : Moose::PetscSupport::getCommonPetscKeys(),
102 : "Names of PETSc name/value pairs for the pressure equation");
103 3588 : params.addParam<std::vector<std::string>>(
104 : "pressure_petsc_options_value",
105 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
106 : "pressure equation");
107 :
108 5382 : params.addRangeCheckedParam<Real>(
109 : "pressure_absolute_tolerance",
110 3588 : 1e-5,
111 : "0.0<pressure_absolute_tolerance",
112 : "The absolute tolerance on the normalized residual of the pressure equation.");
113 :
114 5382 : params.addRangeCheckedParam<Real>("pressure_l_tol",
115 3588 : 1e-5,
116 : "0.0<=pressure_l_tol & pressure_l_tol<1.0",
117 : "The relative tolerance on the normalized residual in the "
118 : "linear solver of the pressure equation.");
119 5382 : params.addRangeCheckedParam<Real>("pressure_l_abs_tol",
120 3588 : 1e-10,
121 : "0.0<pressure_l_abs_tol",
122 : "The absolute tolerance on the normalized residual in the "
123 : "linear solver of the pressure equation.");
124 3588 : params.addParam<unsigned int>(
125 : "pressure_l_max_its",
126 3588 : 10000,
127 : "The maximum allowed iterations in the linear solver of the pressure equation.");
128 :
129 3588 : params.addParamNamesToGroup(
130 : "pressure_variable_relaxation pressure_petsc_options pressure_petsc_options_iname "
131 : "pressure_petsc_options_value pressure_petsc_options_value pressure_absolute_tolerance "
132 : "pressure_l_tol pressure_l_abs_tol pressure_l_max_its pressure_system",
133 : "Pressure Equation");
134 :
135 : /*
136 : * Pressure pin parameters for enclosed flows
137 : */
138 :
139 3588 : params.addParam<bool>(
140 3588 : "pin_pressure", false, "If the pressure field needs to be pinned at a point.");
141 3588 : params.addParam<Real>(
142 3588 : "pressure_pin_value", 0.0, "The value which needs to be enforced for the pressure.");
143 3588 : params.addParam<Point>("pressure_pin_point", "The point where the pressure needs to be pinned.");
144 :
145 3588 : params.addParamNamesToGroup("pin_pressure pressure_pin_value pressure_pin_point", "Pressure Pin");
146 :
147 3588 : params.addParam<bool>(
148 : "print_fields",
149 3588 : false,
150 : "Use this to print the coupling and solution fields and matrices throughout the iteration.");
151 :
152 : /*
153 : * Parameters to control the solution of the energy equation
154 : */
155 :
156 5382 : params.addRangeCheckedParam<Real>(
157 : "energy_equation_relaxation",
158 3588 : 1.0,
159 : "0.0<energy_equation_relaxation<=1.0",
160 : "The relaxation which should be used for the energy equation. (=1 for no relaxation, "
161 : "diagonal dominance will still be enforced)");
162 :
163 3588 : params.addParam<MultiMooseEnum>("energy_petsc_options",
164 3588 : Moose::PetscSupport::getCommonPetscFlags(),
165 : "Singleton PETSc options for the energy equation");
166 3588 : params.addParam<MultiMooseEnum>("energy_petsc_options_iname",
167 3588 : Moose::PetscSupport::getCommonPetscKeys(),
168 : "Names of PETSc name/value pairs for the energy equation");
169 3588 : params.addParam<std::vector<std::string>>(
170 : "energy_petsc_options_value",
171 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
172 : "energy equation");
173 :
174 5382 : params.addRangeCheckedParam<Real>(
175 : "energy_absolute_tolerance",
176 3588 : 1e-5,
177 : "0.0<energy_absolute_tolerance",
178 : "The absolute tolerance on the normalized residual of the energy equation.");
179 :
180 5382 : params.addRangeCheckedParam<Real>("energy_l_tol",
181 3588 : 1e-5,
182 : "0.0<=energy_l_tol & energy_l_tol<1.0",
183 : "The relative tolerance on the normalized residual in the "
184 : "linear solver of the energy equation.");
185 5382 : params.addRangeCheckedParam<Real>("energy_l_abs_tol",
186 3588 : 1e-10,
187 : "0.0<energy_l_abs_tol",
188 : "The absolute tolerance on the normalized residual in the "
189 : "linear solver of the energy equation.");
190 5382 : params.addRangeCheckedParam<unsigned int>(
191 : "energy_l_max_its",
192 3588 : 10000,
193 : "0<energy_l_max_its",
194 : "The maximum allowed iterations in the linear solver of the energy equation.");
195 :
196 3588 : params.addParamNamesToGroup(
197 : "energy_equation_relaxation energy_petsc_options energy_petsc_options_iname "
198 : "energy_petsc_options_value energy_petsc_options_value energy_absolute_tolerance "
199 : "energy_l_tol energy_l_abs_tol energy_l_max_its",
200 : "Energy Equation");
201 :
202 : /*
203 : * Parameters to control the solution of the solid energy equation
204 : */
205 :
206 3588 : params.addParam<MultiMooseEnum>("solid_energy_petsc_options",
207 3588 : Moose::PetscSupport::getCommonPetscFlags(),
208 : "Singleton PETSc options for the solid energy equation");
209 3588 : params.addParam<MultiMooseEnum>("solid_energy_petsc_options_iname",
210 3588 : Moose::PetscSupport::getCommonPetscKeys(),
211 : "Names of PETSc name/value pairs for the solid energy equation");
212 3588 : params.addParam<std::vector<std::string>>(
213 : "solid_energy_petsc_options_value",
214 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
215 : "solid energy equation");
216 :
217 5382 : params.addRangeCheckedParam<Real>(
218 : "solid_energy_absolute_tolerance",
219 3588 : 1e-5,
220 : "0.0<solid_energy_absolute_tolerance",
221 : "The absolute tolerance on the normalized residual of the solid energy equation.");
222 :
223 5382 : params.addRangeCheckedParam<Real>("solid_energy_l_tol",
224 3588 : 1e-5,
225 : "0.0<=solid_energy_l_tol & solid_energy_l_tol<1.0",
226 : "The relative tolerance on the normalized residual in the "
227 : "linear solver of the solid energy equation.");
228 :
229 5382 : params.addRangeCheckedParam<Real>("solid_energy_l_abs_tol",
230 3588 : 1e-10,
231 : "0.0<solid_energy_l_abs_tol",
232 : "The absolute tolerance on the normalized residual in the "
233 : "linear solver of the solid energy equation.");
234 5382 : params.addRangeCheckedParam<unsigned int>(
235 : "solid_energy_l_max_its",
236 3588 : 10000,
237 : "0<solid_energy_l_max_its",
238 : "The maximum allowed iterations in the linear solver of the solid energy equation.");
239 :
240 3588 : params.addParamNamesToGroup("solid_energy_petsc_options solid_energy_petsc_options_iname "
241 : "solid_energy_petsc_options_value solid_energy_absolute_tolerance "
242 : "solid_energy_l_tol solid_energy_l_abs_tol solid_energy_l_max_its",
243 : "Solid Energy Equation");
244 :
245 : /*
246 : * Parameters to control the solution of each scalar advection system
247 : */
248 1794 : params.addParam<std::vector<Real>>("passive_scalar_equation_relaxation",
249 1794 : std::vector<Real>(),
250 : "The relaxation which should be used for the passive scalar "
251 : "equations. (=1 for no relaxation, "
252 : "diagonal dominance will still be enforced)");
253 :
254 3588 : params.addParam<MultiMooseEnum>("passive_scalar_petsc_options",
255 3588 : Moose::PetscSupport::getCommonPetscFlags(),
256 : "Singleton PETSc options for the passive scalar equation(s)");
257 3588 : params.addParam<MultiMooseEnum>(
258 : "passive_scalar_petsc_options_iname",
259 3588 : Moose::PetscSupport::getCommonPetscKeys(),
260 : "Names of PETSc name/value pairs for the passive scalar equation(s)");
261 3588 : params.addParam<std::vector<std::string>>(
262 : "passive_scalar_petsc_options_value",
263 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
264 : "passive scalar equation(s)");
265 1794 : params.addParam<std::vector<Real>>(
266 : "passive_scalar_absolute_tolerance",
267 1794 : std::vector<Real>(),
268 : "The absolute tolerance(s) on the normalized residual(s) of the passive scalar equation(s).");
269 5382 : params.addRangeCheckedParam<Real>("passive_scalar_l_tol",
270 3588 : 1e-5,
271 : "0.0<=passive_scalar_l_tol & passive_scalar_l_tol<1.0",
272 : "The relative tolerance on the normalized residual in the "
273 : "linear solver of the passive scalar equation(s).");
274 5382 : params.addRangeCheckedParam<Real>("passive_scalar_l_abs_tol",
275 3588 : 1e-10,
276 : "0.0<passive_scalar_l_abs_tol",
277 : "The absolute tolerance on the normalized residual in the "
278 : "linear solver of the passive scalar equation(s).");
279 3588 : params.addParam<unsigned int>(
280 : "passive_scalar_l_max_its",
281 3588 : 10000,
282 : "The maximum allowed iterations in the linear solver of the turbulence equation.");
283 :
284 3588 : params.addParamNamesToGroup(
285 : "passive_scalar_systems passive_scalar_equation_relaxation passive_scalar_petsc_options "
286 : "passive_scalar_petsc_options_iname "
287 : "passive_scalar_petsc_options_value passive_scalar_petsc_options_value "
288 : "passive_scalar_absolute_tolerance "
289 : "passive_scalar_l_tol passive_scalar_l_abs_tol passive_scalar_l_max_its",
290 : "passive_scalar Equation");
291 :
292 : /*
293 : * Parameters to control the solution of each participating media radiation equation
294 : */
295 1794 : params.addParam<std::vector<Real>>(
296 : "pm_radiation_equation_relaxation",
297 1794 : std::vector<Real>(),
298 : "The relaxation which should be used for the participating media radiation "
299 : "equations. (=1 for no relaxation, "
300 : "diagonal dominance will still be enforced)");
301 :
302 3588 : params.addParam<MultiMooseEnum>(
303 : "pm_radiation_petsc_options",
304 3588 : Moose::PetscSupport::getCommonPetscFlags(),
305 : "Singleton PETSc options for the participating media radiation equation(s)");
306 3588 : params.addParam<MultiMooseEnum>(
307 : "pm_radiation_petsc_options_iname",
308 3588 : Moose::PetscSupport::getCommonPetscKeys(),
309 : "Names of PETSc name/value pairs for the participating media radiation equation(s)");
310 3588 : params.addParam<std::vector<std::string>>(
311 : "pm_radiation_petsc_options_value",
312 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
313 : "participating media radiation equation(s)");
314 1794 : params.addParam<std::vector<Real>>("pm_radiation_absolute_tolerance",
315 1794 : std::vector<Real>(),
316 : "The absolute tolerance(s) on the normalized residual(s) of "
317 : "the participating media radiation equation(s).");
318 5382 : params.addRangeCheckedParam<Real>(
319 : "pm_radiation_l_tol",
320 3588 : 1e-5,
321 : "0.0<=pm_radiation_l_tol & pm_radiation_l_tol<1.0",
322 : "The relative tolerance on the normalized residual in the "
323 : "linear solver of the participating media radiation equation(s).");
324 5382 : params.addRangeCheckedParam<Real>(
325 : "pm_radiation_l_abs_tol",
326 3588 : 1e-10,
327 : "0.0<pm_radiation_l_abs_tol",
328 : "The absolute tolerance on the normalized residual in the "
329 : "linear solver of the participating media radiation equation(s).");
330 3588 : params.addParam<unsigned int>("pm_radiation_l_max_its",
331 3588 : 10000,
332 : "The maximum allowed iterations in the linear solver of the "
333 : "participating media radiation equation.");
334 :
335 3588 : params.addParamNamesToGroup(
336 : "pm_radiation_systems pm_radiation_equation_relaxation pm_radiation_petsc_options "
337 : "pm_radiation_petsc_options_iname "
338 : "pm_radiation_petsc_options_value pm_radiation_petsc_options_value "
339 : "pm_radiation_absolute_tolerance "
340 : "pm_radiation_l_tol pm_radiation_l_abs_tol pm_radiation_l_max_its",
341 : "Participating Medium Radiation Equation");
342 :
343 : /*
344 : * Parameters to control the solution of each turbulence system
345 : */
346 1794 : params.addParam<std::vector<Real>>("turbulence_equation_relaxation",
347 1794 : std::vector<Real>(),
348 : "The relaxation which should be used for the turbulence "
349 : "equations. (=1 for no relaxation, "
350 : "diagonal dominance will still be enforced)");
351 :
352 1794 : params.addParam<std::vector<Real>>("turbulence_field_relaxation",
353 1794 : std::vector<Real>(),
354 : "The relaxation which should be used for the turbulence "
355 : "fields.");
356 :
357 1794 : params.addParam<std::vector<Real>>(
358 : "turbulence_field_min_limit",
359 1794 : std::vector<Real>(),
360 : "The lower limit imposed on turbulent quantities. The recommended value for robustness "
361 : "is 1e-8. This is the imposed default if not set.");
362 :
363 3588 : params.addParam<MultiMooseEnum>("turbulence_petsc_options",
364 3588 : Moose::PetscSupport::getCommonPetscFlags(),
365 : "Singleton PETSc options for the turbulence equation(s)");
366 3588 : params.addParam<MultiMooseEnum>("turbulence_petsc_options_iname",
367 3588 : Moose::PetscSupport::getCommonPetscKeys(),
368 : "Names of PETSc name/value pairs for the turbulence equation(s)");
369 3588 : params.addParam<std::vector<std::string>>(
370 : "turbulence_petsc_options_value",
371 : "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
372 : "turbulence equation(s)");
373 1794 : params.addParam<std::vector<Real>>(
374 : "turbulence_absolute_tolerance",
375 1794 : std::vector<Real>(),
376 : "The absolute tolerance(s) on the normalized residual(s) of the turbulence equation(s).");
377 5382 : params.addRangeCheckedParam<Real>("turbulence_l_tol",
378 3588 : 1e-5,
379 : "0.0<=turbulence_l_tol & turbulence_l_tol<1.0",
380 : "The relative tolerance on the normalized residual in the "
381 : "linear solver of the turbulence equation(s).");
382 5382 : params.addRangeCheckedParam<Real>("turbulence_l_abs_tol",
383 3588 : 1e-10,
384 : "0.0<turbulence_l_abs_tol",
385 : "The absolute tolerance on the normalized residual in the "
386 : "linear solver of the turbulence equation(s).");
387 3588 : params.addParam<unsigned int>(
388 : "turbulence_l_max_its",
389 3588 : 10000,
390 : "The maximum allowed iterations in the linear solver of the turbulence equation.");
391 :
392 3588 : params.addParamNamesToGroup("turbulence_systems "
393 : "turbulence_equation_relaxation "
394 : "turbulence_field_relaxation "
395 : "turbulence_field_min_limit "
396 : "turbulence_petsc_options "
397 : "turbulence_petsc_options_iname "
398 : "turbulence_petsc_options_value turbulence_petsc_options_value "
399 : "turbulence_absolute_tolerance "
400 : "turbulence_l_tol turbulence_l_abs_tol turbulence_l_max_its",
401 : "Turbulence Equations");
402 :
403 : /*
404 : * SIMPLE iteration control
405 : */
406 :
407 5382 : params.addRangeCheckedParam<unsigned int>(
408 : "num_iterations",
409 3588 : 1000,
410 : "0<num_iterations",
411 : "The number of momentum-pressure-(other fields) iterations needed.");
412 :
413 3588 : params.addParam<bool>("continue_on_max_its",
414 3588 : false,
415 : "If solve should continue if maximum number of iterations is hit.");
416 :
417 1794 : return params;
418 0 : }
419 :
420 897 : SIMPLESolveBase::SIMPLESolveBase(Executioner & ex)
421 : : SolveObject(ex),
422 : UserObjectInterface(this),
423 897 : _momentum_system_names(getParam<std::vector<SolverSystemName>>("momentum_systems")),
424 1794 : _momentum_l_abs_tol(getParam<Real>("momentum_l_abs_tol")),
425 1794 : _momentum_equation_relaxation(getParam<Real>("momentum_equation_relaxation")),
426 1794 : _pressure_system_name(getParam<SolverSystemName>("pressure_system")),
427 1794 : _pressure_l_abs_tol(getParam<Real>("pressure_l_abs_tol")),
428 1794 : _pressure_variable_relaxation(getParam<Real>("pressure_variable_relaxation")),
429 1794 : _pin_pressure(getParam<bool>("pin_pressure")),
430 1794 : _pressure_pin_value(getParam<Real>("pressure_pin_value")),
431 897 : _pressure_pin_dof(libMesh::invalid_uint),
432 1794 : _has_energy_system(isParamValid("energy_system")),
433 1794 : _energy_equation_relaxation(getParam<Real>("energy_equation_relaxation")),
434 1794 : _energy_l_abs_tol(getParam<Real>("energy_l_abs_tol")),
435 1227 : _has_solid_energy_system(_has_energy_system && isParamValid("solid_energy_system")),
436 1794 : _solid_energy_l_abs_tol(getParam<Real>("solid_energy_l_abs_tol")),
437 1794 : _passive_scalar_system_names(getParam<std::vector<SolverSystemName>>("passive_scalar_systems")),
438 897 : _has_passive_scalar_systems(!_passive_scalar_system_names.empty()),
439 1794 : _passive_scalar_equation_relaxation(
440 : getParam<std::vector<Real>>("passive_scalar_equation_relaxation")),
441 1794 : _passive_scalar_l_abs_tol(getParam<Real>("passive_scalar_l_abs_tol")),
442 1794 : _pm_radiation_system_names(getParam<std::vector<SolverSystemName>>("pm_radiation_systems")),
443 897 : _has_pm_radiation_systems(!_pm_radiation_system_names.empty()),
444 1794 : _pm_radiation_equation_relaxation(
445 : getParam<std::vector<Real>>("pm_radiation_equation_relaxation")),
446 1794 : _pm_radiation_l_abs_tol(getParam<Real>("pm_radiation_l_abs_tol")),
447 1794 : _turbulence_system_names(getParam<std::vector<SolverSystemName>>("turbulence_systems")),
448 897 : _has_turbulence_systems(!_turbulence_system_names.empty()),
449 1794 : _turbulence_equation_relaxation(getParam<std::vector<Real>>("turbulence_equation_relaxation")),
450 1794 : _turbulence_field_relaxation(getParam<std::vector<Real>>("turbulence_field_relaxation")),
451 1794 : _turbulence_field_min_limit(getParam<std::vector<Real>>("turbulence_field_min_limit")),
452 1794 : _turbulence_l_abs_tol(getParam<Real>("turbulence_l_abs_tol")),
453 1794 : _momentum_absolute_tolerance(getParam<Real>("momentum_absolute_tolerance")),
454 1794 : _pressure_absolute_tolerance(getParam<Real>("pressure_absolute_tolerance")),
455 1794 : _energy_absolute_tolerance(getParam<Real>("energy_absolute_tolerance")),
456 1794 : _solid_energy_absolute_tolerance(getParam<Real>("solid_energy_absolute_tolerance")),
457 1794 : _passive_scalar_absolute_tolerance(
458 : getParam<std::vector<Real>>("passive_scalar_absolute_tolerance")),
459 1794 : _pm_radiation_absolute_tolerance(
460 : getParam<std::vector<Real>>("pm_radiation_absolute_tolerance")),
461 1794 : _turbulence_absolute_tolerance(getParam<std::vector<Real>>("turbulence_absolute_tolerance")),
462 1794 : _num_iterations(getParam<unsigned int>("num_iterations")),
463 1794 : _continue_on_max_its(getParam<bool>("continue_on_max_its")),
464 8970 : _print_fields(getParam<bool>("print_fields"))
465 : {
466 897 : if (_momentum_system_names.size() != _problem.mesh().dimension())
467 0 : paramError("momentum_systems",
468 : "The number of momentum components should be equal to the number of "
469 : "spatial dimensions on the mesh.");
470 :
471 897 : const auto & momentum_petsc_options = getParam<MultiMooseEnum>("momentum_petsc_options");
472 : const auto & momentum_petsc_pair_options = getParam<MooseEnumItem, std::string>(
473 1794 : "momentum_petsc_options_iname", "momentum_petsc_options_value");
474 897 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
475 : momentum_petsc_options, "", *this, _momentum_petsc_options);
476 1794 : Moose::PetscSupport::addPetscPairsToPetscOptions(
477 897 : momentum_petsc_pair_options, _problem.mesh().dimension(), "", *this, _momentum_petsc_options);
478 :
479 1794 : _momentum_linear_control.real_valued_data["rel_tol"] = getParam<Real>("momentum_l_tol");
480 1794 : _momentum_linear_control.real_valued_data["abs_tol"] = getParam<Real>("momentum_l_abs_tol");
481 897 : _momentum_linear_control.int_valued_data["max_its"] =
482 1794 : getParam<unsigned int>("momentum_l_max_its");
483 :
484 897 : const auto & pressure_petsc_options = getParam<MultiMooseEnum>("pressure_petsc_options");
485 : const auto & pressure_petsc_pair_options = getParam<MooseEnumItem, std::string>(
486 1794 : "pressure_petsc_options_iname", "pressure_petsc_options_value");
487 897 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
488 : pressure_petsc_options, "", *this, _pressure_petsc_options);
489 1794 : Moose::PetscSupport::addPetscPairsToPetscOptions(
490 897 : pressure_petsc_pair_options, _problem.mesh().dimension(), "", *this, _pressure_petsc_options);
491 :
492 1794 : _pressure_linear_control.real_valued_data["rel_tol"] = getParam<Real>("pressure_l_tol");
493 1794 : _pressure_linear_control.real_valued_data["abs_tol"] = getParam<Real>("pressure_l_abs_tol");
494 897 : _pressure_linear_control.int_valued_data["max_its"] =
495 1794 : getParam<unsigned int>("pressure_l_max_its");
496 :
497 897 : if (_has_energy_system)
498 : {
499 330 : const auto & energy_petsc_options = getParam<MultiMooseEnum>("energy_petsc_options");
500 : const auto & energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
501 660 : "energy_petsc_options_iname", "energy_petsc_options_value");
502 330 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
503 : energy_petsc_options, "", *this, _energy_petsc_options);
504 660 : Moose::PetscSupport::addPetscPairsToPetscOptions(
505 330 : energy_petsc_pair_options, _problem.mesh().dimension(), "", *this, _energy_petsc_options);
506 :
507 660 : _energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("energy_l_tol");
508 660 : _energy_linear_control.real_valued_data["abs_tol"] = getParam<Real>("energy_l_abs_tol");
509 660 : _energy_linear_control.int_valued_data["max_its"] = getParam<unsigned int>("energy_l_max_its");
510 330 : }
511 : else
512 1134 : checkDependentParameterError("energy_system",
513 : {"energy_petsc_options",
514 : "energy_petsc_options_iname",
515 : "energy_petsc_options_value",
516 : "energy_l_tol",
517 : "energy_l_abs_tol",
518 : "energy_l_max_its",
519 : "energy_absolute_tolerance",
520 : "energy_equation_relaxation"},
521 : false);
522 :
523 897 : if (_has_solid_energy_system)
524 : {
525 : const auto & solid_energy_petsc_options =
526 59 : getParam<MultiMooseEnum>("solid_energy_petsc_options");
527 : const auto & solid_energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
528 118 : "solid_energy_petsc_options_iname", "solid_energy_petsc_options_value");
529 59 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
530 : solid_energy_petsc_options, "", *this, _solid_energy_petsc_options);
531 118 : Moose::PetscSupport::addPetscPairsToPetscOptions(solid_energy_petsc_pair_options,
532 59 : _problem.mesh().dimension(),
533 : "",
534 : *this,
535 : _solid_energy_petsc_options);
536 :
537 118 : _solid_energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("solid_energy_l_tol");
538 59 : _solid_energy_linear_control.real_valued_data["abs_tol"] =
539 118 : getParam<Real>("solid_energy_l_abs_tol");
540 59 : _solid_energy_linear_control.int_valued_data["max_its"] =
541 118 : getParam<unsigned int>("solid_energy_l_max_its");
542 59 : }
543 : else
544 1676 : checkDependentParameterError("solid_energy_system",
545 : {"solid_energy_petsc_options",
546 : "solid_energy_petsc_options_iname",
547 : "solid_energy_petsc_options_value",
548 : "solid_energy_l_tol",
549 : "solid_energy_l_abs_tol",
550 : "solid_energy_l_max_its",
551 : "solid_energy_absolute_tolerance",
552 : "solid_energy_equation_relaxation"},
553 : false);
554 :
555 : // We check for input errors with regards to the participating media radiation equations. At the
556 : // same time, we set up the corresponding system numbers
557 897 : if (_has_pm_radiation_systems)
558 : {
559 16 : if (_pm_radiation_system_names.size() != _pm_radiation_equation_relaxation.size())
560 0 : paramError("pm_radiation_equation_relaxation",
561 : "The number of equation relaxation parameters does not match the number of "
562 : "participating media radiation equations!");
563 16 : if (_pm_radiation_system_names.size() != _pm_radiation_absolute_tolerance.size())
564 0 : paramError("pm_radiation_absolute_tolerance",
565 : "The number of absolute tolerances does not match the number of "
566 : "participating media radiation equations!");
567 : }
568 897 : if (_has_pm_radiation_systems)
569 : {
570 : const auto & pm_radiation_petsc_options =
571 16 : getParam<MultiMooseEnum>("pm_radiation_petsc_options");
572 : const auto & pm_radiation_petsc_pair_options = getParam<MooseEnumItem, std::string>(
573 32 : "pm_radiation_petsc_options_iname", "pm_radiation_petsc_options_value");
574 16 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
575 : pm_radiation_petsc_options, "", *this, _pm_radiation_petsc_options);
576 32 : Moose::PetscSupport::addPetscPairsToPetscOptions(pm_radiation_petsc_pair_options,
577 16 : _problem.mesh().dimension(),
578 : "",
579 : *this,
580 : _pm_radiation_petsc_options);
581 :
582 32 : _pm_radiation_linear_control.real_valued_data["rel_tol"] = getParam<Real>("pm_radiation_l_tol");
583 16 : _pm_radiation_linear_control.real_valued_data["abs_tol"] =
584 32 : getParam<Real>("pm_radiation_l_abs_tol");
585 16 : _pm_radiation_linear_control.int_valued_data["max_its"] =
586 32 : getParam<unsigned int>("pm_radiation_l_max_its");
587 16 : }
588 : else
589 1762 : checkDependentParameterError("pm_radiation_systems",
590 : {"pm_radiation_petsc_options",
591 : "pm_radiation_petsc_options_iname",
592 : "pm_radiation_petsc_options_value",
593 : "pm_radiation_l_tol",
594 : "pm_radiation_l_abs_tol",
595 : "pm_radiation_l_max_its",
596 : "pm_radiation_equation_relaxation",
597 : "pm_radiation_absolute_tolerance"},
598 : false);
599 :
600 : // We check for input errors with regards to the passive scalar equations. At the same time, we
601 : // set up the corresponding system numbers
602 897 : if (_has_passive_scalar_systems)
603 : {
604 99 : if (_passive_scalar_system_names.size() != _passive_scalar_equation_relaxation.size())
605 0 : paramError("passive_scalar_equation_relaxation",
606 : "The number of equation relaxation parameters does not match the number of "
607 : "passive scalar equations!");
608 99 : if (_passive_scalar_system_names.size() != _passive_scalar_absolute_tolerance.size())
609 0 : paramError("passive_scalar_absolute_tolerance",
610 : "The number of absolute tolerances does not match the number of "
611 : "passive scalar equations!");
612 : }
613 897 : if (_has_passive_scalar_systems)
614 : {
615 : const auto & passive_scalar_petsc_options =
616 99 : getParam<MultiMooseEnum>("passive_scalar_petsc_options");
617 : const auto & passive_scalar_petsc_pair_options = getParam<MooseEnumItem, std::string>(
618 198 : "passive_scalar_petsc_options_iname", "passive_scalar_petsc_options_value");
619 99 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
620 : passive_scalar_petsc_options, "", *this, _passive_scalar_petsc_options);
621 198 : Moose::PetscSupport::addPetscPairsToPetscOptions(passive_scalar_petsc_pair_options,
622 99 : _problem.mesh().dimension(),
623 : "",
624 : *this,
625 : _passive_scalar_petsc_options);
626 :
627 99 : _passive_scalar_linear_control.real_valued_data["rel_tol"] =
628 198 : getParam<Real>("passive_scalar_l_tol");
629 99 : _passive_scalar_linear_control.real_valued_data["abs_tol"] =
630 198 : getParam<Real>("passive_scalar_l_abs_tol");
631 99 : _passive_scalar_linear_control.int_valued_data["max_its"] =
632 198 : getParam<unsigned int>("passive_scalar_l_max_its");
633 99 : }
634 : else
635 1596 : checkDependentParameterError("passive_scalar_systems",
636 : {"passive_scalar_petsc_options",
637 : "passive_scalar_petsc_options_iname",
638 : "passive_scalar_petsc_options_value",
639 : "passive_scalar_l_tol",
640 : "passive_scalar_l_abs_tol",
641 : "passive_scalar_l_max_its",
642 : "passive_scalar_equation_relaxation",
643 : "passive_scalar_absolute_tolerance"},
644 : false);
645 :
646 : // We check for input errors with regards to the surrogate turbulence equations. At the same time,
647 : // we set up the corresponding system numbers
648 897 : if (_has_turbulence_systems)
649 : {
650 225 : if (_turbulence_system_names.size() != _turbulence_equation_relaxation.size())
651 0 : paramError("turbulence_equation_relaxation",
652 : "The number of equation relaxation parameters does not match the number of "
653 : "turbulence equations!");
654 225 : if (_turbulence_system_names.size() != _turbulence_absolute_tolerance.size())
655 0 : paramError("turbulence_absolute_tolerance",
656 : "The number of absolute tolerances does not match the number of "
657 : "turbulence equations!");
658 225 : if (_turbulence_field_min_limit.empty())
659 : // If no minimum bounds are given, initialize to default value 1e-8
660 225 : _turbulence_field_min_limit.resize(_turbulence_system_names.size(), 1e-8);
661 :
662 : // Assign turbulence field relaxation as 1.0 if not defined
663 225 : if (_turbulence_field_relaxation.empty())
664 159 : _turbulence_field_relaxation.resize(_turbulence_system_names.size(), 1.0);
665 :
666 225 : const auto & turbulence_petsc_options = getParam<MultiMooseEnum>("turbulence_petsc_options");
667 : const auto & turbulence_petsc_pair_options = getParam<MooseEnumItem, std::string>(
668 450 : "turbulence_petsc_options_iname", "turbulence_petsc_options_value");
669 225 : Moose::PetscSupport::addPetscFlagsToPetscOptions(
670 : turbulence_petsc_options, "", *this, _turbulence_petsc_options);
671 450 : Moose::PetscSupport::addPetscPairsToPetscOptions(turbulence_petsc_pair_options,
672 225 : _problem.mesh().dimension(),
673 : "",
674 : *this,
675 : _turbulence_petsc_options);
676 :
677 450 : _turbulence_linear_control.real_valued_data["rel_tol"] = getParam<Real>("turbulence_l_tol");
678 450 : _turbulence_linear_control.real_valued_data["abs_tol"] = getParam<Real>("turbulence_l_abs_tol");
679 225 : _turbulence_linear_control.int_valued_data["max_its"] =
680 450 : getParam<unsigned int>("turbulence_l_max_its");
681 225 : }
682 : else
683 1344 : checkDependentParameterError("turbulence_systems",
684 : {"turbulence_petsc_options",
685 : "turbulence_petsc_options_iname",
686 : "turbulence_petsc_options_value",
687 : "turbulence_l_tol",
688 : "turbulence_l_abs_tol",
689 : "turbulence_l_max_its",
690 : "turbulence_equation_relaxation",
691 : "turbulence_field_relaxation",
692 : "turbulence_field_min_limit",
693 : "turbulence_absolute_tolerance"},
694 : false);
695 897 : }
696 :
697 : void
698 896 : SIMPLESolveBase::setupPressurePin()
699 : {
700 896 : if (_pin_pressure)
701 644 : _pressure_pin_dof = NS::FV::findPointDoFID(_problem.getVariable(0, "pressure"),
702 322 : _problem.mesh(),
703 : getParam<Point>("pressure_pin_point"));
704 896 : }
705 :
706 : void
707 3953 : SIMPLESolveBase::checkDependentParameterError(const std::string & main_parameter,
708 : const std::vector<std::string> & dependent_parameters,
709 : const bool should_be_defined)
710 : {
711 36921 : for (const auto & param : dependent_parameters)
712 32968 : if (parameters().isParamSetByUser(param) == !should_be_defined)
713 0 : paramError(param,
714 0 : "This parameter should " + std::string(should_be_defined ? "" : "not") +
715 0 : " be given by the user with the corresponding " + main_parameter +
716 : " setting!");
717 3953 : }
|
