metafold 0.12.1__tar.gz → 0.13.dev1__tar.gz

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

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

{metafold-0.12.1 → 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.12.1 → metafold-0.13.dev1}/metafold/simulation/compression_simulation.py

@@ -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:
@@ -444,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,
@@ -1475,6 +1477,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 = {}
@@ -1511,6 +1532,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
         )
@@ -2413,27 +2437,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

{metafold-0.12.1 → 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.12.1 → metafold-0.13.dev1}/metafold.egg-info/PKG-INFO

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

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

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

{metafold-0.12.1 → 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.12.1 → metafold-0.13.dev1}/tests/test_compression_simulation.py

@@ -579,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()
 

{metafold-0.12.1 → 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 = {}