luminarycloud 0.15.2__py3-none-any.whl → 0.15.4__py3-none-any.whl

luminarycloud/simulation_param.py

@@ -308,37 +308,41 @@ class SimulationParam(_SimulationParam):
     def __repr__(self) -> str:
         return pformat(vars(self), compact=True, sort_dicts=True)
 
-    def to_code(self, hide_defaults: bool = True) -> str:
+    def to_code(self, hide_defaults: bool = True, use_tmp_objs: bool = True) -> str:
         """
         Returns the python code that generates an identical SimulationParam object.
-        This is a verbose representation that does not make use of helper functions like
+        This is an automatic 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.
+        By default the idiom used to populate lists and maps is to create a temporary object and
+        then append or insert, respectively. The alternative, using [] to access items, is used if
+        use_tmp_objs=False.
         """
-        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.
+        code = """## NOTE: This is an automatic representation of a SimulationParam object as the
+## code that creates (from scratch) an identical object. As such, some parts do
+## not match 1 to 1 with hand-written examples.
 import luminarycloud
-from luminarycloud import *
 from luminarycloud.types import Vector3
+from luminarycloud.tables import RectilinearTable
 from luminarycloud.enum import *
 from luminarycloud.params.enum import *
-from luminarycloud.params import simulation as params
+from luminarycloud.params import simulation as sim_params
+from luminarycloud import outputs, SimulationParam, EntityIdentifier
 
 
 """
-        return code + self._to_code_helper("obj", hide_defaults).replace(
+        return code + self._to_code_helper("obj", hide_defaults, use_tmp_objs).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.
+        Searches the full output of "to_code(False, False)" 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")):
+        for i, line in enumerate(self.to_code(False, False).split("\n")):
             if parameter.lower() in line.lower():
                 print(f"line {i}: {line}")
 

luminarycloud/simulation_template.py

@@ -2,7 +2,7 @@
 from datetime import datetime
 from os import PathLike
 from copy import deepcopy
-from typing import Optional, Union, overload
+from typing import Optional, overload
 from difflib import Differ
 
 from .enum import (
@@ -76,6 +76,7 @@ class SimulationTemplate(ProtoWrapperBase):
         *,
         name: Optional[str] = None,
         parameters: Optional[SimulationParam | PathLike] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> None:
         """
         Update simulation template.
@@ -84,19 +85,23 @@ class SimulationTemplate(ProtoWrapperBase):
         ----------
         name : str, optional
             New project name.
-        parameters : SimulationParam or PathLike
+        parameters : SimulationParam or PathLike, optional
             New complete simulation parameters object or path to local JSON file containing
             simulation parameters. In the former case, the input argument is modified to reflect
             changes applied by the backend (server), for example due to presets. Any differences
             between input and result are printed on screen.
+        copy_from : SimulationTemplate or SimulationTemplateID or str, optional
+            Simulation template to copy. If provided, it will be deep-copied into this simulation
+            template. Can pass a SimulationTemplate object or an ID of the template to copy.
         """
-        return self._update(name=name, parameters=parameters)
+        return self._update(name=name, parameters=parameters, copy_from=copy_from)
 
     def _update(
         self,
         *,
         name: Optional[str] = None,
         parameters: Optional[SimulationParam | clientpb.SimulationParam | PathLike] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> None:
         """
         Update simulation template. See `update()` for more details.
@@ -124,21 +129,31 @@ class SimulationTemplate(ProtoWrapperBase):
 
             req.parameters.CopyFrom(param_proto)
 
+        if copy_from is not None:
+            if isinstance(copy_from, SimulationTemplate):
+                req.copy_from = copy_from.id
+            elif isinstance(copy_from, str):
+                req.copy_from = copy_from
+            else:
+                raise ValueError(f"Invalid copy_from argument: {copy_from}")
+
         res: simtemplatepb.UpdateSimulationTemplateResponse = (
             get_default_client().UpdateSimulationTemplate(req)
         )
         self._proto = res.simulation_template
 
         def print_diff(
-            old: Union[clientpb.SimulationParam, SimulationParam],
-            new: Union[clientpb.SimulationParam, SimulationParam],
+            old: clientpb.SimulationParam | SimulationParam,
+            new: clientpb.SimulationParam | SimulationParam,
         ) -> None:
             diffs = list(Differ().compare(str(old).split("\n"), str(new).split("\n")))
             has_diffs = False
             for diff in diffs:
                 if diff.startswith("-") or diff.startswith("+"):
                     if not has_diffs:
-                        print("The input parameters have been modified:\n")
+                        print(
+                            "The given parameters have been modified, both in memory and server-side, due to presets. The modifications:\n"
+                        )
                         has_diffs = True
                     print(diff)
 
@@ -159,7 +174,10 @@ class SimulationTemplate(ProtoWrapperBase):
         get_default_client().DeleteSimulationTemplate(req)
 
     def get_parameters(self) -> SimulationParam:
-        return self.get_simulation_param()
+        """
+        Returns a copy of the simulation parameters associated with this template.
+        """
+        return SimulationParam.from_proto(self._proto.parameters)
 
     @deprecated(
         "Use get_parameters() instead. This method will be removed in a future release.",
@@ -168,7 +186,7 @@ class SimulationTemplate(ProtoWrapperBase):
         """
         Returns a copy of the simulation parameters associated with this template.
         """
-        return SimulationParam.from_proto(self._proto.parameters)
+        return self.get_parameters()
 
     def list_tables(
         self,
@@ -460,20 +478,21 @@ class SimulationTemplate(ProtoWrapperBase):
 
     def to_code(self, hide_defaults: bool = True) -> str:
         """
-        Returns the python code that generates an identical SimulationTemplate object.
+        Returns the python code that generates (from scratch) 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)
+        param_code = self.get_parameters().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 += '# Create a new simulation template or modify the one that is synced with the UI "Setup" tab.\n'
+        code += "# TODO(USER): Replace ... with project ID, or create a project.\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 += "template = project.list_simulation_templates()[0] # Setup template\n\n"
 
         code += "# Define the simulation parameters.\n"
         code += param_code

luminarycloud/solution.py

@@ -38,7 +38,7 @@ class Solution(ProtoWrapperBase):
     "Solution ID."
     simulation_id: SimulationID
     "Simulation ID of parent"
-    iteration: str
+    iteration: int
     "Iteration index of the solution."
     physical_time: float
     "The physical time, in seconds, of the solution iteration (for transient simulations)."

luminarycloud/types/__init__.py

@@ -12,6 +12,8 @@ from .ids import (
 from .adfloat import (
     FirstOrderAdFloat as FirstOrderAdFloat,
     SecondOrderAdFloat as SecondOrderAdFloat,
+    Expression as Expression,
+    LcFloat as LcFloat,
 )
 from .vector3 import (
     Vector3 as Vector3,

luminarycloud/types/adfloat.py

@@ -1,10 +1,10 @@
 from abc import ABCMeta
-from typing import Any
-from .._proto.base.base_pb2 import AdFloatType, FirstOrderAdType, SecondOrderAdType
+from typing import Any, Union
+from .._proto.base.base_pb2 import AdFloatType, ExpressionType, FirstOrderAdType, SecondOrderAdType
 
 
 class AdFloat(float, metaclass=ABCMeta):
-    """An immutable float with adjoints/tangents"""
+    """An immutable float with adjoints/tangents or an expression"""
 
     pass
 
@@ -110,8 +110,47 @@ class SecondOrderAdFloat(AdFloat):
         )
 
 
-def _to_ad_proto(value: float) -> AdFloatType:
-    """Convert a float to an AdFloatType proto."""
+class Expression:
+    """An expression or value that can be evaluated or used in evaluations."""
+
+    _value: float
+    _expression: str
+
+    def __init__(self, expression: str):
+        if not expression:
+            raise ValueError("Expression cannot be empty")
+        self._value = 0.0
+        self._expression = expression
+
+    @property
+    def expression(self) -> str:
+        return self._expression
+
+    @property
+    def value(self) -> float:
+        return self._value
+
+    def _to_proto(self) -> AdFloatType:
+        return AdFloatType(variable=ExpressionType(value=self.value, expression=self.expression))
+
+    @staticmethod
+    def _from_proto(proto: AdFloatType) -> "Expression":
+        expr = object.__new__(Expression)  # Create a new instance without calling __init__
+        expr._value = proto.variable.value
+        expr._expression = proto.variable.expression
+        return expr
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Expression):
+            return False
+        return self._value == other._value and self._expression == other._expression
+
+
+LcFloat = Union[float, FirstOrderAdFloat, SecondOrderAdFloat, Expression]
+
+
+def _to_ad_proto(value: LcFloat) -> AdFloatType:
+    """Convert an LcFloat to an AdFloatType proto."""
     if isinstance(value, FirstOrderAdFloat):
         return AdFloatType(
             first_order=FirstOrderAdType(
@@ -128,18 +167,21 @@ def _to_ad_proto(value: float) -> AdFloatType:
                 adjoint=[_to_ad_proto(a).first_order for a in value.adjoint],
             )
         )
+    elif isinstance(value, Expression):
+        return value._to_proto()
     return AdFloatType(value=float(value))
 
 
-def _from_ad_proto(proto: AdFloatType) -> float:
-    """Convert an AdFloatType proto to a float."""
+def _from_ad_proto(proto: AdFloatType) -> LcFloat:
+    """Convert an AdFloatType proto to an LcFloat."""
     if proto.HasField("first_order"):
         return FirstOrderAdFloat._from_proto(proto.first_order)
     elif proto.HasField("second_order"):
         return SecondOrderAdFloat._from_proto(proto.second_order)
     elif proto.HasField("value"):
         return float(proto.value)
-
+    elif proto.HasField("variable"):
+        return Expression._from_proto(proto)
     # An empty proto evaluates to 0.0
     if not proto.ListFields():
         return 0.0

luminarycloud/types/ids.py

@@ -10,4 +10,6 @@ SimulationTemplateID = NewType("SimulationTemplateID", str)
 GeometryFeatureID = NewType("GeometryFeatureID", str)
 NamedVariableSetID = NewType("NamedVariableSetID", str)
 PhysicsAiArchitectureID = NewType("PhysicsAiArchitectureID", str)
+PhysicsAiArchitectureVersionID = NewType("PhysicsAiArchitectureVersionID", str)
 PhysicsAiModelID = NewType("PhysicsAiModelID", str)
+PhysicsAiModelVersionID = NewType("PhysicsAiModelVersionID", str)

luminarycloud/types/vector3.py

@@ -8,10 +8,11 @@ from .adfloat import (
     _to_ad_proto as _float_to_ad_proto,
     _from_ad_proto as _float_from_ad_proto,
 )
+from ..pipeline_util.dictable import PipelineDictable
 
 
 @dataclass
-class Vector3:
+class Vector3(PipelineDictable):
     """Represents a 3-dimensional vector.
 
     Supports direct component access, indexing, iteration, and conversion to numpy arrays.

luminarycloud/vis/__init__.py

@@ -1,7 +1,6 @@
 from .visualization import (
     RenderOutput as RenderOutput,
     Scene as Scene,
-    ColorMapPreset as ColorMapPreset,
     EntityType as EntityType,
     list_renders as list_renders,
     list_quantities as list_quantities,
@@ -9,12 +8,15 @@ from .visualization import (
     LookAtCamera as LookAtCamera,
 )
 
+from .primitives import (
+    Plane as Plane,
+    Box as Box,
+)
+
 from .filters import (
     Slice as Slice,
     PlaneClip as PlaneClip,
     BoxClip as BoxClip,
-    Plane as Plane,
-    Box as Box,
     FixedSizeVectorGlyphs as FixedSizeVectorGlyphs,
     ScaledVectorGlyphs as ScaledVectorGlyphs,
     RakeStreamlines as RakeStreamlines,
@@ -24,13 +26,18 @@ from .filters import (
     Isosurface as Isosurface,
 )
 
+from .data_extraction import (
+    IntersectionCurve as IntersectionCurve,
+    DataExtractor as DataExtractor,
+    ExtractOutput as ExtractOutput,
+    list_data_extracts as list_data_extracts,
+)
+
 from .display import (
     Field as Field,
     DataRange as DataRange,
     ColorMap as ColorMap,
     ColorMapAppearance as ColorMapAppearance,
-    Representation as Representation,
-    FieldComponent as FieldComponent,
     DisplayAttributes as DisplayAttributes,
 )