#include <IncompressibleMomentumSPBase.h>

Inheritance diagram for IncompressibleMomentumSPBaseTempl< is_ad >:

Public Member Functions
	IncompressibleMomentumSPBaseTempl (const InputParameters &parameters)

virtual bool	isADObject () const override

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

Static Public Member Functions
static InputParameters	validParams ()

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

Protected Member Functions
virtual GenericReal< is_ad >	computeQpResidual () override

virtual Real	computeQpJacobian () override

virtual Real	computeQpJacobianMDot ()

virtual Real	computeQpJacobianDP ()

virtual GenericReal< is_ad >	computeFrictionFactor (const GenericReal< is_ad > &mu, const GenericReal< is_ad > &G, const GenericReal< is_ad > &Dh, const unsigned int j)

virtual GenericReal< is_ad >	massFlowRate () const =0

virtual GenericReal< is_ad >	pressureDrop () const =0

Real	computeQpJacobian ()

std::string	deduceFunctorName (const std::string &name) const

const Moose::Functor< T > &	getFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

bool	isFunctor (const std::string &name) const

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

const Moose::Functor< T > &	getFunctorByName (const std::string &name)

Protected Attributes
const size_t	_n_temps
	Number of coupled temperature variables.

std::vector< const VariableValue * >	_T
	Coupled temperature variables.

const bool	_is_implicit
	Property state integration flag.

const Moose::Functor< GenericReal< is_ad > > &	_Pref
	System reference pressure.

const SinglePhaseFluidProperties &	_fp
	Fluid properties object.

const size_t	_n_segments
	Number of geometrically/thermally unique segments.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_areas
	Flow area of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_perimeters
	Wetted perimeter of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_lengths
	Length of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_alphas
	Angle with respect to the horizontal of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_forms_losses
	Forms loss coefficients of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_dPps
	Pump pressure gains of each segment.

std::vector< const Moose::Functor< GenericReal< is_ad > > * >	_roughnesses
	Wall roughness of each segment.

const Moose::Functor< GenericReal< is_ad > > &	_gravity
	Gravitational acceleration in the vertical downward direction.

Private Types
using	Base = typename std::conditional< is_ad, ADScalarKernel, ScalarKernel >::type

Private Member Functions
const Moose::Functor< T > *	defaultFunctor (const std::string &name)

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

Private Attributes
const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

Detailed Description

template<bool is_ad>
class IncompressibleMomentumSPBaseTempl< is_ad >

Definition at line 19 of file IncompressibleMomentumSPBase.h.

Member Typedef Documentation

◆ Base

template<bool is_ad>

using IncompressibleMomentumSPBaseTempl< is_ad >::Base = typename std::conditional<is_ad, ADScalarKernel, ScalarKernel>::type

private

Definition at line 23 of file IncompressibleMomentumSPBase.h.

Constructor & Destructor Documentation

◆ IncompressibleMomentumSPBaseTempl()

template<bool is_ad>

IncompressibleMomentumSPBaseTempl< is_ad >::IncompressibleMomentumSPBaseTempl ( const InputParameters & parameters )

Definition at line 70 of file IncompressibleMomentumSPBase.C.

  : Base(parameters),
    FunctorInterface(this),
    _n_temps(ScalarCoupleable::coupledScalarComponents("temperatures")),
    _T(_n_temps),
    _is_implicit(this->template getParam<bool>("is_implicit")),
    _Pref(this->template getFunctor<GenericReal<is_ad>>("reference_pressure")),
    _fp(this->template getUserObject<SinglePhaseFluidProperties>("fp")),
    _n_segments(this->template getParam<std::vector<MooseFunctorName>>("areas").size()),
    _areas(this->template getParam<std::vector<MooseFunctorName>>("areas").size()),
    _perimeters(this->template getParam<std::vector<MooseFunctorName>>("perimeters").size()),
    _lengths(this->template getParam<std::vector<MooseFunctorName>>("lengths").size()),
    _alphas(this->template getParam<std::vector<MooseFunctorName>>("alphas").size()),
    _forms_losses(this->template getParam<std::vector<MooseFunctorName>>("forms_losses").size()),
    _dPps(this->template getParam<std::vector<MooseFunctorName>>("pump_pressures").size()),
    _roughnesses(this->template getParam<std::vector<MooseFunctorName>>("roughnesses").size()),
    _gravity(this->template getFunctor<GenericReal<is_ad>>("g"))
{
  const auto & area_names = MooseBase::getParam<std::vector<MooseFunctorName>>("areas");
  const auto & perimeter_names = MooseBase::getParam<std::vector<MooseFunctorName>>("perimeters");
  const auto & length_names = MooseBase::getParam<std::vector<MooseFunctorName>>("lengths");
  const auto & alpha_names = MooseBase::getParam<std::vector<MooseFunctorName>>("alphas");
  const auto & forms_loss_names =
      MooseBase::getParam<std::vector<MooseFunctorName>>("forms_losses");
  const auto & dPp_names = MooseBase::getParam<std::vector<MooseFunctorName>>("pump_pressures");
  const auto & roughness_names = MooseBase::getParam<std::vector<MooseFunctorName>>("roughnesses");
  if (_n_segments != area_names.size() || _n_segments != perimeter_names.size() ||
      _n_segments != length_names.size() || _n_segments != alpha_names.size() ||
      _n_segments != forms_loss_names.size() || _n_segments != dPp_names.size() ||
      _n_segments != roughness_names.size() || _n_segments != _n_temps)
  {
    mooseError(
        "Must provide consistent number of segments for each parameter! Including temperatures!");
  }
  for (const auto j : make_range(_n_segments))
  {
    _T[j] = &(ScalarCoupleable::coupledScalarValue("temperatures", j));
    _areas[j] = &(this->template getFunctor<GenericReal<is_ad>>(area_names[j]));
    _perimeters[j] = &(this->template getFunctor<GenericReal<is_ad>>(perimeter_names[j]));
    _lengths[j] = &(this->template getFunctor<GenericReal<is_ad>>(length_names[j]));
    _alphas[j] = &(this->template getFunctor<GenericReal<is_ad>>(alpha_names[j]));
    _forms_losses[j] = &(this->template getFunctor<GenericReal<is_ad>>(forms_loss_names[j]));
    _dPps[j] = &(this->template getFunctor<GenericReal<is_ad>>(dPp_names[j]));
    _roughnesses[j] = &(this->template getFunctor<GenericReal<is_ad>>(roughness_names[j]));
  }
}

Member Function Documentation

◆ computeFrictionFactor()

template<bool is_ad>

GenericReal< is_ad > IncompressibleMomentumSPBaseTempl< is_ad >::computeFrictionFactor	(	const GenericReal< is_ad > &	mu,
		const GenericReal< is_ad > &	G,
		const GenericReal< is_ad > &	Dh,
		const unsigned int	j
	)

protectedvirtual

Definition at line 253 of file IncompressibleMomentumSPBase.C.

{
  const Moose::ElemArg qp = Moose::ElemArg();
  const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
  const auto Re = abs(G) * Dh / mu;
  const auto f_lam = 64.0 / Re;
  const auto f_turb =
      0.25 / pow((log10((*(_roughnesses[j]))(qp, state) / (Dh * 3.7) + 5.74 / pow(Re, 0.9))), 2);
  if (Re < 2300.0) // laminar
    return f_lam;
  else if (Re > 4000.0) // turbulent using Swamee-Jain approx. of Colebrook-White eq.
    return f_turb;
  else // transition, conservative interpolation between the two
    return std::max((f_turb - f_lam) / 1700 * Re + f_lam, std::max(f_lam, f_turb));
}

◆ computeQpJacobian() [1/2]

Real IncompressibleMomentumSPBaseTempl< true >::computeQpJacobian ( )

protected

Definition at line 245 of file IncompressibleMomentumSPBase.C.

{
  mooseError("Internal error, calling computeQpJacobian in AD class.");
  return 0.0;
}

◆ computeQpJacobian() [2/2]

template<bool is_ad>

Real IncompressibleMomentumSPBaseTempl< is_ad >::computeQpJacobian ( )

overrideprotectedvirtual

Reimplemented in CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >, and IncompressibleMomentumSPScalarKernelTempl< is_ad >.

Definition at line 230 of file IncompressibleMomentumSPBase.C.

{
  if constexpr (!is_ad)
  {
    return 0;
  }
  else
  {
    mooseError("computeQpJacobian() should not be called in AD mode");
    return 0;
  }
}

◆ computeQpJacobianDP()

template<bool is_ad>

Real IncompressibleMomentumSPBaseTempl< is_ad >::computeQpJacobianDP ( )

protectedvirtual

Definition at line 206 of file IncompressibleMomentumSPBase.C.

{
  if constexpr (!is_ad)
  {
    const Moose::ElemArg qp = Moose::ElemArg();
    const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
    // Global rescale factor, see computeQpResidual()
    Real L_over_A_sum = 0;
    for (const auto j : make_range(_n_segments))
      L_over_A_sum += (*(_lengths[j]))(qp, state) / (*(_areas[j]))(qp, state);
    const auto inv_L_over_A_sum = 1.0 / L_over_A_sum;
    // reference pressure drop is subtracted once, scaled by inv_L_over_A_sum, so its derivative is
    // -inv_L_over_A_sum
    return -inv_L_over_A_sum;
  }
  else
  {
    mooseError("computeQpJacobian() should not be called in AD mode");
    return 0;
  }
}

◆ computeQpJacobianMDot()

template<bool is_ad>

Real IncompressibleMomentumSPBaseTempl< is_ad >::computeQpJacobianMDot ( )

protectedvirtual

Definition at line 164 of file IncompressibleMomentumSPBase.C.

{
  if constexpr (!is_ad)
  {
    Real momentum_jacob = 0;
    const Moose::ElemArg qp = Moose::ElemArg();
    const int i = 0;
    const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
    // start by getting global fluid properties
    const auto Tave = ((*(_T[0]))[i] + (*(_T[_n_temps - 1]))[i]) / 2;
    const auto mu = _fp.mu_from_p_T(_Pref(qp, state), Tave);
    const auto rhog = _fp.rho_from_p_T(_Pref(qp, state), Tave);
    // Global rescale factor, see computeQpResidual()
    Real L_over_A_sum = 0;
    for (const auto j : make_range(_n_segments))
      L_over_A_sum += (*(_lengths[j]))(qp, state) / (*(_areas[j]))(qp, state);
    const auto inv_L_over_A_sum = 1.0 / L_over_A_sum;
    // loop over segments
    for (const auto j : make_range(_n_segments))
    {
      // Decide flow regime for friction factor
      const auto Dh = 4.0 * (*(_areas[j]))(qp, state) / (*(_perimeters[j]))(qp, state);
      const auto G = massFlowRate() / (*(_areas[j]))(qp, state);
      const auto fd = computeFrictionFactor(mu, G, Dh, j);
      // Friction
      momentum_jacob +=
          fd * (*(_lengths[j]))(qp, state) / Dh * G / rhog / (*(_areas[j]))(qp, state);
      // Form losses
      momentum_jacob += (*(_forms_losses[j]))(qp, state) * G / rhog / (*(_areas[j]))(qp, state);
    }
 
    return momentum_jacob * inv_L_over_A_sum;
  }
  else
  {
    mooseError("computeQpJacobian() should not be called in AD mode");
    return 0;
  }
}

◆ computeQpResidual()

template<bool is_ad>

GenericReal< is_ad > IncompressibleMomentumSPBaseTempl< is_ad >::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 120 of file IncompressibleMomentumSPBase.C.

{
  GenericReal<is_ad> momentum_residual = 0;
  const Moose::ElemArg qp = Moose::ElemArg();
  const int i = 0;
  const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
  // start by getting global fluid properties
  const auto Tave = ((*(_T[0]))[i] + (*(_T[_n_temps - 1]))[i]) / 2;
  const auto mu = _fp.mu_from_p_T(_Pref(qp, state), Tave);
  const auto rhog = _fp.rho_from_p_T(_Pref(qp, state), Tave);
  // Global rescale factor so the mass flow rate's transient term has a unit coefficient,
  // matching the coefficient of ODETimeDerivative kernel: the path's lumped L_over_A_sum is
  // Sum_j(length_j / area_j), so the whole equation is divided through by that single sum.
  GenericReal<is_ad> L_over_A_sum = 0;
  for (const auto j : make_range(_n_segments))
    L_over_A_sum += (*(_lengths[j]))(qp, state) / (*(_areas[j]))(qp, state);
  const auto inv_L_over_A_sum = 1.0 / L_over_A_sum;
  // loop over segments
  for (const auto j : make_range(_n_segments))
  {
    // Decide flow regime for friction factor
    const auto Dh = 4.0 * (*(_areas[j]))(qp, state) / (*(_perimeters[j]))(qp, state);
    const auto G = massFlowRate() / (*(_areas[j]))(qp, state);
    const auto fd = computeFrictionFactor(mu, G, Dh, j);
    // Friction
    momentum_residual += fd * (*(_lengths[j]))(qp, state) / Dh * G * abs(G) / 2.0 / rhog;
    // Form losses
    momentum_residual += (*(_forms_losses[j]))(qp, state) * G * abs(G) / 2.0 / rhog;
    // Gravity
    // get local density for natural circulation aspect
    auto rhol = _fp.rho_from_p_T(_Pref(qp, state), (*(_T[j]))[i]);
    momentum_residual +=
        rhol * _gravity(qp, state) * (*(_lengths[j]))(qp, state) * sin((*(_alphas[j]))(qp, state));
    // Pump pressure
    momentum_residual -= (*(_dPps[j]))(qp, state);
  }
  // Pressure drop (single path-wide unknown, applied once)
  momentum_residual += pressureDrop();
 
  return momentum_residual * inv_L_over_A_sum;
}

◆ isADObject()

template<bool is_ad>

virtual bool IncompressibleMomentumSPBaseTempl< is_ad >::isADObject ( ) const

inlineoverridevirtual

Implements FunctorInterface.

Reimplemented in CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >, and IncompressibleMomentumSPScalarKernelTempl< is_ad >.

Definition at line 27 of file IncompressibleMomentumSPBase.h.

27{ return is_ad; };

◆ massFlowRate()

template<bool is_ad>

virtual GenericReal< is_ad > IncompressibleMomentumSPBaseTempl< is_ad >::massFlowRate ( ) const

protectedpure virtual

Implemented in CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >, and IncompressibleMomentumSPScalarKernelTempl< is_ad >.

◆ pressureDrop()

template<bool is_ad>

virtual GenericReal< is_ad > IncompressibleMomentumSPBaseTempl< is_ad >::pressureDrop ( ) const

protectedpure virtual

Implemented in CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >, and IncompressibleMomentumSPScalarKernelTempl< is_ad >.

◆ validParams()

template<bool is_ad>

InputParameters IncompressibleMomentumSPBaseTempl< is_ad >::validParams ( )

static

Definition at line 19 of file IncompressibleMomentumSPBase.C.

{
  InputParameters params = is_ad ? ADScalarKernel::validParams() : ScalarKernel::validParams();
  params += FunctorInterface::validParams();
  params.addClassDescription("Base class for path-integrated incompressible momentum kernels.");
  params.addCoupledVar("temperatures",
                       {},
                       "Fluid temperature in each segment of this component. Takes a "
                       "list of scalar variable names");
  params.addParam<bool>(
      "is_implicit",
      false,
      "Whether an explicit (previous value calculation) or implicit (current value) is used");
  params.addRequiredParam<MooseFunctorName>("reference_pressure", "system reference pressure [Pa]");
  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");
  params.addParam<std::vector<MooseFunctorName>>(
      "areas",
      std::vector<MooseFunctorName>({}),
      "Component flow areas per segment. Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "perimeters",
      std::vector<MooseFunctorName>({}),
      "Component flow perimeters per segment. Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "lengths",
      std::vector<MooseFunctorName>({}),
      "Component flow lengths per segment. Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "alphas",
      std::vector<MooseFunctorName>({}),
      "Component flow angles per segment with respect to horizontal (-pi/2 downward to pi/2 "
      "upward). Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "forms_losses",
      std::vector<MooseFunctorName>({}),
      "Forms loss coefficients per segment. Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "pump_pressures",
      std::vector<MooseFunctorName>({}),
      "Pump pressure gains per segment [Pa]. Takes a vector of functors.");
  params.addParam<std::vector<MooseFunctorName>>(
      "roughnesses",
      std::vector<MooseFunctorName>({}),
      "Component wall roughnesses per segment [m]. Takes a vector of functors.");
  params.addParam<MooseFunctorName>(
      "g", PhysicalConstants::acceleration_of_gravity, "Gravitational acceleration [m/s]");
 
  return params;
}