metafold 0.12.dev11__tar.gz → 0.13.0__tar.gz

{metafold-0.12.dev11 → metafold-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.12.dev11
+Version: 0.13.0
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs~=23.2
@@ -38,7 +38,7 @@ Requires-Dist: dotenv>=0.9.9; extra == "simulation"
 Requires-Dist: pandas>=2.3.3; extra == "simulation"
 Requires-Dist: plyfile>=1.1.3; extra == "simulation"
 Requires-Dist: pyyaml>=6.0.3; extra == "simulation"
-Requires-Dist: simulation-configurator==0.1.2; extra == "simulation"
+Requires-Dist: simulation-configurator==0.2.*; extra == "simulation"
 Requires-Dist: tables>=3.11.1; extra == "simulation"
 Dynamic: license-file
 

{metafold-0.12.dev11 → metafold-0.13.0}/metafold/projects.py

@@ -13,9 +13,11 @@ class Access(Enum):
     Attributes:
         PRIVATE: Project is private to owner.
         PUBLIC: Project may be accessed by unauthenticated users.
+        ORG: Project may be accessed by members of the same organization.
     """
     PRIVATE = "private"
     PUBLIC = "public"
+    ORG = "org"
 
 
 class ProjectType(Enum):
@@ -65,7 +67,7 @@ class Project:
     access: Access = field(converter=check_access)
     created: datetime = field(converter=asdatetime)
     modified: datetime = field(converter=asdatetime)
-    type: ProjectType = field(converter=check_project_type, default=ProjectType.UNSPECIFIED) 
+    type: ProjectType = field(converter=check_project_type, default=ProjectType.UNSPECIFIED)
     thumbnail: str | None = None
     project: dict[str, Any] | None = None
     graph: dict[str, Any] | None = None

{metafold-0.12.dev11 → metafold-0.13.0}/metafold/simulation/compression_experiment.py

@@ -1,6 +1,6 @@
 import copy
 import json
-from typing import Any, List, Union, cast
+from typing import Any, List, Optional, Union, cast
 import glob
 from pathlib import Path
 from metafold.simulation.compression_simulation import (
@@ -106,6 +106,41 @@ class VarySimulationParameter(ExperimentVarying):
         setattr(obj, parts[-1], self.values[sim_index])
 
 
+class VaryVelocity(ExperimentVarying):
+    """Vary a rigid part's velocity keyframes (e.g. a piston's motion profile).
+    Each value is a full velocity profile: a list of [t, vx, vy, vz] rows."""
+
+    part_name: str
+    velocities: List[list]
+
+    def __init__(self, part_name: str, velocities: List[list]):
+        # Each element is one profile: a list of [t,vx,vy,vz] rows.
+        for i, profile in enumerate(velocities):
+            if (
+                not isinstance(profile, list)
+                or not profile
+                or not all(isinstance(row, list) and len(row) == 4 for row in profile)
+            ):
+                raise ValueError(
+                    f"velocity profile {i} for part {part_name!r} must be a list "
+                    f"of [t, vx, vy, vz] rows, got: {profile!r}"
+                )
+        self.part_name = part_name
+        self.velocities = velocities
+
+    def resolve(self, _base_dir: Path) -> None:
+        self.sim_count = len(self.velocities)
+
+    def apply_to(self, sim_index: int, sim: CompressionSimulation):
+        part_info: CompressionSimulation.PartInfo = sim.get_part_info(self.part_name)
+        if not hasattr(part_info.part, "velocity"):
+            # Only rigid (piston/support) parts consume a velocity profile.
+            raise ValueError(
+                f"Part {self.part_name!r} is not a rigid (piston/support) part "
+            )
+        part_info.part.velocity = self.velocities[sim_index]
+
+
 class CompressionExperiment:
     base_simulation: CompressionSimulation
     varying: List[ExperimentVarying] = []
@@ -124,12 +159,16 @@ class CompressionExperiment:
         auto_upload_server_manifest: bool = True,
         use_legacy_results_format: bool = False,
         write_ups: bool = True,
+        simulation_names: Optional[List[str]] = None,
     ):
         simulation.use_legacy_results_format = use_legacy_results_format
         simulation.write_ups = write_ups
         self.use_legacy_results_format = use_legacy_results_format
         self.base_simulation = simulation
         self.varying = varying
+        # Optional per-simulation display names (index-aligned). A blank/missing
+        # entry falls back to the auto "<base>_sim<index>" name.
+        self.simulation_names = simulation_names or []
         self.verbose = verbose
         self.force_rerun = force_rerun
         self.varying_part_names = []
@@ -139,12 +178,59 @@ class CompressionExperiment:
             if hasattr(v, "part_name"):
                 self.varying_part_names.append(v.part_name)
 
+        # Every varying must produce the same number of variants — prepare()
+        # sizes the sim loop from one of them and indexes into all of them.
+        counts = {v.sim_count for v in self.varying}
+        if len(counts) > 1:
+            raise ValueError(
+                "All varying entries must have the same number of values, got "
+                f"counts: {sorted(counts)}"
+            )
+
+        self._validate_simulation_names()
+
         if auto_run:
             self.prepare()
             self.run(auto_upload_server_manifest)
             if auto_download_results:
                 self.download_results()
 
+    def _sim_name(self, sim_index: int) -> str:
+        """Name for the sim at sim_index: the caller-supplied name when present,
+        otherwise the auto "<base>_sim<index>" name."""
+        custom = (
+            self.simulation_names[sim_index]
+            if sim_index < len(self.simulation_names)
+            else None
+        )
+        return custom or f"{self.base_simulation.simulation_name}_sim{sim_index}"
+
+    def _validate_simulation_names(self):
+        """Names must be a list of path-safe strings (None or "" = use the
+        auto name) and resolve to a unique name per sim (they become filenames
+        and zip member paths)."""
+        if not isinstance(self.simulation_names, list) or not all(
+            n is None or isinstance(n, str) for n in self.simulation_names
+        ):
+            raise ValueError(
+                f"simulation_names must be a list of strings, got: "
+                f"{self.simulation_names!r}"
+            )
+        self.simulation_names = [n or "" for n in self.simulation_names]
+        for name in self.simulation_names:
+            if any(c in name for c in "/\\:"):
+                raise ValueError(
+                    f"simulation name {name!r} contains a path separator"
+                )
+
+        sim_count = self.varying[0].sim_count if self.varying else 1
+        resolved = [self._sim_name(i) for i in range(sim_count)]
+        duplicates = {n for n in resolved if resolved.count(n) > 1}
+        if duplicates:
+            raise ValueError(
+                f"simulation names must be unique, duplicated: {sorted(duplicates)}"
+            )
+
     @property
     def _experiment_state_filename(self) -> Path:
         assert self.base_simulation.out_dir is not None
@@ -157,12 +243,18 @@ class CompressionExperiment:
         """Delete the experiment state file and all per-sim results files."""
         if self._experiment_state_filename.is_file():
             self._experiment_state_filename.unlink()
-        # delete per-sim results — we don't know sim names without state,
-        # so just glob for anything matching the pattern
+        # delete per-sim results: auto-named sims match the glob pattern,
+        # custom-named sims are deleted by name
         for f in self.base_simulation.out_dir.glob(
             f"{self.base_simulation.simulation_name}_sim*_results.json"
         ):
             f.unlink()
+        for name in self.simulation_names:
+            if not name:
+                continue
+            f = self.base_simulation.out_dir / f"{name}_results.json"
+            if f.is_file():
+                f.unlink()
         # delete out.zip if it exists
         out_zip = self.base_simulation.out_dir / "out.zip"
         if out_zip.is_file():
@@ -193,7 +285,7 @@ class CompressionExperiment:
         self.base_simulation.part_infos = base_part_infos
 
         # give each sim a unique name so zip paths don't collide
-        clone.simulation_name = f"{self.base_simulation.simulation_name}_sim{sim_index}"
+        clone.simulation_name = self._sim_name(sim_index)
 
         # ok now for the part infos we want to do something different, we want to keep shared elements the same but fork
         # the part infos which we are varying, that way we dont mess up other copies when experiments vary things

{metafold-0.12.dev11 → metafold-0.13.0}/metafold/simulation/compression_simulation.py

@@ -8,7 +8,7 @@ import uuid
 
 from requests import HTTPError
 import yaml
-from dotenv import load_dotenv
+from dotenv import load_dotenv  # type: ignore
 from metafold import MetafoldClient
 from pathlib import Path
 from numpy.typing import DTypeLike
@@ -311,6 +311,7 @@ class WorkflowStepType(Enum):
     STRESS_STRAIN = "stress_strain"
     PARTICLE_DISPLACEMENT = "particle_displacement"
     ENERGY_METRICS = "energy_metrics"
+    REDUCE_RESULTS = "reduce_results"
 
 
 class WorkflowStep:
@@ -353,6 +354,8 @@ class CompressionSimulation:
         bvh_filename: Optional[str] = None
         # Sampling resolution (longest axis) assigned for the pass-2 sample job.
         sample_resolution: Optional[int] = None
+        # From the prep metrics job; None until prep completes.
+        interior_volume: Optional[float] = None
         patch: dict = field(default_factory=dict)
         jobs: dict[str, Any] = field(default_factory=lambda: {})
         part_unique_name = ""
@@ -374,6 +377,7 @@ class CompressionSimulation:
                 "is_piston": isinstance(self.part, ExperimentPistonBase),
                 "part_name": self.part.name,
                 "disabled": self.disabled,
+                "interior_volume": self.interior_volume,
             }
 
         def restore_from_state_dict(self, saved: dict):
@@ -382,6 +386,7 @@ class CompressionSimulation:
             self.material_name = saved["material_name"]
             self.jobs = saved["jobs"]
             self.disabled = saved.get("disabled", False)
+            self.interior_volume = saved.get("interior_volume")
 
     client: MetafoldClient
     project_id: str = ""
@@ -425,7 +430,7 @@ class CompressionSimulation:
         simulation_name: str,
         project_id: str = "",
         stl_folder_path: str = "PLY",
-        env_source: str = ".env.dev",
+        env_source: str | None = ".env.dev",
         output_path: str = "",
         client: Optional[MetafoldClient] = None,
         simulation_parameters: SimulationParameters = SimulationParameters(),
@@ -440,6 +445,7 @@ class CompressionSimulation:
             # stress_strain is opt-in (not default): callers add it via workflow_steps.
             WorkflowStep(WorkflowStepType.PARTICLE_DISPLACEMENT),
             WorkflowStep(WorkflowStepType.ENERGY_METRICS),
+            # reduce-results is auto-added in build_workflow (not a step).
         ],
         force_reupload_files=False,
         prep_workflow_batch_size: int = 10,
@@ -605,6 +611,7 @@ class CompressionSimulation:
         auth_domain: str = "metafold3d.us.auth0.com",
         base_url: str = "https://api.metafold3d.com/",
         cancel_existing_workflows: bool = True,
+        project_access: Access = Access.PRIVATE,
     ) -> str:
         """Find an existing project by name or create a new one.
 
@@ -636,13 +643,14 @@ class CompressionSimulation:
             return project_id
         created = client.projects.create(
             project_name,
-            access=Access.PRIVATE,
+            access=project_access,
             type=ProjectType.DIGITAL_TEST_BENCH_EXPERIMENT,
         )
         return created.id
 
     def setup_client(self, env_source, project_id) -> MetafoldClient:
-        load_dotenv(env_source)
+        if env_source is not None:
+            load_dotenv(env_source)
 
         if not project_id:
             self.project_id = os.environ.get("METAFOLD_PROJECT_ID", "")
@@ -824,6 +832,24 @@ class CompressionSimulation:
             params[f"{sample_mesh_job}.resolution"] = f"{resolution}"
             part_info.jobs["sample-mesh"] = sample_mesh_job
 
+            # Metrics run in prep (not the main workflow) so interior volume
+            # is known before dispatch, when the server manifest is uploaded.
+            if self._is_analysis_target(part_info.part) and self._get_step(
+                WorkflowStepType.METRICS, part_info.part.name
+            ):
+                metrics_job = f"metrics-{unique_name}"
+                jobs[metrics_job] = {
+                    "type": "implicit/metrics",
+                    "needs": [sample_mesh_job],
+                    "assets": {"volume": sample_mesh_job},
+                    "parameters": {
+                        "volume_size": {"job": sample_mesh_job, "parameter": "patch_size"},
+                        "volume_offset": {"job": sample_mesh_job, "parameter": "patch_offset"},
+                        "volume_resolution": {"job": sample_mesh_job, "parameter": "patch_resolution"},
+                    },
+                }
+                part_info.jobs["metrics"] = metrics_job
+
         workflow_yaml = yaml.dump({"jobs": jobs}, default_flow_style=False)
         return workflow_yaml, params, assets
 
@@ -1025,6 +1051,30 @@ class CompressionSimulation:
             if volume_asset is not None:
                 info.volume_filename = volume_asset.filename
 
+            metrics_job = prep_workflow_jobs.get(info.jobs.get("metrics", ""))
+            if metrics_job is not None:
+                raw = metrics_job.outputs.params.get("interior_volume")
+                if raw is not None:
+                    info.interior_volume = float(raw)
+
+    def _total_interior_volume(self, workflow: Optional[Workflow] = None) -> float:
+        """Sum interior volumes across analysis-target parts. Falls back to
+        the main-workflow metrics readback for experiments dispatched before
+        metrics moved to the prep workflow."""
+        total = 0.0
+        for part_info in self.part_infos:
+            if not self._is_analysis_target(part_info.part) or part_info.disabled:
+                continue
+            if part_info.interior_volume is not None:
+                total += part_info.interior_volume
+                continue
+            metrics_job = part_info.jobs.get("metrics", "")
+            if workflow is not None and metrics_job:
+                raw = workflow.get_parameter(f"{metrics_job}.interior_volume")
+                if raw is not None:
+                    total += float(raw)
+        return total
+
     def get_part_info(self, name):
         for info in self.part_infos:
             if info.part.name == name:
@@ -1218,6 +1268,9 @@ class CompressionSimulation:
         ElementTree.indent(self.ups)
 
     def _add_to_workflow_metrics(self, part_infos: list[PartInfo]):
+        # Duplicates the prep metrics jobs (which feed the server manifest):
+        # removing these changed main-workflow scheduling and left it pending,
+        # so they stay until that's understood.
         for part_info in part_infos:
             part = part_info.part
             if not self._is_analysis_target(part):
@@ -1241,7 +1294,6 @@ class CompressionSimulation:
             self.workflow_params[f"{metrics_job_name}.volume_resolution"] = json.dumps(
                 part_info.patch["resolution"]
             )
-            part_info.jobs["metrics"] = metrics_job_name
 
     def _add_to_workflow_compress(self, part_infos: list[PartInfo]):
         compress_job_name = "compress"
@@ -1426,6 +1478,25 @@ class CompressionSimulation:
             part_infos, "force-displacement", "energy-metrics"
         )
 
+    # One merged reduce-results job consumes the particle-data outputs the
+    # browser renders and produces a compact (trimmed + int16 + decimated) HDF5.
+    # Auto-added whenever compress ran; the manifest points DTB at its output.
+    _REDUCE_SOURCE_JOBS = [
+        "compress", "von-mises-stress", "effective-strain",
+        "particle-displacement",
+    ]
+    _REDUCE_JOB_NAME = "reduce-results"
+
+    def _add_to_workflow_reduce_results(self):
+        sources = [j for j in self._REDUCE_SOURCE_JOBS if j in self.workflow_jobs]
+        if "compress" not in sources:
+            return  # nothing to preview without particle positions
+        self.workflow_jobs[self._REDUCE_JOB_NAME] = {
+            "type": "sim/postprocess/reduce-results",
+            "needs": sources,
+            "assets": {"data": [{"job": s, "asset": "output"} for s in sources]},
+        }
+
     def build_workflow(self, name_suffix=""):
         self.workflow_yaml = ""
         self.workflow_params = {}
@@ -1462,6 +1533,9 @@ class CompressionSimulation:
             elif step.type == WorkflowStepType.COMPUTE_BVH:
                 pass  # this is done on the prep workflow, not here
 
+        # Always emit the browser preview when there's particle data to preview.
+        self._add_to_workflow_reduce_results()
+
         self.workflow_yaml = yaml.dump(
             {"jobs": self.workflow_jobs}, default_flow_style=False, sort_keys=False
         )
@@ -2046,16 +2120,7 @@ class CompressionSimulation:
                     data["ply"] = f"{name}/ply/part.####.ply"
 
                     # Sum interior volumes from all parts
-                    total_volume = 0.0
-                    for part_info in self.part_infos:
-                        if self._is_analysis_target(part_info.part):
-                            if part_info.disabled:
-                                continue
-                            metrics_job = part_info.jobs.get("metrics", "")
-                            if metrics_job:
-                                raw = w.get_parameter(f"{metrics_job}.interior_volume")
-                                if raw is not None:
-                                    total_volume += float(raw)
+                    total_volume = self._total_interior_volume(w)
 
                     result.update(
                         {
@@ -2279,18 +2344,7 @@ class CompressionSimulation:
                             }
 
             # Sum interior volumes across analysis-target parts.
-            total_volume = 0.0
-            for part_info in self.part_infos:
-                if not self._is_analysis_target(part_info.part):
-                    continue
-                if part_info.disabled:
-                    continue
-                metrics_job = part_info.jobs.get("metrics", "")
-                if not metrics_job:
-                    continue
-                raw = w.get_parameter(f"{metrics_job}.interior_volume")
-                if raw is not None:
-                    total_volume += float(raw)
+            total_volume = self._total_interior_volume(w)
 
             result.update(
                 {
@@ -2384,27 +2438,32 @@ class CompressionSimulation:
                 "particle-displacement",
             ),
         ]
+        # Point the particle datasets DTB renders at the merged reduce-results
+        # job (compact int16/decimated), falling back to the raw job if preview
+        # didn't run. Histograms are tiny — leave them on the raw job.
+        reduce_job_id = job_id_lookup.get(self._REDUCE_JOB_NAME, "")
         for step, dataset_root, key_prefix, has_histogram, local_job in full_hdf_refs:
             if not self._contains_step(step):
                 continue
-            job_id = job_id_lookup.get(local_job, "")
+            raw_job_id = job_id_lookup.get(local_job, "")
+            data_job_id = reduce_job_id or raw_job_id
             for i in range(n_materials):
                 if self.part_infos[i].disabled:
                     continue
                 server_data[f"{key_prefix}{i}"] = {
-                    "jobId": job_id,
+                    "jobId": data_job_id,
                     "assetName": "output",
                     "path": f"/material{i}/{dataset_root}",
                 }
                 if has_histogram:
                     server_data[f"{key_prefix}Histogram{i}"] = {
-                        "jobId": job_id,
+                        "jobId": raw_job_id,
                         "assetName": "output",
                         "path": f"/material{i}/{dataset_root}_histogram",
                     }
 
         if self._contains_step(WorkflowStepType.COMPRESS):
-            job_id = job_id_lookup.get("compress", "")
+            job_id = reduce_job_id or job_id_lookup.get("compress", "")
             for i in range(n_materials):
                 if self.part_infos[i].disabled:
                     continue
@@ -2445,19 +2504,7 @@ class CompressionSimulation:
         Volume is inlined (from prep workflow parameters); energy values are
         refs that the server resolves from the energy-metrics job output."""
         scalars: dict[str, Any] = {}
-
-        total_volume = 0.0
-        for part_info in self.part_infos:
-            if not self._is_analysis_target(part_info.part):
-                continue
-            if part_info.disabled:
-                continue
-            metrics_job = part_info.jobs.get("metrics", "")
-            if metrics_job:
-                raw = workflow.get_parameter(f"{metrics_job}.interior_volume")
-                if raw is not None:
-                    total_volume += float(raw)
-        scalars["volume"] = total_volume
+        scalars["volume"] = self._total_interior_volume(workflow)
 
         if self._contains_step(WorkflowStepType.ENERGY_METRICS):
             em_job_id = job_id_lookup.get("energy-metrics", "")
@@ -2498,6 +2545,10 @@ class CompressionSimulation:
                 server_result["data"] = {}
             server_results.append(server_result)
 
+        # ensure material index is set on all parts for a multi-simulation experiment
+        for i, part_info in enumerate(self.part_infos):
+            part_info.material_index = i
+
         self.make_manifest_v2(results=server_results)
         manifest = copy.deepcopy(self.manifest)
         manifest["results"] = server_results
@@ -2717,7 +2768,7 @@ class CompressionSimulation:
                     "heading": "Absorbed Energy (J)",
                     "filtering": False,
                 }
-            )    
+            )
             self.manifest["resultsListConfig"].append(
                             {
                     "key": "loadingEnergy",

{metafold-0.12.dev11 → metafold-0.13.0}/metafold/simulation/run_experiment.py

@@ -55,7 +55,14 @@ JSON manifest format
                 }
             }
         ]},
-        {"field": "max_time", "values": [0.02, 0.04]}
+        # A rigid part's velocity keyframes; each value is a full [t,vx,vy,vz] profile:
+        {"part": "piston", "velocity": [
+            [[0.0, 0, 0, 0.0], [0.04, 0, 0, -1.25]],
+            [[0.0, 0, 0, 0.0], [0.04, 0, 0, -2.50]],
+            [[0.0, 0, 0, 0.0], [0.04, 0, 0, -5.00]]
+        ]},
+        # Every varying entry must have the same number of values (one per variant).
+        {"field": "max_time", "values": [0.02, 0.04, 0.06]}
     ],
 
     "simulation": {
@@ -82,7 +89,12 @@ JSON manifest format
         "compress",
         "force_displacement",
         {"step": "metrics", "parts": ["midsole", "outsole"]}
-    ]
+    ],
+
+    # Optional display name per simulation variant, index-aligned with the variants
+    # the varying entries produce. A null/blank/missing entry falls back to
+    # "<name>_sim<i>". Names must be unique and must not contain path separators.
+    "simulation_names": ["slow piston", null, "fastest piston"]
 }
 
 Available material presets
@@ -137,6 +149,7 @@ from metafold.simulation.compression_experiment import (
     VaryMaterial,
     VaryMesh,
     VarySimulationParameter,
+    VaryVelocity,
 )
 from metafold.simulation.compression_simulation import (
     CompressionSimulation,
@@ -180,6 +193,8 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
 
         if part_type == "piston_cylinder":
             kwargs = {}
+            if "name" in entry:
+                kwargs["name"] = entry["name"]
             if "velocity" in entry:
                 kwargs["velocity"] = entry["velocity"]
             if "shape_parameters" in entry:
@@ -190,6 +205,8 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
 
         elif part_type == "piston_box":
             kwargs = {}
+            if "name" in entry:
+                kwargs["name"] = entry["name"]
             if "velocity" in entry:
                 kwargs["velocity"] = entry["velocity"]
             if "shape_parameters" in entry:
@@ -200,6 +217,8 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
 
         elif part_type == "piston_mesh":
             kwargs = {"filename": entry["file"]}
+            if "name" in entry:
+                kwargs["name"] = entry["name"]
             if "velocity" in entry:
                 kwargs["velocity"] = entry["velocity"]
             if "material" in entry:
@@ -243,6 +262,14 @@ def _build_varying(varying_config: list[dict]) -> list[ExperimentVarying]:
                 VaryMaterial(entry["part"], [_resolve_material(m) for m in materials])
             )
 
+        elif "part" in entry and "velocity" in entry:
+            velocities = entry["velocity"]
+            if not isinstance(velocities, list):
+                raise ValueError(
+                    f"varying 'velocity' must be a list of velocity profiles, got: {velocities!r}"
+                )
+            varying.append(VaryVelocity(entry["part"], velocities))
+
         elif "field" in entry and "values" in entry:
             varying.append(VarySimulationParameter(entry["field"], entry["values"]))
 
@@ -366,6 +393,7 @@ def run_experiment(
     CompressionExperiment(
         simulation=sim,
         varying=varying,
+        simulation_names=config.get("simulation_names"),
         auto_download_results=wait_for_results,
     )
 

{metafold-0.12.dev11 → metafold-0.13.0}/metafold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.12.dev11
+Version: 0.13.0
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs~=23.2
@@ -38,7 +38,7 @@ Requires-Dist: dotenv>=0.9.9; extra == "simulation"
 Requires-Dist: pandas>=2.3.3; extra == "simulation"
 Requires-Dist: plyfile>=1.1.3; extra == "simulation"
 Requires-Dist: pyyaml>=6.0.3; extra == "simulation"
-Requires-Dist: simulation-configurator==0.1.2; extra == "simulation"
+Requires-Dist: simulation-configurator==0.2.*; extra == "simulation"
 Requires-Dist: tables>=3.11.1; extra == "simulation"
 Dynamic: license-file
 

{metafold-0.12.dev11 → metafold-0.13.0}/metafold.egg-info/requires.txt

@@ -9,5 +9,5 @@ dotenv>=0.9.9
 pandas>=2.3.3
 plyfile>=1.1.3
 pyyaml>=6.0.3
-simulation-configurator==0.1.2
+simulation-configurator==0.2.*
 tables>=3.11.1

{metafold-0.12.dev11 → metafold-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metafold"
-version = "0.12.dev11"
+version = "0.13.0"
 authors = [
     {name = "Metafold 3D", email = "info@metafold3d.com"},
 ]
@@ -18,7 +18,7 @@ dependencies = [
 readme = "README.md"
 license = {file = "LICENSE"}
 description = "Metafold SDK for Python"
-requires-python = ">=3.12"
+requires-python = ">=3.11"
 keywords = ["metafold", "api", "sdk", "implicit geometry"]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -38,7 +38,7 @@ simulation = [
     "pandas>=2.3.3",
     "plyfile>=1.1.3",
     "pyyaml>=6.0.3",
-    "simulation-configurator==0.1.2",
+    "simulation-configurator==0.2.*",
     "tables>=3.11.1",
 ]
 
@@ -68,7 +68,7 @@ packages = ["metafold", "metafold.simulation"]
 environments = ["sys_platform == 'linux'"]
 
 [tool.uv.sources]
-simulation-configurator = { index = "sim-config-idx" }
+simulation-configurator = { index = "gitlab" }
 
 [[tool.mypy.overrides]]
 module = [
@@ -79,7 +79,7 @@ module = [
 ignore_missing_imports = true
 
 [[tool.uv.index]]
-name = "sim-config-idx"
+name = "gitlab"
 url = "https://gitlab.com/api/v4/projects/75460563/packages/pypi/simple"
 explicit = true
 authenticate = "always"

{metafold-0.12.dev11 → metafold-0.13.0}/tests/test_compession_experiment.py

@@ -4,7 +4,13 @@ import copy
 from pathlib import Path
 from unittest.mock import MagicMock
 
-from metafold.simulation.compression_experiment import CompressionExperiment, VaryMesh, VaryMaterial, VarySimulationParameter
+from metafold.simulation.compression_experiment import (
+    CompressionExperiment,
+    VaryMesh,
+    VaryMaterial,
+    VarySimulationParameter,
+    VaryVelocity,
+)
 from metafold.materials import Material, ConstitutiveModel, RigidParams
 
 
@@ -246,6 +252,132 @@ class TestVaryMaterialSweep:
         assert v.materials[1].constitutive_model.params.shear_modulus == 20.0
 
 
+PROFILES = [
+    [[0.0, 0, 0, 0.0], [0.04, 0, 0, -1.25]],
+    [[0.0, 0, 0, 0.0], [0.04, 0, 0, -2.50]],
+]
+
+
+class TestVaryVelocity:
+    def test_resolve_sets_sim_count(self, tmp_path):
+        v = VaryVelocity("piston", PROFILES)
+        v.resolve(tmp_path)
+        assert v.sim_count == 2
+
+    def test_apply_to_sets_velocity(self, mock_sim):
+        v = VaryVelocity("piston", PROFILES)
+        v.apply_to(0, mock_sim)
+        assert mock_sim.get_part_info("piston").part.velocity == PROFILES[0]
+        v.apply_to(1, mock_sim)
+        assert mock_sim.get_part_info("piston").part.velocity == PROFILES[1]
+
+    def test_single_flat_profile_rejected(self):
+        # one profile passed where a list of profiles is expected
+        with pytest.raises(ValueError, match="list of \\[t, vx, vy, vz\\] rows"):
+            VaryVelocity("piston", [[0.0, 0, 0, 0.0], [0.04, 0, 0, -1.25]])
+
+    def test_malformed_row_rejected(self):
+        with pytest.raises(ValueError, match="rows"):
+            VaryVelocity("piston", [[[0.0, 0, 0]]])  # 3 floats, not 4
+
+    def test_non_rigid_part_rejected(self, mock_sim):
+        class PlainPart:  # no velocity attribute, unlike piston/support parts
+            name = "midsole"
+
+        info = MagicMock()
+        info.part = PlainPart()
+        mock_sim.get_part_info.side_effect = lambda n: info
+
+        v = VaryVelocity("midsole", PROFILES)
+        with pytest.raises(ValueError, match="not a rigid"):
+            v.apply_to(0, mock_sim)
+
+
+class TestSimulationNames:
+    def _experiment(self, mock_sim, names, varying=None):
+        return CompressionExperiment(
+            mock_sim,
+            varying if varying is not None else [VaryMesh("midsole", "mid-*.ply")],
+            simulation_names=names,
+            auto_run=False,
+        )
+
+    def test_custom_names_used(self, mock_sim):
+        exp = self._experiment(mock_sim, ["a", "b", "c"])
+        exp.prepare()
+        assert [s.simulation_name for s in exp.sims] == ["a", "b", "c"]
+
+    def test_blank_name_falls_back_to_auto(self, mock_sim):
+        exp = self._experiment(mock_sim, ["a", "", "c"])
+        exp.prepare()
+        assert [s.simulation_name for s in exp.sims] == ["a", "base_sim_sim1", "c"]
+
+    def test_short_list_falls_back_to_auto(self, mock_sim):
+        exp = self._experiment(mock_sim, ["a"])
+        exp.prepare()
+        assert [s.simulation_name for s in exp.sims] == [
+            "a", "base_sim_sim1", "base_sim_sim2"]
+
+    def test_duplicate_names_rejected(self, mock_sim):
+        with pytest.raises(ValueError, match="unique"):
+            self._experiment(mock_sim, ["a", "a", "c"])
+
+    def test_name_colliding_with_auto_name_rejected(self, mock_sim):
+        # sim1's fallback name is base_sim_sim1; naming sim0 the same collides
+        with pytest.raises(ValueError, match="unique"):
+            self._experiment(mock_sim, ["base_sim_sim1"])
+
+    def test_path_separator_rejected(self, mock_sim):
+        with pytest.raises(ValueError, match="path separator"):
+            self._experiment(mock_sim, ["run/1"])
+
+    def test_none_entry_falls_back_to_auto(self, mock_sim):
+        exp = self._experiment(mock_sim, [None, "custom2", None])
+        exp.prepare()
+        assert [s.simulation_name for s in exp.sims] == [
+            "base_sim_sim0", "custom2", "base_sim_sim2"]
+
+    def test_non_list_rejected(self, mock_sim):
+        with pytest.raises(ValueError, match="list of strings"):
+            self._experiment(mock_sim, "baseline")
+
+    def test_non_string_entry_rejected(self, mock_sim):
+        with pytest.raises(ValueError, match="list of strings"):
+            self._experiment(mock_sim, ["a", 2])
+
+    def test_force_rerun_clears_custom_named_results(self, mock_sim):
+        stale = mock_sim.out_dir / "custom_a_results.json"
+        stale.write_text("{}")
+        exp = self._experiment(mock_sim, ["custom_a", "b", "c"])
+        exp.force_rerun = True
+        exp._clear_saved_state()
+        assert not stale.exists()
+
+
+class TestVaryingCountMismatch:
+    def test_mismatched_counts_rejected(self, mock_sim):
+        with pytest.raises(ValueError, match="same number"):
+            CompressionExperiment(
+                mock_sim,
+                [
+                    VaryMesh("midsole", "mid-*.ply"),  # 3 files
+                    VaryVelocity("piston", PROFILES),  # 2 profiles
+                ],
+                auto_run=False,
+            )
+
+    def test_matching_counts_accepted(self, mock_sim):
+        exp = CompressionExperiment(
+            mock_sim,
+            [
+                VarySimulationParameter("max_time", [0.02, 0.04]),
+                VaryVelocity("piston", PROFILES),
+            ],
+            auto_run=False,
+        )
+        assert exp.varying[0].sim_count == exp.varying[1].sim_count == 2
+
+
 class TestVarySimulationParameter:
     def test_resolve_sets_sim_count(self, tmp_path):
         v = VarySimulationParameter("max_time", [0.02, 0.04, 0.06])

{metafold-0.12.dev11 → metafold-0.13.0}/tests/test_compression_simulation.py

@@ -167,13 +167,15 @@ class TestBuildWorkflow:
         assert isinstance(piston.part, ExperimentPistonBase)
         assert piston.material_index == 0
 
-    def test_build_workflow_has_per_part_metrics_jobs(self, prepared_sim):
-        yaml_str, _ = prepared_sim.build_workflow()
+    def test_prep_workflow_has_per_part_metrics_jobs(self, prepared_sim):
+        mesh_parts = [p for p in prepared_sim.part_infos if hasattr(p.part, "filename")]
+        yaml_str, _, _ = prepared_sim._build_sample_workflow_for_batch(mesh_parts)
         loaded = yaml.safe_load(yaml_str)
-        # one metrics job per non-piston mesh part
+        # one metrics job per non-piston mesh part, chained to its sample job
         for info in prepared_sim.part_infos:
             if not isinstance(info.part, ExperimentPistonBase) and hasattr(info.part, "filename"):
-                assert f"metrics-{info.part_unique_name}" in loaded["jobs"]
+                job = loaded["jobs"][f"metrics-{info.part_unique_name}"]
+                assert job["needs"] == [f"sample-mesh-{info.part_unique_name}"]
 
     def test_build_workflow_compress_has_velocity(self, prepared_sim):
         _, params = prepared_sim.build_workflow()
@@ -577,6 +579,23 @@ jobs:
     - force-displacement
     assets:
       data: force-displacement
+  reduce-results:
+    type: sim/postprocess/reduce-results
+    needs:
+    - compress
+    - von-mises-stress
+    - effective-strain
+    - particle-displacement
+    assets:
+      data:
+      - job: compress
+        asset: output
+      - job: von-mises-stress
+        asset: output
+      - job: effective-strain
+        asset: output
+      - job: particle-displacement
+        asset: output
 """
         assert yaml_str.strip() == expected_yaml.strip()
 
@@ -1130,6 +1149,7 @@ class TestSetupClient:
             simulation_name="t",
             stl_folder_path=str(ply_folder),
             output_path=str(tmp_path / "out"),
+            env_source=None,  # Ensure local .env files do not pollute test environment
             **kwargs,
         )
 

{metafold-0.12.dev11 → metafold-0.13.0}/tests/test_run_experiment.py

@@ -36,6 +36,7 @@ from metafold.simulation.compression_experiment import (
     VaryMaterial,
     VaryMesh,
     VarySimulationParameter,
+    VaryVelocity,
 )
 
 
@@ -109,6 +110,18 @@ class TestBuildParts:
         assert isinstance(parts[0], ExperimentPistonMesh)
         assert parts[0].filename == "piston.ply"
 
+    def test_piston_parts_custom_name(self):
+        parts = _build_parts([
+            {"type": "piston_mesh", "name": "last", "file": "last.ply"},
+            {"type": "piston_cylinder", "name": "press"},
+            {"type": "piston_box", "name": "anvil"},
+        ])
+        assert [p.name for p in parts] == ["last", "press", "anvil"]
+
+    def test_piston_parts_default_name_when_omitted(self):
+        parts = _build_parts([{"type": "piston_mesh", "file": "piston.ply"}])
+        assert parts[0].name == "piston"
+
     def test_piston_mesh_with_velocity(self):
         velocity = [[0.0, 0, 0, 0.0], [0.02, 0, 0, -1.25], [0.04, 0, 0, 0.0]]
         parts = _build_parts([{"type": "piston_mesh", "file": "piston.ply", "velocity": velocity}])
@@ -220,6 +233,20 @@ class TestBuildVarying:
         assert varying[0].field_path == "max_time"
         assert varying[0].values == [0.02, 0.04, 0.06]
 
+    def test_vary_velocity(self):
+        profiles = [
+            [[0.0, 0, 0, 0.0], [0.04, 0, 0, -1.25]],
+            [[0.0, 0, 0, 0.0], [0.04, 0, 0, -2.50]],
+        ]
+        varying = _build_varying([{"part": "piston", "velocity": profiles}])
+        assert isinstance(varying[0], VaryVelocity)
+        assert varying[0].part_name == "piston"
+        assert varying[0].velocities == profiles
+
+    def test_vary_velocity_non_list_rejected(self):
+        with pytest.raises(ValueError, match="velocity"):
+            _build_varying([{"part": "piston", "velocity": "nope"}])
+
     def test_unrecognised_entry_raises(self):
         with pytest.raises(ValueError, match="Unrecognised varying"):
             _build_varying([{"unknown_key": "foo"}])
@@ -394,6 +421,26 @@ class TestRunExperiment:
         assert params.max_time == 0.02
         assert params.max_resolution == 128
 
+    def test_simulation_names_passed_to_experiment(self, ply_folder, tmp_path):
+        fake_sim = self._fake_sim(ply_folder)
+        captured = {}
+
+        def capture_experiment(*args, **kwargs):
+            captured.update(kwargs)
+
+        with (
+            patch("metafold.simulation.run_experiment.CompressionSimulation", return_value=fake_sim),
+            patch("metafold.simulation.run_experiment.CompressionExperiment", side_effect=capture_experiment),
+        ):
+            run_experiment({
+                "project_name": "t",
+                "output_path": str(tmp_path / "out"),
+                "parts": [],
+                "simulation_names": ["baseline", "stiff outsole"],
+            })
+
+        assert captured["simulation_names"] == ["baseline", "stiff outsole"]
+
     def test_workflow_steps_config_passed_to_simulation(self, ply_folder, tmp_path):
         fake_sim = self._fake_sim(ply_folder)
         captured = {}