Defines a discretized line segment in 3D space. More...

#include <DiscreteLineSegmentInterface.h>

Inheritance diagram for DiscreteLineSegmentInterface:

Public Member Functions
	DiscreteLineSegmentInterface (const MooseObject *moose_object)

virtual Point	getPosition () const

Point	getStartPoint () const

Point	getEndPoint () const

virtual RealVectorValue	getDirection () const

virtual Real	getRotation () const

virtual Real	getNumElems () const

virtual Real	getLength () const

Real	getMinimumElemSize () const
	Gets the minimum element size.

Real	computeAxialCoordinate (const Point &p) const

Real	computeRadialCoordinate (const Point &p) const

unsigned int	getAxialSectionIndex (const Point &p) const

unsigned int	getAxialElementIndex (const Point &p_center) const

Point	computeRealPointFromReferencePoint (const Point &p) const
	Computes point in 3-D space from a point in reference space.

Point	computeReferencePointFromRealPoint (const Point &p) const
	Computes point in reference space from a point in 3-D space.

MooseEnum	getAlignmentAxis () const
	Gets an axis MooseEnum for the axis the component is aligned with.

std::vector< Real >	getElementBoundaryCoordinates () const
	Gets the element boundary coordinates for the aligned axis.

Static Public Member Functions
static InputParameters	validParams ()

static RealTensorValue	computeDirectionTransformationTensor (const RealVectorValue &dir)
	Computes the direction transformation tensor.

static RealTensorValue	computeXRotationTransformationTensor (const Real &rotation)
	Computes the rotation transformation tensor.

static Point	computeRealPointFromReferencePoint (const Point &p, const RealVectorValue &position, const RealTensorValue &R, const RealTensorValue &Rx)
	Computes point in 3-D space from a point in reference space.

static Point	computeReferencePointFromRealPoint (const Point &p, const RealVectorValue &position, const RealTensorValue &R_inv, const RealTensorValue &Rx_inv)
	Computes point in reference space from a point in 3-D space.

static MooseEnum	getAlignmentAxis (const RealVectorValue &dir)
	Gets an axis MooseEnum for the axis the component is aligned with.

static std::vector< Real >	getElementBoundaryCoordinates (const RealVectorValue &position, const RealVectorValue &orientation, const Real &rotation, const std::vector< Real > &lengths, const std::vector< unsigned int > &n_elems)
	Gets the element boundary coordinates for the aligned axis.

Public Attributes
Real	_dx_min
	Minimum element size.

Protected Attributes
const Point &	_position
	Start position of axis in 3-D space.

const RealVectorValue &	_dir_unnormalized
	Unnormalized direction of axis from start position to end position.

const RealVectorValue	_dir
	Normalized direction of axis from start position to end position.

const Real &	_rotation
	Angle of rotation about the x-axis.

std::vector< Real >	_lengths
	Length of each axial section.

Real	_length
	Total axial length.

const Point	_end_point
	End point of line segment.

std::vector< unsigned int >	_n_elems
	Number of elements in each axial section.

unsigned int	_n_elem
	Total number of axial elements.

const unsigned int	_n_sections
	Number of axial sections.

std::vector< Real >	_section_end
	Axial coordinate of the end of each axial section using the line 'position' as the origin.

std::vector< Real >	_x_centers
	Center axial coordinate of each axial element.

const RealTensorValue	_R
	Direction transformation tensor.

const RealTensorValue	_Rx
	Rotational transformation tensor about x-axis.

const RealTensorValue	_R_inv
	Inverse direction transformation tensor.

const RealTensorValue	_Rx_inv
	Inverse rotational transformation tensor about x-axis.

const std::string	_moose_object_name_dlsi
	Name of the MOOSE object.

Static Private Member Functions
static RealVectorValue	initializeDirectionVector (const RealVectorValue &dir_unnormalized)
	Computes a normalized direction vector or reports an error if the zero vector is provided.

Detailed Description

Defines a discretized line segment in 3D space.

Definition at line 22 of file DiscreteLineSegmentInterface.h.

Constructor & Destructor Documentation

◆ DiscreteLineSegmentInterface()

DiscreteLineSegmentInterface::DiscreteLineSegmentInterface ( const MooseObject * moose_object )

Definition at line 33 of file DiscreteLineSegmentInterface.C.

  : _position(moose_object->parameters().get<Point>("position")),
    _dir_unnormalized(moose_object->parameters().get<RealVectorValue>("orientation")),
    _dir(initializeDirectionVector(_dir_unnormalized)),
    _rotation(moose_object->parameters().get<Real>("rotation")),
    _lengths(moose_object->parameters().get<std::vector<Real>>("length")),
    _length(std::accumulate(_lengths.begin(), _lengths.end(), 0.0)),
    _end_point(_position + _dir * _length),
    _n_elems(moose_object->parameters().get<std::vector<unsigned int>>("n_elems")),
    _n_elem(std::accumulate(_n_elems.begin(), _n_elems.end(), 0)),
    _n_sections(_lengths.size()),
    _section_end(_n_sections),
    _x_centers(_n_elem),
    _R(computeDirectionTransformationTensor(_dir)),
    _Rx(computeXRotationTransformationTensor(_rotation)),
    _R_inv(_R.inverse()),
    _Rx_inv(_Rx.inverse()),
    _moose_object_name_dlsi(moose_object->name())
{
  std::partial_sum(_lengths.begin(), _lengths.end(), _section_end.begin());
 
  if (_lengths.size() != _n_elems.size())
    mooseError("The parameters 'length' and 'n_elems' must have the same number of entries.");
 
  // Compute the axial coordinates of the centers of each element
  unsigned int k_section_begin = 0;
  Real x_begin = 0.0;
  _dx_min = std::numeric_limits<Real>::max();
  for (unsigned int j = 0; j < _n_sections; j++)
  {
    const Real dx = _lengths[j] / _n_elems[j];
    _dx_min = std::min(dx, _dx_min);
    for (unsigned int i = 0; i < _n_elems[j]; i++)
    {
      const unsigned int k = k_section_begin + i;
      _x_centers[k] = x_begin + 0.5 * dx;
      x_begin += dx;
    }
    k_section_begin += _n_elems[j];
  }
}

Member Function Documentation

◆ computeAxialCoordinate()

Real DiscreteLineSegmentInterface::computeAxialCoordinate ( const Point & p ) const

Definition at line 110 of file DiscreteLineSegmentInterface.C.

{
  const Real ax_coord = _dir * (p - _position);
  if (MooseUtils::absoluteFuzzyLessThan(ax_coord, 0.0) ||
      MooseUtils::absoluteFuzzyGreaterThan(ax_coord, _length))
    mooseError(_moose_object_name_dlsi,
               ": The point ",
               p,
               " has an invalid axial coordinate (",
               ax_coord,
               "). Valid axial coordinates are in the range (0,",
               _length,
               ").");
  else
    return ax_coord;
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue(), getAxialElementIndex(), and getAxialSectionIndex().

◆ computeDirectionTransformationTensor()

RealTensorValue DiscreteLineSegmentInterface::computeDirectionTransformationTensor ( const RealVectorValue & dir )

static

Computes the direction transformation tensor.

Parameters

[in] dir Direction vector

Definition at line 85 of file DiscreteLineSegmentInterface.C.

{
  if (MooseUtils::absoluteFuzzyEqual(dir.norm(), 0.0))
    mooseError("The direction vector must not be the zero vector.");
 
  const auto dir_normalized = dir / dir.norm();
  const Real theta = acos(dir_normalized(2));
  const Real aphi = atan2(dir_normalized(1), dir_normalized(0));
  return RealTensorValue(
      RealVectorValue(cos(aphi) * sin(theta), -sin(aphi), -cos(aphi) * cos(theta)),
      RealVectorValue(sin(aphi) * sin(theta), cos(aphi), -sin(aphi) * cos(theta)),
      RealVectorValue(cos(theta), 0.0, sin(theta)));
}

Referenced by getElementBoundaryCoordinates().

◆ computeRadialCoordinate()

Real DiscreteLineSegmentInterface::computeRadialCoordinate ( const Point & p ) const

Definition at line 128 of file DiscreteLineSegmentInterface.C.

{
  const RealVectorValue v = (p - _position);
  return v.cross(_dir).norm();
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ computeRealPointFromReferencePoint() [1/2]

Point DiscreteLineSegmentInterface::computeRealPointFromReferencePoint ( const Point & p ) const

Computes point in 3-D space from a point in reference space.

Parameters

[in] p Point in reference space

Definition at line 166 of file DiscreteLineSegmentInterface.C.

{
  return computeRealPointFromReferencePoint(p, _position, _R, _Rx);
}

Referenced by computeRealPointFromReferencePoint(), getElementBoundaryCoordinates(), and GeneratedMeshComponent::setupMesh().

◆ computeRealPointFromReferencePoint() [2/2]

Point DiscreteLineSegmentInterface::computeRealPointFromReferencePoint	(	const Point &	p,
		const RealVectorValue &	position,
		const RealTensorValue &	R,
		const RealTensorValue &	Rx
	)

static

Computes point in 3-D space from a point in reference space.

Parameters

[in] p Point in reference space

Definition at line 157 of file DiscreteLineSegmentInterface.C.

{
  return R * (Rx * p) + position;
}

◆ computeReferencePointFromRealPoint() [1/2]

Point DiscreteLineSegmentInterface::computeReferencePointFromRealPoint ( const Point & p ) const

Computes point in reference space from a point in 3-D space.

Parameters

[in] p Point in 3-D space

Definition at line 181 of file DiscreteLineSegmentInterface.C.

{
  return computeReferencePointFromRealPoint(p, _position, _R_inv, _Rx_inv);
}

Referenced by computeReferencePointFromRealPoint().

◆ computeReferencePointFromRealPoint() [2/2]

Point DiscreteLineSegmentInterface::computeReferencePointFromRealPoint	(	const Point &	p,
		const RealVectorValue &	position,
		const RealTensorValue &	R_inv,
		const RealTensorValue &	Rx_inv
	)

static

Computes point in reference space from a point in 3-D space.

Parameters

[in] p Point in 3-D space

Definition at line 172 of file DiscreteLineSegmentInterface.C.

{
  return Rx_inv * R_inv * (p - position);
}

◆ computeXRotationTransformationTensor()

RealTensorValue DiscreteLineSegmentInterface::computeXRotationTransformationTensor ( const Real & rotation )

static

Computes the rotation transformation tensor.

Parameters

[in] rotation Rotation about the x-axis, in degrees

Definition at line 100 of file DiscreteLineSegmentInterface.C.

{
  const Real rotation_rad = M_PI * rotation / 180.;
  const RealVectorValue Rx_x(1., 0., 0.);
  const RealVectorValue Rx_y(0., cos(rotation_rad), -sin(rotation_rad));
  const RealVectorValue Rx_z(0., sin(rotation_rad), cos(rotation_rad));
  return RealTensorValue(Rx_x, Rx_y, Rx_z);
}

Referenced by getElementBoundaryCoordinates().

◆ getAlignmentAxis() [1/2]

MooseEnum DiscreteLineSegmentInterface::getAlignmentAxis ( ) const

Gets an axis MooseEnum for the axis the component is aligned with.

If the axis does not align with the x, y, or z axis, then an invalid MooseEnum is returned.

Definition at line 201 of file DiscreteLineSegmentInterface.C.

{
  return getAlignmentAxis(_dir);
}

Referenced by CoupledHeatTransferAction::addUserObjects(), CoupledHeatTransferAction::CoupledHeatTransferAction(), getAlignmentAxis(), and getElementBoundaryCoordinates().

◆ getAlignmentAxis() [2/2]

MooseEnum DiscreteLineSegmentInterface::getAlignmentAxis ( const RealVectorValue & dir )

static

Gets an axis MooseEnum for the axis the component is aligned with.

If the axis does not align with the x, y, or z axis, then an invalid MooseEnum is returned.

Definition at line 187 of file DiscreteLineSegmentInterface.C.

{
  MooseEnum axis("x y z");
  if (THM::areParallelVectors(dir, RealVectorValue(1, 0, 0)))
    axis = "x";
  else if (THM::areParallelVectors(dir, RealVectorValue(0, 1, 0)))
    axis = "y";
  else if (THM::areParallelVectors(dir, RealVectorValue(0, 0, 1)))
    axis = "z";
 
  return axis;
}

◆ getAxialElementIndex()

unsigned int DiscreteLineSegmentInterface::getAxialElementIndex ( const Point & p_center ) const

Definition at line 146 of file DiscreteLineSegmentInterface.C.

{
  const Real axial_coordinate = computeAxialCoordinate(p_center);
  for (unsigned int i = 0; i < _n_elem; ++i)
    if (MooseUtils::absoluteFuzzyEqual(axial_coordinate, _x_centers[i]))
      return i;
 
  mooseError("No axial element index was found.");
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ getAxialSectionIndex()

unsigned int DiscreteLineSegmentInterface::getAxialSectionIndex ( const Point & p ) const

Definition at line 135 of file DiscreteLineSegmentInterface.C.

{
  const Real axial_coordinate = computeAxialCoordinate(p);
  for (unsigned int i = 0; i < _n_sections; ++i)
    if (MooseUtils::absoluteFuzzyLessEqual(axial_coordinate, _section_end[i]))
      return i;
 
  mooseError("No axial section index was found.");
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ getDirection()

virtual RealVectorValue DiscreteLineSegmentInterface::getDirection ( ) const

inlinevirtual

Definition at line 30 of file DiscreteLineSegmentInterface.h.

30{ return _dir; }

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatSourceFromPowerDensity::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), HSBoundaryRadiation::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::getFlowChannelAxisAlignment(), and Component1DConnection::setupMesh().

◆ getElementBoundaryCoordinates() [1/2]

std::vector< Real > DiscreteLineSegmentInterface::getElementBoundaryCoordinates ( ) const

Gets the element boundary coordinates for the aligned axis.

Definition at line 257 of file DiscreteLineSegmentInterface.C.

{
  return getElementBoundaryCoordinates(_position, _dir, _rotation, _lengths, _n_elems);
}

Referenced by CoupledHeatTransferAction::addUserObjects(), and getElementBoundaryCoordinates().

◆ getElementBoundaryCoordinates() [2/2]

std::vector< Real > DiscreteLineSegmentInterface::getElementBoundaryCoordinates	(	const RealVectorValue &	position,
		const RealVectorValue &	orientation,
		const Real &	rotation,
		const std::vector< Real > &	lengths,
		const std::vector< unsigned int > &	n_elems
	)

static

Gets the element boundary coordinates for the aligned axis.

Parameters

[in]	position	Start position of axis in 3-D space
[in]	orientation	Direction of axis from start position to end position
[in]	rotation	Angle of rotation about the x-axis, in degrees
[in]	lengths	Length of each axial section
[in]	n_elems	Number of elements in each axial section

Definition at line 207 of file DiscreteLineSegmentInterface.C.

{
  const auto axis = getAlignmentAxis(orientation);
 
  unsigned int d;
  if (axis == "x")
    d = 0;
  else if (axis == "y")
    d = 1;
  else if (axis == "z")
    d = 2;
  else
    mooseError("Invalid axis.");
 
  const auto R = computeDirectionTransformationTensor(orientation);
  const auto Rx = computeXRotationTransformationTensor(rotation);
 
  const unsigned int n_elems_total = std::accumulate(n_elems.begin(), n_elems.end(), 0);
  const unsigned int n_sections = lengths.size();
 
  unsigned int i_section_start = 0;
  Real section_start_ref_position = 0.0;
  std::vector<Real> element_boundary_coordinates(n_elems_total + 1);
  element_boundary_coordinates[0] =
      computeRealPointFromReferencePoint(Point(0, 0, 0), position, R, Rx)(d);
  for (unsigned int j = 0; j < n_sections; ++j)
  {
    const Real section_dx = lengths[j] / n_elems[j];
    for (unsigned int k = 0; k < n_elems[j]; ++k)
    {
      const unsigned int i = i_section_start + k + 1;
      const Real ref_position = section_start_ref_position + section_dx * k;
      const Point ref_point = Point(ref_position, 0, 0);
      element_boundary_coordinates[i] =
          computeRealPointFromReferencePoint(ref_point, position, R, Rx)(d);
    }
 
    section_start_ref_position += lengths[j];
    i_section_start += n_elems[j];
  }
 
  return element_boundary_coordinates;
}

◆ getEndPoint()

Point DiscreteLineSegmentInterface::getEndPoint ( ) const

inline

Definition at line 29 of file DiscreteLineSegmentInterface.h.

29{ return _end_point; }

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm().

◆ getLength()

virtual Real DiscreteLineSegmentInterface::getLength ( ) const

inlinevirtual

Definition at line 34 of file DiscreteLineSegmentInterface.h.

34{ return _length; }

Referenced by HeatSourceFromTotalPower::addMooseObjects(), and HeatTransferFromHeatStructure3D1Phase::init().

◆ getMinimumElemSize()

Real DiscreteLineSegmentInterface::getMinimumElemSize ( ) const

inline

Gets the minimum element size.

Definition at line 37 of file DiscreteLineSegmentInterface.h.

37{ return _dx_min; }

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm().

◆ getNumElems()

virtual Real DiscreteLineSegmentInterface::getNumElems ( ) const

inlinevirtual

Definition at line 33 of file DiscreteLineSegmentInterface.h.

33{ return _n_elem; }

Referenced by HeatTransferFromHeatStructure3D1Phase::init().

◆ getPosition()

virtual Point DiscreteLineSegmentInterface::getPosition ( ) const

inlinevirtual

Definition at line 27 of file DiscreteLineSegmentInterface.h.

27{ return getStartPoint(); }

DiscreteLineSegmentInterface::getStartPoint

Point getStartPoint() const

Definition DiscreteLineSegmentInterface.h:28

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatSourceFromPowerDensity::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::addMooseObjects(), HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), and HSBoundaryRadiation::addMooseObjects().

◆ getRotation()

virtual Real DiscreteLineSegmentInterface::getRotation ( ) const

inlinevirtual

Definition at line 31 of file DiscreteLineSegmentInterface.h.

31{ return _rotation; }

◆ getStartPoint()

Point DiscreteLineSegmentInterface::getStartPoint ( ) const

inline

Definition at line 28 of file DiscreteLineSegmentInterface.h.

28{ return _position; }

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm(), and getPosition().

◆ initializeDirectionVector()

RealVectorValue DiscreteLineSegmentInterface::initializeDirectionVector ( const RealVectorValue & dir_unnormalized )

staticprivate

Computes a normalized direction vector or reports an error if the zero vector is provided.

Parameters

[in] dir_unnormalized Unnormalized direction vector

Definition at line 76 of file DiscreteLineSegmentInterface.C.

{
  if (!MooseUtils::absoluteFuzzyEqual(dir_unnormalized.norm(), 0.0))
    return dir_unnormalized / dir_unnormalized.norm();
  else
    mooseError("The parameter 'orientation' must not be the zero vector.");
}

◆ validParams()

InputParameters DiscreteLineSegmentInterface::validParams ( )

static

Definition at line 17 of file DiscreteLineSegmentInterface.C.

{
  InputParameters params = emptyInputParameters();
 
  params.addRequiredParam<Point>("position", "Start position of axis in 3-D space [m]");
  params.addRequiredParam<RealVectorValue>(
      "orientation",
      "Direction of axis from start position to end position (no need to normalize)");
  params.addParam<Real>("rotation", 0.0, "Angle of rotation about the x-axis [degrees]");
  params.addRequiredParam<std::vector<Real>>("length", "Length of each axial section [m]");
  params.addRequiredParam<std::vector<unsigned int>>("n_elems",
                                                     "Number of elements in each axial section");
 
  return params;
}