libMesh::LineConstraint Class Reference

Represents a line constraint defined by a base point and direction vector. More...

#include <variational_smoother_constraint.h>

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

Private Attributes
Point	_point
	A point on the constraining line.
Point	_direction
	Direction of the constraining line.
Real	_tol
	Tolerance to use for numerical comparisons.

Detailed Description

Represents a line constraint defined by a base point and direction vector.

Definition at line 123 of file variational_smoother_constraint.h.

Constructor & Destructor Documentation

LineConstraint() [1/2]

libMesh::LineConstraint::LineConstraint ( )

default

LineConstraint() [2/2]

libMesh::LineConstraint::LineConstraint	(	const Point &	point,
		const Point &	direction,
		const Real &	tol = TOLERANCE * TOLERANCE
	)

Constructor.

Parameters

point	A point on the constraining line.
direction	the direction of the constraining line.
tol	The tolerance to use for numerical comparisons.

Definition at line 79 of file variational_smoother_constraint.C.

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

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

Member Function Documentation

contains_point()

bool libMesh::LineConstraint::contains_point

(

const PointConstraint &

p

)

const

Query whether a point lies on the line.

Parameters

p	The point in question

Returns

bool indicating whether p lies on the line.

Definition at line 103 of file variational_smoother_constraint.C.

{
  // If the point lies on the line, then the vector p - point is parallel to the
  // line In that case, the cross product of p - point with the line's direction
  // will be zero.
  return _direction.cross(p.point() - _point).norm() < _tol;
}

References _direction, _point, _tol, libMesh::TypeVector< T >::cross(), and libMesh::PointConstraint::point().

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

direction()

const Point & libMesh::LineConstraint::direction ( ) const

inline

Const getter for the _direction attribute.

Definition at line 194 of file variational_smoother_constraint.h.

{ return _direction; }

References _direction.

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

intersect()

ConstraintVariant libMesh::LineConstraint::intersect

(

const ConstraintVariant &

other

)

const

Computes the intersection of this line with another constraint.

Handles intersection with LineConstraint, PlaneConstraint, 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 121 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, LineConstraint>)
          {
            if (*this == o)
              return *this;
 
            if (this->is_parallel(o))
              // Lines are parallel and do not intersect
              return InvalidConstraint();
 
            // Solve for t in the equation p1 + t·d1 = p2 + s·d2
            // The shortest vector between skew lines lies along the normal vector
            // (d1 × d2). Projecting the vector (p2 - p1) onto this normal gives a
            // scalar proportional to the distance. This is equivalent to solving:
            //   ((p2 - p1) × d2) · (d1 × d2) = t · |d1 × d2|²
            //   ⇒ t = ((delta × d2) · (d1 × d2)) / |d1 × d2|²
 
            const Point delta = o.point() - _point;
            const Point cross_d1_d2 = _direction.cross(o.direction());
            const Real cross_dot = (delta.cross(o.direction())) * cross_d1_d2;
            const Real denom = cross_d1_d2.norm_sq();
 
            const Real t = cross_dot / denom;
            const Point intersection = _point + t * _direction;
 
            // Verify that intersection lies on both lines
            if (o.direction().cross(intersection - o.point()).norm() > _tol)
              // Lines do not intersect at a single point
              return InvalidConstraint();
 
            return PointConstraint{intersection};
          }
 
        else if constexpr (std::is_same_v<T, PlaneConstraint>)
          return o.intersect(*this);
 
        else if constexpr (std::is_same_v<T, PointConstraint>)
          {
            if (!this->contains_point(o))
              // Point is not on the line
              return InvalidConstraint();
 
            return o;
          }
 
        else
          libmesh_error_msg("Unsupported constraint type in Line::intersect.");
      },
      other);
}

References _direction, _point, _tol, contains_point(), libMesh::TypeVector< T >::cross(), is_parallel(), libMesh::TypeVector< T >::norm_sq(), and libMesh::Real.

is_parallel() [1/2]

bool libMesh::LineConstraint::is_parallel

(

const LineConstraint &

l

)

const

Query whether a line is parallel to this line.

Parameters

l	The line in question

Returns

bool indicating whether l is parallel to this line.

Definition at line 111 of file variational_smoother_constraint.C.

{
  return _direction.absolute_fuzzy_equals(l.direction(), _tol);
}

References _direction, _tol, libMesh::TypeVector< T >::absolute_fuzzy_equals(), and direction().

Referenced by intersect(), and libMesh::PlaneConstraint::is_parallel().

is_parallel() [2/2]

bool libMesh::LineConstraint::is_parallel

(

const PlaneConstraint &

p

)

const

Query whether a plane is parallel to this line.

Parameters

p	The plane in question

Returns

bool indicating whether p is parallel to this line.

Definition at line 116 of file variational_smoother_constraint.C.

{
  return _direction * p.normal() < _tol;
}

References _direction, _tol, and libMesh::PlaneConstraint::normal().

operator<()

bool libMesh::LineConstraint::operator<

(

const LineConstraint &

other

)

const

Comparison operator for ordering LineConstraint objects.

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

Parameters

other

The LineConstraint to compare with.

Returns

True if this LineConstraint is less than the other.

Definition at line 86 of file variational_smoother_constraint.C.

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

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

operator==()

bool libMesh::LineConstraint::operator==

(

const LineConstraint &

other

)

const

Equality operator.

Parameters

other

The LineConstraint to compare with.

Returns

True if both LineConstraints represent the same line.

Definition at line 96 of file variational_smoother_constraint.C.

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

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

point()

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

inline

Const getter for the _point attribute.

Definition at line 189 of file variational_smoother_constraint.h.

{ return _point; }

References _point.

Referenced by libMesh::PlaneConstraint::contains_line(), operator<(), and operator==().

tol()

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

inline

Const getter for the _tol attribute.

Definition at line 199 of file variational_smoother_constraint.h.

{ return _tol; }

References _tol.

Member Data Documentation

_direction

Point libMesh::LineConstraint::_direction

private

Direction of the constraining line.

Definition at line 211 of file variational_smoother_constraint.h.

Referenced by contains_point(), direction(), intersect(), is_parallel(), is_parallel(), LineConstraint(), operator<(), and operator==().

_point

Point libMesh::LineConstraint::_point

private

A point on the constraining line.

Definition at line 206 of file variational_smoother_constraint.h.

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

_tol

Real libMesh::LineConstraint::_tol

private

Tolerance to use for numerical comparisons.

Definition at line 216 of file variational_smoother_constraint.h.

Referenced by contains_point(), intersect(), is_parallel(), is_parallel(), LineConstraint(), operator<(), operator==(), 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