SBMBndElementBase Class Reference

Base class for SBM boundary elements. More...

#include <SBMBndElementBase.h>

Inheritance diagram for SBMBndElementBase:

Public Member Functions
	SBMBndElementBase (const Elem *elem, const Point &normal)
	Constructor takes a pointer to a boundary element and its precomputed unit normal.
virtual	~SBMBndElementBase ()=default
	Virtual destructor to ensure proper cleanup in derived classes.
const Elem &	elem () const
	Getter for the underlying element.
const Point &	normal () const
	Getter for the normal vector.
bool	intersect (const LineSegment &line_segment) const
	Check if the given line segment intersects this boundary element.
unsigned int	expectedEmbeddingMeshDim () const
	Getter of expected embedding solving mesh dimension Because the boundary element is a face of the embedding mesh, its dimension is one less than the dimension of the embedding mesh.
virtual Point	distanceFrom (const Point &pt) const
	Compute the distance vector from an arbitrary point to this boundary element.
Ball	computeBoundingBall () const
	Compute a bounding ball for this boundary element.
Real	getProjectedBoundingBoxDiagonal (const Point &normal_dir) const
	Compute the length of the element bounding-box diagonal projected onto a plane orthogonal to a given direction.

Private Attributes
const Elem *	_elem
	< Pointer to the libMesh element representing this boundary face.
const Point	_normal

Detailed Description

Base class for SBM boundary elements.

Definition at line 18 of file SBMBndElementBase.h.

Constructor & Destructor Documentation

SBMBndElementBase()

SBMBndElementBase::SBMBndElementBase	(	const Elem *	elem,
		const Point &	normal
	)

Constructor takes a pointer to a boundary element and its precomputed unit normal.

The normal is computed eagerly by derived classes (which know their geometry) so the base can store it const and shared concurrent reads are safe.

Definition at line 16 of file SBMBndElementBase.C.

  : _elem(elem), _normal(normal)
{
  mooseAssert(elem, "Element must not be null");
  mooseAssert(MooseUtils::absoluteFuzzyEqual(_normal.norm(), 1),
              "normal vector must be unit length, length = " << _normal.norm());
 
  // Validate side type once, here, so distanceFrom() can trust the invariant
  // without paying a per-call check. libMesh standard elements have uniform
  // side types, so probing side(0) is sufficient.
  if (elem && elem->n_sides() > 0)
  {
    const auto t = elem->build_side_ptr(0)->type();
    if (t != EDGE2 && t != NODEELEM)
      mooseError("SBMBndElementBase: unsupported side type ",
                 libMesh::Utility::enum_to_string(t),
                 " (from element type ",
                 libMesh::Utility::enum_to_string(elem->type()),
                 "). distanceFrom() only handles EDGE2 and NODEELEM sides.");
  }
}

~SBMBndElementBase()

virtual SBMBndElementBase::~SBMBndElementBase ( )

virtualdefault

Virtual destructor to ensure proper cleanup in derived classes.

Member Function Documentation

computeBoundingBall()

Ball SBMBndElementBase::computeBoundingBall

(

)

const

Compute a bounding ball for this boundary element.

Delegates to the underlying geometry via dynamic_cast.

Definition at line 134 of file SBMBndElementBase.C.

{
  if (const auto * geom = dynamic_cast<const GeometryBase *>(this))
    return geom->computeBoundingBall();
 
  mooseError("SBMBndElementBase::computeBoundingBall: unsupported geometry type");
}

Referenced by TEST(), and TEST().

distanceFrom()

Point SBMBndElementBase::distanceFrom ( const Point &  pt ) const

virtual

Compute the distance vector from an arbitrary point to this boundary element.

Default: normal-based distance vector. Override in derived class if needed. (a) First calculation of the normal-based distance and the projection point (b) If the projection point is outside the element, return the distance to the closest vertex.

Definition at line 39 of file SBMBndElementBase.C.

{
  // Side-type precondition is validated once in the base ctor; no per-call
  // check needed here.
 
  // (a) Project pt onto the normal direction
  const auto vec_to_first = _elem->point(0) - pt;
  const auto scale = vec_to_first * _normal;
  const auto projection = _normal * scale;
 
  // Check if projection point lands inside the geometry
  if (_elem->contains_point(pt + projection))
    return projection;
 
  // (d) Point to closest edge or node
  Real min_dist = std::numeric_limits<Real>::max();
  Point closest_vec;
 
  const unsigned int n_edges = _elem->n_sides();
  for (unsigned int j = 0; j < n_edges; ++j)
  {
    std::unique_ptr<const Elem> curr_edge = _elem->build_side_ptr(j);
 
    switch (curr_edge->type())
    {
      case EDGE2:
      {
        const Point & p1 = *curr_edge->node_ptr(0);
        const Point & p2 = *curr_edge->node_ptr(1);
 
        const Point edge = p2 - p1;
        Real t = ((pt - p1) * edge) / (edge * edge);
        t = std::clamp(t, 0.0, 1.0);
        const Point proj = p1 + t * edge;
        const Real dist = (pt - proj).norm();
 
        if (dist < min_dist)
        {
          min_dist = dist;
          closest_vec = proj - pt;
        }
        break;
      }
 
      case NODEELEM:
      {
        const Point & p = *curr_edge->node_ptr(0);
        const Real dist = (pt - p).norm();
        if (dist < min_dist)
        {
          min_dist = dist;
          closest_vec = p - pt;
        }
        break;
      }
 
      default:
        mooseAssert(false, "unreachable: side type validated in SBMBndElementBase ctor");
    }
  }
 
  return closest_vec;
}

Referenced by UnsignedDistanceToSurfaceMesh::distanceVectorToSurface(), TEST(), TEST(), TEST(), TEST(), and TEST().

elem()

const Elem & SBMBndElementBase::elem ( ) const

inline

Getter for the underlying element.

Definition at line 32 of file SBMBndElementBase.h.

{ return *_elem; }

Referenced by SBMBndEdge2::SBMBndEdge2(), SBMBndElementBase(), SBMBndUnsupportedForTest::SBMBndElementBase(), and SBMBndTri3::SBMBndTri3().

expectedEmbeddingMeshDim()

unsigned int SBMBndElementBase::expectedEmbeddingMeshDim ( ) const

inline

Getter of expected embedding solving mesh dimension Because the boundary element is a face of the embedding mesh, its dimension is one less than the dimension of the embedding mesh.

Definition at line 46 of file SBMBndElementBase.h.

{ return _elem->dim() + 1; }

getProjectedBoundingBoxDiagonal()

Real SBMBndElementBase::getProjectedBoundingBoxDiagonal

(

const Point &

normal_dir

)

const

Compute the length of the element bounding-box diagonal projected onto a plane orthogonal to a given direction.

The projection plane is defined only by its normal direction; the specific location (offset) of the plane is irrelevant for this operation. Equivalently, this function removes the component of the bounding-box diagonal along the given normal direction and returns the norm of the remaining tangential component.

Parameters

normal_dir

A direction vector defining the plane normal.

Returns

The length of the longest diagonal of the projected rectangle.

Definition at line 104 of file SBMBndElementBase.C.

{
  BoundingBox bbox = _elem->loose_bounding_box();
 
  const Point & min_pt = bbox.first;
  const Point & max_pt = bbox.second;
 
  // Step (a): Calculate box_vec
  Point box_vec = max_pt - min_pt;
 
  // Step (b): Project box_vec onto normal_dir
  Real normal_scale = box_vec * normal_dir;
  Point normal_box_vec = normal_dir * normal_scale;
 
  // Step (c): Calculate tangent_vec and its norm
  Point tangent_vec = box_vec - normal_box_vec;
 
  return tangent_vec.norm();
}

Referenced by TEST().

intersect()

bool SBMBndElementBase::intersect

(

const LineSegment &

line_segment

)

const

Check if the given line segment intersects this boundary element.

Delegates to the underlying geometry via dynamic_cast.

Definition at line 125 of file SBMBndElementBase.C.

{
  if (const auto * geom = dynamic_cast<const GeometryBase *>(this))
    return geom->intersect(line_segment);
 
  mooseError("SBMBndElementBase::intersect: unsupported geometry type");
}

Referenced by TEST(), and TEST().

normal()

const Point & SBMBndElementBase::normal ( ) const

inline

Getter for the normal vector.

Definition at line 35 of file SBMBndElementBase.h.

{ return _normal; }

Referenced by UnsignedDistanceToSurfaceMesh::surfaceNormal().

Member Data Documentation

_elem

const Elem* SBMBndElementBase::_elem

private

< Pointer to the libMesh element representing this boundary face.

Derived classes access it through elem() rather than this field directly. Unit normal vector of the boundary element, computed eagerly in the derived constructor and passed through the base constructor.

Definition at line 80 of file SBMBndElementBase.h.

Referenced by distanceFrom(), elem(), expectedEmbeddingMeshDim(), and getProjectedBoundingBoxDiagonal().

_normal

const Point SBMBndElementBase::_normal

private

Definition at line 83 of file SBMBndElementBase.h.

Referenced by distanceFrom(), normal(), and SBMBndElementBase().

---

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

• shifted_boundary_method/include/SBMBndElement/SBMBndElementBase.h
• shifted_boundary_method/src/SBMBndElement/SBMBndElementBase.C