luminarycloud 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

luminarycloud/simulation_param.py

@@ -9,6 +9,7 @@ from typing import Optional, TypeVar, cast
 import luminarycloud.params.enum._enum_wrappers as enum
 from luminarycloud._helpers._simulation_params_from_json import (
     simulation_params_from_json_path,
+    simulation_params_from_json_dict,
 )
 from luminarycloud._helpers.warnings import experimental
 from luminarycloud._proto.client import simulation_pb2 as clientpb
@@ -46,7 +47,29 @@ logger = getLogger(__name__)
 
 @dataclass(kw_only=True, repr=False)
 class SimulationParam(_SimulationParam):
-    """Simulation configuration that supports multiple physics."""
+    """
+    Solver configuration parameters that support multi-physics simulations.
+
+    The structure of these parameters is related to the decision tree of selecting different models,
+    boundary conditions, etc. for the simulation.
+    Most of these choices are made by picking one class for a given field over a number of
+    alternatives. For example:
+
+    >>> import luminarycloud.params.simulation as sim_params
+    >>> params = SimulationParam()
+    >>> params.physics[0].fluid.turbulence = sim_params.physics.fluid.turbulence.KomegaSst()
+    >>> params.physics[0].fluid.turbulence = sim_params.physics.fluid.turbulence.SpalartAllmaras()
+
+    The alternatives are listed in the documentation of each field (turbulence in this case), and
+    the (sub)module that provides them is always named after the field.
+    Therefore, even without consulting the documentation, it is possible to list the alternatives
+    using Python's ``dir`` function, in this case:
+
+    >>> dir(sim_params.physics.fluid.turbulence)
+
+    The alternative classes have different fields, which may again have their own alternative
+    classes thereby repeating the pattern and creating the tree structure.
+    """
 
     reference_values: ReferenceValues = field(default_factory=ReferenceValues)
     "Reference values for outputs and stopping conditions."
@@ -56,30 +79,67 @@ class SimulationParam(_SimulationParam):
 
     def _to_proto(self) -> clientpb.SimulationParam:
         _proto = super()._to_proto()
-        transient = self.basic is not None and self.basic.time == enum.FlowBehavior.TRANSIENT
-        if self.reference_values.reference_value_type == ReferenceValuesType.FARFIELD_VALUES:
-            raise ValueError(
-                "ReferenceValuesType.FARFIELD_VALUES cannot be used in SimulationParam yet."
-            )
-        self.reference_values._to_proto_common(_proto.reference_values)
+        _proto.reference_values.CopyFrom(self.reference_values._to_client_proto())
         return _proto
 
     @classmethod
     def from_proto(self, proto: clientpb.SimulationParam) -> "SimulationParam":
         _wrapper = cast(SimulationParam, super().from_proto(proto))
-        transient = (
-            _wrapper.basic is not None and _wrapper.basic.time == enum.FlowBehavior.TRANSIENT
-        )
-        _wrapper.reference_values._from_proto_common(proto.reference_values)
+        _wrapper.reference_values._from_client_proto(proto.reference_values)
         return _wrapper
 
     @classmethod
-    def from_json(cls, path: PathLike) -> "SimulationParam":
-        return cls.from_proto(simulation_params_from_json_path(path))
+    def from_json(cls, source: PathLike | dict) -> "SimulationParam":
+        if isinstance(source, PathLike):
+            return cls.from_proto(simulation_params_from_json_path(source))
+        else:
+            return cls.from_proto(simulation_params_from_json_dict(source))
 
     def assign_material(self, material: MaterialEntity, volume: Volume | str) -> None:
         """
-        Assigns a material entity to a volume ID.
+        Assigns a material entity to a volume.
+
+        This method links a material entity to a specific volume in the simulation domain.
+        If the volume or material entity has not been added to the simulation parameters yet,
+        they will be added automatically.
+
+        Parameters
+        ----------
+        material : MaterialEntity
+            The material entity to assign to the volume. This is typically created using
+            lc.params.simulation.MaterialEntity.
+        volume : Volume | str
+            The volume to assign the material to. Can be a Volume object or a string
+            representing the volume ID.
+
+        Examples
+        --------
+        Using volumes from list_tags():
+
+        >>> # Get the fluid volume from tags
+        >>> tags = geometry.list_tags()
+        >>> # Assume the fluid volume is tagged with "Fluid"
+        >>> fluid_volume_tag_name = "Fluid"
+        >>> fluid_tag = next(
+        ...     (tag for tag in tags if tag.name == fluid_volume_tag_name and tag.volumes), None
+        ... )
+        >>> if fluid_tag:
+        ...     # Assume we want to assign the material to the first volume in the tag
+        ...     for fluid_volume in fluid_tag.volumes:
+        ...         simulation_param.assign_material(material, fluid_volume)
+        >>> else:
+        ...     raise ValueError("No fluid volume found")
+
+        Using volumes from list_entities():
+
+        >>> # Get the fluid volume from list_entities()
+        >>> surfaces, volumes = geometry.list_entities()
+        >>> if volumes:
+        ...     # Assume we want to assign the material to the first volume in the list
+        ...     fluid_volume_to_assign = volumes[0]
+        ...     simulation_param.assign_material(material, fluid_volume_to_assign)
+        >>> else:
+        ...     raise ValueError("No fluid volume found")
         """
         volume_identifier = EntityIdentifier()
         if isinstance(volume, str):
@@ -112,7 +172,49 @@ class SimulationParam(_SimulationParam):
 
     def assign_physics(self, physics: Physics, volume: Volume | str) -> None:
         """
-        Assigns a physics entity to a volume ID.
+        Assigns a physics entity to a volume.
+
+        This method links a physics entity to a specific volume in the simulation domain.
+        If the volume or physics entity has not been added to the simulation parameters yet,
+        they will be added automatically.
+
+        Parameters
+        ----------
+        physics : Physics
+            The physics entity to assign to the volume. This is typically created using
+            lc.params.simulation.Physics.
+        volume : Volume | str
+            The volume to assign the physics to. Can be a Volume object or a string
+            representing the volume ID.
+
+        Examples
+        --------
+        Using volumes from list_tags():
+
+        >>> # Get the fluid volume from tags
+        >>> tags = geometry.list_tags()
+        >>> # Assume the fluid volume is tagged with "Fluid"
+        >>> fluid_volume_tag_name = "Fluid"
+        >>> fluid_tag = next(
+        ...     (tag for tag in tags if tag.name == fluid_volume_tag_name and tag.volumes), None
+        ... )
+        >>> if fluid_tag:
+        ...     # Assume we want to assign the physics to the first volume in the tag
+        ...     for fluid_volume in fluid_tag.volumes:
+        ...         simulation_param.assign_physics(physics, fluid_volume)
+        >>> else:
+        ...     raise ValueError("No fluid volume found")
+
+        Using volumes from list_entities():
+
+        >>> # Get the fluid volume from list_entities()
+        >>> surfaces, volumes = geometry.list_entities()
+        >>> if volumes:
+        ...     # Assume we want to assign the physics to the first volume in the list
+        ...     fluid_volume_to_assign = volumes[0]
+        ...     simulation_param.assign_physics(physics, fluid_volume_to_assign)
+        >>> else:
+        ...     raise ValueError("No fluid volume found")
         """
         if isinstance(volume, str):
             volume_identifier = EntityIdentifier(id=volume)
@@ -206,16 +308,17 @@ class SimulationParam(_SimulationParam):
     def __repr__(self) -> str:
         return pformat(vars(self), compact=True, sort_dicts=True)
 
-    def to_code(self) -> str:
+    def to_code(self, hide_defaults: bool = True) -> str:
         """
         Returns the python code that generates an identical SimulationParam object.
-        This is a verbose representation where every parameter is set, even if its value
-        corresponds to the default, or a preset would override the value.
+        This is a verbose representation that does not make use of helper functions like
+        assign_material and assign_physics.
+        Parameters with default values are omitted by default, with hide_defaults=False, code will
+        also be generated for those parameters.
         """
         code = """## NOTE: This is a verbose representation of a SimulationParam object as the
 ## code that creates an identical object. The verbosity is intended to facilitate
-## the discovery of available parameters. However, note that when presets are used
-## (e.g. for material properties) some lines of this representation become redundant.
+## the discovery of available parameters.
 import luminarycloud
 from luminarycloud import *
 from luminarycloud.types import Vector3
@@ -224,16 +327,20 @@ from luminarycloud.params.enum import *
 from luminarycloud.params import simulation as params
 
 
-obj = SimulationParam()
 """
-        for line in _SimulationParam.to_code(self).split("\n")[1:]:
-            if line.startswith("new_") or line.startswith("#"):
-                code += f"{line}\n"
-            elif line.startswith(".new_"):
-                code += f"{line[1:]}\n"
-            elif line:
-                code += f"obj{line}\n"
-        return code
+        return code + self._to_code_helper("obj", hide_defaults).replace(
+            "luminarycloud.simulation_param.SimulationParam()", "SimulationParam()", 1
+        )
+
+    def find_parameter(self, parameter: str) -> None:
+        """
+        Searches the full output of "to_code()" for occurrences of "parameter" and prints the lines
+        with matches. This is a helper function to assist users in finding, for example, how to
+        change farfield conditions, material properties, etc.
+        """
+        for i, line in enumerate(self.to_code(False).split("\n")):
+            if parameter.lower() in line.lower():
+                print(f"line {i}: {line}")
 
 
 T = TypeVar("T")

luminarycloud/simulation_template.py

@@ -8,7 +8,7 @@ from difflib import Differ
 from .enum import (
     TableType,
 )
-from ._helpers.warnings import experimental
+from ._helpers.warnings import experimental, deprecated
 from ._client import get_default_client
 from ._helpers._simulation_params_from_json import simulation_params_from_json_path
 from ._helpers._timestamp_to_datetime import timestamp_to_datetime
@@ -60,8 +60,6 @@ class SimulationTemplate(ProtoWrapperBase):
     "Simulation template ID."
     name: str
     "Simulation name."
-    parameters: clientpb.SimulationParam
-    "Simulation description."
 
     _proto: simtemplatepb.SimulationTemplate
 
@@ -77,7 +75,7 @@ class SimulationTemplate(ProtoWrapperBase):
         self,
         *,
         name: Optional[str] = None,
-        parameters: Optional[Union[clientpb.SimulationParam, SimulationParam, PathLike]] = None,
+        parameters: Optional[SimulationParam | PathLike] = None,
     ) -> None:
         """
         Update simulation template.
@@ -92,6 +90,17 @@ class SimulationTemplate(ProtoWrapperBase):
             changes applied by the backend (server), for example due to presets. Any differences
             between input and result are printed on screen.
         """
+        return self._update(name=name, parameters=parameters)
+
+    def _update(
+        self,
+        *,
+        name: Optional[str] = None,
+        parameters: Optional[SimulationParam | clientpb.SimulationParam | PathLike] = None,
+    ) -> None:
+        """
+        Update simulation template. See `update()` for more details.
+        """
         req = simtemplatepb.UpdateSimulationTemplateRequest(id=self.id)
 
         if name is not None:
@@ -110,12 +119,14 @@ class SimulationTemplate(ProtoWrapperBase):
                 # Table references are manipulated via the simulation template, hence we need to persist
                 # them when we update the parameters.
                 param_proto.table_references.clear()
-                for k, v in self.parameters.table_references.items():
+                for k, v in self._proto.parameters.table_references.items():
                     param_proto.table_references[k].CopyFrom(v)
 
             req.parameters.CopyFrom(param_proto)
 
-        res = get_default_client().UpdateSimulationTemplate(req)
+        res: simtemplatepb.UpdateSimulationTemplateResponse = (
+            get_default_client().UpdateSimulationTemplate(req)
+        )
         self._proto = res.simulation_template
 
         def print_diff(
@@ -134,11 +145,11 @@ class SimulationTemplate(ProtoWrapperBase):
         # Show any inconsistency after the update and update the input argument.
         if isinstance(parameters, SimulationParam):
             old_param = deepcopy(parameters)
-            parameters._from_proto(self.parameters)
+            parameters._from_proto(self._proto.parameters)
             print_diff(old_param, parameters)
         elif isinstance(parameters, clientpb.SimulationParam):
-            print_diff(parameters, self.parameters)
-            parameters.CopyFrom(self.parameters)
+            print_diff(parameters, self._proto.parameters)
+            parameters.CopyFrom(self._proto.parameters)
 
     def delete(self) -> None:
         """
@@ -147,12 +158,17 @@ class SimulationTemplate(ProtoWrapperBase):
         req = simtemplatepb.DeleteSimulationTemplateRequest(id=self.id)
         get_default_client().DeleteSimulationTemplate(req)
 
+    def get_parameters(self) -> SimulationParam:
+        return self.get_simulation_param()
+
+    @deprecated(
+        "Use get_parameters() instead. This method will be removed in a future release.",
+    )
     def get_simulation_param(self) -> SimulationParam:
         """
-        Returns the simulation parameters associated with this template to allow customization of
-        the parameters.
+        Returns a copy of the simulation parameters associated with this template.
         """
-        return SimulationParam.from_proto(self.parameters)
+        return SimulationParam.from_proto(self._proto.parameters)
 
     def list_tables(
         self,
@@ -172,7 +188,7 @@ class SimulationTemplate(ProtoWrapperBase):
             List of tables.
         """
         res: list[RectilinearTable] = []
-        for id, metadata in self.parameters.table_references.items():
+        for id, metadata in self._proto.parameters.table_references.items():
             if table_type is None or table_type.value == metadata.table_type:
                 res.append(
                     RectilinearTable(
@@ -442,6 +458,61 @@ class SimulationTemplate(ProtoWrapperBase):
             self.id, max_iterations, max_physical_time, max_inner_iterations, stop_on_any
         )
 
+    def to_code(self, hide_defaults: bool = True) -> str:
+        """
+        Returns the python code that generates an identical SimulationTemplate object.
+        By default parameters with default values are omitted, this change be changed with
+        hide_defaults=False.
+        """
+        param_code = self.get_simulation_param().to_code(hide_defaults)
+        code, param_code = param_code.split("\n\n\n")
+
+        # Modify the header note included by SimulationParam.to_code.
+        code = code.replace("SimulationParam", "SimulationTemplate")
+        code += "\n\n\n"
+        code += '# Create a new simulation template or modify the "Setup" template.\n'
+        code += 'project = get_project("...")\n'
+        code += f"# template = project.create_simulation_template(name={self.name})\n"
+        code += "template = project.list_simulation_templates()[0]\n\n"
+
+        code += "# Define the simulation parameters.\n"
+        code += param_code
+        code += "\n# Update the simulation template with the parameters.\n"
+        code += "template.update(parameters=obj)\n\n"
+
+        code += "# Define the outputs for monitoring simulations.\n"
+        code += "# This assumes the outputs do not exist yet, to modify an exiting output use\n"
+        code += "# update_output_definition instead of create_output_definition, the former\n"
+        code += "# requires the definition ID, that is obtained from list_output_definitions.\n"
+        output_definitions = self.list_output_definitions()
+        for i, definition in enumerate(output_definitions):
+            if i == 0:
+                code += "outputs = []\n"
+            output_code = definition._to_code_helper("new_output", hide_defaults)
+            for line in output_code.split("\n"):
+                # Omit ID because we are generating for create_output_definition.
+                if line and not line.startswith("new_output.id"):
+                    code += f"{line}\n"
+            code += "outputs.append(template.create_output_definition(new_output))\n\n"
+
+        code += "# Define the basic and output-based stopping conditions.\n"
+        gsc = self.get_general_stopping_conditions()
+        code += f"template.update_general_stopping_conditions({gsc.max_iterations}, "
+        code += f"{gsc.max_physical_time}, {gsc.max_inner_iterations}, {gsc.stop_on_any})\n"
+
+        for i, sc in enumerate(self.list_stopping_conditions()):
+            if i == 0:
+                code += "\n# Output-based conditions require the ID of the associated output.\n"
+            # Find the old output to use the new ID created by create_output_definition.
+            for j, od in enumerate(output_definitions):
+                if sc.output_definition_id == od.id:
+                    code += f"template.create_or_update_stopping_condition(outputs[{j}].id, "
+                    code += f"{sc.threshold}, {sc.start_at_iteration}, {sc.averaging_iterations}, "
+                    code += f"{sc.iterations_to_consider})\n"
+                    break
+
+        return code
+
 
 def get_simulation_template(id: SimulationTemplateID) -> SimulationTemplate:
     """

luminarycloud/solution.py

@@ -6,11 +6,13 @@ from os import PathLike
 import luminarycloud as lc
 
 from ._client import get_default_client
+from ._helpers.warnings import experimental
 from ._helpers.download import (
     download_surface_solution,
     download_volume_solution,
     download_surface_deformation_template,
     download_surface_sensitivity_data,
+    download_parameter_sensitivity_data,
 )
 from ._helpers.file_chunk_stream import FileChunkStream
 from ._proto.api.v0.luminarycloud.solution import solution_pb2 as solutionpb
@@ -131,7 +133,7 @@ class Solution(ProtoWrapperBase):
         Project.set_surface_deformation to create simulations with volume mesh morphing.
         """
         stream = download_surface_deformation_template(get_default_client(), self.id)
-        return _handle_surface_data_stream(stream, dst)
+        _handle_surface_data_stream(stream, dst)
 
     def download_surface_sensitivity_data(self, dst: Optional[PathLike] = None) -> None:
         """
@@ -142,4 +144,17 @@ class Solution(ProtoWrapperBase):
         The IDs of the sensitivity data are consistent with the node IDs of the surface deformation.
         """
         stream = download_surface_sensitivity_data(get_default_client(), self.id)
-        return _handle_surface_data_stream(stream, dst)
+        _handle_surface_data_stream(stream, dst)
+
+    @experimental
+    def download_parameter_sensitivity_data(self, dst: Optional[PathLike] = None) -> None:
+        """
+        Download the parameter sensitivity data associated with an adjoint solution into the
+        destination file or into a default-named file. The data consists of parameter names and
+        sensitivity values (d "adjoint output" / d "SimulationParam parameter").
+
+        NOTE: This is a very experimental feature, likely to change in the future in favor of
+        including the sensitivities in a SimulationParam object directly.
+        """
+        stream = download_parameter_sensitivity_data(get_default_client(), self.id)
+        _handle_surface_data_stream(stream, dst)

luminarycloud/types/__init__.py

@@ -6,6 +6,7 @@ from .ids import (
     SolutionID as SolutionID,
     SimulationTemplateID as SimulationTemplateID,
     GeometryFeatureID as GeometryFeatureID,
+    NamedVariableSetID as NamedVariableSetID,
 )
 
 from .adfloat import (

luminarycloud/types/adfloat.py

@@ -1,19 +1,40 @@
+from abc import ABCMeta
 from typing import Any
 from .._proto.base.base_pb2 import AdFloatType, FirstOrderAdType, SecondOrderAdType
 
 
-class FirstOrderAdFloat(float):
+class AdFloat(float, metaclass=ABCMeta):
+    """An immutable float with adjoints/tangents"""
+
+    pass
+
+
+class FirstOrderAdFloat(AdFloat):
     """An immutable float with first order adjoints/tangents attached."""
 
-    tangent: tuple[float, ...]
-    adjoint: tuple[float, ...]
+    _tangent: tuple[float, ...]
+    _adjoint: tuple[float, ...]
 
     def __new__(cls: type["FirstOrderAdFloat"], value: float, *_: Any) -> "FirstOrderAdFloat":
         return super().__new__(cls, value)
 
     def __init__(self, value: float, tangent: tuple[float, ...], adjoint: tuple[float, ...]):
-        self.tangent = tuple(float(t) for t in tangent)
-        self.adjoint = tuple(float(a) for a in adjoint)
+        if isinstance(value, AdFloat):
+            raise ValueError("Value cannot be an AdFloat")
+        if any(isinstance(t, AdFloat) for t in tangent):
+            raise ValueError("Tangent cannot be an AdFloat")
+        if any(isinstance(a, AdFloat) for a in adjoint):
+            raise ValueError("Adjoint cannot be an AdFloat")
+        self._tangent = tuple(float(t) for t in tangent)
+        self._adjoint = tuple(float(a) for a in adjoint)
+
+    @property
+    def tangent(self) -> tuple[float, ...]:
+        return self._tangent
+
+    @property
+    def adjoint(self) -> tuple[float, ...]:
+        return self._adjoint
 
     @staticmethod
     def _from_proto(proto: FirstOrderAdType) -> "FirstOrderAdFloat":
@@ -24,12 +45,12 @@ class FirstOrderAdFloat(float):
         )
 
 
-class SecondOrderAdFloat(float):
+class SecondOrderAdFloat(AdFloat):
     """An immutable float with second order adjoints/tangents attached."""
 
-    value: FirstOrderAdFloat
-    tangent: tuple[FirstOrderAdFloat, ...]
-    adjoint: tuple[FirstOrderAdFloat, ...]
+    _value: FirstOrderAdFloat
+    _tangent: tuple[FirstOrderAdFloat, ...]
+    _adjoint: tuple[FirstOrderAdFloat, ...]
 
     def __new__(cls, value: FirstOrderAdFloat, *_: Any) -> "SecondOrderAdFloat":
         return super().__new__(cls, value)
@@ -42,16 +63,25 @@ class SecondOrderAdFloat(float):
     ):
         if not isinstance(value, FirstOrderAdFloat):
             raise TypeError("Value must be a FirstOrderAdFloat")
-        for t in tangent:
-            if not isinstance(t, FirstOrderAdFloat):
-                raise TypeError("Tangent must be a tuple of FirstOrderAdFloat")
-        for a in adjoint:
-            if not isinstance(a, FirstOrderAdFloat):
-                raise TypeError("Adjoint must be a tuple of FirstOrderAdFloat")
-
-        self.value = value
-        self.tangent = tangent
-        self.adjoint = adjoint
+        if any(not isinstance(t, FirstOrderAdFloat) for t in tangent):
+            raise TypeError("Tangent must be a tuple of FirstOrderAdFloat")
+        if any(not isinstance(a, FirstOrderAdFloat) for a in adjoint):
+            raise TypeError("Adjoint must be a tuple of FirstOrderAdFloat")
+        self._value = value
+        self._tangent = tangent
+        self._adjoint = adjoint
+
+    @property
+    def value(self) -> FirstOrderAdFloat:
+        return self._value
+
+    @property
+    def tangent(self) -> tuple[FirstOrderAdFloat, ...]:
+        return self._tangent
+
+    @property
+    def adjoint(self) -> tuple[FirstOrderAdFloat, ...]:
+        return self._adjoint
 
     @staticmethod
     def _from_proto(proto: SecondOrderAdType) -> "SecondOrderAdFloat":

luminarycloud/types/ids.py

@@ -8,3 +8,6 @@ SimulationID = NewType("SimulationID", str)
 SolutionID = NewType("SolutionID", str)
 SimulationTemplateID = NewType("SimulationTemplateID", str)
 GeometryFeatureID = NewType("GeometryFeatureID", str)
+NamedVariableSetID = NewType("NamedVariableSetID", str)
+PhysicsAiArchitectureID = NewType("PhysicsAiArchitectureID", str)
+PhysicsAiModelID = NewType("PhysicsAiModelID", str)

luminarycloud/vis/__init__.py

@@ -37,6 +37,3 @@ from .display import (
 from .interactive_scene import (
     InteractiveScene as InteractiveScene,
 )
-
-from ..enum.vis_enums import *
-from ..types.vector3 import Vector3, Vector3Like

luminarycloud/vis/display.py

@@ -185,4 +185,5 @@ class ColorMap:
             res.height = self.appearance.height
             res.lower_left_anchor_location.x = self.appearance.lower_left_x
             res.lower_left_anchor_location.y = self.appearance.lower_left_y
+            res.text_size = self.appearance.text_size
         return res

luminarycloud/vis/interactive_scene.py

@@ -1,5 +1,5 @@
 from .display import DisplayAttributes
-from .filters import SurfaceStreamlines, Filter
+from .filters import SurfaceStreamlines, Filter, SurfaceLIC
 from .._client import get_default_client
 from ..enum.vis_enums import EntityType, SceneMode
 from typing import TYPE_CHECKING, cast
@@ -15,6 +15,9 @@ except ImportError:
     lcj = None
 
 
+_SOURCE_FILTER_ID = "___LC_SOURCE_FILTER___"
+
+
 class InteractiveScene:
     """
     The InteractiveScene acts as the bridge between the the Scene and
@@ -39,6 +42,9 @@ class InteractiveScene:
         self.widget._ipython_display_()
 
     def set_scene(self, scene: "Scene") -> None:
+        # Import here to avoid circular import issue
+        from .visualization import LookAtCamera
+
         # Display the initial scene we've been given
         # Submit request for the render data URLs we need
         req = vis_pb2.GetRenderDataUrlsRequest()
@@ -67,6 +73,12 @@ class InteractiveScene:
                 bad_ids = scene._validate_surfaces_and_tags(streamlines._surface_names)
                 if len(bad_ids) != 0:
                     raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
+            if isinstance(filter, SurfaceLIC):
+                # Validate surfaces names
+                lic = cast(SurfaceLIC, filter)
+                bad_ids = scene._validate_surfaces_and_tags(lic._surface_names)
+                if len(bad_ids) != 0:
+                    raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
 
             if isinstance(filter, Filter):
                 vis_filter: vis_pb2.Filter = filter._to_proto()
@@ -85,6 +97,27 @@ class InteractiveScene:
         # is moved there.
         self.widget.set_workspace_state(scene, resp)
 
+        # Sync display attributes and visibilities for surfaces
+        self.set_display_attributes(_SOURCE_FILTER_ID, scene.global_display_attrs)
+        for s, v in scene._surface_visibilities.items():
+            self.set_surface_visibility(s, v)
+
+        for f in scene._filters:
+            self.set_display_attributes(f.id, f.display_attrs)
+
+        # Find and apply the first look at camera, if any, in the scene
+        set_camera = False
+        for c in scene._cameras:
+            if not isinstance(c, LookAtCamera):
+                continue
+            set_camera = True
+            self.set_camera(c)
+
+        # If we don't have an initial camera to use, reset the camera after loading
+        # the workspace state
+        if not set_camera:
+            self.reset_camera()
+
     def set_surface_visibility(self, surface_id: str, visible: bool) -> None:
         self.widget.set_surface_visibility(surface_id, visible)
 
@@ -97,6 +130,12 @@ class InteractiveScene:
     def reset_camera(self) -> None:
         self.widget.reset_camera()
 
+    def set_camera(self, camera: "LookAtCamera") -> None:
+        self.widget.camera_pan = [camera.pan_x, camera.pan_y]
+        self.widget.camera_position = [camera.position[0], camera.position[1], camera.position[2]]
+        self.widget.camera_look_at = [camera.look_at[0], camera.look_at[1], camera.look_at[2]]
+        self.widget.camera_up = [camera.up[0], camera.up[1], camera.up[2]]
+
     def get_camera(self) -> "LookAtCamera":
         # Import here to avoid circular import issue
         from .visualization import LookAtCamera
@@ -105,4 +144,11 @@ class InteractiveScene:
         camera.position = self.widget.camera_position
         camera.look_at = self.widget.camera_look_at
         camera.up = self.widget.camera_up
+        # Immediately after creation, the widget's camera_pan is empty, so avoid going out of bounds
+        # and report 0 which is what it would be anyway
+        camera.pan_x = self.widget.camera_pan[0] if self.widget.camera_pan else 0
+        camera.pan_y = self.widget.camera_pan[1] if self.widget.camera_pan else 0
         return camera
+
+    def set_triad_visible(self, visible: bool) -> None:
+        self.widget.set_triad_visible(visible)