WCNSFVFluidHeatTransferPhysicsBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "NavierStokesPhysicsBase.h"
#include "WCNSFVCoupledAdvectionPhysicsHelper.h"
#include "NS.h"
 
#define registerWCNSFVFluidHeatTransferPhysicsBaseTasks(app_name, derived_name)                    \
  registerMooseAction(app_name, derived_name, "get_turbulence_physics");                           \
  registerMooseAction(app_name, derived_name, "add_variables_physics");                            \
  registerMooseAction(app_name, derived_name, "add_ics_physics");                                  \
  registerMooseAction(app_name, derived_name, "add_fv_kernel");                                    \
  registerMooseAction(app_name, derived_name, "add_fv_bc");                                        \
  registerMooseAction(app_name, derived_name, "add_materials_physics")
 
class WCNSFVFluidHeatTransferPhysicsBase : public NavierStokesPhysicsBase,
                                           public WCNSFVCoupledAdvectionPhysicsHelper
{
public:
  static InputParameters validParams();
 
  WCNSFVFluidHeatTransferPhysicsBase(const InputParameters & parameters);
 
  const VariableName & getFluidTemperatureName() const { return _fluid_temperature_name; }
 
  const MooseFunctorName & getSpecificHeatName() const { return _specific_heat_name; }
  MooseFunctorName getSpecificEnthalpyName() const { return NS::specific_enthalpy; }
  const std::vector<MooseFunctorName> & getThermalConductivityName() const
  {
    return _thermal_conductivity_name;
  }
 
  const std::vector<std::vector<SubdomainName>> & getAmbientConvectionBlocks() const
  {
    return _ambient_convection_blocks;
  }
  const std::vector<MooseFunctorName> & getAmbientConvectionHTCs() const
  {
    return _ambient_convection_alpha;
  }
 
  bool hasEnergyEquation() const { return _has_energy_equation; }
 
protected:
  void actOnAdditionalTasks() override;
  void addInitialConditions() override;
  void addFVKernels() override;
  void addFVBCs() override;
 
  unsigned short getNumberAlgebraicGhostingLayersNeeded() const override;
 
  virtual void addEnergyTimeKernels() = 0;
  virtual void addEnergyHeatConductionKernels() = 0;
  virtual void addEnergyAdvectionKernels() = 0;
  virtual void addEnergyAmbientConvection() = 0;
  virtual void addEnergyExternalHeatSource() = 0;
 
  virtual void addEnergyInletBC() = 0;
  virtual void addEnergyWallBC() = 0;
  virtual void addEnergyOutletBC() = 0;
  virtual void addEnergySeparatorBC() = 0;
 
  bool processThermalConductivity();
  void defineEffectiveThermalDiffusionCoeffFunctors(const bool use_ad);
 
  const bool _has_energy_equation;
  const bool _solve_for_enthalpy;
  const VariableName _fluid_enthalpy_name;
  VariableName _fluid_temperature_name;
  MooseFunctorName _specific_heat_name;
  std::vector<std::vector<SubdomainName>> _thermal_conductivity_blocks;
  std::vector<MooseFunctorName> _thermal_conductivity_name;
 
  std::vector<std::vector<SubdomainName>> _ambient_convection_blocks;
  std::vector<MooseFunctorName> _ambient_convection_alpha;
  std::vector<MooseFunctorName> _ambient_temperature;
 
  MultiMooseEnum _energy_inlet_types;
  std::vector<MooseFunctorName> _energy_inlet_functors;
  MultiMooseEnum _energy_wall_types;
  std::vector<MooseFunctorName> _energy_wall_functors;
};