Merge pull request #31196 from GiudGiud/PR_aux_non_AD

GiudGiud · web-flow · commit 5dfaae19d74b · 2025-08-11T23:07:37.000-06:00
Move NS auxkernels away from AD
diff --git a/modules/navier_stokes/include/auxkernels/HasPorosityJumpFace.h b/modules/navier_stokes/include/auxkernels/HasPorosityJumpFace.h
@@ -25,5 +25,5 @@ class HasPorosityJumpFace : public AuxKernel
   Real computeValue() override;
 
   /// The porosity
-  const Moose::Functor<ADReal> & _eps;
+  const Moose::Functor<Real> & _eps;
 };
diff --git a/modules/navier_stokes/include/auxkernels/NSLiquidFractionAux.h b/modules/navier_stokes/include/auxkernels/NSLiquidFractionAux.h
@@ -25,9 +25,9 @@ class NSLiquidFractionAux : public AuxKernel
   virtual Real computeValue();
 
   /// The temperature
-  const Moose::Functor<ADReal> & _T;
+  const Moose::Functor<Real> & _T;
   /// The solidus temperature
-  const Moose::Functor<ADReal> & _T_solidus;
+  const Moose::Functor<Real> & _T_solidus;
   /// The liquidus temperture
-  const Moose::Functor<ADReal> & _T_liquidus;
+  const Moose::Functor<Real> & _T_liquidus;
 };
diff --git a/modules/navier_stokes/include/auxkernels/PecletNumberFunctorAux.h b/modules/navier_stokes/include/auxkernels/PecletNumberFunctorAux.h
@@ -25,9 +25,9 @@ class PecletNumberFunctorAux : public AuxKernel
   Real computeValue() override;
 
   /// The fluid speed
-  const Moose::Functor<ADReal> & _speed;
+  const Moose::Functor<Real> & _speed;
   /// The fluid thermal diffusivity or mass diffusivity. Should have units of length^2/time
-  const Moose::Functor<ADReal> & _alpha;
+  const Moose::Functor<Real> & _alpha;
   /// Whether to use a quadrature-based argument to evaluate the functors
   const bool _use_qp_arg;
 };
diff --git a/modules/navier_stokes/include/auxkernels/ReynoldsNumberFunctorAux.h b/modules/navier_stokes/include/auxkernels/ReynoldsNumberFunctorAux.h
@@ -25,11 +25,11 @@ class ReynoldsNumberFunctorAux : public AuxKernel
   Real computeValue() override;
 
   /// The fluid speed
-  const Moose::Functor<ADReal> & _speed;
+  const Moose::Functor<Real> & _speed;
   /// The fluid density
-  const Moose::Functor<ADReal> & _rho;
+  const Moose::Functor<Real> & _rho;
   /// The fluid dynamic viscosity
-  const Moose::Functor<ADReal> & _mu;
+  const Moose::Functor<Real> & _mu;
   /// Whether to use a quadrature-based argument to evaluate the functors
   const bool _use_qp_arg;
 };
diff --git a/modules/navier_stokes/include/auxkernels/TurbulentConductivityAux.h b/modules/navier_stokes/include/auxkernels/TurbulentConductivityAux.h
@@ -29,11 +29,11 @@ class TurbulentConductivityAux : public AuxKernel
   virtual Real computeValue() override;
 
   /// Specific heat at Constant Pressure
-  const Moose::Functor<ADReal> & _cp;
+  const Moose::Functor<Real> & _cp;
 
   /// Turbulent Prandtl number
-  const Moose::Functor<ADReal> & _Pr_t;
+  const Moose::Functor<Real> & _Pr_t;
 
   /// Turbulent viscosity
-  const Moose::Functor<ADReal> & _mu_t;
+  const Moose::Functor<Real> & _mu_t;
 };
diff --git a/modules/navier_stokes/include/auxkernels/WallFunctionWallShearStressAux.h b/modules/navier_stokes/include/auxkernels/WallFunctionWallShearStressAux.h
@@ -36,10 +36,10 @@ class WallFunctionWallShearStressAux : public AuxKernel
   const INSFVVelocityVariable * const _w_var;
 
   /// Density
-  const Moose::Functor<ADReal> & _rho;
+  const Moose::Functor<Real> & _rho;
 
   /// Dynamic viscosity
-  const Moose::Functor<ADReal> & _mu;
+  const Moose::Functor<Real> & _mu;
 
   /// Wall boundaries
   const std::vector<BoundaryName> & _wall_boundary_names;
diff --git a/modules/navier_stokes/include/auxkernels/WallFunctionYPlusAux.h b/modules/navier_stokes/include/auxkernels/WallFunctionYPlusAux.h
@@ -36,10 +36,10 @@ class WallFunctionYPlusAux : public AuxKernel
   const INSFVVelocityVariable * const _w_var;
 
   /// Density
-  const Moose::Functor<ADReal> & _rho;
+  const Moose::Functor<Real> & _rho;
 
   /// Dynamic viscosity
-  const Moose::Functor<ADReal> & _mu;
+  const Moose::Functor<Real> & _mu;
 
   /// Wall boundaries
   const std::vector<BoundaryName> & _wall_boundary_names;
diff --git a/modules/navier_stokes/include/utils/NSFVUtils.h b/modules/navier_stokes/include/utils/NSFVUtils.h
@@ -48,7 +48,13 @@ namespace NS
  * the porosity value on the "element" side of the face, and the second member is the porosity value
  * on the "neighbor" side of the face
  */
-std::tuple<bool, ADReal, ADReal> isPorosityJumpFace(const Moose::Functor<ADReal> & porosity,
-                                                    const FaceInfo & fi,
-                                                    const Moose::StateArg & time);
+template <class T>
+std::tuple<bool, T, T> isPorosityJumpFace(const Moose::FunctorBase<T> & porosity,
+                                          const FaceInfo & fi,
+                                          const Moose::StateArg & time);
+
+extern template std::tuple<bool, Real, Real> isPorosityJumpFace<Real>(
+    const Moose::FunctorBase<Real> & porosity, const FaceInfo & fi, const Moose::StateArg & time);
+extern template std::tuple<bool, ADReal, ADReal> isPorosityJumpFace<ADReal>(
+    const Moose::FunctorBase<ADReal> & porosity, const FaceInfo & fi, const Moose::StateArg & time);
 }
diff --git a/modules/navier_stokes/src/auxkernels/HasPorosityJumpFace.C b/modules/navier_stokes/src/auxkernels/HasPorosityJumpFace.C
@@ -24,7 +24,7 @@ HasPorosityJumpFace::validParams()
 }
 
 HasPorosityJumpFace::HasPorosityJumpFace(const InputParameters & parameters)
-  : AuxKernel(parameters), _eps(getFunctor<ADReal>(NS::porosity))
+  : AuxKernel(parameters), _eps(getFunctor<Real>(NS::porosity))
 {
   if (isNodal())
     mooseError("This AuxKernel only supports Elemental fields");
diff --git a/modules/navier_stokes/src/auxkernels/INSFVMixingLengthTurbulentViscosityAux.C b/modules/navier_stokes/src/auxkernels/INSFVMixingLengthTurbulentViscosityAux.C
@@ -58,16 +58,16 @@ INSFVMixingLengthTurbulentViscosityAux::computeValue()
   const Elem & elem = *_current_elem;
   const auto state = determineState();
 
-  const auto & grad_u = _u_var->adGradSln(&elem, state);
-  ADReal symmetric_strain_tensor_norm = 2.0 * Utility::pow<2>(grad_u(0));
+  const auto grad_u = MetaPhysicL::raw_value(_u_var->adGradSln(&elem, state));
+  Real symmetric_strain_tensor_norm = 2.0 * Utility::pow<2>(grad_u(0));
   if (_dim >= 2)
   {
-    const auto & grad_v = _v_var->adGradSln(&elem, state);
+    const auto grad_v = MetaPhysicL::raw_value(_v_var->adGradSln(&elem, state));
     symmetric_strain_tensor_norm +=
         2.0 * Utility::pow<2>(grad_v(1)) + Utility::pow<2>(grad_v(0) + grad_u(1));
     if (_dim >= 3)
     {
-      const auto & grad_w = _w_var->adGradSln(&elem, state);
+      const auto grad_w = MetaPhysicL::raw_value(_w_var->adGradSln(&elem, state));
       symmetric_strain_tensor_norm += 2.0 * Utility::pow<2>(grad_w(2)) +
                                       Utility::pow<2>(grad_u(2) + grad_w(0)) +
                                       Utility::pow<2>(grad_v(2) + grad_w(1));
@@ -77,8 +77,8 @@ INSFVMixingLengthTurbulentViscosityAux::computeValue()
   symmetric_strain_tensor_norm = std::sqrt(symmetric_strain_tensor_norm + offset);
 
   // Compute the eddy diffusivitiy
-  ADReal eddy_diff = symmetric_strain_tensor_norm * _mixing_len[_qp] * _mixing_len[_qp];
+  const Real eddy_diff = symmetric_strain_tensor_norm * _mixing_len[_qp] * _mixing_len[_qp];
 
   // Return the turbulent stress contribution to the momentum equation
-  return eddy_diff.value();
+  return eddy_diff;
 }
diff --git a/modules/navier_stokes/src/auxkernels/NSLiquidFractionAux.C b/modules/navier_stokes/src/auxkernels/NSLiquidFractionAux.C
@@ -26,9 +26,9 @@ NSLiquidFractionAux::validParams()
 
 NSLiquidFractionAux::NSLiquidFractionAux(const InputParameters & parameters)
   : AuxKernel(parameters),
-    _T(getFunctor<ADReal>(NS::temperature)),
-    _T_solidus(getFunctor<ADReal>("T_solidus")),
-    _T_liquidus(getFunctor<ADReal>("T_liquidus"))
+    _T(getFunctor<Real>(NS::temperature)),
+    _T_solidus(getFunctor<Real>("T_solidus")),
+    _T_liquidus(getFunctor<Real>("T_liquidus"))
 {
 }
 
@@ -40,11 +40,11 @@ NSLiquidFractionAux::computeValue()
   const auto elem_arg = makeElemArg(_current_elem);
   const auto state = determineState();
 
-  if (raw_value(_T_liquidus(elem_arg, state)) < raw_value(_T_solidus(elem_arg, state)))
+  if (_T_liquidus(elem_arg, state) < _T_solidus(elem_arg, state))
     mooseError("The specified liquidus temperature is smaller than the solidus temperature.");
 
-  Real fl = raw_value((_T(elem_arg, state) - _T_solidus(elem_arg, state)) /
-                      (_T_liquidus(elem_arg, state) - _T_solidus(elem_arg, state)));
+  Real fl = (_T(elem_arg, state) - _T_solidus(elem_arg, state)) /
+            (_T_liquidus(elem_arg, state) - _T_solidus(elem_arg, state));
 
   fl = (fl > 1.0) ? 1.0 : fl;
   fl = (fl < 0.0) ? 0.0 : fl;
diff --git a/modules/navier_stokes/src/auxkernels/PecletNumberFunctorAux.C b/modules/navier_stokes/src/auxkernels/PecletNumberFunctorAux.C
@@ -28,8 +28,8 @@ PecletNumberFunctorAux::validParams()
 
 PecletNumberFunctorAux::PecletNumberFunctorAux(const InputParameters & parameters)
   : AuxKernel(parameters),
-    _speed(getFunctor<ADReal>(NS::speed)),
-    _alpha(getFunctor<ADReal>(NS::thermal_diffusivity)),
+    _speed(getFunctor<Real>(NS::speed)),
+    _alpha(getFunctor<Real>(NS::thermal_diffusivity)),
     _use_qp_arg(dynamic_cast<MooseVariableFE<Real> *>(&_var))
 {
   if (!_use_qp_arg && !dynamic_cast<MooseVariableFV<Real> *>(&_var))
@@ -50,13 +50,11 @@ PecletNumberFunctorAux::computeValue()
   if (_use_qp_arg)
   {
     const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
-    return _current_elem->hmax() * raw_value(_speed(qp_arg, state)) /
-           raw_value(_alpha(qp_arg, state));
+    return _current_elem->hmax() * _speed(qp_arg, state) / _alpha(qp_arg, state);
   }
   else
   {
     const auto elem_arg = makeElemArg(_current_elem);
-    return _current_elem->hmax() * raw_value(_speed(elem_arg, state)) /
-           raw_value(_alpha(elem_arg, state));
+    return _current_elem->hmax() * _speed(elem_arg, state) / _alpha(elem_arg, state);
   }
 }
diff --git a/modules/navier_stokes/src/auxkernels/ReynoldsNumberFunctorAux.C b/modules/navier_stokes/src/auxkernels/ReynoldsNumberFunctorAux.C
@@ -26,9 +26,9 @@ ReynoldsNumberFunctorAux::validParams()
 
 ReynoldsNumberFunctorAux::ReynoldsNumberFunctorAux(const InputParameters & parameters)
   : AuxKernel(parameters),
-    _speed(getFunctor<ADReal>(NS::speed)),
-    _rho(getFunctor<ADReal>(NS::density)),
-    _mu(getFunctor<ADReal>(NS::mu)),
+    _speed(getFunctor<Real>(NS::speed)),
+    _rho(getFunctor<Real>(NS::density)),
+    _mu(getFunctor<Real>(NS::mu)),
     _use_qp_arg(dynamic_cast<MooseVariableFE<Real> *>(&_var))
 {
   if (!_use_qp_arg && !dynamic_cast<MooseVariableFV<Real> *>(&_var))
@@ -49,13 +49,12 @@ ReynoldsNumberFunctorAux::computeValue()
   if (_use_qp_arg)
   {
     const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
-    return _current_elem->hmax() * raw_value(_rho(qp_arg, state)) *
-           raw_value(_speed(qp_arg, state)) / raw_value(_mu(qp_arg, state));
+    return _current_elem->hmax() * _rho(qp_arg, state) * _speed(qp_arg, state) / _mu(qp_arg, state);
   }
   else
   {
     const auto elem_arg = makeElemArg(_current_elem);
-    return _current_elem->hmax() * raw_value(_rho(elem_arg, state)) *
-           raw_value(_speed(elem_arg, state)) / raw_value(_mu(elem_arg, state));
+    return _current_elem->hmax() * _rho(elem_arg, state) * _speed(elem_arg, state) /
+           _mu(elem_arg, state);
   }
 }
diff --git a/modules/navier_stokes/src/auxkernels/TurbulentConductivityAux.C b/modules/navier_stokes/src/auxkernels/TurbulentConductivityAux.C
@@ -26,9 +26,9 @@ TurbulentConductivityAux::validParams()
 
 TurbulentConductivityAux::TurbulentConductivityAux(const InputParameters & params)
   : AuxKernel(params),
-    _cp(getFunctor<ADReal>(NS::cp)),
-    _Pr_t(getFunctor<ADReal>("Pr_t")),
-    _mu_t(getFunctor<ADReal>(NS::mu_t))
+    _cp(getFunctor<Real>(NS::cp)),
+    _Pr_t(getFunctor<Real>("Pr_t")),
+    _mu_t(getFunctor<Real>(NS::mu_t))
 {
 }
 
@@ -38,6 +38,6 @@ TurbulentConductivityAux::computeValue()
   const auto current_argument = makeElemArg(_current_elem);
   const auto state = determineState();
 
-  return raw_value(_cp(current_argument, state) * _mu_t(current_argument, state) /
-                   _Pr_t(current_argument, state));
+  return _cp(current_argument, state) * _mu_t(current_argument, state) /
+         _Pr_t(current_argument, state);
 }
diff --git a/modules/navier_stokes/src/auxkernels/WallFunctionWallShearStressAux.C b/modules/navier_stokes/src/auxkernels/WallFunctionWallShearStressAux.C
@@ -38,8 +38,8 @@ WallFunctionWallShearStressAux::WallFunctionWallShearStressAux(const InputParame
     _w_var(params.isParamValid("w")
                ? dynamic_cast<const INSFVVelocityVariable *>(getFieldVar("w", 0))
                : nullptr),
-    _rho(getFunctor<ADReal>("rho")),
-    _mu(getFunctor<ADReal>("mu")),
+    _rho(getFunctor<Real>("rho")),
+    _mu(getFunctor<Real>("mu")),
     _wall_boundary_names(getParam<std::vector<BoundaryName>>("walls"))
 {
   if (!_u_var)
@@ -98,31 +98,30 @@ WallFunctionWallShearStressAux::computeValue()
   const auto state = determineState();
 
   // Get the velocity vector
-  ADRealVectorValue velocity(_u_var->getElemValue(&elem, state));
+  RealVectorValue velocity(MetaPhysicL::raw_value(_u_var->getElemValue(&elem, state)));
   if (_v_var)
-    velocity(1) = _v_var->getElemValue(&elem, state);
+    velocity(1) = MetaPhysicL::raw_value(_v_var->getElemValue(&elem, state));
   if (_w_var)
-    velocity(2) = _w_var->getElemValue(&elem, state);
+    velocity(2) = MetaPhysicL::raw_value(_w_var->getElemValue(&elem, state));
 
   // Compute the velocity and direction of the velocity component that is parallel to the wall
   Real dist = std::abs(wall_vec * normal);
-  ADReal perpendicular_speed = velocity * normal;
-  ADRealVectorValue parallel_velocity = velocity - perpendicular_speed * normal;
-  ADReal parallel_speed = parallel_velocity.norm();
-  ADRealVectorValue parallel_dir = parallel_velocity / parallel_speed;
+  Real perpendicular_speed = velocity * normal;
+  RealVectorValue parallel_velocity = velocity - perpendicular_speed * normal;
+  Real parallel_speed = parallel_velocity.norm();
 
   if (parallel_speed < 1e-6)
     return 0;
 
-  if (!std::isfinite(parallel_speed.value()))
-    return parallel_speed.value();
+  if (!std::isfinite(parallel_speed))
+    return parallel_speed;
 
   // Compute the friction velocity and the wall shear stress
   const auto elem_arg = makeElemArg(_current_elem);
   const auto rho = _rho(elem_arg, state);
   const auto mu = _mu(elem_arg, state);
-  ADReal u_star = NS::findUStar<ADReal>(mu.value(), rho.value(), parallel_speed, dist);
-  ADReal tau = u_star * u_star * rho.value();
+  const Real u_star = NS::findUStar<Real>(mu, rho, parallel_speed, dist);
+  const Real tau = u_star * u_star * rho;
 
-  return tau.value();
+  return tau;
 }
diff --git a/modules/navier_stokes/src/auxkernels/WallFunctionYPlusAux.C b/modules/navier_stokes/src/auxkernels/WallFunctionYPlusAux.C
@@ -38,8 +38,8 @@ WallFunctionYPlusAux::WallFunctionYPlusAux(const InputParameters & params)
     _w_var(params.isParamValid("w")
                ? dynamic_cast<const INSFVVelocityVariable *>(getFieldVar("w", 0))
                : nullptr),
-    _rho(getFunctor<ADReal>("rho")),
-    _mu(getFunctor<ADReal>("mu")),
+    _rho(getFunctor<Real>("rho")),
+    _mu(getFunctor<Real>("mu")),
     _wall_boundary_names(getParam<std::vector<BoundaryName>>("walls"))
 {
   if (!_u_var)
@@ -98,31 +98,29 @@ WallFunctionYPlusAux::computeValue()
   const auto state = determineState();
 
   // Get the velocity vector
-  ADRealVectorValue velocity(_u_var->getElemValue(&elem, state));
+  RealVectorValue velocity(MetaPhysicL::raw_value(_u_var->getElemValue(&elem, state)));
   if (_v_var)
-    velocity(1) = _v_var->getElemValue(&elem, state);
+    velocity(1) = MetaPhysicL::raw_value(_v_var->getElemValue(&elem, state));
   if (_w_var)
-    velocity(2) = _w_var->getElemValue(&elem, state);
+    velocity(2) = MetaPhysicL::raw_value(_w_var->getElemValue(&elem, state));
 
   // Compute the velocity and direction of the velocity component that is parallel to the wall
   Real dist = std::abs(wall_vec * normal);
-  ADReal perpendicular_speed = velocity * normal;
-  ADRealVectorValue parallel_velocity = velocity - perpendicular_speed * normal;
-  ADReal parallel_speed = parallel_velocity.norm();
-  ADRealVectorValue parallel_dir = parallel_velocity / parallel_speed;
+  const Real perpendicular_speed = velocity * normal;
+  const RealVectorValue parallel_velocity = velocity - perpendicular_speed * normal;
+  const Real parallel_speed = parallel_velocity.norm();
 
-  if (parallel_speed.value() < 1e-6)
+  if (parallel_speed < 1e-6)
     return 0;
 
-  if (!std::isfinite(parallel_speed.value()))
-    return parallel_speed.value();
+  if (!std::isfinite(parallel_speed))
+    return parallel_speed;
 
   // Compute the friction velocity and the wall shear stress
   const auto elem_arg = makeElemArg(_current_elem);
   const auto rho = _rho(elem_arg, state);
   const auto mu = _mu(elem_arg, state);
-  ADReal u_star = NS::findUStar<ADReal>(mu.value(), rho.value(), parallel_speed, dist);
-  ADReal tau = u_star * u_star * rho;
+  const Real u_star = NS::findUStar<Real>(mu, rho, parallel_speed, dist);
 
-  return (dist * u_star * rho / mu).value();
+  return (dist * u_star * rho / mu);
 }
diff --git a/modules/navier_stokes/src/utils/NSFVUtils.C b/modules/navier_stokes/src/utils/NSFVUtils.C
@@ -54,8 +54,9 @@ interpolationParameters()
 
 namespace NS
 {
-std::tuple<bool, ADReal, ADReal>
-isPorosityJumpFace(const Moose::Functor<ADReal> & porosity,
+template <class T>
+std::tuple<bool, T, T>
+isPorosityJumpFace(const Moose::FunctorBase<T> & porosity,
                    const FaceInfo & fi,
                    const Moose::StateArg & time)
 {
@@ -74,4 +75,9 @@ isPorosityJumpFace(const Moose::Functor<ADReal> & porosity,
   const auto eps_elem = porosity(face_elem, time), eps_neighbor = porosity(face_neighbor, time);
   return {!MooseUtils::relativeFuzzyEqual(eps_elem, eps_neighbor), eps_elem, eps_neighbor};
 }
+
+template std::tuple<bool, Real, Real> isPorosityJumpFace<Real>(
+    const Moose::FunctorBase<Real> & porosity, const FaceInfo & fi, const Moose::StateArg & time);
+template std::tuple<bool, ADReal, ADReal> isPorosityJumpFace<ADReal>(
+    const Moose::FunctorBase<ADReal> & porosity, const FaceInfo & fi, const Moose::StateArg & time);
 }

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ HasPorosityJumpFace::validParams()`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`HasPorosityJumpFace::HasPorosityJumpFace(const InputParameters & parameters)`
`27`		`- : AuxKernel(parameters), _eps(getFunctor<ADReal>(NS::porosity))`
	`27`	`+ : AuxKernel(parameters), _eps(getFunctor<Real>(NS::porosity))`
`28`	`28`	`{`
`29`	`29`	`if (isNodal())`
`30`	`30`	`mooseError("This AuxKernel only supports Elemental fields");`