Creating ansys.geometry.core.misc.units submodule

src/ansys/geometry/core/__init__.py

@@ -14,18 +14,3 @@
 
 __version__ = importlib_metadata.version(__name__.replace(".", "-"))
 """The installed version of PyGeometry."""
-
-
-# Units
-# ------------------------------------------------------------------------------
-
-from pint import UnitRegistry
-
-UNITS = UnitRegistry()
-"""Unit manager."""
-
-UNIT_LENGTH = UNITS.meter
-"""Default length unit for PyGeometry."""
-
-UNIT_ANGLE = UNITS.radian
-"""Default angle unit for PyGeometry."""

src/ansys/geometry/core/math/__init__.py

@@ -1,41 +1,32 @@
 """PyGeometry math subpackage."""
+import numpy as np
+
+from ansys.geometry.core.math.constants import (
+    DEFAULT_POINT,
+    UNIT_VECTOR_X,
+    UNIT_VECTOR_Y,
+    UNIT_VECTOR_Z,
+    ZERO_VECTOR3D,
+)
 from ansys.geometry.core.math.frame import Frame
 from ansys.geometry.core.math.matrix import Matrix, Matrix33, Matrix44
 from ansys.geometry.core.math.plane import Plane
-from ansys.geometry.core.math.point import Point2D, Point3D
-from ansys.geometry.core.math.vector import (
-    QuantityVector2D,
-    QuantityVector3D,
-    UnitVector2D,
-    UnitVector3D,
-    Vector2D,
-    Vector3D,
-)
+from ansys.geometry.core.math.point import Point
+from ansys.geometry.core.math.vector import QuantityVector, UnitVector, Vector
 
 __all__ = [
+    "DEFAULT_POINT",
+    "UNIT_VECTOR_X",
+    "UNIT_VECTOR_Y",
+    "UNIT_VECTOR_Z",
+    "ZERO_VECTOR3D",
     "Frame",
     "Matrix",
     "Matrix33",
     "Matrix44",
     "Plane",
-    "Point2D",
-    "Point3D",
-    "QuantityVector2D",
-    "QuantityVector3D",
-    "UnitVector2D",
-    "UnitVector3D",
-    "Vector2D",
-    "Vector3D",
+    "Point",
+    "QuantityVector",
+    "UnitVector",
+    "Vector",
 ]
-
-UNIT_VECTOR_X = UnitVector3D([1, 0, 0])
-"""Unit vector in the cartesian traditional X direction."""
-
-UNIT_VECTOR_Y = UnitVector3D([0, 1, 0])
-"""Unit vector in the cartesian traditional Y direction."""
-
-UNIT_VECTOR_Z = UnitVector3D([0, 0, 1])
-"""Unit vector in the cartesian traditional Z direction."""
-
-ZERO_VECTOR3D = Vector3D([0, 0, 0])
-"""Zero-valued Vector3D object."""

src/ansys/geometry/core/math/constants.py

@@ -0,0 +1,26 @@
+"""Mathematical constants for PyGeometry."""
+
+from ansys.geometry.core.math.point import DEFAULT_POINT_VALUES, Point
+from ansys.geometry.core.math.vector import UnitVector, Vector
+
+DEFAULT_POINT = Point(DEFAULT_POINT_VALUES)
+"""Default value for a 3D ``Point``."""
+
+UNIT_VECTOR_X = UnitVector([1, 0, 0])
+"""Unit vector in the cartesian traditional X direction."""
+
+UNIT_VECTOR_Y = UnitVector([0, 1, 0])
+"""Unit vector in the cartesian traditional Y direction."""
+
+UNIT_VECTOR_Z = UnitVector([0, 0, 1])
+"""Unit vector in the cartesian traditional Z direction."""
+
+ZERO_VECTOR3D = Vector([0, 0, 0])
+"""Zero-valued Vector object."""
+
+# Define the numpy.ndarrays as read-only - just for the sake of being "safe"
+DEFAULT_POINT.setflags(write=False)
+UNIT_VECTOR_X.setflags(write=False)
+UNIT_VECTOR_Y.setflags(write=False)
+UNIT_VECTOR_Z.setflags(write=False)
+ZERO_VECTOR3D.setflags(write=False)

src/ansys/geometry/core/math/frame.py

@@ -4,8 +4,8 @@
 
 import numpy as np
 
-from ansys.geometry.core.math.point import Point3D
-from ansys.geometry.core.math.vector import UnitVector3D, Vector3D
+from ansys.geometry.core.math.point import Point
+from ansys.geometry.core.math.vector import UnitVector, Vector
 from ansys.geometry.core.misc.checks import check_type, check_type_equivalence
 from ansys.geometry.core.typing import RealSequence
 
@@ -16,32 +16,32 @@ class Frame:
 
     Parameters
     ----------
-    origin : Optional[Union[~numpy.ndarray, RealSequence, Point3D]]
+    origin : Optional[Union[~numpy.ndarray, RealSequence, Point]]
         Centered origin of the ``Frame``. By default, cartesian origin.
-    direction_x: Optional[Union[~numpy.ndarray, RealSequence, UnitVector3D, Vector3D]]
+    direction_x: Optional[Union[~numpy.ndarray, RealSequence, UnitVector, Vector]]
         X-axis direction. By default, ``UNIT_VECTOR_X``
-    direction_y: Optional[Union[~numpy.ndarray, RealSequence, UnitVector3D, Vector3D]]
+    direction_y: Optional[Union[~numpy.ndarray, RealSequence, UnitVector, Vector]]
         Y-axis direction. By default, ``UNIT_VECTOR_Y``
     """
 
     def __init__(
         self,
-        origin: Union[np.ndarray, RealSequence, Point3D] = [0, 0, 0],
-        direction_x: Union[np.ndarray, RealSequence, UnitVector3D, Vector3D] = [1, 0, 0],
-        direction_y: Union[np.ndarray, RealSequence, UnitVector3D, Vector3D] = [0, 1, 0],
+        origin: Union[np.ndarray, RealSequence, Point] = [0, 0, 0],
+        direction_x: Union[np.ndarray, RealSequence, UnitVector, Vector] = [1, 0, 0],
+        direction_y: Union[np.ndarray, RealSequence, UnitVector, Vector] = [0, 1, 0],
     ):
         """Constructor method for ``Frame``."""
 
-        check_type(origin, (np.ndarray, List, Point3D))
-        check_type(direction_x, (np.ndarray, List, UnitVector3D, Vector3D))
-        check_type(direction_y, (np.ndarray, List, UnitVector3D, Vector3D))
+        check_type(origin, (np.ndarray, List, Point))
+        check_type(direction_x, (np.ndarray, List, UnitVector, Vector))
+        check_type(direction_y, (np.ndarray, List, UnitVector, Vector))
 
-        self._origin = Point3D(origin) if not isinstance(origin, Point3D) else origin
+        self._origin = Point(origin) if not isinstance(origin, Point) else origin
         self._direction_x = (
-            UnitVector3D(direction_x) if not isinstance(direction_x, UnitVector3D) else direction_x
+            UnitVector(direction_x) if not isinstance(direction_x, UnitVector) else direction_x
         )
         self._direction_y = (
-            UnitVector3D(direction_y) if not isinstance(direction_y, UnitVector3D) else direction_y
+            UnitVector(direction_y) if not isinstance(direction_y, UnitVector) else direction_y
         )
 
         # origin is fixed once the frame is built
@@ -50,25 +50,25 @@ def __init__(
         if not self._direction_x.is_perpendicular_to(self._direction_y):
             raise ValueError("Direction x and direction y must be perpendicular")
 
-        self._direction_z = UnitVector3D(self._direction_x % self._direction_y)
+        self._direction_z = UnitVector(self._direction_x % self._direction_y)
 
     @property
-    def origin(self) -> Point3D:
+    def origin(self) -> Point:
         """Return the origin of the ``Frame``."""
         return self._origin
 
     @property
-    def direction_x(self) -> UnitVector3D:
+    def direction_x(self) -> UnitVector:
         """Return the X-axis direction of the ``Frame``."""
         return self._direction_x
 
     @property
-    def direction_y(self) -> UnitVector3D:
+    def direction_y(self) -> UnitVector:
         """Return the Y-axis direction of the ``Frame``."""
         return self._direction_y
 
     @property
-    def direction_z(self) -> UnitVector3D:
+    def direction_z(self) -> UnitVector:
         """Return the Z-axis direction of the ``Frame``."""
         return self._direction_z
 

src/ansys/geometry/core/math/plane.py

@@ -5,8 +5,8 @@
 import numpy as np
 
 from ansys.geometry.core.math.frame import Frame
-from ansys.geometry.core.math.point import Point3D
-from ansys.geometry.core.math.vector import UnitVector3D, Vector3D
+from ansys.geometry.core.math.point import Point
+from ansys.geometry.core.math.vector import UnitVector, Vector
 from ansys.geometry.core.typing import RealSequence
 
 
@@ -16,19 +16,19 @@ class Plane(Frame):
 
     Parameters
     ----------
-    origin : Optional[Union[~numpy.ndarray, RealSequence, Point3D]]
+    origin : Optional[Union[~numpy.ndarray, RealSequence, Point]]
         Centered origin of the ``Frame``. By default, cartesian origin.
-    direction_x: Optional[Union[~numpy.ndarray, RealSequence, UnitVector3D, Vector3D]]
+    direction_x: Optional[Union[~numpy.ndarray, RealSequence, UnitVector, Vector]]
         X-axis direction. By default, ``UNIT_VECTOR_X``
-    direction_y: Optional[Union[~numpy.ndarray, RealSequence, UnitVector3D, Vector3D]]
+    direction_y: Optional[Union[~numpy.ndarray, RealSequence, UnitVector, Vector]]
         Y-axis direction. By default, ``UNIT_VECTOR_Y``
     """
 
     def __init__(
         self,
-        origin: Union[np.ndarray, RealSequence, Point3D] = [0, 0, 0],
-        direction_x: Union[np.ndarray, RealSequence, UnitVector3D, Vector3D] = [1, 0, 0],
-        direction_y: Union[np.ndarray, RealSequence, UnitVector3D, Vector3D] = [0, 1, 0],
+        origin: Union[np.ndarray, RealSequence, Point] = [0, 0, 0],
+        direction_x: Union[np.ndarray, RealSequence, UnitVector, Vector] = [1, 0, 0],
+        direction_y: Union[np.ndarray, RealSequence, UnitVector, Vector] = [0, 1, 0],
     ):
         """Constructor method for ``Plane``."""
         super().__init__(origin, direction_x, direction_y)