#include <IncompressibleEnergySPScalarKernel.h>

Inheritance diagram for IncompressibleEnergySPScalarKernelTempl< is_ad >:

Public Member Functions
	IncompressibleEnergySPScalarKernelTempl (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

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 SinglePhaseFluidProperties &	_fp
	Fluid properties object.

const VariableValue &	_m
	Coupled mass flow rate through the segment.

const VariableValue &	_Tup
	Coupled temperature of the upstream segment.

const VariableValue &	_Tdown
	Coupled temperature of the downstream segment.

const VariableValue &	_Tw
	Coupled temperature of the component wall.

const bool	_is_implicit
	Property state integration flag.

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

const Moose::Functor< GenericReal< is_ad > > &	_area
	Flow area of the segment.

const Moose::Functor< GenericReal< is_ad > > &	_perimeter
	Wetted perimeter of the segment.

const Moose::Functor< GenericReal< is_ad > > &	_length
	Length of the segment.

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

Definition at line 19 of file IncompressibleEnergySPScalarKernel.h.

Member Typedef Documentation

◆ Base

template<bool is_ad>

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

private

Definition at line 23 of file IncompressibleEnergySPScalarKernel.h.

Constructor & Destructor Documentation

◆ IncompressibleEnergySPScalarKernelTempl()

template<bool is_ad>

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

Definition at line 56 of file IncompressibleEnergySPScalarKernel.C.

  : Base(parameters),
    FunctorInterface(this),
    _fp(this->template getUserObject<SinglePhaseFluidProperties>("fp")),
    _m(ScalarCoupleable::coupledScalarValue("mass_flow_rate")),
    _Tup(ScalarCoupleable::coupledScalarValue("inlet_temperature")),
    _Tdown(ScalarCoupleable::coupledScalarValue("outlet_temperature")),
    _Tw(ScalarCoupleable::coupledScalarValue("wall_temperature")),
    _is_implicit(this->template getParam<bool>("is_implicit")),
    _Pref(this->template getFunctor<GenericReal<is_ad>>("reference_pressure")),
    _area(this->template getFunctor<GenericReal<is_ad>>("area")),
    _perimeter(this->template getFunctor<GenericReal<is_ad>>("perimeter")),
    _length(this->template getFunctor<GenericReal<is_ad>>("length"))
{
}

Member Function Documentation

◆ computeQpJacobian() [1/2]

Real IncompressibleEnergySPScalarKernelTempl< true >::computeQpJacobian ( )

protected

Definition at line 149 of file IncompressibleEnergySPScalarKernel.C.

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

◆ computeQpJacobian() [2/2]

template<bool is_ad>

Real IncompressibleEnergySPScalarKernelTempl< is_ad >::computeQpJacobian ( )

overrideprotectedvirtual

Definition at line 109 of file IncompressibleEnergySPScalarKernel.C.

{
  if constexpr (!is_ad)
  {
    Real energy_jacob = 0;
    const Moose::ElemArg qp = Moose::ElemArg();
    const int i = 0;
    const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
    // start by getting fluid properties
    const auto in = 1.0 / 2.0 * (1 - abs(_m[i]) / _m[i]) * _Tdown[i] +
                    1.0 / 2.0 * (1 + abs(_m[i]) / _m[i]) * _Tup[i];
    const auto mu = _fp.mu_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
    const auto rho = _fp.rho_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
    const auto cp = _fp.cp_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
    const auto k = _fp.k_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
 
    // Decide flow regime for HTC
    const auto Dh = 4.0 * _area(qp, state) / _perimeter(qp, state);
    const auto G = abs(_m[i]) / _area(qp, state);
    const auto Re = G * Dh / mu;
    const auto Pr = mu * cp / k;
    // Heat transfer to fluid (Dittus-Boelter)
    const auto h = 0.023 * pow(Re, 0.8) * pow(Pr, 0.4) * k / Dh;
    const auto q = -h * _perimeter(qp, state) / 2.0;
    // Advection component
    energy_jacob += abs(_m[i]) / _length(qp, state) / _area(qp, state) / rho;
    // Wall heat transfer
    energy_jacob -= q / _area(qp, state) / rho / cp;
 
    return energy_jacob;
  }
  else
  {
    mooseError("computeQpJacobian() should not be called in AD mode");
    return 0;
  }
}

◆ computeQpResidual()

template<bool is_ad>

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

overrideprotectedvirtual

Definition at line 75 of file IncompressibleEnergySPScalarKernel.C.

{
  GenericReal<is_ad> energy_residual = 0;
  const Moose::ElemArg qp = Moose::ElemArg();
  const int i = 0;
  const auto state = _is_implicit ? Moose::currentState() : Moose::oldState();
  // start by getting fluid properties
  const auto in = 1.0 / 2.0 * (1 - abs(_m[i]) / _m[i]) * _Tdown[i] +
                  1.0 / 2.0 * (1 + abs(_m[i]) / _m[i]) * _Tup[i];
  const auto mu = _fp.mu_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
  const auto rho = _fp.rho_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
  const auto cp = _fp.cp_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
  const auto k = _fp.k_from_p_T(_Pref(qp, state), (Base::_u[i] + in) / 2);
 
  // Compute HTC quantities
  const auto Dh = 4.0 * _area(qp, state) / _perimeter(qp, state);
  const auto G = abs(_m[i]) / _area(qp, state);
  const auto Re = G * Dh / mu;
  const auto Pr = mu * cp / k;
  // Heat transfer to fluid (Dittus-Boelter)
  const auto h = 0.023 * pow(Re, 0.8) * pow(Pr, 0.4) * k / Dh;
  const auto q = h * _perimeter(qp, state) / 2.0 * (2.0 * _Tw[i] - Base::_u[i] - in);
  // Advection component
  energy_residual += (_m[i] / 2.0 * (1 - abs(_m[i]) / _m[i]) * _Tdown[i] -
                      _m[i] / 2.0 * (1 + abs(_m[i]) / _m[i]) * _Tup[i] + abs(_m[i]) * Base::_u[i]) /
                     _length(qp, state) / _area(qp, state) / rho;
  // Wall heat transfer
  energy_residual -= q / _area(qp, state) / rho / cp;
 
  return energy_residual;
}

◆ isADObject()

template<bool is_ad>

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

inlineoverridevirtual

Implements FunctorInterface.

Definition at line 27 of file IncompressibleEnergySPScalarKernel.h.

27{ return is_ad; };

◆ validParams()

template<bool is_ad>

InputParameters IncompressibleEnergySPScalarKernelTempl< is_ad >::validParams ( )

static

Definition at line 21 of file IncompressibleEnergySPScalarKernel.C.

{
  InputParameters params = is_ad ? ADScalarKernel::validParams() : ScalarKernel::validParams();
  params += FunctorInterface::validParams();
  params.addClassDescription("Implements a generic energy solve over a 1D flow path segment.");
  params.addCoupledVar("mass_flow_rate",
                       {},
                       "Mass flow rate in component. Takes a "
                       "scalar variable name");
  params.addCoupledVar("inlet_temperature",
                       {},
                       "Fluid temperature of nominal inlet segment/component (N-1). Takes a "
                       "scalar variable name");
  params.addCoupledVar("outlet_temperature",
                       {},
                       "Fluid temperature of nominal outlet segment/component (N+1). Takes a "
                       "scalar variable name");
  params.addCoupledVar("wall_temperature",
                       {},
                       "Wall temperature adjacent to fluid. Takes a "
                       "scalar variable name");
  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.addRequiredParam<MooseFunctorName>("area", "Segment/Component flow area [m^2]");
  params.addRequiredParam<MooseFunctorName>("perimeter", "Segment/Component wetted perimeter [m]");
  params.addRequiredParam<MooseFunctorName>("length", "Segment/Component length [m]");
 
  return params;
}