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 50409 : NSFVBase::commonNavierStokesFlowParams()
18 : {
19 50409 : InputParameters params = emptyInputParameters();
20 100818 : MooseEnum comp_type("incompressible weakly-compressible", "incompressible");
21 100818 : params.addParam<MooseEnum>(
22 : "compressibility", comp_type, "Compressibility constraint for the Navier-Stokes equations.");
23 :
24 100818 : 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 100818 : 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 100818 : 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 50409 : params.addParam<std::vector<BoundaryName>>(
43 50409 : "inlet_boundaries", std::vector<BoundaryName>(), "Names of inlet boundaries");
44 50409 : params.addParam<std::vector<BoundaryName>>(
45 50409 : "outlet_boundaries", std::vector<BoundaryName>(), "Names of outlet boundaries");
46 50409 : params.addParam<std::vector<BoundaryName>>(
47 50409 : "wall_boundaries", std::vector<BoundaryName>(), "Names of wall boundaries");
48 50409 : params.addParam<std::vector<BoundaryName>>("hydraulic_separator_sidesets",
49 50409 : std::vector<BoundaryName>(),
50 : "Sidesets which serve as hydraulic separators.");
51 50409 : return params;
52 50409 : }
53 :
54 : InputParameters
55 50409 : NSFVBase::commonMomentumEquationParams()
56 : {
57 50409 : InputParameters params = emptyInputParameters();
58 :
59 100818 : params.addParam<MooseFunctorName>(
60 : "dynamic_viscosity", NS::mu, "The name of the dynamic viscosity");
61 100818 : params.addParam<MooseFunctorName>("density", NS::density, "The name of the density");
62 :
63 : // Dynamic pressure parameter
64 : // TODO: make default
65 100818 : params.addParam<bool>("solve_for_dynamic_pressure",
66 100818 : false,
67 : "Whether to solve for the dynamic pressure instead of the total pressure");
68 :
69 : // Pressure pin parameters
70 100818 : params.addParam<bool>(
71 100818 : "pin_pressure", false, "Switch to enable pressure shifting for incompressible simulations.");
72 100818 : MooseEnum s_type("average point-value average-uo point-value-uo", "average-uo");
73 100818 : params.addParam<MooseEnum>(
74 : "pinned_pressure_type",
75 : s_type,
76 : "Types for shifting (pinning) the pressure in case of incompressible simulations.");
77 50409 : params.addParam<Point>(
78 : "pinned_pressure_point",
79 50409 : Point(),
80 : "The XYZ coordinates where pressure needs to be pinned for incompressible simulations.");
81 100818 : params.addParam<PostprocessorName>(
82 : "pinned_pressure_value",
83 : "1e5",
84 : "The value used for pinning the pressure (point value/domain average).");
85 :
86 100818 : params.addParam<bool>("boussinesq_approximation", false, "True to have Boussinesq approximation");
87 :
88 50409 : params.addParam<RealVectorValue>(
89 50409 : "gravity", RealVectorValue(0, 0, 0), "The gravitational acceleration vector.");
90 :
91 151227 : params.addRangeCheckedParam<Real>(
92 : "ref_temperature",
93 100818 : 273.15,
94 : "ref_temperature > 0.0",
95 : "Value for reference temperature in case of Boussinesq approximation");
96 100818 : params.addParam<MooseFunctorName>(
97 : "thermal_expansion",
98 : NS::alpha,
99 : "The name of the thermal expansion coefficient in the Boussinesq approximation");
100 :
101 100818 : params.addParamNamesToGroup(
102 : "pin_pressure pinned_pressure_type pinned_pressure_point pinned_pressure_value ",
103 : "Incompressible flow pressure constraint");
104 100818 : 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 100818 : 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 100818 : params.addParam<std::vector<std::vector<std::string>>>(
116 : "friction_types", {}, "The types of friction forces for every block in 'friction_blocks'.");
117 :
118 100818 : 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 100818 : params.addParam<bool>(
126 : "standard_friction_formulation",
127 100818 : 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 100818 : params.addParamNamesToGroup("friction_blocks friction_types friction_coeffs "
132 : "standard_friction_formulation",
133 : "Friction control");
134 50409 : return params;
135 50409 : }
136 :
137 : InputParameters
138 50409 : NSFVBase::commonMomentumBoundaryTypesParams()
139 : {
140 50409 : InputParameters params = emptyInputParameters();
141 50409 : MultiMooseEnum mom_inlet_types("fixed-velocity flux-velocity flux-mass fixed-pressure");
142 100818 : params.addParam<MultiMooseEnum>("momentum_inlet_types",
143 : mom_inlet_types,
144 : "Types of inlet boundaries for the momentum equation.");
145 :
146 50409 : MultiMooseEnum mom_outlet_types("fixed-pressure zero-gradient fixed-pressure-zero-gradient");
147 100818 : params.addParam<MultiMooseEnum>("momentum_outlet_types",
148 : mom_outlet_types,
149 : "Types of outlet boundaries for the momentum equation");
150 50409 : params.addParam<std::vector<MooseFunctorName>>("pressure_functors",
151 50409 : std::vector<MooseFunctorName>(),
152 : "Functions for boundary pressures at outlets.");
153 :
154 50409 : MultiMooseEnum mom_wall_types("symmetry noslip slip wallfunction");
155 100818 : params.addParam<MultiMooseEnum>(
156 : "momentum_wall_types", mom_wall_types, "Types of wall boundaries for the momentum equation");
157 :
158 50409 : return params;
159 50409 : }
160 :
161 : InputParameters
162 50409 : NSFVBase::commonMomentumBoundaryFluxesParams()
163 : {
164 50409 : InputParameters params = emptyInputParameters();
165 50409 : params.addParam<std::vector<std::vector<MooseFunctorName>>>(
166 : "momentum_inlet_functors",
167 50409 : 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 50409 : params.addParam<std::vector<PostprocessorName>>(
173 : "flux_inlet_pps",
174 50409 : 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 50409 : params.addParam<std::vector<Point>>(
178 : "flux_inlet_directions",
179 50409 : 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 100818 : params.addParamNamesToGroup("flux_inlet_pps flux_inlet_directions", "Boundary condition");
186 :
187 50409 : return params;
188 0 : }
189 :
190 : InputParameters
191 49818 : NSFVBase::commonFluidEnergyEquationParams()
192 : {
193 49818 : InputParameters params = emptyInputParameters();
194 99636 : params.addParam<FunctionName>(
195 : "initial_temperature", "300", "The initial temperature, assumed constant everywhere");
196 :
197 99636 : 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 99636 : params.addParam<std::vector<MooseFunctorName>>(
203 : "thermal_conductivity",
204 149454 : std::vector<MooseFunctorName>({NS::k}),
205 : "The name of the fluid thermal conductivity for each block");
206 :
207 99636 : params.addParam<MooseFunctorName>("specific_heat", NS::cp, "The name of the specific heat");
208 :
209 49818 : MultiMooseEnum en_inlet_types("fixed-temperature flux-mass flux-velocity heatflux");
210 99636 : params.addParam<MultiMooseEnum>("energy_inlet_types",
211 : en_inlet_types,
212 : "Types for the inlet boundaries for the energy equation.");
213 :
214 49818 : params.addParam<std::vector<MooseFunctorName>>(
215 : "energy_inlet_functors",
216 49818 : std::vector<MooseFunctorName>(),
217 : "Functions for fixed-value boundaries in the energy equation.");
218 :
219 49818 : MultiMooseEnum en_wall_types("fixed-temperature heatflux wallfunction convection");
220 99636 : en_wall_types.addDocumentation("fixed-temperature",
221 : "Set a constant fluid temperature on the wall");
222 99636 : en_wall_types.addDocumentation("heatflux", "Set a constant heat flux on the wall");
223 99636 : en_wall_types.addDocumentation(
224 : "wallfunction",
225 : "Use a wall function, defined by the turbulence Physics, to compute the wall heat flux");
226 99636 : 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 99636 : params.addParam<MultiMooseEnum>(
230 : "energy_wall_types", en_wall_types, "Types for the wall boundaries for the energy equation.");
231 99636 : 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 49818 : params.addParam<std::vector<MooseFunctorName>>(
238 : "energy_wall_functors",
239 49818 : 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 49818 : params.addParam<std::vector<std::vector<SubdomainName>>>(
245 : "ambient_convection_blocks",
246 49818 : std::vector<std::vector<SubdomainName>>(),
247 : "The blocks where the ambient convection is present.");
248 :
249 49818 : params.addParam<std::vector<MooseFunctorName>>(
250 : "ambient_convection_alpha",
251 49818 : std::vector<MooseFunctorName>(),
252 : "The heat exchange coefficients for each block in 'ambient_convection_blocks'.");
253 :
254 49818 : params.addParam<std::vector<MooseFunctorName>>(
255 : "ambient_temperature",
256 49818 : std::vector<MooseFunctorName>(),
257 : "The ambient temperature for each block in 'ambient_convection_blocks'.");
258 :
259 99636 : params.addParam<MooseFunctorName>(
260 : "external_heat_source",
261 : "The name of a functor which contains the external heat source for the energy equation.");
262 99636 : params.addParam<Real>(
263 99636 : "external_heat_source_coeff", 1.0, "Multiplier for the coupled heat source term.");
264 99636 : params.addParam<bool>("use_external_enthalpy_material",
265 99636 : false,
266 : "To indicate if the enthalpy material is set up outside of the action.");
267 :
268 99636 : params.addParamNamesToGroup("ambient_convection_alpha ambient_convection_blocks "
269 : "ambient_temperature",
270 : "Volumetric heat convection");
271 99636 : params.addParamNamesToGroup("external_heat_source external_heat_source_coeff", "Heat source");
272 99636 : params.addParamNamesToGroup("use_external_enthalpy_material", "Material properties");
273 :
274 49818 : return params;
275 49818 : }
276 :
277 : InputParameters
278 49642 : NSFVBase::commonScalarFieldAdvectionParams()
279 : {
280 49642 : InputParameters params = emptyInputParameters();
281 49642 : params.addParam<std::vector<NonlinearVariableName>>(
282 : "passive_scalar_names",
283 49642 : std::vector<NonlinearVariableName>(),
284 : "Vector containing the names of the advected scalar variables.");
285 :
286 99284 : params.addParam<std::vector<FunctionName>>("initial_scalar_variables",
287 : "Initial values of the passive scalar variables.");
288 :
289 49642 : params.addParam<std::vector<MooseFunctorName>>(
290 : "passive_scalar_diffusivity",
291 49642 : std::vector<MooseFunctorName>(),
292 : "Functor names for the diffusivities used for the passive scalar fields.");
293 :
294 49642 : params.addParam<std::vector<MooseFunctorName>>(
295 : "passive_scalar_source",
296 49642 : std::vector<MooseFunctorName>(),
297 : "Functor names for the sources used for the passive scalar fields.");
298 :
299 49642 : params.addParam<std::vector<std::vector<MooseFunctorName>>>(
300 : "passive_scalar_coupled_source",
301 49642 : 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 49642 : params.addParam<std::vector<std::vector<Real>>>(
306 : "passive_scalar_coupled_source_coeff",
307 49642 : 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 49642 : MultiMooseEnum ps_inlet_types("fixed-value flux-mass flux-velocity");
312 99284 : 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 99284 : 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 49642 : return params;
322 49642 : }
323 :
324 : InputParameters
325 49544 : NSFVBase::commonTurbulenceParams()
326 : {
327 49544 : InputParameters params = emptyInputParameters();
328 :
329 : /**
330 : * Parameter controlling the turbulence handling used for the equations.
331 : */
332 49544 : params.addParam<std::vector<BoundaryName>>(
333 : "mixing_length_walls",
334 49544 : std::vector<BoundaryName>(),
335 : "Walls where the mixing length model should be utilized.");
336 :
337 49544 : ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
338 99088 : params.addParam<ExecFlagEnum>("mixing_length_aux_execute_on",
339 : exec_enum,
340 : "When the mixing length aux kernels should be executed.");
341 :
342 99088 : params.addParam<MooseFunctorName>(
343 99088 : "von_karman_const", 0.41, "Von Karman parameter for the mixing length model");
344 99088 : params.addParam<MooseFunctorName>("von_karman_const_0", 0.09, "'Escudier' model parameter");
345 99088 : params.addParam<MooseFunctorName>(
346 : "mixing_length_delta",
347 99088 : 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 99088 : params.addRangeCheckedParam<Real>("turbulent_prandtl",
352 : 1,
353 : "turbulent_prandtl > 0",
354 : "Turbulent Prandtl number for energy turbulent diffusion");
355 49544 : params.addParam<std::vector<Real>>(
356 49544 : "Sc_t", std::vector<Real>(), "Turbulent Schmidt numbers used for the passive scalar fields.");
357 99088 : params.addParamNamesToGroup("mixing_length_walls mixing_length_aux_execute_on von_karman_const "
358 : "von_karman_const_0 mixing_length_delta",
359 : "Mixing length model");
360 :
361 49544 : return params;
362 0 : }
363 :
364 : InputParameters
365 48447 : NSFVBase::validParams()
366 : {
367 48447 : InputParameters params = Action::validParams();
368 :
369 : /**
370 : * Add params relevant to the objects we may add
371 : */
372 48447 : params += INSFVRhieChowInterpolator::uniqueParams();
373 48447 : params += INSFVMomentumAdvection::uniqueParams();
374 :
375 : /**
376 : * General parameters used to set up the simulation.
377 : */
378 48447 : params += NSFVBase::commonNavierStokesFlowParams();
379 :
380 96894 : params.addParam<bool>(
381 96894 : "porous_medium_treatment", false, "Whether to use porous medium kernels or not.");
382 :
383 96894 : MooseEnum turbulence_type("mixing-length none", "none");
384 96894 : params.addParam<MooseEnum>(
385 : "turbulence_handling",
386 : turbulence_type,
387 : "The way additional diffusivities are determined in the turbulent regime.");
388 :
389 96894 : params.addParam<bool>("initialize_variables_from_mesh_file",
390 96894 : false,
391 : "Determines if the variables that are added by the action are initialized "
392 : "from the mesh file (only for Exodus format)");
393 96894 : params.addParam<std::string>(
394 : "initial_from_file_timestep",
395 : "LATEST",
396 : "Gives the timestep (or \"LATEST\") for which to read a solution from a file "
397 : "for a given variable. (Default: LATEST)");
398 :
399 96894 : params.addParam<bool>("add_flow_equations", true, "True to add mass and momentum equations");
400 96894 : params.addParam<bool>("add_energy_equation", false, "True to add energy equation");
401 96894 : params.addParam<bool>("add_scalar_equation", false, "True to add advected scalar(s) equation");
402 :
403 96894 : params.addParamNamesToGroup("compressibility porous_medium_treatment turbulence_handling "
404 : "add_flow_equations add_energy_equation add_scalar_equation ",
405 : "General control");
406 :
407 96894 : params.addParamNamesToGroup("velocity_variable pressure_variable fluid_temperature_variable",
408 : "External variable");
409 :
410 : /**
411 : * Parameters influencing the porous medium treatment.
412 : */
413 :
414 96894 : params.addParam<MooseFunctorName>(
415 : "porosity", NS::porosity, "The name of the auxiliary variable for the porosity field.");
416 :
417 96894 : params.addParam<unsigned short>(
418 : "porosity_smoothing_layers",
419 : "The number of interpolation-reconstruction operations to perform on the porosity.");
420 :
421 96894 : MooseEnum porosity_interface_pressure_treatment("automatic bernoulli", "automatic");
422 96894 : params.addParam<MooseEnum>("porosity_interface_pressure_treatment",
423 : porosity_interface_pressure_treatment,
424 : "How to treat pressure at a porosity interface");
425 96894 : params.addParam<std::vector<BoundaryName>>(
426 : "pressure_drop_sidesets", {}, "Sidesets over which form loss coefficients are to be applied");
427 96894 : params.addParam<std::vector<Real>>(
428 : "pressure_drop_form_factors",
429 : {},
430 : "User-supplied form loss coefficients to be applied over the sidesets listed above");
431 :
432 96894 : params.addParam<bool>("use_friction_correction",
433 96894 : false,
434 : "If friction correction should be applied in the momentum equation.");
435 :
436 96894 : params.addParam<Real>(
437 : "consistent_scaling",
438 : "Scaling parameter for the friction correction in the momentum equation (if requested).");
439 :
440 96894 : params.addParamNamesToGroup("porosity porosity_smoothing_layers use_friction_correction "
441 : "consistent_scaling porosity_interface_pressure_treatment "
442 : "pressure_drop_sidesets pressure_drop_form_factors",
443 : "Porous medium treatment");
444 :
445 : /**
446 : * Parameters used to define the handling of the momentum-mass equations.
447 : */
448 48447 : std::vector<FunctionName> default_initial_velocity = {"1e-15", "1e-15", "1e-15"};
449 96894 : params.addParam<std::vector<FunctionName>>("initial_velocity",
450 : default_initial_velocity,
451 : "The initial velocity, assumed constant everywhere");
452 :
453 96894 : params.addParam<FunctionName>(
454 : "initial_pressure", "1e5", "The initial pressure, assumed constant everywhere");
455 :
456 48447 : params += NSFVBase::commonMomentumEquationParams();
457 :
458 : /**
459 : * Parameters describing the momentum equations boundary conditions
460 : */
461 48447 : params += NSFVBase::commonMomentumBoundaryTypesParams();
462 48447 : params += NSFVBase::commonMomentumBoundaryFluxesParams();
463 :
464 : /**
465 : * Parameters describing the fluid energy equation
466 : */
467 48447 : params += NSFVBase::commonFluidEnergyEquationParams();
468 :
469 : /**
470 : * Parameters describing the handling of advected scalar fields
471 : */
472 48447 : params += NSFVBase::commonScalarFieldAdvectionParams();
473 :
474 : /**
475 : * Parameters describing the handling of turbulence
476 : */
477 48447 : params += NSFVBase::commonTurbulenceParams();
478 :
479 : /**
480 : * Parameters allowing the control over numerical schemes for different terms in the
481 : * Navier-Stokes + energy equations.
482 : */
483 :
484 48447 : MooseEnum adv_interpol_types(Moose::FV::interpolationMethods());
485 96894 : params.addParam<MooseEnum>("mass_advection_interpolation",
486 : adv_interpol_types,
487 : "The numerical scheme to use for interpolating density, "
488 : "as an advected quantity, to the face.");
489 96894 : params.addParam<MooseEnum>("momentum_advection_interpolation",
490 : adv_interpol_types,
491 : "The numerical scheme to use for interpolating momentum/velocity, "
492 : "as an advected quantity, to the face.");
493 96894 : params.addParam<MooseEnum>("energy_advection_interpolation",
494 : adv_interpol_types,
495 : "The numerical scheme to use for interpolating energy/temperature, "
496 : "as an advected quantity, to the face.");
497 96894 : params.addParam<MooseEnum>("passive_scalar_advection_interpolation",
498 : adv_interpol_types,
499 : "The numerical scheme to use for interpolating passive scalar field, "
500 : "as an advected quantity, to the face.");
501 :
502 96894 : MooseEnum face_interpol_types("average skewness-corrected", "average");
503 96894 : params.addParam<MooseEnum>("pressure_face_interpolation",
504 : face_interpol_types,
505 : "The numerical scheme to interpolate the pressure to the "
506 : "face (separate from the advected quantity interpolation).");
507 96894 : params.addParam<MooseEnum>("momentum_face_interpolation",
508 : face_interpol_types,
509 : "The numerical scheme to interpolate the velocity/momentum to the "
510 : "face (separate from the advected quantity interpolation).");
511 96894 : params.addParam<MooseEnum>("energy_face_interpolation",
512 : face_interpol_types,
513 : "The numerical scheme to interpolate the temperature/energy to the "
514 : "face (separate from the advected quantity interpolation).");
515 96894 : params.addParam<MooseEnum>(
516 : "passive_scalar_face_interpolation",
517 : face_interpol_types,
518 : "The numerical scheme to interpolate the passive scalar field variables to the "
519 : "face (separate from the advected quantity interpolation).");
520 :
521 96894 : MooseEnum velocity_interpolation("average rc", "rc");
522 96894 : params.addParam<MooseEnum>(
523 : "velocity_interpolation",
524 : velocity_interpolation,
525 : "The interpolation to use for the velocity. Options are "
526 : "'average' and 'rc' which stands for Rhie-Chow. The default is Rhie-Chow.");
527 :
528 96894 : params.addParam<bool>(
529 : "pressure_two_term_bc_expansion",
530 96894 : true,
531 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
532 : "of the pressure.");
533 96894 : params.addParam<bool>(
534 : "pressure_allow_expansion_on_bernoulli_faces",
535 96894 : false,
536 : "Switch to enable the two-term extrapolation on porosity jump faces. "
537 : "WARNING: Depending on the mesh, enabling this parameter may lead to "
538 : "termination in parallel runs due to insufficient ghosting between "
539 : "processors. An example can be the presence of multiple porosity jumps separated by only "
540 : "one cell while using the Bernoulli pressure treatment. In such cases adjust the "
541 : "`ghost_layers` parameter. ");
542 96894 : params.addParam<bool>(
543 : "momentum_two_term_bc_expansion",
544 96894 : true,
545 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
546 : "of the velocity/momentum.");
547 96894 : params.addParam<bool>(
548 : "energy_two_term_bc_expansion",
549 96894 : true,
550 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
551 : "of the temperature/energy.");
552 96894 : params.addParam<bool>(
553 : "passive_scalar_two_term_bc_expansion",
554 96894 : true,
555 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
556 : "of the advected passive scalar field.");
557 96894 : params.addParam<bool>(
558 : "mixing_length_two_term_bc_expansion",
559 96894 : true,
560 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
561 : "of the mixing length field.");
562 :
563 145341 : params.addRangeCheckedParam<Real>(
564 : "mass_scaling",
565 96894 : 1.0,
566 : "mass_scaling > 0.0",
567 : "The scaling factor for the mass variables (for incompressible simulation "
568 : "this is pressure scaling).");
569 145341 : params.addRangeCheckedParam<Real>("momentum_scaling",
570 96894 : 1.0,
571 : "momentum_scaling > 0.0",
572 : "The scaling factor for the momentum variables.");
573 145341 : params.addRangeCheckedParam<Real>(
574 96894 : "energy_scaling", 1.0, "energy_scaling > 0.0", "The scaling factor for the energy variable.");
575 145341 : params.addRangeCheckedParam<Real>("passive_scalar_scaling",
576 96894 : 1.0,
577 : "passive_scalar_scaling > 0.0",
578 : "The scaling factor for the passive scalar field variables.");
579 :
580 96894 : params.addParamNamesToGroup(
581 : "momentum_advection_interpolation energy_advection_interpolation "
582 : "passive_scalar_advection_interpolation mass_advection_interpolation "
583 : "momentum_face_interpolation energy_face_interpolation passive_scalar_face_interpolation "
584 : "pressure_face_interpolation momentum_two_term_bc_expansion "
585 : "energy_two_term_bc_expansion passive_scalar_two_term_bc_expansion "
586 : "mixing_length_two_term_bc_expansion pressure_two_term_bc_expansion "
587 : "pressure_allow_expansion_on_bernoulli_faces velocity_interpolation",
588 : "Numerical scheme");
589 :
590 96894 : params.addParamNamesToGroup("momentum_scaling energy_scaling mass_scaling passive_scalar_scaling",
591 : "Scaling");
592 :
593 : /**
594 : * Parameters controlling the ghosting/parallel execution
595 : */
596 145341 : params.addRangeCheckedParam<unsigned short>(
597 : "ghost_layers",
598 96894 : 2,
599 : "ghost_layers > 0",
600 : "The number of geometric/algebraic/coupling layers to ghost.");
601 :
602 96894 : params.addParamNamesToGroup("ghost_layers", "Parallel Execution Tuning");
603 :
604 : // Create input parameter groups
605 96894 : params.addParamNamesToGroup("dynamic_viscosity density thermal_expansion "
606 : "thermal_conductivity_blocks thermal_conductivity specific_heat",
607 : "Material property");
608 :
609 96894 : params.addParamNamesToGroup(
610 : "inlet_boundaries momentum_inlet_types momentum_inlet_functors energy_inlet_types "
611 : "energy_inlet_functors wall_boundaries momentum_wall_types energy_wall_boundaries "
612 : "energy_wall_types energy_wall_functors outlet_boundaries momentum_outlet_types "
613 : "pressure_functors passive_scalar_inlet_types flux_inlet_pps flux_inlet_directions",
614 : "Boundary condition");
615 :
616 96894 : params.addParamNamesToGroup(
617 : "initial_pressure initial_velocity initial_temperature initial_scalar_variables "
618 : "initialize_variables_from_mesh_file initial_from_file_timestep",
619 : "Initial condition");
620 :
621 48447 : return params;
622 48447 : }
|
