luminarycloud 0.22.2__py3-none-any.whl → 0.23.0__py3-none-any.whl

luminarycloud/types/vector3.py

@@ -1,13 +1,15 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import TypeAlias, Iterator
+from typing import TypeAlias
+
+from luminarycloud.types import LcFloat
 
 from .._proto.api.v0.luminarycloud.common import common_pb2 as commonpb
-from .._proto.base.base_pb2 import AdVector3, Vector3 as Vector3Proto
-from .adfloat import (
-    _to_ad_proto as _float_to_ad_proto,
-    _from_ad_proto as _float_from_ad_proto,
-)
+from .._proto.base import base_pb2 as basepb
+from .adfloat import Expression, _lcfloat_to_float
+from .adfloat import _from_ad_proto as _float_from_ad_proto
+from .adfloat import _to_ad_proto as _float_to_ad_proto
 
 
 @dataclass
@@ -30,43 +32,64 @@ class Vector3:
         array([1., 2., 3.])
     """
 
-    x: float = 0.0
-    y: float = 0.0
-    z: float = 0.0
+    x: LcFloat = 0.0
+    y: LcFloat = 0.0
+    z: LcFloat = 0.0
 
     def _to_proto(self) -> commonpb.Vector3:
-        return commonpb.Vector3(x=self.x, y=self.y, z=self.z)
+        # TODO(LC-26796) evaluate expressions to do this conversion
+        if any(isinstance(c, Expression) for c in (self.x, self.y, self.z)):
+            raise ValueError(
+                "Cannot convert Vector3 with Expression components to commonpb.Vector3"
+            )
+        return commonpb.Vector3(
+            x=_lcfloat_to_float(self.x),
+            y=_lcfloat_to_float(self.y),
+            z=_lcfloat_to_float(self.z),
+        )
 
     def _from_proto(self, proto: commonpb.Vector3) -> None:
         self.x = proto.x
         self.y = proto.y
         self.z = proto.z
 
-    def _to_ad_proto(self) -> AdVector3:
-        advector = AdVector3()
+    def _to_ad_proto(self) -> basepb.AdVector3:
+        advector = basepb.AdVector3()
         advector.x.CopyFrom(_float_to_ad_proto(self.x))
         advector.y.CopyFrom(_float_to_ad_proto(self.y))
         advector.z.CopyFrom(_float_to_ad_proto(self.z))
         return advector
 
-    def _to_base_proto(self) -> Vector3Proto:
-        return Vector3Proto(x=self.x, y=self.y, z=self.z)
-
-    def _from_ad_proto(self, proto: AdVector3) -> None:
+    def _from_ad_proto(self, proto: basepb.AdVector3) -> None:
         self.x = _float_from_ad_proto(proto.x)
         self.y = _float_from_ad_proto(proto.y)
         self.z = _float_from_ad_proto(proto.z)
 
     @classmethod
-    def from_ad_proto(cls, proto: AdVector3) -> "Vector3":
+    def from_ad_proto(cls, proto: basepb.AdVector3) -> "Vector3":
         vector = cls()
         vector._from_ad_proto(proto)
         return vector
 
-    def __getitem__(self, index: int) -> float:
+    def _to_base_proto(self) -> basepb.Vector3:
+        # TODO(LC-26796) evaluate expressions to do this conversion
+        if any(isinstance(c, Expression) for c in (self.x, self.y, self.z)):
+            raise ValueError("Cannot convert Vector3 with Expression components to basepb.Vector3")
+        return basepb.Vector3(
+            x=_lcfloat_to_float(self.x),
+            y=_lcfloat_to_float(self.y),
+            z=_lcfloat_to_float(self.z),
+        )
+
+    def _from_base_proto(self, proto: basepb.Vector3) -> None:
+        self.x = proto.x
+        self.y = proto.y
+        self.z = proto.z
+
+    def __getitem__(self, index: int) -> LcFloat:
         return [self.x, self.y, self.z][index]
 
-    def __setitem__(self, index: int, value: float) -> None:
+    def __setitem__(self, index: int, value: LcFloat) -> None:
         if index == 0:
             self.x = value
         elif index == 1:
@@ -76,7 +99,7 @@ class Vector3:
         else:
             raise IndexError(f"Index {index} out of bounds for Vector3")
 
-    def __iter__(self) -> Iterator[float]:
+    def __iter__(self) -> Iterator[LcFloat]:
         """Enable iteration over the vector components."""
         yield self.x
         yield self.y
@@ -90,10 +113,12 @@ class Vector3:
 Vector3Like: TypeAlias = Vector3 | list[float] | tuple[float, float, float]  # type: ignore
 
 
-def _to_vector3(value: Vector3Like) -> Vector3:
+def _to_vector3(value: Vector3Like | None) -> Vector3:
+    if value is None:
+        return Vector3()
     if isinstance(value, Vector3):
         return value
-    elif isinstance(value, list) or isinstance(value, tuple):
+    elif isinstance(value, (list, tuple)):
         assert len(value) == 3
         return Vector3(value[0], value[1], value[2])
     else:
@@ -104,5 +129,9 @@ def _to_vector3_proto(value: Vector3Like) -> commonpb.Vector3:
     return _to_vector3(value)._to_proto()
 
 
-def _to_vector3_ad_proto(value: Vector3Like) -> AdVector3:
+def _to_vector3_base_proto(value: Vector3Like) -> basepb.Vector3:
+    return _to_vector3(value)._to_base_proto()
+
+
+def _to_vector3_ad_proto(value: Vector3Like) -> basepb.AdVector3:
     return _to_vector3(value)._to_ad_proto()

luminarycloud/vis/__init__.py

@@ -1,3 +1,4 @@
+from .display import Field as Field
 from .visualization import (
     RenderOutput as RenderOutput,
     Scene as Scene,
@@ -8,6 +9,8 @@ from .visualization import (
     list_cameras as list_cameras,
     RangeResult as RangeResult,
     range_query as range_query,
+    ExtremaResult as ExtremaResult,
+    extrema_query as extrema_query,
     get_camera as get_camera,
     DirectionalCamera as DirectionalCamera,
     LookAtCamera as LookAtCamera,

luminarycloud/vis/visualization.py

@@ -25,6 +25,7 @@ from luminarycloud.enum import (
     VisQuantity,
     QuantityType,
     FieldAssociation,
+    ExtremaType,
 )
 from ..exceptions import NotFoundError
 from ..geometry import Geometry, get_geometry
@@ -1109,6 +1110,28 @@ class RangeResult:
     """ Name of the field.  """
 
 
+@dc.dataclass
+class ExtremaResult:
+    """
+    Result from an extrema query containing information about a single extremum value.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+    """
+
+    value: float
+    """ The extremum value. """
+    local_cell_id: int
+    """ Local cell id in the volume specified by the volume name. """
+    approx_cell_center: Vector3
+    """ Approximate cell center in global coordinates. """
+    volume_id: str
+    """ Id of the volume. """
+    global_face_ids: List[int]
+    """ Cell's global face ids. """
+    connected_bounds_ids: List[str]
+    """ Ids of any connected surfaces. """
+
+
 def range_query(solution: Solution, field_association: FieldAssociation) -> List[RangeResult]:
     """
     The range query returns the min/max values for all fields in a solution. Two
@@ -1155,6 +1178,71 @@ def range_query(solution: Solution, field_association: FieldAssociation) -> List
     return result
 
 
+def extrema_query(
+    solution: Solution,
+    field: Field,
+    extrema_type: ExtremaType,
+    num_values: int = 10,
+) -> List[ExtremaResult]:
+    """
+    The extrema query returns the top N minimum or maximum values for a specific
+    field/component in a solution. This is useful for finding hotspots, peak values,
+    or other extreme conditions in your simulation results.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Parameters
+    ----------
+    solution: Solution
+        The solution object to query.
+    field: Field
+        The field (quantity and component) to query for extrema values.
+    extrema_type: ExtremaType
+        Whether to find minimum or maximum values.
+    num_values: int
+        How many extrema values to return. Default: 10
+
+    Returns
+    -------
+    List[ExtremaResult]
+        A list of extrema results, each containing the value, location, and connectivity information.
+    """
+
+    if num_values <= 0:
+        raise ValueError(f"num_values must be positive, got {num_values}")
+
+    if field.quantity == VisQuantity.NONE:
+        raise ValueError("Field quantity cannot be NONE")
+
+    sim = get_simulation(solution.simulation_id)
+    req = vis_pb2.ExtremaQueryRequest()
+    req.entity.simulation.id = solution.simulation_id
+    req.entity.simulation.solution_id = solution.id
+    req.project_id = sim.project_id
+
+    # Use the Field's _to_proto method to properly set field with quantity and component
+    req.field.CopyFrom(field._to_proto())
+
+    req.num_values = num_values
+    req.extrema_type = extrema_type
+
+    res: vis_pb2.ExtremaQueryReply = get_default_client().ExtremaQuery(req)
+    result: List[ExtremaResult] = []
+    for e in res.extrema:
+        extrema_result = ExtremaResult(
+            value=e.value,
+            local_cell_id=e.local_cell_id,
+            approx_cell_center=Vector3(
+                x=e.approx_cell_center.x, y=e.approx_cell_center.y, z=e.approx_cell_center.z
+            ),
+            volume_id=e.volume_id,
+            global_face_ids=list(e.global_face_ids),
+            connected_bounds_ids=list(e.connected_bounds_ids),
+        )
+        result.append(extrema_result)
+    return result
+
+
 def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
     """
     Lists all previously created renders associated with a project and an entity.

luminarycloud/volume_selection.py

@@ -12,7 +12,7 @@ from luminarycloud._proto.api.v0.luminarycloud.geometry import (
     geometry_pb2 as geometrypb,
 )
 from luminarycloud._proto.upload import upload_pb2 as uploadpb
-from luminarycloud.types.adfloat import _from_ad_proto, _to_ad_proto
+from luminarycloud.types.adfloat import LcFloat, _from_ad_proto, _to_ad_proto
 
 from ._client import get_default_client
 from ._proto.base import base_pb2 as basepb
@@ -122,9 +122,9 @@ class VolumeSelection:
 
     def import_cad(
         self,
-        cad_file_path: PathLike,
+        cad_file_path: PathLike | str,
         *,
-        scaling: float = 1.0,
+        scaling: LcFloat = 1.0,
         feature_name: str = "Import CAD",
     ) -> None:
         """
@@ -134,7 +134,7 @@ class VolumeSelection:
         ----------
         cad_file_path : PathLike
             The path to the CAD file to import.
-        scaling : float
+        scaling : LcFloat
             The scaling factor to apply to the CAD file.
         feature_name : str
             The name of the feature. This is not a tag name.
@@ -347,7 +347,7 @@ class VolumeSelection:
 
     def rotate(
         self,
-        angle: float,
+        angle: LcFloat,
         axis: Vector3Like,
         origin: Vector3Like,
         *,
@@ -359,7 +359,7 @@ class VolumeSelection:
 
         Parameters
         ----------
-        angle : float
+        angle : LcFloat
             The angle to rotate the selected volumes by, in degrees.
         axis : Vector3Like
             The axis to rotate the selected volumes around.
@@ -389,7 +389,7 @@ class VolumeSelection:
 
     def scale(
         self,
-        factor: float,
+        factor: LcFloat,
         origin: Vector3Like,
         *,
         keep: bool = False,
@@ -400,7 +400,7 @@ class VolumeSelection:
 
         Parameters
         ----------
-        factor : float
+        factor : LcFloat
             The scaling factor.
         origin : Vector3Like
             The origin to scale the selected volumes from.
@@ -620,7 +620,7 @@ class VolumeSelection:
     def linear_pattern_with_vector_magnitude(
         self,
         vector: Vector3Like,
-        magnitude: float,
+        magnitude: LcFloat,
         quantity: int,
         symmetric: bool = False,
         *,
@@ -634,7 +634,7 @@ class VolumeSelection:
         ----------
         vector : Vector3Like
             Direction of the vector to repeat the selected volumes along. It will be normalized.
-        magnitude : float
+        magnitude : LcFloat
             The magnitude of the vector.
         quantity : int
             The number of times to repeat the selected volumes.
@@ -643,16 +643,28 @@ class VolumeSelection:
         feature_name : str
             The name of the feature.
         """
-        return self.linear_pattern(
-            vector=[vector[i] * magnitude for i in range(3)],
-            quantity=quantity,
-            symmetric=symmetric,
-            feature_name=feature_name,
+        self.__create_feature(
+            gpb.Feature(
+                feature_name=feature_name,
+                pattern=gpb.Pattern(
+                    body=self.__volume_ids,
+                    direction=gpb.Pattern.Direction(
+                        linear_spacing=transformationpb.Translation(
+                            magnitude_vector=transformationpb.MagnitudeAdVector3(
+                                direction=_to_vector3_ad_proto(vector),
+                                magnitude=_to_ad_proto(magnitude),
+                            ),
+                        ),
+                        quantity=quantity,
+                        symmetric=symmetric,
+                    ),
+                ),
+            )
         )
 
     def circular_pattern(
         self,
-        angle: float,
+        angle: LcFloat,
         axis: Vector3Like,
         origin: Vector3Like,
         quantity: int,
@@ -666,7 +678,7 @@ class VolumeSelection:
 
         Parameters
         ----------
-        angle : float
+        angle : LcFloat
             The angle of the circular arc, in degrees.
         axis : Vector3Like
             The axis of the circular arc.

{luminarycloud-0.22.2.dist-info → luminarycloud-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.22.2
+Version: 0.23.0
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/