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_variable");                                     \
  registerMooseAction(app_name, derived_name, "add_ic");                                           \
  registerMooseAction(app_name, derived_name, "add_fv_kernel");                                    \
  registerMooseAction(app_name, derived_name, "add_fv_bc");                                        \
  registerMooseAction(app_name, derived_name, "add_material")

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;
  void addMaterials() 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();

  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;
};