HSBoundaryInterface Class Reference

Interface class for coupling to a heat structure boundary. More...

#include <HSBoundaryInterface.h>

Inheritance diagram for HSBoundaryInterface:

Public Member Functions
	HSBoundaryInterface (Component *component)
void	check (const Component *const component) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
bool	HSBoundaryIsValid (const Component *const component) const
	Returns true if the specified heat structure boundary is valid.
const BoundaryName &	getHSBoundaryName (const Component *const component) const
	Gets the boundary name corresponding to the heat structure and side.
Component2D::ExternalBoundaryType	getHSExternalBoundaryType (const Component *const component) const
	Gets the external boundary type for the coupled heat structure boundary.

Protected Attributes
const std::string &	_hs_name
	Heat structure name.
Component2D::ExternalBoundaryType	_hs_side
	Heat structure side.
bool	_hs_side_valid
	True if the heat structure side enum is valid.

Detailed Description

Interface class for coupling to a heat structure boundary.

Definition at line 21 of file HSBoundaryInterface.h.

Constructor & Destructor Documentation

HSBoundaryInterface()

HSBoundaryInterface::HSBoundaryInterface

(

Component *

component

)

Definition at line 27 of file HSBoundaryInterface.C.

  : _hs_name(component->getParam<std::string>("hs")),
    _hs_side(component->getEnumParam<Component2D::ExternalBoundaryType>("hs_side", false)),
    _hs_side_valid(static_cast<int>(_hs_side) >= 0)
{
  component->addDependency(_hs_name);
 
  component->checkMutuallyExclusiveParameters({"hs_side", "hs_boundary"});
}

Member Function Documentation

check()

void HSBoundaryInterface::check

(

const Component *const

component

)

const

Definition at line 38 of file HSBoundaryInterface.C.

{
  component->checkComponentOfTypeExistsByName<HeatStructureBase>(_hs_name);
 
  if (component->hasComponentByName<HeatStructureBase>(_hs_name))
  {
    const auto & hs = component->getComponentByName<HeatStructureBase>(_hs_name);
 
    BoundaryName hs_boundary;
    Component2D::ExternalBoundaryType hs_side;
    if (component->isParamValid("hs_side"))
    {
      if (_hs_side_valid)
      {
        hs_boundary = hs.getExternalBoundaryName(_hs_side);
        hs_side = _hs_side;
      }
      else
      {
        component->logError("The parameter 'hs_side' was given an invalid value.");
        return;
      }
    }
    else
    {
      hs_boundary = component->getParam<BoundaryName>("hs_boundary");
      hs_side = hs.getExternalBoundaryType(hs_boundary);
    }
 
    if (!hs.hasBoundary(hs_boundary))
      component->logError("The heat structure boundary '", hs_boundary, "' does not exist.");
 
    const Real & P_hs = hs.getUnitPerimeter(hs_side);
    if (MooseUtils::absoluteFuzzyEqual(P_hs, 0.))
    {
      if (component->isParamValid("hs_side"))
        component->logError("'hs_side' parameter is set to '",
                            component->getParam<MooseEnum>("hs_side"),
                            "', but this side of the heat structure '",
                            _hs_name,
                            "' has radius of zero.");
      else
        component->logError("The specified boundary '",
                            hs_boundary,
                            "' of the heat structure '",
                            _hs_name,
                            "' has a radius of zero.");
    }
    if (std::isnan(P_hs))
      component->logError("The specified boundary '",
                          hs_boundary,
                          "' of the heat structure '",
                          _hs_name,
                          "' is either START and END boundary, which may not be used.");
  }
}

Referenced by HeatTransferFromHeatStructure1Phase::check().

getHSBoundaryName()

const BoundaryName & HSBoundaryInterface::getHSBoundaryName ( const Component *const  component ) const

protected

Gets the boundary name corresponding to the heat structure and side.

Parameters

[in]

component

Component pointer

Definition at line 96 of file HSBoundaryInterface.C.

{
  if (component->isParamValid("hs_side"))
  {
    const auto & hs = component->getComponentByName<HeatStructureBase>(_hs_name);
    return hs.getExternalBoundaryName(_hs_side);
  }
  else
    return component->getParam<BoundaryName>("hs_boundary");
}

Referenced by HeatTransferFromHeatStructure1Phase::addMooseObjects(), and HeatTransferFromHeatStructure1Phase::setupMesh().

getHSExternalBoundaryType()

Component2D::ExternalBoundaryType HSBoundaryInterface::getHSExternalBoundaryType ( const Component *const  component ) const

protected

Gets the external boundary type for the coupled heat structure boundary.

Parameters

[in]

component

Component pointer

Definition at line 108 of file HSBoundaryInterface.C.

{
  if (component->isParamValid("hs_side"))
    return _hs_side;
  else
  {
    const auto & hs = component->getComponentByName<HeatStructureBase>(_hs_name);
    const auto hs_boundary = component->getParam<BoundaryName>("hs_boundary");
    return hs.getExternalBoundaryType(hs_boundary);
  }
}

Referenced by HeatTransferFromHeatStructure1Phase::addMooseObjects().

HSBoundaryIsValid()

bool HSBoundaryInterface::HSBoundaryIsValid ( const Component *const  component ) const

protected

Returns true if the specified heat structure boundary is valid.

Definition at line 121 of file HSBoundaryInterface.C.

{
  const auto & hs = component->getComponentByName<HeatStructureBase>(_hs_name);
 
  BoundaryName hs_boundary;
  if (component->isParamValid("hs_side"))
  {
    if (_hs_side_valid)
      hs_boundary = hs.getExternalBoundaryName(_hs_side);
    else
      return false;
  }
  else
    hs_boundary = component->getParam<BoundaryName>("hs_boundary");
 
  return hs.hasBoundary(hs_boundary);
}

Referenced by HeatTransferFromHeatStructure1Phase::setupMesh().

validParams()

InputParameters HSBoundaryInterface::validParams ( )

static

Definition at line 15 of file HSBoundaryInterface.C.

{
  InputParameters params = emptyInputParameters();
 
  params.addRequiredParam<std::string>("hs", "Heat structure name");
  params.addParam<MooseEnum>(
      "hs_side", Component2D::getExternalBoundaryTypeMooseEnum(), "Heat structure side");
  params.addParam<BoundaryName>("hs_boundary", "Name of the coupled heat structure boundary.");
 
  return params;
}

Referenced by HeatTransferFromHeatStructure1Phase::validParams().

Member Data Documentation

_hs_name

const std::string& HSBoundaryInterface::_hs_name

protected

Heat structure name.

Definition at line 51 of file HSBoundaryInterface.h.

Referenced by HeatTransferFromHeatStructure1Phase::addMooseObjects(), HeatTransferFromHeatStructure1Phase::addVariables(), check(), getHSBoundaryName(), getHSExternalBoundaryType(), HSBoundaryInterface(), HSBoundaryIsValid(), and HeatTransferFromHeatStructure1Phase::setupMesh().

_hs_side

Component2D::ExternalBoundaryType HSBoundaryInterface::_hs_side

protected

Heat structure side.

Definition at line 54 of file HSBoundaryInterface.h.

Referenced by check(), getHSBoundaryName(), getHSExternalBoundaryType(), and HSBoundaryIsValid().

_hs_side_valid

bool HSBoundaryInterface::_hs_side_valid

protected

True if the heat structure side enum is valid.

Definition at line 56 of file HSBoundaryInterface.h.

Referenced by check(), and HSBoundaryIsValid().

---

The documentation for this class was generated from the following files:

• thermal_hydraulics/include/interfaces/HSBoundaryInterface.h
• thermal_hydraulics/src/interfaces/HSBoundaryInterface.C