#include <CoupledPressureIncompressibleMomentumSPScalarKernel.h>

Inheritance diagram for CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >:

Public Member Functions
	CoupledPressureIncompressibleMomentumSPScalarKernelTempl (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 >	massFlowRate () const override

virtual GenericReal< is_ad >	pressureDrop () const override

virtual Real	computeQpJacobian () override

virtual GenericReal< is_ad >	computeQpResidual () 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)

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 VariableValue &	_mc
	Coupled mass flow rate through the flow path.

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 = IncompressibleMomentumSPBaseTempl< is_ad >

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 CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >

Definition at line 15 of file CoupledPressureIncompressibleMomentumSPScalarKernel.h.

Member Typedef Documentation

◆ Base

template<bool is_ad>

using CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >::Base = IncompressibleMomentumSPBaseTempl<is_ad>

private

Definition at line 18 of file CoupledPressureIncompressibleMomentumSPScalarKernel.h.

Constructor & Destructor Documentation

◆ CoupledPressureIncompressibleMomentumSPScalarKernelTempl()

template<bool is_ad>

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

Definition at line 36 of file CoupledPressureIncompressibleMomentumSPScalarKernel.C.

  : Base(parameters), _mc(ScalarCoupleable::coupledScalarValue("coupled_mass_flow_rate"))
{
}

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
	)

protectedvirtualinherited

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()

template<bool is_ad>

Real CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >::computeQpJacobian ( )

overrideprotectedvirtual

Reimplemented from IncompressibleMomentumSPBaseTempl< is_ad >.

Definition at line 44 of file CoupledPressureIncompressibleMomentumSPScalarKernel.C.

{
  return Base::computeQpJacobianDP();
}

◆ computeQpJacobianDP()

template<bool is_ad>

Real IncompressibleMomentumSPBaseTempl< is_ad >::computeQpJacobianDP ( )

protectedvirtualinherited

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 ( )

protectedvirtualinherited

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 ( )

overrideprotectedvirtualinherited

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 CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >::isADObject ( ) const

inlineoverridevirtual

Reimplemented from IncompressibleMomentumSPBaseTempl< is_ad >.

Definition at line 22 of file CoupledPressureIncompressibleMomentumSPScalarKernel.h.

22{ return is_ad; };

◆ massFlowRate()

template<bool is_ad>

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

inlineoverrideprotectedvirtual

Implements IncompressibleMomentumSPBaseTempl< is_ad >.

Definition at line 26 of file CoupledPressureIncompressibleMomentumSPScalarKernel.h.

26{ return _mc[0]; };

◆ pressureDrop()

template<bool is_ad>

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

inlineoverrideprotectedvirtual

Implements IncompressibleMomentumSPBaseTempl< is_ad >.

Definition at line 27 of file CoupledPressureIncompressibleMomentumSPScalarKernel.h.

27{ return -Base::_u[0]; };

◆ validParams()

template<bool is_ad>

InputParameters CoupledPressureIncompressibleMomentumSPScalarKernelTempl< is_ad >::validParams ( )

static

Definition at line 21 of file CoupledPressureIncompressibleMomentumSPScalarKernel.C.

{
  InputParameters params = IncompressibleMomentumSPBaseTempl<is_ad>::validParams();
  params += FunctorInterface::validParams();
  params.addClassDescription("Implements a generic momentum solve over a 1D flow path, acting on "
                             "the reference pressure drop.");
  params.addCoupledVar("coupled_mass_flow_rate",
                       {},
                       "coupled_mass_flow_rate. Takes a "
                       "scalar variable name");
 
  return params;
}