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 "NSFVBase.h"
11 : #include "NS.h"
12 : #include "Action.h"
13 : #include "INSFVMomentumAdvection.h"
14 : #include "INSFVRhieChowInterpolator.h"
15 :
16 : InputParameters
17 48927 : NSFVBase::commonNavierStokesFlowParams()
18 : {
19 48927 : InputParameters params = emptyInputParameters();
20 97854 : MooseEnum comp_type("incompressible weakly-compressible", "incompressible");
21 97854 : params.addParam<MooseEnum>(
22 : "compressibility", comp_type, "Compressibility constraint for the Navier-Stokes equations.");
23 :
24 97854 : params.addParam<std::vector<std::string>>(
25 : "velocity_variable",
26 : "If supplied, the system checks for available velocity variables. "
27 : "Otherwise, they are created within the action.");
28 :
29 97854 : params.addParam<NonlinearVariableName>("pressure_variable",
30 : "If supplied, the system checks for available pressure "
31 : "variable. Otherwise, it is created within the action.");
32 :
33 97854 : params.addParam<NonlinearVariableName>(
34 : "fluid_temperature_variable",
35 : "If supplied, the system checks for available fluid "
36 : "temperature variable. Otherwise, it is created within the action.");
37 :
38 : /**
39 : * Parameters used to define the boundaries of the domain.
40 : */
41 :
42 48927 : params.addParam<std::vector<BoundaryName>>(
43 48927 : "inlet_boundaries", std::vector<BoundaryName>(), "Names of inlet boundaries");
44 48927 : params.addParam<std::vector<BoundaryName>>(
45 48927 : "outlet_boundaries", std::vector<BoundaryName>(), "Names of outlet boundaries");
46 48927 : params.addParam<std::vector<BoundaryName>>(
47 48927 : "wall_boundaries", std::vector<BoundaryName>(), "Names of wall boundaries");
48 48927 : params.addParam<std::vector<BoundaryName>>("hydraulic_separator_sidesets",
49 48927 : std::vector<BoundaryName>(),
50 : "Sidesets which serve as hydraulic separators.");
51 48927 : return params;
52 48927 : }
53 :
54 : InputParameters
55 48927 : NSFVBase::commonMomentumEquationParams()
56 : {
57 48927 : InputParameters params = emptyInputParameters();
58 :
59 97854 : params.addParam<MooseFunctorName>(
60 : "dynamic_viscosity", NS::mu, "The name of the dynamic viscosity");
61 97854 : params.addParam<MooseFunctorName>("density", NS::density, "The name of the density");
62 :
63 : // Dynamic pressure parameter
64 : // TODO: make default
65 97854 : params.addParam<bool>("solve_for_dynamic_pressure",
66 97854 : false,
67 : "Whether to solve for the dynamic pressure instead of the total pressure");
68 :
69 : // Pressure pin parameters
70 97854 : params.addParam<bool>(
71 97854 : "pin_pressure", false, "Switch to enable pressure shifting for incompressible simulations.");
72 97854 : MooseEnum s_type("average point-value average-uo point-value-uo", "average-uo");
73 97854 : params.addParam<MooseEnum>(
74 : "pinned_pressure_type",
75 : s_type,
76 : "Types for shifting (pinning) the pressure in case of incompressible simulations.");
77 48927 : params.addParam<Point>(
78 : "pinned_pressure_point",
79 48927 : Point(),
80 : "The XYZ coordinates where pressure needs to be pinned for incompressible simulations.");
81 97854 : params.addParam<PostprocessorName>(
82 : "pinned_pressure_value",
83 : "1e5",
84 : "The value used for pinning the pressure (point value/domain average).");
85 :
86 97854 : params.addParam<bool>("boussinesq_approximation", false, "True to have Boussinesq approximation");
87 :
88 48927 : params.addParam<RealVectorValue>(
89 48927 : "gravity", RealVectorValue(0, 0, 0), "The gravitational acceleration vector.");
90 :
91 146781 : params.addRangeCheckedParam<Real>(
92 : "ref_temperature",
93 97854 : 273.15,
94 : "ref_temperature > 0.0",
95 : "Value for reference temperature in case of Boussinesq approximation");
96 97854 : params.addParam<MooseFunctorName>(
97 : "thermal_expansion",
98 : NS::alpha,
99 : "The name of the thermal expansion coefficient in the Boussinesq approximation");
100 :
101 97854 : params.addParamNamesToGroup(
102 : "pin_pressure pinned_pressure_type pinned_pressure_point pinned_pressure_value ",
103 : "Incompressible flow pressure constraint");
104 97854 : params.addParamNamesToGroup("ref_temperature boussinesq_approximation gravity",
105 : "Gravity treatment");
106 :
107 : /**
108 : * Parameters controlling the friction terms in case of porous medium simulations.
109 : */
110 97854 : params.addParam<std::vector<std::vector<SubdomainName>>>(
111 : "friction_blocks",
112 : {},
113 : "The blocks where the friction factors are applied to emulate flow resistances.");
114 :
115 97854 : params.addParam<std::vector<std::vector<std::string>>>(
116 : "friction_types", {}, "The types of friction forces for every block in 'friction_blocks'.");
117 :
118 97854 : params.addParam<std::vector<std::vector<std::string>>>(
119 : "friction_coeffs",
120 : {},
121 : "The friction coefficients for every item in 'friction_types'. Note that if "
122 : "'porous_medium_treatment' is enabled, the coefficients already contain a velocity "
123 : "multiplier but they are not multiplied with density yet!");
124 :
125 97854 : params.addParam<bool>(
126 : "standard_friction_formulation",
127 97854 : true,
128 : "Flag to enable the standard friction formulation or its alternative, "
129 : "which is a simplified version (see user documentation for PINSFVMomentumFriction).");
130 :
131 97854 : params.addParamNamesToGroup("friction_blocks friction_types friction_coeffs "
132 : "standard_friction_formulation",
133 : "Friction control");
134 48927 : return params;
135 48927 : }
136 :
137 : InputParameters
138 48927 : NSFVBase::commonMomentumBoundaryTypesParams()
139 : {
140 48927 : InputParameters params = emptyInputParameters();
141 48927 : MultiMooseEnum mom_inlet_types("fixed-velocity flux-velocity flux-mass fixed-pressure");
142 97854 : params.addParam<MultiMooseEnum>("momentum_inlet_types",
143 : mom_inlet_types,
144 : "Types of inlet boundaries for the momentum equation.");
145 :
146 48927 : MultiMooseEnum mom_outlet_types("fixed-pressure zero-gradient fixed-pressure-zero-gradient");
147 97854 : params.addParam<MultiMooseEnum>("momentum_outlet_types",
148 : mom_outlet_types,
149 : "Types of outlet boundaries for the momentum equation");
150 48927 : params.addParam<std::vector<MooseFunctorName>>("pressure_function",
151 48927 : std::vector<MooseFunctorName>(),
152 : "Functions for boundary pressures at outlets.");
153 :
154 48927 : MultiMooseEnum mom_wall_types("symmetry noslip slip wallfunction");
155 97854 : params.addParam<MultiMooseEnum>(
156 : "momentum_wall_types", mom_wall_types, "Types of wall boundaries for the momentum equation");
157 :
158 48927 : return params;
159 48927 : }
160 :
161 : InputParameters
162 48927 : NSFVBase::commonMomentumBoundaryFluxesParams()
163 : {
164 48927 : InputParameters params = emptyInputParameters();
165 48927 : params.addParam<std::vector<std::vector<MooseFunctorName>>>(
166 : "momentum_inlet_function",
167 48927 : std::vector<std::vector<MooseFunctorName>>(),
168 : "Functions for inlet boundary velocities or pressures (for fixed-pressure option). Provide a "
169 : "double vector where the leading dimension corresponds to the number of fixed-velocity and "
170 : "fixed-pressure entries in momentum_inlet_types and the second index runs either over "
171 : "dimensions for fixed-velocity boundaries or is a single function name for pressure inlets.");
172 48927 : params.addParam<std::vector<PostprocessorName>>(
173 : "flux_inlet_pps",
174 48927 : std::vector<PostprocessorName>(),
175 : "The name of the postprocessors which compute the mass flow/ velocity magnitude. "
176 : "Mainly used for coupling between different applications.");
177 48927 : params.addParam<std::vector<Point>>(
178 : "flux_inlet_directions",
179 48927 : std::vector<Point>(),
180 : "The directions which can be used to define the orientation of the flux with respect to the "
181 : "mesh. This can be used to define a flux which is incoming with an angle or to adjust the "
182 : "flux direction with respect to the normal. If the inlet surface is defined on an internal "
183 : "face, this is necessary to ensure the arbitrary orientation of the normal does not result "
184 : "in non-physical results.");
185 97854 : params.addParamNamesToGroup("flux_inlet_pps flux_inlet_directions", "Boundary condition");
186 :
187 48927 : return params;
188 0 : }
189 :
190 : InputParameters
191 48336 : NSFVBase::commonFluidEnergyEquationParams()
192 : {
193 48336 : InputParameters params = emptyInputParameters();
194 96672 : params.addParam<FunctionName>(
195 : "initial_temperature", "300", "The initial temperature, assumed constant everywhere");
196 :
197 96672 : params.addParam<std::vector<std::vector<SubdomainName>>>(
198 : "thermal_conductivity_blocks",
199 : {},
200 : "The blocks where the user wants define different thermal conductivities.");
201 :
202 96672 : params.addParam<std::vector<MooseFunctorName>>(
203 : "thermal_conductivity",
204 145008 : std::vector<MooseFunctorName>({NS::k}),
205 : "The name of the fluid thermal conductivity for each block");
206 :
207 96672 : params.addParam<MooseFunctorName>("specific_heat", NS::cp, "The name of the specific heat");
208 :
209 48336 : MultiMooseEnum en_inlet_types("fixed-temperature flux-mass flux-velocity heatflux");
210 96672 : params.addParam<MultiMooseEnum>("energy_inlet_types",
211 : en_inlet_types,
212 : "Types for the inlet boundaries for the energy equation.");
213 :
214 48336 : params.addParam<std::vector<MooseFunctorName>>(
215 : "energy_inlet_function",
216 48336 : std::vector<MooseFunctorName>(),
217 : "Functions for fixed-value boundaries in the energy equation.");
218 :
219 48336 : MultiMooseEnum en_wall_types("fixed-temperature heatflux wallfunction convection");
220 96672 : en_wall_types.addDocumentation("fixed-temperature",
221 : "Set a constant fluid temperature on the wall");
222 96672 : en_wall_types.addDocumentation("heatflux", "Set a constant heat flux on the wall");
223 96672 : en_wall_types.addDocumentation(
224 : "wallfunction",
225 : "Use a wall function, defined by the turbulence Physics, to compute the wall heat flux");
226 96672 : en_wall_types.addDocumentation("convection",
227 : "Computes the heat transfer as h(T_fluid - T_solid), where h "
228 : "generally computed using a correlation");
229 96672 : params.addParam<MultiMooseEnum>(
230 : "energy_wall_types", en_wall_types, "Types for the wall boundaries for the energy equation.");
231 96672 : params.addParam<std::vector<BoundaryName>>(
232 : "energy_wall_boundaries",
233 : {},
234 : "Wall boundaries to apply energy boundary conditions on. If not specified, the flow equation "
235 : "Physics wall boundaries will be used");
236 :
237 48336 : params.addParam<std::vector<MooseFunctorName>>(
238 : "energy_wall_function",
239 48336 : std::vector<MooseFunctorName>(),
240 : "Functions for Dirichlet/Neumann boundaries in the energy equation. For wall types requiring "
241 : "multiple functions, the syntax is <function_1>:<function_2>:... So, 'convection' types are "
242 : "'<Tinf_function>:<htc_function>'.");
243 :
244 48336 : params.addParam<std::vector<std::vector<SubdomainName>>>(
245 : "ambient_convection_blocks",
246 48336 : std::vector<std::vector<SubdomainName>>(),
247 : "The blocks where the ambient convection is present.");
248 :
249 48336 : params.addParam<std::vector<MooseFunctorName>>(
250 : "ambient_convection_alpha",
251 48336 : std::vector<MooseFunctorName>(),
252 : "The heat exchange coefficients for each block in 'ambient_convection_blocks'.");
253 :
254 48336 : params.addParam<std::vector<MooseFunctorName>>(
255 : "ambient_temperature",
256 48336 : std::vector<MooseFunctorName>(),
257 : "The ambient temperature for each block in 'ambient_convection_blocks'.");
258 :
259 96672 : params.addParam<MooseFunctorName>(
260 : "external_heat_source",
261 : "The name of a functor which contains the external heat source for the energy equation.");
262 96672 : params.addParam<Real>(
263 96672 : "external_heat_source_coeff", 1.0, "Multiplier for the coupled heat source term.");
264 96672 : params.addParam<bool>("use_external_enthalpy_material",
265 96672 : false,
266 : "To indicate if the enthalpy material is set up outside of the action.");
267 :
268 96672 : params.addParamNamesToGroup("ambient_convection_alpha ambient_convection_blocks "
269 : "ambient_temperature",
270 : "Volumetric heat convection");
271 96672 : params.addParamNamesToGroup("external_heat_source external_heat_source_coeff", "Heat source");
272 96672 : params.addParamNamesToGroup("use_external_enthalpy_material", "Material properties");
273 :
274 48336 : return params;
275 48336 : }
276 :
277 : InputParameters
278 48217 : NSFVBase::commonScalarFieldAdvectionParams()
279 : {
280 48217 : InputParameters params = emptyInputParameters();
281 48217 : params.addParam<std::vector<NonlinearVariableName>>(
282 : "passive_scalar_names",
283 48217 : std::vector<NonlinearVariableName>(),
284 : "Vector containing the names of the advected scalar variables.");
285 :
286 96434 : params.addParam<std::vector<FunctionName>>("initial_scalar_variables",
287 : "Initial values of the passive scalar variables.");
288 :
289 48217 : params.addParam<std::vector<MooseFunctorName>>(
290 : "passive_scalar_diffusivity",
291 48217 : std::vector<MooseFunctorName>(),
292 : "Functor names for the diffusivities used for the passive scalar fields.");
293 :
294 48217 : params.addParam<std::vector<MooseFunctorName>>(
295 : "passive_scalar_source",
296 48217 : std::vector<MooseFunctorName>(),
297 : "Functor names for the sources used for the passive scalar fields.");
298 :
299 48217 : params.addParam<std::vector<std::vector<MooseFunctorName>>>(
300 : "passive_scalar_coupled_source",
301 48217 : std::vector<std::vector<MooseFunctorName>>(),
302 : "Coupled variable names for the sources used for the passive scalar fields. If multiple "
303 : "sources for each equation are specified, major (outer) ordering by equation.");
304 :
305 48217 : params.addParam<std::vector<std::vector<Real>>>(
306 : "passive_scalar_coupled_source_coeff",
307 48217 : std::vector<std::vector<Real>>(),
308 : "Coupled variable multipliers for the sources used for the passive scalar fields. If multiple"
309 : " sources for each equation are specified, major (outer) ordering by equation.");
310 :
311 48217 : MultiMooseEnum ps_inlet_types("fixed-value flux-mass flux-velocity");
312 96434 : params.addParam<MultiMooseEnum>(
313 : "passive_scalar_inlet_types",
314 : ps_inlet_types,
315 : "Types for the inlet boundaries for the passive scalar equation.");
316 :
317 96434 : params.addParamNamesToGroup("passive_scalar_names passive_scalar_diffusivity "
318 : "passive_scalar_source passive_scalar_coupled_source "
319 : "passive_scalar_coupled_source_coeff",
320 : "Passive scalar control");
321 48217 : return params;
322 48217 : }
323 :
324 : InputParameters
325 48119 : NSFVBase::commonTurbulenceParams()
326 : {
327 48119 : InputParameters params = emptyInputParameters();
328 :
329 : /**
330 : * Parameter controlling the turbulence handling used for the equations.
331 : */
332 48119 : params.addParam<std::vector<BoundaryName>>(
333 : "mixing_length_walls",
334 48119 : std::vector<BoundaryName>(),
335 : "Walls where the mixing length model should be utilized.");
336 :
337 48119 : ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
338 96238 : params.addParam<ExecFlagEnum>("mixing_length_aux_execute_on",
339 : exec_enum,
340 : "When the mixing length aux kernels should be executed.");
341 :
342 96238 : params.addParam<MooseFunctorName>(
343 96238 : "von_karman_const", 0.41, "Von Karman parameter for the mixing length model");
344 96238 : params.addParam<MooseFunctorName>("von_karman_const_0", 0.09, "'Escudier' model parameter");
345 96238 : params.addParam<MooseFunctorName>(
346 : "mixing_length_delta",
347 96238 : 1.0,
348 : "Tunable parameter related to the thickness of the boundary layer."
349 : "When it is not specified, Prandtl's original unbounded wall distance mixing length model is"
350 : "retrieved.");
351 96238 : params.addRangeCheckedParam<Real>("turbulent_prandtl",
352 : 1,
353 : "turbulent_prandtl > 0",
354 : "Turbulent Prandtl number for energy turbulent diffusion");
355 48119 : params.addParam<std::vector<Real>>(
356 : "passive_scalar_schmidt_number",
357 48119 : std::vector<Real>(),
358 : "Turbulent Schmidt numbers used for the passive scalar fields.");
359 96238 : params.deprecateParam("passive_scalar_schmidt_number", "Sc_t", "01/01/2025");
360 96238 : params.addParamNamesToGroup("mixing_length_walls mixing_length_aux_execute_on von_karman_const "
361 : "von_karman_const_0 mixing_length_delta",
362 : "Mixing length model");
363 :
364 48119 : return params;
365 0 : }
366 :
367 : InputParameters
368 47022 : NSFVBase::validParams()
369 : {
370 47022 : InputParameters params = Action::validParams();
371 :
372 : /**
373 : * Add params relevant to the objects we may add
374 : */
375 47022 : params += INSFVRhieChowInterpolator::uniqueParams();
376 47022 : params += INSFVMomentumAdvection::uniqueParams();
377 :
378 : /**
379 : * General parameters used to set up the simulation.
380 : */
381 47022 : params += NSFVBase::commonNavierStokesFlowParams();
382 :
383 94044 : params.addParam<bool>(
384 94044 : "porous_medium_treatment", false, "Whether to use porous medium kernels or not.");
385 :
386 94044 : MooseEnum turbulence_type("mixing-length none", "none");
387 94044 : params.addParam<MooseEnum>(
388 : "turbulence_handling",
389 : turbulence_type,
390 : "The way additional diffusivities are determined in the turbulent regime.");
391 :
392 94044 : params.addParam<bool>("initialize_variables_from_mesh_file",
393 94044 : false,
394 : "Determines if the variables that are added by the action are initialized "
395 : "from the mesh file (only for Exodus format)");
396 94044 : params.addParam<std::string>(
397 : "initial_from_file_timestep",
398 : "LATEST",
399 : "Gives the timestep (or \"LATEST\") for which to read a solution from a file "
400 : "for a given variable. (Default: LATEST)");
401 :
402 94044 : params.addParam<bool>("add_flow_equations", true, "True to add mass and momentum equations");
403 94044 : params.addParam<bool>("add_energy_equation", false, "True to add energy equation");
404 94044 : params.addParam<bool>("add_scalar_equation", false, "True to add advected scalar(s) equation");
405 :
406 94044 : params.addParamNamesToGroup("compressibility porous_medium_treatment turbulence_handling "
407 : "add_flow_equations add_energy_equation add_scalar_equation ",
408 : "General control");
409 :
410 94044 : params.addParamNamesToGroup("velocity_variable pressure_variable fluid_temperature_variable",
411 : "External variable");
412 :
413 : /**
414 : * Parameters influencing the porous medium treatment.
415 : */
416 :
417 94044 : params.addParam<MooseFunctorName>(
418 : "porosity", NS::porosity, "The name of the auxiliary variable for the porosity field.");
419 :
420 94044 : params.addParam<unsigned short>(
421 : "porosity_smoothing_layers",
422 : "The number of interpolation-reconstruction operations to perform on the porosity.");
423 :
424 94044 : MooseEnum porosity_interface_pressure_treatment("automatic bernoulli", "automatic");
425 94044 : params.addParam<MooseEnum>("porosity_interface_pressure_treatment",
426 : porosity_interface_pressure_treatment,
427 : "How to treat pressure at a porosity interface");
428 94044 : params.addParam<std::vector<BoundaryName>>(
429 : "pressure_drop_sidesets", {}, "Sidesets over which form loss coefficients are to be applied");
430 94044 : params.addParam<std::vector<Real>>(
431 : "pressure_drop_form_factors",
432 : {},
433 : "User-supplied form loss coefficients to be applied over the sidesets listed above");
434 :
435 94044 : params.addParam<bool>("use_friction_correction",
436 94044 : false,
437 : "If friction correction should be applied in the momentum equation.");
438 :
439 94044 : params.addParam<Real>(
440 : "consistent_scaling",
441 : "Scaling parameter for the friction correction in the momentum equation (if requested).");
442 :
443 94044 : params.addParamNamesToGroup("porosity porosity_smoothing_layers use_friction_correction "
444 : "consistent_scaling porosity_interface_pressure_treatment "
445 : "pressure_drop_sidesets pressure_drop_form_factors",
446 : "Porous medium treatment");
447 :
448 : /**
449 : * Parameters used to define the handling of the momentum-mass equations.
450 : */
451 47022 : std::vector<FunctionName> default_initial_velocity = {"1e-15", "1e-15", "1e-15"};
452 94044 : params.addParam<std::vector<FunctionName>>("initial_velocity",
453 : default_initial_velocity,
454 : "The initial velocity, assumed constant everywhere");
455 :
456 94044 : params.addParam<FunctionName>(
457 : "initial_pressure", "1e5", "The initial pressure, assumed constant everywhere");
458 :
459 47022 : params += NSFVBase::commonMomentumEquationParams();
460 :
461 : /**
462 : * Parameters describing the momentum equations boundary conditions
463 : */
464 47022 : params += NSFVBase::commonMomentumBoundaryTypesParams();
465 47022 : params += NSFVBase::commonMomentumBoundaryFluxesParams();
466 :
467 : /**
468 : * Parameters describing the fluid energy equation
469 : */
470 47022 : params += NSFVBase::commonFluidEnergyEquationParams();
471 :
472 : /**
473 : * Parameters describing the handling of advected scalar fields
474 : */
475 47022 : params += NSFVBase::commonScalarFieldAdvectionParams();
476 :
477 : // These parameters are not shared because the WCNSFVPhysics use functors
478 47022 : params.addParam<std::vector<std::vector<std::string>>>(
479 : "passive_scalar_inlet_function",
480 47022 : std::vector<std::vector<std::string>>(),
481 : "Functions for inlet boundaries in the passive scalar equations.");
482 :
483 : /**
484 : * Parameters describing the handling of turbulence
485 : */
486 47022 : params += NSFVBase::commonTurbulenceParams();
487 :
488 : /**
489 : * Parameters allowing the control over numerical schemes for different terms in the
490 : * Navier-Stokes + energy equations.
491 : */
492 :
493 47022 : MooseEnum adv_interpol_types(Moose::FV::interpolationMethods());
494 94044 : params.addParam<MooseEnum>("mass_advection_interpolation",
495 : adv_interpol_types,
496 : "The numerical scheme to use for interpolating density, "
497 : "as an advected quantity, to the face.");
498 94044 : params.addParam<MooseEnum>("momentum_advection_interpolation",
499 : adv_interpol_types,
500 : "The numerical scheme to use for interpolating momentum/velocity, "
501 : "as an advected quantity, to the face.");
502 94044 : params.addParam<MooseEnum>("energy_advection_interpolation",
503 : adv_interpol_types,
504 : "The numerical scheme to use for interpolating energy/temperature, "
505 : "as an advected quantity, to the face.");
506 94044 : params.addParam<MooseEnum>("passive_scalar_advection_interpolation",
507 : adv_interpol_types,
508 : "The numerical scheme to use for interpolating passive scalar field, "
509 : "as an advected quantity, to the face.");
510 :
511 94044 : MooseEnum face_interpol_types("average skewness-corrected", "average");
512 94044 : params.addParam<MooseEnum>("pressure_face_interpolation",
513 : face_interpol_types,
514 : "The numerical scheme to interpolate the pressure to the "
515 : "face (separate from the advected quantity interpolation).");
516 94044 : params.addParam<MooseEnum>("momentum_face_interpolation",
517 : face_interpol_types,
518 : "The numerical scheme to interpolate the velocity/momentum to the "
519 : "face (separate from the advected quantity interpolation).");
520 94044 : params.addParam<MooseEnum>("energy_face_interpolation",
521 : face_interpol_types,
522 : "The numerical scheme to interpolate the temperature/energy to the "
523 : "face (separate from the advected quantity interpolation).");
524 94044 : params.addParam<MooseEnum>(
525 : "passive_scalar_face_interpolation",
526 : face_interpol_types,
527 : "The numerical scheme to interpolate the passive scalar field variables to the "
528 : "face (separate from the advected quantity interpolation).");
529 :
530 94044 : MooseEnum velocity_interpolation("average rc", "rc");
531 94044 : params.addParam<MooseEnum>(
532 : "velocity_interpolation",
533 : velocity_interpolation,
534 : "The interpolation to use for the velocity. Options are "
535 : "'average' and 'rc' which stands for Rhie-Chow. The default is Rhie-Chow.");
536 :
537 94044 : params.addParam<bool>(
538 : "pressure_two_term_bc_expansion",
539 94044 : true,
540 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
541 : "of the pressure.");
542 94044 : params.addParam<bool>(
543 : "pressure_allow_expansion_on_bernoulli_faces",
544 94044 : false,
545 : "Switch to enable the two-term extrapolation on porosity jump faces. "
546 : "WARNING: Depending on the mesh, enabling this parameter may lead to "
547 : "termination in parallel runs due to insufficient ghosting between "
548 : "processors. An example can be the presence of multiple porosity jumps separated by only "
549 : "one cell while using the Bernoulli pressure treatment. In such cases adjust the "
550 : "`ghost_layers` parameter. ");
551 94044 : params.addParam<bool>(
552 : "momentum_two_term_bc_expansion",
553 94044 : true,
554 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
555 : "of the velocity/momentum.");
556 94044 : params.addParam<bool>(
557 : "energy_two_term_bc_expansion",
558 94044 : true,
559 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
560 : "of the temperature/energy.");
561 94044 : params.addParam<bool>(
562 : "passive_scalar_two_term_bc_expansion",
563 94044 : true,
564 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
565 : "of the advected passive scalar field.");
566 94044 : params.addParam<bool>(
567 : "mixing_length_two_term_bc_expansion",
568 94044 : true,
569 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
570 : "of the mixing length field.");
571 :
572 141066 : params.addRangeCheckedParam<Real>(
573 : "mass_scaling",
574 94044 : 1.0,
575 : "mass_scaling > 0.0",
576 : "The scaling factor for the mass variables (for incompressible simulation "
577 : "this is pressure scaling).");
578 141066 : params.addRangeCheckedParam<Real>("momentum_scaling",
579 94044 : 1.0,
580 : "momentum_scaling > 0.0",
581 : "The scaling factor for the momentum variables.");
582 141066 : params.addRangeCheckedParam<Real>(
583 94044 : "energy_scaling", 1.0, "energy_scaling > 0.0", "The scaling factor for the energy variable.");
584 141066 : params.addRangeCheckedParam<Real>("passive_scalar_scaling",
585 94044 : 1.0,
586 : "passive_scalar_scaling > 0.0",
587 : "The scaling factor for the passive scalar field variables.");
588 :
589 94044 : params.addParamNamesToGroup(
590 : "momentum_advection_interpolation energy_advection_interpolation "
591 : "passive_scalar_advection_interpolation mass_advection_interpolation "
592 : "momentum_face_interpolation energy_face_interpolation passive_scalar_face_interpolation "
593 : "pressure_face_interpolation momentum_two_term_bc_expansion "
594 : "energy_two_term_bc_expansion passive_scalar_two_term_bc_expansion "
595 : "mixing_length_two_term_bc_expansion pressure_two_term_bc_expansion "
596 : "pressure_allow_expansion_on_bernoulli_faces velocity_interpolation",
597 : "Numerical scheme");
598 :
599 94044 : params.addParamNamesToGroup("momentum_scaling energy_scaling mass_scaling passive_scalar_scaling",
600 : "Scaling");
601 :
602 : /**
603 : * Parameters controlling the ghosting/parallel execution
604 : */
605 141066 : params.addRangeCheckedParam<unsigned short>(
606 : "ghost_layers",
607 94044 : 2,
608 : "ghost_layers > 0",
609 : "The number of geometric/algebraic/coupling layers to ghost.");
610 :
611 94044 : params.addParamNamesToGroup("ghost_layers", "Parallel Execution Tuning");
612 :
613 : // Create input parameter groups
614 94044 : params.addParamNamesToGroup("dynamic_viscosity density thermal_expansion "
615 : "thermal_conductivity_blocks thermal_conductivity specific_heat",
616 : "Material property");
617 :
618 94044 : params.addParamNamesToGroup(
619 : "inlet_boundaries momentum_inlet_types momentum_inlet_function energy_inlet_types "
620 : "energy_inlet_function wall_boundaries momentum_wall_types energy_wall_boundaries "
621 : "energy_wall_types energy_wall_function outlet_boundaries momentum_outlet_types "
622 : "pressure_function passive_scalar_inlet_types passive_scalar_inlet_function flux_inlet_pps "
623 : "flux_inlet_directions",
624 : "Boundary condition");
625 :
626 94044 : params.addParamNamesToGroup(
627 : "initial_pressure initial_velocity initial_temperature initial_scalar_variables "
628 : "initialize_variables_from_mesh_file initial_from_file_timestep",
629 : "Initial condition");
630 :
631 47022 : return params;
632 47022 : }
|
