luminarycloud 0.22.1__py3-none-any.whl → 0.22.3__py3-none-any.whl

luminarycloud/_wrapper.py

@@ -103,20 +103,62 @@ class ProtoWrapper(Generic[P]):
         def getter(field_name: str) -> Any:
             return lambda self: getattr(self._proto, field_name)
 
-        def wrapped_getter(field_name: str, wrapper: type[ProtoWrapperBase]) -> Any:
-            return lambda self: wrapper(getattr(self._proto, field_name))
+        def wrapped_getter(field_name: str, wrapper: type) -> Any:
+            def _get(self):
+                proto_value = getattr(self._proto, field_name)
+
+                # If it's a ProtoWrapperBase, use the standard pattern
+                if issubclass(wrapper, ProtoWrapperBase):
+                    return wrapper(proto_value)
+
+                # If it's Vector3, use the conversion pattern
+                if wrapper is Vector3:
+                    return Vector3(
+                        x=float(proto_value.x), y=float(proto_value.y), z=float(proto_value.z)
+                    )
+
+                # For other types, try the constructor directly
+                try:
+                    return wrapper(proto_value)
+                except (TypeError, ValueError):
+                    # Fallback: return the proto value as-is
+                    return proto_value
+
+            return _get
 
         # This binds the field name to the setter.
         def setter(field_name: str) -> Callable[[C, Any], None]:
             return lambda self, value: setattr(self._proto, field_name, value)
 
-        def wrapped_setter(
-            field_name: str, wrapper: type[ProtoWrapperBase]
-        ) -> Callable[[C, Any], None]:
+        def wrapped_setter(field_name: str, wrapper: type) -> Callable[[C, Any], None]:
             def _set(self: C, value: Any) -> None:
                 if not isinstance(value, wrapper):
                     raise TypeError(f"{field_name} should be a {wrapper.__name__}")
-                setattr(self._proto, field_name, value._proto)
+
+                # If it's a ProtoWrapperBase, extract the _proto
+                if issubclass(wrapper, ProtoWrapperBase):
+                    # For protobuf message fields, use CopyFrom instead of direct assignment
+                    proto_field = getattr(self._proto, field_name)
+                    proto_field.CopyFrom(value._proto)
+
+                # If it's Vector3, convert to protobuf Vector3
+                elif wrapper is Vector3:
+                    proto_field = getattr(self._proto, field_name)
+                    proto_field.x = float(value.x)
+                    proto_field.y = float(value.y)
+                    proto_field.z = float(value.z)
+
+                # For other types, try direct assignment or conversion
+                else:
+                    try:
+                        # Try using _to_proto method if it exists
+                        if hasattr(value, "_to_proto"):
+                            setattr(self._proto, field_name, value._to_proto())
+                        else:
+                            setattr(self._proto, field_name, value)
+                    except (TypeError, ValueError, AttributeError):
+                        # Fallback: direct assignment
+                        setattr(self._proto, field_name, value)
 
             return _set
 
@@ -148,7 +190,11 @@ class ProtoWrapper(Generic[P]):
                     pass
                 else:
                     try:
-                        if issubclass(_type, Enum) or issubclass(_type, ProtoWrapperBase):
+                        if (
+                            issubclass(_type, Enum)
+                            or issubclass(_type, ProtoWrapperBase)
+                            or _type is Vector3
+                        ):
                             fget = wrapped_getter(field.name, _type)
                             fset = wrapped_setter(field.name, _type)
                     except TypeError:

luminarycloud/feature_modification.py

@@ -148,6 +148,29 @@ def _update_repeated_field(
     target_field.extend(new_values)
 
 
+def _update_create_op_from_shape(create_op: gpb.Create, shape: Shape) -> None:
+    """Helper function to replace the shape in a gpb.Create operation with a shape object.
+
+    Args:
+        create: The gpb.Create to modify
+        shape: The shape to add
+    """
+    if isinstance(shape, Sphere):
+        create_op.sphere.CopyFrom(shape._to_proto())
+    elif isinstance(shape, Cube):
+        create_op.box.CopyFrom(shape._to_proto())
+    elif isinstance(shape, Cylinder):
+        create_op.cylinder.CopyFrom(shape._to_proto())
+    elif isinstance(shape, Torus):
+        create_op.torus.CopyFrom(shape._to_proto())
+    elif isinstance(shape, Cone):
+        create_op.cone.CopyFrom(shape._to_proto())
+    elif isinstance(shape, HalfSphere):
+        create_op.half_sphere.CopyFrom(shape._to_proto())
+    else:
+        raise TypeError(f"Unsupported shape type: {type(shape)}")
+
+
 def modify_import(
     feature: gpb.Feature,
     geometry_url: Optional[str] = None,
@@ -205,22 +228,7 @@ def modify_create(
     create_op = feature_copy.create
 
     if shape is not None:
-        create_op.ClearField("shape")
-
-        if isinstance(shape, Sphere):
-            create_op.sphere.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cube):
-            create_op.box.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cylinder):
-            create_op.cylinder.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Torus):
-            create_op.torus.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cone):
-            create_op.cone.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, HalfSphere):
-            create_op.half_sphere.CopyFrom(shape._to_proto())  # type: ignore
-        else:
-            raise TypeError(f"Unsupported shape type: {type(shape)}")
+        _update_create_op_from_shape(create_op, shape)
 
     return gpb.Modification(
         mod_type=gpb.Modification.ModificationType.MODIFICATION_TYPE_UPDATE_FEATURE,
@@ -719,22 +727,7 @@ def modify_farfield(
     farfield_op = feature_copy.farfield
 
     if shape is not None:
-        create_op = gpb.Create()
-        if isinstance(shape, Sphere):
-            create_op.sphere.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cube):
-            create_op.box.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cylinder):
-            create_op.cylinder.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Torus):
-            create_op.torus.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, Cone):
-            create_op.cone.CopyFrom(shape._to_proto())  # type: ignore
-        elif isinstance(shape, HalfSphere):
-            create_op.half_sphere.CopyFrom(shape._to_proto())  # type: ignore
-        else:
-            raise TypeError(f"Unsupported shape type: {type(shape)}")
-        farfield_op.create.CopyFrom(create_op)
+        _update_create_op_from_shape(farfield_op.create, shape)
 
     if volumes is not None:
         vol_ids = _volumes_to_int_list(volumes)

luminarycloud/geometry.py

@@ -178,17 +178,17 @@ class Geometry(ProtoWrapperBase):
         """
         create_proto = gpb.Create()
         if isinstance(shape, shapes.Sphere):
-            create_proto.sphere.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.sphere.CopyFrom(shape._to_proto())
         elif isinstance(shape, shapes.Cube):
-            create_proto.box.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.box.CopyFrom(shape._to_proto())
         elif isinstance(shape, shapes.Cylinder):
-            create_proto.cylinder.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.cylinder.CopyFrom(shape._to_proto())
         elif isinstance(shape, shapes.Torus):
-            create_proto.torus.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.torus.CopyFrom(shape._to_proto())
         elif isinstance(shape, shapes.Cone):
-            create_proto.cone.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.cone.CopyFrom(shape._to_proto())
         elif isinstance(shape, shapes.HalfSphere):
-            create_proto.half_sphere.CopyFrom(shape._to_proto())  # type: ignore
+            create_proto.half_sphere.CopyFrom(shape._to_proto())
         else:
             raise TypeError(f"Unsupported shape for farfield: {type(shape)}")
         self._modify(

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,18 @@ 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,
+)
+
+from .datasets import (
+    create_dataset as create_dataset,
+    list_datasets as list_datasets,
+    DatasetCaseInput as DatasetCaseInput,
+    ExportConfig as ExportConfig,
+    PhysicsAiDataset as PhysicsAiDataset,
+)

luminarycloud/physics_ai/architectures.py

@@ -53,7 +53,7 @@ class PhysicsAiArchitectureVersion(ProtoWrapperBase):
         if "custom_args" not in config:
             config["custom_args"] = ""
         if "priority_class" not in config:
-            config["priority_class"] = "prod-batch-priority"
+            config["priority_class"] = "internal-training-job-priority"
         if "resources" not in config:
             config["resources"] = {}
         if "process_cpus" not in config["resources"]: