https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected 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
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParameters & parameters () const
 
MooseObjectName uniqueName () 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 &nm) const
 
void paramError (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
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) 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 ()
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

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
 

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
 
const std::string _type
 
const std::string _name
 
const InputParameters & _pars
 
Factory & _factory
 
ActionFactory & _action_factory
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

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 191 of file NSFVBase.C.

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

192 {
193  InputParameters params = emptyInputParameters();
194  params.addParam<FunctionName>(
195  "initial_temperature", "300", "The initial temperature, assumed constant everywhere");
196 
197  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  params.addParam<std::vector<MooseFunctorName>>(
203  "thermal_conductivity",
204  std::vector<MooseFunctorName>({NS::k}),
205  "The name of the fluid thermal conductivity for each block");
206 
207  params.addParam<MooseFunctorName>("specific_heat", NS::cp, "The name of the specific heat");
208 
209  MultiMooseEnum en_inlet_types("fixed-temperature flux-mass flux-velocity heatflux");
210  params.addParam<MultiMooseEnum>("energy_inlet_types",
211  en_inlet_types,
212  "Types for the inlet boundaries for the energy equation.");
213 
214  params.addParam<std::vector<MooseFunctorName>>(
215  "energy_inlet_function",
216  std::vector<MooseFunctorName>(),
217  "Functions for fixed-value boundaries in the energy equation.");
218 
219  MultiMooseEnum en_wall_types("fixed-temperature heatflux wallfunction convection");
220  en_wall_types.addDocumentation("fixed-temperature",
221  "Set a constant fluid temperature on the wall");
222  en_wall_types.addDocumentation("heatflux", "Set a constant heat flux on the wall");
223  en_wall_types.addDocumentation(
224  "wallfunction",
225  "Use a wall function, defined by the turbulence Physics, to compute the wall heat flux");
226  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  params.addParam<MultiMooseEnum>(
230  "energy_wall_types", en_wall_types, "Types for the wall boundaries for the energy equation.");
231  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  params.addParam<std::vector<MooseFunctorName>>(
238  "energy_wall_function",
239  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  params.addParam<std::vector<std::vector<SubdomainName>>>(
245  "ambient_convection_blocks",
246  std::vector<std::vector<SubdomainName>>(),
247  "The blocks where the ambient convection is present.");
248 
249  params.addParam<std::vector<MooseFunctorName>>(
250  "ambient_convection_alpha",
251  std::vector<MooseFunctorName>(),
252  "The heat exchange coefficients for each block in 'ambient_convection_blocks'.");
253 
254  params.addParam<std::vector<MooseFunctorName>>(
255  "ambient_temperature",
256  std::vector<MooseFunctorName>(),
257  "The ambient temperature for each block in 'ambient_convection_blocks'.");
258 
259  params.addParam<MooseFunctorName>(
260  "external_heat_source",
261  "The name of a functor which contains the external heat source for the energy equation.");
262  params.addParam<Real>(
263  "external_heat_source_coeff", 1.0, "Multiplier for the coupled heat source term.");
264  params.addParam<bool>("use_external_enthalpy_material",
265  false,
266  "To indicate if the enthalpy material is set up outside of the action.");
267 
268  params.addParamNamesToGroup("ambient_convection_alpha ambient_convection_blocks "
269  "ambient_temperature",
270  "Volumetric heat convection");
271  params.addParamNamesToGroup("external_heat_source external_heat_source_coeff", "Heat source");
272  params.addParamNamesToGroup("use_external_enthalpy_material", "Material properties");
273 
274  return params;
275 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()
NS::cp
static const std::string cp
Definition: NS.h:121
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
NS::k
static const std::string k
Definition: NS.h:130

◆ commonMomentumBoundaryFluxesParams()

InputParameters NSFVBase::commonMomentumBoundaryFluxesParams ( )
static

Definition at line 162 of file NSFVBase.C.

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

163 {
164  InputParameters params = emptyInputParameters();
165  params.addParam<std::vector<std::vector<MooseFunctorName>>>(
166  "momentum_inlet_function",
167  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  params.addParam<std::vector<PostprocessorName>>(
173  "flux_inlet_pps",
174  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  params.addParam<std::vector<Point>>(
178  "flux_inlet_directions",
179  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  params.addParamNamesToGroup("flux_inlet_pps flux_inlet_directions", "Boundary condition");
186 
187  return params;
188 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()

◆ commonMomentumBoundaryTypesParams()

InputParameters NSFVBase::commonMomentumBoundaryTypesParams ( )
static

Definition at line 138 of file NSFVBase.C.

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

139 {
140  InputParameters params = emptyInputParameters();
141  MultiMooseEnum mom_inlet_types("fixed-velocity flux-velocity flux-mass fixed-pressure");
142  params.addParam<MultiMooseEnum>("momentum_inlet_types",
143  mom_inlet_types,
144  "Types of inlet boundaries for the momentum equation.");
145 
146  MultiMooseEnum mom_outlet_types("fixed-pressure zero-gradient fixed-pressure-zero-gradient");
147  params.addParam<MultiMooseEnum>("momentum_outlet_types",
148  mom_outlet_types,
149  "Types of outlet boundaries for the momentum equation");
150  params.addParam<std::vector<MooseFunctorName>>("pressure_function",
151  std::vector<MooseFunctorName>(),
152  "Functions for boundary pressures at outlets.");
153 
154  MultiMooseEnum mom_wall_types("symmetry noslip slip wallfunction");
155  params.addParam<MultiMooseEnum>(
156  "momentum_wall_types", mom_wall_types, "Types of wall boundaries for the momentum equation");
157 
158  return params;
159 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()

◆ commonMomentumEquationParams()

InputParameters NSFVBase::commonMomentumEquationParams ( )
static

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

Definition at line 55 of file NSFVBase.C.

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

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 
69  // Pressure pin parameters
70  params.addParam<bool>(
71  "pin_pressure", false, "Switch to enable pressure shifting for incompressible simulations.");
72  MooseEnum s_type("average point-value average-uo point-value-uo", "average-uo");
73  params.addParam<MooseEnum>(
74  "pinned_pressure_type",
75  s_type,
76  "Types for shifting (pinning) the pressure in case of incompressible simulations.");
77  params.addParam<Point>(
78  "pinned_pressure_point",
79  Point(),
80  "The XYZ coordinates where pressure needs to be pinned for incompressible simulations.");
81  params.addParam<PostprocessorName>(
82  "pinned_pressure_value",
83  "1e5",
84  "The value used for pinning the pressure (point value/domain average).");
85 
86  params.addParam<bool>("boussinesq_approximation", false, "True to have Boussinesq approximation");
87 
88  params.addParam<RealVectorValue>(
89  "gravity", RealVectorValue(0, 0, 0), "The gravitational acceleration vector.");
90 
91  params.addRangeCheckedParam<Real>(
92  "ref_temperature",
93  273.15,
94  "ref_temperature > 0.0",
95  "Value for reference temperature in case of Boussinesq approximation");
96  params.addParam<MooseFunctorName>(
97  "thermal_expansion",
98  NS::alpha,
99  "The name of the thermal expansion coefficient in the Boussinesq approximation");
100 
101  params.addParamNamesToGroup(
102  "pin_pressure pinned_pressure_type pinned_pressure_point pinned_pressure_value ",
103  "Incompressible flow pressure constraint");
104  params.addParamNamesToGroup("ref_temperature boussinesq_approximation gravity",
105  "Gravity treatment");
106 
110  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  params.addParam<std::vector<std::vector<std::string>>>(
116  "friction_types", {}, "The types of friction forces for every block in 'friction_blocks'.");
117 
118  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  params.addParam<bool>(
126  "standard_friction_formulation",
127  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  params.addParamNamesToGroup("friction_blocks friction_types friction_coeffs "
132  "standard_friction_formulation",
133  "Friction control");
134  return params;
135 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
NS::density
static const std::string density
Definition: NS.h:33
emptyInputParameters
InputParameters emptyInputParameters()
NS::mu
static const std::string mu
Definition: NS.h:123
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
NS::alpha
static const std::string alpha
Definition: NS.h:134
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

◆ commonNavierStokesFlowParams()

InputParameters NSFVBase::commonNavierStokesFlowParams ( )
static

Parameters used to define the boundaries of the domain.

Definition at line 17 of file NSFVBase.C.

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

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 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()

◆ commonScalarFieldAdvectionParams()

InputParameters NSFVBase::commonScalarFieldAdvectionParams ( )
static

Definition at line 278 of file NSFVBase.C.

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

279 {
280  InputParameters params = emptyInputParameters();
281  params.addParam<std::vector<NonlinearVariableName>>(
282  "passive_scalar_names",
283  std::vector<NonlinearVariableName>(),
284  "Vector containing the names of the advected scalar variables.");
285 
286  params.addParam<std::vector<FunctionName>>("initial_scalar_variables",
287  "Initial values of the passive scalar variables.");
288 
289  params.addParam<std::vector<MooseFunctorName>>(
290  "passive_scalar_diffusivity",
291  std::vector<MooseFunctorName>(),
292  "Functor names for the diffusivities used for the passive scalar fields.");
293 
294  params.addParam<std::vector<MooseFunctorName>>(
295  "passive_scalar_source",
296  std::vector<MooseFunctorName>(),
297  "Functor names for the sources used for the passive scalar fields.");
298 
299  params.addParam<std::vector<std::vector<MooseFunctorName>>>(
300  "passive_scalar_coupled_source",
301  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  params.addParam<std::vector<std::vector<Real>>>(
306  "passive_scalar_coupled_source_coeff",
307  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  MultiMooseEnum ps_inlet_types("fixed-value flux-mass flux-velocity");
312  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  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  return params;
322 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()

◆ commonTurbulenceParams()

InputParameters NSFVBase::commonTurbulenceParams ( )
static

Parameter controlling the turbulence handling used for the equations.

Definition at line 325 of file NSFVBase.C.

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

326 {
327  InputParameters params = emptyInputParameters();
328 
332  params.addParam<std::vector<BoundaryName>>(
333  "mixing_length_walls",
334  std::vector<BoundaryName>(),
335  "Walls where the mixing length model should be utilized.");
336 
337  ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
338  params.addParam<ExecFlagEnum>("mixing_length_aux_execute_on",
339  exec_enum,
340  "When the mixing length aux kernels should be executed.");
341 
342  params.addParam<MooseFunctorName>(
343  "von_karman_const", 0.41, "Von Karman parameter for the mixing length model");
344  params.addParam<MooseFunctorName>("von_karman_const_0", 0.09, "'Escudier' model parameter");
345  params.addParam<MooseFunctorName>(
346  "mixing_length_delta",
347  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  params.addRangeCheckedParam<Real>("turbulent_prandtl",
352  1,
353  "turbulent_prandtl > 0",
354  "Turbulent Prandtl number for energy turbulent diffusion");
355  params.addParam<std::vector<Real>>(
356  "passive_scalar_schmidt_number",
357  std::vector<Real>(),
358  "Turbulent Schmidt numbers used for the passive scalar fields.");
359  params.deprecateParam("passive_scalar_schmidt_number", "Sc_t", "01/01/2025");
360  params.addParamNamesToGroup("mixing_length_walls mixing_length_aux_execute_on von_karman_const "
361  "von_karman_const_0 mixing_length_delta",
362  "Mixing length model");
363 
364  return params;
365 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()
MooseUtils::getDefaultExecFlagEnum
ExecFlagEnum getDefaultExecFlagEnum()
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ 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 368 of file NSFVBase.C.

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

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