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 "DimensionlessFlowNumbers.h"
      11             : #include "MooseError.h"
      12             : 
      13             : namespace fp
      14             : {
      15             : 
      16             : void
      17          12 : deprecatedMessage()
      18             : {
      19          12 :   mooseDoOnce(mooseDeprecated("This function has been moved a different file and namespace. "
      20             :                               "Please replace inclusion of DimensionlessFlowNumbers.h "
      21             :                               "with inclusion of HeatTransferUtils.h and then replace 'fp::' with "
      22             :                               "'HeatTransferUtils::'."));
      23          12 : }
      24             : 
      25             : Real
      26           2 : reynolds(Real rho, Real vel, Real L, Real mu)
      27             : {
      28           2 :   deprecatedMessage();
      29           2 :   return rho * std::fabs(vel) * L / mu;
      30             : }
      31             : 
      32             : ADReal
      33           0 : reynolds(const ADReal & rho, const ADReal & vel, const ADReal & L, const ADReal & mu)
      34             : {
      35           0 :   deprecatedMessage();
      36             :   using std::fabs;
      37           0 :   return rho * fabs(vel) * L / mu;
      38             : }
      39             : 
      40             : Real
      41           2 : prandtl(Real cp, Real mu, Real k)
      42             : {
      43           2 :   deprecatedMessage();
      44           2 :   return cp * mu / k;
      45             : }
      46             : 
      47             : ADReal
      48           0 : prandtl(const ADReal & cp, const ADReal & mu, const ADReal & k)
      49             : {
      50           0 :   deprecatedMessage();
      51           0 :   return cp * mu / k;
      52             : }
      53             : 
      54             : Real
      55           2 : grashof(Real beta, Real T_s, Real T_bulk, Real L, Real rho, Real mu, Real gravity_magnitude)
      56             : {
      57           2 :   deprecatedMessage();
      58           2 :   return gravity_magnitude * beta * std::abs(T_s - T_bulk) * std::pow(L, 3) * (rho * rho) /
      59           2 :          (mu * mu);
      60             : }
      61             : 
      62             : ADReal
      63           0 : grashof(const ADReal & beta,
      64             :         const ADReal & T_s,
      65             :         const ADReal & T_bulk,
      66             :         const ADReal & L,
      67             :         const ADReal & rho,
      68             :         const ADReal & mu,
      69             :         const ADReal & gravity_magnitude)
      70             : {
      71           0 :   deprecatedMessage();
      72             :   using std::abs, std::pow;
      73           0 :   return gravity_magnitude * beta * abs(T_s - T_bulk) * pow(L, 3) * (rho * rho) / (mu * mu);
      74             : }
      75             : 
      76             : Real
      77           2 : laplace(Real sigma, Real rho, Real L, Real mu)
      78             : {
      79           2 :   deprecatedMessage();
      80           2 :   return sigma * rho * L / (mu * mu);
      81             : }
      82             : 
      83             : ADReal
      84           0 : laplace(const ADReal & sigma, const ADReal & rho, const ADReal & L, const ADReal & mu)
      85             : {
      86           0 :   deprecatedMessage();
      87           0 :   return sigma * rho * L / (mu * mu);
      88             : }
      89             : 
      90             : Real
      91           2 : thermalDiffusivity(Real k, Real rho, Real cp)
      92             : {
      93           2 :   deprecatedMessage();
      94           2 :   return k / (rho * cp);
      95             : }
      96             : 
      97             : ADReal
      98           0 : thermalDiffusivity(const ADReal & k, const ADReal & rho, const ADReal & cp)
      99             : {
     100           0 :   deprecatedMessage();
     101           0 :   return k / (rho * cp);
     102             : }
     103             : 
     104             : Real
     105           2 : peclet(Real vel, Real L, Real diffusivity)
     106             : {
     107           2 :   deprecatedMessage();
     108           2 :   return std::fabs(vel) * L / diffusivity;
     109             : }
     110             : 
     111             : ADReal
     112           0 : peclet(const ADReal & vel, const ADReal & L, const ADReal & diffusivity)
     113             : {
     114           0 :   deprecatedMessage();
     115             :   using std::fabs;
     116           0 :   return fabs(vel) * L / diffusivity;
     117             : }
     118             : 
     119             : } // namespace fp