Performance improvements based on Seattle script (#184)

Author: RobPasMue

.github/workflows/nightly_docker_test.yml

@@ -29,8 +29,10 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ env.MAIN_PYTHON_VERSION }}
-          cache: 'pip'
-          cache-dependency-path: 'pyproject.toml'
+          # TODO : This should be activated once the private dependencies are removed
+          #        pip install process installs them again even if they are on cache
+          # cache: 'pip'
+          # cache-dependency-path: 'pyproject.toml'
 
       - name: Create Python venv
         run: |

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

@@ -160,12 +160,7 @@ def transform_point2d_local_to_global(self, point: Point2D) -> Point3D:
         Point3D
             The global coordinates ``Point3D`` object.
         """
-        local_point_as_3d = Point3D(
-            [point.x.to_base_units().m, point.y.to_base_units().m, 0], point.base_unit
-        )
-        return self.origin + Point3D(
-            self.local_to_global_rotation @ local_point_as_3d, point.base_unit
-        )
+        return self.origin + Vector3D(self.local_to_global_rotation @ [point[0], point[1], 0])
 
     def __eq__(self, other: "Frame") -> bool:
         """Equals operator for ``Frame``."""

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

@@ -24,6 +24,8 @@
 if TYPE_CHECKING:  # pragma: no cover
     from ansys.geometry.core.math.vector import Vector2D, Vector3D
 
+BASE_UNIT_LENGTH = UNITS.get_base_units(UNIT_LENGTH)[1]
+
 
 class Point2D(np.ndarray, PhysicalQuantity):
     """
@@ -66,7 +68,8 @@ def __init__(
             raise ValueError("Point2D class must receive 2 arguments.")  # noqa: E501
 
         # Store values
-        self.flat = [(elem * self.unit).to_base_units().magnitude for elem in input]
+        self._quantities = [Quantity(elem, units=unit) for elem in input]
+        self.flat = [elem.to_base_units().m for elem in self._quantities]
 
     def __eq__(self, other: "Point2D") -> bool:
         """Equals operator for ``Point2D``."""
@@ -80,29 +83,36 @@ def __ne__(self, other: "Point2D") -> bool:
     def __set_value(self, input: Quantity, idx: int) -> None:
         """General setter method for ``Point2D`` class."""
         self[idx] = self._base_units_magnitude(input)
+        self._quantities[idx] = input.to(self.unit)
 
     def __add__(self, other: Union["Point2D", "Vector2D"]) -> "Point2D":
         """Add operation for ``Point2D``."""
         from ansys.geometry.core.math.vector import Vector2D
 
         check_type(other, (Point2D, Vector2D))
-        point = Point2D(np.add(self, other), self.base_unit)
-        point.unit = self.unit
+        point = np.add(self, other).view(Point2D)
+        point._unit = self.unit
+        point._base_unit = self.base_unit
+        point._quantities = [np.nan, np.nan]
         return point
 
     def __sub__(self, other: "Point2D") -> "Point2D":
         """Subtraction operation for ``Point2D``."""
         from ansys.geometry.core.math.vector import Vector2D
 
         check_type(other, (Point2D, Vector2D))
-        point = Point2D(np.subtract(self, other), self.base_unit)
-        point.unit = self.unit
+        point = np.subtract(self, other).view(Point2D)
+        point._unit = self.unit
+        point._base_unit = self.base_unit
+        point._quantities = [np.nan, np.nan]
         return point
 
     @property
     def x(self) -> Quantity:
         """Returns the X plane component value."""
-        return self._get_quantity(self[0])
+        if self._quantities[0] is np.nan:
+            self._quantities[0] = Quantity(self[0], units=self.base_unit).to(self.unit)
+        return self._quantities[0]
 
     @x.setter
     def x(self, x: Quantity) -> None:
@@ -112,7 +122,9 @@ def x(self, x: Quantity) -> None:
     @property
     def y(self) -> Quantity:
         """Returns the Y plane component value."""
-        return self._get_quantity(self[1])
+        if self._quantities[1] is np.nan:
+            self._quantities[1] = Quantity(self[1], units=self.base_unit).to(self.unit)
+        return self._quantities[1]
 
     @y.setter
     def y(self, y: Quantity) -> None:
@@ -122,20 +134,20 @@ def y(self, y: Quantity) -> None:
     @PhysicalQuantity.unit.getter
     def unit(self) -> Unit:
         """Returns the unit of the object."""
-        try:
-            return PhysicalQuantity.unit.fget(self)
-        except AttributeError:
+        if hasattr(self, "_unit"):
+            return self._unit
+        else:
             self._unit = UNIT_LENGTH
-            return self.unit
+            return self._unit
 
     @PhysicalQuantity.base_unit.getter
     def base_unit(self) -> Unit:
         """Returns the base unit of the object."""
-        try:
-            return PhysicalQuantity.base_unit.fget(self)
-        except AttributeError:
-            self._base_unit = UNITS.get_base_units(UNIT_LENGTH)[1]
-            return self.base_unit
+        if hasattr(self, "_base_unit"):
+            return self._base_unit
+        else:
+            self._base_unit = BASE_UNIT_LENGTH
+            return self._base_unit
 
 
 class Point3D(np.ndarray, PhysicalQuantity):
@@ -179,7 +191,8 @@ def __init__(
             raise ValueError("Point3D class must receive 3 arguments.")  # noqa: E501
 
         # Store values
-        self.flat = [(elem * self.unit).to_base_units().magnitude for elem in input]
+        self._quantities = [Quantity(elem, units=unit) for elem in input]
+        self.flat = [elem.to_base_units().m for elem in self._quantities]
 
     def __eq__(self, other: "Point3D") -> bool:
         """Equals operator for ``Point3D``."""
@@ -195,27 +208,34 @@ def __add__(self, other: Union["Point3D", "Vector3D"]) -> "Point3D":
         from ansys.geometry.core.math.vector import Vector3D
 
         check_type(other, (Point3D, Vector3D))
-        point = Point3D(np.add(self, other), self.base_unit)
-        point.unit = self.unit
+        point = np.add(self, other).view(Point3D)
+        point._unit = self.unit
+        point._base_unit = self.base_unit
+        point._quantities = [np.nan, np.nan, np.nan]
         return point
 
     def __sub__(self, other: Union["Point3D", "Vector3D"]) -> "Point3D":
         """Subtraction operation for ``Point3D``."""
         from ansys.geometry.core.math.vector import Vector3D
 
         check_type(other, (Point3D, Vector3D))
-        point = Point3D(np.subtract(self, other), self.base_unit)
-        point.unit = self.unit
+        point = np.subtract(self, other).view(Point3D)
+        point._unit = self.unit
+        point._base_unit = self.base_unit
+        point._quantities = [np.nan, np.nan, np.nan]
         return point
 
     def __set_value(self, input: Quantity, idx: int) -> None:
         """General setter method for ``Point3D`` class."""
         self[idx] = self._base_units_magnitude(input)
+        self._quantities[idx] = input.to(self.unit)
 
     @property
     def x(self) -> Quantity:
         """Returns the X plane component value."""
-        return self._get_quantity(self[0])
+        if self._quantities[0] is np.nan:
+            self._quantities[0] = Quantity(self[0], units=self.base_unit).to(self.unit)
+        return self._quantities[0]
 
     @x.setter
     def x(self, x: Quantity) -> None:
@@ -225,7 +245,9 @@ def x(self, x: Quantity) -> None:
     @property
     def y(self) -> Quantity:
         """Returns the Y plane component value."""
-        return self._get_quantity(self[1])
+        if self._quantities[1] is np.nan:
+            self._quantities[1] = Quantity(self[1], units=self.base_unit).to(self.unit)
+        return self._quantities[1]
 
     @y.setter
     def y(self, y: Quantity) -> None:
@@ -235,7 +257,9 @@ def y(self, y: Quantity) -> None:
     @property
     def z(self) -> Quantity:
         """Returns the Z plane component value."""
-        return self._get_quantity(self[2])
+        if self._quantities[2] is np.nan:
+            self._quantities[2] = Quantity(self[2], units=self.base_unit).to(self.unit)
+        return self._quantities[2]
 
     @z.setter
     def z(self, z: Quantity) -> None:
@@ -245,17 +269,17 @@ def z(self, z: Quantity) -> None:
     @PhysicalQuantity.unit.getter
     def unit(self) -> Unit:
         """Returns the unit of the object."""
-        try:
-            return PhysicalQuantity.unit.fget(self)
-        except AttributeError:
+        if hasattr(self, "_unit"):
+            return self._unit
+        else:
             self._unit = UNIT_LENGTH
-            return self.unit
+            return self._unit
 
     @PhysicalQuantity.base_unit.getter
     def base_unit(self) -> Unit:
         """Returns the base unit of the object."""
-        try:
-            return PhysicalQuantity.base_unit.fget(self)
-        except AttributeError:
-            self._base_unit = UNITS.get_base_units(UNIT_LENGTH)[1]
-            return self.base_unit
+        if hasattr(self, "_base_unit"):
+            return self._base_unit
+        else:
+            self._base_unit = BASE_UNIT_LENGTH
+            return self._base_unit

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

@@ -101,7 +101,7 @@ def normalize(self) -> "Vector3D":
         """Return a normalized version of the ``Vector3D``."""
         norm = self.norm
         if norm > 0:
-            return Vector3D(self / norm)
+            return (self / norm).view(Vector3D)
         else:
             raise ValueError("The norm of the Vector3D is not valid.")
 
@@ -135,7 +135,7 @@ def get_angle_between(self, v: "Vector3D") -> Quantity:
     def cross(self, v: "Vector3D") -> "Vector3D":
         """Return cross product of Vector3D objects"""
         check_type_equivalence(v, self)
-        return Vector3D(np.cross(self, v))
+        return np.cross(self, v).view(Vector3D)
 
     def __eq__(self, other: "Vector3D") -> bool:
         """Equals operator for ``Vector3D``."""
@@ -154,7 +154,7 @@ def __mul__(self, other: Union["Vector3D", Real]) -> Union["Vector3D", Real]:
         Also admits scalar multiplication.
         """
         if isinstance(other, (int, float)):
-            return Vector3D(np.multiply(self, other))
+            return np.multiply(self, other).view(Vector3D)
         else:
             check_type_equivalence(other, self)
             return self.dot(other)
@@ -179,7 +179,7 @@ def __add__(self, other: Union["Vector3D", Point3D]) -> Union["Vector3D", Point3
     def __sub__(self, other: "Vector3D") -> "Vector3D":
         """Subtraction operation overload for ``Vector3D`` objects."""
         check_type_equivalence(other, self)
-        return Vector3D(np.subtract(self, other))
+        return np.subtract(self, other).view(Vector3D)
 
     @classmethod
     def from_points(
@@ -285,7 +285,7 @@ def normalize(self) -> "Vector2D":
         """Return a normalized version of the ``Vector2D``."""
         norm = self.norm
         if norm > 0:
-            return Vector2D(self / norm)
+            return (self / norm).view(Vector2D)
         else:
             raise ValueError("The norm of the Vector2D is not valid.")
 
@@ -329,7 +329,7 @@ def __mul__(self, other: Union["Vector2D", Real]) -> Union["Vector2D", Real]:
         Also admits scalar multiplication.
         """
         if isinstance(other, (int, float)):
-            return Vector2D(np.multiply(self, other))
+            return np.multiply(self, other).view(Vector2D)
         else:
             check_type_equivalence(other, self)
             return self.dot(other)
@@ -350,7 +350,7 @@ def __add__(self, other: Union["Vector2D", Point2D]) -> Union["Vector2D", Point2
     def __sub__(self, other: "Vector2D") -> "Vector2D":
         """Subtraction operation overload for ``Vector2D`` objects."""
         check_type_equivalence(other, self)
-        return Vector2D(np.subtract(self, other))
+        return np.subtract(self, other).view(Vector2D)
 
     @classmethod
     def from_points(

src/ansys/geometry/core/misc/units.py

@@ -2,14 +2,17 @@
 
 from typing import Optional, Union
 
-from pint import Quantity, Unit, UnitRegistry
+from pint import Quantity, Unit, UnitRegistry, set_application_registry
 
 from ansys.geometry.core.misc.checks import check_pint_unit_compatibility, check_type
 from ansys.geometry.core.typing import Real
 
 UNITS = UnitRegistry()
 """Unit manager."""
 
+# This forces pint to set the previous UnitRegistry as the one to be used
+set_application_registry(UNITS)
+
 
 class PhysicalQuantity:
     """Base class to handle units homogeneously throughout PyGeometry.
@@ -63,7 +66,7 @@ def _get_quantity(self, input: Real) -> Quantity:
         ~pint.Quantity
             The physical quantity the number represents.
         """
-        return (input * self.base_unit).to(self.unit)
+        return Quantity(input, units=self.base_unit).to(self.unit)
 
     def _base_units_magnitude(self, input: Quantity) -> Real:
         """Returns input's :class:`pint.Quantity` magnitude
@@ -81,4 +84,4 @@ def _base_units_magnitude(self, input: Quantity) -> Real:
         """
         check_type(input, Quantity)
         check_pint_unit_compatibility(input.units, self._base_unit)
-        return input.m_as(self._base_unit)
+        return input.to_base_units().m