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 params.addParam<std::vector<std::vector<std::vector<SubdomainName>>>>(
318 "passive_scalar_coupled_source_blocks",
319 {},
320 "Block restrictions of the sources used for the passive scalar fields. If multiple"
321 " sources for each equation are specified, major (outer) ordering by equation. Innermost "
322 "ordering is subdomains (for each equation and term)");
323
324 MultiMooseEnum ps_inlet_types("fixed-value flux-mass flux-velocity");
325 params.addParam<MultiMooseEnum>(
326 "passive_scalar_inlet_types",
327 ps_inlet_types,
328 "Types for the inlet boundaries for the passive scalar equation.");
329
330 params.addParamNamesToGroup("passive_scalar_names passive_scalar_diffusivity "
331 "passive_scalar_source passive_scalar_coupled_source "
332 "passive_scalar_coupled_source_coeff",
333 "Passive scalar control");
334 return params;
335}

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

◆ commonTurbulenceParams()

InputParameters NSFVBase::commonTurbulenceParams ( )
static

Parameter controlling the turbulence handling used for the equations.

Definition at line 338 of file NSFVBase.C.

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

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