https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
NSFVBase Class Referenceabstract

Base class holding parameters for setting up NSFV actions. More...

#include <NSFVBase.h>

Inheritance diagram for NSFVBase:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
const std::string & name () const
 
std::string typeAndName () const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T * queryParam (const std::string &name) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &name) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 
void mooseError (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecatedNoTrace (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &relative_path) const
 
std::string getDataFilePath (const std::string &relative_path) const
 
PerfGraph & perfGraph ()
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static InputParameters validParams ()
 
static InputParameters commonNavierStokesFlowParams ()
 
static InputParameters commonMomentumEquationParams ()
 
static InputParameters commonMomentumBoundaryTypesParams ()
 
static InputParameters commonMomentumBoundaryFluxesParams ()
 
static InputParameters commonFluidEnergyEquationParams ()
 
static InputParameters commonScalarFieldAdvectionParams ()
 
static InputParameters commonTurbulenceParams ()
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 

Static Public Attributes

static const std::string unique_action_name_param
 
static const std::string type_param
 
static const std::string name_param
 
static const std::string unique_name_param
 
static const std::string app_param
 
static const std::string moose_base_param
 
static const std::string kokkos_object_param
 
static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Member Functions

bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
virtual void act ()=0
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse & _awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

Private Member Functions

bool addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
 
virtual std::string meshPropertyPrefix (const std::string &data_name) const
 
const RestartableDataValue & getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
 
void mooseErrorInternal (Args &&... args) const
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 

Private Attributes

const ParallelParamObject & _parent
 
MooseApp & _meta_data_app
 
const MooseObject *const _meta_data_object
 
const MooseBase & _si_moose_base
 
const FEProblemBase * _si_problem
 

Detailed Description

Base class holding parameters for setting up NSFV actions.

Definition at line 17 of file NSFVBase.h.

Member Function Documentation

◆ commonFluidEnergyEquationParams()

InputParameters NSFVBase::commonFluidEnergyEquationParams ( )
static

Definition at line 197 of file NSFVBase.C.

198{
199 InputParameters params = emptyInputParameters();
200 params.addParam<FunctionName>(
201 "initial_temperature", "300", "The initial temperature, assumed constant everywhere");
202
203 params.addParam<std::vector<std::vector<SubdomainName>>>(
204 "thermal_conductivity_blocks",
205 {},
206 "The blocks where the user wants define different thermal conductivities.");
207
208 params.addParam<std::vector<MooseFunctorName>>(
209 "thermal_conductivity",
210 std::vector<MooseFunctorName>({NS::k}),
211 "The name of the fluid thermal conductivity for each block");
212
213 params.addParam<MooseFunctorName>("specific_heat", NS::cp, "The name of the specific heat");
214
215 MultiMooseEnum en_inlet_types("fixed-temperature flux-mass flux-velocity heatflux");
216 params.addParam<MultiMooseEnum>("energy_inlet_types",
217 en_inlet_types,
218 "Types for the inlet boundaries for the energy equation.");
219
220 params.addParam<std::vector<MooseFunctorName>>(
221 "energy_inlet_functors",
222 std::vector<MooseFunctorName>(),
223 "Functions for fixed-value boundaries in the energy equation.");
224
225 MultiMooseEnum en_wall_types("fixed-temperature heatflux wallfunction convection");
226 en_wall_types.addDocumentation("fixed-temperature",
227 "Set a constant fluid temperature on the wall");
228 en_wall_types.addDocumentation("heatflux", "Set a constant heat flux on the wall");
229 en_wall_types.addDocumentation(
230 "wallfunction",
231 "Use a wall function, defined by the turbulence Physics, to compute the wall heat flux");
232 en_wall_types.addDocumentation("convection",
233 "Computes the heat transfer as h(T_fluid - T_solid), where h "
234 "generally computed using a correlation");
235 params.addParam<MultiMooseEnum>(
236 "energy_wall_types", en_wall_types, "Types for the wall boundaries for the energy equation.");
237 params.addParam<std::vector<BoundaryName>>(
238 "energy_wall_boundaries",
239 {},
240 "Wall boundaries to apply energy boundary conditions on. If not specified, the flow equation "
241 "Physics wall boundaries will be used");
242
243 params.addParam<std::vector<MooseFunctorName>>(
244 "energy_wall_functors",
245 std::vector<MooseFunctorName>(),
246 "Functions for Dirichlet/Neumann boundaries in the energy equation. For wall types requiring "
247 "multiple functions, the syntax is <function_1>:<function_2>:... So, 'convection' types are "
248 "'<Tinf_function>:<htc_function>'.");
249
250 params.addParam<std::vector<std::vector<SubdomainName>>>(
251 "ambient_convection_blocks",
252 std::vector<std::vector<SubdomainName>>(),
253 "The blocks where the ambient convection is present.");
254
255 params.addParam<std::vector<MooseFunctorName>>(
256 "ambient_convection_alpha",
257 std::vector<MooseFunctorName>(),
258 "The heat exchange coefficients for each block in 'ambient_convection_blocks'.");
259
260 params.addParam<std::vector<MooseFunctorName>>(
261 "ambient_temperature",
262 std::vector<MooseFunctorName>(),
263 "The ambient temperature for each block in 'ambient_convection_blocks'.");
264
265 params.addParam<MooseFunctorName>(
266 "external_heat_source",
267 "The name of a functor which contains the external heat source for the energy equation.");
268 params.addParam<Real>(
269 "external_heat_source_coeff", 1.0, "Multiplier for the coupled heat source term.");
270 params.addParam<bool>("use_external_enthalpy_material",
271 false,
272 "To indicate if the enthalpy material is set up outside of the action.");
273
274 params.addParamNamesToGroup("ambient_convection_alpha ambient_convection_blocks "
275 "ambient_temperature",
276 "Volumetric heat convection");
277 params.addParamNamesToGroup("external_heat_source external_heat_source_coeff", "Heat source");
278 params.addParamNamesToGroup("use_external_enthalpy_material", "Material properties");
279
280 return params;
281}
emptyInputParameters
InputParameters emptyInputParameters()
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
NS::cp
static const std::string cp
Definition NS.h:125
NS::k
static const std::string k
Definition NS.h:134
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

Referenced by validParams(), and WCNSFVFluidHeatTransferPhysicsBase::validParams().

◆ commonMomentumBoundaryFluxesParams()

InputParameters NSFVBase::commonMomentumBoundaryFluxesParams ( )
static

Definition at line 168 of file NSFVBase.C.

169{
170 InputParameters params = emptyInputParameters();
171 params.addParam<std::vector<std::vector<MooseFunctorName>>>(
172 "momentum_inlet_functors",
173 std::vector<std::vector<MooseFunctorName>>(),
174 "Functions for inlet boundary velocities or pressures (for fixed-pressure option). Provide a "
175 "double vector where the leading dimension corresponds to the number of fixed-velocity and "
176 "fixed-pressure entries in momentum_inlet_types and the second index runs either over "
177 "dimensions for fixed-velocity boundaries or is a single function name for pressure inlets.");
178 params.addParam<std::vector<PostprocessorName>>(
179 "flux_inlet_pps",
180 std::vector<PostprocessorName>(),
181 "The name of the postprocessors which compute the mass flow/ velocity magnitude. "
182 "Mainly used for coupling between different applications.");
183 params.addParam<std::vector<Point>>(
184 "flux_inlet_directions",
185 std::vector<Point>(),
186 "The directions which can be used to define the orientation of the flux with respect to the "
187 "mesh. This can be used to define a flux which is incoming with an angle or to adjust the "
188 "flux direction with respect to the normal. If the inlet surface is defined on an internal "
189 "face, this is necessary to ensure the arbitrary orientation of the normal does not result "
190 "in non-physical results.");
191 params.addParamNamesToGroup("flux_inlet_pps flux_inlet_directions", "Boundary condition");
192
193 return params;
194}

Referenced by validParams(), and WCNSFVFlowPhysicsBase::validParams().

◆ commonMomentumBoundaryTypesParams()

InputParameters NSFVBase::commonMomentumBoundaryTypesParams ( )
static

Definition at line 144 of file NSFVBase.C.

145{
146 InputParameters params = emptyInputParameters();
147 MultiMooseEnum mom_inlet_types("fixed-velocity flux-velocity flux-mass fixed-pressure");
148 params.addParam<MultiMooseEnum>("momentum_inlet_types",
149 mom_inlet_types,
150 "Types of inlet boundaries for the momentum equation.");
151
152 MultiMooseEnum mom_outlet_types("fixed-pressure zero-gradient fixed-pressure-zero-gradient");
153 params.addParam<MultiMooseEnum>("momentum_outlet_types",
154 mom_outlet_types,
155 "Types of outlet boundaries for the momentum equation");
156 params.addParam<std::vector<MooseFunctorName>>("pressure_functors",
157 std::vector<MooseFunctorName>(),
158 "Functions for boundary pressures at outlets.");
159
160 MultiMooseEnum mom_wall_types("symmetry noslip slip wallfunction");
161 params.addParam<MultiMooseEnum>(
162 "momentum_wall_types", mom_wall_types, "Types of wall boundaries for the momentum equation");
163
164 return params;
165}

Referenced by validParams(), and WCNSFVFlowPhysicsBase::validParams().

◆ commonMomentumEquationParams()

InputParameters NSFVBase::commonMomentumEquationParams ( )
static

Parameters controlling the friction terms in case of porous medium simulations.

Definition at line 55 of file NSFVBase.C.

56{
57 InputParameters params = emptyInputParameters();
58
59 params.addParam<MooseFunctorName>(
60 "dynamic_viscosity", NS::mu, "The name of the dynamic viscosity");
61 params.addParam<MooseFunctorName>("density", NS::density, "The name of the density");
62
63 // Dynamic pressure parameter
64 // TODO: make default
65 params.addParam<bool>("solve_for_dynamic_pressure",
66 false,
67 "Whether to solve for the dynamic pressure instead of the total pressure");
68 params.addParam<Point>("reference_pressure_point",
69 Point(0, 0, 0),
70 "Point at which the gravity term for the static pressure is zero");
71 params.addParam<Real>("reference_pressure", 1e5, "Total pressure at the reference point");
72 params.addParamNamesToGroup(
73 "solve_for_dynamic_pressure reference_pressure_point reference_pressure", "Dynamic pressure");
74
75 // Pressure pin parameters
76 params.addParam<bool>(
77 "pin_pressure", false, "Switch to enable pressure shifting for incompressible simulations.");
78 MooseEnum s_type("average point-value average-uo point-value-uo", "average-uo");
79 params.addParam<MooseEnum>(
80 "pinned_pressure_type",
81 s_type,
82 "Types for shifting (pinning) the pressure in case of incompressible simulations.");
83 params.addParam<Point>(
84 "pinned_pressure_point",
85 Point(),
86 "The XYZ coordinates where pressure needs to be pinned for incompressible simulations.");
87 params.addParam<PostprocessorName>(
88 "pinned_pressure_value",
89 "1e5",
90 "The value used for pinning the pressure (point value/domain average).");
91
92 params.addParam<bool>("boussinesq_approximation", false, "True to have Boussinesq approximation");
93
94 params.addParam<RealVectorValue>(
95 "gravity", RealVectorValue(0, 0, 0), "The gravitational acceleration vector.");
96
97 params.addRangeCheckedParam<Real>(
98 "ref_temperature",
99 273.15,
100 "ref_temperature > 0.0",
101 "Value for reference temperature in case of Boussinesq approximation");
102 params.addParam<MooseFunctorName>(
103 "thermal_expansion",
104 NS::alpha,
105 "The name of the thermal expansion coefficient in the Boussinesq approximation");
106
107 params.addParamNamesToGroup(
108 "pin_pressure pinned_pressure_type pinned_pressure_point pinned_pressure_value ",
109 "Incompressible flow pressure constraint");
110 params.addParamNamesToGroup("ref_temperature boussinesq_approximation gravity",
111 "Gravity treatment");
112
116 params.addParam<std::vector<std::vector<SubdomainName>>>(
117 "friction_blocks",
118 {},
119 "The blocks where the friction factors are applied to emulate flow resistances.");
120
121 params.addParam<std::vector<std::vector<std::string>>>(
122 "friction_types", {}, "The types of friction forces for every block in 'friction_blocks'.");
123
124 params.addParam<std::vector<std::vector<std::string>>>(
125 "friction_coeffs",
126 {},
127 "The friction coefficients for every item in 'friction_types'. Note that if "
128 "'porous_medium_treatment' is enabled, the coefficients already contain a velocity "
129 "multiplier but they are not multiplied with density yet!");
130
131 params.addParam<bool>(
132 "standard_friction_formulation",
133 true,
134 "Flag to enable the standard friction formulation or its alternative, "
135 "which is a simplified version (see user documentation for PINSFVMomentumFriction).");
136
137 params.addParamNamesToGroup("friction_blocks friction_types friction_coeffs "
138 "standard_friction_formulation",
139 "Friction control");
140 return params;
141}
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
NS::density
static const std::string density
Definition NS.h:34
NS::mu
static const std::string mu
Definition NS.h:127
NS::alpha
static const std::string alpha
Definition NS.h:138
libMesh::RealVectorValue
VectorValue< Real > RealVectorValue

Referenced by validParams(), and WCNSFVFlowPhysicsBase::validParams().

◆ commonNavierStokesFlowParams()

InputParameters NSFVBase::commonNavierStokesFlowParams ( )
static

Parameters used to define the boundaries of the domain.

Definition at line 17 of file NSFVBase.C.

18{
19 InputParameters params = emptyInputParameters();
20 MooseEnum comp_type("incompressible weakly-compressible", "incompressible");
21 params.addParam<MooseEnum>(
22 "compressibility", comp_type, "Compressibility constraint for the Navier-Stokes equations.");
23
24 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 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 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
42 params.addParam<std::vector<BoundaryName>>(
43 "inlet_boundaries", std::vector<BoundaryName>(), "Names of inlet boundaries");
44 params.addParam<std::vector<BoundaryName>>(
45 "outlet_boundaries", std::vector<BoundaryName>(), "Names of outlet boundaries");
46 params.addParam<std::vector<BoundaryName>>(
47 "wall_boundaries", std::vector<BoundaryName>(), "Names of wall boundaries");
48 params.addParam<std::vector<BoundaryName>>("hydraulic_separator_sidesets",
49 std::vector<BoundaryName>(),
50 "Sidesets which serve as hydraulic separators.");
51 return params;
52}

Referenced by validParams(), and WCNSFVFlowPhysicsBase::validParams().

◆ commonScalarFieldAdvectionParams()

InputParameters NSFVBase::commonScalarFieldAdvectionParams ( )
static

Definition at line 284 of file NSFVBase.C.

285{
286 InputParameters params = emptyInputParameters();
287 params.addParam<std::vector<NonlinearVariableName>>(
288 "passive_scalar_names",
289 std::vector<NonlinearVariableName>(),
290 "Vector containing the names of the advected scalar variables.");
291
292 params.addParam<std::vector<FunctionName>>("initial_scalar_variables",
293 "Initial values of the passive scalar variables.");
294
295 params.addParam<std::vector<MooseFunctorName>>(
296 "passive_scalar_diffusivity",
297 std::vector<MooseFunctorName>(),
298 "Functor names for the diffusivities used for the passive scalar fields.");
299
300 params.addParam<std::vector<MooseFunctorName>>(
301 "passive_scalar_source",
302 std::vector<MooseFunctorName>(),
303 "Functor names for the sources used for the passive scalar fields.");
304
305 params.addParam<std::vector<std::vector<MooseFunctorName>>>(
306 "passive_scalar_coupled_source",
307 std::vector<std::vector<MooseFunctorName>>(),
308 "Coupled variable names 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 params.addParam<std::vector<std::vector<Real>>>(
312 "passive_scalar_coupled_source_coeff",
313 std::vector<std::vector<Real>>(),
314 "Coupled variable multipliers for the sources used for the passive scalar fields. If multiple"
315 " sources for each equation are specified, major (outer) ordering by equation.");
316
317 MultiMooseEnum ps_inlet_types("fixed-value flux-mass flux-velocity");
318 params.addParam<MultiMooseEnum>(
319 "passive_scalar_inlet_types",
320 ps_inlet_types,
321 "Types for the inlet boundaries for the passive scalar equation.");
322
323 params.addParamNamesToGroup("passive_scalar_names passive_scalar_diffusivity "
324 "passive_scalar_source passive_scalar_coupled_source "
325 "passive_scalar_coupled_source_coeff",
326 "Passive scalar control");
327 return params;
328}

Referenced by validParams(), and WCNSFVScalarTransportPhysicsBase::validParams().

◆ commonTurbulenceParams()

InputParameters NSFVBase::commonTurbulenceParams ( )
static

Parameter controlling the turbulence handling used for the equations.

Definition at line 331 of file NSFVBase.C.

332{
333 InputParameters params = emptyInputParameters();
334
338 params.addParam<std::vector<BoundaryName>>(
339 "mixing_length_walls",
340 std::vector<BoundaryName>(),
341 "Walls where the mixing length model should be utilized.");
342
343 ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
344 params.addParam<ExecFlagEnum>("mixing_length_aux_execute_on",
345 exec_enum,
346 "When the mixing length aux kernels should be executed.");
347
348 params.addParam<MooseFunctorName>(
349 "von_karman_const", 0.41, "Von Karman parameter for the mixing length model");
350 params.addParam<MooseFunctorName>("von_karman_const_0", 0.09, "'Escudier' model parameter");
351 params.addParam<MooseFunctorName>(
352 "mixing_length_delta",
353 1.0,
354 "Tunable parameter related to the thickness of the boundary layer."
355 "When it is not specified, Prandtl's original unbounded wall distance mixing length model is"
356 "retrieved.");
357 params.addRangeCheckedParam<Real>("turbulent_prandtl",
358 1,
359 "turbulent_prandtl > 0",
360 "Turbulent Prandtl number for energy turbulent diffusion");
361 params.addParam<std::vector<Real>>(
362 "Sc_t", std::vector<Real>(), "Turbulent Schmidt numbers used for the passive scalar fields.");
363 params.addParamNamesToGroup("mixing_length_walls mixing_length_aux_execute_on von_karman_const "
364 "von_karman_const_0 mixing_length_delta",
365 "Mixing length model");
366
367 return params;
368}
MooseUtils::getDefaultExecFlagEnum
ExecFlagEnum getDefaultExecFlagEnum()

Referenced by validParams(), and WCNSFVTurbulencePhysicsBase::validParams().

◆ validParams()

InputParameters NSFVBase::validParams ( )
static

Add params relevant to the objects we may add

General parameters used to set up the simulation.

Parameters influencing the porous medium treatment.

Parameters used to define the handling of the momentum-mass equations.

Parameters describing the momentum equations boundary conditions

Parameters describing the fluid energy equation

Parameters describing the handling of advected scalar fields

Parameters describing the handling of turbulence

Parameters allowing the control over numerical schemes for different terms in the Navier-Stokes + energy equations.

Parameters controlling the ghosting/parallel execution

Definition at line 371 of file NSFVBase.C.

372{
373 InputParameters params = Action::validParams();
374
378 params += INSFVRhieChowInterpolator::uniqueParams();
379 params += INSFVMomentumAdvection::uniqueParams();
380
384 params += NSFVBase::commonNavierStokesFlowParams();
385
386 params.addParam<bool>(
387 "porous_medium_treatment", false, "Whether to use porous medium kernels or not.");
388
389 MooseEnum turbulence_type("mixing-length none", "none");
390 params.addParam<MooseEnum>(
391 "turbulence_handling",
392 turbulence_type,
393 "The way additional diffusivities are determined in the turbulent regime.");
394
395 params.addParam<bool>("initialize_variables_from_mesh_file",
396 false,
397 "Determines if the variables that are added by the action are initialized "
398 "from the mesh file (only for Exodus format)");
399 params.addParam<std::string>(
400 "initial_from_file_timestep",
401 "LATEST",
402 "Gives the timestep (or \"LATEST\") for which to read a solution from a file "
403 "for a given variable. (Default: LATEST)");
404
405 params.addParam<bool>("add_flow_equations", true, "True to add mass and momentum equations");
406 params.addParam<bool>("add_energy_equation", false, "True to add energy equation");
407 params.addParam<bool>("add_scalar_equation", false, "True to add advected scalar(s) equation");
408
409 params.addParamNamesToGroup("compressibility porous_medium_treatment turbulence_handling "
410 "add_flow_equations add_energy_equation add_scalar_equation ",
411 "General control");
412
413 params.addParamNamesToGroup("velocity_variable pressure_variable fluid_temperature_variable",
414 "External variable");
415
420 params.addParam<MooseFunctorName>(
421 "porosity", NS::porosity, "The name of the auxiliary variable for the porosity field.");
422
423 params.addParam<unsigned short>(
424 "porosity_smoothing_layers",
425 "The number of interpolation-reconstruction operations to perform on the porosity.");
426
427 MooseEnum porosity_interface_pressure_treatment("automatic bernoulli", "automatic");
428 params.addParam<MooseEnum>("porosity_interface_pressure_treatment",
429 porosity_interface_pressure_treatment,
430 "How to treat pressure at a porosity interface");
431 params.addParam<std::vector<BoundaryName>>(
432 "pressure_drop_sidesets", {}, "Sidesets over which form loss coefficients are to be applied");
433 params.addParam<std::vector<Real>>(
434 "pressure_drop_form_factors",
435 {},
436 "User-supplied form loss coefficients to be applied over the sidesets listed above");
437
438 params.addParam<bool>("use_friction_correction",
439 false,
440 "If friction correction should be applied in the momentum equation.");
441
442 params.addParam<Real>(
443 "consistent_scaling",
444 "Scaling parameter for the friction correction in the momentum equation (if requested).");
445
446 params.addParamNamesToGroup("porosity porosity_smoothing_layers use_friction_correction "
447 "consistent_scaling porosity_interface_pressure_treatment "
448 "pressure_drop_sidesets pressure_drop_form_factors",
449 "Porous medium treatment");
450
454 std::vector<FunctionName> default_initial_velocity = {"1e-15", "1e-15", "1e-15"};
455 params.addParam<std::vector<FunctionName>>("initial_velocity",
456 default_initial_velocity,
457 "The initial velocity, assumed constant everywhere");
458
459 params.addParam<FunctionName>(
460 "initial_pressure", "1e5", "The initial pressure, assumed constant everywhere");
461
462 params += NSFVBase::commonMomentumEquationParams();
463
467 params += NSFVBase::commonMomentumBoundaryTypesParams();
468 params += NSFVBase::commonMomentumBoundaryFluxesParams();
469
473 params += NSFVBase::commonFluidEnergyEquationParams();
474
478 params += NSFVBase::commonScalarFieldAdvectionParams();
479
483 params += NSFVBase::commonTurbulenceParams();
484
490 MooseEnum adv_interpol_types(Moose::FV::interpolationMethods());
491 params.addParam<MooseEnum>("mass_advection_interpolation",
492 adv_interpol_types,
493 "The numerical scheme to use for interpolating density, "
494 "as an advected quantity, to the face.");
495 params.addParam<MooseEnum>("momentum_advection_interpolation",
496 adv_interpol_types,
497 "The numerical scheme to use for interpolating momentum/velocity, "
498 "as an advected quantity, to the face.");
499 params.addParam<MooseEnum>("energy_advection_interpolation",
500 adv_interpol_types,
501 "The numerical scheme to use for interpolating energy/temperature, "
502 "as an advected quantity, to the face.");
503 params.addParam<MooseEnum>("passive_scalar_advection_interpolation",
504 adv_interpol_types,
505 "The numerical scheme to use for interpolating passive scalar field, "
506 "as an advected quantity, to the face.");
507
508 MooseEnum face_interpol_types("average skewness-corrected", "average");
509 params.addParam<MooseEnum>("pressure_face_interpolation",
510 face_interpol_types,
511 "The numerical scheme to interpolate the pressure to the "
512 "face (separate from the advected quantity interpolation).");
513 params.addParam<MooseEnum>("momentum_face_interpolation",
514 face_interpol_types,
515 "The numerical scheme to interpolate the velocity/momentum to the "
516 "face (separate from the advected quantity interpolation).");
517 params.addParam<MooseEnum>("energy_face_interpolation",
518 face_interpol_types,
519 "The numerical scheme to interpolate the temperature/energy to the "
520 "face (separate from the advected quantity interpolation).");
521 params.addParam<MooseEnum>(
522 "passive_scalar_face_interpolation",
523 face_interpol_types,
524 "The numerical scheme to interpolate the passive scalar field variables to the "
525 "face (separate from the advected quantity interpolation).");
526
527 MooseEnum velocity_interpolation("average rc", "rc");
528 params.addParam<MooseEnum>(
529 "velocity_interpolation",
530 velocity_interpolation,
531 "The interpolation to use for the velocity. Options are "
532 "'average' and 'rc' which stands for Rhie-Chow. The default is Rhie-Chow.");
533
534 params.addParam<bool>(
535 "pressure_two_term_bc_expansion",
536 true,
537 "If a two-term Taylor expansion is needed for the determination of the boundary values"
538 "of the pressure.");
539 params.addParam<bool>(
540 "pressure_allow_expansion_on_bernoulli_faces",
541 false,
542 "Switch to enable the two-term extrapolation on porosity jump faces. "
543 "WARNING: Depending on the mesh, enabling this parameter may lead to "
544 "termination in parallel runs due to insufficient ghosting between "
545 "processors. An example can be the presence of multiple porosity jumps separated by only "
546 "one cell while using the Bernoulli pressure treatment. In such cases adjust the "
547 "`ghost_layers` parameter. ");
548 params.addParam<bool>(
549 "momentum_two_term_bc_expansion",
550 true,
551 "If a two-term Taylor expansion is needed for the determination of the boundary values"
552 "of the velocity/momentum.");
553 params.addParam<bool>(
554 "energy_two_term_bc_expansion",
555 true,
556 "If a two-term Taylor expansion is needed for the determination of the boundary values"
557 "of the temperature/energy.");
558 params.addParam<bool>(
559 "passive_scalar_two_term_bc_expansion",
560 true,
561 "If a two-term Taylor expansion is needed for the determination of the boundary values"
562 "of the advected passive scalar field.");
563 params.addParam<bool>(
564 "mixing_length_two_term_bc_expansion",
565 true,
566 "If a two-term Taylor expansion is needed for the determination of the boundary values"
567 "of the mixing length field.");
568
569 params.addRangeCheckedParam<Real>(
570 "mass_scaling",
571 1.0,
572 "mass_scaling > 0.0",
573 "The scaling factor for the mass variables (for incompressible simulation "
574 "this is pressure scaling).");
575 params.addRangeCheckedParam<Real>("momentum_scaling",
576 1.0,
577 "momentum_scaling > 0.0",
578 "The scaling factor for the momentum variables.");
579 params.addRangeCheckedParam<Real>(
580 "energy_scaling", 1.0, "energy_scaling > 0.0", "The scaling factor for the energy variable.");
581 params.addRangeCheckedParam<Real>("passive_scalar_scaling",
582 1.0,
583 "passive_scalar_scaling > 0.0",
584 "The scaling factor for the passive scalar field variables.");
585
586 params.addParamNamesToGroup(
587 "momentum_advection_interpolation energy_advection_interpolation "
588 "passive_scalar_advection_interpolation mass_advection_interpolation "
589 "momentum_face_interpolation energy_face_interpolation passive_scalar_face_interpolation "
590 "pressure_face_interpolation momentum_two_term_bc_expansion "
591 "energy_two_term_bc_expansion passive_scalar_two_term_bc_expansion "
592 "mixing_length_two_term_bc_expansion pressure_two_term_bc_expansion "
593 "pressure_allow_expansion_on_bernoulli_faces velocity_interpolation",
594 "Numerical scheme");
595
596 params.addParamNamesToGroup("momentum_scaling energy_scaling mass_scaling passive_scalar_scaling",
597 "Scaling");
598
602 params.addRangeCheckedParam<unsigned short>(
603 "ghost_layers",
604 2,
605 "ghost_layers > 0",
606 "The number of geometric/algebraic/coupling layers to ghost.");
607
608 params.addParamNamesToGroup("ghost_layers", "Parallel Execution Tuning");
609
610 // Create input parameter groups
611 params.addParamNamesToGroup("dynamic_viscosity density thermal_expansion "
612 "thermal_conductivity_blocks thermal_conductivity specific_heat",
613 "Material property");
614
615 params.addParamNamesToGroup(
616 "inlet_boundaries momentum_inlet_types momentum_inlet_functors energy_inlet_types "
617 "energy_inlet_functors wall_boundaries momentum_wall_types energy_wall_boundaries "
618 "energy_wall_types energy_wall_functors outlet_boundaries momentum_outlet_types "
619 "pressure_functors passive_scalar_inlet_types flux_inlet_pps flux_inlet_directions",
620 "Boundary condition");
621
622 params.addParamNamesToGroup(
623 "initial_pressure initial_velocity initial_temperature initial_scalar_variables "
624 "initialize_variables_from_mesh_file initial_from_file_timestep",
625 "Initial condition");
626
627 return params;
628}
Action::validParams
static InputParameters validParams()
INSFVMomentumAdvection::uniqueParams
static InputParameters uniqueParams()
Parameters of this object that should be added to the NSFV action that are unique to this object.
Definition INSFVMomentumAdvection.C:20
INSFVRhieChowInterpolator::uniqueParams
static InputParameters uniqueParams()
Parameters of this object that should be added to the NSFV action that are unique to this object.
Definition INSFVRhieChowInterpolator.C:45
NSFVBase::commonTurbulenceParams
static InputParameters commonTurbulenceParams()
Definition NSFVBase.C:331
NSFVBase::commonScalarFieldAdvectionParams
static InputParameters commonScalarFieldAdvectionParams()
Definition NSFVBase.C:284
NSFVBase::commonFluidEnergyEquationParams
static InputParameters commonFluidEnergyEquationParams()
Definition NSFVBase.C:197
NSFVBase::commonMomentumEquationParams
static InputParameters commonMomentumEquationParams()
Definition NSFVBase.C:55
NSFVBase::commonMomentumBoundaryTypesParams
static InputParameters commonMomentumBoundaryTypesParams()
Definition NSFVBase.C:144
NSFVBase::commonMomentumBoundaryFluxesParams
static InputParameters commonMomentumBoundaryFluxesParams()
Definition NSFVBase.C:168
NSFVBase::commonNavierStokesFlowParams
static InputParameters commonNavierStokesFlowParams()
Definition NSFVBase.C:17
Moose::FV::interpolationMethods
MooseEnum interpolationMethods()
NS::porosity
static const std::string porosity
Definition NS.h:108

Referenced by PNSFVSolidHeatTransferPhysics::validParams(), WCNSFVFlowPhysics::validParams(), WCNSFVFlowPhysicsBase::validParams(), WCNSFVFluidHeatTransferPhysics::validParams(), WCNSFVFluidHeatTransferPhysicsBase::validParams(), WCNSFVScalarTransportPhysics::validParams(), WCNSFVScalarTransportPhysicsBase::validParams(), and WCNSFVTurbulencePhysics::validParams().

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:43:23 for https://mooseframework.inl.gov by doxygen 1.9.8