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 "WCNSFVEnergyFluxBC.h"
      11             : #include "INSFVEnergyVariable.h"
      12             : #include "SinglePhaseFluidProperties.h"
      13             : #include "NS.h"
      14             : 
      15             : registerMooseObject("NavierStokesApp", WCNSFVEnergyFluxBC);
      16             : 
      17             : InputParameters
      18         405 : WCNSFVEnergyFluxBC::validParams()
      19             : {
      20         405 :   InputParameters params = WCNSFVFluxBCBase::validParams();
      21         405 :   params.addClassDescription("Flux boundary conditions for energy advection.");
      22             : 
      23             :   // Three different ways to input an advected energy flux
      24             :   // 1) Postprocessor with the energy flow rate directly
      25             :   // 2) Postprocessors for velocity and energy, functors for specific heat and density
      26             :   // 3) Postprocessors for mass flow rate and energy, functor for specific heat
      27         810 :   params.addParam<PostprocessorName>("energy_pp", "Postprocessor with the inlet energy flow rate");
      28         810 :   params.addParam<PostprocessorName>("temperature_pp", "Postprocessor with the inlet temperature");
      29         405 :   params.addParam<MooseFunctorName>(NS::cp, "specific heat capacity functor");
      30         405 :   params.addRequiredParam<MooseFunctorName>(NS::T_fluid, "temperature functor");
      31             : 
      32             :   // Parameters to solve with the specific enthalpy variable
      33         405 :   params.addParam<MooseFunctorName>(NS::pressure, "pressure functor");
      34         405 :   params.addParam<MooseFunctorName>(NS::specific_enthalpy,
      35             :                                     "Fluid specific enthalpy functor. This can be specified to "
      36             :                                     "avoid using cp * T as the enthalpy");
      37         405 :   params.addParam<UserObjectName>(NS::fluid, "Fluid properties object");
      38         405 :   return params;
      39           0 : }
      40             : 
      41         229 : WCNSFVEnergyFluxBC::WCNSFVEnergyFluxBC(const InputParameters & params)
      42             :   : WCNSFVFluxBCBase(params),
      43         435 :     _temperature_pp(isParamValid("temperature_pp") ? &getPostprocessorValue("temperature_pp")
      44             :                                                    : nullptr),
      45         471 :     _energy_pp(isParamValid("energy_pp") ? &getPostprocessorValue("energy_pp") : nullptr),
      46         227 :     _cp(isParamValid(NS::cp) ? &getFunctor<ADReal>(NS::cp) : nullptr),
      47         227 :     _temperature(getFunctor<ADReal>(NS::T_fluid)),
      48         271 :     _pressure(isParamValid(NS::pressure) ? &getFunctor<ADReal>(NS::pressure) : nullptr),
      49         271 :     _h_fluid(isParamValid(NS::specific_enthalpy) ? &getFunctor<ADReal>(NS::specific_enthalpy)
      50             :                                                  : nullptr),
      51         227 :     _fluid(isParamValid(NS::fluid)
      52         227 :                ? &UserObjectInterface::getUserObject<SinglePhaseFluidProperties>(NS::fluid)
      53         229 :                : nullptr)
      54             : {
      55         227 :   if (!dynamic_cast<INSFVEnergyVariable *>(&_var))
      56           0 :     paramError("variable",
      57             :                "The variable argument to WCNSFVEnergyFluxBC must be of type INSFVEnergyVariable");
      58             : 
      59             :   // Density is often set as global parameters so it is not checked
      60         227 :   if (_energy_pp && (_velocity_pp || _direction_specified_by_user || _mdot_pp || _temperature_pp))
      61           2 :     mooseWarning("If setting the energy flow rate directly, "
      62             :                  "no need for inlet velocity (magnitude or direction), mass flow or temperature");
      63             : 
      64             :   // Need enough information if trying to use a mass flow rate postprocessor
      65         225 :   if (!_energy_pp)
      66             :   {
      67         210 :     if (!_temperature_pp)
      68           2 :       mooseError("If not providing the energy flow rate, "
      69             :                  "the inlet temperature should be provided");
      70         208 :     if (!_velocity_pp && !_mdot_pp)
      71           2 :       mooseError("If not providing the inlet energy flow rate, the inlet velocity or mass flow "
      72             :                  "should be provided");
      73         206 :     if (_mdot_pp && !_area_pp)
      74           0 :       mooseError("If providing the inlet mass flow rate, the flow"
      75             :                  " area should be provided as well");
      76             :   }
      77          15 :   else if (!_area_pp)
      78           0 :     paramError("energy_pp",
      79             :                "If supplying the energy flow rate, the flow area should be provided as well");
      80         221 : }
      81             : 
      82             : ADReal
      83        9720 : WCNSFVEnergyFluxBC::computeQpResidual()
      84             : {
      85        9720 :   const auto state = determineState();
      86             : 
      87             :   // Currently an outlet
      88        9720 :   if (!isInflow())
      89             :   {
      90         579 :     const auto fa = singleSidedFaceArg();
      91        1158 :     return varVelocity(state) * _normal * _rho(fa, state) * enthalpy(fa, state, false);
      92             :   }
      93             :   // Currently an inlet with a set enthalpy
      94        9141 :   else if (_energy_pp)
      95        1075 :     return -_scaling_factor * *_energy_pp / *_area_pp;
      96             :   // Currently an inlet, compute the enthalpy
      97       16129 :   return -_scaling_factor * inflowMassFlux(state) * enthalpy(singleSidedFaceArg(), state, true);
      98             : }
      99             : 
     100             : bool
     101        9720 : WCNSFVEnergyFluxBC::isInflow() const
     102             : {
     103        9720 :   if (_mdot_pp)
     104        4983 :     return *_mdot_pp >= 0;
     105        4737 :   else if (_velocity_pp)
     106        3662 :     return *_velocity_pp >= 0;
     107        1075 :   else if (_energy_pp)
     108        1075 :     return *_energy_pp >= 0;
     109             : 
     110           0 :   mooseError(
     111             :       "Either mdot_pp or velocity_pp or energy_pp need to be provided OR this function must be "
     112             :       "overridden in derived classes if other input parameter combinations are valid. "
     113             :       "Neither mdot_pp nor velocity_pp are provided.");
     114             :   return true;
     115             : }
     116             : 
     117             : template <typename T>
     118             : ADReal
     119        8645 : WCNSFVEnergyFluxBC::enthalpy(const T & loc_arg,
     120             :                              const Moose::StateArg & state,
     121             :                              const bool inflow) const
     122             : {
     123             :   // Outlet, use interior values
     124        8645 :   if (!inflow)
     125             :   {
     126         579 :     if (_h_fluid)
     127           0 :       return (*_h_fluid)(loc_arg, state);
     128         579 :     else if (_fluid)
     129           0 :       return _fluid->h_from_p_T((*_pressure)(loc_arg, state), _temperature(loc_arg, state));
     130         579 :     else if (_temperature_pp)
     131        1158 :       return (*_cp)(loc_arg, state) * _temperature(loc_arg, state);
     132             :   }
     133             :   else
     134             :   {
     135        8066 :     if (_temperature_pp)
     136             :     {
     137             :       // Preferable to use the fluid property if we know it
     138        8066 :       if (_fluid)
     139        1026 :         return _fluid->h_from_p_T((*_pressure)(loc_arg, state), (*_temperature_pp));
     140        7040 :       else if (_cp)
     141       14080 :         return (*_cp)(loc_arg, state) * (*_temperature_pp);
     142             :     }
     143             :   }
     144           0 :   mooseError("Should not reach here, constructor checks required functor inputs to flux BC");
     145             : }