CSGPlane creates an internal representation of a Constructive Solid Geometry (CSG) plane, represented in the form aX + bY + cZ = d. More...

#include <CSGPlane.h>

Inheritance diagram for CSG::CSGPlane:

[legend]

Public Types
enum	Halfspace { Halfspace::POSITIVE, Halfspace::NEGATIVE }
	Enum for the sign of the half-space being represented by a point and surface. More...

Public Member Functions
	CSGPlane (const std::string &name, const Point &p1, const Point &p2, const Point &p3)
	Construct a new CSGPlane surface from three non co-linear points. More...

	CSGPlane (const std::string &name, const Real a, const Real b, const Real c, const Real d)
	Construct a new CSGPlane surface from coefficients (a, b, c, d) for the equation of a plane: aX + bY + cZ = d. More...

virtual	~CSGPlane ()=default
	Destructor. More...

virtual std::unordered_map< std::string, Real >	getCoeffs () const override
	get coefficients (a, b, c, d) of the Plane aX + bY + cZ = d More...

virtual Real	evaluateSurfaceEquationAtPoint (const Point &p) const override
	given a point, determine its evaluation based on the equation of the plane More...

const std::string &	getSurfaceType () const
	Get the Surface Type. More...

CSGSurface::Halfspace	getHalfspaceFromPoint (const Point &p) const
	given a point, determine if it is in the positive or negative half-space for the surface More...

const std::string &	getName () const
	Get the name of surface. More...

bool	operator== (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are equal. More...

bool	operator!= (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are not equal. More...

const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const
	Get the list of transformations. More...

std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const
	Get the transformations of this object with string representations for types. More...

Static Public Member Functions
static bool	isValidTransformationValue (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Check if the transformation value is valid for the given type. More...

static std::string	getTransformationTypeString (TransformationType type)
	Get the string representation of the transformation type. More...

Protected Member Functions
virtual std::unique_ptr< CSGSurface >	clone () const override
	create clone of CSGPlane object More...

void	coeffsFromPoints (const Point &p1, const Point &p2, const Point &p3)

void	normalizePlaneCoefficients ()
	Normalize plane coefficients so that a^2 + b^2 + c^2 = 1. More...

void	setName (const std::string &name)

void	addTransformation (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Add a transformation to the list of transformations. More...

Point	applyReverseTransformsToPoint (Point p) const
	update the value of point p by applying the inverse of the list of transformations to the point More...


	FRIEND_TEST (CSGSurfaceTest, testSetName)
	Friends for unit testing. More...

	FRIEND_TEST (CSGSurfaceTest, testSurfaceEquality)


	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing. More...

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

Protected Attributes
Real	_a
	Value of a in equation of plane. More...

Real	_b
	Value of b in equation of plane. More...

Real	_c
	Value of c in equation of plane. More...

Real	_d
	Value of d in equation of plane. More...

std::string	_name
	Name of surface. More...

const std::string	_surface_type
	Type of surface that is being represented string is taken directly from the surface class name. More...

std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object. More...

Detailed Description

CSGPlane creates an internal representation of a Constructive Solid Geometry (CSG) plane, represented in the form aX + bY + cZ = d.

Definition at line 23 of file CSGPlane.h.

Member Enumeration Documentation

◆ Halfspace

enum CSG::CSGSurface::Halfspace

stronginherited

Enum for the sign of the half-space being represented by a point and surface.

Enumerator
POSITIVE
NEGATIVE

Definition at line 30 of file CSGSurface.h.

   {
     POSITIVE,
     NEGATIVE
   };

Constructor & Destructor Documentation

◆ CSGPlane() [1/2]

CSG::CSGPlane::CSGPlane	(	const std::string &	name,
		const Point &	p1,
		const Point &	p2,
		const Point &	p3
	)

Construct a new CSGPlane surface from three non co-linear points.

Parameters

name	unique name of plane
p1	point 1
p2	point 2
p3	point 3

Definition at line 15 of file CSGPlane.C.

   : CSGSurface(name, MooseUtils::prettyCppType<CSGPlane>())
 {
   coeffsFromPoints(p1, p2, p3);
   normalizePlaneCoefficients();
 }

◆ CSGPlane() [2/2]

CSG::CSGPlane::CSGPlane	(	const std::string &	name,
		const Real	a,
		const Real	b,
		const Real	c,
		const Real	d
	)

Construct a new CSGPlane surface from coefficients (a, b, c, d) for the equation of a plane: aX + bY + cZ = d.

Parameters

name	unique name of plane
a	coefficient a
b	coefficient b
c	coefficient c
d	coefficient d

Definition at line 22 of file CSGPlane.C.

   : CSGSurface(name, MooseUtils::prettyCppType<CSGPlane>()), _a(a), _b(b), _c(c), _d(d)
 {
   normalizePlaneCoefficients();
 }

◆ ~CSGPlane()

virtual CSG::CSGPlane::~CSGPlane ( )

virtualdefault

Destructor.

Member Function Documentation

◆ addTransformation()

void CSG::CSGTransformationHelper::addTransformation	(	TransformationType	type,
		const std::tuple< Real, Real, Real > &	values
	)

protectedinherited

Add a transformation to the list of transformations.

Parameters

type	The type of transformation
values	The values for the transformation

Definition at line 16 of file CSGTransformationHelper.C.

 {
   if (!isValidTransformationValue(type, values))
     mooseError("Invalid transformation values provided for transformation type " +
                getTransformationTypeString(type));
   _transformations.emplace_back(type, values);
 }

◆ applyReverseTransformsToPoint()

Point CSG::CSGTransformationHelper::applyReverseTransformsToPoint ( Point p ) const

protectedinherited

update the value of point p by applying the inverse of the list of transformations to the point

Parameters

p	point to transform

Returns: transformed point

Definition at line 74 of file CSGTransformationHelper.C.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint().

 {
   // iterate list of transformations in reverse and apply the inverse operation
   for (auto it = _transformations.rbegin(); it != _transformations.rend(); ++it)
   {
     auto trans_type = it->first;
     auto val = it->second;
 
     if (trans_type == TransformationType::TRANSLATION)
     {
       Point offset(std::get<0>(val), std::get<1>(val), std::get<2>(val));
       p -= offset;
     }
     else if (trans_type == TransformationType::SCALE)
     {
       Point scale(std::get<0>(val), std::get<1>(val), std::get<2>(val));
       for (int i = 0; i < 3; ++i)
         p(i) /= scale(i);
     }
     else if (trans_type == TransformationType::ROTATION)
     {
       // get the transpose of the original rotation matrix and apply to point p
       const auto rot_matrix = RealTensorValue::intrinsic_rotation_matrix(
           std::get<0>(val), std::get<1>(val), std::get<2>(val));
       const auto rot_transpose = rot_matrix.transpose();
       p = rot_transpose * p;
     }
     else
       mooseError("Transformation type is not recognized.");
   }
   return p;
 }

◆ clone()

virtual std::unique_ptr<CSGSurface> CSG::CSGPlane::clone ( ) const

inlineoverrideprotectedvirtual

create clone of CSGPlane object

Returns: std::unordered_map<CSGSurface> unique_ptr to cloned plane

Implements CSG::CSGSurface.

Definition at line 75 of file CSGPlane.h.

   {
     return std::make_unique<CSGPlane>(_name, _a, _b, _c, _d);
   }

◆ coeffsFromPoints()

void CSG::CSGPlane::coeffsFromPoints	(	const Point &	p1,
		const Point &	p2,
		const Point &	p3
	)

protected

Definition at line 36 of file CSGPlane.C.

Referenced by CSGPlane().

 {
   // Use three points on plane to solve for the plane equation in form aX + bY +cZ = d,
   // where we are solving for a, b, c, and d.
   RealVectorValue v1 = p2 - p1;
   RealVectorValue v2 = p3 - p1;
   RealVectorValue cross = v2.cross(v1);
 
   // Check that provided points aren't collinear
   if (MooseUtils::absoluteFuzzyEqual(cross.norm(), 0))
     mooseError("Provided points to define a CSGPlane are collinear");
 
   _a = cross(0);
   _b = cross(1);
   _c = cross(2);
   _d = cross * (RealVectorValue)p1;
 }

◆ evaluateSurfaceEquationAtPoint()

Real CSG::CSGPlane::evaluateSurfaceEquationAtPoint ( const Point & p ) const

overridevirtual

given a point, determine its evaluation based on the equation of the plane

Parameters

p point

Returns: evaluation of point based on surface equation

Implements CSG::CSGSurface.

Definition at line 65 of file CSGPlane.C.

 {
   // Compute dot product of <a, b, c> and p to determine if p lies
   // in the positive or negative halfspace of the plane
   const Real dot_prod = _a * p(0) + _b * p(1) + _c * p(2);
 
   return dot_prod - _d;
 }

◆ FRIEND_TEST() [1/4]

CSG::CSGTransformationHelper::FRIEND_TEST	(	CSGSurfaceTest	,
		testHalfspaceWithTransform
	)

protectedinherited

Friends for unit testing.

◆ FRIEND_TEST() [2/4]

CSG::CSGTransformationHelper::FRIEND_TEST	(	CSGSurfaceTest	,
		testHalfspaceWithNullTransform
	)

protectedinherited

◆ FRIEND_TEST() [3/4]

CSG::CSGSurface::FRIEND_TEST	(	CSGSurfaceTest	,
		testSetName
	)

protectedinherited

Friends for unit testing.

◆ FRIEND_TEST() [4/4]

CSG::CSGSurface::FRIEND_TEST	(	CSGSurfaceTest	,
		testSurfaceEquality
	)

protectedinherited

◆ getCoeffs()

std::unordered_map< std::string, Real > CSG::CSGPlane::getCoeffs ( ) const

overridevirtual

get coefficients (a, b, c, d) of the Plane aX + bY + cZ = d

Returns: std::unordered_map<std::string, Real> map of coefficients (a, b, c, and d) and their values

Implements CSG::CSGSurface.

Definition at line 29 of file CSGPlane.C.

 {
   std::unordered_map<std::string, Real> coeffs = {{"a", _a}, {"b", _b}, {"c", _c}, {"d", _d}};
   return coeffs;
 }

◆ getHalfspaceFromPoint()

CSGSurface::Halfspace CSG::CSGSurface::getHalfspaceFromPoint ( const Point & p ) const

inherited

given a point, determine if it is in the positive or negative half-space for the surface

Parameters

p point

Returns: sign of the half-space

Definition at line 23 of file CSGSurface.C.

 {
   // if transformations are present on the surface, apply them in reverse to the point and pass that
   // new point to the evaluation to ensure transformations are considered.
 
   // Create a local transformed copy - the original p in the calling scope is NOT modified
   const Point p_trans = getTransformations().size() ? applyReverseTransformsToPoint(p) : p;
 
   auto eval = evaluateSurfaceEquationAtPoint(p_trans);
   if (MooseUtils::absoluteFuzzyGreaterThan(eval, 0))
     return Halfspace::POSITIVE;
   else if (MooseUtils::absoluteFuzzyLessThan(eval, 0))
     return Halfspace::NEGATIVE;
   else
     mooseError("Point ",
                p,
                " used to determine halfspace evaluation lies on the surface ",
                _name,
                ", leading to an ambiguously defined halfspace.");
 }

◆ getName()

const std::string& CSG::CSGSurface::getName ( ) const

inlineinherited

Get the name of surface.

Returns: std::string name of surface

Definition at line 95 of file CSGSurface.h.

Referenced by CSG::CSGSurfaceList::addSurface(), CSG::CSGBase::addTransformation(), CSG::CSGBase::checkSurfaceInBase(), CSG::CSGBase::deleteSurface(), CSG::CSGSurface::operator==(), and CSG::CSGSurfaceList::renameSurface().

95 { return _name; }

CSG::CSGSurface::_name

std::string _name

Name of surface.

Definition: CSGSurface.h:116

◆ getSurfaceType()

const std::string& CSG::CSGSurface::getSurfaceType ( ) const

inlineinherited

Get the Surface Type.

Returns: type of surface

Definition at line 61 of file CSGSurface.h.

Referenced by CSG::CSGSurface::operator==().

61 { return _surface_type; }

CSG::CSGSurface::_surface_type

const std::string _surface_type

Type of surface that is being represented string is taken directly from the surface class name...

Definition: CSGSurface.h:120

◆ getTransformations()

const std::vector<std::pair<TransformationType, std::tuple<Real, Real, Real> > >& CSG::CSGTransformationHelper::getTransformations ( ) const

inlineinherited

Get the list of transformations.

Returns: The list of transformations

Definition at line 47 of file CSGTransformationHelper.h.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGUniverse::operator==(), CSG::CSGSurface::operator==(), CSG::CSGCell::operator==(), and CSG::CSGLattice::operator==().

   {
     return _transformations;
   }

◆ getTransformationsAsStrings()

std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > > CSG::CSGTransformationHelper::getTransformationsAsStrings ( ) const

inherited

Get the transformations of this object with string representations for types.

Returns: Vector of transformation pairs with string representations for types

Definition at line 65 of file CSGTransformationHelper.C.

 {
   std::vector<std::pair<std::string, std::tuple<Real, Real, Real>>> result;
   for (const auto & transform_pair : _transformations)
     result.emplace_back(getTransformationTypeString(transform_pair.first), transform_pair.second);
   return result;
 }

◆ getTransformationTypeString()

std::string CSG::CSGTransformationHelper::getTransformationTypeString ( TransformationType type )

staticinherited

Get the string representation of the transformation type.

Parameters

type	The transformation type

Returns: String name of the transformation type

Definition at line 56 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation(), and CSG::CSGTransformationHelper::getTransformationsAsStrings().

 {
   // Set the enum to the value and convert it to string
   MooseEnum enum_copy = transformation_type_enum;
   enum_copy = static_cast<int>(type);
   return std::string(enum_copy);
 }

◆ isValidTransformationValue()

bool CSG::CSGTransformationHelper::isValidTransformationValue	(	TransformationType	type,
		const std::tuple< Real, Real, Real > &	values
	)

staticinherited

Check if the transformation value is valid for the given type.

Parameters

type	The type of transformation
values	The values for the transformation

Returns: True if the values are valid for the type

Definition at line 26 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation().

 {
   // Additional validation specific to each transformation type could be added here
   switch (type)
   {
     case TransformationType::TRANSLATION:
       // All translation values are inherently valid
       return true;
 
     case TransformationType::ROTATION:
       // Rotation uses euler notation; values are angles in degrees (phi, theta, psi)
       // For consistency with TransformGenerator, there are no restrictions on the angles
       // phi: rotation around Z-axis
       // theta: rotation around new X-axis
       // psi: rotation around new Z-axis
       return true;
 
     case TransformationType::SCALE:
       // Scaling factors should be non-zero
       if (std::get<0>(values) == 0.0 || std::get<1>(values) == 0.0 || std::get<2>(values) == 0.0)
         return false;
       return true;
 
     default:
       mooseError("Unknown transformation type");
   }
 }

◆ normalizePlaneCoefficients()

void CSG::CSGPlane::normalizePlaneCoefficients ( )

protected

Normalize plane coefficients so that a^2 + b^2 + c^2 = 1.

Definition at line 55 of file CSGPlane.C.

Referenced by CSGPlane().

 {
   const auto k = 1. / std::sqrt(_a * _a + _b * _b + _c * _c);
   _a *= k;
   _b *= k;
   _c *= k;
   _d *= k;
 }

◆ operator!=()

bool CSG::CSGSurface::operator!= ( const CSGSurface & other ) const

inherited

Operator overload for checking if two CSGSurface objects are not equal.

Definition at line 54 of file CSGSurface.C.

 {
   return !(*this == other);
 }

◆ operator==()

bool CSG::CSGSurface::operator== ( const CSGSurface & other ) const

inherited

Operator overload for checking if two CSGSurface objects are equal.

Definition at line 45 of file CSGSurface.C.

 {
   return (this->getName() == other.getName()) &&
          (this->getSurfaceType() == other.getSurfaceType()) &&
          (this->getCoeffs() == other.getCoeffs()) &&
          (this->getTransformations() == other.getTransformations());
 }