Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "CylindricalGapHeatFluxFunctorMaterial.h"
      11             : #include "HeatTransferModels.h"
      12             : 
      13             : registerMooseObject("HeatTransferApp", CylindricalGapHeatFluxFunctorMaterial);
      14             : registerMooseObject("HeatTransferApp", ADCylindricalGapHeatFluxFunctorMaterial);
      15             : 
      16             : template <bool is_ad>
      17             : InputParameters
      18          19 : CylindricalGapHeatFluxFunctorMaterialTempl<is_ad>::validParams()
      19             : {
      20          19 :   InputParameters params = FunctorMaterial::validParams();
      21             : 
      22          19 :   params.addClassDescription("Computes cylindrical gap heat flux due to conduction and radiation.");
      23             : 
      24          38 :   params.addRequiredParam<MooseFunctorName>("r_inner", "Inner surface radius functor [m]");
      25          38 :   params.addRequiredParam<MooseFunctorName>("r_outer", "Outer surface radius functor [m]");
      26          38 :   params.addRequiredParam<MooseFunctorName>("T_inner", "Inner surface temperature functor [K]");
      27          38 :   params.addRequiredParam<MooseFunctorName>("T_outer", "Outer surface temperature functor [K]");
      28          38 :   params.addRequiredParam<MooseFunctorName>("k_gap", "Gap thermal conductivity [W/(m-K)]");
      29          38 :   params.addRequiredParam<MooseFunctorName>("emissivity_inner", "Inner surface emissivity functor");
      30          38 :   params.addRequiredParam<MooseFunctorName>("emissivity_outer", "Outer surface emissivity functor");
      31             : 
      32          38 :   params.addParam<MooseFunctorName>(
      33             :       "conduction_heat_flux_name",
      34             :       "conduction_heat_flux",
      35             :       "Name to give the conduction heat flux functor material property");
      36          38 :   params.addParam<MooseFunctorName>(
      37             :       "radiation_heat_flux_name",
      38             :       "radiation_heat_flux",
      39             :       "Name to give the radiation heat flux functor material property");
      40          38 :   params.addParam<MooseFunctorName>("total_heat_flux_name",
      41             :                                     "total_heat_flux",
      42             :                                     "Name to give the total heat flux functor material property");
      43             : 
      44          19 :   return params;
      45           0 : }
      46             : 
      47             : template <bool is_ad>
      48          10 : CylindricalGapHeatFluxFunctorMaterialTempl<is_ad>::CylindricalGapHeatFluxFunctorMaterialTempl(
      49             :     const InputParameters & parameters)
      50             :   : FunctorMaterial(parameters),
      51          10 :     _r_inner(getFunctor<GenericReal<is_ad>>("r_inner")),
      52          20 :     _r_outer(getFunctor<GenericReal<is_ad>>("r_outer")),
      53          20 :     _T_inner(getFunctor<GenericReal<is_ad>>("T_inner")),
      54          20 :     _T_outer(getFunctor<GenericReal<is_ad>>("T_outer")),
      55          20 :     _k_gap(getFunctor<GenericReal<is_ad>>("k_gap")),
      56          20 :     _emiss_inner(getFunctor<GenericReal<is_ad>>("emissivity_inner")),
      57          30 :     _emiss_outer(getFunctor<GenericReal<is_ad>>("emissivity_outer"))
      58             : {
      59          40 :   addFunctorProperty<GenericReal<is_ad>>(
      60          20 :       getParam<MooseFunctorName>("conduction_heat_flux_name"),
      61        6000 :       [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      62             :       {
      63             :         return HeatTransferModels::cylindricalGapConductionHeatFlux(
      64        6000 :             _k_gap(r, t), _r_inner(r, t), _r_outer(r, t), _T_inner(r, t), _T_outer(r, t));
      65             :       });
      66             : 
      67          40 :   addFunctorProperty<GenericReal<is_ad>>(
      68          20 :       getParam<MooseFunctorName>("radiation_heat_flux_name"),
      69        6000 :       [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      70             :       {
      71        6000 :         return HeatTransferModels::cylindricalGapRadiationHeatFlux(_r_inner(r, t),
      72        6000 :                                                                    _r_outer(r, t),
      73        6000 :                                                                    _emiss_inner(r, t),
      74        6000 :                                                                    _emiss_outer(r, t),
      75        6000 :                                                                    _T_inner(r, t),
      76        6000 :                                                                    _T_outer(r, t));
      77             :       });
      78             : 
      79          40 :   addFunctorProperty<GenericReal<is_ad>>(
      80          20 :       getParam<MooseFunctorName>("total_heat_flux_name"),
      81        6000 :       [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      82             :       {
      83             :         return HeatTransferModels::cylindricalGapConductionHeatFlux(
      84        6000 :                    _k_gap(r, t), _r_inner(r, t), _r_outer(r, t), _T_inner(r, t), _T_outer(r, t)) +
      85        6000 :                HeatTransferModels::cylindricalGapRadiationHeatFlux(_r_inner(r, t),
      86        6000 :                                                                    _r_outer(r, t),
      87        6000 :                                                                    _emiss_inner(r, t),
      88        6000 :                                                                    _emiss_outer(r, t),
      89        6000 :                                                                    _T_inner(r, t),
      90       12000 :                                                                    _T_outer(r, t));
      91             :       });
      92          40 : }
      93             : 
      94             : template class CylindricalGapHeatFluxFunctorMaterialTempl<false>;
      95             : template class CylindricalGapHeatFluxFunctorMaterialTempl<true>;