luminarycloud 0.15.5__py3-none-any.whl → 0.16.1__py3-none-any.whl

luminarycloud/feature_modification.py

@@ -12,7 +12,7 @@ from google.protobuf.internal.containers import RepeatedScalarFieldContainer
 class FeatureOperationType(Enum):
     """Enum representing the type of operation in a Feature."""
 
-    IMPORT = auto()
+    IMPORT_GEOMETRY = auto()
     CREATE = auto()
     DELETE = auto()
     UNION = auto()
@@ -73,7 +73,7 @@ def get_operation_type(feature: gpb.Feature) -> FeatureOperationType:
 
     # Base operation map for simple one-to-one mappings
     base_operation_map = {
-        "import": FeatureOperationType.IMPORT,
+        "import_geometry": FeatureOperationType.IMPORT_GEOMETRY,
         "create": FeatureOperationType.CREATE,
         "delete": FeatureOperationType.DELETE,
         "imprint": FeatureOperationType.IMPRINT,
@@ -165,21 +165,20 @@ def modify_import(
     Returns:
         A gpb.Modification object
     """
-    if get_operation_type(feature) != FeatureOperationType.IMPORT:
+    if get_operation_type(feature) != FeatureOperationType.IMPORT_GEOMETRY:
         raise ValueError("Feature is not an import operation")
 
     feature_copy = deepcopy(feature)
-    import_op = getattr(feature_copy, "import")
 
     if geometry_url is not None:
         # TODO(chiodi): Handle upload of file here.
-        import_op.geometry_url = geometry_url
+        feature_copy.import_geometry.geometry_url = geometry_url
 
     if scaling is not None:
-        import_op.scaling = scaling
+        feature_copy.import_geometry.scaling = scaling
 
     if force_discrete is not None:
-        import_op.force_discrete = force_discrete
+        feature_copy.import_geometry.force_discrete = force_discrete
 
     return gpb.Modification(
         mod_type=gpb.Modification.ModificationType.MODIFICATION_TYPE_UPDATE_FEATURE,

luminarycloud/geometry.py

@@ -554,6 +554,30 @@ class Geometry(ProtoWrapperBase):
         res: geometrypb.GetGeometryResponse = get_default_client().GetGeometry(req)
         self._proto = res.geometry
 
+    def to_code(self) -> str:
+        """
+        Returns the python code that creates (from scratch) an identical geometry.
+        If the geometry has been modified, the code will be generated for the latest version of the
+        geometry.
+
+        Returns
+        -------
+        str
+            The SDK code that can be used to recreate this geometry.
+
+        Examples
+        --------
+        >>> geometry = lc.get_geometry("geometry-id")
+        >>> python_code = geometry.to_code()
+        >>> print(python_code)
+        """
+        req = geometrypb.GetSdkCodeRequest(
+            geometry_id=self.id,
+            geometry_version_id="",  # Use the latest version of the geometry by default
+        )
+        res: geometrypb.GetSdkCodeResponse = get_default_client().GetSdkCode(req)
+        return res.sdk_code
+
 
 def get_geometry(id: str) -> Geometry:
     """

luminarycloud/geometry_version.py

@@ -126,6 +126,29 @@ class GeometryVersion(ProtoWrapperBase):
         )
         return list(res.features_issues)
 
+    def to_code(self) -> str:
+        """
+        Returns the Python code that creates (from scratch) an identical geometry of
+        this particular version.
+
+        Returns
+        -------
+        str
+            The SDK code that can be used to recreate this specific geometry version.
+
+        Examples
+        --------
+        >>> geometry_version = lc.get_geometry_version("version-id")
+        >>> python_code = geometry_version.to_code()
+        >>> print(python_code)
+        """
+        req = geometrypb.GetSdkCodeRequest(
+            geometry_id=self.geometry_id,
+            geometry_version_id=self.id,
+        )
+        res: geometrypb.GetSdkCodeResponse = get_default_client().GetSdkCode(req)
+        return res.sdk_code
+
 
 def get_geometry_version(id: str) -> GeometryVersion:
     """

luminarycloud/mesh.py

@@ -44,10 +44,17 @@ class Mesh(ProtoWrapperBase):
         """
         return lc.get_project(ProjectID(self._proto.project_id))
 
-    def geometry_version(self) -> GeometryVersion:
+    def geometry_version(self) -> GeometryVersion | None:
         """
         Get the geometry version associated with this mesh.
+
+        Returns
+        -------
+        GeometryVersion | None
+            The geometry version associated with this mesh, or None if the mesh has no geometry version.
         """
+        if self._proto.geometry_version_id == "":
+            return None
         return get_geometry_version(self._proto.geometry_version_id)
 
     def update(

luminarycloud/params/simulation/adjoint_.py

@@ -22,7 +22,7 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
     """Settings for adjoint sensitivity analysis."""
 
-    output: Any | None = None
+    _output: Any | None = None
     "Function to differentiate."
     surfaces: list[str] = field(default_factory=list)
     ""
@@ -33,8 +33,8 @@ class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
 
     def _to_proto(self) -> clientpb.Adjoint:
         _proto = clientpb.Adjoint()
-        if self.output is not None:
-            _proto.adjoint_output.CopyFrom(self.output)
+        if self._output is not None:
+            _proto.adjoint_output.CopyFrom(self._output)
         if self.surfaces is not None:
             _proto.surfaces.extend(self.surfaces)
         if self.deformed_coords_id is not None:
@@ -44,7 +44,7 @@ class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
         return _proto
 
     def _from_proto(self, proto: clientpb.Adjoint) -> None:
-        self.output = proto.adjoint_output
+        self._output = proto.adjoint_output
         self.surfaces.extend(proto.surfaces)
         self.deformed_coords_id = proto.deformed_coords_id
         self.primal_simulation_id = proto.primal_simulation_id

luminarycloud/params/simulation/material/material_fluid_.py

@@ -85,7 +85,7 @@ class MaterialFluid(CodeRepr, ParamGroupWrapper[clientpb.MaterialFluid]):
     "Model for the laminar thermal conductivity of a fluid. Possible types: ``PrescribedPrandtlNumber``, ``PrescribedConductivity``, ``TemperatureDependentConductivity`` from the ``thermal_conductivity_model`` module."
     boussinesq_approximation: BoussinesqApproximation = field(default_factory=BoussinesqOn)
     "Introduce a body force due to thermal expansion without modifying the material density. Possible types: ``BoussinesqOff``, ``BoussinesqOn`` from the ``boussinesq_approximation`` module."
-    preset: enum.MaterialFluidPreset = enum.MaterialFluidPreset.CUSTOM_MATERIAL_FLUID
+    preset: enum.MaterialFluidPreset = enum.MaterialFluidPreset.STANDARD_AIR
     "Select a predefined set of material properties or allow a custom set of properties."
     viscosity_model: ViscosityModel = field(default_factory=Sutherland)
     "Models available for the dynamic viscosity of the fluid. Possible types: ``Sutherland``, ``PrescribedViscosity``, ``TemperatureDependentViscosity`` from the ``viscosity_model`` module."

luminarycloud/params/simulation/material/material_solid_.py

@@ -30,7 +30,7 @@ class MaterialSolid(CodeRepr, ParamGroupWrapper[clientpb.MaterialSolid]):
     "The thermal conductivity of the material."
     thermal_conductivity_table: RectilinearTable | None = None
     "Correlation between thermal conductivity and temperature."
-    preset: enum.MaterialSolidPreset = enum.MaterialSolidPreset.CUSTOM_MATERIAL_SOLID
+    preset: enum.MaterialSolidPreset = enum.MaterialSolidPreset.ALUMINUM
     "Select a predefined set of material properties or allow a custom set of properties."
 
     def _to_proto(self) -> clientpb.MaterialSolid:

luminarycloud/params/simulation/output_.py

@@ -22,7 +22,7 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 class Output(CodeRepr, ParamGroupWrapper[clientpb.Output]):
     """Solution output settings."""
 
-    iters_per_output: int = 1000
+    iters_per_output: int = 0
     "Number of (pseudo) timesteps between successive full solution output. If ≤0, only the final solution is written."
     include_residuals: bool = False
     "Include the residuals for each equation in the volume solution."

luminarycloud/params/simulation/physics/fluid/initialization/fluid_existing_solution_.py

@@ -19,6 +19,10 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 
 from luminarycloud.params.simulation.physics.fluid.initialization_fluid_ import InitializationFluid
 from luminarycloud.params.simulation.physics.fluid.initialization_fluid_ import *
+from luminarycloud.params.simulation.physics.fluid.initialization.turbulence_initialization_ import (
+    TurbulenceInitialization,
+)
+from luminarycloud.params.simulation.physics.fluid.initialization.turbulence_initialization_ import *
 
 
 @dataclass(kw_only=True)
@@ -27,16 +31,40 @@ class FluidExistingSolution(InitializationFluid):
 
     solution_id: str = ""
     "ID for the existing solution to use for initialization."
+    turbulence: TurbulenceInitialization = field(default_factory=TurbulenceInitialization)
+    ""
 
     def _to_proto(self) -> clientpb.InitializationFluid:
         _proto = super()._to_proto()
         _proto.initialization_type = clientpb.InitializationType.EXISTING_SOLUTION
         if self.solution_id is not None:
             _proto.existing_solution_id = self.solution_id
+        _proto.turbulent_variable_initialization_type_sa = self.turbulence.spalart_allmaras.value
+        _proto.turbulent_variable_initialization_type_komega = self.turbulence.komega.value
+        _proto.init_turbulent_viscosity_ratio.CopyFrom(
+            _to_ad_proto(self.turbulence.viscosity_ratio)
+        )
+        _proto.init_turbulent_viscosity.CopyFrom(_to_ad_proto(self.turbulence.viscosity))
+        _proto.init_turbulence_intensity.CopyFrom(_to_ad_proto(self.turbulence.intensity))
+        _proto.uniform_nu_tilde.CopyFrom(_to_ad_proto(self.turbulence.sa_variable))
+        _proto.uniform_tke.CopyFrom(_to_ad_proto(self.turbulence.tke))
+        _proto.uniform_omega.CopyFrom(_to_ad_proto(self.turbulence.omega))
         return _proto
 
     def _from_proto(self, proto: clientpb.InitializationFluid) -> None:
         super()._from_proto(proto)
         assert proto.initialization_type == clientpb.InitializationType.EXISTING_SOLUTION
         self.solution_id = proto.existing_solution_id
+        self.turbulence.spalart_allmaras = enum.TurbulentVariableInitializationTypeSa(
+            proto.turbulent_variable_initialization_type_sa
+        )
+        self.turbulence.komega = enum.TurbulentVariableInitializationTypeKomega(
+            proto.turbulent_variable_initialization_type_komega
+        )
+        self.turbulence.viscosity_ratio = _from_ad_proto(proto.init_turbulent_viscosity_ratio)
+        self.turbulence.viscosity = _from_ad_proto(proto.init_turbulent_viscosity)
+        self.turbulence.intensity = _from_ad_proto(proto.init_turbulence_intensity)
+        self.turbulence.sa_variable = _from_ad_proto(proto.uniform_nu_tilde)
+        self.turbulence.tke = _from_ad_proto(proto.uniform_tke)
+        self.turbulence.omega = _from_ad_proto(proto.uniform_omega)
         return None

luminarycloud/params/simulation/physics/fluid/solution_controls/fluid_relaxation_method/fluid_implicit_relaxation/robust_startup/__init__.py

@@ -1,2 +1,3 @@
+from .robust_startup_auto_ import RobustStartupAuto
 from .robust_startup_off_ import RobustStartupOff
 from .robust_startup_on_ import RobustStartupOn

luminarycloud/params/simulation/physics/fluid/solution_controls/fluid_relaxation_method/fluid_implicit_relaxation/robust_startup/robust_startup_auto_.py

@@ -0,0 +1,30 @@
+# 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.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup_ import (
+    RobustStartup,
+)
+from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup_ import *
+
+
+@dataclass(kw_only=True)
+class RobustStartupAuto(RobustStartup):
+    """Enable robust startup mode and automatically determine the settings."""
+
+    pass

luminarycloud/params/simulation/physics/fluid/solution_controls/fluid_relaxation_method/fluid_implicit_relaxation/robust_startup/robust_startup_on_.py

@@ -25,7 +25,7 @@ from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relax
 
 @dataclass(kw_only=True)
 class RobustStartupOn(RobustStartup):
-    """Enable robust startup mode."""
+    """Enable robust startup mode and manually specify the settings."""
 
     robust_startup_initial_cfl: LcFloat = 1.0
     "Initial CFL number for robust startup mode. The CFL is ramped toward the target value during startup."

luminarycloud/params/simulation/physics/fluid/solution_controls/fluid_relaxation_method/fluid_implicit_relaxation_.py

@@ -37,6 +37,10 @@ from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relax
     RobustStartup,
 )
 from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup_ import *
+from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup.robust_startup_auto_ import (
+    RobustStartupAuto,
+)
+from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup.robust_startup_auto_ import *
 from luminarycloud.params.simulation.physics.fluid.solution_controls.fluid_relaxation_method.fluid_implicit_relaxation.robust_startup.robust_startup_off_ import (
     RobustStartupOff,
 )
@@ -63,8 +67,8 @@ class FluidImplicitRelaxation(FluidRelaxationMethod):
     "How many iterations in between updating the Jacobian values for implicit solving."
     jacobian_warmup_threshold: int = 300
     "How many iterations to update Jacobians every iteration before switching to the specified 'Jacobian Update Interval'."
-    robust_startup: RobustStartup = field(default_factory=RobustStartupOn)
-    "Applies a robust startup process during the initial transients of a simulation. Applicable to steady problems only. Possible types: ``RobustStartupOn``, ``RobustStartupOff`` from the ``robust_startup`` module."
+    robust_startup: RobustStartup = field(default_factory=RobustStartupAuto)
+    "Applies a robust startup process during the initial transients of a simulation. Applicable to steady problems only. Possible types: ``RobustStartupOn``, ``RobustStartupAuto``, ``RobustStartupOff`` from the ``robust_startup`` module."
     relaxation_flow: LcFloat = 1.0
     "Under-relaxation factor in [0,1] applied to the mean flow solution update with each implicit nonlinear iteration. Default of 1.0."
     relaxation_turb: LcFloat = 0.5

luminarycloud/params/simulation/physics/fluid/solution_controls_fluid_.py

@@ -122,6 +122,8 @@ class SolutionControlsFluid(CodeRepr, ParamGroupWrapper[clientpb.SolutionControl
                 _proto.robust_startup_iterations.value = (
                     self.fluid_relaxation_method.robust_startup.robust_startup_iterations
                 )
+            if isinstance(self.fluid_relaxation_method.robust_startup, RobustStartupAuto):
+                _proto.robust_startup = clientpb.ROBUST_STARTUP_AUTO
             if isinstance(self.fluid_relaxation_method.robust_startup, RobustStartupOff):
                 _proto.robust_startup = clientpb.ROBUST_STARTUP_OFF
             _proto.relax_flow.CopyFrom(_to_ad_proto(self.fluid_relaxation_method.relaxation_flow))
@@ -211,6 +213,8 @@ class SolutionControlsFluid(CodeRepr, ParamGroupWrapper[clientpb.SolutionControl
                 self.fluid_relaxation_method.robust_startup.robust_startup_iterations = (
                     proto.robust_startup_iterations.value
                 )
+            elif proto.robust_startup == clientpb.ROBUST_STARTUP_AUTO:
+                self.fluid_relaxation_method.robust_startup = RobustStartupAuto()
             elif proto.robust_startup == clientpb.ROBUST_STARTUP_OFF:
                 self.fluid_relaxation_method.robust_startup = RobustStartupOff()
             self.fluid_relaxation_method.relaxation_flow = _from_ad_proto(proto.relax_flow)

luminarycloud/params/simulation/simulation_param_.py

@@ -77,6 +77,8 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
     "Body frame."
     surface_name: dict[str, SurfaceName] = field(default_factory=dict)
     "Surface name map."
+    _table_references: dict[str, Any] = field(default_factory=dict)
+    "Solution inputs - metadata for general n-dimensional rectilinear grid data (Monitor points, radial distribution, blade geometry, airfoil performance)."
     output: Output = field(default_factory=Output)
     "Solution output settings."
     entity_relationships: EntityRelationships = field(default_factory=EntityRelationships)
@@ -115,6 +117,9 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
         if self.surface_name is not None:
             for k, v in self.surface_name.items():
                 _proto.surface_name[k].CopyFrom(v._to_proto())
+        if self._table_references is not None:
+            for k, v in self._table_references.items():
+                _proto.table_references[k].CopyFrom(v)
         if self.output is not None:
             _proto.output.CopyFrom(self.output._to_proto())
         if self.entity_relationships is not None:
@@ -140,6 +145,7 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
         self.monitor_plane = [MonitorPlane.from_proto(v) for v in proto.monitor_plane]
         self.body_frame = BodyFrame.from_proto(proto.body_frame)
         self.surface_name = {k: SurfaceName.from_proto(v) for k, v in proto.surface_name.items()}
+        self._table_references.update(proto.table_references)
         self.output = Output.from_proto(proto.output)
         self.entity_relationships = EntityRelationships.from_proto(proto.entity_relationships)
         self.adaptive_mesh_refinement = AdaptiveMeshRefinement.from_proto(

luminarycloud/physics_ai/__init__.py

@@ -8,3 +8,7 @@ from .models import (
     PhysicsAiModel as PhysicsAiModel,
     PhysicsAiModelVersion as PhysicsAiModelVersion,
 )
+
+from .solution import (
+    _download_processed_solution_physics_ai as _download_processed_solution_physics_ai,
+)

luminarycloud/physics_ai/inference.py

@@ -1,30 +1,165 @@
 # File: python/sdk/luminarycloud/inference/inference.py
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
 from datetime import datetime
-from typing import Any
+from typing import Any, Callable
 from json import loads as json_loads
+from dataclasses import dataclass
+import base64
+import os
+import urllib.request
 
 from .._client import get_default_client
 from .._helpers._timestamp_to_datetime import timestamp_to_datetime
 from .._proto.api.v0.luminarycloud.inference import inference_pb2 as inferencepb
 from .._proto.inferenceservice import inferenceservice_pb2 as inferenceservicepb
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
+from ..project import Project
 from .._helpers.warnings import experimental
+from ..project import Project
+from .._helpers import upload_file
+from .._proto.upload import upload_pb2 as uploadpb
+
+
+@dataclass
+class ExtAeroInferenceResult:
+    """Result of an external aerodynamic inference job.
+
+    Attributes
+    ----------
+    drag_force: float
+        The drag force returned from the inference.
+    lift_force: float
+        The lift force returned from the inference.
+    wall_shear_stress:
+        A dict containing wall shear stress data, or None if not available.
+    pressure_surface:
+        A dict containing pressure surface stress data, or None if not available.
+    """
+
+    drag_force: float
+    lift_force: float
+    wall_shear_stress: dict[str, Any] | None
+    pressure_surface: dict[str, Any] | None
+
+    def __init__(self, inference_result: dict[str, Any]) -> None:
+        self.drag_force = inference_result["drag_force"]
+        self.lift_force = inference_result["lift_force"]
+        self.wall_shear_stress = inference_result.get("wall-shear-stress", None)
+        self.pressure_surface = inference_result.get("pressure_surface", None)
+
+
+@experimental
+def external_aero_inference(
+    project: Project, stl_file: str, checkpoint_file: str, config_name: str, stencil_size: int
+) -> ExtAeroInferenceResult:
+    """Performs an inference job returning external aerodynamic results.
+    Parameters
+    ----------
+    project : Project
+        The project to which the inference files will be added.
+    stl_file : str
+        Fullpath the STL file to be used for inference.
+    checkpoint_file : str
+        Fullpath of the model to be used for inference.
+    config_name :str
+        Name of the configuration to be used for inference.
+    stencil_size :int
+        Size of the stencil to be used for inference.
+
+    Returns
+    ExtAeroInferenceResult
+        Result of the external aerodynamic inference job.
+
+    warning:: This feature is experimental and may change or be removed without notice.
+    """
+
+    result = perform_inference(project, stl_file, checkpoint_file, config_name, stencil_size)
+    return ExtAeroInferenceResult(result)
+
+
+@experimental
+def perform_inference(
+    project: Project, stl_file: str, checkpoint_file: str, config_name: str, stencil_size: int
+) -> dict[str, Any]:
+    """Creates an inference service job.
+    Parameters
+    ----------
+    project : Project
+        The project to which the inference files will be added.
+    stl_file : str
+        Fullpath the STL file to be used for inference.
+    checkpoint_file : str
+        Fullpath of the model to be used for inference.
+    config_name :str
+        Name of the configuration to be used for inference.
+    stencil_size :int
+        Size of the stencil to be used for inference.
+
+
+    Returns
+    dict[str, Any]
+        Response from the server as key-value pairs.
+
+    warning:: This feature is experimental and may change or be removed without notice.
+    """
+
+    client = get_default_client()
+
+    def upload_if_file(fname: str) -> str:
+        if os.path.exists(fname) and os.path.isfile(fname):
+            params = uploadpb.ResourceParams()
+            result = upload_file(client, project.id, params, fname)
+            return result[1].url
+        if fname.startswith("gs://"):
+            return fname
+        raise RuntimeError("Unsupported file for inference")
+
+    def future_file(url: str) -> Callable[[], dict[str, Any]]:
+        def download_file() -> dict[str, Any]:
+            with urllib.request.urlopen(url) as f:
+                serialized = f.read()
+                jsondata = json_loads(serialized)
+                data = base64.b64decode(jsondata["data"])
+                jsondata["data"] = data
+                return jsondata
+
+        return download_file
+
+    stl_url = upload_if_file(stl_file)
+    check_url = upload_if_file(checkpoint_file)
+
+    raw = start_inference_job(project, stl_url, check_url, config_name, stencil_size)
+    currated: dict[str, Any] = {}
+    for k, v in raw.items():
+        if isinstance(v, str) and v.startswith("https://"):
+            tmp = future_file(v)
+            if k.endswith("_url"):
+                currated[k[:-4]] = tmp
+                currated[k] = v
+            else:
+                currated[k] = tmp
+                currated[k + "_url"] = v
+        else:
+            currated[k] = v
+    return currated
 
 
 @experimental
 def start_inference_job(
+    project: Project,
     stl_url: str,
-    model_url: str,
+    checkpoint_url: str,
     config_name: str,
     stencil_size: int,
 ) -> dict[str, Any]:
     """Creates an inference service job.
     Parameters
     ----------
+    project : Project
+        Reference to a project.
     stl_url : str
         URL of the STL file to be used for inference.
-    model_url : str
+    checkpoint_url : str
         URL of the model to be used for inference.
     config_name :str
         Name of the configuration to be used for inference.
@@ -41,9 +176,10 @@ def start_inference_job(
 
     req = inferencepb.CreateInferenceServiceJobRequest(
         stl_url=stl_url,
-        model_url=model_url,
+        checkpoint_url=checkpoint_url,
         config_name=config_name,
         stencil_size=stencil_size,
+        project_id=project.id,
     )
 
     res: inferencepb.CreateInferenceServiceJobResponse = (

luminarycloud/physics_ai/solution.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import tarfile
+from typing import List, Optional, BinaryIO, cast
+
+from .._client import get_default_client
+from .._helpers.warnings import experimental
+from .._helpers.download import download_solution_physics_ai as _download_solution_physics_ai
+from ..enum.quantity_type import QuantityType
+
+
+@experimental
+def _download_processed_solution_physics_ai(  # noqa: F841
+    solution_id: str,
+    exclude_surfaces: Optional[List[str]] = None,
+    fill_holes: float = -1.0,
+    surface_fields_to_keep: Optional[List[QuantityType]] = None,
+    volume_fields_to_keep: Optional[List[QuantityType]] = None,
+    process_volume: bool = False,
+    single_precision: bool = True,
+) -> tarfile.TarFile:
+    """
+    Download solution data with physics AI processing applied.
+
+    Returns a compressed archive containing processed solution files including
+    merged surfaces (VTP/STL) and optionally volume data (VTU).
+
+    Args:
+        solution_id: ID of the solution to download
+        exclude_surfaces: List of surface names to exclude from processing
+        fill_holes: Sets the maximum size of the hole to be filled for the STL file, measured as the radius of the bounding circumsphere.
+            If fill_holes is negative or zero, no holes will be filled.
+        surface_fields_to_keep: List of QuantityType enum values for surface fields to keep in output.
+            If None, all available surface fields are included.
+        volume_fields_to_keep: List of QuantityType enum values for volume fields to keep in output.
+            If None, all available volume fields are included.
+        process_volume: Whether to process volume data
+        single_precision: Whether to use single precision for floating point fields
+
+    Raises:
+        ValueError: If invalid field names are provided
+    """
+
+    stream = _download_solution_physics_ai(
+        get_default_client(),
+        solution_id,
+        exclude_surfaces=exclude_surfaces,
+        fill_holes=fill_holes,
+        surface_fields_to_keep=surface_fields_to_keep,
+        volume_fields_to_keep=volume_fields_to_keep,
+        process_volume=process_volume,
+        single_precision=single_precision,
+    )
+
+    assert stream is not None, "Failed to download solution data"
+    return tarfile.open(
+        name=stream.filename,
+        fileobj=cast(BinaryIO, stream),
+        mode="r|gz",
+    )

luminarycloud/project.py

@@ -39,6 +39,7 @@ from ._proto.api.v0.luminarycloud.simulation_template import (
     simulation_template_pb2 as simtemplatepb,
 )
 from ._proto.client import simulation_pb2 as clientpb
+from ._proto.table import table_pb2 as tablepb
 from ._proto.hexmesh import hexmesh_pb2 as hexmeshpb
 from ._proto.upload import upload_pb2 as uploadpb
 from ._wrapper import ProtoWrapper, ProtoWrapperBase
@@ -440,13 +441,14 @@ class Project(ProtoWrapperBase):
             raise RuntimeError("The table upload failed.")
 
         # Update the simulation template with the new table reference.
-        params: clientpb.SimulationParam = simulation_template._proto.parameters
-        params.table_references[name].url = url
-        params.table_references[name].table_type = table_type.value
-        params.table_references[name].uploaded_filename = uploaded_filename
-        simulation_template._update(name=simulation_template.name, parameters=params)
-
-        return RectilinearTable(id=name, name=uploaded_filename, table_type=table_type)
+        params: SimulationParam = simulation_template.get_parameters()
+        params._table_references[name] = tablepb.Metadata()
+        params._table_references[name].url = url
+        params._table_references[name].table_type = table_type.value
+        params._table_references[name].uploaded_filename = uploaded_filename
+        simulation_template.update(parameters=params)
+        # The name is lost in to/from proto conversions so make it equal to the id for consistency.
+        return RectilinearTable(id=name, name=name, table_type=table_type)
 
     @experimental
     def set_surface_deformation(