FlowModel1PhaseFunctorMaterial.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "FlowModel1PhaseFunctorMaterial.h"
 
registerMooseObject("ThermalHydraulicsApp", FlowModel1PhaseFunctorMaterial);
 
InputParameters
FlowModel1PhaseFunctorMaterial::validParams()
{
  InputParameters params = FunctorMaterial::validParams();
 
  params.addClassDescription("Computes several quantities for FlowModel1Phase.");
 
  params.addRequiredParam<UserObjectName>("fluid_properties",
                                          "The SinglePhaseFluidProperties object for the fluid");
 
  return params;
}
 
FlowModel1PhaseFunctorMaterial::FlowModel1PhaseFunctorMaterial(const InputParameters & parameters)
  : FunctorMaterial(parameters),
    _rhoA(getFunctor<ADReal>(THM::RHOA)),
    _rhouA(getFunctor<ADReal>(THM::RHOUA)),
    _rhoEA(getFunctor<ADReal>(THM::RHOEA)),
    _A(getFunctor<Real>(THM::AREA)),
    _fp(getUserObject<SinglePhaseFluidProperties>("fluid_properties"))
{
  // pressure
  addPressureFunctorProperty<false>();
 
  // temperature
  addTemperatureFunctorProperty<false>();
 
  // velocity
  addVelocityFunctorProperty<false>();
}
 
template <bool is_ad>
void
FlowModel1PhaseFunctorMaterial::addPressureFunctorProperty()
{
  addFunctorProperty<GenericReal<is_ad>>(
      THM::functorMaterialPropertyName<is_ad>(THM::PRESSURE),
      [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      {
        const auto rhoA = Moose::ADRealToGenericReal<is_ad>(_rhoA(r, t));
        const auto rhouA = Moose::ADRealToGenericReal<is_ad>(_rhouA(r, t));
        const auto rhoEA = Moose::ADRealToGenericReal<is_ad>(_rhoEA(r, t));
        const auto A = _A(r, t);
        const auto v = A / rhoA;
        const auto e = (rhoEA - 0.5 * rhouA * rhouA / rhoA) / rhoA;
        return _fp.p_from_v_e(v, e);
      });
}
 
template <bool is_ad>
void
FlowModel1PhaseFunctorMaterial::addTemperatureFunctorProperty()
{
  addFunctorProperty<GenericReal<is_ad>>(
      THM::functorMaterialPropertyName<is_ad>(THM::TEMPERATURE),
      [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      {
        const auto rhoA = Moose::ADRealToGenericReal<is_ad>(_rhoA(r, t));
        const auto rhouA = Moose::ADRealToGenericReal<is_ad>(_rhouA(r, t));
        const auto rhoEA = Moose::ADRealToGenericReal<is_ad>(_rhoEA(r, t));
        const auto A = _A(r, t);
        const auto v = A / rhoA;
        const auto e = (rhoEA - 0.5 * rhouA * rhouA / rhoA) / rhoA;
        return _fp.T_from_v_e(v, e);
      });
}
 
template <bool is_ad>
void
FlowModel1PhaseFunctorMaterial::addVelocityFunctorProperty()
{
  addFunctorProperty<GenericReal<is_ad>>(
      THM::functorMaterialPropertyName<is_ad>(THM::VELOCITY),
      [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      {
        const auto rhoA = Moose::ADRealToGenericReal<is_ad>(_rhoA(r, t));
        const auto rhouA = Moose::ADRealToGenericReal<is_ad>(_rhouA(r, t));
        return rhouA / rhoA;
      });
}