metafold 0.12.dev6__tar.gz → 0.12.dev8__tar.gz

{metafold-0.12.dev6 → metafold-0.12.dev8}/PKG-INFO

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

{metafold-0.12.dev6 → metafold-0.12.dev8}/metafold/simulation/compression_simulation.py

@@ -345,6 +345,15 @@ class CompressionSimulation:
         # workflow. Downstream main-workflow jobs (metrics, compress) consume
         # this directly as an asset by filename.
         volume_filename: Optional[str] = None
+        # Mesh bounds ({"min": [...], "max": [...]}, mm) reported by the
+        # pass-1 preprocess job; used to density-match sampling resolutions.
+        bounds: Optional[dict] = None
+        # Output asset filenames from the pass-1 preprocess/BVH jobs, bound
+        # as inputs to the pass-2 sample job so nothing is recomputed.
+        preprocessed_filename: Optional[str] = None
+        bvh_filename: Optional[str] = None
+        # Sampling resolution (longest axis) assigned for the pass-2 sample job.
+        sample_resolution: Optional[int] = None
         patch: dict = field(default_factory=dict)
         jobs: dict[str, Any] = field(default_factory=lambda: {})
         part_unique_name = ""
@@ -407,6 +416,10 @@ class CompressionSimulation:
     prep_workflows: list[Workflow] = []
     prep_workflow_batch_size: int = 10
     write_ups: bool = True
+    # Sample spacing (mm) anchored to the representative part's longest axis:
+    # longest_axis / (max_resolution - 1). Cached so experiment variants
+    # sampled later match the base simulation's density.
+    sample_spacing: Optional[float] = None
 
     def __init__(
         self,
@@ -735,8 +748,10 @@ class CompressionSimulation:
                     asset = self.client.assets.create(str(info.file_path))
                 info.asset = asset
 
-    def _build_prep_workflow_for_batch(self, batch: list) -> tuple[str, dict, dict]:
-        """Build the YAML, params, and assets for one batch of part_infos."""
+    def _build_preprocess_workflow_for_batch(self, batch: list) -> tuple[str, dict, dict]:
+        """Build the pass-1 prep workflow: preprocess (+ BVH) per part. The
+        preprocess job outputs each mesh's exact bounds, used to density-match
+        the pass-2 sampling resolutions. No sampling happens in this pass."""
         jobs: dict = {}
         params: dict = {}
         assets: dict = {}
@@ -753,7 +768,6 @@ class CompressionSimulation:
             assets[f"{preprocess_job}.mesh"] = part_info.part.filename
             part_info.jobs["preprocess-mesh"] = preprocess_job
 
-            compute_bvh_job = ""
             if self._get_step(WorkflowStepType.COMPUTE_BVH, part_info.part.name):
                 compute_bvh_job = f"compute-bvh-{unique_name}"
                 jobs[compute_bvh_job] = {
@@ -763,25 +777,169 @@ class CompressionSimulation:
                 }
                 part_info.jobs["compute-bvh"] = compute_bvh_job
 
+        workflow_yaml = yaml.dump({"jobs": jobs}, default_flow_style=False)
+        return workflow_yaml, params, assets
+
+    def _build_sample_workflow_for_batch(self, batch: list) -> tuple[str, dict, dict]:
+        """Build the pass-2 sampling workflow: one implicit/from-mesh job per
+        part at its density-matched resolution, reusing the preprocessed mesh
+        and BVH assets produced in pass 1."""
+        jobs: dict = {}
+        params: dict = {}
+        assets: dict = {}
+
+        for part_info in batch:
+            if not hasattr(part_info.part, "filename"):
+                continue
+            if part_info.part.filename is None:
+                continue
+            unique_name = part_info.part_unique_name
+
             sample_mesh_job = f"sample-mesh-{unique_name}"
-            sample_mesh_def: dict = {
-                "type": "implicit/from-mesh",
-                "needs": [preprocess_job],
-                "assets": {"mesh": preprocess_job},
-            }
-            if compute_bvh_job:
-                sample_mesh_def["needs"].append(compute_bvh_job)
-                sample_mesh_def["assets"]["bvh"] = compute_bvh_job
-            jobs[sample_mesh_job] = sample_mesh_def
+            if part_info.preprocessed_filename:
+                # Bind the pass-1 outputs directly; nothing is recomputed.
+                jobs[sample_mesh_job] = {"type": "implicit/from-mesh"}
+                assets[f"{sample_mesh_job}.mesh"] = part_info.preprocessed_filename
+                if part_info.bvh_filename:
+                    assets[f"{sample_mesh_job}.bvh"] = part_info.bvh_filename
+            else:
+                # Pass-1 outputs unavailable for this part: fall back to the
+                # full in-workflow chain (slightly wasteful, never wrong).
+                preprocess_job = f"preprocess-mesh-{unique_name}"
+                jobs[preprocess_job] = {"type": "mesh/preprocess"}
+                assets[f"{preprocess_job}.mesh"] = part_info.part.filename
+                part_info.jobs["preprocess-mesh"] = preprocess_job
+
+                sample_mesh_def: dict = {
+                    "type": "implicit/from-mesh",
+                    "needs": [preprocess_job],
+                    "assets": {"mesh": preprocess_job},
+                }
+                if self._get_step(WorkflowStepType.COMPUTE_BVH, part_info.part.name):
+                    compute_bvh_job = f"compute-bvh-{unique_name}"
+                    jobs[compute_bvh_job] = {
+                        "type": "mesh/compute-bvh",
+                        "needs": [preprocess_job],
+                        "assets": {"mesh": preprocess_job},
+                    }
+                    part_info.jobs["compute-bvh"] = compute_bvh_job
+                    sample_mesh_def["needs"].append(compute_bvh_job)
+                    sample_mesh_def["assets"]["bvh"] = compute_bvh_job
+                jobs[sample_mesh_job] = sample_mesh_def
 
-            params[f"{sample_mesh_job}.resolution"] = (
-                f"{self.simulation_parameters.max_resolution}"
+            resolution = part_info.sample_resolution or int(
+                self.simulation_parameters.max_resolution
             )
+            params[f"{sample_mesh_job}.resolution"] = f"{resolution}"
             part_info.jobs["sample-mesh"] = sample_mesh_job
 
         workflow_yaml = yaml.dump({"jobs": jobs}, default_flow_style=False)
         return workflow_yaml, params, assets
 
+    def _run_workflow_batches(self, batches: list, build_workflow_fn) -> list:
+        """Dispatch one workflow per batch (all in parallel), then wait for
+        every workflow to finish. Raises if any failed."""
+        workflows = []
+        for batch in batches:
+            workflow_yaml, params, assets = build_workflow_fn(batch)
+            wf = self.client.workflows.run_async(
+                workflow_yaml, parameters=params, assets=assets
+            )
+            workflows.append(wf)
+
+        for i, wf in enumerate(workflows):
+            while wf.state not in ["success", "failure", "canceled"]:
+                sleep(1)
+                wf = self.client.workflows.get(wf.id)
+            workflows[i] = wf
+
+        failed = [wf for wf in workflows if wf.state != "success"]
+        if failed:
+            raise RuntimeError(f"{len(failed)} prep workflow(s) failed")
+        return workflows
+
+    @staticmethod
+    def _job_output_asset_filename(job) -> Optional[str]:
+        """First output asset filename of a job, preferring the named outputs
+        mapping and falling back to the deprecated flat asset list."""
+        outputs = getattr(job, "outputs", None)
+        named = getattr(outputs, "assets", None) if outputs is not None else None
+        if isinstance(named, dict):
+            for asset in named.values():
+                filename = getattr(asset, "filename", None)
+                if filename:
+                    return filename
+        for asset in getattr(job, "assets", None) or []:
+            filename = getattr(asset, "filename", None)
+            if filename:
+                return filename
+        return None
+
+    def _collect_preprocess_outputs(self, part_infos: list, workflows: list):
+        """Read mesh bounds and output asset filenames from the pass-1
+        preprocess/BVH jobs onto each part_info."""
+        jobs_by_name = {
+            job.name: job
+            for wf in workflows
+            for job_id in wf.jobs
+            if (job := self.client.jobs.get(job_id)) is not None
+        }
+        for info in part_infos:
+            pre_job = jobs_by_name.get(info.jobs.get("preprocess-mesh", ""), None)
+            if pre_job is None:
+                continue
+
+            outputs = getattr(pre_job, "outputs", None)
+            out_params = getattr(outputs, "params", None) if outputs is not None else None
+            if isinstance(out_params, dict) and "bounds" in out_params:
+                bounds = out_params["bounds"]
+                info.bounds = json.loads(bounds) if isinstance(bounds, str) else bounds
+            info.preprocessed_filename = self._job_output_asset_filename(pre_job)
+
+            bvh_job = jobs_by_name.get(info.jobs.get("compute-bvh", ""), None)
+            if bvh_job is not None:
+                info.bvh_filename = self._job_output_asset_filename(bvh_job)
+
+    @staticmethod
+    def _bounds_longest_axis(bounds: dict) -> float:
+        mn = np.array(bounds["min"], dtype=np.float64)
+        mx = np.array(bounds["max"], dtype=np.float64)
+        return float(np.max(mx - mn))
+
+    def _assign_sample_resolutions(self, part_infos: list):
+        """Assign each part a sampling resolution so all parts share the
+        representative part's sample spacing. Parts smaller than the
+        representative get proportionally lower resolutions (and larger ones
+        higher), keeping particle density uniform across the simulation."""
+        max_resolution = max(2, int(self.simulation_parameters.max_resolution))
+
+        if self.sample_spacing is None:
+            # Prefer a representative-named info from the batch being sampled:
+            # experiments fork varied parts, so the base sim's own info may
+            # not carry the pass-1 bounds.
+            rep_info = next(
+                (
+                    i for i in part_infos
+                    if i.part.name == self.representative_part and i.bounds
+                ),
+                None,
+            ) or self.get_part_info(self.representative_part)
+            if rep_info is not None and rep_info.bounds:
+                self.sample_spacing = self._bounds_longest_axis(rep_info.bounds) / (
+                    max_resolution - 1
+                )
+
+        for info in part_infos:
+            if self.sample_spacing and info.bounds:
+                longest = self._bounds_longest_axis(info.bounds)
+                info.sample_resolution = max(
+                    2, int(round(longest / self.sample_spacing)) + 1
+                )
+            else:
+                # Legacy fallback: this part samples at max_resolution over
+                # its own bounds (density then depends on the part's size).
+                info.sample_resolution = max_resolution
+
     def sample_assets(self, part_infos=None):
         if part_infos is None:
             part_infos = self.part_infos
@@ -793,25 +951,25 @@ class CompressionSimulation:
             for i in range(0, max(len(mesh_parts), 1), batch_size)
         ]
 
-        # Launch all batch workflows in parallel
-        self.prep_workflows = []
-        for i, batch in enumerate(batches):
-            workflow_yaml, params, assets = self._build_prep_workflow_for_batch(batch)
-            wf = self.client.workflows.run_async(
-                workflow_yaml, parameters=params, assets=assets
-            )
-            self.prep_workflows.append(wf)
+        # Pass 1: preprocess (+ BVH) every mesh. The preprocess job reports
+        # each mesh's exact bounds without sampling anything.
+        preprocess_workflows = self._run_workflow_batches(
+            batches, self._build_preprocess_workflow_for_batch
+        )
+        self._collect_preprocess_outputs(mesh_parts, preprocess_workflows)
 
-        # Wait for all to finish
-        for i, wf in enumerate(self.prep_workflows):
-            while wf.state not in ["success", "failure", "canceled"]:
-                sleep(1)
-                wf = self.client.workflows.get(wf.id)
-            self.prep_workflows[i] = wf
+        # Anchor sample spacing to the representative part so every part is
+        # sampled at the same spatial density (the grid is sized from the
+        # representative patch downstream).
+        self._assign_sample_resolutions(mesh_parts)
 
-        failed = [wf for wf in self.prep_workflows if wf.state != "success"]
-        if failed:
-            raise RuntimeError(f"{len(failed)} prep workflow(s) failed")
+        # Pass 2: sample each mesh at its density-matched resolution, reusing
+        # the preprocessed/BVH assets from pass 1.
+        sample_workflows = self._run_workflow_batches(
+            batches, self._build_sample_workflow_for_batch
+        )
+
+        self.prep_workflows = preprocess_workflows + sample_workflows
 
     def collect_sampled_volumes(self, part_infos=None):
         if part_infos is None:

{metafold-0.12.dev6 → metafold-0.12.dev8}/metafold/simulation/run_experiment.py

@@ -29,7 +29,9 @@ JSON manifest format
             ]
         },
         {"type": "piston_box", "shape_parameters": {"min": [...], "max": [...]}},
-        {"type": "piston_mesh", "file": "piston.ply", "velocity": [...]},
+        # piston parts take an optional "material" (preset key or inline dict);
+        # omit to use DEFAULT_PISTON_MATERIAL
+        {"type": "piston_mesh", "file": "piston.ply", "velocity": [...], "material": "default_piston_material"},
         {
             "type":           "mesh",
             "name":           "midsole",
@@ -59,6 +61,9 @@ JSON manifest format
 
     "simulation": {
         "max_time": 0.04,
+        # Sampling resolution along the representative part's longest axis.
+        # Other parts sample at resolutions scaled to their size so every
+        # part shares the same spatial density.
         "max_resolution": 512,
 
         # Force source for force-displacement: "boundary_force" (default) or
@@ -177,6 +182,8 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
                 kwargs["velocity"] = entry["velocity"]
             if "shape_parameters" in entry:
                 kwargs["shape_parameters"] = entry["shape_parameters"]
+            if "material" in entry:
+                kwargs["material"] = _resolve_material(entry["material"])
             parts.append(ExperimentPistonCylinder(**kwargs))
 
         elif part_type == "piston_box":
@@ -185,12 +192,16 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
                 kwargs["velocity"] = entry["velocity"]
             if "shape_parameters" in entry:
                 kwargs["shape_parameters"] = entry["shape_parameters"]
+            if "material" in entry:
+                kwargs["material"] = _resolve_material(entry["material"])
             parts.append(ExperimentPistonBox(**kwargs))
 
         elif part_type == "piston_mesh":
             kwargs = {"filename": entry["file"]}
             if "velocity" in entry:
                 kwargs["velocity"] = entry["velocity"]
+            if "material" in entry:
+                kwargs["material"] = _resolve_material(entry["material"])
             parts.append(ExperimentPistonMesh(**kwargs))
 
         else:

{metafold-0.12.dev6 → metafold-0.12.dev8}/metafold.egg-info/PKG-INFO

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

{metafold-0.12.dev6 → metafold-0.12.dev8}/pyproject.toml

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

{metafold-0.12.dev6 → metafold-0.12.dev8}/tests/test_compression_simulation.py

@@ -1,4 +1,5 @@
 from io import BytesIO
+from types import SimpleNamespace
 from zipfile import ZipFile
 
 import pytest
@@ -13,6 +14,7 @@ from metafold.simulation.compression_simulation import (
     ExperimentMesh,
     ExperimentPistonBase,
     ExperimentPistonCylinder,
+    SimulationParameters,
     WorkflowStep,
     WorkflowStepType,
 )
@@ -315,15 +317,15 @@ class TestSampleAssets:
         )
         assert s.prep_workflow_batch_size == 5
 
-    def test_fewer_parts_than_batch_size_runs_one_workflow(self, sim):
-        # 3 mesh parts, batch_size=10 → 1 workflow
+    def test_fewer_parts_than_batch_size_runs_one_workflow_per_pass(self, sim):
+        # 3 mesh parts, batch_size=10 → 1 batch × 2 passes (preprocess, sample)
         sim.client.workflows.run_async.return_value = self._make_success_workflow()
         sim.sample_assets()
-        assert sim.client.workflows.run_async.call_count == 1
-        assert len(sim.prep_workflows) == 1
+        assert sim.client.workflows.run_async.call_count == 2
+        assert len(sim.prep_workflows) == 2
 
     def test_parts_split_into_multiple_batches(self, ply_folder, basic_parts, tmp_path):
-        # 3 mesh parts, batch_size=2 → 2 workflows
+        # 3 mesh parts, batch_size=2 → 2 batches × 2 passes
         sim = CompressionSimulation(
             parts=basic_parts,
             simulation_name="t",
@@ -334,23 +336,48 @@ class TestSampleAssets:
         )
         sim.client.workflows.run_async.return_value = self._make_success_workflow()
         sim.sample_assets()
-        assert sim.client.workflows.run_async.call_count == 2
-        assert len(sim.prep_workflows) == 2
+        assert sim.client.workflows.run_async.call_count == 4
+        assert len(sim.prep_workflows) == 4
 
-    def test_all_workflows_launched_before_any_wait(self, sim):
-        # run_async should be called for all batches before workflows.get is polled
-        call_log = []
-        sim.client.workflows.run_async.side_effect = lambda *a, **kw: (
-            call_log.append("launch") or self._make_success_workflow()
+    def test_all_workflows_launched_before_any_wait(
+        self, ply_folder, basic_parts, tmp_path, monkeypatch
+    ):
+        # Within a pass, run_async is called for every batch before
+        # workflows.get is polled (batches run in parallel).
+        monkeypatch.setattr(
+            "metafold.simulation.compression_simulation.sleep", lambda s: None
         )
-        sim.client.workflows.get.side_effect = lambda id: (
-            call_log.append("poll") or self._make_success_workflow()
+        sim = CompressionSimulation(
+            parts=basic_parts,
+            simulation_name="t",
+            stl_folder_path=str(ply_folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+            prep_workflow_batch_size=2,  # 2 batches per pass
         )
+        call_log = []
+        pending_then_done = []
+
+        def launch(*a, **kw):
+            call_log.append("launch")
+            wf = MagicMock()
+            wf.state = "pending"
+            wf.jobs = []
+            wf.id = f"wf{len(call_log)}"
+            pending_then_done.append(wf)
+            return wf
+
+        def poll(id):
+            call_log.append("poll")
+            return self._make_success_workflow()
+
+        sim.client.workflows.run_async.side_effect = launch
+        sim.client.workflows.get.side_effect = poll
         sim.sample_assets()
-        # all launches happened before any polls
-        last_launch = max(i for i, e in enumerate(call_log) if e == "launch")
-        first_poll = next((i for i, e in enumerate(call_log) if e == "poll"), len(call_log))
-        assert last_launch < first_poll
+
+        # Pass 1: both batch launches happen before the first poll
+        first_poll = call_log.index("poll")
+        assert call_log[:first_poll].count("launch") == 2
 
     def test_failed_workflow_raises(self, sim):
         failed_wf = MagicMock()
@@ -368,6 +395,116 @@ class TestSampleAssets:
                 assert "sample-mesh" in info.jobs
                 assert "preprocess-mesh" in info.jobs
 
+    def test_fallback_resamples_at_max_resolution_with_full_chain(self, sim):
+        # When pass-1 outputs are unavailable (no bounds, no preprocessed
+        # asset), pass 2 falls back to the legacy per-part chain at
+        # max_resolution.
+        sim.client.workflows.run_async.return_value = self._make_success_workflow()
+        sim.sample_assets()
+
+        max_res = int(sim.simulation_parameters.max_resolution)
+        for info in sim.part_infos:
+            if hasattr(info.part, "filename"):
+                assert info.sample_resolution == max_res
+
+        _, kwargs = sim.client.workflows.run_async.call_args_list[1]
+        assert kwargs["parameters"]["sample-mesh-midsole.resolution"] == str(max_res)
+        # Full chain rebuilt in the sampling workflow
+        yaml_arg = sim.client.workflows.run_async.call_args_list[1][0][0]
+        assert "mesh/preprocess" in yaml_arg
+
+
+class TestDensityMatchedSampling:
+    """Sampling resolutions are scaled per part so every mesh shares the
+    representative part's sample spacing (the piston-density regression)."""
+
+    def _make_job(self, name, longest_axis=None, asset_key=None, filename=None):
+        params = {}
+        if longest_axis is not None:
+            params["bounds"] = json.dumps(
+                {"min": [0.0, 0.0, 0.0], "max": [longest_axis, 50.0, 20.0]}
+            )
+        assets = {asset_key: SimpleNamespace(filename=filename)} if asset_key else {}
+        return SimpleNamespace(
+            name=name, outputs=SimpleNamespace(params=params, assets=assets), assets=[]
+        )
+
+    @pytest.fixture
+    def sampled_sim(self, ply_folder, basic_parts, tmp_path):
+        # max_resolution=31 and rep (midsole) longest axis 300 → spacing 10
+        sim = CompressionSimulation(
+            parts=basic_parts,
+            simulation_name="t",
+            stl_folder_path=str(ply_folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+            simulation_parameters=SimulationParameters(max_resolution=31),
+        )
+
+        jobs = {
+            "p-up": self._make_job("preprocess-mesh-upper_foam", 150.0, "mesh", "pre_up.ply"),
+            "b-up": self._make_job("compute-bvh-upper_foam", None, "bvh", "bvh_up.bin"),
+            "p-mid": self._make_job("preprocess-mesh-midsole", 300.0, "mesh", "pre_mid.ply"),
+            "b-mid": self._make_job("compute-bvh-midsole", None, "bvh", "bvh_mid.bin"),
+            "p-out": self._make_job("preprocess-mesh-outsole", 600.0, "mesh", "pre_out.ply"),
+            "b-out": self._make_job("compute-bvh-outsole", None, "bvh", "bvh_out.bin"),
+        }
+        pass1_wf = SimpleNamespace(state="success", jobs=list(jobs), id="wf1")
+        pass2_wf = SimpleNamespace(state="success", jobs=[], id="wf2")
+        sim.client.workflows.run_async.side_effect = [pass1_wf, pass2_wf]
+        sim.client.jobs.get.side_effect = lambda job_id: jobs[job_id]
+
+        sim.sample_assets()
+        return sim
+
+    def test_spacing_anchored_to_representative(self, sampled_sim):
+        assert sampled_sim.sample_spacing == pytest.approx(10.0)
+
+    def test_representative_part_gets_max_resolution(self, sampled_sim):
+        assert sampled_sim.get_part_info("midsole").sample_resolution == 31
+
+    def test_smaller_part_gets_lower_resolution(self, sampled_sim):
+        # 150 mm at 10 mm spacing → 15 cells → 16 samples
+        assert sampled_sim.get_part_info("upper_foam").sample_resolution == 16
+
+    def test_larger_part_gets_higher_resolution(self, sampled_sim):
+        # 600 mm at 10 mm spacing → 60 cells → 61 samples (above max_resolution)
+        assert sampled_sim.get_part_info("outsole").sample_resolution == 61
+
+    def test_sampling_pass_binds_pass1_outputs(self, sampled_sim):
+        args, kwargs = sampled_sim.client.workflows.run_async.call_args_list[1]
+        assert kwargs["parameters"] == {
+            "sample-mesh-upper_foam.resolution": "16",
+            "sample-mesh-midsole.resolution": "31",
+            "sample-mesh-outsole.resolution": "61",
+        }
+        assert kwargs["assets"] == {
+            "sample-mesh-upper_foam.mesh": "pre_up.ply",
+            "sample-mesh-upper_foam.bvh": "bvh_up.bin",
+            "sample-mesh-midsole.mesh": "pre_mid.ply",
+            "sample-mesh-midsole.bvh": "bvh_mid.bin",
+            "sample-mesh-outsole.mesh": "pre_out.ply",
+            "sample-mesh-outsole.bvh": "bvh_out.bin",
+        }
+        # No preprocess re-run in the sampling pass
+        assert "mesh/preprocess" not in args[0]
+
+    def test_preprocess_pass_has_no_sampling(self, sampled_sim):
+        yaml_arg = sampled_sim.client.workflows.run_async.call_args_list[0][0][0]
+        assert "implicit/from-mesh" not in yaml_arg
+        assert "mesh/preprocess" in yaml_arg
+
+    def test_spacing_cached_for_later_variant_sampling(self, sampled_sim):
+        # Experiment variants sampled in a later call reuse the cached spacing
+        # even though the representative part isn't in that batch.
+        variant = CompressionSimulation.PartInfo(
+            ExperimentMesh("midsole_v1", None, "mid.ply")
+        )
+        variant.part_unique_name = "midsole_v1"
+        variant.bounds = {"min": [0.0, 0.0, 0.0], "max": [300.0, 50.0, 20.0]}
+        sampled_sim._assign_sample_resolutions([variant])
+        assert variant.sample_resolution == 31
+
 
 
 class TestWorkflowYaml:

{metafold-0.12.dev6 → metafold-0.12.dev8}/tests/test_run_experiment.py

@@ -114,6 +114,39 @@ class TestBuildParts:
         parts = _build_parts([{"type": "piston_mesh", "file": "piston.ply", "velocity": velocity}])
         assert parts[0].velocity == velocity
 
+    def test_piston_mesh_default_material_when_omitted(self):
+        from metafold.materials import DEFAULT_PISTON_MATERIAL
+        parts = _build_parts([{"type": "piston_mesh", "file": "piston.ply"}])
+        assert parts[0].material is DEFAULT_PISTON_MATERIAL
+
+    def test_piston_mesh_with_preset_material(self):
+        parts = _build_parts([
+            {"type": "piston_mesh", "file": "piston.ply", "material": "material_aluminum"}
+        ])
+        assert parts[0].material is MATERIAL_ALUMINUM
+
+    def test_piston_mesh_with_inline_material(self):
+        parts = _build_parts([
+            {
+                "type": "piston_mesh",
+                "file": "piston.ply",
+                "material": {
+                    "density": 1730.0,
+                    "thermal_conductivity": 45,
+                    "specific_heat": 4.8e-4,
+                    "constitutive_model": {
+                        "type": "rigid",
+                        "params": {"shear_modulus": 2667.0e6, "bulk_modulus": 8000.0e6},
+                    },
+                },
+            }
+        ])
+        assert parts[0].material.constitutive_model.params.get_type() == "rigid"
+
+    def test_piston_cylinder_with_material(self):
+        parts = _build_parts([{"type": "piston_cylinder", "material": "material_aluminum"}])
+        assert parts[0].material is MATERIAL_ALUMINUM
+
     def test_mesh_part_with_preset_material(self):
         parts = _build_parts([
             {