WCNSLinearFVFluidHeatTransferPhysics.C

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
 
#include "WCNSLinearFVFluidHeatTransferPhysics.h"
#include "WCNSFVFlowPhysics.h"
#include "PINSFVEnergyAnisotropicDiffusion.h"
#include "NSFVBase.h"
 
registerNavierStokesPhysicsBaseTasks("NavierStokesApp", WCNSLinearFVFluidHeatTransferPhysics);
registerWCNSFVFluidHeatTransferPhysicsBaseTasks("NavierStokesApp",
                                                WCNSLinearFVFluidHeatTransferPhysics);
registerMooseAction("NavierStokesApp", WCNSLinearFVFluidHeatTransferPhysics, "add_aux_variable");
registerMooseAction("NavierStokesApp", WCNSLinearFVFluidHeatTransferPhysics, "add_aux_kernel");
 
InputParameters
WCNSLinearFVFluidHeatTransferPhysics::validParams()
{
  InputParameters params = WCNSFVFluidHeatTransferPhysicsBase::validParams();
  params.addParam<bool>(
      "use_nonorthogonal_correction",
      true,
      "Whether to use a non-orthogonal correction. This can potentially slow down convergence "
      ", but reduces numerical dispersion on non-orthogonal meshes. Can be safely turned off on "
      "orthogonal meshes.");
  params.set<std::vector<SolverSystemName>>("system_names") = {"energy_system"};
 
  // We could split between discretization and solver here.
  params.addParamNamesToGroup("use_nonorthogonal_correction system_names", "Numerical scheme");
 
  // Not implemented
  params.suppressParameter<bool>("effective_conductivity");
  // Not needed
  params.suppressParameter<bool>("add_energy_equation");
  params.suppressParameter<MooseEnum>("preconditioning");
 
  return params;
}
 
WCNSLinearFVFluidHeatTransferPhysics::WCNSLinearFVFluidHeatTransferPhysics(
    const InputParameters & parameters)
  : WCNSFVFluidHeatTransferPhysicsBase(parameters)
{
  if (_porous_medium_treatment)
    paramError("porous_medium_treatment", "Porous media not supported at this time");
  checkSecondParamSetOnlyIfFirstOneTrue("solve_for_enthalpy", NS::fluid);
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addSolverVariables()
{
  // For compatibility with Modules/NavierStokesFV syntax
  if (!_has_energy_equation)
    return;
 
  const auto variable_name = _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
 
  // Dont add if the user already defined the variable
  if (!shouldCreateVariable(variable_name, _blocks, /*error if aux*/ true))
    reportPotentiallyMissedParameters({"system_names"}, "MooseLinearVariableFVReal");
  else if (_define_variables)
  {
    const auto var_type = "MooseLinearVariableFVReal";
    auto params = getFactory().getValidParams(var_type);
    assignBlocks(params, _blocks);
    params.set<SolverSystemName>("solver_sys") = getSolverSystem(variable_name);
    getProblem().addVariable(var_type, variable_name, params);
  }
  else
    paramError(_solve_for_enthalpy ? "solve_for_enthalpy" : "fluid_temperature_variable",
               "Variable (" + variable_name +
                   ") supplied to the WCNSLinearFVFluidHeatTransferPhysics does not exist!");
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyTimeKernels()
{
  std::string kernel_type = "LinearFVTimeDerivative";
  std::string kernel_name = prefix() + "ins_energy_time";
 
  InputParameters params = getFactory().getValidParams(kernel_type);
  params.set<LinearVariableName>("variable") =
      _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
  assignBlocks(params, _blocks);
  if (!_solve_for_enthalpy)
    params.set<MooseFunctorName>("factor") = "rho_cp";
  else
    params.set<MooseFunctorName>("factor") = _density_name;
 
  getProblem().addLinearFVKernel(kernel_type, kernel_name, params);
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyAdvectionKernels()
{
  std::string kernel_type = "LinearFVEnergyAdvection";
  std::string kernel_name = prefix() + "ins_energy_advection";
 
  InputParameters params = getFactory().getValidParams(kernel_type);
  assignBlocks(params, _blocks);
  if (!getParam<bool>("solve_for_enthalpy"))
  {
    params.set<LinearVariableName>("variable") = _fluid_temperature_name;
    params.set<MooseEnum>("advected_quantity") = "temperature";
    if (!MooseUtils::isFloat(_specific_heat_name))
      paramError("specific_heat", "Must be a Real number. Functors not supported at this time");
    params.set<Real>("cp") = std::atof(_specific_heat_name.c_str());
  }
  else
    params.set<LinearVariableName>("variable") = _fluid_enthalpy_name;
  params.set<UserObjectName>("rhie_chow_user_object") = _flow_equations_physics->rhieChowUOName();
  params.set<MooseEnum>("advected_interp_method") =
      getParam<MooseEnum>("energy_advection_interpolation");
 
  getProblem().addLinearFVKernel(kernel_type, kernel_name, params);
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels()
{
  const auto num_blocks = _thermal_conductivity_blocks.size();
  const auto num_used_blocks = num_blocks ? num_blocks : 1;
 
  for (const auto block_i : make_range(num_used_blocks))
  {
    std::string block_name = "";
    if (num_blocks)
      block_name = Moose::stringify(_thermal_conductivity_blocks[block_i]);
    else
      block_name = "all";
 
    const std::string kernel_type = "LinearFVDiffusion";
    InputParameters params = getFactory().getValidParams(kernel_type);
    if (!_solve_for_enthalpy)
    {
      params.set<LinearVariableName>("variable") = _fluid_temperature_name;
      params.set<MooseFunctorName>("diffusion_coeff") =
          _thermal_conductivity_name[block_i] + (_has_turbulence_model ? "_plus_kt" : "");
    }
    else
    {
      params.set<LinearVariableName>("variable") = _fluid_enthalpy_name;
      const auto th_cond_name =
          _thermal_conductivity_name[block_i] + (_has_turbulence_model ? "_plus_kt" : "");
      params.set<MooseFunctorName>("diffusion_coeff") = th_cond_name + "_by_cp";
    }
    std::vector<SubdomainName> block_names =
        num_blocks ? _thermal_conductivity_blocks[block_i] : _blocks;
    assignBlocks(params, block_names);
    // NOTE: vector conductivities not supported at this time
    bool has_vector = processThermalConductivity();
    if (has_vector)
      paramError("thermal_conductivity",
                 "Vector thermal conductivities not currently supported with the linear finite "
                 "volume discretization");
 
    params.set<bool>("use_nonorthogonal_correction") =
        getParam<bool>("use_nonorthogonal_correction");
 
    getProblem().addLinearFVKernel(
        kernel_type, prefix() + "ins_energy_diffusion_" + block_name, params);
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection()
{
  unsigned int num_convection_blocks = _ambient_convection_blocks.size();
  unsigned int num_used_blocks = num_convection_blocks ? num_convection_blocks : 1;
 
  const std::string kernel_type = "LinearFVVolumetricHeatTransfer";
  InputParameters params = getFactory().getValidParams(kernel_type);
  params.set<LinearVariableName>("variable") =
      _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
  params.set<VariableName>(NS::T_fluid) = _fluid_temperature_name;
  params.set<bool>("is_solid") = false;
 
  for (unsigned int block_i = 0; block_i < num_used_blocks; ++block_i)
  {
    std::string block_name = "";
    if (num_convection_blocks)
    {
      params.set<std::vector<SubdomainName>>("block") = _ambient_convection_blocks[block_i];
      block_name = Moose::stringify(_ambient_convection_blocks[block_i]);
    }
    else
    {
      assignBlocks(params, _blocks);
      block_name = std::to_string(block_i);
    }
 
    params.set<MooseFunctorName>("h_solid_fluid") = _ambient_convection_alpha[block_i];
    params.set<VariableName>(NS::T_solid) = _ambient_temperature[block_i];
 
    getProblem().addLinearFVKernel(
        kernel_type, prefix() + "ambient_convection_" + block_name, params);
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyExternalHeatSource()
{
  const std::string kernel_type = "LinearFVSource";
  InputParameters params = getFactory().getValidParams(kernel_type);
  params.set<LinearVariableName>("variable") =
      _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
  assignBlocks(params, _blocks);
  params.set<MooseFunctorName>("source_density") =
      getParam<MooseFunctorName>("external_heat_source");
  params.set<MooseFunctorName>("scaling_factor") =
      std::to_string(getParam<Real>("external_heat_source_coeff"));
 
  getProblem().addLinearFVKernel(kernel_type, prefix() + "external_heat_source", params);
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryVariables()
{
  if (_solve_for_enthalpy)
  {
    // Dont add if the user already defined the variable
    if (variableExists(_fluid_temperature_name,
                       /*error_if_aux=*/false))
      checkBlockRestrictionIdentical(_fluid_temperature_name,
                                     getProblem().getVariable(0, _fluid_temperature_name).blocks());
    else if (_define_variables)
    {
      const auto var_type = "MooseLinearVariableFVReal";
      auto params = getFactory().getValidParams(var_type);
      assignBlocks(params, _blocks);
      getProblem().addAuxVariable(var_type, _fluid_temperature_name, params);
    }
    else
      paramError("fluid_temperature_variable",
                 "Variable (" + _fluid_temperature_name +
                     ") supplied to the WCNSLinearFVFluidHeatTransferPhysics does not exist!");
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addAuxiliaryKernels()
{
  if (_solve_for_enthalpy)
  {
    // Keep temperature updated
    const std::string kernel_type = "FunctorAux";
    InputParameters params = getFactory().getValidParams(kernel_type);
    params.set<AuxVariableName>("variable") = _fluid_temperature_name;
    assignBlocks(params, _blocks);
    params.set<MooseFunctorName>("functor") = "T_from_p_h";
    params.set<ExecFlagEnum>("execute_on") = {EXEC_NONLINEAR};
    getProblem().addAuxKernel(kernel_type, prefix() + "update_temperature", params);
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyInletBC()
{
  const auto & inlet_boundaries = _flow_equations_physics->getInletBoundaries();
  // These are parameter errors for now. If Components add boundaries to Physics, the error
  // may not be due to parameters anymore.
  if (inlet_boundaries.size() != _energy_inlet_types.size())
    paramError("energy_inlet_types",
               "Energy inlet types (size " + std::to_string(_energy_inlet_types.size()) +
                   ") should be the same size as inlet_boundaries (size " +
                   std::to_string(inlet_boundaries.size()) + ")");
  if (inlet_boundaries.size() != _energy_inlet_functors.size())
    paramError("energy_inlet_functors",
               "Energy inlet functors (size " + std::to_string(_energy_inlet_functors.size()) +
                   ") should be the same size as inlet_boundaries (size " +
                   std::to_string(inlet_boundaries.size()) + ")");
 
  for (const auto bc_ind : index_range(_energy_inlet_types))
  {
    if (_energy_inlet_types[bc_ind] == "fixed-temperature")
    {
      const std::string bc_type = "LinearFVAdvectionDiffusionFunctorDirichletBC";
      InputParameters params = getFactory().getValidParams(bc_type);
      params.set<LinearVariableName>("variable") = _fluid_temperature_name;
      params.set<MooseFunctorName>("functor") = _energy_inlet_functors[bc_ind];
      params.set<std::vector<BoundaryName>>("boundary") = {inlet_boundaries[bc_ind]};
 
      getProblem().addLinearFVBC(
          bc_type, _fluid_temperature_name + "_" + inlet_boundaries[bc_ind], params);
 
      // Boundary condition on temperature must be forwarded to enthalpy
      if (_solve_for_enthalpy)
      {
        params.set<LinearVariableName>("variable") = _fluid_enthalpy_name;
        params.set<MooseFunctorName>("functor") = "h_from_p_T";
        getProblem().addLinearFVBC(
            bc_type, _fluid_enthalpy_name + "_" + inlet_boundaries[bc_ind], params);
      }
    }
    else if (_energy_inlet_types[bc_ind] == "heatflux")
      paramError("energy_inlet_types", "Heat flux inlet boundary conditions not yet supported");
    else if (_energy_inlet_types[bc_ind] == "flux-mass" ||
             _energy_inlet_types[bc_ind] == "flux-velocity")
      paramError("energy_inlet_types", "Flux inlet boundary conditions not yet supported");
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC()
{
  const auto & wall_boundaries = isParamSetByUser("energy_wall_boundaries")
                                     ? getParam<std::vector<BoundaryName>>("energy_wall_boundaries")
                                     : _flow_equations_physics->getWallBoundaries();
  if (wall_boundaries.size() != _energy_wall_types.size())
    paramError("energy_wall_types",
               "Energy wall types (size " + std::to_string(_energy_wall_types.size()) +
                   ") should be the same size as wall_boundaries (size " +
                   std::to_string(wall_boundaries.size()) + ")");
  if (wall_boundaries.size() != _energy_wall_functors.size())
    paramError("energy_wall_functors",
               "Energy wall functors (size " + std::to_string(_energy_wall_functors.size()) +
                   ") should be the same size as wall_boundaries (size " +
                   std::to_string(wall_boundaries.size()) + ")");
 
  for (unsigned int bc_ind = 0; bc_ind < _energy_wall_types.size(); ++bc_ind)
  {
    if (_energy_wall_types[bc_ind] == "fixed-temperature")
    {
      const std::string bc_type = "LinearFVAdvectionDiffusionFunctorDirichletBC";
      InputParameters params = getFactory().getValidParams(bc_type);
      params.set<LinearVariableName>("variable") = _fluid_temperature_name;
      params.set<MooseFunctorName>("functor") = _energy_wall_functors[bc_ind];
      params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
 
      getProblem().addLinearFVBC(
          bc_type, _fluid_temperature_name + "_" + wall_boundaries[bc_ind], params);
 
      // Boundary condition on temperature must be forwarded to enthalpy
      if (_solve_for_enthalpy)
      {
        params.set<LinearVariableName>("variable") = _fluid_enthalpy_name;
        params.set<MooseFunctorName>("functor") = "h_from_p_T";
        getProblem().addLinearFVBC(
            bc_type, _fluid_enthalpy_name + "_" + wall_boundaries[bc_ind], params);
      }
    }
    else if (_energy_wall_types[bc_ind] == "heatflux")
    {
      const std::string bc_type = "LinearFVAdvectionDiffusionFunctorNeumannBC";
      InputParameters params = getFactory().getValidParams(bc_type);
      const auto var_name = _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
      params.set<LinearVariableName>("variable") = var_name;
      params.set<MooseFunctorName>("functor") = _energy_wall_functors[bc_ind];
      params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
 
      getProblem().addLinearFVBC(
          bc_type, var_name + "_heatflux_" + wall_boundaries[bc_ind], params);
    }
    else if (_energy_wall_types[bc_ind] == "convection")
    {
      const std::string bc_type = "LinearFVConvectiveHeatTransferBC";
      InputParameters params = getFactory().getValidParams(bc_type);
      params.set<LinearVariableName>("variable") =
          _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
      params.set<MooseFunctorName>(NS::T_fluid) = _fluid_temperature_name;
      const auto Tinf_htc_functors =
          MooseUtils::split(_energy_wall_functors[bc_ind], /*delimiter=*/":", /*max_count=*/1);
      if (Tinf_htc_functors.size() != 2)
        paramError("energy_wall_functors",
                   "'convection' wall types require two functors specified as "
                   "<Tinf_functor>:<htc_functor>.");
      params.set<MooseFunctorName>(NS::T_solid) = Tinf_htc_functors[0];
      params.set<MooseFunctorName>("h") = Tinf_htc_functors[1];
      params.set<std::vector<BoundaryName>>("boundary") = {wall_boundaries[bc_ind]};
 
      getProblem().addLinearFVBC(
          bc_type,
          (_solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name) + "_" +
              wall_boundaries[bc_ind],
          params);
    }
    else
      paramError(
          "energy_wall_types", _energy_wall_types[bc_ind], " wall type is currently unsupported.");
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addEnergyOutletBC()
{
  const auto & outlet_boundaries = _flow_equations_physics->getOutletBoundaries();
  if (outlet_boundaries.empty())
    return;
 
  for (const auto & outlet_bdy : outlet_boundaries)
  {
    const std::string bc_type = "LinearFVAdvectionDiffusionOutflowBC";
    const auto variable_name = _solve_for_enthalpy ? _fluid_enthalpy_name : _fluid_temperature_name;
    InputParameters params = getFactory().getValidParams(bc_type);
    params.set<std::vector<BoundaryName>>("boundary") = {outlet_bdy};
    params.set<bool>("use_two_term_expansion") = getParam<bool>("energy_two_term_bc_expansion");
 
    params.set<LinearVariableName>("variable") = variable_name;
    getProblem().addLinearFVBC(bc_type, variable_name + "_" + outlet_bdy, params);
  }
}
 
void
WCNSLinearFVFluidHeatTransferPhysics::addMaterials()
{
  // For compatibility with Modules/NavierStokesFV syntax
  if (!_has_energy_equation)
    return;
 
  // Note that this material choice would not work for Newton-INSFV + solve_for_enthalpy
  const auto object_type = "LinearFVEnthalpyFunctorMaterial";
 
  InputParameters params = getFactory().getValidParams(object_type);
  assignBlocks(params, _blocks);
  params.set<MooseFunctorName>(NS::pressure) = _flow_equations_physics->getPressureName();
  params.set<MooseFunctorName>(NS::T_fluid) = _fluid_temperature_name;
  params.set<MooseFunctorName>(NS::specific_enthalpy) = _fluid_enthalpy_name;
  if (isParamValid(NS::fluid))
    params.set<UserObjectName>(NS::fluid) = getParam<UserObjectName>(NS::fluid);
 
  if (_solve_for_enthalpy)
  {
    if (!isParamValid(NS::fluid))
    {
      if (!getProblem().hasFunctor("h_from_p_T_functor", 0) ||
          !getProblem().hasFunctor("T_from_p_h_functor", 0))
        paramError(NS::fluid,
                   "Either 'fp' must be specified or the 'h_from_p_T_functor' and "
                   "'T_from_p_h_functor' must be defined outside the Physics");
      // Note: we could define those in the Physics if cp is constant
      params.set<MooseFunctorName>("h_from_p_T_functor") = "h_from_p_T_functor";
      params.set<MooseFunctorName>("T_from_p_h_functor") = "T_from_p_h_functor";
    }
  }
  // If we are solving for enthalpy, we need this to compute temperature from p & h
  // Else we don't really need it
  if (_solve_for_enthalpy)
    getProblem().addMaterial(object_type, prefix() + "enthalpy_material", params);
 
  if (_solve_for_enthalpy || _has_turbulence_model)
    WCNSFVFluidHeatTransferPhysicsBase::defineEffectiveThermalDiffusionCoeffFunctors(
        /*use ad*/ false);
}