metafold 0.13.dev0__tar.gz → 0.13.dev1__tar.gz

{metafold-0.13.dev0 → metafold-0.13.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.13.dev0
+Version: 0.13.dev1
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D

{metafold-0.13.dev0 → metafold-0.13.dev1}/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,57 @@ 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 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(
+            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}"
+            )
+        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 +241,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 +283,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.13.dev0 → metafold-0.13.dev1}/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 blank/missing entry falls back to "<name>_sim<i>".
+    # Names must be unique and must not contain path separators.
+    "simulation_names": ["slow piston", "fast piston", "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,
@@ -227,6 +240,14 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
 def _build_varying(varying_config: list[dict]) -> list[ExperimentVarying]:
     varying: list[ExperimentVarying] = []
     for entry in varying_config:
+        # Each entry varies exactly one thing; to vary several, use several entries.
+        kinds = [k for k in ("files", "material", "velocity", "values") if k in entry]
+        if len(kinds) > 1:
+            raise ValueError(
+                f"varying entry may only vary one of files/material/velocity/values, "
+                f"got {kinds}: {entry}"
+            )
+
         if "part" in entry and "files" in entry:
             files = entry["files"]
             if not isinstance(files, list):
@@ -243,6 +264,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 +395,7 @@ def run_experiment(
     CompressionExperiment(
         simulation=sim,
         varying=varying,
+        simulation_names=config.get("simulation_names"),
         auto_download_results=wait_for_results,
     )
 

{metafold-0.13.dev0 → metafold-0.13.dev1}/metafold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.13.dev0
+Version: 0.13.dev1
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D

{metafold-0.13.dev0 → metafold-0.13.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metafold"
-version = "0.13.dev0"
+version = "0.13.dev1"
 authors = [
     {name = "Metafold 3D", email = "info@metafold3d.com"},
 ]

{metafold-0.13.dev0 → metafold-0.13.dev1}/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,126 @@ 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_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.13.dev0 → metafold-0.13.dev1}/tests/test_run_experiment.py

@@ -36,6 +36,7 @@ from metafold.simulation.compression_experiment import (
     VaryMaterial,
     VaryMesh,
     VarySimulationParameter,
+    VaryVelocity,
 )
 
 
@@ -220,6 +221,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 +409,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 = {}