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

luminarycloud/project.py

@@ -1,6 +1,7 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 from __future__ import annotations
 
+import logging
 import re
 import uuid
 from datetime import datetime
@@ -45,7 +46,8 @@ from .enum import GPUType, MeshType, TableType
 from .meshing import MeshAdaptationParams, MeshGenerationParams
 from .simulation_param import SimulationParam
 from .tables import RectilinearTable, create_rectilinear_table
-from .types import MeshID, ProjectID, SimulationTemplateID
+from .types import MeshID, ProjectID, SimulationTemplateID, NamedVariableSetID, Expression, LcFloat
+from .named_variable_set import get_named_variable_set
 
 if TYPE_CHECKING:
     from .geometry import Geometry
@@ -482,6 +484,7 @@ class Project(ProtoWrapperBase):
         name: str,
         simulation_template_id: str,
         *,
+        _named_variable_set_id: Optional[NamedVariableSetID] = None,
         description: str = "",
         batch_processing: bool = True,
         gpu_type: Optional[GPUType] = None,
@@ -514,12 +517,19 @@ class Project(ProtoWrapperBase):
             Number of GPUs to use for the simulation. Must be specified to a
             positive value if `gpu_type` is specified.
         """
+
+        named_variable_set_version_id: Optional[str] = None
+        if _named_variable_set_id is not None:
+            named_variable_set = get_named_variable_set(_named_variable_set_id)
+            named_variable_set_version_id = named_variable_set._version_id
+
         _simulation = create_simulation(
             get_default_client(),
             self.id,
             mesh_id,
             name,
             simulation_template_id,
+            named_variable_set_version_id=named_variable_set_version_id,
             description=description,
             batch_processing=batch_processing,
             gpu_type=gpu_type,
@@ -550,7 +560,7 @@ class Project(ProtoWrapperBase):
         *,
         parameters: Optional[SimulationParam] = None,
         params_json_path: Optional[PathLike | str] = None,
-        copy_from: Optional["SimulationTemplate" | SimulationTemplateID | str] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> "SimulationTemplate":
         """
         Create a new simulation template object.
@@ -600,7 +610,7 @@ class Project(ProtoWrapperBase):
 
     @experimental
     def create_named_variable_set(
-        self, name: str, named_variables: dict[str, float | str]
+        self, name: str, named_variables: dict[str, LcFloat]
     ) -> NamedVariableSet:
         """
         Create a new named variable set.
@@ -626,6 +636,47 @@ class Project(ProtoWrapperBase):
         return [lc.NamedVariableSet(n) for n in res.named_variable_sets]
 
 
+@experimental
+def add_named_variables_from_csv(project: Project, csv_path: str) -> list[NamedVariableSet]:
+    """
+    This function reads named variables from a CSV file and creates corresponding NamedVariableSets in the given project.
+    The CSV file should have the following format:
+    name, var1, var2, ...
+    name1, val1, val2, ...
+    name2, val1, val2, ...
+    """
+    import csv
+
+    def is_float(s: str) -> bool:
+        try:
+            float(s)
+            return True
+        except ValueError:
+            return False
+
+    named_variable_sets = []
+    with open(csv_path) as csvfile:
+        reader = csv.reader(csvfile)
+        header = next(reader)
+        keys = [k.strip() for k in header[1:]]
+        for row in reader:
+            if len(row) != len(keys) + 1:
+                logging.warning(
+                    f"Skipping row {row} because it has the wrong number of columns ({len(row)} instead of {len(keys) + 1})"
+                )
+                continue
+            name = row[0]
+            named_variables: dict[str, LcFloat] = {
+                k: float(v.strip()) if is_float(v.strip()) else Expression(v.strip())
+                for k, v in zip(keys, row[1:])
+            }
+            named_variable_sets.append(
+                project.create_named_variable_set(name=name, named_variables=named_variables)
+            )
+            logging.info(f"Created named variable set {name} with {len(named_variables)} variables")
+    return named_variable_sets
+
+
 def create_project(
     name: str,
     description: str = "",

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)
 

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/vis/__init__.py

@@ -8,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,
@@ -23,6 +26,13 @@ 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,