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

virtual RealVectorValue	getDirection () const

virtual Real	getRotation () const

virtual Real	getNumElems () const

virtual Real	getLength () const

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. More...

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

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

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

Static Public Member Functions
static InputParameters	validParams ()

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

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

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. More...

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. More...

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

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. More...

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

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

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

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

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

Real	_length
	Total axial length. More...

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

const unsigned int	_n_elem
	Total number of axial elements. More...

const unsigned int	_n_sections
	Number of axial sections. More...

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

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

const RealTensorValue	_R
	Direction transformation tensor. More...

const RealTensorValue	_Rx
	Rotational transformation tensor about x-axis. More...

const RealTensorValue	_R_inv
	Inverse direction transformation tensor. More...

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

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

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. More...

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)),
     _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;
   for (unsigned int j = 0; j < _n_sections; j++)
   {
     const Real dx = _lengths[j] / _n_elems[j];
     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 107 of file DiscreteLineSegmentInterface.C.

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

 {
   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;
 }

◆ computeDirectionTransformationTensor()

RealTensorValue DiscreteLineSegmentInterface::computeDirectionTransformationTensor ( const RealVectorValue & dir )

static

Computes the direction transformation tensor.

Parameters

[in] dir Direction vector

Definition at line 82 of file DiscreteLineSegmentInterface.C.

Referenced by getElementBoundaryCoordinates().

 {
   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)));
 }

◆ computeRadialCoordinate()

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

Definition at line 125 of file DiscreteLineSegmentInterface.C.

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

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

◆ 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 163 of file DiscreteLineSegmentInterface.C.

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

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

◆ 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 154 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 178 of file DiscreteLineSegmentInterface.C.

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

◆ 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 169 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 97 of file DiscreteLineSegmentInterface.C.

Referenced by getElementBoundaryCoordinates().

 {
   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);
 }

◆ 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 198 of file DiscreteLineSegmentInterface.C.

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

 {
   return getAlignmentAxis(_dir);
 }

◆ 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 184 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 143 of file DiscreteLineSegmentInterface.C.

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

 {
   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.");
 }

◆ getAxialSectionIndex()

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

Definition at line 132 of file DiscreteLineSegmentInterface.C.

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

 {
   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.");
 }

◆ getDirection()

virtual RealVectorValue DiscreteLineSegmentInterface::getDirection ( ) const

inlinevirtual

Definition at line 28 of file DiscreteLineSegmentInterface.h.

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatStructure2DCoupler::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::getFlowChannelAxisAlignment(), and Component1DConnection::setupMesh().

28 { return _dir; }

DiscreteLineSegmentInterface::_dir

const RealVectorValue _dir

Normalized direction of axis from start position to end position.

Definition: DiscreteLineSegmentInterface.h:95

◆ getElementBoundaryCoordinates() [1/2]

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

Gets the element boundary coordinates for the aligned axis.

Definition at line 254 of file DiscreteLineSegmentInterface.C.

Referenced by CoupledHeatTransferAction::addUserObjects().

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

◆ 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 204 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;
 }

◆ getLength()

virtual Real DiscreteLineSegmentInterface::getLength ( ) const

inlinevirtual

Definition at line 32 of file DiscreteLineSegmentInterface.h.

Referenced by HeatTransferFromHeatStructure1Phase::check(), and HeatTransferFromHeatStructure3D1Phase::init().

32 { return _length; }

DiscreteLineSegmentInterface::_length

Real _length

Total axial length.

Definition: DiscreteLineSegmentInterface.h:102

◆ getNumElems()

virtual Real DiscreteLineSegmentInterface::getNumElems ( ) const

inlinevirtual

Definition at line 31 of file DiscreteLineSegmentInterface.h.

Referenced by HeatTransferFromHeatStructure1Phase::check(), and HeatTransferFromHeatStructure3D1Phase::init().

31 { return _n_elem; }

DiscreteLineSegmentInterface::_n_elem

const unsigned int _n_elem

Total number of axial elements.

Definition: DiscreteLineSegmentInterface.h:107

◆ getPosition()

virtual Point DiscreteLineSegmentInterface::getPosition ( ) const

inlinevirtual

Definition at line 27 of file DiscreteLineSegmentInterface.h.

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatSourceFromTotalPower::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), and HeatTransferFromHeatStructure3D1Phase::addMooseObjects().

27 { return _position; }

DiscreteLineSegmentInterface::_position

const Point & _position

Start position of axis in 3-D space.

Definition: DiscreteLineSegmentInterface.h:91

◆ getRotation()

virtual Real DiscreteLineSegmentInterface::getRotation ( ) const

inlinevirtual

Definition at line 29 of file DiscreteLineSegmentInterface.h.

29 { return _rotation; }

DiscreteLineSegmentInterface::_rotation

const Real & _rotation

Angle of rotation about the x-axis.

Definition: DiscreteLineSegmentInterface.h:97

◆ 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 73 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.

Referenced by GeneratedMeshComponent::validParams(), and DiscreteLineSegmentInterfaceTestAux::validParams().

 {
   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;
 }