Namespaces
namespace	FV

namespace	phase

namespace	settings

namespace	splitting

Enumerations
enum class	WallTreatmentEnum { EQ_NEWTON = 0 , EQ_INCREMENTAL = 1 , EQ_LINEARIZED = 2 , NEQ = 3 }
	Wall treatment options. More...

enum	CHTSide { SOLID = 0 , FLUID = 1 }
	CHT side options, we want to make sure these can be used as integers so we are avoiding the enum class here. More...

enum class	MomentumInletTypes { FIXED_VELOCITY = 0 , FLUX_VELOCITY = 1 , FLUX_MASS = 2 , FIXED_PRESSURE = 3 }

enum class	ViscousForm : int { Traction , Laplace }

Functions
int	delta (unsigned int i, unsigned int j)
	Delta function, which returns zero if $i\ne j$ and unity if $i=j$.

int	computeSign (const Real &a)
	Sign function, returns $+1$ if $a$ is positive and $-1$ if $a$ is negative.

unsigned int	getIndex (const Real &p, const std::vector< Real > &bounds)
	Determines the index $i$ in a sorted array such that the input point is within the $i$-th and $i+1$-th entries in the array.

Real	reynoldsPropertyDerivative (const Real &Re, const Real &rho, const Real &mu, const Real &drho, const Real &dmu)
	Computes the derivative of the Reynolds number, $Re\equiv \frac{\rho Vd}{\mu}$, with respect to an arbitrary variable $\zeta$, where it is assumed that only the material properties of density $\rho$ and dynamic viscosity $\mu$ have nonzero derivatives with respect to $\zeta$.

Real	prandtlPropertyDerivative (const Real &mu, const Real &cp, const Real &k, const Real &dmu, const Real &dcp, const Real &dk)
	Computes the derivative of the Prandtl number, $Pr\equiv\frac{\mu C_p}{k}$, with respect to an arbitrary variale $\zeta$.

template<typename T >
T	findUStar (const T &mu, const T &rho, const T &u, Real dist)
	Finds the friction velocity using standard velocity wall functions formulation.

template<typename T >
T	findYplusThermal (const T &Pr, const T &Pr_t)
	Finds the thermal non-dimensional wall distance at which the laminar and logarithmic temperature wall functions intersect.

template<typename T >
T	findyPlus (const T &mu, const T &rho, const T &u, Real dist)
	Finds the non-dimensional wall distance normalized with the friction velocity Implements a fixed-point iteration in the wall function to get this velocity.

template<typename T >
T	computeSpeed (const libMesh::VectorValue< T > &velocity)
	Compute the speed (velocity norm) given the supplied velocity.

template<typename T >
T	computeShearStrainRateNormSquared (const Moose::Functor< T > &u, const Moose::Functor< T > v, const Moose::Functor< T > w, const Moose::ElemArg &elem_arg, const Moose::StateArg &state, const Moose::CoordinateSystemType coord_sys=Moose::COORD_XYZ, const unsigned int rz_radial_coord=0)
	Utility function to compute the shear strain rate.

void	getWallBoundedElements (const std::vector< BoundaryName > &wall_boundary_name, const FEProblemBase &fe_problem, const SubProblem &subproblem, const std::set< SubdomainID > &block_ids, std::unordered_set< const Elem * > &wall_bounded)
	Map marking wall bounded elements The map passed in `wall_bounded_map` gets cleared and re-populated.

void	getWallDistance (const std::vector< BoundaryName > &wall_boundary_name, const FEProblemBase &fe_problem, const SubProblem &subproblem, const std::set< SubdomainID > &block_ids, std::map< const Elem *, std::vector< Real > > &dist_map)
	Map storing wall ditance for near-wall marked elements The map passed in `dist_map` gets cleared and re-populated.

void	getElementFaceArgs (const std::vector< BoundaryName > &wall_boundary_name, const FEProblemBase &fe_problem, const SubProblem &subproblem, const std::set< SubdomainID > &block_ids, std::map< const Elem , std::vector< const FaceInfo > > &face_info_map)
	Map storing face arguments to wall bounded faces The map passed in `face_info_map` gets cleared and re-populated.

template<typename T , typename VectorType , typename PointType >
T	divergence (const TensorValue< T > &gradient, const VectorType &value, const PointType &point, const Moose::CoordinateSystemType &coord_sys, const unsigned int rz_radial_coord)
	Compute the divergence of a vector given its matrix of derivatives.

template<typename T1 , typename T2 , typename T3 >
auto	wallHeatTransferCoefficient (const T1 &Nu, const T2 &k, const T3 &D_h)
	Compute wall heat transfer coefficient.

template Real	findUStar< Real > (const Real &mu, const Real &rho, const Real &u, const Real dist)

template ADReal	findUStar< ADReal > (const ADReal &mu, const ADReal &rho, const ADReal &u, const Real dist)

template Real	findyPlus< Real > (const Real &mu, const Real &rho, const Real &u, Real dist)

template ADReal	findyPlus< ADReal > (const ADReal &mu, const ADReal &rho, const ADReal &u, Real dist)

template Real	computeSpeed< Real > (const libMesh::VectorValue< Real > &velocity)

template ADReal	computeSpeed< ADReal > (const libMesh::VectorValue< ADReal > &velocity)

template Real	computeShearStrainRateNormSquared< Real > (const Moose::Functor< Real > &u, const Moose::Functor< Real > v, const Moose::Functor< Real > w, const Moose::ElemArg &elem_arg, const Moose::StateArg &state, const Moose::CoordinateSystemType coord_sys, const unsigned int rz_radial_coord)

template ADReal	computeShearStrainRateNormSquared< ADReal > (const Moose::Functor< ADReal > &u, const Moose::Functor< ADReal > v, const Moose::Functor< ADReal > w, const Moose::ElemArg &elem_arg, const Moose::StateArg &state, const Moose::CoordinateSystemType coord_sys, const unsigned int rz_radial_coord)

std::string	grad (const std::string &var)

std::string	time_deriv (const std::string &var)

MooseEnum	fvAdvectedInterpolationMethods ()
	Enum of the advected interpolation methods supported by FVInterpolationMethod objects.

std::string	fvAdvectedInterpolationMethodType (const MooseEnum &interpolation_method)
	Gets the FVInterpolationMethod object type for an advected interpolation method.

MooseEnum	fvFaceInterpolationMethods ()
	Enum of the interpolation methods supported by FVInterpolationMethod objects.

std::string	fvFaceInterpolationMethodType (const MooseEnum &interpolation_method)
	Gets the FVInterpolationMethod object type for a face interpolation method name.

void	addFVFaceInterpolationMethod (FEProblemBase &problem, Factory &factory, const MooseEnum &interpolation_method)
	Add the FVInterpolationMethod object for a face interpolation method name, if absent.

template<class T >
std::tuple< bool, T, T >	isPorosityJumpFace (const Moose::FunctorBase< T > &porosity, const FaceInfo &fi, const Moose::StateArg &time)
	Checks to see whether the porosity value jumps from one side to the other of the provided face.

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)

template Real	findYplusThermal< Real > (const Real &Pr, const Real &Pr_t)

Variables
static const std::string	directions [3] = {"x", "y", "z"}

static const std::string	pebble_diameter = "pebble_diameter"

static const std::string	infinite_porosity = "infinite_porosity"

static const std::string	axis = "axis"

static const std::string	center = "center"

static const std::string	wall_porosity = "wall_porosity"

static const std::string	wall_distance = "wall_distance"

static const std::string	density = "rho"

static const std::string	superficial_density = "superficial_rho"

static const std::string	momentum_x = "rhou"

static const std::string	momentum_y = "rhov"

static const std::string	momentum_z = "rhow"

static const std::string	momentum_vector [3] = {momentum_x, momentum_y, momentum_z}

static const std::string	superficial_momentum_x = "superficial_rhou"

static const std::string	superficial_momentum_y = "superficial_rhov"

static const std::string	superficial_momentum_z = "superficial_rhow"

static const std::string	superficial_momentum_vector [3]

static const std::string	velocity = "velocity"

static const std::string	velocity_x = "vel_x"

static const std::string	velocity_y = "vel_y"

static const std::string	velocity_z = "vel_z"

const std::string	velocity_vector [3] = {velocity_x, velocity_y, velocity_z}

static const std::string	superficial_velocity_x = "superficial_vel_x"

static const std::string	superficial_velocity_y = "superficial_vel_y"

static const std::string	superficial_velocity_z = "superficial_vel_z"

static const std::string	superficial_velocity = "superficial_velocity"

static const std::string	superficial_velocity_vector [3]

static const std::string	pressure = "pressure"

static const std::string	total_pressure = "pressure_total"

static const std::string	temperature = "temperature"

static const std::string	internal_energy = "internal_energy"

static const std::string	specific_internal_energy = "e"

static const std::string	specific_total_energy = "et"

static const std::string	internal_energy_density = "rho_e"

static const std::string	total_energy_density = "rho_et"

static const std::string	superficial_total_energy_density = "superficial_rho_et"

static const std::string	specific_enthalpy = "h"

static const std::string	specific_total_enthalpy = "ht"

static const std::string	enthalpy_density = "rho_h"

static const std::string	total_enthalpy_density = "rho_ht"

static const std::string	superficial_total_enthalpy_density = "superficial_rho_ht"

static const std::string	mixing_length = "mixing_length"

static const std::string	wall_shear_stress = "wall_shear_stress"

static const std::string	wall_yplus = "wall_yplus"

static const std::string	eddy_viscosity = "eddy_viscosity"

static const std::string	total_viscosity = "total_viscosity"

static const std::string	mach_number = "Mach"

static const std::string	specific_volume = "specific_volume"

static const std::string	momentum = "momentum"

static const std::string	v = "v"

static const std::string	acceleration = "acceleration"

static const std::string	fluid = "fp"

static const std::string	porosity = "porosity"

static const std::string	smoothed_porosity = "smoothed_porosity"

static const std::string	T_fluid = "T_fluid"

static const std::string	T_solid = "T_solid"

static const std::string	heat_source = "heat_source"

static const std::string	cL = "Darcy_coefficient"

static const std::string	cQ = "Forchheimer_coefficient"

static const std::string	alpha_boussinesq = "alpha_b"

static const std::string	drhos_dTs = "drhos_dTs"

static const std::string	dks_dTs = "dks_dTs"

static const std::string	kappa = "kappa"

static const std::string	kappa_s = "kappa_s"

static const std::string	rho_s = "rho_s"

static const std::string	cp_s = "cp_s"

static const std::string	k_s = "k_s"

static const std::string	cp = "cp"

static const std::string	cv = "cv"

static const std::string	mu = "mu"

static const std::string	mu_t = "mu_t"

static const std::string	mu_t_passive_scalar = "mu_t_passive_scalar"

static const std::string	mu_eff = "mu_eff"

static const std::string	k = "k"

static const std::string	k_t = "k_t"

static const std::string	k_eff_t = "k_eff_t"

static const std::string	thermal_diffusivity = "thermal_diffusivity"

static const std::string	alpha = "alpha"

static const std::string	alpha_wall = "alpha_wall"

static const std::string	solid = "solid"

static const std::string	Prandtl = "Pr"

static const std::string	turbulent_Prandtl = "Pr_t"

static const std::string	Reynolds = "Re"

static const std::string	Reynolds_hydraulic = "Re_h"

static const std::string	Reynolds_interstitial = "Re_i"

static const std::string	c = "c"

static const std::string	speed = "speed"

static const std::string	sound_speed = "sound_speed"

static const std::string	latent_heat = "latent_heat"

static const std::string	T_liquidus = "T_liquidus"

static const std::string	T_solidus = "T_solidus"

static const std::string	alpha_exchange = "alpha_exchange"

static const std::string	component = "component"

static const std::string	source_scaling = "source_scaling"

static const std::string	matrix_tau = "matrix_tau"

static const std::string	vector_tau = "vector_tau"

static const std::string	scalar_tau = "scalar_tau"

static const std::string	diagonal_tau = "diagonal_tau"

static const std::string	A = "A"

static const std::string	R = "R"

static const std::string	S = "S"

static const std::string	dS_dTs = "dS_dTs"

static const std::string	F = "F"

static const std::string	G = "G"

static const std::string	dUdt = "dUdt"

static const std::string	C = "C"

static const std::string	Z = "Z"

static const std::string	K = "K"

static const std::string	mass_flux = "mass_flux"

static const std::string	TKE = "tke"

static const std::string	TKED = "epsilon"

static constexpr Real	von_karman_constant = 0.4187

static constexpr Real	E_turb_constant = 9.793

static constexpr Real	mu_t_low_limit = 1.0e-8

static constexpr Real	epsilon_low_limit = 1.0e-8

static constexpr Real	min_y_plus = 1e-10

Enumeration Type Documentation

◆ CHTSide

enum NS::CHTSide

CHT side options, we want to make sure these can be used as integers so we are avoiding the enum class here.

Enumerator
SOLID
FLUID

Definition at line 199 of file NS.h.

{
  SOLID = 0,
  FLUID = 1
};

◆ MomentumInletTypes

enum class NS::MomentumInletTypes

strong

Enumerator
FIXED_VELOCITY
FLUX_VELOCITY
FLUX_MASS
FIXED_PRESSURE

Definition at line 216 of file NS.h.

{
  FIXED_VELOCITY = 0,
  FLUX_VELOCITY = 1,
  FLUX_MASS = 2,
  FIXED_PRESSURE = 3
};

◆ ViscousForm

enum class NS::ViscousForm : int

strong

Enumerator
Traction
Laplace

Definition at line 20 of file NSEnums.h.

{
  Traction,
  Laplace
};

◆ WallTreatmentEnum

enum class NS::WallTreatmentEnum

strong

Wall treatment options.

Enumerator
EQ_NEWTON
EQ_INCREMENTAL
EQ_LINEARIZED
NEQ

Definition at line 187 of file NS.h.

{
  EQ_NEWTON = 0,
  EQ_INCREMENTAL = 1,
  EQ_LINEARIZED = 2,
  NEQ = 3
};

Function Documentation

◆ addFVFaceInterpolationMethod()

void NS::addFVFaceInterpolationMethod	(	FEProblemBase &	problem,
		Factory &	factory,
		const MooseEnum &	interpolation_method
	)

Add the FVInterpolationMethod object for a face interpolation method name, if absent.

Parameters

problem	The problem to which the interpolation method should be added
factory	The factory used to build interpolation method parameters
interpolation_method	The interpolation method enum to add

The method name must be supported by fvFaceInterpolationMethodType().

Definition at line 103 of file NSFVUtils.C.

{
  const std::string method_name = interpolation_method;
  if (problem.hasFVInterpolationMethod(method_name))
    return;
 
  const auto method_type = fvFaceInterpolationMethodType(interpolation_method);
 
  InputParameters params = factory.getValidParams(method_type);
  problem.addFVInterpolationMethod(method_type, method_name, params);
}

◆ computeShearStrainRateNormSquared()

template<typename T >

T NS::computeShearStrainRateNormSquared	(	const Moose::Functor< T > &	u,
		const Moose::Functor< T > *	v,
		const Moose::Functor< T > *	w,
		const Moose::ElemArg &	elem_arg,
		const Moose::StateArg &	state,
		const Moose::CoordinateSystemType	coord_sys = `Moose::COORD_XYZ`,
		const unsigned int	rz_radial_coord = `0`
	)

Utility function to compute the shear strain rate.

Definition at line 249 of file NavierStokesMethods.C.

{
  const auto & grad_u = u.gradient(elem_arg, state);
  const T Sij_xx = 2.0 * grad_u(0);
  T Sij_xy = 0.0;
  T Sij_xz = 0.0;
  T Sij_yy = 0.0;
  T Sij_yz = 0.0;
  T Sij_zz = 0.0;
 
  const T grad_xx = grad_u(0);
  T grad_xy = 0.0;
  T grad_xz = 0.0;
  T grad_yx = 0.0;
  T grad_yy = 0.0;
  T grad_yz = 0.0;
  T grad_zx = 0.0;
  T grad_zy = 0.0;
  T grad_zz = 0.0;
 
  T trace = Sij_xx / 3.0;
 
  if (v) // dim >= 2
  {
    const auto & grad_v = (*v).gradient(elem_arg, state);
    Sij_xy = grad_u(1) + grad_v(0);
    Sij_yy = 2.0 * grad_v(1);
 
    grad_xy = grad_u(1);
    grad_yx = grad_v(0);
    grad_yy = grad_v(1);
 
    trace += Sij_yy / 3.0;
 
    if (w) // dim >= 3
    {
      const auto & grad_w = (*w).gradient(elem_arg, state);
 
      Sij_xz = grad_u(2) + grad_w(0);
      Sij_yz = grad_v(2) + grad_w(1);
      Sij_zz = 2.0 * grad_w(2);
 
      grad_xz = grad_u(2);
      grad_yz = grad_v(2);
      grad_zx = grad_w(0);
      grad_zy = grad_w(1);
      grad_zz = grad_w(2);
 
      trace += Sij_zz / 3.0;
    }
  }
 
  if (coord_sys == Moose::COORD_RZ)
  {
    mooseAssert(elem_arg.elem, "ElemArg must reference an element for cylindrical calculations.");
    const auto radius = elem_arg.elem->vertex_average()(rz_radial_coord);
    mooseAssert(radius > 0.0, "Axisymmetric radial coordinate should be positive.");
 
    const Moose::Functor<T> * radial_functor = nullptr;
    switch (rz_radial_coord)
    {
      case 0:
        radial_functor = &u;
        break;
      case 1:
        radial_functor = v;
        break;
      default:
        mooseError("Unsupported axisymmetric radial coordinate index: ", rz_radial_coord);
    }
 
    mooseAssert(radial_functor,
                "The functor corresponding to the axisymmetric radial velocity must be provided.");
    const T radial_velocity = (*radial_functor)(elem_arg, state);
    Sij_zz = 2.0 * radial_velocity / radius;
    grad_zz = radial_velocity / radius;
    trace += Sij_zz / 3.0;
  }
 
  // Note that in RZ we can only do X or Y axis. However, due to the hoop stress the
  // Z direction (polar coordinate) tensors are not 0 in this case.
  return (Sij_xx - trace) * grad_xx + Sij_xy * grad_xy + Sij_xz * grad_xz + Sij_xy * grad_yx +
         (Sij_yy - trace) * grad_yy + Sij_yz * grad_yz + Sij_xz * grad_zx + Sij_yz * grad_zy +
         (Sij_zz - trace) * grad_zz;
}

◆ computeShearStrainRateNormSquared< ADReal >()

template ADReal NS::computeShearStrainRateNormSquared< ADReal >	(	const Moose::Functor< ADReal > &	u,
		const Moose::Functor< ADReal > *	v,
		const Moose::Functor< ADReal > *	w,
		const Moose::ElemArg &	elem_arg,
		const Moose::StateArg &	state,
		const Moose::CoordinateSystemType	coord_sys,
		const unsigned int	rz_radial_coord
	)

extern

Referenced by INSFVTKEDSourceSink::computeQpResidual(), and INSFVTKESourceSink::computeQpResidual().

◆ computeShearStrainRateNormSquared< Real >()

template Real NS::computeShearStrainRateNormSquared< Real >	(	const Moose::Functor< Real > &	u,
		const Moose::Functor< Real > *	v,
		const Moose::Functor< Real > *	w,
		const Moose::ElemArg &	elem_arg,
		const Moose::StateArg &	state,
		const Moose::CoordinateSystemType	coord_sys,
		const unsigned int	rz_radial_coord
	)

extern

Referenced by LinearFVTKEDSourceSink::computeRightHandSideContribution(), and LinearFVTKESourceSink::computeRightHandSideContribution().

◆ computeSign()

int NS::computeSign ( const Real & a )

Sign function, returns $+1$ if $a$ is positive and $-1$ if $a$ is negative.

Parameters

[in] a number

Returns: the sign of the input

Definition at line 27 of file NavierStokesMethods.C.

{
  return a > 0 ? 1 : (a < 0 ? -1 : 0);
}

◆ computeSpeed()

template<typename T >

T NS::computeSpeed ( const libMesh::VectorValue< T > & velocity )

Compute the speed (velocity norm) given the supplied velocity.

Definition at line 236 of file NavierStokesMethods.C.

{
  // if the velocity is zero, then the norm function call fails because AD tries to calculate the
  // derivatives which causes a divide by zero - because d/dx(sqrt(f(x))) = 1/2/sqrt(f(x))*df/dx.
  // So add a bit of noise (based on hitchhiker's guide to the galaxy's meaning of life number) to
  // avoid this failure mode.
  return isZero(velocity) ? 1e-42 : velocity.norm();
}

Referenced by LinearFVMomentumFriction::computeFrictionCoefficient().

◆ computeSpeed< ADReal >()

template ADReal NS::computeSpeed< ADReal > ( const libMesh::VectorValue< ADReal > & velocity )

extern

Referenced by INSFVTKEDWallFunctionBC::boundaryValue(), INSFVTurbulentViscosityWallFunction::boundaryValue(), PINSFVMomentumFriction::computeFrictionWCoefficient(), ConservedVarValuesMaterial::computeQpProperties(), INSADTauMaterialTempl< T >::computeQpProperties(), PorousConservedVarMaterial::computeQpProperties(), PorousMixedVarMaterial::computeQpProperties(), PorousPrimitiveVarMaterial::computeQpProperties(), INSFVTurbulentTemperatureWallFunction::computeQpResidual(), INSFVTKEDSourceSink::computeQpResidual(), INSFVTKESourceSink::computeQpResidual(), WCNSFV2PInterfaceAreaSourceSink::computeQpResidual(), LinearFrictionFactorFunctorMaterial::LinearFrictionFactorFunctorMaterial(), NSFVDispersePhaseDragFunctorMaterial::NSFVDispersePhaseDragFunctorMaterial(), and PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial().

◆ computeSpeed< Real >()

template Real NS::computeSpeed< Real > ( const libMesh::VectorValue< Real > & velocity )

extern

Referenced by LinearFVTKESourceSink::computeMatrixContribution(), LinearFVTKEDSourceSink::computeRightHandSideContribution(), LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), and RANSYPlusAux::computeValue().

◆ delta()

int NS::delta	(	unsigned int	i,
		unsigned int	j
	)

Delta function, which returns zero if $i\ne j$ and unity if $i=j$.

Parameters

[in]	i	integer number
[in]	j	integer number

Returns: delta function

Definition at line 18 of file NavierStokesMethods.C.

{
  if (i == j)
    return 1;
  else
    return 0;
}

◆ divergence()

template<typename T , typename VectorType , typename PointType >

T NS::divergence	(	const TensorValue< T > &	gradient,
		const VectorType &	value,
		const PointType &	point,
		const Moose::CoordinateSystemType &	coord_sys,
		const unsigned int	rz_radial_coord
	)

Compute the divergence of a vector given its matrix of derivatives.

Definition at line 183 of file NavierStokesMethods.h.

{
  mooseAssert((coord_sys == Moose::COORD_XYZ) || (coord_sys == Moose::COORD_RZ),
              "This function only supports calculations of divergence in Cartesian and "
              "axisymmetric coordinate systems");
  auto div = gradient.tr();
  if (coord_sys == Moose::COORD_RZ)
    // u_r / r
    div += value(rz_radial_coord) / point(rz_radial_coord);
  return div;
}

Referenced by INSADMaterial::computeQpProperties(), INSADMomentumGradDiv::computeQpResidual(), and INSFVMomentumDiffusion::computeStrongResidual().

◆ findUStar()

template<typename T >

T NS::findUStar	(	const T &	mu,
		const T &	rho,
		const T &	u,
		Real	dist
	)

Finds the friction velocity using standard velocity wall functions formulation.

It is used in WallFunctionWallShearStressAux, WallFunctionYPlusAux and INSFVWallFunctionBC.

Parameters

mu	the dynamic viscosity
rho	the density
u	the centroid velocity
dist	the element centroid distance to the wall

Returns: the velocity at the wall

This is important to reduce the number of nonlinear iterations

Definition at line 65 of file NavierStokesMethods.C.

{
  using std::log, std::sqrt, std::pow, std::max, std::abs;
 
  // usually takes about 3-4 iterations
  constexpr int MAX_ITERS{50};
  constexpr Real REL_TOLERANCE{1e-6};
 
  // Check inputs
  mooseAssert(mu > 0, "Need a strictly positive viscosity");
  mooseAssert(rho > 0, "Need a strictly positive density");
  mooseAssert(u > 0, "Need a strictly positive velocity");
  mooseAssert(dist > 0, "Need a strictly positive wall distance");
 
  const T nu = mu / rho;
 
  // Wall-function linearized guess
  const Real a_c = 1 / NS::von_karman_constant;
  const T b_c = 1.0 / NS::von_karman_constant * (log(NS::E_turb_constant * dist / mu) + 1.0);
  const T & c_c = u;
 
  T u_star = max(1e-20, (-b_c + sqrt(pow(b_c, 2) + 4.0 * a_c * c_c)) / (2.0 * a_c));
 
  // Newton-Raphson method to solve for u_star (friction velocity).
  for (int i = 0; i < MAX_ITERS; ++i)
  {
    T residual =
        u_star / NS::von_karman_constant * log(NS::E_turb_constant * u_star * dist / nu) - u;
    T deriv = (1.0 + log(NS::E_turb_constant * u_star * dist / nu)) / NS::von_karman_constant;
    T new_u_star = max(1e-20, u_star - residual / deriv);
 
    Real rel_err =
        abs(MetaPhysicL::raw_value(new_u_star - u_star) / MetaPhysicL::raw_value(new_u_star));
 
    u_star = new_u_star;
    if (rel_err < REL_TOLERANCE)
      return u_star;
  }
 
  mooseException("Could not find the wall friction velocity (mu: ",
                 mu,
                 " rho: ",
                 rho,
                 " velocity: ",
                 u,
                 " wall distance: ",
                 dist,
                 ")");
}

◆ findUStar< ADReal >()

template ADReal NS::findUStar< ADReal >	(	const ADReal &	mu,
		const ADReal &	rho,
		const ADReal &	u,
		const Real	dist
	)

extern

Referenced by INSFVTKEDWallFunctionBC::boundaryValue(), INSFVTurbulentViscosityWallFunction::boundaryValue(), INSFVTurbulentTemperatureWallFunction::computeQpResidual(), and INSFVWallFunctionBC::computeStrongResidual().

◆ findUStar< Real >()

template Real NS::findUStar< Real >	(	const Real &	mu,
		const Real &	rho,
		const Real &	u,
		const Real	dist
	)

extern

Referenced by LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), WallFunctionWallShearStressAux::computeValue(), and WallFunctionYPlusAux::computeValue().

◆ findyPlus()

template<typename T >

T NS::findyPlus	(	const T &	mu,
		const T &	rho,
		const T &	u,
		Real	dist
	)

Finds the non-dimensional wall distance normalized with the friction velocity Implements a fixed-point iteration in the wall function to get this velocity.

Parameters

mu	the dynamic viscosity
rho	the density
u	the centroid velocity
dist	the element centroid distance to the wall

Returns: the non-dimensional wall distance

Definition at line 121 of file NavierStokesMethods.C.

{
  using std::max, std::log, std::abs;
 
  // Fixed point iteration method to find y_plus
  // It should take 3 or 4 iterations
  constexpr int MAX_ITERS{10};
  constexpr Real REL_TOLERANCE{1e-2};
 
  // Check inputs
  mooseAssert(mu > 0, "Need a strictly positive viscosity");
  mooseAssert(u > 0, "Need a strictly positive velocity");
  mooseAssert(rho > 0, "Need a strictly positive density");
  mooseAssert(dist > 0, "Need a strictly positive wall distance");
 
  Real yPlusLast = 0.0;
  T yPlus = dist * u * rho / mu; // Assign initial value to laminar
  const Real rev_yPlusLam = 1.0 / MetaPhysicL::raw_value(yPlus);
  const T kappa_time_Re = NS::von_karman_constant * u * dist / (mu / rho);
  unsigned int iters = 0;
 
  do
  {
    yPlusLast = MetaPhysicL::raw_value(yPlus);
    // Negative y plus does not make sense
    yPlus = max(NS::min_y_plus, yPlus);
    yPlus = (kappa_time_Re + yPlus) / (1.0 + log(NS::E_turb_constant * yPlus));
  } while (abs(rev_yPlusLam * (MetaPhysicL::raw_value(yPlus) - yPlusLast)) > REL_TOLERANCE &&
           ++iters < MAX_ITERS);
 
  return max(NS::min_y_plus, yPlus);
}

◆ findyPlus< ADReal >()

template ADReal NS::findyPlus< ADReal >	(	const ADReal &	mu,
		const ADReal &	rho,
		const ADReal &	u,
		Real	dist
	)

extern

Referenced by INSFVTurbulentViscosityWallFunction::boundaryValue(), INSFVTurbulentTemperatureWallFunction::computeQpResidual(), INSFVTKEDSourceSink::computeQpResidual(), and INSFVTKESourceSink::computeQpResidual().

◆ findyPlus< Real >()

template Real NS::findyPlus< Real >	(	const Real &	mu,
		const Real &	rho,
		const Real &	u,
		Real	dist
	)

extern

Referenced by LinearFVTKESourceSink::computeMatrixContribution(), LinearFVTKEDSourceSink::computeRightHandSideContribution(), LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), and RANSYPlusAux::computeValue().

◆ findYplusThermal()

template<typename T >

T NS::findYplusThermal	(	const T &	Pr,
		const T &	Pr_t
	)

Finds the thermal non-dimensional wall distance at which the laminar and logarithmic temperature wall functions intersect.

If multiple intersections exist, this is intended to recover the largest one.

Parameters

Pr	the molecular Prandtl number
Pr_t	the turbulent Prandtl number

Returns: the thermal matching non-dimensional wall distance

Definition at line 160 of file NavierStokesMethods.C.

{
  using std::abs, std::exp, std::log, std::max, std::pow;
 
  constexpr int MAX_ITERS{35};
  constexpr Real REL_TOLERANCE{1e-3};
  constexpr Real DERIV_TOLERANCE{1e-12};
 
  mooseAssert(Pr > 0, "Need a strictly positive Prandtl number");
  mooseAssert(Pr_t > 0, "Need a strictly positive turbulent Prandtl number");
 
  const auto Pr_ratio = Pr / Pr_t;
 
  const auto jayatilleke_P =
      9.24 * (pow(Pr_ratio, 0.75) - 1.0) * (1.0 + 0.28 * exp(-0.007 * Pr_ratio));
 
  auto f = [&](const T y)
  {
    return Pr * y -
           Pr_t * (1.0 / NS::von_karman_constant * log(NS::E_turb_constant * y) + jayatilleke_P);
  };
 
  auto df = [&](const T y) { return Pr - Pr_t * (1.0 / NS::von_karman_constant / y); };
 
  // Location of the minimum of f(y); the larger root is to the right of this.
  const auto y_plus_min = Pr_t / (Pr * NS::von_karman_constant);
 
  // Start to the right of the minimum so Newton converges to the larger root.
  auto y_plus = max(1.5 * y_plus_min, NS::min_y_plus);
  auto y_plus_last = y_plus;
 
  // If the minimum is above zero, no real intersection exists.
  const auto f_min = f(y_plus_min);
  if (f_min > 0.0)
    return T(y_plus);
 
  unsigned int iters = 0;
  do
  {
    y_plus_last = y_plus;
 
    const auto f_val = f(y_plus);
    const auto df_val = df(y_plus);
 
    // Avoid division by nearly zero derivative
    if (abs(df_val) < DERIV_TOLERANCE)
      mooseException("Derivative vanished while finding the thermal matching non-dimensional wall "
                     "distance (Pr: ",
                     Pr,
                     " Pr_t: ",
                     Pr_t,
                     ")");
 
    auto y_new = y_plus - f_val / df_val;
 
    // Keep Newton on the right branch so we get the largest root
    if (y_new <= y_plus_min)
      y_new = 0.5 * (y_plus + y_plus_min);
 
    y_plus = max(y_new, NS::min_y_plus);
  } while (abs((y_plus - y_plus_last) / y_plus_last) > REL_TOLERANCE && ++iters < MAX_ITERS);
 
  if (iters >= MAX_ITERS && abs(f(y_plus)) > REL_TOLERANCE * Pr_t)
    mooseException("Could not find the thermal matching non-dimensional wall distance (Pr: ",
                   Pr,
                   " Pr_t: ",
                   Pr_t,
                   ")");
 
  return T(max(y_plus, NS::min_y_plus));
}

◆ findYplusThermal< Real >()

template Real NS::findYplusThermal< Real >	(	const Real &	Pr,
		const Real &	Pr_t
	)

Referenced by LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), and TEST().

◆ fvAdvectedInterpolationMethods()

MooseEnum NS::fvAdvectedInterpolationMethods ( )

Enum of the advected interpolation methods supported by FVInterpolationMethod objects.

Definition at line 61 of file NSFVUtils.C.

{
  return MooseEnum("average upwind vanLeer min_mod venkatakrishnan", "upwind");
}

Referenced by WCNSFVTurbulencePhysicsBase::validParams(), WCNSLinearFVFlowPhysics::validParams(), and WCNSLinearFVScalarTransportPhysics::validParams().

◆ fvAdvectedInterpolationMethodType()

std::string NS::fvAdvectedInterpolationMethodType ( const MooseEnum & interpolation_method )

Gets the FVInterpolationMethod object type for an advected interpolation method.

Parameters

interpolation_method The interpolation method enum to query

Errors when no FVInterpolationMethod equivalent is supported.

Definition at line 67 of file NSFVUtils.C.

{
  const std::string method_name = interpolation_method;
  if (interpolation_method == "average")
    return "FVGeometricAverage";
  if (interpolation_method == "upwind")
    return "FVAdvectedUpwind";
  if (interpolation_method == "vanLeer")
    return "FVAdvectedVanLeerWeightBased";
  if (interpolation_method == "min_mod")
    return "FVAdvectedMinmodWeightBased";
  if (interpolation_method == "venkatakrishnan")
    return "FVAdvectedMUSCLDeferredCorrection";
 
  mooseError("Unsupported linear FV advected interpolation method '", method_name, "'.");
}

Referenced by NavierStokesPhysicsBase::addFVAdvectedInterpolationMethod().

◆ fvFaceInterpolationMethods()

MooseEnum NS::fvFaceInterpolationMethods ( )

Enum of the interpolation methods supported by FVInterpolationMethod objects.

Definition at line 85 of file NSFVUtils.C.

{
  return MooseEnum("average harmonic");
}

Referenced by WCNSLinearFVFlowPhysics::validParams().

◆ fvFaceInterpolationMethodType()

std::string NS::fvFaceInterpolationMethodType ( const MooseEnum & interpolation_method )

Gets the FVInterpolationMethod object type for a face interpolation method name.

Parameters

interpolation_method The interpolation method enum to query

Errors when no FVInterpolationMethod equivalent is supported.

Definition at line 91 of file NSFVUtils.C.

{
  const std::string method_name = interpolation_method;
  if (interpolation_method == "average")
    return "FVGeometricAverage";
  if (interpolation_method == "harmonic")
    return "FVHarmonicAverage";
 
  mooseError("Unsupported linear FV face interpolation method '", method_name, "'.");
}

Referenced by addFVFaceInterpolationMethod().

◆ getElementFaceArgs()

void NS::getElementFaceArgs	(	const std::vector< BoundaryName > &	wall_boundary_name,
		const FEProblemBase &	fe_problem,
		const SubProblem &	subproblem,
		const std::set< SubdomainID > &	block_ids,
		std::map< const Elem , std::vector< const FaceInfo > > &	face_info_map
	)

Map storing face arguments to wall bounded faces The map passed in face_info_map gets cleared and re-populated.

Face arguments to wall-bounded faces for wall treatment.

Definition at line 491 of file NavierStokesMethods.C.

{
  face_info_map.clear();
  const auto wall_boundary_ids = subproblem.mesh().getBoundaryIDs(wall_boundary_name);
 
  for (const auto & elem : fe_problem.mesh().getMesh().active_local_element_ptr_range())
    if (block_ids.find(elem->subdomain_id()) != block_ids.end())
      for (const auto i_side : elem->side_index_range())
      {
        // This is needed because in some cases the internal boundary is registered
        // to the neighbor element
        std::set<BoundaryID> combined_side_bds;
        const auto & side_bnds = subproblem.mesh().getBoundaryIDs(elem, i_side);
        combined_side_bds.insert(side_bnds.begin(), side_bnds.end());
        if (elem->neighbor_ptr(i_side) && !elem->neighbor_ptr(i_side)->is_remote())
        {
          const auto neighbor = elem->neighbor_ptr(i_side);
          const auto neighbor_side = neighbor->which_neighbor_am_i(elem);
          const std::vector<BoundaryID> & neighbor_bnds =
              subproblem.mesh().getBoundaryIDs(neighbor, neighbor_side);
          combined_side_bds.insert(neighbor_bnds.begin(), neighbor_bnds.end());
        }
 
        for (const auto wall_id : wall_boundary_ids)
          if (combined_side_bds.count(wall_id))
          {
            // The list below stores the face infos with respect to their owning elements,
            // depending on the block restriction we might encounter situations where the
            // element outside of the block owns the face info.
            const auto & neighbor = elem->neighbor_ptr(i_side);
            const auto elem_has_fi = Moose::FV::elemHasFaceInfo(*elem, neighbor);
            const auto & elem_for_fi = elem_has_fi ? elem : neighbor;
            const auto side = elem_has_fi ? i_side : neighbor->which_neighbor_am_i(elem);
 
            const FaceInfo * const fi = subproblem.mesh().faceInfo(elem_for_fi, side);
            face_info_map[elem].push_back(fi);
          }
      }
}

Referenced by kEpsilonViscosityAux::initialSetup(), RANSYPlusAux::initialSetup(), INSFVTKEDSourceSink::initialSetup(), INSFVTKESourceSink::initialSetup(), LinearFVTKEDSourceSink::initialSetup(), and LinearFVTKESourceSink::initialSetup().

◆ getIndex()

unsigned int NS::getIndex	(	const Real &	p,
		const std::vector< Real > &	bounds
	)

Determines the index $i$ in a sorted array such that the input point is within the $i$-th and $i+1$-th entries in the array.

Parameters

[in]	p	input point
[in]	bounds	sorted array

Returns: index of point

Definition at line 33 of file NavierStokesMethods.C.

{
  if (p < bounds.front() || p > bounds.back())
    mooseError("Point exceeds bounds of domain!");
 
  for (unsigned int i = 1; i < bounds.size(); ++i)
    if (p <= bounds[i])
      return i - 1;
 
  return bounds.size() - 2;
}

◆ getWallBoundedElements()

void NS::getWallBoundedElements	(	const std::vector< BoundaryName > &	wall_boundary_name,
		const FEProblemBase &	fe_problem,
		const SubProblem &	subproblem,
		const std::set< SubdomainID > &	block_ids,
		std::unordered_set< const Elem * > &	wall_bounded
	)

Map marking wall bounded elements The map passed in wall_bounded_map gets cleared and re-populated.

Bounded element maps for wall treatment.

Definition at line 358 of file NavierStokesMethods.C.

{
 
  wall_bounded.clear();
  const auto wall_boundary_ids = subproblem.mesh().getBoundaryIDs(wall_boundary_names);
 
  // We define these lambdas so that we can fetch the bounded elements from other
  // processors.
  auto gather_functor = [&subproblem, &wall_bounded](const processor_id_type libmesh_dbg_var(pid),
                                                     const std::vector<dof_id_type> & elem_ids,
                                                     std::vector<unsigned char> & data_to_fill)
  {
    mooseAssert(pid != subproblem.processor_id(), "We shouldn't be gathering from ourselves.");
    data_to_fill.resize(elem_ids.size());
 
    const auto & mesh = subproblem.mesh().getMesh();
 
    for (const auto i : index_range(elem_ids))
    {
      const auto elem = mesh.elem_ptr(elem_ids[i]);
      data_to_fill[i] = wall_bounded.count(elem) != 0;
    }
  };
 
  auto action_functor = [&subproblem, &wall_bounded](const processor_id_type libmesh_dbg_var(pid),
                                                     const std::vector<dof_id_type> & elem_ids,
                                                     const std::vector<unsigned char> & filled_data)
  {
    mooseAssert(pid != subproblem.processor_id(),
                "The request filler shouldn't have been ourselves");
    mooseAssert(elem_ids.size() == filled_data.size(), "I think these should be the same size");
 
    const auto & mesh = subproblem.mesh().getMesh();
 
    for (const auto i : index_range(elem_ids))
    {
      const auto elem = mesh.elem_ptr(elem_ids[i]);
      if (filled_data[i])
        wall_bounded.insert(elem);
    }
  };
 
  // We need these elements from other processors
  std::unordered_map<processor_id_type, std::vector<dof_id_type>> elem_ids_requested;
 
  for (const auto & elem : fe_problem.mesh().getMesh().active_local_element_ptr_range())
    if (block_ids.find(elem->subdomain_id()) != block_ids.end())
      for (const auto i_side : elem->side_index_range())
      {
        // This is needed because in some cases the internal boundary is registered
        // to the neighbor element
        std::set<BoundaryID> combined_side_bds;
        const auto & side_bnds = subproblem.mesh().getBoundaryIDs(elem, i_side);
        combined_side_bds.insert(side_bnds.begin(), side_bnds.end());
        if (const auto neighbor = elem->neighbor_ptr(i_side))
        {
          const auto neighbor_side = neighbor->which_neighbor_am_i(elem);
          const auto & neighbor_bnds = subproblem.mesh().getBoundaryIDs(neighbor, neighbor_side);
          combined_side_bds.insert(neighbor_bnds.begin(), neighbor_bnds.end());
 
          // If the neighbor lives on the first layer of the ghost region then we would
          // like to grab its value as well (if it exists)
          if (neighbor->processor_id() != subproblem.processor_id() &&
              block_ids.find(neighbor->subdomain_id()) != block_ids.end())
            elem_ids_requested[neighbor->processor_id()].push_back(neighbor->id());
        }
 
        for (const auto wall_id : wall_boundary_ids)
          if (combined_side_bds.count(wall_id))
          {
            wall_bounded.insert(elem);
            break;
          }
      }
 
  unsigned char * bool_ex = nullptr;
  TIMPI::pull_parallel_vector_data(
      subproblem.comm(), elem_ids_requested, gather_functor, action_functor, bool_ex);
}

Referenced by kEpsilonViscosityAux::initialSetup(), RANSYPlusAux::initialSetup(), INSFVTKEDSourceSink::initialSetup(), INSFVTKESourceSink::initialSetup(), INSFVTurbulentAdvection::initialSetup(), INSFVTurbulentDiffusion::initialSetup(), LinearFVTKEDSourceSink::initialSetup(), LinearFVTKESourceSink::initialSetup(), LinearFVTurbulentAdvection::initialSetup(), LinearFVTurbulentDiffusion::initialSetup(), and LinearFVTurbulentTimeDerivative::initialSetup().

◆ getWallDistance()

void NS::getWallDistance	(	const std::vector< BoundaryName > &	wall_boundary_name,
		const FEProblemBase &	fe_problem,
		const SubProblem &	subproblem,
		const std::set< SubdomainID > &	block_ids,
		std::map< const Elem *, std::vector< Real > > &	dist_map
	)

Map storing wall ditance for near-wall marked elements The map passed in dist_map gets cleared and re-populated.

Bounded element face distances for wall treatment.

Definition at line 444 of file NavierStokesMethods.C.

{
  dist_map.clear();
  const auto wall_boundary_ids = subproblem.mesh().getBoundaryIDs(wall_boundary_name);
 
  for (const auto & elem : fe_problem.mesh().getMesh().active_local_element_ptr_range())
    if (block_ids.find(elem->subdomain_id()) != block_ids.end())
      for (const auto i_side : elem->side_index_range())
      {
        // This is needed because in some cases the internal boundary is registered
        // to the neighbor element
        std::set<BoundaryID> combined_side_bds;
        const auto & side_bnds = subproblem.mesh().getBoundaryIDs(elem, i_side);
        combined_side_bds.insert(side_bnds.begin(), side_bnds.end());
        if (const auto neighbor = elem->neighbor_ptr(i_side))
        {
          const auto neighbor_side = neighbor->which_neighbor_am_i(elem);
          const std::vector<BoundaryID> & neighbor_bnds =
              subproblem.mesh().getBoundaryIDs(neighbor, neighbor_side);
          combined_side_bds.insert(neighbor_bnds.begin(), neighbor_bnds.end());
        }
 
        for (const auto wall_id : wall_boundary_ids)
          if (combined_side_bds.count(wall_id))
          {
            // The list below stores the face infos with respect to their owning elements,
            // depending on the block restriction we might encounter situations where the
            // element outside of the block owns the face info.
            const auto & neighbor = elem->neighbor_ptr(i_side);
            const auto elem_has_fi = Moose::FV::elemHasFaceInfo(*elem, neighbor);
            const auto & elem_for_fi = elem_has_fi ? elem : neighbor;
            const auto side = elem_has_fi ? i_side : neighbor->which_neighbor_am_i(elem);
 
            const FaceInfo * const fi = subproblem.mesh().faceInfo(elem_for_fi, side);
            const auto & elem_centroid = elem_has_fi ? fi->elemCentroid() : fi->neighborCentroid();
            const Real dist = std::abs((elem_centroid - fi->faceCentroid()) * fi->normal());
            dist_map[elem].push_back(dist);
          }
      }
}

Referenced by kEpsilonViscosityAux::initialSetup(), RANSYPlusAux::initialSetup(), INSFVTKEDSourceSink::initialSetup(), INSFVTKESourceSink::initialSetup(), LinearFVTKEDSourceSink::initialSetup(), and LinearFVTKESourceSink::initialSetup().

◆ grad()

std::string NS::grad ( const std::string & var )

inline

Definition at line 92 of file NS.h.

{
  return MathUtils::gradName(var);
}

◆ isPorosityJumpFace()

template<class T >

std::tuple< bool, T, T > NS::isPorosityJumpFace	(	const Moose::FunctorBase< T > &	porosity,
		const FaceInfo &	fi,
		const Moose::StateArg &	time
	)

Checks to see whether the porosity value jumps from one side to the other of the provided face.

Parameters

porosity	the porosity
fi	the face to inspect for porosity jumps
time	A temporal argument indicating at what time state to evaluate the porosity

Returns: a tuple where the zeroth member indicates whether there is a jump, the first member is 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

Definition at line 119 of file NSFVUtils.C.

{
  if (!fi.neighborPtr() || (fi.elem().subdomain_id() == fi.neighbor().subdomain_id()))
    // We've agreed to only support porosity jump treatment at subdomain boundaries
    return {false, 0, 0};
 
  mooseAssert(porosity.hasBlocks(fi.elem().subdomain_id()) &&
                  porosity.hasBlocks(fi.neighbor().subdomain_id()),
              "Porosity should have blocks on both elem and neighbor");
 
  const Moose::FaceArg face_elem{
      &fi, Moose::FV::LimiterType::CentralDifference, true, false, fi.elemPtr(), nullptr};
  const Moose::FaceArg face_neighbor{
      &fi, Moose::FV::LimiterType::CentralDifference, true, false, fi.neighborPtr(), nullptr};
  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};
}

Referenced by INSFVMomentumAdvection::computeResidualsAndAData(), WCNSFV2PMomentumAdvectionSlip::computeResidualsAndAData(), HasPorosityJumpFace::computeValue(), BernoulliPressureVariable::getDirichletBoundaryFaceValue(), INSFVRhieChowInterpolator::getVelocity(), BernoulliPressureVariable::isDirichletBoundaryFace(), and BernoulliPressureVariable::isExtrapolatedBoundaryFace().

◆ isPorosityJumpFace< ADReal >()

template std::tuple< bool, ADReal, ADReal > NS::isPorosityJumpFace< ADReal >	(	const Moose::FunctorBase< ADReal > &	porosity,
		const FaceInfo &	fi,
		const Moose::StateArg &	time
	)

extern

◆ isPorosityJumpFace< Real >()

template std::tuple< bool, Real, Real > NS::isPorosityJumpFace< Real >	(	const Moose::FunctorBase< Real > &	porosity,
		const FaceInfo &	fi,
		const Moose::StateArg &	time
	)

extern

◆ prandtlPropertyDerivative()

Real NS::prandtlPropertyDerivative	(	const Real &	mu,
		const Real &	cp,
		const Real &	k,
		const Real &	dmu,
		const Real &	dcp,
		const Real &	dk
	)

Computes the derivative of the Prandtl number, $Pr\equiv\frac{\mu C_p}{k}$, with respect to an arbitrary variale $\zeta$.

This derivative is

$\frac{\partial Pr}{\partial \zeta}=\frac{k\left(\mu\frac{\partial C_p}{\partial\zeta}+C_p\frac{\partial mu}{\partial\zeta}\right)-\mu C_p\frac{\partial k}{\partial\zeta}}{k^2}$

Parameters

[in]	mu	dynamic viscosity
[in]	cp	isobaric specific heat
[in]	k	thermal conductivity
[in]	dmu	derivative of dynamic viscosity with respect to $\zeta$
[in]	dcp	derivative of isobaric specific heat with respect to $\zeta$
[in]	dk	derivative of thermal conductivity with respect to $\zeta$

Returns: derivative of Prandtl number with respect to $\zeta$

Definition at line 53 of file NavierStokesMethods.C.

{
  return (k * (mu * dcp + cp * dmu) - mu * cp * dk) / std::max(k * k, 1e-8);
}

Referenced by GeneralFluidProps::computeQpProperties(), and GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl().

◆ reynoldsPropertyDerivative()

Real NS::reynoldsPropertyDerivative	(	const Real &	Re,
		const Real &	rho,
		const Real &	mu,
		const Real &	drho,
		const Real &	dmu
	)

Computes the derivative of the Reynolds number, $Re\equiv \frac{\rho Vd}{\mu}$, with respect to an arbitrary variable $\zeta$, where it is assumed that only the material properties of density $\rho$ and dynamic viscosity $\mu$ have nonzero derivatives with respect to $\zeta$.

To eliminate the need to pass in the velocity $V$ and characteristic length $d$, the derivative is rewritten in terms of the Reynolds number such that the partial derivative of $Re$ with respect to an aritrary parameter $\zeta$ is

$\frac{\partial Re}{\partial\zeta}=Re\left(\frac{1}{\rho}\frac{\partial\rho}{\partial x}-\frac{1}{\mu}\frac{\partial\mu}{\partial x}$

Parameters

[in]	Re	Reynolds number
[in]	rho	density
[in]	mu	dynamic viscosity
[in]	drho	partial derivative of density with respect to arbitrary variable $\zeta$
[in]	dmu	partial derivative of dynamic viscosity with respect to arbitrary variable $\zeta$

Returns: derivative of Reynolds number with respect to $\zeta$

Definition at line 46 of file NavierStokesMethods.C.

{
  return Re * (drho / std::max(rho, 1e-6) - dmu / std::max(mu, 1e-8));
}

Referenced by GeneralFluidProps::computeQpProperties(), and GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl().

◆ time_deriv()

std::string NS::time_deriv ( const std::string & var )

inline

Definition at line 98 of file NS.h.

{
  if (MooseUtils::isFloat(var))
    return "0";
  else
    return MathUtils::timeDerivName(var);
}

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyTimeKernels(), WCNSFVFlowPhysics::addMassTimeKernels(), WCNSFVFlowPhysics::addMomentumTimeKernels(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyTimeKernels(), AriaLaserWeld304LStainlessSteelFunctorMaterial::AriaLaserWeld304LStainlessSteelFunctorMaterial(), GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl(), INSFVEnthalpyFunctorMaterial::INSFVEnthalpyFunctorMaterial(), PINSFVEnergyTimeDerivative::PINSFVEnergyTimeDerivative(), RhoFromPTFunctorMaterial::RhoFromPTFunctorMaterial(), INSFVEnergyTimeDerivative::validParams(), PINSFVEnergyTimeDerivative::validParams(), WCNSFVEnergyTimeDerivative::validParams(), WCNSFVMassTimeDerivative::validParams(), and WCNSFVMomentumTimeDerivative::validParams().

◆ wallHeatTransferCoefficient()

template<typename T1 , typename T2 , typename T3 >

auto NS::wallHeatTransferCoefficient	(	const T1 &	Nu,
		const T2 &	k,
		const T3 &	D_h
	)

Compute wall heat transfer coefficient.

Parameters

Nu	Nusselt number
k	Thermal conductivity
D_h	Hydraulic diameter

Returns: the wall heat transfer coefficient

Definition at line 209 of file NavierStokesMethods.h.

{
  return Nu * k / D_h;
}

Referenced by DittusBoelterFunctorMaterialTempl< is_ad >::DittusBoelterFunctorMaterialTempl(), and wallHeatTransferCoefficient().

Variable Documentation

◆ A

const std::string NS::A = "A"

static

Definition at line 166 of file NS.h.

◆ acceleration

const std::string NS::acceleration = "acceleration"

static

Definition at line 86 of file NS.h.

◆ alpha

const std::string NS::alpha = "alpha"

static

Definition at line 139 of file NS.h.

Referenced by NSFVBase::commonMomentumEquationParams(), NSFVEnergyAmbientConvection::validParams(), and NSFVMixturePhaseInterface::validParams().

◆ alpha_boussinesq

const std::string NS::alpha_boussinesq = "alpha_b"

static

Definition at line 117 of file NS.h.

Referenced by INSFVMomentumBoussinesq::validParams(), and LinearFVMomentumBoussinesq::validParams().

◆ alpha_exchange

const std::string NS::alpha_exchange = "alpha_exchange"

static

Definition at line 155 of file NS.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addPhaseInterfaceTerm(), WCNSLinearFVTwoPhaseMixturePhysics::addPhaseInterfaceTerm(), and WCNSFVTwoPhaseMixturePhysics::commonMixtureParams().

◆ alpha_wall

const std::string NS::alpha_wall = "alpha_wall"

static

Definition at line 140 of file NS.h.

◆ axis

const std::string NS::axis = "axis"

static

Definition at line 28 of file NS.h.

◆ c

const std::string NS::c = "c"

static

Definition at line 147 of file NS.h.

◆ C

const std::string NS::C = "C"

static

Definition at line 173 of file NS.h.

◆ center

const std::string NS::center = "center"

static

Definition at line 29 of file NS.h.

◆ cL

const std::string NS::cL = "Darcy_coefficient"

static

Definition at line 115 of file NS.h.

Referenced by FunctorIsotropicDragCoefficients< Derived >::FunctorIsotropicDragCoefficients().

◆ component

const std::string NS::component = "component"

static

Definition at line 158 of file NS.h.

◆ cp

const std::string NS::cp = "cp"

static

Definition at line 125 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSFVFluidHeatTransferPhysics::addEnergyInletBC(), WCNSFVFluidHeatTransferPhysics::addEnergyWallBC(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), PNSFVSolidHeatTransferPhysics::addMaterials(), WCNSFVFluidHeatTransferPhysics::addMaterials(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyTimeKernels(), AriaLaserWeld304LStainlessSteelFunctorMaterial::AriaLaserWeld304LStainlessSteelFunctorMaterial(), NSFVBase::commonFluidEnergyEquationParams(), prandtlPropertyDerivative(), EffectiveTurbulentThermalConductivityAux::validParams(), GeneralFunctorFluidPropsTempl< is_ad >::validParams(), INSFVEnthalpyFunctorMaterial::validParams(), ThermalDiffusivityFunctorMaterial::validParams(), INSFVTurbulentTemperatureWallFunction::validParams(), NSFVOutflowTemperatureBC::validParams(), WCNSFVEnergyFluxBC::validParams(), WCNSFVInletTemperatureBC::validParams(), PINSFVEnergyTimeDerivative::validParams(), WCNSFVMixingLengthEnergyDiffusion::validParams(), LinearFVTemperatureWallFunctionBC::validParams(), LinearFVEnthalpyVolumetricHeatTransfer::validParams(), PNSFVSolidHeatTransferPhysics::validParams(), and INSElementIntegralEnergyAdvectionTempl< is_ad >::validParams().

◆ cp_s

const std::string NS::cp_s = "cp_s"

static

Definition at line 123 of file NS.h.

◆ cQ

const std::string NS::cQ = "Forchheimer_coefficient"

static

Definition at line 116 of file NS.h.

Referenced by FunctorIsotropicDragCoefficients< Derived >::FunctorIsotropicDragCoefficients().

◆ cv

const std::string NS::cv = "cv"

static

Definition at line 126 of file NS.h.

Referenced by GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl().

◆ density

const std::string NS::density = "rho"

static

Definition at line 34 of file NS.h.

◆ diagonal_tau

const std::string NS::diagonal_tau = "diagonal_tau"

static

Definition at line 165 of file NS.h.

◆ directions

const std::string NS::directions[3] = {"x", "y", "z"}

static

Definition at line 23 of file NS.h.

23{"x", "y", "z"};

◆ dks_dTs

const std::string NS::dks_dTs = "dks_dTs"

static

Definition at line 119 of file NS.h.

◆ drhos_dTs

const std::string NS::drhos_dTs = "drhos_dTs"

static

Definition at line 118 of file NS.h.

◆ dS_dTs

const std::string NS::dS_dTs = "dS_dTs"

static

Definition at line 169 of file NS.h.

◆ dUdt

const std::string NS::dUdt = "dUdt"

static

Definition at line 172 of file NS.h.

◆ E_turb_constant

constexpr Real NS::E_turb_constant = 9.793

staticconstexpr

Definition at line 207 of file NS.h.

Referenced by INSFVTurbulentViscosityWallFunction::boundaryValue(), INSFVTurbulentTemperatureWallFunction::computeQpResidual(), LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), findUStar(), findyPlus(), and findYplusThermal().

◆ eddy_viscosity

const std::string NS::eddy_viscosity = "eddy_viscosity"

static

Definition at line 78 of file NS.h.

◆ enthalpy_density

const std::string NS::enthalpy_density = "rho_h"

static

Definition at line 71 of file NS.h.

Referenced by AriaLaserWeld304LStainlessSteelFunctorMaterial::AriaLaserWeld304LStainlessSteelFunctorMaterial(), INSFVEnthalpyFunctorMaterial::INSFVEnthalpyFunctorMaterial(), INSFVEnthalpyFunctorMaterial::validParams(), and INSFVEnergyAdvection::validParams().

◆ epsilon_low_limit

constexpr Real NS::epsilon_low_limit = 1.0e-8

staticconstexpr

Definition at line 211 of file NS.h.

Referenced by kEpsilonViscosityAux::computeValue(), and INSFVkEpsilonViscosityFunctorMaterial::INSFVkEpsilonViscosityFunctorMaterial().

◆ F

const std::string NS::F = "F"

static

Definition at line 170 of file NS.h.

◆ fluid

const std::string NS::fluid = "fp"

static

Definition at line 88 of file NS.h.

◆ G

const std::string NS::G = "G"

static

Definition at line 171 of file NS.h.

◆ heat_source

const std::string NS::heat_source = "heat_source"

static

Definition at line 112 of file NS.h.

◆ infinite_porosity

const std::string NS::infinite_porosity = "infinite_porosity"

static

Definition at line 27 of file NS.h.

◆ internal_energy

const std::string NS::internal_energy = "internal_energy"

static

Definition at line 62 of file NS.h.

◆ internal_energy_density

const std::string NS::internal_energy_density = "rho_e"

static

Definition at line 65 of file NS.h.

◆ k

const std::string NS::k = "k"

static

Definition at line 134 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyHeatConductionKernels(), AriaLaserWeld304LStainlessSteelFunctorMaterial::AriaLaserWeld304LStainlessSteelFunctorMaterial(), NSFVBase::commonFluidEnergyEquationParams(), prandtlPropertyDerivative(), EffectiveTurbulentThermalConductivityAux::validParams(), GeneralFunctorFluidPropsTempl< is_ad >::validParams(), ThermalDiffusivityFunctorMaterial::validParams(), NSFVFunctorHeatFluxBC::validParams(), PINSFVEnergyDiffusion::validParams(), LinearFVTemperatureWallFunctionBC::validParams(), and wallHeatTransferCoefficient().

◆ K

const std::string NS::K = "K"

static

Definition at line 175 of file NS.h.

◆ k_eff_t

const std::string NS::k_eff_t = "k_eff_t"

static

Definition at line 137 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSFVTurbulencePhysicsBase::addAuxiliaryVariables(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVTurbulencePhysicsBase::addMaterials(), WCNSFVFluidHeatTransferPhysicsBase::defineEffectiveThermalDiffusionCoeffFunctors(), and WCNSFVTurbulencePhysicsBase::WCNSFVTurbulencePhysicsBase().

◆ k_s

const std::string NS::k_s = "k_s"

static

Definition at line 124 of file NS.h.

Referenced by NSFVFunctorHeatFluxBC::validParams().

◆ k_t

const std::string NS::k_t = "k_t"

static

Definition at line 136 of file NS.h.

◆ kappa

const std::string NS::kappa = "kappa"

static

Definition at line 120 of file NS.h.

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyHeatConductionKernels(), WCNSFVFluidHeatTransferPhysics::addEnergyWallBC(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyHeatConductionKernels(), FunctorIsotropicEffectiveFluidThermalConductivity< Derived >::FunctorIsotropicEffectiveFluidThermalConductivity(), INSFVTurbulentTemperatureWallFunction::validParams(), NSFVFunctorHeatFluxBC::validParams(), and PINSFVEnergyAnisotropicDiffusion::validParams().

◆ kappa_s

const std::string NS::kappa_s = "kappa_s"

static

Definition at line 121 of file NS.h.

Referenced by NSFVFunctorHeatFluxBC::validParams().

◆ latent_heat

const std::string NS::latent_heat = "latent_heat"

static

Definition at line 152 of file NS.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addPhaseChangeEnergySource().

◆ mach_number

const std::string NS::mach_number = "Mach"

static

Definition at line 81 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSMachAux(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ mass_flux

const std::string NS::mass_flux = "mass_flux"

static

Definition at line 176 of file NS.h.

Referenced by NS::FV::pressureJumpOneSidedFaceValue().

◆ matrix_tau

const std::string NS::matrix_tau = "matrix_tau"

static

Definition at line 162 of file NS.h.

◆ min_y_plus

constexpr Real NS::min_y_plus = 1e-10

staticconstexpr

Definition at line 213 of file NS.h.

Referenced by findyPlus(), and findYplusThermal().

◆ mixing_length

const std::string NS::mixing_length = "mixing_length"

static

Definition at line 75 of file NS.h.

Referenced by WCNSFVTurbulencePhysics::addFlowTurbulenceKernels(), WCNSFVTurbulencePhysics::addFluidEnergyTurbulenceKernels(), WCNSFVTurbulencePhysics::addMaterials(), and WCNSFVTurbulencePhysics::addScalarAdvectionTurbulenceKernels().

◆ momentum

const std::string NS::momentum = "momentum"

static

Definition at line 84 of file NS.h.

◆ momentum_vector

const std::string NS::momentum_vector[3] = {momentum_x, momentum_y, momentum_z}

static

Definition at line 39 of file NS.h.

39{momentum_x, momentum_y, momentum_z};

NS::momentum_x

static const std::string momentum_x

Definition NS.h:36

NS::momentum_y

static const std::string momentum_y

Definition NS.h:37

NS::momentum_z

static const std::string momentum_z

Definition NS.h:38

◆ momentum_x

const std::string NS::momentum_x = "rhou"

static

◆ momentum_y

const std::string NS::momentum_y = "rhov"

static

◆ momentum_z

const std::string NS::momentum_z = "rhow"

static

◆ mu

const std::string NS::mu = "mu"

static

Definition at line 127 of file NS.h.

◆ mu_eff

const std::string NS::mu_eff = "mu_eff"

static

Definition at line 133 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addMaterials(), and WCNSLinearFVFlowPhysics::addMomentumFluxKernels().

◆ mu_t

const std::string NS::mu_t = "mu_t"

static

Definition at line 129 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSLinearFVTurbulencePhysics::addFunctorMaterials(), WCNSFVTurbulencePhysics::addFVBCs(), WCNSFVTurbulencePhysics::addKEpsilonSink(), WCNSLinearFVTurbulencePhysics::addKEpsilonSink(), WCNSFVTurbulencePhysicsBase::addMaterials(), INSFVkEpsilonViscosityFunctorMaterial::INSFVkEpsilonViscosityFunctorMaterial(), EffectiveTurbulentThermalConductivityAux::validParams(), FunctorEffectiveDynamicViscosityTempl< is_ad >::validParams(), INSFVTKEDWallFunctionBC::validParams(), INSFVTurbulentViscosityWallFunction::validParams(), INSFVTKEDSourceSink::validParams(), INSFVTKESourceSink::validParams(), LinearFVTKEDSourceSink::validParams(), and LinearFVTKESourceSink::validParams().

◆ mu_t_low_limit

constexpr Real NS::mu_t_low_limit = 1.0e-8

staticconstexpr

Definition at line 209 of file NS.h.

Referenced by INSFVTurbulentViscosityWallFunction::boundaryValue(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), and INSFVkEpsilonViscosityFunctorMaterial::INSFVkEpsilonViscosityFunctorMaterial().

◆ mu_t_passive_scalar

const std::string NS::mu_t_passive_scalar = "mu_t_passive_scalar"

static

Definition at line 131 of file NS.h.

Referenced by WCNSFVTurbulencePhysics::addScalarAdvectionTurbulenceKernels().

◆ pebble_diameter

const std::string NS::pebble_diameter = "pebble_diameter"

static

Definition at line 26 of file NS.h.

Referenced by FunctorPebbleBedDragCoefficients< Derived >::validParams().

◆ porosity

const std::string NS::porosity = "porosity"

static

Definition at line 108 of file NS.h.

◆ Prandtl

const std::string NS::Prandtl = "Pr"

static

Definition at line 142 of file NS.h.

Referenced by GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl(), and DittusBoelterFunctorMaterialTempl< is_ad >::validParams().

◆ pressure

const std::string NS::pressure = "pressure"

static

Definition at line 57 of file NS.h.

Referenced by CNSAction::act(), INSAction::act(), WCNSFVFluidHeatTransferPhysics::addEnergyInletBC(), WCNSFVFluidHeatTransferPhysics::addEnergyWallBC(), WCNSFVFlowPhysicsBase::addFluidPropertiesFunctorMaterial(), INSAction::addINSMomentum(), INSAction::addINSNoBCBC(), INSAction::addINSPressureBC(), WCNSFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), CNSAction::addNoPenetrationBC(), CNSAction::addNSMomentumInviscidFlux(), CNSAction::addSpecificTotalEnthalpyAux(), GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl(), WCNSFVFlowPhysicsBase::getFlowVariableName(), LinearFVMomentumPressure::getPressureVariable(), PrintMatricesNSProblem::onTimestepEnd(), PINSFVRhieChowInterpolator::pinsfvSetup(), PorousRhieChowMassFlux::PorousRhieChowMassFlux(), RhieChowInterpolatorBase::RhieChowInterpolatorBase(), RhieChowMassFlux::RhieChowMassFlux(), INSAction::setKernelCommonParams(), INSAction::setNoBCCommonParams(), EnthalpyAux::validParams(), INSStressComponentAux::validParams(), InternalEnergyAux::validParams(), NSSpecificTotalEnthalpyAux::validParams(), INSADMomentumNoBCBC::validParams(), INSMomentumNoBCBCBase::validParams(), INSPressureGradientBC::validParams(), MomentumFreeBC::validParams(), NSEnergyInviscidSpecifiedDensityAndVelocityBC::validParams(), NSEnergyInviscidSpecifiedNormalFlowBC::validParams(), NSEnergyInviscidUnspecifiedBC::validParams(), NSMomentumInviscidSpecifiedNormalFlowBC::validParams(), NSPressureNeumannBC::validParams(), NSStagnationPressureBC::validParams(), NSPressurePin::validParams(), INSPressureGradientDGKernel::validParams(), GeneralFunctorFluidPropsTempl< is_ad >::validParams(), INSFVEnthalpyFunctorMaterial::validParams(), LinearFVEnthalpyFunctorMaterial::validParams(), RhoFromPTFunctorMaterial::validParams(), CNSFVHLLCSpecifiedPressureBC::validParams(), FVSpecificEnthalpyFromPressureTemperatureDirichletBC::validParams(), PCNSFVHLLCSpecifiedPressureBC::validParams(), PCNSFVStrongBC::validParams(), WCNSFVEnergyFluxBC::validParams(), INSFVMomentumPressure::validParams(), INSFVMomentumPressureFlux::validParams(), PINSFVMomentumPressurePorosityGradient::validParams(), PNSFVMomentumPressureFluxRZ::validParams(), WCNSFV2PInterfaceAreaSourceSink::validParams(), NavierStokesLHDGAssemblyHelper::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), INSADMomentumPressure::validParams(), INSBase::validParams(), INSChorinCorrector::validParams(), INSProjection::validParams(), NSMomentumInviscidFlux::validParams(), NSMomentumInviscidFluxWithGradP::validParams(), PressureGradient::validParams(), LinearFVMomentumPressure::validParams(), INSADMaterial::validParams(), PorousMixedVarMaterial::validParams(), PorousPrimitiveVarMaterial::validParams(), IntegralDirectedSurfaceForce::validParams(), NSEntropyError::validParams(), RhieChowInterpolatorBase::validParams(), RhieChowMassFlux::validParams(), PINSFVFunctorBC::validParams(), PrintMatricesNSProblem::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ R

const std::string NS::R = "R"

static

Definition at line 167 of file NS.h.

◆ Reynolds

const std::string NS::Reynolds = "Re"

static

Definition at line 144 of file NS.h.

Referenced by GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl(), ReynoldsNumberFunctorMaterial::ReynoldsNumberFunctorMaterial(), DittusBoelterFunctorMaterialTempl< is_ad >::validParams(), and ExponentialFrictionFunctorMaterial::validParams().

◆ Reynolds_hydraulic

const std::string NS::Reynolds_hydraulic = "Re_h"

static

Definition at line 145 of file NS.h.

Referenced by GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl().

◆ Reynolds_interstitial

const std::string NS::Reynolds_interstitial = "Re_i"

static

Definition at line 146 of file NS.h.

Referenced by GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl().

◆ rho_s

const std::string NS::rho_s = "rho_s"

static

Definition at line 122 of file NS.h.

◆ S

const std::string NS::S = "S"

static

Definition at line 168 of file NS.h.

◆ scalar_tau

const std::string NS::scalar_tau = "scalar_tau"

static

Definition at line 164 of file NS.h.

◆ smoothed_porosity

const std::string NS::smoothed_porosity = "smoothed_porosity"

static

Definition at line 109 of file NS.h.

Referenced by PINSFVRhieChowInterpolator::PINSFVRhieChowInterpolator(), PINSFVRhieChowInterpolator::pinsfvSetup(), and WCNSFVFlowPhysics::WCNSFVFlowPhysics().

◆ solid

const std::string NS::solid = "solid"

static

Definition at line 141 of file NS.h.

◆ sound_speed

const std::string NS::sound_speed = "sound_speed"

static

Definition at line 149 of file NS.h.

◆ source_scaling

const std::string NS::source_scaling = "source_scaling"

static

Definition at line 159 of file NS.h.

◆ specific_enthalpy

const std::string NS::specific_enthalpy = "h"

static

Definition at line 69 of file NS.h.

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyInletBC(), WCNSFVFluidHeatTransferPhysics::addEnergyTimeKernels(), WCNSFVFluidHeatTransferPhysics::addMaterials(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyTimeKernels(), AriaLaserWeld304LStainlessSteelFunctorMaterial::AriaLaserWeld304LStainlessSteelFunctorMaterial(), WCNSFVFluidHeatTransferPhysicsBase::getSpecificEnthalpyName(), INSFVEnthalpyFunctorMaterial::INSFVEnthalpyFunctorMaterial(), PINSFVEnergyTimeDerivative::PINSFVEnergyTimeDerivative(), INSFVEnthalpyFunctorMaterial::validParams(), LinearFVEnthalpyFunctorMaterial::validParams(), WCNSFVEnergyFluxBC::validParams(), INSFVEnergyTimeDerivative::validParams(), PINSFVEnergyTimeDerivative::validParams(), and WCNSFVEnergyTimeDerivative::validParams().

◆ specific_internal_energy

const std::string NS::specific_internal_energy = "e"

static

Definition at line 63 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSInternalEnergyAux(), CNSAction::addNSMachAux(), CNSAction::addPressureOrTemperatureAux(), NSMachAux::validParams(), NSPressureAux::validParams(), NSTemperatureAux::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ specific_total_energy

const std::string NS::specific_total_energy = "et"

static

Definition at line 64 of file NS.h.

◆ specific_total_enthalpy

const std::string NS::specific_total_enthalpy = "ht"

static

Definition at line 70 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSEnergyInviscidFlux(), CNSAction::addNSSUPGEnergy(), CNSAction::addNSSUPGMass(), CNSAction::addNSSUPGMomentum(), CNSAction::addSpecificTotalEnthalpyAux(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSEnergyInviscidFlux::validParams(), NSSUPGBase::validParams(), NavierStokesMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ specific_volume

const std::string NS::specific_volume = "specific_volume"

static

Definition at line 82 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSMachAux(), CNSAction::addPressureOrTemperatureAux(), CNSAction::addSpecificVolumeComputation(), NSMachAux::validParams(), NSPressureAux::validParams(), NSTemperatureAux::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ speed

const std::string NS::speed = "speed"

static

Definition at line 148 of file NS.h.

Referenced by WCNSFVFlowPhysicsBase::addFluidPropertiesFunctorMaterial(), WCNSFVFlowPhysics::addMomentumFrictionKernels(), WCNSFVFlowPhysicsBase::addNonPorousMediumSpeedMaterial(), ExponentialFrictionFunctorMaterial::ExponentialFrictionFunctorMaterial(), PINSFVMomentumFrictionCorrection::PINSFVMomentumFrictionCorrection(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), PecletNumberFunctorAux::validParams(), ReynoldsNumberFunctorAux::validParams(), ExponentialFrictionFunctorMaterial::validParams(), GeneralFunctorFluidPropsTempl< is_ad >::validParams(), NSFVPumpFunctorMaterial::validParams(), PINSFVSpeedFunctorMaterial::validParams(), ReynoldsNumberFunctorMaterial::validParams(), PINSFVMomentumFriction::validParams(), and PINSFVMomentumFrictionCorrection::validParams().

◆ superficial_density

const std::string NS::superficial_density = "superficial_rho"

static

Definition at line 35 of file NS.h.

Referenced by PNSInitialCondition::validParams(), and PNSInitialCondition::value().

◆ superficial_momentum_vector

const std::string NS::superficial_momentum_vector[3]

static

Initial value:

= {

superficial_momentum_x, superficial_momentum_y, superficial_momentum_z}

NS::superficial_momentum_z

static const std::string superficial_momentum_z

Definition NS.h:42

NS::superficial_momentum_y

static const std::string superficial_momentum_y

Definition NS.h:41

NS::superficial_momentum_x

static const std::string superficial_momentum_x

Definition NS.h:40

Definition at line 43 of file NS.h.

43 {

44 superficial_momentum_x, superficial_momentum_y, superficial_momentum_z};

◆ superficial_momentum_x

const std::string NS::superficial_momentum_x = "superficial_rhou"

static

Definition at line 40 of file NS.h.

Referenced by PCNSFVHLLCSpecifiedMassFluxAndTemperatureBC::validParams(), PNSInitialCondition::validParams(), PorousConservedVarMaterial::validParams(), PorousMixedVarMaterial::validParams(), and PNSInitialCondition::value().

◆ superficial_momentum_y

const std::string NS::superficial_momentum_y = "superficial_rhov"

static

Definition at line 41 of file NS.h.

Referenced by PorousMixedVarMaterial::PorousMixedVarMaterial(), PCNSFVHLLCSpecifiedMassFluxAndTemperatureBC::validParams(), PNSInitialCondition::validParams(), PorousConservedVarMaterial::validParams(), PorousMixedVarMaterial::validParams(), and PNSInitialCondition::value().

◆ superficial_momentum_z

const std::string NS::superficial_momentum_z = "superficial_rhow"

static

Definition at line 42 of file NS.h.

Referenced by PorousMixedVarMaterial::PorousMixedVarMaterial(), PCNSFVHLLCSpecifiedMassFluxAndTemperatureBC::validParams(), PNSInitialCondition::validParams(), PorousConservedVarMaterial::validParams(), PorousMixedVarMaterial::validParams(), and PNSInitialCondition::value().

◆ superficial_total_energy_density

const std::string NS::superficial_total_energy_density = "superficial_rho_et"

static

Definition at line 67 of file NS.h.

Referenced by PNSInitialCondition::validParams(), and PNSInitialCondition::value().

◆ superficial_total_enthalpy_density

const std::string NS::superficial_total_enthalpy_density = "superficial_rho_ht"

static

Definition at line 73 of file NS.h.

Referenced by PNSInitialCondition::validParams(), and PNSInitialCondition::value().

◆ superficial_velocity

const std::string NS::superficial_velocity = "superficial_velocity"

static

Definition at line 54 of file NS.h.

Referenced by PCNSFVStrongBC::validParams().

◆ superficial_velocity_vector

const std::string NS::superficial_velocity_vector[3]

static

Initial value:

= {

superficial_velocity_x, superficial_velocity_y, superficial_velocity_z}

NS::superficial_velocity_y

static const std::string superficial_velocity_y

Definition NS.h:52

NS::superficial_velocity_z

static const std::string superficial_velocity_z

Definition NS.h:53

NS::superficial_velocity_x

static const std::string superficial_velocity_x

Definition NS.h:51

Definition at line 55 of file NS.h.

55 {

56 superficial_velocity_x, superficial_velocity_y, superficial_velocity_z};

Referenced by WCNSFVFlowPhysicsBase::addPorousMediumSpeedMaterial().

◆ superficial_velocity_x

const std::string NS::superficial_velocity_x = "superficial_vel_x"

static

Definition at line 51 of file NS.h.

Referenced by LinearFrictionFactorFunctorMaterial::LinearFrictionFactorFunctorMaterial(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), LinearFrictionFactorFunctorMaterial::validParams(), PINSFVSpeedFunctorMaterial::validParams(), PNSInitialCondition::validParams(), PorousPrimitiveVarMaterial::validParams(), PINSFVFunctorBC::validParams(), and PNSInitialCondition::value().

◆ superficial_velocity_y

const std::string NS::superficial_velocity_y = "superficial_vel_y"

static

Definition at line 52 of file NS.h.

Referenced by LinearFrictionFactorFunctorMaterial::LinearFrictionFactorFunctorMaterial(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), PorousPrimitiveVarMaterial::PorousPrimitiveVarMaterial(), LinearFrictionFactorFunctorMaterial::validParams(), PINSFVSpeedFunctorMaterial::validParams(), PNSInitialCondition::validParams(), PorousPrimitiveVarMaterial::validParams(), PINSFVFunctorBC::validParams(), and PNSInitialCondition::value().

◆ superficial_velocity_z

const std::string NS::superficial_velocity_z = "superficial_vel_z"

static

Definition at line 53 of file NS.h.

Referenced by LinearFrictionFactorFunctorMaterial::LinearFrictionFactorFunctorMaterial(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), PorousPrimitiveVarMaterial::PorousPrimitiveVarMaterial(), LinearFrictionFactorFunctorMaterial::validParams(), PINSFVSpeedFunctorMaterial::validParams(), PNSInitialCondition::validParams(), PorousPrimitiveVarMaterial::validParams(), PINSFVFunctorBC::validParams(), and PNSInitialCondition::value().

◆ T_fluid

const std::string NS::T_fluid = "T_fluid"

static

Definition at line 110 of file NS.h.

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSFVFluidHeatTransferPhysics::addEnergyInletBC(), WCNSFVFluidHeatTransferPhysics::addEnergyWallBC(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), WCNSFVFlowPhysicsBase::addFluidPropertiesFunctorMaterial(), WCNSLinearFVFluidHeatTransferPhysics::addMaterials(), WCNSFVFlowPhysics::addMomentumBoussinesqKernels(), WCNSLinearFVFlowPhysics::addMomentumBoussinesqKernels(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyAmbientConvection(), GeneralFunctorFluidPropsTempl< is_ad >::GeneralFunctorFluidPropsTempl(), LinearFVMomentumBoussinesq::getTemperatureVariable(), INSFVEnthalpyFunctorMaterial::INSFVEnthalpyFunctorMaterial(), DittusBoelterFunctorMaterialTempl< is_ad >::validParams(), GeneralFunctorFluidPropsTempl< is_ad >::validParams(), LinearFVEnthalpyFunctorMaterial::validParams(), FVSpecificEnthalpyFromPressureTemperatureDirichletBC::validParams(), PCNSFVStrongBC::validParams(), WCNSFVEnergyFluxBC::validParams(), FVConvectionCorrelationInterface::validParams(), INSFVMomentumBoussinesq::validParams(), PINSFVEnergyAmbientConvection::validParams(), LinearFVConvectiveHeatTransferBC::validParams(), LinearFVMomentumBoussinesq::validParams(), LinearFVVolumetricHeatTransfer::validParams(), PorousMixedVarMaterial::validParams(), PorousPrimitiveVarMaterial::validParams(), PNSFVSolidHeatTransferPhysics::validParams(), and WCNSFVFluidHeatTransferPhysicsBase::validParams().

◆ T_liquidus

const std::string NS::T_liquidus = "T_liquidus"

static

Definition at line 153 of file NS.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addPhaseChangeEnergySource().

◆ T_solid

const std::string NS::T_solid = "T_solid"

static

Definition at line 111 of file NS.h.

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyAmbientConvection(), WCNSLinearFVFluidHeatTransferPhysics::addEnergyWallBC(), PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyAmbientConvection(), FVConvectionCorrelationInterface::validParams(), PINSFVEnergyAmbientConvection::validParams(), LinearFVConvectiveHeatTransferBC::validParams(), LinearFVVolumetricHeatTransfer::validParams(), and PNSFVSolidHeatTransferPhysics::validParams().

◆ T_solidus

const std::string NS::T_solidus = "T_solidus"

static

Definition at line 154 of file NS.h.

Referenced by WCNSFVTwoPhaseMixturePhysics::addPhaseChangeEnergySource().

◆ temperature

const std::string NS::temperature = "temperature"

static

Definition at line 60 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSEnergyInviscidSpecifiedPressureBC(), CNSAction::addNSSUPGEnergy(), CNSAction::addNSSUPGMass(), CNSAction::addNSSUPGMomentum(), CNSAction::addPressureOrTemperatureAux(), WCNSFVFlowPhysicsBase::getFlowVariableName(), INSAction::validParams(), NSLiquidFractionAux::validParams(), NSEnergyInviscidBC::validParams(), NSEnergyViscousBC::validParams(), NSStagnationTemperatureBC::validParams(), RhoFromPTFunctorMaterial::validParams(), CNSFVHLLCSpecifiedMassFluxAndTemperatureBC::validParams(), PCNSFVHLLCSpecifiedMassFluxAndTemperatureBC::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSEnergyThermalFlux::validParams(), NSSUPGBase::validParams(), NavierStokesMaterial::validParams(), INSElementIntegralEnergyAdvectionTempl< is_ad >::validParams(), AriaLaserWeld304LStainlessSteelFunctorMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ thermal_diffusivity

const std::string NS::thermal_diffusivity = "thermal_diffusivity"

static

Definition at line 138 of file NS.h.

Referenced by ThermalDiffusivityFunctorMaterial::ThermalDiffusivityFunctorMaterial(), and PecletNumberFunctorAux::validParams().

◆ TKE

const std::string NS::TKE = "tke"

static

Definition at line 181 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSFVFluidHeatTransferPhysics::addEnergyWallBC(), WCNSFVTurbulencePhysics::addFVBCs(), WCNSLinearFVTurbulencePhysics::addFVBCs(), WCNSFVTurbulencePhysics::addKEpsilonSink(), WCNSLinearFVTurbulencePhysics::addKEpsilonSink(), WCNSFVTurbulencePhysicsBase::addMaterials(), RANSYPlusAux::RANSYPlusAux(), kEpsilonViscosityAux::validParams(), RANSYPlusAux::validParams(), INSFVkEpsilonViscosityFunctorMaterial::validParams(), INSFVMixingLengthTKEDBC::validParams(), INSFVTKEDWallFunctionBC::validParams(), INSFVTurbulentTemperatureWallFunction::validParams(), INSFVTurbulentViscosityWallFunction::validParams(), INSFVTKEDSourceSink::validParams(), LinearFVTemperatureWallFunctionBC::validParams(), LinearFVTurbulentViscosityWallFunctionBC::validParams(), LinearFVTKEDSourceSink::validParams(), and WCNSFVTurbulencePhysicsBase::validParams().

◆ TKED

const std::string NS::TKED = "epsilon"

static

Definition at line 182 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::addAuxiliaryKernels(), WCNSFVTurbulencePhysics::addKEpsilonSink(), WCNSLinearFVTurbulencePhysics::addKEpsilonSink(), WCNSFVTurbulencePhysicsBase::addMaterials(), kEpsilonViscosityAux::validParams(), INSFVkEpsilonViscosityFunctorMaterial::validParams(), INSFVTKESourceSink::validParams(), LinearFVTKESourceSink::validParams(), and WCNSFVTurbulencePhysicsBase::validParams().

◆ total_energy_density

const std::string NS::total_energy_density = "rho_et"

static

Definition at line 66 of file NS.h.

Referenced by CNSAction::act(), CNSAction::addNSEnergyInviscidFlux(), CNSAction::addNSEnergyInviscidSpecifiedPressureBC(), CNSAction::addNSEnergyWeakStagnationBC(), CNSAction::addNSInternalEnergyAux(), CNSAction::addNSSUPGEnergy(), CNSAction::addNSTimeKernels(), CNSAction::addSpecificTotalEnthalpyAux(), CNSAction::setBCCommonParams(), CNSAction::setKernelCommonParams(), NSInternalEnergyAux::validParams(), NSSpecificTotalEnthalpyAux::validParams(), NSIntegratedBC::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSKernel::validParams(), ConservedVarValuesMaterial::validParams(), NavierStokesMaterial::validParams(), PorousConservedVarMaterial::validParams(), PressureEqualsDensityMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ total_enthalpy_density

const std::string NS::total_enthalpy_density = "rho_ht"

static

Definition at line 72 of file NS.h.

◆ total_pressure

const std::string NS::total_pressure = "pressure_total"

static

Definition at line 59 of file NS.h.

◆ total_viscosity

const std::string NS::total_viscosity = "total_viscosity"

static

Definition at line 79 of file NS.h.

Referenced by WCNSFVFlowPhysics::addWallsBC(), and MixingLengthTurbulentViscosityFunctorMaterial::MixingLengthTurbulentViscosityFunctorMaterial().

◆ turbulent_Prandtl

const std::string NS::turbulent_Prandtl = "Pr_t"

static

Definition at line 143 of file NS.h.

Referenced by WCNSFVTurbulencePhysicsBase::validParams().

◆ v

const std::string NS::v = "v"

static

Definition at line 85 of file NS.h.

Referenced by computeShearStrainRateNormSquared().

◆ vector_tau

const std::string NS::vector_tau = "vector_tau"

static

Definition at line 163 of file NS.h.

◆ velocity

const std::string NS::velocity = "velocity"

static

Definition at line 46 of file NS.h.

Referenced by INSAction::act(), INSAction::addINSMomentum(), INSAction::addINSNoBCBC(), INSAction::addINSTemperature(), INSAction::addINSTimeKernels(), INSAction::addINSVelocityAux(), INSAction::addINSVelocityBC(), computeSpeed(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), PINSFVSpeedFunctorMaterial::validParams(), and INSElementIntegralEnergyAdvectionTempl< is_ad >::validParams().

◆ velocity_vector

const std::string NS::velocity_vector[3] = {velocity_x, velocity_y, velocity_z}

Definition at line 50 of file NS.h.

50{velocity_x, velocity_y, velocity_z};

NS::velocity_y

static const std::string velocity_y

Definition NS.h:48

NS::velocity_z

static const std::string velocity_z

Definition NS.h:49

NS::velocity_x

static const std::string velocity_x

Definition NS.h:47

Referenced by WCNSFVFluidHeatTransferPhysics::addEnergyInletBC(), WCNSFVFlowPhysics::addInletBC(), and WCNSFVFlowPhysicsBase::WCNSFVFlowPhysicsBase().

◆ velocity_x

const std::string NS::velocity_x = "vel_x"

static

Definition at line 47 of file NS.h.

Referenced by CNSAction::act(), INSAction::act(), INSAction::addINSMomentum(), INSAction::addINSNoBCBC(), INSAction::addINSTemperature(), INSAction::addINSTimeKernels(), INSAction::addINSVelocityAux(), INSAction::addINSVelocityBC(), CNSAction::addNSVelocityAux(), WCNSFVScalarTransportPhysics::addScalarInletBC(), CNSAction::coupleVelocities(), WCNSFVFlowPhysicsBase::getFlowVariableName(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), INSAction::setKernelCommonParams(), INSAction::setNoBCCommonParams(), NSInternalEnergyAux::validParams(), NSMachAux::validParams(), NSImposedVelocityDirectionBC::validParams(), NSIntegratedBC::validParams(), PINSFVSpeedFunctorMaterial::validParams(), WCNSFVFluxBCBase::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSKernel::validParams(), NSTemperatureL2::validParams(), NavierStokesMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ velocity_y

const std::string NS::velocity_y = "vel_y"

static

Definition at line 48 of file NS.h.

Referenced by CNSAction::act(), INSAction::act(), INSAction::addINSMomentum(), INSAction::addINSNoBCBC(), INSAction::addINSTemperature(), INSAction::addINSTimeKernels(), INSAction::addINSVelocityAux(), INSAction::addINSVelocityBC(), CNSAction::addNSVelocityAux(), WCNSFVScalarTransportPhysics::addScalarInletBC(), CNSAction::coupleVelocities(), WCNSFVFlowPhysicsBase::getFlowVariableName(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), INSAction::setKernelCommonParams(), INSAction::setNoBCCommonParams(), NSInternalEnergyAux::validParams(), NSMachAux::validParams(), NSImposedVelocityDirectionBC::validParams(), NSIntegratedBC::validParams(), PINSFVSpeedFunctorMaterial::validParams(), WCNSFVFluxBCBase::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSKernel::validParams(), NSTemperatureL2::validParams(), NavierStokesMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ velocity_z

const std::string NS::velocity_z = "vel_z"

static

Definition at line 49 of file NS.h.

Referenced by CNSAction::act(), INSAction::act(), INSAction::addINSMomentum(), INSAction::addINSNoBCBC(), INSAction::addINSTemperature(), INSAction::addINSTimeKernels(), INSAction::addINSVelocityAux(), INSAction::addINSVelocityBC(), CNSAction::addNSVelocityAux(), WCNSFVScalarTransportPhysics::addScalarInletBC(), CNSAction::coupleVelocities(), WCNSFVFlowPhysicsBase::getFlowVariableName(), PINSFVSpeedFunctorMaterial::PINSFVSpeedFunctorMaterial(), INSAction::setKernelCommonParams(), INSAction::setNoBCCommonParams(), NSInternalEnergyAux::validParams(), NSMachAux::validParams(), NSImposedVelocityDirectionBC::validParams(), NSIntegratedBC::validParams(), PINSFVSpeedFunctorMaterial::validParams(), WCNSFVFluxBCBase::validParams(), NSFunctionInitialCondition::validParams(), NSInitialCondition::validParams(), PNSInitialCondition::validParams(), NSKernel::validParams(), NSTemperatureL2::validParams(), NavierStokesMaterial::validParams(), NSFunctionInitialCondition::value(), NSInitialCondition::value(), and PNSInitialCondition::value().

◆ von_karman_constant

constexpr Real NS::von_karman_constant = 0.4187

staticconstexpr

Definition at line 206 of file NS.h.

Referenced by INSFVTurbulentViscosityWallFunction::boundaryValue(), LinearFVTKESourceSink::computeMatrixContribution(), INSFVTurbulentTemperatureWallFunction::computeQpResidual(), INSFVTKEDSourceSink::computeQpResidual(), INSFVTKESourceSink::computeQpResidual(), LinearFVTKEDSourceSink::computeRightHandSideContribution(), LinearFVTemperatureWallFunctionBC::computeTurbulentThermalConductivity(), LinearFVTurbulentViscosityWallFunctionBC::computeTurbulentViscosity(), kEpsilonViscosityAux::computeValue(), findUStar(), findyPlus(), and findYplusThermal().

◆ wall_distance

const std::string NS::wall_distance = "wall_distance"

static

Definition at line 31 of file NS.h.

◆ wall_porosity

const std::string NS::wall_porosity = "wall_porosity"

static

Definition at line 30 of file NS.h.

◆ wall_shear_stress

const std::string NS::wall_shear_stress = "wall_shear_stress"

static

Definition at line 76 of file NS.h.

◆ wall_yplus

const std::string NS::wall_yplus = "wall_yplus"

static

Definition at line 77 of file NS.h.

◆ Z

const std::string NS::Z = "Z"

static

Definition at line 174 of file NS.h.

Namespaces

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ CHTSide

◆ MomentumInletTypes

◆ ViscousForm

◆ WallTreatmentEnum

Function Documentation

◆ addFVFaceInterpolationMethod()

◆ computeShearStrainRateNormSquared()

◆ computeShearStrainRateNormSquared< ADReal >()

◆ computeShearStrainRateNormSquared< Real >()

◆ computeSign()

◆ computeSpeed()

◆ computeSpeed< ADReal >()

◆ computeSpeed< Real >()

◆ delta()

◆ divergence()

◆ findUStar()

◆ findUStar< ADReal >()

◆ findUStar< Real >()

◆ findyPlus()

◆ findyPlus< ADReal >()

◆ findyPlus< Real >()

◆ findYplusThermal()

◆ findYplusThermal< Real >()

◆ fvAdvectedInterpolationMethods()

◆ fvAdvectedInterpolationMethodType()

◆ fvFaceInterpolationMethods()

◆ fvFaceInterpolationMethodType()

◆ getElementFaceArgs()

◆ getIndex()

◆ getWallBoundedElements()

◆ getWallDistance()

◆ grad()

◆ isPorosityJumpFace()

◆ isPorosityJumpFace< ADReal >()

◆ isPorosityJumpFace< Real >()

◆ prandtlPropertyDerivative()

◆ reynoldsPropertyDerivative()

◆ time_deriv()

◆ wallHeatTransferCoefficient()

Variable Documentation

◆ A

◆ acceleration

◆ alpha

◆ alpha_boussinesq

◆ alpha_exchange

◆ alpha_wall

◆ axis

◆ c

◆ C

◆ center

◆ cL

◆ component

◆ cp

◆ cp_s

◆ cQ

◆ cv

◆ density

◆ diagonal_tau

◆ directions

◆ dks_dTs

◆ drhos_dTs

◆ dS_dTs

◆ dUdt

◆ E_turb_constant

◆ eddy_viscosity

◆ enthalpy_density

◆ epsilon_low_limit

◆ F

◆ fluid

◆ G

◆ heat_source

◆ infinite_porosity

◆ internal_energy

◆ internal_energy_density

◆ k