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 | Private Member Functions | List of all members
WCNSFVFluidHeatTransferPhysics Class Referencefinal

Creates all the objects needed to solve the Navier Stokes energy equation. More...

#include <WCNSFVFluidHeatTransferPhysics.h>

Inheritance diagram for WCNSFVFluidHeatTransferPhysics:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 WCNSFVFluidHeatTransferPhysics (const InputParameters &parameters)
 
const VariableName & getFluidTemperatureName () const
 Get the name of the fluid temperature variable. More...
 
const MooseFunctorName & getSpecificHeatName () const
 Get the name of the specific heat material property. More...
 
MooseFunctorName getSpecificEnthalpyName () const
 
const std::vector< MooseFunctorName > & getThermalConductivityName () const
 
const std::vector< std::vector< SubdomainName > > & getAmbientConvectionBlocks () const
 Get the ambient convection parameters for parameter checking. More...
 
const std::vector< MooseFunctorName > & getAmbientConvectionHTCs () const
 Name of the ambient convection heat transfer coefficients for each block-group. More...
 
bool hasEnergyEquation () const
 Whether the physics is actually creating the heat equation. More...
 
virtual void act () override final
 
void addBlocks (const std::vector< SubdomainName > &blocks)
 
void addBlocksById (const std::vector< SubdomainID > &block_ids)
 
const std::vector< SubdomainName > & blocks () const
 
bool checkBlockRestrictionIdentical (const std::string &object_name, const std::vector< SubdomainName > &blocks, const bool error_if_not_identical=true) const
 
const T * getCoupledPhysics (const PhysicsName &phys_name, const bool allow_fail=false) const
 
const std::vector< T *> getCoupledPhysics (const bool allow_fail=false) const
 
unsigned int dimension () const
 
const ActionComponent & getActionComponent (const ComponentName &comp_name) const
 
void checkComponentType (const ActionComponent &component) const
 
virtual void addComponent (const ActionComponent &component)
 
const std::vector< VariableName > & solverVariableNames () const
 
const std::vector< VariableName > & auxVariableNames () const
 
void timedAct ()
 
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 mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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 ()
 
void assertParamDefined (const std::string &libmesh_dbg_var(param)) const
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
const WCNSFVFlowPhysicsBase * getCoupledFlowPhysics () const
 
const WCNSFVTurbulencePhysics * getCoupledTurbulencePhysics () const
 
MooseFunctorName getPorosityFunctorName (bool smoothed) const
 Return the porosity functor name. More...
 
const MooseFunctorName & densityName () const
 
const MooseFunctorName & dynamicViscosityName () const
 

Static Public Member Functions

static InputParameters validParams ()
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
 

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

void actOnAdditionalTasks () override
 
void addInitialConditions () override
 
void addFVKernels () override
 
void addFVBCs () override
 
unsigned short getNumberAlgebraicGhostingLayersNeeded () const override
 Return the number of ghosting layers needed. More...
 
bool processThermalConductivity ()
 Process thermal conductivity (multiple functor input options are available). More...
 
void defineKOverCpFunctors (const bool use_ad)
 Define the k/cp diffusion coefficients when solving for enthalpy. More...
 
bool usingNavierStokesFVSyntax () const
 Detects if we are using the new Physics syntax or the old NavierStokesFV action. More...
 
InputParameters getAdditionalRMParams () const override
 Parameters to change or add relationship managers. More...
 
void assertParamDefined (const std::string &param) const
 
bool isTransient () const
 
Factory & getFactory ()
 
Factory & getFactory () const
 
virtual FEProblemBase & getProblem ()
 
virtual const FEProblemBase & getProblem () const
 
void prepareCopyVariablesFromMesh () const
 
void copyVariablesFromMesh (const std::vector< VariableName > &variables_to_copy, bool are_nonlinear=true)
 
std::string prefix () const
 
void saveSolverVariableName (const VariableName &var_name)
 
void saveAuxVariableName (const VariableName &var_name)
 
bool variableExists (const VariableName &var_name, bool error_if_aux) const
 
bool solverVariableExists (const VariableName &var_name) const
 
const SolverSystemName & getSolverSystem (unsigned int variable_index) const
 
const SolverSystemName & getSolverSystem (const VariableName &variable_name) const
 
void addRequiredPhysicsTask (const std::string &task)
 
void assignBlocks (InputParameters &params, const std::vector< SubdomainName > &blocks) const
 
bool allMeshBlocks (const std::vector< SubdomainName > &blocks) const
 
bool allMeshBlocks (const std::set< SubdomainName > &blocks) const
 
std::set< SubdomainID > getSubdomainIDs (const std::set< SubdomainName > &blocks) const
 
std::vector< std::string > getSubdomainNamesAndIDs (const std::set< SubdomainID > &blocks) const
 
void addPetscPairsToPetscOptions (const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options)
 
bool isVariableFV (const VariableName &var_name) const
 
bool isVariableScalar (const VariableName &var_name) const
 
bool shouldCreateVariable (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_aux)
 
bool shouldCreateIC (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool ic_is_default_ic, const bool error_if_already_defined) const
 
bool shouldCreateTimeDerivative (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_already_defined) const
 
void reportPotentiallyMissedParameters (const std::vector< std::string > &param_names, const std::string &object_type) const
 
bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
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
 
void checkParamsBothSetOrNotSet (const std::string &param1, const std::string &param2) const
 
void checkSecondParamSetOnlyIfFirstOneTrue (const std::string &param1, const std::string &param2) const
 
void checkSecondParamSetOnlyIfFirstOneSet (const std::string &param1, const std::string &param2) const
 
void checkSecondParamNotSetIfFirstOneSet (const std::string &param1, const std::string &param2) const
 
void checkVectorParamsSameLength (const std::string &param1, const std::string &param2) const
 
void checkVectorParamAndMultiMooseEnumLength (const std::string &param1, const std::string &param2) const
 
void checkTwoDVectorParamsSameLength (const std::string &param1, const std::string &param2) const
 
void checkVectorParamsNoOverlap (const std::vector< std::string > &param_vecs) const
 
void checkTwoDVectorParamsNoRespectiveOverlap (const std::vector< std::string > &param_vecs) const
 
void checkTwoDVectorParamInnerSameLengthAsOneDVector (const std::string &param1, const std::string &param2) const
 
void checkTwoDVectorParamMultiMooseEnumSameLength (const std::string &param1, const std::string &param2, const bool error_for_param2) const
 
void checkVectorParamNotEmpty (const std::string &param1) const
 
void checkVectorParamsSameLengthIfSet (const std::string &param1, const std::string &param2, const bool ignore_empty_default_param2=false) const
 
void checkVectorParamLengthSameAsCombinedOthers (const std::string &param1, const std::string &param2, const std::string &param3) const
 
void checkBlockwiseConsistency (const std::string &block_param_name, const std::vector< std::string > &parameter_names) const
 
bool parameterConsistent (const InputParameters &other_param, const std::string &param_name) const
 
void warnInconsistent (const InputParameters &parameters, const std::string &param_name) const
 
void errorDependentParameter (const std::string &param1, const std::string &value_not_set, const std::vector< std::string > &dependent_params) const
 
void errorInconsistentDependentParameter (const std::string &param1, const std::string &value_set, const std::vector< std::string > &dependent_params) const
 

Static Protected Member Functions

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

Protected Attributes

const bool _has_energy_equation
 A boolean to help compatibility with the old Modules/NavierStokesFV syntax. More...
 
const bool _solve_for_enthalpy
 User-selected option to solve for enthalpy. More...
 
const VariableName _fluid_enthalpy_name
 Name of the fluid specific enthalpy. More...
 
VariableName _fluid_temperature_name
 Fluid temperature name. More...
 
MooseFunctorName _specific_heat_name
 Name of the specific heat material property. More...
 
std::vector< std::vector< SubdomainName > > _thermal_conductivity_blocks
 Vector of subdomain groups where we want to have different thermal conduction. More...
 
std::vector< MooseFunctorName > _thermal_conductivity_name
 Name of the thermal conductivity functor for each block-group. More...
 
std::vector< std::vector< SubdomainName > > _ambient_convection_blocks
 Vector of subdomain groups where we want to have different ambient convection. More...
 
std::vector< MooseFunctorName > _ambient_convection_alpha
 Name of the ambient convection heat transfer coefficients for each block-group. More...
 
std::vector< MooseFunctorName > _ambient_temperature
 Name of the solid domain temperature for each block-group. More...
 
MultiMooseEnum _energy_inlet_types
 Energy inlet boundary types. More...
 
std::vector< MooseFunctorName > _energy_inlet_functors
 Functors describing the inlet boundary values. See energy_inlet_types for what the functors actually represent. More...
 
MultiMooseEnum _energy_wall_types
 Energy wall boundary types. More...
 
std::vector< MooseFunctorName > _energy_wall_functors
 Functors describing the wall boundary values. See energy_wall_types for what the functors actually represent. More...
 
bool _define_variables
 Whether to define variables if they do not exist. More...
 
std::vector< SolverSystemName > _system_names
 
std::vector< unsigned int > _system_numbers
 
const bool _verbose
 
const MooseEnum & _preconditioning
 
std::vector< SubdomainName > _blocks
 
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
 
const NavierStokesPhysicsBase * _advection_physics
 The Physics class using this helper. More...
 
const WCNSFVFlowPhysicsBase * _flow_equations_physics
 Flow physics. More...
 
const WCNSFVTurbulencePhysics * _turbulence_physics
 Turbulence. More...
 
const MooseEnum _compressibility
 Compressibility type, can be compressible, incompressible or weakly-compressible. More...
 
const bool _porous_medium_treatment
 Switch to show if porous medium treatment is requested or not. More...
 
const std::vector< std::string > _velocity_names
 Velocity names. More...
 
const NonlinearVariableName _pressure_name
 Pressure name. More...
 
const MooseFunctorName _density_name
 Name of the density material property. More...
 
const MooseFunctorName _dynamic_viscosity_name
 Name of the dynamic viscosity material property. More...
 
const MooseEnum _velocity_interpolation
 The velocity / momentum face interpolation method for advecting other quantities. More...
 

Private Member Functions

virtual void addSolverVariables () override
 
virtual void addMaterials () override
 
void addEnergyTimeKernels () override
 Functions adding kernels for the incompressible / weakly compressible energy equation If the material properties are not constant, some of these can be used for weakly-compressible simulations as well. More...
 
void addEnergyHeatConductionKernels () override
 
void addEnergyAdvectionKernels () override
 
void addEnergyAmbientConvection () override
 
void addEnergyExternalHeatSource () override
 
void addEnergyInletBC () override
 Functions adding boundary conditions for the incompressible simulation. More...
 
void addEnergyWallBC () override
 
void addEnergyOutletBC () override
 
void addEnergySeparatorBC () override
 

Detailed Description

Creates all the objects needed to solve the Navier Stokes energy equation.

Definition at line 18 of file WCNSFVFluidHeatTransferPhysics.h.

Constructor & Destructor Documentation

◆ WCNSFVFluidHeatTransferPhysics()

WCNSFVFluidHeatTransferPhysics::WCNSFVFluidHeatTransferPhysics ( const InputParameters &  parameters)

Definition at line 35 of file WCNSFVFluidHeatTransferPhysics.C.

36  : WCNSFVFluidHeatTransferPhysicsBase(parameters)
37 {
38  checkSecondParamNotSetIfFirstOneSet("solve_for_enthalpy", "fluid_temperature_variable");
39 }
PhysicsBase::parameters
const InputParameters & parameters() const
WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase
WCNSFVFluidHeatTransferPhysicsBase(const InputParameters &parameters)
Definition: WCNSFVFluidHeatTransferPhysicsBase.C:63
PhysicsBase::checkSecondParamNotSetIfFirstOneSet
void checkSecondParamNotSetIfFirstOneSet(const std::string &param1, const std::string &param2) const

Member Function Documentation

◆ actOnAdditionalTasks()

void WCNSFVFluidHeatTransferPhysicsBase::actOnAdditionalTasks ( )
overrideprotectedvirtualinherited

Reimplemented from PhysicsBase.

Definition at line 158 of file WCNSFVFluidHeatTransferPhysicsBase.C.

159 {
160  // Turbulence physics would not be initialized before this task
161  if (_current_task == "get_turbulence_physics")
162  _turbulence_physics = getCoupledTurbulencePhysics();
163 }
WCNSFVCoupledAdvectionPhysicsHelper::_turbulence_physics
const WCNSFVTurbulencePhysics * _turbulence_physics
Turbulence.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:45
PhysicsBase::_current_task
const std::string & _current_task
WCNSFVCoupledAdvectionPhysicsHelper::getCoupledTurbulencePhysics
const WCNSFVTurbulencePhysics * getCoupledTurbulencePhysics() const
Definition: WCNSFVCoupledAdvectionPhysicsHelper.C:77

◆ addEnergyAdvectionKernels()

void WCNSFVFluidHeatTransferPhysics::addEnergyAdvectionKernels ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 123 of file WCNSFVFluidHeatTransferPhysics.C.

124 {
125  std::string kernel_type = "INSFVEnergyAdvection";
126  std::string kernel_name = prefix() + "ins_energy_advection";
127  if (_porous_medium_treatment)
128  {
129  kernel_type = "PINSFVEnergyAdvection";
130  kernel_name = prefix() + "pins_energy_advection";
131  }
132 
133  const auto & solver_variable_name =
134  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
135 
136  InputParameters params = getFactory().getValidParams(kernel_type);
137  params.set<NonlinearVariableName>("variable") = solver_variable_name;
138  assignBlocks(params, _blocks);
139  params.set<MooseEnum>("velocity_interp_method") = _velocity_interpolation;
140  params.set<UserObjectName>("rhie_chow_user_object") = _flow_equations_physics->rhieChowUOName();
141  params.set<MooseEnum>("advected_interp_method") =
142  getParam<MooseEnum>("energy_advection_interpolation");
143 
144  getProblem().addFVKernel(kernel_type, kernel_name, params);
145 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
WCNSFVFlowPhysicsBase::rhieChowUOName
virtual UserObjectName rhieChowUOName() const =0
Return the name of the Rhie Chow user object.
WCNSFVCoupledAdvectionPhysicsHelper::_porous_medium_treatment
const bool _porous_medium_treatment
Switch to show if porous medium treatment is requested or not.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:51
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
WCNSFVCoupledAdvectionPhysicsHelper::_velocity_interpolation
const MooseEnum _velocity_interpolation
The velocity / momentum face interpolation method for advecting other quantities. ...
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:64

◆ addEnergyAmbientConvection()

void WCNSFVFluidHeatTransferPhysics::addEnergyAmbientConvection ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 206 of file WCNSFVFluidHeatTransferPhysics.C.

207 {
208  unsigned int num_convection_blocks = _ambient_convection_blocks.size();
209  unsigned int num_used_blocks = num_convection_blocks ? num_convection_blocks : 1;
210  const auto & solver_variable_name =
211  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
212 
213  const std::string kernel_type = "PINSFVEnergyAmbientConvection";
214  InputParameters params = getFactory().getValidParams(kernel_type);
215  params.set<NonlinearVariableName>("variable") = solver_variable_name;
216  params.set<MooseFunctorName>(NS::T_fluid) = _fluid_temperature_name;
217  params.set<bool>("is_solid") = false;
218 
219  for (unsigned int block_i = 0; block_i < num_used_blocks; ++block_i)
220  {
221  std::string block_name = "";
222  if (num_convection_blocks)
223  {
224  params.set<std::vector<SubdomainName>>("block") = _ambient_convection_blocks[block_i];
225  block_name = Moose::stringify(_ambient_convection_blocks[block_i]);
226  }
227  else
228  {
229  assignBlocks(params, _blocks);
230  block_name = std::to_string(block_i);
231  }
232 
233  params.set<MooseFunctorName>("h_solid_fluid") = _ambient_convection_alpha[block_i];
234  params.set<MooseFunctorName>(NS::T_solid) = _ambient_temperature[block_i];
235 
236  getProblem().addFVKernel(kernel_type, prefix() + "ambient_convection_" + block_name, params);
237  }
238 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
WCNSFVFluidHeatTransferPhysicsBase::_ambient_temperature
std::vector< MooseFunctorName > _ambient_temperature
Name of the solid domain temperature for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:109
NS::T_solid
static const std::string T_solid
Definition: NS.h:107
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_blocks
std::vector< std::vector< SubdomainName > > _ambient_convection_blocks
Vector of subdomain groups where we want to have different ambient convection.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:105
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::T_fluid
static const std::string T_fluid
Definition: NS.h:106
Moose::stringify
std::string stringify(const T &t)
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_alpha
std::vector< MooseFunctorName > _ambient_convection_alpha
Name of the ambient convection heat transfer coefficients for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:107
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)

◆ addEnergyExternalHeatSource()

void WCNSFVFluidHeatTransferPhysics::addEnergyExternalHeatSource ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 241 of file WCNSFVFluidHeatTransferPhysics.C.

242 {
243  const auto & solver_variable_name =
244  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
245  const std::string kernel_type = "FVCoupledForce";
246  InputParameters params = getFactory().getValidParams(kernel_type);
247  params.set<NonlinearVariableName>("variable") = solver_variable_name;
248  assignBlocks(params, _blocks);
249  params.set<MooseFunctorName>("v") = getParam<MooseFunctorName>("external_heat_source");
250  params.set<Real>("coef") = getParam<Real>("external_heat_source_coeff");
251 
252  getProblem().addFVKernel(kernel_type, prefix() + "external_heat_source", params);
253 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)

◆ addEnergyHeatConductionKernels()

void WCNSFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 148 of file WCNSFVFluidHeatTransferPhysics.C.

149 {
150  const auto vector_conductivity = processThermalConductivity();
151  const auto num_blocks = _thermal_conductivity_blocks.size();
152  const auto num_used_blocks = num_blocks ? num_blocks : 1;
153  const auto & solver_variable_name =
154  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
155 
156  for (const auto block_i : make_range(num_used_blocks))
157  {
158  std::string block_name = "";
159  if (num_blocks)
160  block_name = Moose::stringify(_thermal_conductivity_blocks[block_i]);
161  else
162  block_name = "all";
163 
164  if (_porous_medium_treatment)
165  {
166  const auto kernel_type =
167  vector_conductivity ? "PINSFVEnergyAnisotropicDiffusion" : "PINSFVEnergyDiffusion";
168 
169  InputParameters params = getFactory().getValidParams(kernel_type);
170  params.set<NonlinearVariableName>("variable") = solver_variable_name;
171  const auto block_names = num_blocks ? _thermal_conductivity_blocks[block_i] : _blocks;
172  assignBlocks(params, block_names);
173  const auto conductivity_name = vector_conductivity ? NS::kappa : NS::k;
174  params.set<MooseFunctorName>(NS::porosity) =
175  _flow_equations_physics->getPorosityFunctorName(true);
176  params.set<bool>("effective_conductivity") = getParam<bool>("effective_conductivity");
177  if (!_solve_for_enthalpy)
178  params.set<MooseFunctorName>(conductivity_name) = _thermal_conductivity_name[block_i];
179  else
180  params.set<MooseFunctorName>(conductivity_name) =
181  _thermal_conductivity_name[block_i] + "_by_cp";
182 
183  getProblem().addFVKernel(
184  kernel_type, prefix() + "pins_energy_diffusion_" + block_name, params);
185  }
186  else
187  {
188  const std::string kernel_type = "FVDiffusion";
189  InputParameters params = getFactory().getValidParams(kernel_type);
190  params.set<NonlinearVariableName>("variable") = solver_variable_name;
191  std::vector<SubdomainName> block_names =
192  num_blocks ? _thermal_conductivity_blocks[block_i] : _blocks;
193  assignBlocks(params, block_names);
194  if (!_solve_for_enthalpy)
195  params.set<MooseFunctorName>("coeff") = _thermal_conductivity_name[block_i];
196  else
197  params.set<MooseFunctorName>("coeff") = _thermal_conductivity_name[block_i] + "_by_cp";
198 
199  getProblem().addFVKernel(
200  kernel_type, prefix() + "ins_energy_diffusion_" + block_name, params);
201  }
202  }
203 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::porosity
static const std::string porosity
Definition: NS.h:104
WCNSFVFlowPhysicsBase::getPorosityFunctorName
MooseFunctorName getPorosityFunctorName(const bool smoothed) const
Definition: WCNSFVFlowPhysicsBase.C:459
WCNSFVCoupledAdvectionPhysicsHelper::_porous_medium_treatment
const bool _porous_medium_treatment
Switch to show if porous medium treatment is requested or not.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:51
Moose::stringify
std::string stringify(const T &t)
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_blocks
std::vector< std::vector< SubdomainName > > _thermal_conductivity_blocks
Vector of subdomain groups where we want to have different thermal conduction.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:100
NS::kappa
static const std::string kappa
Definition: NS.h:116
WCNSFVFluidHeatTransferPhysicsBase::processThermalConductivity
bool processThermalConductivity()
Process thermal conductivity (multiple functor input options are available).
Definition: WCNSFVFluidHeatTransferPhysicsBase.C:166
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
std::vector< MooseFunctorName > _thermal_conductivity_name
Name of the thermal conductivity functor for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:102
make_range
IntRange< T > make_range(T beg, T end)
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
NS::k
static const std::string k
Definition: NS.h:130
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43

◆ addEnergyInletBC()

void WCNSFVFluidHeatTransferPhysics::addEnergyInletBC ( )
overrideprivatevirtual

Functions adding boundary conditions for the incompressible simulation.

These are used for weakly-compressible simulations as well.

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 256 of file WCNSFVFluidHeatTransferPhysics.C.

257 {
258  const auto & inlet_boundaries = _flow_equations_physics->getInletBoundaries();
259  // These are parameter errors for now. If Components add boundaries to Physics, the error
260  // may not be due to parameters anymore.
261  if (inlet_boundaries.size() != _energy_inlet_types.size())
262  paramError("energy_inlet_types",
263  "Energy inlet types (size " + std::to_string(_energy_inlet_types.size()) +
264  ") should be the same size as inlet_boundaries (size " +
265  std::to_string(inlet_boundaries.size()) + ")");
266  if (inlet_boundaries.size() != _energy_inlet_functors.size())
267  paramError("energy_inlet_functors",
268  "Energy inlet functors (size " + std::to_string(_energy_inlet_functors.size()) +
269  ") should be the same size as inlet_boundaries (size " +
270  std::to_string(inlet_boundaries.size()) + ")");
271 
272  const auto & solver_variable_name =
273  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
274 
275  unsigned int flux_bc_counter = 0;
276  for (const auto bc_ind : index_range(_energy_inlet_types))
277  {
278  if (_energy_inlet_types[bc_ind] == "fixed-temperature")
279  {
280  const std::string bc_type = _solve_for_enthalpy
281  ? "FVSpecificEnthalpyFromPressureTemperatureDirichletBC"
282  : "FVADFunctorDirichletBC";
283  InputParameters params = getFactory().getValidParams(bc_type);
284  params.set<NonlinearVariableName>("variable") = solver_variable_name;
285  if (!_solve_for_enthalpy)
286  params.set<MooseFunctorName>("functor") = _energy_inlet_functors[bc_ind];
287  else
288  {
289  mooseAssert(_flow_equations_physics, "Should be coupled");
290  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
291  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
292  params.set<MooseFunctorName>(NS::T_fluid) = _energy_inlet_functors[bc_ind];
293  }
294  params.set<std::vector<BoundaryName>>("boundary") = {inlet_boundaries[bc_ind]};
295 
296  getProblem().addFVBC(bc_type, solver_variable_name + "_" + inlet_boundaries[bc_ind], params);
297 
298  // Check the BCs for momentum
299  const auto momentum_inlet_type =
300  _flow_equations_physics->inletBoundaryType(inlet_boundaries[bc_ind]);
301  if (getParam<bool>("check_bc_compatibility") &&
302  (momentum_inlet_type == NS::MomentumInletTypes::FLUX_VELOCITY ||
303  momentum_inlet_type == NS::MomentumInletTypes::FLUX_MASS))
304  paramError("energy_inlet_types",
305  "At inlet '" + inlet_boundaries[bc_ind] +
306  "', you are using a Dirichlet boundary condition on temperature, and a "
307  "flux boundary condition on momentum. This is known to create an "
308  "undesirable inlet source term.");
309  }
310  else if (_energy_inlet_types[bc_ind] == "heatflux")
311  {
312  const std::string bc_type = "FVFunctionNeumannBC";
313  InputParameters params = getFactory().getValidParams(bc_type);
314  params.set<NonlinearVariableName>("variable") = solver_variable_name;
315  params.set<FunctionName>("function") = _energy_inlet_functors[bc_ind];
316  params.set<std::vector<BoundaryName>>("boundary") = {inlet_boundaries[bc_ind]};
317 
318  getProblem().addFVBC(bc_type, solver_variable_name + "_" + inlet_boundaries[bc_ind], params);
319  }
320  else if (_energy_inlet_types[bc_ind] == "flux-mass" ||
321  _energy_inlet_types[bc_ind] == "flux-velocity")
322  {
323  const std::string bc_type = "WCNSFVEnergyFluxBC";
324  InputParameters params = getFactory().getValidParams(bc_type);
325  params.set<NonlinearVariableName>("variable") = solver_variable_name;
326  const auto & flux_inlet_directions = _flow_equations_physics->getFluxInletDirections();
327  const auto & flux_inlet_pps = _flow_equations_physics->getFluxInletPPs();
328 
329  if (flux_inlet_pps.size() < flux_bc_counter)
330  _flow_equations_physics->paramError(
331  "flux_inlet_pps",
332  "Should be specified for all 'flux-mass/velocity' boundary conditions");
333 
334  if (flux_inlet_directions.size())
335  {
336  if (flux_inlet_directions.size() < flux_bc_counter)
337  _flow_equations_physics->paramError("flux_inlet_pps",
338  "Should be specified for all or none of the "
339  "'flux-mass/velocity' boundary conditions");
340  params.set<Point>("direction") = flux_inlet_directions[flux_bc_counter];
341  }
342  if (_energy_inlet_types[bc_ind] == "flux-mass")
343  {
344  params.set<PostprocessorName>("mdot_pp") = flux_inlet_pps[flux_bc_counter];
345  params.set<PostprocessorName>("area_pp") = "area_pp_" + inlet_boundaries[bc_ind];
346  }
347  else
348  params.set<PostprocessorName>("velocity_pp") = flux_inlet_pps[flux_bc_counter];
349 
350  params.set<PostprocessorName>("temperature_pp") = _energy_inlet_functors[bc_ind];
351  params.set<MooseFunctorName>(NS::density) = _density_name;
352  params.set<MooseFunctorName>(NS::cp) = _specific_heat_name;
353  params.set<MooseFunctorName>(NS::T_fluid) = _fluid_temperature_name;
354 
355  if (isParamValid(NS::fluid))
356  {
357  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
358  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
359  }
360 
361  if (_solve_for_enthalpy)
362  params.set<MooseFunctorName>(NS::specific_enthalpy) = _fluid_enthalpy_name;
363 
364  for (const auto d : make_range(dimension()))
365  params.set<MooseFunctorName>(NS::velocity_vector[d]) = _velocity_names[d];
366 
367  params.set<std::vector<BoundaryName>>("boundary") = {inlet_boundaries[bc_ind]};
368 
369  getProblem().addFVBC(bc_type, solver_variable_name + "_" + inlet_boundaries[bc_ind], params);
370  flux_bc_counter += 1;
371  }
372  }
373 }
WCNSFVFluidHeatTransferPhysicsBase::_specific_heat_name
MooseFunctorName _specific_heat_name
Name of the specific heat material property.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:98
WCNSFVCoupledAdvectionPhysicsHelper::_density_name
const MooseFunctorName _density_name
Name of the density material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:59
PhysicsBase::getFactory
Factory & getFactory()
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
WCNSFVFlowPhysicsBase::getInletBoundaries
const std::vector< BoundaryName > & getInletBoundaries() const
Get the inlet boundaries.
Definition: WCNSFVFlowPhysicsBase.h:69
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
NS::density
static const std::string density
Definition: NS.h:33
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
MultiMooseEnum::size
unsigned int size() const
NS::fluid
static const std::string fluid
Definition: NS.h:87
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::dimension
unsigned int dimension() const
WCNSFVFluidHeatTransferPhysicsBase::_energy_inlet_types
MultiMooseEnum _energy_inlet_types
Energy inlet boundary types.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:112
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::cp
static const std::string cp
Definition: NS.h:121
NS::T_fluid
static const std::string T_fluid
Definition: NS.h:106
WCNSFVFlowPhysicsBase::getFluxInletPPs
const std::vector< PostprocessorName > & getFluxInletPPs() const
Get the inlet flux postprocessor if using a flux inlet.
Definition: WCNSFVFlowPhysicsBase.h:85
WCNSFVFlowPhysicsBase::inletBoundaryType
NS::MomentumInletTypes inletBoundaryType(const BoundaryName &boundary_name) const
Get the type of the inlet BC.
Definition: WCNSFVFlowPhysicsBase.h:77
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVCoupledAdvectionPhysicsHelper::_velocity_names
const std::vector< std::string > _velocity_names
Velocity names.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:54
WCNSFVFluidHeatTransferPhysicsBase::_energy_inlet_functors
std::vector< MooseFunctorName > _energy_inlet_functors
Functors describing the inlet boundary values. See energy_inlet_types for what the functors actually ...
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:114
NS::pressure
static const std::string pressure
Definition: NS.h:56
make_range
IntRange< T > make_range(T beg, T end)
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
NS::velocity_vector
const std::string velocity_vector[3]
Definition: NS.h:49
WCNSFVFlowPhysicsBase::getFluxInletDirections
const std::vector< Point > & getFluxInletDirections() const
Get the inlet direction if using a flux inlet.
Definition: WCNSFVFlowPhysicsBase.h:83
FEProblemBase::addFVBC
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
index_range
auto index_range(const T &sizable)
NS::specific_enthalpy
static const std::string specific_enthalpy
Definition: NS.h:68
WCNSFVFlowPhysicsBase::getPressureName
const NonlinearVariableName & getPressureName() const
Definition: WCNSFVFlowPhysicsBase.h:41

◆ addEnergyOutletBC()

void WCNSFVFluidHeatTransferPhysics::addEnergyOutletBC ( )
inlineoverrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 45 of file WCNSFVFluidHeatTransferPhysics.h.

45 {}

◆ addEnergySeparatorBC()

void WCNSFVFluidHeatTransferPhysics::addEnergySeparatorBC ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 537 of file WCNSFVFluidHeatTransferPhysics.C.

538 {
539  if (_flow_equations_physics->getHydraulicSeparators().size())
540  {
541  const auto & solver_variable_name =
542  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
543 
544  const std::string bc_type = "INSFVScalarFieldSeparatorBC";
545  InputParameters params = getFactory().getValidParams(bc_type);
546  params.set<NonlinearVariableName>("variable") = solver_variable_name;
547  params.set<std::vector<BoundaryName>>("boundary") =
548  _flow_equations_physics->getHydraulicSeparators();
549  getProblem().addFVBC(bc_type, prefix() + solver_variable_name + "_separators", params);
550  }
551 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::getFactory
Factory & getFactory()
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
WCNSFVFlowPhysicsBase::getHydraulicSeparators
const std::vector< BoundaryName > & getHydraulicSeparators() const
Get the hydraulic separator boundaries.
Definition: WCNSFVFlowPhysicsBase.h:75
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
FEProblemBase::addFVBC
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43

◆ addEnergyTimeKernels()

void WCNSFVFluidHeatTransferPhysics::addEnergyTimeKernels ( )
overrideprivatevirtual

Functions adding kernels for the incompressible / weakly compressible energy equation If the material properties are not constant, some of these can be used for weakly-compressible simulations as well.

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 77 of file WCNSFVFluidHeatTransferPhysics.C.

78 {
79  std::string kernel_type =
80  ((_compressibility == "weakly-compressible") ? "WCNSFVEnergyTimeDerivative"
81  : "INSFVEnergyTimeDerivative");
82  std::string kernel_name =
83  prefix() + ((_compressibility == "weakly-compressible") ? "wcns" : "ins") + "_energy_time";
84  if (_porous_medium_treatment)
85  {
86  kernel_type = "PINSFVEnergyTimeDerivative";
87  kernel_name = prefix() + ((_compressibility == "weakly-compressible") ? "pwcns" : "pins") +
88  "_energy_time";
89  }
90 
91  const auto & solver_variable_name =
92  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
93 
94  InputParameters params = getFactory().getValidParams(kernel_type);
95  assignBlocks(params, _blocks);
96  params.set<NonlinearVariableName>("variable") = solver_variable_name;
97  params.set<MooseFunctorName>(NS::density) = _density_name;
98  params.set<MooseFunctorName>(NS::time_deriv(NS::specific_enthalpy)) =
99  NS::time_deriv(NS::specific_enthalpy);
100  if (_compressibility == "weakly-compressible")
101  {
102  params.set<MooseFunctorName>(NS::time_deriv(NS::density)) = NS::time_deriv(_density_name);
103  params.set<MooseFunctorName>(NS::specific_enthalpy) = NS::specific_enthalpy;
104  }
105  if (_porous_medium_treatment)
106  {
107  params.set<MooseFunctorName>(NS::porosity) =
108  _flow_equations_physics->getPorosityFunctorName(/*smoothed=*/false);
109  if (getProblem().hasFunctor(NS::time_deriv(_density_name),
110  /*thread_id=*/0))
111  {
112  params.set<MooseFunctorName>(NS::time_deriv(NS::density)) = NS::time_deriv(_density_name);
113  params.set<MooseFunctorName>(NS::specific_enthalpy) = NS::specific_enthalpy;
114  }
115 
116  params.set<bool>("is_solid") = false;
117  }
118 
119  getProblem().addFVKernel(kernel_type, kernel_name, params);
120 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
WCNSFVCoupledAdvectionPhysicsHelper::_density_name
const MooseFunctorName _density_name
Name of the density material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:59
PhysicsBase::getFactory
Factory & getFactory()
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
NS::density
static const std::string density
Definition: NS.h:33
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::porosity
static const std::string porosity
Definition: NS.h:104
WCNSFVCoupledAdvectionPhysicsHelper::_compressibility
const MooseEnum _compressibility
Compressibility type, can be compressible, incompressible or weakly-compressible. ...
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:48
WCNSFVFlowPhysicsBase::getPorosityFunctorName
MooseFunctorName getPorosityFunctorName(const bool smoothed) const
Definition: WCNSFVFlowPhysicsBase.C:459
WCNSFVCoupledAdvectionPhysicsHelper::_porous_medium_treatment
const bool _porous_medium_treatment
Switch to show if porous medium treatment is requested or not.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:51
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
NS::time_deriv
std::string time_deriv(const std::string &var)
Definition: NS.h:97
NS::specific_enthalpy
static const std::string specific_enthalpy
Definition: NS.h:68

◆ addEnergyWallBC()

void WCNSFVFluidHeatTransferPhysics::addEnergyWallBC ( )
overrideprivatevirtual

Implements WCNSFVFluidHeatTransferPhysicsBase.

Definition at line 376 of file WCNSFVFluidHeatTransferPhysics.C.

377 {
378  const auto & wall_boundaries = isParamSetByUser("energy_wall_boundaries")
379  ? getParam<std::vector<BoundaryName>>("energy_wall_boundaries")
380  : _flow_equations_physics->getWallBoundaries();
381  if (wall_boundaries.size() != _energy_wall_types.size())
382  paramError("energy_wall_types",
383  "Energy wall types (size " + std::to_string(_energy_wall_types.size()) +
384  ") should be the same size as wall_boundaries (size " +
385  std::to_string(wall_boundaries.size()) + ")");
386  if (wall_boundaries.size() != _energy_wall_functors.size())
387  paramError("energy_wall_functors",
388  "Energy wall functors (size " + std::to_string(_energy_wall_functors.size()) +
389  ") should be the same size as wall_boundaries (size " +
390  std::to_string(wall_boundaries.size()) + ")");
391 
392  const auto & solver_variable_name =
393  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
394 
395  for (unsigned int bc_ind = 0; bc_ind < _energy_wall_types.size(); ++bc_ind)
396  {
397  if (_energy_wall_types[bc_ind] == "fixed-temperature")
398  {
399  const std::string bc_type = _solve_for_enthalpy
400  ? "FVSpecificEnthalpyFromPressureTemperatureDirichletBC"
401  : "FVADFunctorDirichletBC";
402  InputParameters params = getFactory().getValidParams(bc_type);
403  params.set<NonlinearVariableName>("variable") = solver_variable_name;
404  if (!_solve_for_enthalpy)
405  params.set<MooseFunctorName>("functor") = _energy_wall_functors[bc_ind];
406  else
407  {
408  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
409  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
410  params.set<MooseFunctorName>(NS::T_fluid) = _energy_wall_functors[bc_ind];
411  }
412  params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
413 
414  getProblem().addFVBC(bc_type, solver_variable_name + "_" + wall_boundaries[bc_ind], params);
415  }
416  else if (_energy_wall_types[bc_ind] == "heatflux")
417  {
418  const std::string bc_type = "FVFunctorNeumannBC";
419  InputParameters params = getFactory().getValidParams(bc_type);
420  params.set<NonlinearVariableName>("variable") = solver_variable_name;
421  params.set<MooseFunctorName>("functor") = _energy_wall_functors[bc_ind];
422  params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
423 
424  getProblem().addFVBC(bc_type, solver_variable_name + "_" + wall_boundaries[bc_ind], params);
425  }
426  else if (_energy_wall_types[bc_ind] == "convection")
427  {
428  const std::string bc_type = "FVFunctorConvectiveHeatFluxBC";
429  InputParameters params = getFactory().getValidParams(bc_type);
430  params.set<NonlinearVariableName>("variable") = solver_variable_name;
431  params.set<MooseFunctorName>("T_bulk") = _fluid_temperature_name;
432  params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
433  params.set<bool>("is_solid") = false;
434  const auto Tinf_htc_functors =
435  MooseUtils::split(_energy_wall_functors[bc_ind], /*delimiter=*/":", /*max_count=*/1);
436  if (Tinf_htc_functors.size() != 2)
437  paramError("energy_wall_functors",
438  "'convective' wall types require two functors specified as "
439  "<Tinf_functor>:<htc_functor>.");
440  params.set<MooseFunctorName>("T_solid") = Tinf_htc_functors[0];
441  params.set<MooseFunctorName>("heat_transfer_coefficient") = Tinf_htc_functors[1];
442 
443  getProblem().addFVBC(bc_type, solver_variable_name + "_" + wall_boundaries[bc_ind], params);
444  }
445  // We add this boundary condition here to facilitate the input of wall boundaries / functors for
446  // energy. If there are too many turbulence options and this gets out of hand we will have to
447  // move this to the turbulence Physics
448  else if (_energy_wall_types[bc_ind] == "wallfunction")
449  {
450  if (!_turbulence_physics)
451  paramError("coupled_turbulence_physics",
452  "A coupled turbulence Physics was not found for defining the wall function "
453  "boundary condition on boundary: " +
454  wall_boundaries[bc_ind]);
455  const std::string bc_type = "INSFVTurbulentTemperatureWallFunction";
456  InputParameters params = getFactory().getValidParams(bc_type);
457  params.set<NonlinearVariableName>("variable") = solver_variable_name;
458  params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
459  params.set<MooseEnum>("wall_treatment") =
460  _turbulence_physics->turbulenceTemperatureWallTreatment();
461  params.set<MooseFunctorName>("T_w") = _energy_wall_functors[bc_ind];
462  params.set<MooseFunctorName>(NS::density) = _density_name;
463  params.set<MooseFunctorName>(NS::mu) = _dynamic_viscosity_name;
464  params.set<MooseFunctorName>(NS::TKE) = _turbulence_physics->tkeName();
465  if (_thermal_conductivity_name.size() != 1)
466  mooseError("Several anisotropic thermal conductivity (kappa) regions have been specified. "
467  "Selecting the right kappa coefficient for the turbulence boundaries is not "
468  "currently implemented.\nBoundaries:\n" +
469  Moose::stringify(_turbulence_physics->turbulenceWalls()) +
470  "\nKappa(s) specified:\n" + Moose::stringify(_thermal_conductivity_name));
471  params.set<MooseFunctorName>(NS::kappa) = _thermal_conductivity_name[0];
472  params.set<MooseFunctorName>(NS::cp) = _specific_heat_name;
473  const std::string u_names[3] = {"u", "v", "w"};
474  for (const auto d : make_range(dimension()))
475  params.set<MooseFunctorName>(u_names[d]) = _velocity_names[d];
476  // Currently only Newton method for WCNSFVFluidHeatTransferPhysics
477  params.set<bool>("newton_solve") = true;
478  getProblem().addFVBC(bc_type, prefix() + "wallfunction_" + wall_boundaries[bc_ind], params);
479  }
480  else
481  paramError(
482  "energy_wall_types", _energy_wall_types[bc_ind], " wall type is currently unsupported.");
483  }
484 }
PhysicsBase::prefix
std::string prefix() const
WCNSFVFluidHeatTransferPhysicsBase::_specific_heat_name
MooseFunctorName _specific_heat_name
Name of the specific heat material property.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:98
WCNSFVCoupledAdvectionPhysicsHelper::_density_name
const MooseFunctorName _density_name
Name of the density material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:59
PhysicsBase::getFactory
Factory & getFactory()
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
WCNSFVTurbulencePhysics::turbulenceTemperatureWallTreatment
MooseEnum turbulenceTemperatureWallTreatment() const
The turbulence temperature wall treatment (same for all turbulence walls currently) ...
Definition: WCNSFVTurbulencePhysics.h:38
NS::density
static const std::string density
Definition: NS.h:33
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
NS::TKE
static const std::string TKE
Definition: NS.h:176
MultiMooseEnum::size
unsigned int size() const
NS::fluid
static const std::string fluid
Definition: NS.h:87
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
WCNSFVCoupledAdvectionPhysicsHelper::_dynamic_viscosity_name
const MooseFunctorName _dynamic_viscosity_name
Name of the dynamic viscosity material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:61
WCNSFVFluidHeatTransferPhysicsBase::_energy_wall_types
MultiMooseEnum _energy_wall_types
Energy wall boundary types.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:116
PhysicsBase::dimension
unsigned int dimension() const
WCNSFVFluidHeatTransferPhysicsBase::_energy_wall_functors
std::vector< MooseFunctorName > _energy_wall_functors
Functors describing the wall boundary values. See energy_wall_types for what the functors actually re...
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:118
WCNSFVCoupledAdvectionPhysicsHelper::_turbulence_physics
const WCNSFVTurbulencePhysics * _turbulence_physics
Turbulence.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:45
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::cp
static const std::string cp
Definition: NS.h:121
NS::T_fluid
static const std::string T_fluid
Definition: NS.h:106
NS::mu
static const std::string mu
Definition: NS.h:123
Moose::stringify
std::string stringify(const T &t)
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVCoupledAdvectionPhysicsHelper::_velocity_names
const std::vector< std::string > _velocity_names
Velocity names.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:54
NS::kappa
static const std::string kappa
Definition: NS.h:116
NS::pressure
static const std::string pressure
Definition: NS.h:56
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
std::vector< MooseFunctorName > _thermal_conductivity_name
Name of the thermal conductivity functor for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:102
make_range
IntRange< T > make_range(T beg, T end)
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::mooseError
void mooseError(Args &&... args) const
WCNSFVTurbulencePhysics::tkeName
MooseFunctorName tkeName() const
The name of the turbulent kinetic energy variable.
Definition: WCNSFVTurbulencePhysics.h:40
MooseUtils::split
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count)
FEProblemBase::addFVBC
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
WCNSFVTurbulencePhysics::turbulenceWalls
std::vector< BoundaryName > turbulenceWalls() const
The names of the boundaries with turbulence wall functions.
Definition: WCNSFVTurbulencePhysics.h:34
PhysicsBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
WCNSFVFlowPhysicsBase::getWallBoundaries
const std::vector< BoundaryName > & getWallBoundaries() const
Get the wall boundaries.
Definition: WCNSFVFlowPhysicsBase.h:73
WCNSFVFlowPhysicsBase::getPressureName
const NonlinearVariableName & getPressureName() const
Definition: WCNSFVFlowPhysicsBase.h:41

◆ addFVBCs()

void WCNSFVFluidHeatTransferPhysicsBase::addFVBCs ( )
overrideprotectedvirtualinherited

Reimplemented from PhysicsBase.

Definition at line 145 of file WCNSFVFluidHeatTransferPhysicsBase.C.

146 {
147  // For compatibility with Modules/NavierStokesFV syntax
148  if (!_has_energy_equation)
149  return;
150 
151  addEnergyInletBC();
152  addEnergyWallBC();
153  addEnergyOutletBC();
154  addEnergySeparatorBC();
155 }
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90
WCNSFVFluidHeatTransferPhysicsBase::addEnergyInletBC
virtual void addEnergyInletBC()=0
Functions adding boundary conditions for the fluid heat transfer equation.

◆ addFVKernels()

void WCNSFVFluidHeatTransferPhysicsBase::addFVKernels ( )
overrideprotectedvirtualinherited

Reimplemented from PhysicsBase.

Definition at line 124 of file WCNSFVFluidHeatTransferPhysicsBase.C.

125 {
126  // For compatibility with Modules/NavierStokesFV syntax
127  if (!_has_energy_equation)
128  return;
129 
130  if (shouldCreateTimeDerivative(_solve_for_enthalpy ? _fluid_enthalpy_name
131  : _fluid_temperature_name,
132  _blocks,
133  /*error if already defined*/ false))
134  addEnergyTimeKernels();
135 
136  addEnergyAdvectionKernels();
137  addEnergyHeatConductionKernels();
138  if (getParam<std::vector<MooseFunctorName>>("ambient_temperature").size())
139  addEnergyAmbientConvection();
140  if (isParamValid("external_heat_source"))
141  addEnergyExternalHeatSource();
142 }
WCNSFVFluidHeatTransferPhysicsBase::addEnergyExternalHeatSource
virtual void addEnergyExternalHeatSource()=0
WCNSFVFluidHeatTransferPhysicsBase::addEnergyTimeKernels
virtual void addEnergyTimeKernels()=0
Functions adding kernels for the incompressible / weakly compressible energy equation.
PhysicsBase::getParam
const T & getParam(const std::string &name) const
PhysicsBase::shouldCreateTimeDerivative
bool shouldCreateTimeDerivative(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_already_defined) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
WCNSFVFluidHeatTransferPhysicsBase::addEnergyAmbientConvection
virtual void addEnergyAmbientConvection()=0
WCNSFVFluidHeatTransferPhysicsBase::addEnergyAdvectionKernels
virtual void addEnergyAdvectionKernels()=0
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::addEnergyHeatConductionKernels
virtual void addEnergyHeatConductionKernels()=0

◆ addInitialConditions()

void WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions ( )
overrideprotectedvirtualinherited

Reimplemented from PhysicsBase.

Definition at line 211 of file WCNSFVFluidHeatTransferPhysicsBase.C.

212 {
213  // For compatibility with Modules/NavierStokesFV syntax
214  if (!_has_energy_equation)
215  return;
216  if (!_define_variables && parameters().isParamSetByUser("initial_temperature"))
217  paramError(
218  "initial_temperature",
219  "T_fluid is defined externally of WCNSFVFluidHeatTransferPhysicsBase, so should the inital "
220  "condition");
221  // do not set initial conditions if we are not defining variables
222  if (!_define_variables)
223  {
224  reportPotentiallyMissedParameters({"initial_temperature", "initial_enthalpy"}, "FunctionIC");
225  return;
226  }
227 
228  InputParameters params = getFactory().getValidParams("FVFunctionIC");
229  assignBlocks(params, _blocks);
230 
231  // initial_temperature has a default so we should almost always set it (see shouldCreateIC logic)
232  {
233  bool temperature_ic_used = false;
234  if (variableExists(_fluid_temperature_name, false) &&
235  shouldCreateIC(_fluid_temperature_name,
236  _blocks,
237  /*whether IC is a default*/ !isParamSetByUser("initial_temperature"),
238  /*error if already an IC*/ isParamSetByUser("initial_temperature")))
239  {
240  params.set<VariableName>("variable") = _fluid_temperature_name;
241  params.set<FunctionName>("function") = getParam<FunctionName>("initial_temperature");
242 
243  getProblem().addFVInitialCondition("FVFunctionIC", _fluid_temperature_name + "_ic", params);
244  temperature_ic_used = true;
245  }
246  // Needed to solve for enthalpy: an initial condition on enthalpy based on the initial
247  // temperature
248  if (isParamValid(NS::fluid) && _solve_for_enthalpy && !isParamValid("initial_enthalpy") &&
249  shouldCreateIC(_fluid_enthalpy_name,
250  _blocks,
251  /*whether IC is a default*/ !isParamSetByUser("initial_temperature"),
252  /*error if already an IC*/ isParamSetByUser("initial_temperature")))
253  {
254  // from the FluidProperties module
255  InputParameters params =
256  getFactory().getValidParams("SpecificEnthalpyFromPressureTemperatureIC");
257  assignBlocks(params, _blocks);
258  params.set<VariableName>("variable") = _fluid_enthalpy_name;
259  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
260  params.set<std::vector<VariableName>>("p") = {_flow_equations_physics->getPressureName()};
261  Real temp;
262  if (MooseUtils::parsesToReal(getParam<FunctionName>("initial_temperature"), &temp))
263  {
264  params.defaultCoupledValue("T", temp, 0);
265  params.set<std::vector<VariableName>>("T") = {};
266  }
267  else
268  paramError("initial_temperature", "Only Real values supported when solving for enthalpy");
269  getProblem().addInitialCondition(
270  "SpecificEnthalpyFromPressureTemperatureIC", _fluid_enthalpy_name + "_ic", params);
271  temperature_ic_used = true;
272  }
273 
274  if (!temperature_ic_used && isParamSetByUser("initial_temperature"))
275  reportPotentiallyMissedParameters({"initial_temperature"}, "FunctionIC");
276  }
277  if (isParamValid("initial_enthalpy") && _solve_for_enthalpy &&
278  shouldCreateIC(_fluid_enthalpy_name,
279  _blocks,
280  /*whether IC is a default*/ false,
281  /*error if already an IC*/ false))
282  {
283  params.set<VariableName>("variable") = _fluid_enthalpy_name;
284  params.set<FunctionName>("function") = getParam<FunctionName>("initial_enthalpy");
285 
286  getProblem().addFVInitialCondition("FVFunctionIC", _fluid_enthalpy_name + "_ic", params);
287  }
288  else if (isParamValid("initial_enthalpy"))
289  reportPotentiallyMissedParameters({"initial_enthalpy"}, "FunctionIC");
290 }
FEProblemBase::addFVInitialCondition
virtual void addFVInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
PhysicsBase::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
NS::fluid
static const std::string fluid
Definition: NS.h:87
PhysicsBase::shouldCreateIC
bool shouldCreateIC(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool ic_is_default_ic, const bool error_if_already_defined) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
FEProblemBase::addInitialCondition
virtual void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
InputParameters::defaultCoupledValue
Real defaultCoupledValue(const std::string &coupling_name, unsigned int i=0) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90
PhysicsBase::variableExists
bool variableExists(const VariableName &var_name, bool error_if_aux) const
NavierStokesPhysicsBase::_define_variables
bool _define_variables
Whether to define variables if they do not exist.
Definition: NavierStokesPhysicsBase.h:44
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
PhysicsBase::reportPotentiallyMissedParameters
void reportPotentiallyMissedParameters(const std::vector< std::string > &param_names, const std::string &object_type) const
MooseUtils::parsesToReal
bool parsesToReal(const std::string &input, Real *parsed_real)
PhysicsBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
WCNSFVFlowPhysicsBase::getPressureName
const NonlinearVariableName & getPressureName() const
Definition: WCNSFVFlowPhysicsBase.h:41

◆ addMaterials()

void WCNSFVFluidHeatTransferPhysics::addMaterials ( )
overrideprivatevirtual

Reimplemented from PhysicsBase.

Definition at line 487 of file WCNSFVFluidHeatTransferPhysics.C.

488 {
489  if (!_has_energy_equation)
490  return;
491 
492  // Note that this material choice does not make sense for Newton-INSFV + solve_for_enthalpy since
493  // this material explicitly computes enthalpy from temperature
494  const auto object_type = "INSFVEnthalpyFunctorMaterial";
495 
496  InputParameters params = getFactory().getValidParams(object_type);
497  assignBlocks(params, _blocks);
498 
499  params.set<MooseFunctorName>(NS::density) = _density_name;
500  params.set<MooseFunctorName>(NS::cp) = _specific_heat_name;
501 
502  if (_solve_for_enthalpy)
503  {
504  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
505  params.set<MooseFunctorName>(NS::specific_enthalpy + "_in") = _fluid_enthalpy_name;
506  params.set<bool>("assumed_constant_cp") = false;
507  if (isParamValid(NS::fluid))
508  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
509  else
510  paramError(NS::fluid, "Required when solving for enthalpy");
511  }
512  // the functor material defines the temperature
513  else
514  {
515  params.set<MooseFunctorName>("temperature") = _fluid_temperature_name;
516  params.set<MooseFunctorName>(NS::specific_enthalpy) = _fluid_enthalpy_name;
517  if (isParamValid(NS::fluid))
518  {
519  params.set<bool>("assumed_constant_cp") = false;
520  params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
521  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
522  }
523  }
524  if (_solve_for_enthalpy)
525  {
526  params.set<std::vector<std::string>>("output_properties") = {_fluid_temperature_name};
527  params.set<std::vector<OutputName>>("outputs") = {"all"};
528  }
529 
530  getProblem().addMaterial(object_type, prefix() + "enthalpy_material", params);
531 
532  if (_solve_for_enthalpy)
533  WCNSFVFluidHeatTransferPhysicsBase::defineKOverCpFunctors(/*use ad*/ true);
534 }
PhysicsBase::prefix
std::string prefix() const
WCNSFVFluidHeatTransferPhysicsBase::_specific_heat_name
MooseFunctorName _specific_heat_name
Name of the specific heat material property.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:98
WCNSFVFluidHeatTransferPhysicsBase::defineKOverCpFunctors
void defineKOverCpFunctors(const bool use_ad)
Define the k/cp diffusion coefficients when solving for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.C:293
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
WCNSFVCoupledAdvectionPhysicsHelper::_density_name
const MooseFunctorName _density_name
Name of the density material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:59
PhysicsBase::getFactory
Factory & getFactory()
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
FEProblemBase::addMaterial
virtual void addMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
NS::density
static const std::string density
Definition: NS.h:33
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
NS::fluid
static const std::string fluid
Definition: NS.h:87
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
NS::cp
static const std::string cp
Definition: NS.h:121
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90
NS::pressure
static const std::string pressure
Definition: NS.h:56
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43
NS::specific_enthalpy
static const std::string specific_enthalpy
Definition: NS.h:68
WCNSFVFlowPhysicsBase::getPressureName
const NonlinearVariableName & getPressureName() const
Definition: WCNSFVFlowPhysicsBase.h:41

◆ addSolverVariables()

void WCNSFVFluidHeatTransferPhysics::addSolverVariables ( )
overrideprivatevirtual

Reimplemented from PhysicsBase.

Definition at line 42 of file WCNSFVFluidHeatTransferPhysics.C.

43 {
44  // For compatibility with Modules/NavierStokesFV syntax
45  if (!_has_energy_equation)
46  return;
47 
48  const auto & solver_variable_name =
49  _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
50 
51  // Dont add if the user already defined the variable
52  if (!shouldCreateVariable(solver_variable_name, _blocks, /*error if aux*/ true))
53  reportPotentiallyMissedParameters({"system_names",
54  "energy_scaling",
55  "energy_face_interpolation",
56  "energy_two_term_bc_expansion"},
57  "INSFVEnergyVariable");
58  else if (_define_variables)
59  {
60  auto params = getFactory().getValidParams("INSFVEnergyVariable");
61  assignBlocks(params, _blocks);
62  params.set<std::vector<Real>>("scaling") = {getParam<Real>("energy_scaling")};
63  params.set<MooseEnum>("face_interp_method") = getParam<MooseEnum>("energy_face_interpolation");
64  params.set<bool>("two_term_boundary_expansion") =
65  getParam<bool>("energy_two_term_bc_expansion");
66  params.set<SolverSystemName>("solver_sys") = getSolverSystem(solver_variable_name);
67  getProblem().addVariable("INSFVEnergyVariable", solver_variable_name, params);
68  }
69  else
70  // we don't let the user select the enthalpy variable name at this time
71  paramError(_solve_for_enthalpy ? "solve_for_enthalpy" : "fluid_temperature_variable",
72  "Variable (" + solver_variable_name +
73  ") supplied to the WCNSFVFluidHeatTransferPhysics does not exist!");
74 }
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::shouldCreateVariable
bool shouldCreateVariable(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_aux)
PhysicsBase::getFactory
Factory & getFactory()
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
PhysicsBase::getSolverSystem
const SolverSystemName & getSolverSystem(unsigned int variable_index) const
WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
const VariableName _fluid_enthalpy_name
Name of the fluid specific enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:94
FEProblemBase::addVariable
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90
NavierStokesPhysicsBase::_define_variables
bool _define_variables
Whether to define variables if they do not exist.
Definition: NavierStokesPhysicsBase.h:44
WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
const bool _solve_for_enthalpy
User-selected option to solve for enthalpy.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:92
PhysicsBase::reportPotentiallyMissedParameters
void reportPotentiallyMissedParameters(const std::vector< std::string > &param_names, const std::string &object_type) const

◆ defineKOverCpFunctors()

void WCNSFVFluidHeatTransferPhysicsBase::defineKOverCpFunctors ( const bool  use_ad)
protectedinherited

Define the k/cp diffusion coefficients when solving for enthalpy.

Definition at line 293 of file WCNSFVFluidHeatTransferPhysicsBase.C.

Referenced by addMaterials(), and WCNSLinearFVFluidHeatTransferPhysics::addMaterials().

294 {
295  // Define alpha, the diffusion coefficient when solving for enthalpy, on each block
296  for (unsigned int i = 0; i < _thermal_conductivity_name.size(); ++i)
297  {
298  const auto object_type = use_ad ? "ADParsedFunctorMaterial" : "ParsedFunctorMaterial";
299  InputParameters params = getFactory().getValidParams(object_type);
300  assignBlocks(params, _blocks);
301  std::vector<std::string> f_names;
302  if (!MooseUtils::parsesToReal(_thermal_conductivity_name[i]))
303  f_names.push_back(_thermal_conductivity_name[i]);
304  if (!MooseUtils::parsesToReal(getSpecificHeatName()))
305  f_names.push_back(getSpecificHeatName());
306  params.set<std::vector<std::string>>("functor_names") = f_names;
307  params.set<std::string>("expression") =
308  _thermal_conductivity_name[i] + "/" + getSpecificHeatName();
309  params.set<std::string>("property_name") = _thermal_conductivity_name[i] + "_by_cp";
310  getProblem().addMaterial(
311  object_type, prefix() + "rho_alpha_from_" + _thermal_conductivity_name[i], params);
312  }
313 }
PhysicsBase::prefix
std::string prefix() const
PhysicsBase::assignBlocks
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
PhysicsBase::getFactory
Factory & getFactory()
FEProblemBase::addMaterial
virtual void addMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
PhysicsBase::_blocks
std::vector< SubdomainName > _blocks
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
WCNSFVFluidHeatTransferPhysicsBase::getSpecificHeatName
const MooseFunctorName & getSpecificHeatName() const
Get the name of the specific heat material property.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:39
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
std::vector< MooseFunctorName > _thermal_conductivity_name
Name of the thermal conductivity functor for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:102
MooseUtils::parsesToReal
bool parsesToReal(const std::string &input, Real *parsed_real)

◆ densityName()

const MooseFunctorName& WCNSFVCoupledAdvectionPhysicsHelper::densityName ( ) const
inlineinherited

Definition at line 36 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::WCNSFVTwoPhaseMixturePhysics(), and WCNSLinearFVTwoPhaseMixturePhysics::WCNSLinearFVTwoPhaseMixturePhysics().

36 { return _density_name; }
WCNSFVCoupledAdvectionPhysicsHelper::_density_name
const MooseFunctorName _density_name
Name of the density material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:59

◆ dynamicViscosityName()

const MooseFunctorName& WCNSFVCoupledAdvectionPhysicsHelper::dynamicViscosityName ( ) const
inlineinherited

Definition at line 37 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

37 { return _dynamic_viscosity_name; }
WCNSFVCoupledAdvectionPhysicsHelper::_dynamic_viscosity_name
const MooseFunctorName _dynamic_viscosity_name
Name of the dynamic viscosity material property.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:61

◆ getAdditionalRMParams()

InputParameters NavierStokesPhysicsBase::getAdditionalRMParams ( ) const
overrideprotectedvirtualinherited

Parameters to change or add relationship managers.

Reimplemented from PhysicsBase.

Definition at line 42 of file NavierStokesPhysicsBase.C.

43 {
44  unsigned short necessary_layers = getParam<unsigned short>("ghost_layers");
45  necessary_layers = std::max(necessary_layers, getNumberAlgebraicGhostingLayersNeeded());
46 
47  // Just an object that has a ghost_layers parameter
48  const std::string kernel_type = "INSFVMixingLengthReynoldsStress";
49  InputParameters params = getFactory().getValidParams(kernel_type);
50  params.template set<unsigned short>("ghost_layers") = necessary_layers;
51 
52  return params;
53 }
PhysicsBase::getFactory
Factory & getFactory()
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
NavierStokesPhysicsBase::getNumberAlgebraicGhostingLayersNeeded
virtual unsigned short getNumberAlgebraicGhostingLayersNeeded() const =0
Return the number of ghosting layers needed.

◆ getAmbientConvectionBlocks()

const std::vector<std::vector<SubdomainName> >& WCNSFVFluidHeatTransferPhysicsBase::getAmbientConvectionBlocks ( ) const
inlineinherited

Get the ambient convection parameters for parameter checking.

Definition at line 47 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by PNSFVSolidHeatTransferPhysics::checkFluidAndSolidHeatTransferPhysicsParameters().

48  {
49  return _ambient_convection_blocks;
50  }
WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_blocks
std::vector< std::vector< SubdomainName > > _ambient_convection_blocks
Vector of subdomain groups where we want to have different ambient convection.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:105

◆ getAmbientConvectionHTCs()

const std::vector<MooseFunctorName>& WCNSFVFluidHeatTransferPhysicsBase::getAmbientConvectionHTCs ( ) const
inlineinherited

Name of the ambient convection heat transfer coefficients for each block-group.

Definition at line 52 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by PNSFVSolidHeatTransferPhysics::checkFluidAndSolidHeatTransferPhysicsParameters().

53  {
54  return _ambient_convection_alpha;
55  }
WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_alpha
std::vector< MooseFunctorName > _ambient_convection_alpha
Name of the ambient convection heat transfer coefficients for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:107

◆ getCoupledFlowPhysics()

const WCNSFVFlowPhysicsBase * WCNSFVCoupledAdvectionPhysicsHelper::getCoupledFlowPhysics ( ) const
inherited

Definition at line 53 of file WCNSFVCoupledAdvectionPhysicsHelper.C.

54 {
55  // User passed it, just use that
56  if (_advection_physics->isParamValid("coupled_flow_physics"))
57  return _advection_physics->getCoupledPhysics<WCNSFVFlowPhysicsBase>(
58  _advection_physics->getParam<PhysicsName>("coupled_flow_physics"));
59  // Look for any physics of the right type, and check the block restriction
60  else
61  {
62  const auto all_flow_physics =
63  _advection_physics->getCoupledPhysics<const WCNSFVFlowPhysicsBase>();
64  for (const auto physics : all_flow_physics)
65  if (_advection_physics->checkBlockRestrictionIdentical(
66  physics->name(), physics->blocks(), /*error_if_not_identical=*/false))
67  {
68  return physics;
69  }
70  }
71  mooseError("No coupled flow Physics found of type derived from 'WCNSFVFlowPhysicsBase'. Use the "
72  "'coupled_flow_physics' parameter to give the name of the desired "
73  "WCNSFVFlowPhysicsBase-derived Physics to couple with");
74 }
PhysicsBase::getParam
const T & getParam(const std::string &name) const
mooseError
void mooseError(Args &&... args)
PhysicsBase::getCoupledPhysics
const T * getCoupledPhysics(const PhysicsName &phys_name, const bool allow_fail=false) const
WCNSFVFlowPhysicsBase
Base class for Physics which create the Navier Stokes flow equations.
Definition: WCNSFVFlowPhysicsBase.h:29
PhysicsBase::checkBlockRestrictionIdentical
bool checkBlockRestrictionIdentical(const std::string &object_name, const std::vector< SubdomainName > &blocks, const bool error_if_not_identical=true) const
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
WCNSFVCoupledAdvectionPhysicsHelper::_advection_physics
const NavierStokesPhysicsBase * _advection_physics
The Physics class using this helper.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:41

◆ getCoupledTurbulencePhysics()

const WCNSFVTurbulencePhysics * WCNSFVCoupledAdvectionPhysicsHelper::getCoupledTurbulencePhysics ( ) const
inherited

Definition at line 77 of file WCNSFVCoupledAdvectionPhysicsHelper.C.

Referenced by WCNSFVFluidHeatTransferPhysicsBase::actOnAdditionalTasks().

78 {
79  // User passed it, just use that
80  if (_advection_physics->isParamValid("coupled_turbulence_physics"))
81  return _advection_physics->getCoupledPhysics<WCNSFVTurbulencePhysics>(
82  _advection_physics->getParam<PhysicsName>("coupled_turbulence_physics"));
83  // Look for any physics of the right type, and check the block restriction
84  else
85  {
86  const auto all_turbulence_physics =
87  _advection_physics->getCoupledPhysics<const WCNSFVTurbulencePhysics>(true);
88  for (const auto physics : all_turbulence_physics)
89  if (_advection_physics->checkBlockRestrictionIdentical(
90  physics->name(), physics->blocks(), /*error_if_not_identical=*/false))
91  return physics;
92  }
93  // Did not find one
94  return nullptr;
95 }
WCNSFVTurbulencePhysics
Creates all the objects needed to add a turbulence model to an incompressible / weakly-compressible N...
Definition: WCNSFVTurbulencePhysics.h:23
PhysicsBase::getParam
const T & getParam(const std::string &name) const
PhysicsBase::getCoupledPhysics
const T * getCoupledPhysics(const PhysicsName &phys_name, const bool allow_fail=false) const
PhysicsBase::checkBlockRestrictionIdentical
bool checkBlockRestrictionIdentical(const std::string &object_name, const std::vector< SubdomainName > &blocks, const bool error_if_not_identical=true) const
PhysicsBase::isParamValid
bool isParamValid(const std::string &name) const
WCNSFVCoupledAdvectionPhysicsHelper::_advection_physics
const NavierStokesPhysicsBase * _advection_physics
The Physics class using this helper.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:41

◆ getFluidTemperatureName()

const VariableName& WCNSFVFluidHeatTransferPhysicsBase::getFluidTemperatureName ( ) const
inlineinherited

Get the name of the fluid temperature variable.

Definition at line 36 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addPhaseChangeEnergySource().

36 { return _fluid_temperature_name; }
WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
VariableName _fluid_temperature_name
Fluid temperature name.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:96

◆ getNumberAlgebraicGhostingLayersNeeded()

unsigned short WCNSFVFluidHeatTransferPhysicsBase::getNumberAlgebraicGhostingLayersNeeded ( ) const
overrideprotectedvirtualinherited

Return the number of ghosting layers needed.

Implements NavierStokesPhysicsBase.

Definition at line 316 of file WCNSFVFluidHeatTransferPhysicsBase.C.

317 {
318  unsigned short necessary_layers = getParam<unsigned short>("ghost_layers");
319  necessary_layers =
320  std::max(necessary_layers, _flow_equations_physics->getNumberAlgebraicGhostingLayersNeeded());
321  if (getParam<MooseEnum>("energy_face_interpolation") == "skewness-corrected")
322  necessary_layers = std::max(necessary_layers, (unsigned short)3);
323 
324  return necessary_layers;
325 }
WCNSFVFlowPhysicsBase::getNumberAlgebraicGhostingLayersNeeded
unsigned short getNumberAlgebraicGhostingLayersNeeded() const override
Return the number of algebraic ghosting layers needed.
Definition: WCNSFVFlowPhysicsBase.C:415
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43

◆ getPorosityFunctorName()

MooseFunctorName WCNSFVCoupledAdvectionPhysicsHelper::getPorosityFunctorName ( bool  smoothed) const
inherited

Return the porosity functor name.

It is important to forward to the Physics so we do not get the smoothing status wrong

Definition at line 47 of file WCNSFVCoupledAdvectionPhysicsHelper.C.

48 {
49  return _flow_equations_physics->getPorosityFunctorName(smoothed);
50 }
WCNSFVFlowPhysicsBase::getPorosityFunctorName
MooseFunctorName getPorosityFunctorName(const bool smoothed) const
Definition: WCNSFVFlowPhysicsBase.C:459
WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
const WCNSFVFlowPhysicsBase * _flow_equations_physics
Flow physics.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:43

◆ getSpecificEnthalpyName()

MooseFunctorName WCNSFVFluidHeatTransferPhysicsBase::getSpecificEnthalpyName ( ) const
inlineinherited

Definition at line 40 of file WCNSFVFluidHeatTransferPhysicsBase.h.

40 { return NS::specific_enthalpy; }
NS::specific_enthalpy
static const std::string specific_enthalpy
Definition: NS.h:68

◆ getSpecificHeatName()

const MooseFunctorName& WCNSFVFluidHeatTransferPhysicsBase::getSpecificHeatName ( ) const
inlineinherited

Get the name of the specific heat material property.

Definition at line 39 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSFVTurbulencePhysics::addAuxiliaryKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVTurbulencePhysics::addMaterials(), PNSFVSolidHeatTransferPhysics::checkFluidAndSolidHeatTransferPhysicsParameters(), WCNSFVFluidHeatTransferPhysicsBase::defineKOverCpFunctors(), WCNSFVTwoPhaseMixturePhysics::WCNSFVTwoPhaseMixturePhysics(), and WCNSLinearFVTwoPhaseMixturePhysics::WCNSLinearFVTwoPhaseMixturePhysics().

39 { return _specific_heat_name; }
WCNSFVFluidHeatTransferPhysicsBase::_specific_heat_name
MooseFunctorName _specific_heat_name
Name of the specific heat material property.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:98

◆ getThermalConductivityName()

const std::vector<MooseFunctorName>& WCNSFVFluidHeatTransferPhysicsBase::getThermalConductivityName ( ) const
inlineinherited

Definition at line 41 of file WCNSFVFluidHeatTransferPhysicsBase.h.

42  {
43  return _thermal_conductivity_name;
44  }
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
std::vector< MooseFunctorName > _thermal_conductivity_name
Name of the thermal conductivity functor for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:102

◆ hasEnergyEquation()

bool WCNSFVFluidHeatTransferPhysicsBase::hasEnergyEquation ( ) const
inlineinherited

Whether the physics is actually creating the heat equation.

Definition at line 58 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVTwoPhaseMixturePhysics::addFVKernels(), WCNSFVTwoPhaseMixturePhysics::addFVKernels(), WCNSFVTurbulencePhysics::retrieveCoupledPhysics(), WCNSFVTwoPhaseMixturePhysics::WCNSFVTwoPhaseMixturePhysics(), and WCNSLinearFVTwoPhaseMixturePhysics::WCNSLinearFVTwoPhaseMixturePhysics().

58 { return _has_energy_equation; }
WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
const bool _has_energy_equation
A boolean to help compatibility with the old Modules/NavierStokesFV syntax.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:90

◆ processThermalConductivity()

bool WCNSFVFluidHeatTransferPhysicsBase::processThermalConductivity ( )
protectedinherited

Process thermal conductivity (multiple functor input options are available).

Return true if we have vector thermal conductivity and false if scalar

Definition at line 166 of file WCNSFVFluidHeatTransferPhysicsBase.C.

Referenced by addEnergyHeatConductionKernels(), and WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels().

167 {
168  checkBlockwiseConsistency<MooseFunctorName>("thermal_conductivity_blocks",
169  {"thermal_conductivity"});
170  bool have_scalar = false;
171  bool have_vector = false;
172 
173  for (unsigned int i = 0; i < _thermal_conductivity_name.size(); ++i)
174  {
175  // First, check if the name is just a number (only in case of isotropic conduction)
176  if (MooseUtils::parsesToReal(_thermal_conductivity_name[i]))
177  have_scalar = true;
178  // Now we determine what kind of functor we are dealing with
179  else
180  {
181  if (getProblem().hasFunctorWithType<ADReal>(_thermal_conductivity_name[i],
182  /*thread_id=*/0) ||
183  getProblem().hasFunctorWithType<Real>(_thermal_conductivity_name[i],
184  /*thread_id=*/0))
185  have_scalar = true;
186  else
187  {
188  if (getProblem().hasFunctorWithType<ADRealVectorValue>(_thermal_conductivity_name[i],
189  /*thread_id=*/0))
190  have_vector = true;
191  else
192  paramError("thermal_conductivity",
193  "We only allow functor of type Real/ADReal or ADRealVectorValue for thermal "
194  "conductivity! Functor '" +
195  _thermal_conductivity_name[i] + "' is not of the requested type.");
196  }
197  }
198  }
199 
200  if (have_vector && !_porous_medium_treatment)
201  paramError("thermal_conductivity", "Cannot use anisotropic diffusion with non-porous flows!");
202 
203  if (have_vector == have_scalar)
204  paramError("thermal_conductivity",
205  "The entries on thermal conductivity shall either be scalars of vectors, mixing "
206  "them is not supported!");
207  return have_vector;
208 }
PhysicsBase::paramError
void paramError(const std::string &param, Args... args) const
ADReal
DualNumber< Real, DNDerivativeType, true > ADReal
PhysicsBase::getProblem
virtual FEProblemBase & getProblem()
FEProblemBase::hasFunctorWithType
bool hasFunctorWithType(const std::string &name, const THREAD_ID tid) const
WCNSFVCoupledAdvectionPhysicsHelper::_porous_medium_treatment
const bool _porous_medium_treatment
Switch to show if porous medium treatment is requested or not.
Definition: WCNSFVCoupledAdvectionPhysicsHelper.h:51
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
std::vector< MooseFunctorName > _thermal_conductivity_name
Name of the thermal conductivity functor for each block-group.
Definition: WCNSFVFluidHeatTransferPhysicsBase.h:102
MooseUtils::parsesToReal
bool parsesToReal(const std::string &input, Real *parsed_real)

◆ usingNavierStokesFVSyntax()

bool NavierStokesPhysicsBase::usingNavierStokesFVSyntax ( ) const
inlineprotectedinherited

Detects if we are using the new Physics syntax or the old NavierStokesFV action.

Definition at line 32 of file NavierStokesPhysicsBase.h.

33  {
34  return (parameters().get<std::string>("registered_identifier") == "Modules/NavierStokesFV");
35  }
PhysicsBase::parameters
const InputParameters & parameters() const

◆ validParams()

InputParameters WCNSFVFluidHeatTransferPhysics::validParams ( )
static

Definition at line 19 of file WCNSFVFluidHeatTransferPhysics.C.

20 {
21  InputParameters params = WCNSFVFluidHeatTransferPhysicsBase::validParams();
22  params.transferParam<MooseEnum>(NSFVBase::validParams(), "energy_face_interpolation");
23  params.transferParam<Real>(NSFVBase::validParams(), "energy_scaling");
24  params.addParam<bool>(
25  "check_bc_compatibility",
26  true,
27  "Whether to check for known incompatibility between boundary conditions for "
28  "the heat transport equation physics and other physics");
29  params.addParamNamesToGroup("check_bc_compatibility", "Advanced");
30 
31  params.addParamNamesToGroup("energy_face_interpolation energy_scaling", "Numerical scheme");
32  return params;
33 }
NSFVBase::validParams
static InputParameters validParams()
Definition: NSFVBase.C:371
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::transferParam
void transferParam(const InputParameters &source_param, const std::string &name, const std::string &new_name="", const std::string &new_description="")
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

Member Data Documentation

◆ _advection_physics

const NavierStokesPhysicsBase* WCNSFVCoupledAdvectionPhysicsHelper::_advection_physics
protectedinherited

The Physics class using this helper.

Definition at line 41 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by WCNSFVCoupledAdvectionPhysicsHelper::getCoupledFlowPhysics(), and WCNSFVCoupledAdvectionPhysicsHelper::getCoupledTurbulencePhysics().

◆ _ambient_convection_alpha

std::vector<MooseFunctorName> WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_alpha
protectedinherited

Name of the ambient convection heat transfer coefficients for each block-group.

Definition at line 107 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), and WCNSFVFluidHeatTransferPhysicsBase::getAmbientConvectionHTCs().

◆ _ambient_convection_blocks

std::vector<std::vector<SubdomainName> > WCNSFVFluidHeatTransferPhysicsBase::_ambient_convection_blocks
protectedinherited

Vector of subdomain groups where we want to have different ambient convection.

Definition at line 105 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), and WCNSFVFluidHeatTransferPhysicsBase::getAmbientConvectionBlocks().

◆ _ambient_temperature

std::vector<MooseFunctorName> WCNSFVFluidHeatTransferPhysicsBase::_ambient_temperature
protectedinherited

Name of the solid domain temperature for each block-group.

Definition at line 109 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyAmbientConvection(), and WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection().

◆ _compressibility

const MooseEnum WCNSFVCoupledAdvectionPhysicsHelper::_compressibility
protectedinherited

Compressibility type, can be compressible, incompressible or weakly-compressible.

Definition at line 48 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by addEnergyTimeKernels().

◆ _define_variables

bool NavierStokesPhysicsBase::_define_variables
protectedinherited

Whether to define variables if they do not exist.

Definition at line 44 of file NavierStokesPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryVariables(), WCNSFVTurbulencePhysics::addAuxiliaryVariables(), WCNSFVTurbulencePhysics::addInitialConditions(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), WCNSFVScalarTransportPhysicsBase::addInitialConditions(), WCNSFVFlowPhysicsBase::addInitialConditions(), addSolverVariables(), WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables(), WCNSFVFlowPhysics::addSolverVariables(), WCNSLinearFVFlowPhysics::addSolverVariables(), WCNSFVTurbulencePhysics::addSolverVariables(), and WCNSFVFlowPhysicsBase::WCNSFVFlowPhysicsBase().

◆ _density_name

const MooseFunctorName WCNSFVCoupledAdvectionPhysicsHelper::_density_name
protectedinherited

Name of the density material property.

Definition at line 59 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by addEnergyInletBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyTimeKernels(), addEnergyTimeKernels(), addEnergyWallBC(), WCNSFVTurbulencePhysics::addFlowTurbulenceKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), addMaterials(), WCNSFVTurbulencePhysics::addMaterials(), WCNSFVScalarTransportPhysics::addScalarInletBC(), and WCNSFVCoupledAdvectionPhysicsHelper::densityName().

◆ _dynamic_viscosity_name

const MooseFunctorName WCNSFVCoupledAdvectionPhysicsHelper::_dynamic_viscosity_name
protectedinherited

Name of the dynamic viscosity material property.

Definition at line 61 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by addEnergyWallBC(), WCNSFVTurbulencePhysics::addMaterials(), and WCNSFVCoupledAdvectionPhysicsHelper::dynamicViscosityName().

◆ _energy_inlet_functors

std::vector<MooseFunctorName> WCNSFVFluidHeatTransferPhysicsBase::_energy_inlet_functors
protectedinherited

Functors describing the inlet boundary values. See energy_inlet_types for what the functors actually represent.

Definition at line 114 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), and addEnergyInletBC().

◆ _energy_inlet_types

MultiMooseEnum WCNSFVFluidHeatTransferPhysicsBase::_energy_inlet_types
protectedinherited

Energy inlet boundary types.

Definition at line 112 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), and addEnergyInletBC().

◆ _energy_wall_functors

std::vector<MooseFunctorName> WCNSFVFluidHeatTransferPhysicsBase::_energy_wall_functors
protectedinherited

Functors describing the wall boundary values. See energy_wall_types for what the functors actually represent.

Definition at line 118 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), and addEnergyWallBC().

◆ _energy_wall_types

MultiMooseEnum WCNSFVFluidHeatTransferPhysicsBase::_energy_wall_types
protectedinherited

Energy wall boundary types.

Definition at line 116 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), and addEnergyWallBC().

◆ _flow_equations_physics

const WCNSFVFlowPhysicsBase* WCNSFVCoupledAdvectionPhysicsHelper::_flow_equations_physics
protectedinherited

Flow physics.

Definition at line 43 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addAdvectionSlipTerm(), WCNSFVTurbulencePhysics::addAuxiliaryKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAdvectionKernels(), addEnergyAdvectionKernels(), addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), addEnergyInletBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyOutletBC(), addEnergySeparatorBC(), addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), addEnergyWallBC(), WCNSFVTurbulencePhysics::addFlowTurbulenceKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVTurbulencePhysics::addFVBCs(), WCNSLinearFVTwoPhaseMixturePhysics::addFVKernels(), WCNSFVTwoPhaseMixturePhysics::addFVKernels(), WCNSFVTurbulencePhysics::addInitialConditions(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), WCNSFVTurbulencePhysics::addKEpsilonAdvection(), WCNSFVTurbulencePhysics::addKEpsilonDiffusion(), WCNSFVTurbulencePhysics::addKEpsilonSink(), addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVTwoPhaseMixturePhysics::addMaterials(), WCNSFVTwoPhaseMixturePhysics::addMaterials(), WCNSFVTurbulencePhysics::addMaterials(), WCNSLinearFVTwoPhaseMixturePhysics::addPhaseDriftFluxTerm(), WCNSFVTwoPhaseMixturePhysics::addPhaseDriftFluxTerm(), WCNSFVScalarTransportPhysics::addScalarAdvectionKernels(), WCNSLinearFVScalarTransportPhysics::addScalarAdvectionKernels(), WCNSLinearFVScalarTransportPhysics::addScalarInletBC(), WCNSFVScalarTransportPhysics::addScalarInletBC(), WCNSLinearFVScalarTransportPhysics::addScalarOutletBC(), WCNSLinearFVTwoPhaseMixturePhysics::checkIntegrity(), WCNSFVTurbulencePhysics::getNumberAlgebraicGhostingLayersNeeded(), WCNSFVFluidHeatTransferPhysicsBase::getNumberAlgebraicGhostingLayersNeeded(), WCNSFVScalarTransportPhysicsBase::getNumberAlgebraicGhostingLayersNeeded(), WCNSFVCoupledAdvectionPhysicsHelper::getPorosityFunctorName(), WCNSFVTurbulencePhysics::retrieveCoupledPhysics(), WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase(), WCNSFVTwoPhaseMixturePhysics::WCNSFVTwoPhaseMixturePhysics(), WCNSLinearFVScalarTransportPhysics::WCNSLinearFVScalarTransportPhysics(), and WCNSLinearFVTwoPhaseMixturePhysics::WCNSLinearFVTwoPhaseMixturePhysics().

◆ _fluid_enthalpy_name

const VariableName WCNSFVFluidHeatTransferPhysicsBase::_fluid_enthalpy_name
protectedinherited

Name of the fluid specific enthalpy.

Definition at line 94 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyAdvectionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAdvectionKernels(), addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyExternalHeatSource(), addEnergyExternalHeatSource(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), addEnergyInletBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyOutletBC(), addEnergySeparatorBC(), addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), addEnergyWallBC(), WCNSFVFluidHeatTransferPhysicsBase::addFVKernels(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables(), addSolverVariables(), and WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase().

◆ _fluid_temperature_name

VariableName WCNSFVFluidHeatTransferPhysicsBase::_fluid_temperature_name
protectedinherited

Fluid temperature name.

Definition at line 96 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryKernels(), WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryVariables(), addEnergyAdvectionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAdvectionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyExternalHeatSource(), addEnergyExternalHeatSource(), addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), addEnergyInletBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyOutletBC(), addEnergySeparatorBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyTimeKernels(), addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), addEnergyWallBC(), WCNSFVFluidHeatTransferPhysicsBase::addFVKernels(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), addSolverVariables(), WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables(), WCNSFVFluidHeatTransferPhysicsBase::getFluidTemperatureName(), and WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase().

◆ _has_energy_equation

const bool WCNSFVFluidHeatTransferPhysicsBase::_has_energy_equation
protectedinherited

A boolean to help compatibility with the old Modules/NavierStokesFV syntax.

Definition at line 90 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSFVFluidHeatTransferPhysicsBase::addFVBCs(), WCNSFVFluidHeatTransferPhysicsBase::addFVKernels(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables(), addSolverVariables(), WCNSFVFluidHeatTransferPhysicsBase::hasEnergyEquation(), and WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase().

◆ _porous_medium_treatment

const bool WCNSFVCoupledAdvectionPhysicsHelper::_porous_medium_treatment
protectedinherited

Switch to show if porous medium treatment is requested or not.

Definition at line 51 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by addEnergyAdvectionKernels(), addEnergyHeatConductionKernels(), addEnergyTimeKernels(), WCNSFVTurbulencePhysics::addFlowTurbulenceKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVScalarTransportPhysics::addScalarAdvectionKernels(), WCNSFVFluidHeatTransferPhysicsBase::processThermalConductivity(), WCNSLinearFVFluidHeatTransferPhysics::WCNSLinearFVFluidHeatTransferPhysics(), and WCNSLinearFVScalarTransportPhysics::WCNSLinearFVScalarTransportPhysics().

◆ _pressure_name

const NonlinearVariableName WCNSFVCoupledAdvectionPhysicsHelper::_pressure_name
protectedinherited

Pressure name.

Definition at line 56 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

◆ _solve_for_enthalpy

const bool WCNSFVFluidHeatTransferPhysicsBase::_solve_for_enthalpy
protectedinherited

User-selected option to solve for enthalpy.

Definition at line 92 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryKernels(), WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryVariables(), addEnergyAdvectionKernels(), addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyExternalHeatSource(), addEnergyExternalHeatSource(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC(), addEnergyInletBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyOutletBC(), addEnergySeparatorBC(), addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyTimeKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), addEnergyWallBC(), WCNSFVFluidHeatTransferPhysicsBase::addFVKernels(), WCNSFVFluidHeatTransferPhysicsBase::addInitialConditions(), addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables(), addSolverVariables(), and WCNSFVFluidHeatTransferPhysicsBase::WCNSFVFluidHeatTransferPhysicsBase().

◆ _specific_heat_name

MooseFunctorName WCNSFVFluidHeatTransferPhysicsBase::_specific_heat_name
protectedinherited

Name of the specific heat material property.

Definition at line 98 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by WCNSLinearFVFluidHeatTransferPhysics::addEnergyAdvectionKernels(), addEnergyInletBC(), addEnergyWallBC(), addMaterials(), and WCNSFVFluidHeatTransferPhysicsBase::getSpecificHeatName().

◆ _thermal_conductivity_blocks

std::vector<std::vector<SubdomainName> > WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_blocks
protectedinherited

Vector of subdomain groups where we want to have different thermal conduction.

Definition at line 100 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyHeatConductionKernels(), and WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels().

◆ _thermal_conductivity_name

std::vector<MooseFunctorName> WCNSFVFluidHeatTransferPhysicsBase::_thermal_conductivity_name
protectedinherited

Name of the thermal conductivity functor for each block-group.

Definition at line 102 of file WCNSFVFluidHeatTransferPhysicsBase.h.

Referenced by addEnergyHeatConductionKernels(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), addEnergyWallBC(), WCNSFVFluidHeatTransferPhysicsBase::defineKOverCpFunctors(), WCNSFVFluidHeatTransferPhysicsBase::getThermalConductivityName(), and WCNSFVFluidHeatTransferPhysicsBase::processThermalConductivity().

◆ _turbulence_physics

const WCNSFVTurbulencePhysics* WCNSFVCoupledAdvectionPhysicsHelper::_turbulence_physics
protectedinherited

Turbulence.

Definition at line 45 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by WCNSFVFluidHeatTransferPhysicsBase::actOnAdditionalTasks(), and addEnergyWallBC().

◆ _velocity_interpolation

const MooseEnum WCNSFVCoupledAdvectionPhysicsHelper::_velocity_interpolation
protectedinherited

The velocity / momentum face interpolation method for advecting other quantities.

Definition at line 64 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by addEnergyAdvectionKernels(), WCNSFVTurbulencePhysics::addKEpsilonAdvection(), and WCNSFVScalarTransportPhysics::addScalarAdvectionKernels().

◆ _velocity_names

const std::vector<std::string> WCNSFVCoupledAdvectionPhysicsHelper::_velocity_names
protectedinherited

Velocity names.

Definition at line 54 of file WCNSFVCoupledAdvectionPhysicsHelper.h.

Referenced by WCNSFVTurbulencePhysics::addAuxiliaryKernels(), addEnergyInletBC(), addEnergyWallBC(), WCNSFVTurbulencePhysics::addFlowTurbulenceKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVTurbulencePhysics::addFVBCs(), WCNSFVTurbulencePhysics::addKEpsilonSink(), WCNSFVTurbulencePhysics::addMaterials(), WCNSFVTurbulencePhysics::addScalarAdvectionTurbulenceKernels(), and WCNSFVScalarTransportPhysics::addScalarInletBC().

The documentation for this class was generated from the following files:
Generated on Tue Nov 4 2025 20:27:22 for https://mooseframework.inl.gov by   doxygen 1.8.14