libMesh::PlaneConstraint Class Reference

Represents a plane constraint defined by a point and normal vector. More...

#include <variational_smoother_constraint.h>

Public Member Functions
	PlaneConstraint ()=default
	PlaneConstraint (const Point &point, const Point &normal, const Real &tol=TOLERANCE *TOLERANCE)
	Constructor.
bool	operator< (const PlaneConstraint &other) const
	Comparison operator for ordering PlaneConstraint objects.
bool	operator== (const PlaneConstraint &other) const
	Equality operator.
bool	contains_point (const PointConstraint &p) const
	Query whether a point lies on the plane.
bool	contains_line (const LineConstraint &l) const
	Query whether a line lies on the plane.
bool	is_parallel (const PlaneConstraint &p) const
	Query whether a plane is parallel to this plane.
bool	is_parallel (const LineConstraint &l) const
	Query whether a line is parallel to this plane.
ConstraintVariant	intersect (const ConstraintVariant &other) const
	Computes the intersection of this plane with another constraint.
const Point &	point () const
	Const getter for the _point attribute.
const Point &	normal () const
	Const getter for the _normal attribute.
const Real &	tol () const
	Const getter for the _tol attribute.

Private Attributes
Point	_point
	A point on the constraining plane.
Point	_normal
	The direction normal to the constraining plane.
Real	_tol
	Tolerance to use for numerical comparisons.

Detailed Description

Represents a plane constraint defined by a point and normal vector.

Definition at line 222 of file variational_smoother_constraint.h.

Constructor & Destructor Documentation

PlaneConstraint() [1/2]

libMesh::PlaneConstraint::PlaneConstraint ( )

default

PlaneConstraint() [2/2]

libMesh::PlaneConstraint::PlaneConstraint	(	const Point &	point,
		const Point &	normal,
		const Real &	tol = TOLERANCE * TOLERANCE
	)

Constructor.

Parameters

point	A point on the constraining plane.
normal	the direction normal to the constraining plane.
tol	The tolerance to use for numerical comparisons.

Definition at line 179 of file variational_smoother_constraint.C.

  : _point(point), _normal(get_positive_vector(normal)), _tol(tol)
{
  libmesh_error_msg_if(_normal.norm() < _tol,
                       "Can't define a plane with zero magnitude direction vector.");
}

References _normal, _tol, and libMesh::TypeVector< T >::norm().

Member Function Documentation

contains_line()

bool libMesh::PlaneConstraint::contains_line

(

const LineConstraint &

l

)

const

Query whether a line lies on the plane.

Parameters

l	The line in question

Returns

bool indicating whether l lies on the plane.

Definition at line 217 of file variational_smoother_constraint.C.

{
  const bool base_on_plane = this->contains_point(PointConstraint(l.point()));
  const bool dir_orthogonal = std::abs(_normal * l.direction()) < _tol;
  return base_on_plane && dir_orthogonal;
}

References _normal, _tol, contains_point(), libMesh::LineConstraint::direction(), and libMesh::LineConstraint::point().

Referenced by intersect().

contains_point()

bool libMesh::PlaneConstraint::contains_point

(

const PointConstraint &

p

)

const

Query whether a point lies on the plane.

Parameters

p	The point in question

Returns

bool indicating whether p lies on the plane.

Definition at line 210 of file variational_smoother_constraint.C.

{
  // distance between the point and the plane
  const Real dist = (p.point() - _point) * _normal;
  return std::abs(dist) < _tol;
}

References _normal, _point, _tol, libMesh::PointConstraint::point(), and libMesh::Real.

Referenced by contains_line(), intersect(), and operator==().

intersect()

ConstraintVariant libMesh::PlaneConstraint::intersect

(

const ConstraintVariant &

other

)

const

Computes the intersection of this plane with another constraint.

Handles intersection with PlaneConstraint, LineConstraint, or PointConstraint.

Parameters

other

The constraint to intersect with.

Returns

The most specific ConstraintVariant that satisfies both constraints. constraints. If no intersection exists, return an InvalidConstraint.

Definition at line 224 of file variational_smoother_constraint.C.

{
  // using visit to resolve the variant to its actual type
  return std::visit(
      [&](auto && o) -> ConstraintVariant {
        // Use std::decay_t to strip references/const/volatile from o's type,
        // so we can match the actual stored variant type in std::is_same_v.
        using T = std::decay_t<decltype(o)>;
        if constexpr (std::is_same_v<T, PlaneConstraint>)
          {
            // If planes are identical, return one of them
            if (*this == o)
              return *this;
 
            if (this->is_parallel(o))
              // Planes are parallel and do not intersect
              return InvalidConstraint();
 
            // Solve for a point on the intersection line of two planes.
            // Given planes:
            //   Plane 1: n1 · (x - p1) = 0
            //   Plane 2: n2 · (x - p2) = 0
            // The line of intersection has direction dir = n1 × n2.
            // To find a point on this line, we assume:
            //   x = p1 + s·n1 = p2 + t·n2
            //   ⇒ p1 - p2 = t·n2 - s·n1
            // Taking dot products with n1 and n2 leads to:
            //   [-n1·n1   n1·n2] [s] = [n1 · (p1 - p2)]
            //   [-n1·n2   n2·n2] [t]   [n2 · (p1 - p2)]
 
            const Point dir = this->_normal.cross(o.normal()); // direction of line of intersection
            libmesh_assert(dir.norm() > _tol);
            const Point w = _point - o.point();
 
            // Dot product terms used in 2x2 system
            const Real n1_dot_n1 = _normal * _normal;
            const Real n1_dot_n2 = _normal * o.normal();
            const Real n2_dot_n2 = o.normal() * o.normal();
            const Real n1_dot_w = _normal * w;
            const Real n2_dot_w = o.normal() * w;
 
            const Real denom = -(n1_dot_n1 * n2_dot_n2 - n1_dot_n2 * n1_dot_n2);
            libmesh_assert(std::abs(denom) > _tol);
 
            const Real s = -(n1_dot_n2 * n2_dot_w - n2_dot_n2 * n1_dot_w) / denom;
            const Point p0 = _point + s * _normal;
 
            return LineConstraint{p0, dir};
          }
 
        else if constexpr (std::is_same_v<T, LineConstraint>)
          {
            if (this->contains_line(o))
              return o;
 
            if (this->is_parallel(o))
              // Line is parallel and does not intersect the plane
              return InvalidConstraint();
 
            // Solve for t in the parametric equation:
            //   p(t) = point + t·d
            // such that this point also satisfies the plane equation:
            //   n · (p(t) - p0) = 0
            // which leads to:
            //   t = (n · (p0 - point)) / (n · d)
 
            const Real denom = _normal * o.direction();
            libmesh_assert(std::abs(denom) > _tol);
            const Real t = (_normal * (_point - o.point())) / denom;
            return PointConstraint{o.point() + t * o.direction()};
          }
 
        else if constexpr (std::is_same_v<T, PointConstraint>)
          {
            if (!this->contains_point(o))
              // Point is not on the plane
              return InvalidConstraint();
 
            return o;
          }
 
        else
          libmesh_error_msg("Unsupported constraint type in Plane::intersect.");
      },
      other);
}

References _normal, _point, _tol, contains_line(), contains_point(), libMesh::TypeVector< T >::cross(), is_parallel(), libMesh::libmesh_assert(), libMesh::TypeVector< T >::norm(), libMesh::PointConstraint::point(), and libMesh::Real.

is_parallel() [1/2]

bool libMesh::PlaneConstraint::is_parallel

(

const LineConstraint &

l

)

const

Query whether a line is parallel to this plane.

Parameters

l	The line in question

Returns

bool indicating whether l is parallel to this plane.

Definition at line 208 of file variational_smoother_constraint.C.

{ return l.is_parallel(*this); }

References libMesh::LineConstraint::is_parallel().

is_parallel() [2/2]

bool libMesh::PlaneConstraint::is_parallel

(

const PlaneConstraint &

p

)

const

Query whether a plane is parallel to this plane.

Parameters

p	The plane in question

Returns

bool indicating whether p is parallel to this plane.

Definition at line 203 of file variational_smoother_constraint.C.

{
  return _normal.absolute_fuzzy_equals(p.normal(), _tol);
}

References _normal, _tol, libMesh::TypeVector< T >::absolute_fuzzy_equals(), and normal().

Referenced by intersect().

normal()

const Point & libMesh::PlaneConstraint::normal ( ) const

inline

Const getter for the _normal attribute.

Definition at line 301 of file variational_smoother_constraint.h.

{ return _normal; }

References _normal.

Referenced by libMesh::LineConstraint::is_parallel(), is_parallel(), operator<(), and operator==().

operator<()

bool libMesh::PlaneConstraint::operator<

(

const PlaneConstraint &

other

)

const

Comparison operator for ordering PlaneConstraint objects.

The comparison is primarily based on the normal vector. If the normal vectors are equal (within tolerance), the tie is broken using the dot product of the normal with the point on the plane.

Parameters

other

The PlaneConstraint to compare with.

Returns

True if this PlaneConstraint is less than the other.

Definition at line 186 of file variational_smoother_constraint.C.

{
  if (*this == other)
    return false;
 
  if (!(_normal.absolute_fuzzy_equals(other.normal(), _tol)))
    return _normal < other.normal();
  return (_normal * _point) < (other.normal() * other.point());
}

References _normal, _point, _tol, libMesh::TypeVector< T >::absolute_fuzzy_equals(), normal(), and point().

operator==()

bool libMesh::PlaneConstraint::operator==

(

const PlaneConstraint &

other

)

const

Equality operator.

Parameters

other

The PlaneConstraint to compare with.

Returns

True if both PlaneConstraints represent the same plane.

Definition at line 196 of file variational_smoother_constraint.C.

{
  if (!(_normal.absolute_fuzzy_equals(other.normal(), _tol)))
    return false;
  return this->contains_point(other.point());
}

References _normal, _tol, libMesh::TypeVector< T >::absolute_fuzzy_equals(), contains_point(), normal(), and point().

point()

const Point & libMesh::PlaneConstraint::point ( ) const

inline

Const getter for the _point attribute.

Definition at line 296 of file variational_smoother_constraint.h.

{ return _point; }

References _point.

Referenced by operator<(), and operator==().

tol()

const Real & libMesh::PlaneConstraint::tol ( ) const

inline

Const getter for the _tol attribute.

Definition at line 306 of file variational_smoother_constraint.h.

{ return _tol; }

References _tol.

Member Data Documentation

_normal

Point libMesh::PlaneConstraint::_normal

private

The direction normal to the constraining plane.

Definition at line 318 of file variational_smoother_constraint.h.

Referenced by contains_line(), contains_point(), intersect(), is_parallel(), normal(), operator<(), operator==(), and PlaneConstraint().

_point

Point libMesh::PlaneConstraint::_point

private

A point on the constraining plane.

Definition at line 313 of file variational_smoother_constraint.h.

Referenced by contains_point(), intersect(), operator<(), and point().

_tol

Real libMesh::PlaneConstraint::_tol

private

Tolerance to use for numerical comparisons.

Definition at line 323 of file variational_smoother_constraint.h.

Referenced by contains_line(), contains_point(), intersect(), is_parallel(), operator<(), operator==(), PlaneConstraint(), and tol().

---

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

• include/systems/variational_smoother_constraint.h
• src/systems/variational_smoother_constraint.C