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

luminarycloud/meshing/mesh_generation_params.py

@@ -16,11 +16,10 @@ from ..params.geometry import (
 )
 from ..types import Vector3
 from .sizing_strategy import MaxCount, Minimal, MinimalCount, SizingStrategy, TargetCount
-from ..pipeline_util.dictable import PipelineDictable
 
 
 @dataclass(kw_only=True)
-class VolumeMeshingParams(PipelineDictable):
+class VolumeMeshingParams:
     """Volume meshing parameters."""
 
     volumes: list[Volume]
@@ -39,7 +38,7 @@ class VolumeMeshingParams(PipelineDictable):
 
 
 @dataclass(kw_only=True)
-class ModelMeshingParams(PipelineDictable):
+class ModelMeshingParams:
     """Model meshing parameters."""
 
     surfaces: Sequence[Surface | str]
@@ -62,7 +61,7 @@ class ModelMeshingParams(PipelineDictable):
 
 
 @dataclass(kw_only=True)
-class BoundaryLayerParams(PipelineDictable):
+class BoundaryLayerParams:
     """Boundary layer meshing parameters."""
 
     surfaces: Sequence[Surface | str]
@@ -88,7 +87,7 @@ class BoundaryLayerParams(PipelineDictable):
 
 
 @dataclass(kw_only=True)
-class RefinementRegion(PipelineDictable):
+class RefinementRegion:
     """Refinement region parameters."""
 
     name: str
@@ -138,7 +137,7 @@ class RefinementRegion(PipelineDictable):
 
 
 @dataclass(kw_only=True)
-class MeshGenerationParams(PipelineDictable):
+class MeshGenerationParams:
     """Mesh generation parameters."""
 
     geometry_id: str

luminarycloud/meshing/sizing_strategy/sizing_strategies.py

@@ -1,11 +1,10 @@
 from dataclasses import dataclass
 
 from luminarycloud._helpers.warnings.deprecated import deprecated
-from ...pipeline_util.dictable import PipelineDictable
 
 
 @dataclass
-class SizingStrategy(PipelineDictable):
+class SizingStrategy:
     """Sizing strategy parameters."""
 
     pass

luminarycloud/outputs/__init__.py

@@ -19,6 +19,8 @@ from .output_definitions import (
 
 from .stopping_conditions import (
     StoppingCondition as StoppingCondition,
+    StoppingConditionResult as StoppingConditionResult,
+    StoppingConditionStatusResult as StoppingConditionStatusResult,
     GeneralStoppingConditions as GeneralStoppingConditions,
     create_or_update_stopping_condition as create_or_update_stopping_condition,
     get_stopping_condition as get_stopping_condition,

luminarycloud/outputs/output_definitions.py

@@ -125,7 +125,7 @@ class SurfaceAverageOutputDefinition(CodeRepr):
     space_averaging_type: SpaceAveragingType = SpaceAveragingType.AREA
     "Type of spatial averaging to use."
     vector_component: Vector3Component = Vector3Component.UNSPECIFIED
-    "For vector quantities, the component to measure."
+    "For vector quantities, the component to measure must be specified (X, Y, or Z)."
 
     def _to_proto(self) -> feoutputpb.OutputNode:
         proto = feoutputpb.OutputNode(
@@ -309,7 +309,7 @@ class PointProbeOutputDefinition(CodeRepr):
     include: OutputDefinitionInclusions = field(default_factory=OutputDefinitionInclusions)
     "Configuration for what values to include."
     vector_component: Vector3Component = Vector3Component.UNSPECIFIED
-    "For vector quantities, the component to measure."
+    "For vector quantities, the component to measure must be specified (X, Y, or Z)."
 
     def _to_proto(self) -> feoutputpb.OutputNode:
         proto = feoutputpb.OutputNode(
@@ -356,7 +356,7 @@ class VolumeReductionOutputDefinition(CodeRepr):
     volume_reduction_type: VolumeReductionType = VolumeReductionType.AVERAGE
     "Type of reduction to perform for each volume."
     vector_component: Vector3Component = Vector3Component.UNSPECIFIED
-    "For vector quantities, the component to measure."
+    "For vector quantities, the component to measure must be specified (X, Y, or Z)."
 
     def _to_proto(self) -> feoutputpb.OutputNode:
         proto = feoutputpb.OutputNode(

luminarycloud/outputs/stopping_conditions.py

@@ -2,6 +2,7 @@
 
 from .._client import get_default_client
 from .._proto.api.v0.luminarycloud.stopping_condition import stopping_condition_pb2 as stopcondpb
+from .._proto.api.v0.luminarycloud.simulation import simulation_pb2 as simulationpb
 from .._proto.output import output_pb2 as outputpb
 from dataclasses import dataclass
 
@@ -213,3 +214,96 @@ def update_general_stopping_conditions(
     )
     res = get_default_client().UpdateBasicStoppingConditions(req)
     return GeneralStoppingConditions._from_proto(res.basic_stopping_conditions)
+
+
+@dataclass
+class StoppingConditionResult:
+    """
+    Result of evaluating a single stopping condition.
+
+    Attributes
+    ----------
+    output_name : str
+        Name of the output being monitored.
+    threshold : float
+        The threshold value for this condition.
+    value : float
+        The actual value of the monitored output.
+    satisfied : bool
+        Whether this condition was satisfied.
+    is_force_condition : bool
+        Whether this is a force-stop condition (e.g., max iterations, max time).
+        Force conditions cause immediate termination regardless of other conditions.
+    """
+
+    output_name: str
+    threshold: float
+    value: float
+    satisfied: bool
+    is_force_condition: bool
+
+
+@dataclass
+class StoppingConditionStatusResult:
+    """
+    Status of all stopping conditions for a simulation.
+
+    This represents the evaluation of stopping conditions against the final
+    simulation results.
+
+    Attributes
+    ----------
+    overall_success : bool
+        Whether the overall stopping criteria were met (excluding force-stop conditions).
+    force_stopped : bool
+        Whether a force-stop condition was triggered.
+    condition_results : list[StoppingConditionResult]
+        Results for each individual stopping condition.
+    """
+
+    overall_success: bool
+    force_stopped: bool
+    condition_results: list[StoppingConditionResult]
+
+    @classmethod
+    def _from_proto(
+        cls, proto: simulationpb.GetStoppingConditionStatusResponse
+    ) -> "StoppingConditionStatusResult":
+        condition_results = []
+        for i, condition in enumerate(proto.conditions):
+            # Get the value from the status with bounds checking
+            value = (
+                proto.status.value[i].values[0].value
+                if i < len(proto.status.value) and proto.status.value[i].values
+                else float("nan")
+            )
+
+            # Get the threshold, checking for field presence (not truthiness)
+            threshold = condition.threshold.value if condition.HasField("threshold") else 0.0
+
+            # Check if this is a force condition
+            is_force = condition.op == outputpb.STOP_COND_OP_FORCE
+
+            # Get output name with field presence check
+            output_name = condition.output.name if condition.HasField("output") else ""
+
+            # Get satisfied status with bounds checking
+            satisfied = (
+                proto.status.cond_success[i] if i < len(proto.status.cond_success) else False
+            )
+
+            condition_results.append(
+                StoppingConditionResult(
+                    output_name=output_name,
+                    threshold=threshold,
+                    value=value,
+                    satisfied=satisfied,
+                    is_force_condition=is_force,
+                )
+            )
+
+        return cls(
+            overall_success=proto.status.success,
+            force_stopped=proto.status.force_stop,
+            condition_results=condition_results,
+        )

luminarycloud/params/enum/_enum_wrappers.py

@@ -747,6 +747,14 @@ class PtTableFluid(_IntEnum):
         R410A.
     REAL_GAS_R507A
         R507A.
+    REAL_GAS_R513A
+        R513A.
+    REAL_GAS_R513B
+        R513B.
+    REAL_GAS_R515A
+        R515A.
+    REAL_GAS_R515B
+        R515B.
     REAL_GAS_RC318
         RC318.
     REAL_GAS_SES36
@@ -883,6 +891,10 @@ class PtTableFluid(_IntEnum):
     >>> PtTableFluid.REAL_GAS_R41
     >>> PtTableFluid.REAL_GAS_R410A
     >>> PtTableFluid.REAL_GAS_R507A
+    >>> PtTableFluid.REAL_GAS_R513A
+    >>> PtTableFluid.REAL_GAS_R513B
+    >>> PtTableFluid.REAL_GAS_R515A
+    >>> PtTableFluid.REAL_GAS_R515B
     >>> PtTableFluid.REAL_GAS_RC318
     >>> PtTableFluid.REAL_GAS_SES36
     >>> PtTableFluid.REAL_GAS_SULFUR_DIOXIDE
@@ -1009,6 +1021,10 @@ class PtTableFluid(_IntEnum):
     REAL_GAS_R41 = _clientpb.REAL_GAS_R41
     REAL_GAS_R410A = _clientpb.REAL_GAS_R410A
     REAL_GAS_R507A = _clientpb.REAL_GAS_R507A
+    REAL_GAS_R513A = _clientpb.REAL_GAS_R513A
+    REAL_GAS_R513B = _clientpb.REAL_GAS_R513B
+    REAL_GAS_R515A = _clientpb.REAL_GAS_R515A
+    REAL_GAS_R515B = _clientpb.REAL_GAS_R515B
     REAL_GAS_RC318 = _clientpb.REAL_GAS_RC318
     REAL_GAS_SES36 = _clientpb.REAL_GAS_SES36
     REAL_GAS_SULFUR_DIOXIDE = _clientpb.REAL_GAS_SULFUR_DIOXIDE

luminarycloud/params/geometry/shapes.py

@@ -1,84 +1,84 @@
 # Copyright 2024 Luminary Cloud, Inc. All Rights Reserved.
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
-from luminarycloud.types import Vector3
-from luminarycloud._helpers.proto_decorator import proto_decorator
+from luminarycloud._helpers.proto_decorator import ProtoConvertible, proto_decorator
 from luminarycloud._proto.cad import shape_pb2 as shapepb
+from luminarycloud.types import Vector3
 
 
-class Shape:
+class Shape(ProtoConvertible):
     pass
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.Sphere)
 class Sphere(Shape):
-    center: Vector3
-    radius: float
+    center: Vector3 = field(default_factory=Vector3)
+    radius: float = 0.0
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.SphereShell)
 class SphereShell(Shape):
-    center: Vector3
-    radius: float
-    radius_inner: float
+    center: Vector3 = field(default_factory=Vector3)
+    radius: float = 0.0
+    radius_inner: float = 0.0
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.HalfSphere)
 class HalfSphere(Shape):
-    center: Vector3
-    radius: float
-    normal: Vector3
+    center: Vector3 = field(default_factory=Vector3)
+    radius: float = 0.0
+    normal: Vector3 = field(default_factory=Vector3)
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.Cube)
 class Cube(Shape):
-    min: Vector3
-    max: Vector3
+    min: Vector3 = field(default_factory=Vector3)
+    max: Vector3 = field(default_factory=Vector3)
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.OrientedCube)
 class OrientedCube(Shape):
-    min: Vector3
-    max: Vector3
-    origin: Vector3
-    x_axis: Vector3
-    y_axis: Vector3
+    min: Vector3 = field(default_factory=Vector3)
+    max: Vector3 = field(default_factory=Vector3)
+    origin: Vector3 = field(default_factory=Vector3)
+    x_axis: Vector3 = field(default_factory=Vector3)
+    y_axis: Vector3 = field(default_factory=Vector3)
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.Cylinder)
 class Cylinder(Shape):
-    start: Vector3
-    end: Vector3
-    radius: float
+    start: Vector3 = field(default_factory=Vector3)
+    end: Vector3 = field(default_factory=Vector3)
+    radius: float = 0.0
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.AnnularCylinder)
 class AnnularCylinder(Shape):
-    start: Vector3
-    end: Vector3
-    radius: float
-    radius_inner: float
+    start: Vector3 = field(default_factory=Vector3)
+    end: Vector3 = field(default_factory=Vector3)
+    radius: float = 0.0
+    radius_inner: float = 0.0
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.Torus)
 class Torus(Shape):
-    center: Vector3
-    normal: Vector3
-    major_radius: float
-    minor_radius: float
+    center: Vector3 = field(default_factory=Vector3)
+    normal: Vector3 = field(default_factory=Vector3)
+    major_radius: float = 0.0
+    minor_radius: float = 0.0
 
 
 @dataclass(kw_only=True)
 @proto_decorator(shapepb.Cone)
 class Cone(Shape):
-    apex: Vector3
-    base_center: Vector3
-    base_radius: float
+    apex: Vector3 = field(default_factory=Vector3)
+    base_center: Vector3 = field(default_factory=Vector3)
+    base_radius: float = 0.0

luminarycloud/params/simulation/adaptive_mesh_refinement/__init__.py

@@ -1 +1,2 @@
+from .active_region_ import ActiveRegion
 from .boundary_layer_profile_ import BoundaryLayerProfile

luminarycloud/params/simulation/adaptive_mesh_refinement/active_region_.py

@@ -0,0 +1,83 @@
+# Generated by generate_sdk_wrappers.py. DO NOT EDIT
+
+from abc import ABC, ABCMeta
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from google.protobuf.message import Message as _Message
+from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
+from luminarycloud.types import Vector3, LcFloat
+from luminarycloud.types.adfloat import _to_ad_proto, _from_ad_proto
+from luminarycloud._helpers._entity_identifier import _create_entity_identifier
+from luminarycloud._proto.client import simulation_pb2 as clientpb
+from luminarycloud._proto.client.entity_pb2 import EntityIdentifier
+from luminarycloud._helpers import CodeRepr
+import luminarycloud.params.enum._enum_wrappers as enum
+
+from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_unique_id
+
+from luminarycloud.params.geometry import shapes
+
+
+@dataclass(kw_only=True)
+class ActiveRegion(CodeRepr, ParamGroupWrapper[clientpb.ActiveRegion]):
+    """Region(s) within which the mesh is adapted at full resolution. Outside of these regions the mesh is coarsened with increasing distance from the region."""
+
+    error_weight: LcFloat = 1.0
+    "Error weighting from the active region at Max Distance. Local error weighting is 1.0 inside the region and decreases to Error Weight at the Max Distance."
+    max_distance: LcFloat = 0.0
+    "Distance from the active regions at which to apply the full error factor."
+    cube: shapes.Cube | None = None
+    "Coordinate-aligned box."
+    oriented_cube: shapes.OrientedCube | None = None
+    "Box oriented along arbitrary axes."
+    cylinder: shapes.Cylinder | None = None
+    "Cylinder shape."
+    annular_cylinder: shapes.AnnularCylinder | None = None
+    "Cylinder with a hole along the axis."
+    sphere: shapes.Sphere | None = None
+    "Sphere shape."
+    sphere_shell: shapes.SphereShell | None = None
+    "Spherical shell shape."
+
+    def _to_proto(self) -> clientpb.ActiveRegion:
+        _proto = clientpb.ActiveRegion()
+        _proto.error_weight.CopyFrom(_to_ad_proto(self.error_weight))
+        _proto.max_distance.CopyFrom(_to_ad_proto(self.max_distance))
+        if self.cube is not None:
+            _proto.cube.CopyFrom(self.cube._to_proto())
+        if self.oriented_cube is not None:
+            _proto.oriented_cube.CopyFrom(self.oriented_cube._to_proto())
+        if self.cylinder is not None:
+            _proto.cylinder.CopyFrom(self.cylinder._to_proto())
+        if self.annular_cylinder is not None:
+            _proto.annular_cylinder.CopyFrom(self.annular_cylinder._to_proto())
+        if self.sphere is not None:
+            _proto.sphere.CopyFrom(self.sphere._to_proto())
+        if self.sphere_shell is not None:
+            _proto.sphere_shell.CopyFrom(self.sphere_shell._to_proto())
+        return _proto
+
+    def _from_proto(self, proto: clientpb.ActiveRegion) -> None:
+        self.error_weight = _from_ad_proto(proto.error_weight)
+        self.max_distance = _from_ad_proto(proto.max_distance)
+        if proto.cube.ByteSize() > 0:
+            self.cube = shapes.Cube()
+            self.cube._from_proto(proto.cube)
+        if proto.oriented_cube.ByteSize() > 0:
+            self.oriented_cube = shapes.OrientedCube()
+            self.oriented_cube._from_proto(proto.oriented_cube)
+        if proto.cylinder.ByteSize() > 0:
+            self.cylinder = shapes.Cylinder()
+            self.cylinder._from_proto(proto.cylinder)
+        if proto.annular_cylinder.ByteSize() > 0:
+            self.annular_cylinder = shapes.AnnularCylinder()
+            self.annular_cylinder._from_proto(proto.annular_cylinder)
+        if proto.sphere.ByteSize() > 0:
+            self.sphere = shapes.Sphere()
+            self.sphere._from_proto(proto.sphere)
+        if proto.sphere_shell.ByteSize() > 0:
+            self.sphere_shell = shapes.SphereShell()
+            self.sphere_shell._from_proto(proto.sphere_shell)
+        return None

luminarycloud/params/simulation/adaptive_mesh_refinement/boundary_layer_profile_.py

@@ -20,7 +20,7 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 
 @dataclass(kw_only=True)
 class BoundaryLayerProfile(CodeRepr, ParamGroupWrapper[clientpb.BoundaryLayerProfile]):
-    """"""
+    """Boundary layer meshing parameters to apply to adapted meshes."""
 
     n_layers: int = 40
     "Maximum number of prism layers within a boundary layer mesh."

luminarycloud/params/simulation/adaptive_mesh_refinement_.py

@@ -17,6 +17,8 @@ import luminarycloud.params.enum._enum_wrappers as enum
 
 from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_unique_id
 
+from luminarycloud.params.simulation.adaptive_mesh_refinement.active_region_ import ActiveRegion
+from luminarycloud.params.simulation.adaptive_mesh_refinement.active_region_ import *
 from luminarycloud.params.simulation.adaptive_mesh_refinement.boundary_layer_profile_ import (
     BoundaryLayerProfile,
 )
@@ -46,7 +48,9 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
     user_scaling: LcFloat = 1.0
     "Scale factor between the geometry and the mesh."
     boundary_layer_profile: list[BoundaryLayerProfile] = field(default_factory=list)
-    ""
+    "Boundary layer meshing parameters to apply to adapted meshes."
+    active_region: list[ActiveRegion] = field(default_factory=list)
+    "Region(s) within which the mesh is adapted at full resolution. Outside of these regions the mesh is coarsened with increasing distance from the region."
 
     def _to_proto(self) -> clientpb.AdaptiveMeshRefinement:
         _proto = clientpb.AdaptiveMeshRefinement()
@@ -61,6 +65,8 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
         _proto.user_scaling.CopyFrom(_to_ad_proto(self.user_scaling))
         if self.boundary_layer_profile is not None:
             _proto.boundary_layer_profile.extend(v._to_proto() for v in self.boundary_layer_profile)
+        if self.active_region is not None:
+            _proto.active_region.extend(v._to_proto() for v in self.active_region)
         return _proto
 
     def _from_proto(self, proto: clientpb.AdaptiveMeshRefinement) -> None:
@@ -76,4 +82,5 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
         self.boundary_layer_profile = [
             BoundaryLayerProfile.from_proto(v) for v in proto.boundary_layer_profile
         ]
+        self.active_region = [ActiveRegion.from_proto(v) for v in proto.active_region]
         return None

luminarycloud/physics_ai/__init__.py

@@ -12,3 +12,10 @@ from .models import (
 from .solution import (
     _download_processed_solution_physics_ai as _download_processed_solution_physics_ai,
 )
+
+from .inference import (
+    InferenceJob as InferenceJob,
+    SurfaceForInference as SurfaceForInference,
+    VisualizationExport as VisualizationExport,
+    NumericResult as NumericResult,
+)