VolumeJunctionCoupledFlux1PhasePostprocessor.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 "VolumeJunctionCoupledFlux1PhasePostprocessor.h"
#include "ADVolumeJunction1PhaseUserObject.h"
#include "ADNumericalFlux3EqnBase.h"
#include "SinglePhaseFluidProperties.h"
#include "THMIndicesVACE.h"
 
registerMooseObject("ThermalHydraulicsApp", VolumeJunctionCoupledFlux1PhasePostprocessor);
 
InputParameters
VolumeJunctionCoupledFlux1PhasePostprocessor::validParams()
{
  InputParameters params = GeneralPostprocessor::validParams();
 
  MooseEnum equation("mass energy");
  params.addRequiredParam<MooseEnum>(
      "equation", equation, "Equation for which to query flux vector");
  params.addRequiredParam<PostprocessorName>("pressure", "Pressure post-processor");
  params.addRequiredParam<PostprocessorName>("temperature", "Temperature post-processor");
  params.addRequiredParam<Real>("A_coupled", "Area of the flux coupling");
  params.addRequiredParam<RealVectorValue>("normal_from_junction",
                                           "Unit normal vector from the junction");
  params.addRequiredParam<UserObjectName>(
      "volume_junction_uo",
      "ADVolumeJunction1PhaseUserObject object corresponding to the volume junction");
  params.addRequiredParam<UserObjectName>("numerical_flux_uo", "ADNumericalFlux3EqnBase object");
  params.addRequiredParam<UserObjectName>("fluid_properties", "SinglePhaseFluidProperties object");
 
  params.addClassDescription("Computes a mass or energy flux for VolumeJunctionCoupledFlux1Phase.");
 
  return params;
}
 
VolumeJunctionCoupledFlux1PhasePostprocessor::VolumeJunctionCoupledFlux1PhasePostprocessor(
    const InputParameters & parameters)
  : GeneralPostprocessor(parameters),
    _equation(getParam<MooseEnum>("equation")),
    _p(getPostprocessorValue("pressure")),
    _T(getPostprocessorValue("temperature")),
    _A_coupled(getParam<Real>("A_coupled")),
    _normal_from_junction(getParam<RealVectorValue>("normal_from_junction")),
    _normal_to_junction(-_normal_from_junction),
    _volume_junction_uo(getUserObject<ADVolumeJunction1PhaseUserObject>("volume_junction_uo")),
    _numerical_flux_uo(getUserObject<ADNumericalFlux3EqnBase>("numerical_flux_uo")),
    _fp(getUserObject<SinglePhaseFluidProperties>("fluid_properties"))
{
}
 
void
VolumeJunctionCoupledFlux1PhasePostprocessor::finalize()
{
  const auto rho = _fp.rho_from_p_T(_p, _T);
  const auto E = _fp.e_from_p_T(_p, _T);
 
  std::vector<ADReal> U(THMVACE3D::N_FLUX_INPUTS, 0.0);
  U[THMVACE3D::RHOA] = rho * _A_coupled;
  U[THMVACE3D::RHOEA] = rho * E * _A_coupled;
  U[THMVACE3D::AREA] = _A_coupled;
 
  const auto flux_3d =
      _volume_junction_uo.compute3DFlux(_numerical_flux_uo, U, _normal_to_junction);
 
  if (_equation == "mass")
    _value = raw_value(flux_3d[THMVACE3D::MASS]);
  else if (_equation == "energy")
    _value = raw_value(flux_3d[THMVACE3D::ENERGY]);
  else
    mooseError("Invalid MooseEnum value.");
}
 
PostprocessorValue
VolumeJunctionCoupledFlux1PhasePostprocessor::getValue() const
{
  return _value;
}