metafold 0.12.dev8__tar.gz → 0.12.dev10__tar.gz

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

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

{metafold-0.12.dev8 → metafold-0.12.dev10}/metafold/simulation/compression_experiment.py

@@ -246,6 +246,10 @@ class CompressionExperiment:
         self.base_simulation.populate_assets(self.experiment_part_infos)
         self._log("Sampling assets...")
         self.base_simulation.sample_assets(self.experiment_part_infos)
+        # Clones were deep-copied before sampling, so copy over the spacing that
+        # was anchored during sampling — each clone's grid must match it.
+        for local_sim in self.sims:
+            local_sim.sample_spacing = self.base_simulation.sample_spacing
         self._log("Collecting sampled volumes...")
         self.base_simulation.collect_sampled_volumes(self.experiment_part_infos)
         self._log("Prepare complete.")

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

@@ -6,9 +6,9 @@ from typing import Any, Optional, Union
 from io import BytesIO
 import uuid
 
-from dotenv import load_dotenv
 from requests import HTTPError
 import yaml
+from dotenv import load_dotenv
 from metafold import MetafoldClient
 from pathlib import Path
 from numpy.typing import DTypeLike
@@ -171,7 +171,6 @@ class ExperimentPart:
 @dataclass
 class ExperimentMesh(ExperimentPart):
     filename: str = ""
-    representative_part: bool = False
 
 
 @dataclass
@@ -389,7 +388,6 @@ class CompressionSimulation:
     stl_folder: Optional[Path] = None
     out_dir: Optional[Path] = None
     results: list = []
-    representative_part: str = ""
     simulation_name: str = ""
     simulation_parameters: SimulationParameters
     piston_velocity: list[list[float]]
@@ -416,9 +414,9 @@ 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 (mm) anchored to the union ("total box") of every part's
+    # bounds: longest_axis(total_box) / (max_resolution - 1). Cached so
+    # experiment variants sampled later match the base simulation's density.
     sample_spacing: Optional[float] = None
 
     def __init__(
@@ -478,7 +476,6 @@ class CompressionSimulation:
             else:
                 self.part_infos.append(inner_part)
 
-        self.validate_parts()
         self.setup_ply_files(stl_folder_path)
         self.setup_results(output_path)
         if client is None:
@@ -538,17 +535,6 @@ class CompressionSimulation:
     def download_results(self):
         self.write_results()
 
-    def validate_parts(self):
-        for p in self.part_infos:
-            if hasattr(p.part, "representative_part") and p.part.representative_part:
-                if self.representative_part:
-                    raise ValueError(
-                        f"At most one part can have representative_part set to True"
-                    )
-                self.representative_part = p.part.name
-        if not self.representative_part:
-            raise ValueError(f"One part must have representative_part set to True")
-
     def setup_results(self, output_path):
         self.out_dir = Path(output_path)
         self.out_dir.mkdir(parents=True, exist_ok=True)
@@ -735,7 +721,12 @@ class CompressionSimulation:
 
         for info in part_infos:
             if info.file_path and info.asset is None:
-                existing = self.client.assets.list(q=f"filename:{info.part.filename}")
+                # Quote the filename so the search parser keeps it as one term,
+                # and match it exactly (the search is a case-insensitive ILIKE).
+                existing = [
+                    a for a in self.client.assets.list(q=f'filename:"{info.part.filename}"')
+                    if a.filename == info.part.filename
+                ]
                 asset = None
                 if existing:
                     asset = existing[0]
@@ -906,38 +897,65 @@ class CompressionSimulation:
         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
-                )
+    @staticmethod
+    def _part_bounds_mm(info):
+        """(min, max) axis-aligned bounds of a part in mm, or None. Mesh parts
+        report bounds via the pass-1 preprocess job (mm); primitives report
+        them analytically via get_bounds() (metres)."""
+        part = info.part
+        if isinstance(part, ExperimentPrimitive):
+            pmin, pmax = part.get_bounds()
+            return (
+                np.array(pmin, dtype=np.float64) * 1000.0,
+                np.array(pmax, dtype=np.float64) * 1000.0,
+            )
+        if info.bounds:
+            return (
+                np.array(info.bounds["min"], dtype=np.float64),
+                np.array(info.bounds["max"], dtype=np.float64),
+            )
+        return None
 
+    def _union_bounds_mm(self, part_infos: list):
+        """Union ("total box") of every part's bounds in mm, or None."""
+        mins, maxs = [], []
         for info in part_infos:
+            b = self._part_bounds_mm(info)
+            if b is not None:
+                mins.append(b[0])
+                maxs.append(b[1])
+        if not mins:
+            return None
+        return np.min(mins, axis=0), np.max(maxs, axis=0)
+
+    def _ensure_sample_spacing(self, part_infos: list):
+        """Set sample_spacing (mm) from the total box of all parts, if unset.
+        Anchoring to the union — not one 'representative' part — makes
+        max_resolution the resolution of the whole simulation's longest axis."""
+        if self.sample_spacing is not None:
+            return
+        max_resolution = max(2, int(self.simulation_parameters.max_resolution))
+        union = self._union_bounds_mm(part_infos)
+        if union is not None:
+            longest = float(np.max(union[1] - union[0]))
+            if longest > 0:
+                self.sample_spacing = longest / (max_resolution - 1)
+
+    def _assign_sample_resolutions(self, all_infos: list, mesh_infos: list):
+        """Anchor sample spacing to the total box (union of all part bounds),
+        then give each mesh a resolution scaled to its own size so every part
+        samples at the same spatial density."""
+        max_resolution = max(2, int(self.simulation_parameters.max_resolution))
+        self._ensure_sample_spacing(all_infos)
+
+        for info in mesh_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).
+                # Fallback: sample at max_resolution over the part's own bounds.
                 info.sample_resolution = max_resolution
 
     def sample_assets(self, part_infos=None):
@@ -958,10 +976,9 @@ class CompressionSimulation:
         )
         self._collect_preprocess_outputs(mesh_parts, preprocess_workflows)
 
-        # 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)
+        # Anchor sample spacing to the total box (union of all parts, primitives
+        # included) so every part samples at the same spatial density.
+        self._assign_sample_resolutions(part_infos, mesh_parts)
 
         # Pass 2: sample each mesh at its density-matched resolution, reusing
         # the preprocessed/BVH assets from pass 1.
@@ -1016,11 +1033,11 @@ class CompressionSimulation:
 
     def create_sim_config(self, name_suffix=""):
         """
-        grid_patch: the midsole patch, used as representative for grid sizing.
+        The grid spans the total box (union of every part's bounds) and is
+        sized by the shared sample spacing — no representative part.
         Piston velocity is [0,0,0] in the UPS — actual motion driven by velocity.txt.
         """
         name = self.simulation_name
-        grid_patch = self.get_part_info(self.representative_part).patch
 
         sim = Simulation(
             name,
@@ -1031,13 +1048,11 @@ class CompressionSimulation:
             timestep_multiplier=self.simulation_parameters.timestep_multiplier,
         )
 
-        grid_min = np.array(grid_patch["offset"], dtype=np.float32) * 1e-3
-        grid_max = np.array(grid_patch["size"], dtype=np.float32) * 1e-3 + grid_min
-
-        # Expand grid to contain every part's bounding box, so nothing is
-        # clipped (e.g. a support/outsole extending below the representative
-        # part). Primitives report bounds via get_bounds() in metres, mesh
-        # parts via their sampled patch (offset/size in mm)
+        # Total box: union of every part's bounding box so nothing is clipped.
+        # Primitives report bounds via get_bounds() in metres, mesh parts via
+        # their sampled patch (offset/size in mm).
+        grid_min = np.array([np.inf, np.inf, np.inf], dtype=np.float32)
+        grid_max = np.array([-np.inf, -np.inf, -np.inf], dtype=np.float32)
         for info in self.part_infos:
             part = info.part
             if isinstance(part, ExperimentPrimitive):
@@ -1057,11 +1072,10 @@ class CompressionSimulation:
         grid_max[2] += self.simulation_parameters.margin_z
 
         grid_size = grid_max - grid_min
-        spacing = (
-            np.array(grid_patch["size"], dtype=np.float32)
-            / (np.array(grid_patch["resolution"]) - 1)
-            * 1e-3
-        )
+        # Every part is sampled at this uniform (isotropic) spacing, so the grid
+        # cells match particle spacing. mm -> m.
+        self._ensure_sample_spacing(self.part_infos)
+        spacing = (self.sample_spacing or 1.0) * 1e-3
         grid_resolution = np.ceil(
             grid_size / (self.simulation_parameters.points_per_cell * spacing)
         ).astype(np.int32)
@@ -1371,20 +1385,36 @@ class CompressionSimulation:
             )
 
     def _add_to_workflow_stress_strain(self, part_infos: list[PartInfo]):
-        job_name_base = "stress-strain"
-        self._add_to_workflow_postprocess(
-            part_infos, "force-displacement", job_name_base
-        )
-        self.workflow_params[f"{job_name_base}.keys"] = json.dumps(
-            ["/force_displacement"]
-        )
-        representative_patch = self.get_part_info(self.representative_part).patch
-        self.workflow_params[f"{job_name_base}.compression_area"] = str(
-            representative_patch["size"][0] * representative_patch["size"][1]
-        )
-        self.workflow_params[f"{job_name_base}.initial_length"] = str(
-            representative_patch["size"][2]
+        # One stress-strain job per deformable part, each normalizing the shared
+        # (global) force-displacement curve by that part's own cross-section
+        # (X*Y) and height (Z). Named stress-strain-<part> like metrics-<part>.
+        fd_job = next(
+            (p.jobs["force-displacement"] for p in part_infos
+             if "force-displacement" in p.jobs),
+            None,
         )
+        if fd_job is None:
+            return
+        for part_info in part_infos:
+            if not self._is_analysis_target(part_info.part):
+                continue
+            if part_info.disabled or not part_info.patch:
+                continue
+            job_name = f"stress-strain-{part_info.part_unique_name}"
+            self.workflow_jobs[job_name] = {
+                "type": "sim/postprocess/stress-strain",
+                "needs": [fd_job],
+                "assets": {"data": fd_job},
+            }
+            self.workflow_params[f"{job_name}.keys"] = json.dumps(
+                ["/force_displacement"]
+            )
+            size = part_info.patch["size"]
+            self.workflow_params[f"{job_name}.compression_area"] = str(
+                size[0] * size[1]
+            )
+            self.workflow_params[f"{job_name}.initial_length"] = str(size[2])
+            part_info.jobs["stress-strain"] = job_name
 
     def _add_to_workflow_particle_displacement(self, part_infos: list[PartInfo]):
         self._add_to_workflow_postprocess(
@@ -1973,16 +2003,25 @@ class CompressionSimulation:
                                     loading.to_csv(f)
                                 data["loadingForceDisplacement"] = filename
 
-                    # Stress-strain
+                    # Stress-strain: one curve per deformable part.
                     if self._contains_step(WorkflowStepType.STRESS_STRAIN):
-                        ss_asset = w.get_asset("stress-strain.output")
-                        assert ss_asset
-                        self.client.assets.download_file(ss_asset.id, hdf_filename)
-                        with pd.HDFStore(hdf_filename) as store:
-                            filename = f"{name}/stressStrain.csv"
-                            with zf.open(filename, "w") as f:
-                                store["/stress_strain"].to_csv(f)
-                            data["stressStrain"] = filename
+                        for part_info in self.part_infos:
+                            if not self._is_analysis_target(part_info.part):
+                                continue
+                            if part_info.disabled:
+                                continue
+                            i = part_info.material_index
+                            ss_asset = w.get_asset(
+                                f"stress-strain-{part_info.part_unique_name}.output"
+                            )
+                            if ss_asset is None:
+                                continue
+                            self.client.assets.download_file(ss_asset.id, hdf_filename)
+                            with pd.HDFStore(hdf_filename) as store:
+                                filename = f"{name}/stressStrain{i}.csv"
+                                with zf.open(filename, "w") as f:
+                                    store["/stress_strain"].to_csv(f)
+                                data[f"stressStrain{i}"] = filename
 
                     # ----------------------------------------------------------
                     # Write PLY files from the combined all-material dataframe.
@@ -2218,18 +2257,26 @@ class CompressionSimulation:
                     if raw_ue is not None:
                         unloading_energy = float(raw_ue)
 
-                # Stress-strain: ship whole.
+                # Stress-strain: ship one whole file per deformable part.
                 if self._contains_step(WorkflowStepType.STRESS_STRAIN):
-                    ss_asset = w.get_asset("stress-strain.output")
-                    if ss_asset is not None:
-                        ss_hdf = tempdir_path / "stress_strain.h5"
-                        self.client.assets.download_file(ss_asset.id, ss_hdf)
-                        ss_zip_path = f"{name}/stress_strain.h5"
-                        zf.write(ss_hdf, arcname=ss_zip_path)
-                        data["stressStrain"] = {
-                            "name": ss_zip_path,
-                            "path": "/stress_strain",
-                        }
+                    for part_info in self.part_infos:
+                        if not self._is_analysis_target(part_info.part):
+                            continue
+                        if part_info.disabled:
+                            continue
+                        i = part_info.material_index
+                        ss_asset = w.get_asset(
+                            f"stress-strain-{part_info.part_unique_name}.output"
+                        )
+                        if ss_asset is not None:
+                            ss_hdf = tempdir_path / f"stress_strain_{i}.h5"
+                            self.client.assets.download_file(ss_asset.id, ss_hdf)
+                            ss_zip_path = f"{name}/stress_strain_{i}.h5"
+                            zf.write(ss_hdf, arcname=ss_zip_path)
+                            data[f"stressStrain{i}"] = {
+                                "name": ss_zip_path,
+                                "path": "/stress_strain",
+                            }
 
             # Sum interior volumes across analysis-target parts.
             total_volume = 0.0
@@ -2375,11 +2422,19 @@ class CompressionSimulation:
             }
 
         if self._contains_step(WorkflowStepType.STRESS_STRAIN):
-            server_data["stressStrain"] = {
-                "jobId": job_id_lookup.get("stress-strain", ""),
-                "assetName": "output",
-                "path": "/stress_strain",
-            }
+            for part_info in self.part_infos:
+                if not self._is_analysis_target(part_info.part):
+                    continue
+                if part_info.disabled:
+                    continue
+                i = part_info.material_index
+                server_data[f"stressStrain{i}"] = {
+                    "jobId": job_id_lookup.get(
+                        f"stress-strain-{part_info.part_unique_name}", ""
+                    ),
+                    "assetName": "output",
+                    "path": "/stress_strain",
+                }
 
         return server_data
 
@@ -2604,21 +2659,53 @@ class CompressionSimulation:
                 },
             ]
 
+        # One stress-strain card per deformable part (keyed stressStrain{i}),
+        # under force-displacement: same data, per-part normalizations.
+        if self._contains_step(WorkflowStepType.STRESS_STRAIN):
+            for part_info in self.part_infos:
+                if not self._is_analysis_target(part_info.part):
+                    continue
+                if part_info.disabled:
+                    continue
+                i = part_info.material_index
+                self.manifest["cardsConfig"]["A"].append(
+                    {
+                        "id": f"stressStrain{i}",
+                        "title": f"{part_info.part_unique_name} Stress-Strain",
+                        "component": "MultiExperimentLineChart",
+                        "props": {
+                            "xColumn": "strain",
+                            "yColumn": "stress",
+                            "yMin": 0.0,
+                            "xAxisLabel": "Strain",
+                            "yAxisLabel": "Stress (MPa)",
+                            "dataSource": f"stressStrain{i}",
+                        },
+                    }
+                )
+
+        # One von Mises histogram card per deformable part (keyed
+        # vonMisesStressHistogram{i}).
         self.manifest["cardsConfig"]["B"] = []
         if self._contains_step(WorkflowStepType.VON_MISES_STRESS):
-            rep_idx = self.get_part_info(self.representative_part).material_index
-            self.manifest["cardsConfig"]["B"].append(
-                {
-                    "id": "vonMisesStress",
-                    "title": "von Mises Stress",
-                    "component": "SingleExperimentHistogram",
-                    "props": {
-                        "dataSource": f"vonMisesStressHistogram{rep_idx}",
-                        "xAxisLabel": "von Mises Stress",
-                        "yAxisLabel": "Frequency",
-                    },
-                }
-            )
+            for part_info in self.part_infos:
+                if not self._is_analysis_target(part_info.part):
+                    continue
+                if part_info.disabled:
+                    continue
+                i = part_info.material_index
+                self.manifest["cardsConfig"]["B"].append(
+                    {
+                        "id": f"vonMisesStress{i}",
+                        "title": f"{part_info.part_unique_name} von Mises Stress",
+                        "component": "SingleExperimentHistogram",
+                        "props": {
+                            "dataSource": f"vonMisesStressHistogram{i}",
+                            "xAxisLabel": "von Mises Stress",
+                            "yAxisLabel": "Frequency",
+                        },
+                    }
+                )
 
         if self._results_have_energy_metrics(results):
             self.manifest["resultsListConfig"].append(
@@ -2645,7 +2732,7 @@ class CompressionSimulation:
                     "filtering": False,
                 }
             )
-            self.manifest["cardsConfig"]["C"] = [
+            self.manifest["cardsConfig"]["C"].append(
                 {
                     "id": "energyVolume",
                     "title": "Energy Absorbed-Interior Volume",
@@ -2657,7 +2744,7 @@ class CompressionSimulation:
                         "yAxisLabel": "Energy Absorbed (J)",
                         "colorScaleMeasurement": "energyAbsorbed",
                     },
-                },
-            ]
+                }
+            )
 
 

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

@@ -36,8 +36,7 @@ JSON manifest format
             "type":           "mesh",
             "name":           "midsole",
             "material":       "default_midsole_nominal",
-            "file":           "mid.ply",
-            "representative": true
+            "file":           "mid.ply"
         }
     ],
 
@@ -61,9 +60,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.
+        # Sampling resolution along the longest axis of the total box (the
+        # union of every part's bounds). Each part samples at a resolution
+        # scaled to its own size so every part shares the same spatial density.
         "max_resolution": 512,
 
         # Force source for force-displacement: "boundary_force" (default) or
@@ -217,7 +216,6 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
                     name=entry["name"],
                     material=_resolve_material(entry["material"]),
                     filename=entry["file"],
-                    representative_part=entry.get("representative", False),
                 )
             )
     return parts

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

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

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

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

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

@@ -14,6 +14,7 @@ from metafold.simulation.compression_simulation import (
     ExperimentMesh,
     ExperimentPistonBase,
     ExperimentPistonCylinder,
+    ExperimentPistonMesh,
     SimulationParameters,
     WorkflowStep,
     WorkflowStepType,
@@ -38,7 +39,7 @@ def basic_parts():
     return [
         ExperimentPistonCylinder(),
         ExperimentMesh("upper_foam", DEFAULT_UPPER_FOAM, "top.ply"),
-        ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply", representative_part=True),
+        ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply"),
         ExperimentMesh("outsole", DEFAULT_OUTSOLE, "out.ply"),
     ]
 
@@ -83,7 +84,7 @@ class TestConstruction:
 
     def test_missing_ply_raises(self, ply_folder, tmp_path):
         parts = [
-            ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "nonexistent.ply", representative_part=True),
+            ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "nonexistent.ply"),
         ]
         with pytest.raises(ValueError, match="not found"):
             CompressionSimulation(
@@ -94,36 +95,6 @@ class TestConstruction:
                 client=MagicMock(),
             )
 
-class TestValidation:
-    def test_requires_representative_part(self, ply_folder, tmp_path):
-        parts = [
-            ExperimentPistonCylinder(),
-            ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply"),  # no rep
-        ]
-        with pytest.raises(ValueError, match="representative_part"):
-            CompressionSimulation(
-                parts=parts,
-                simulation_name="t",
-                stl_folder_path=str(ply_folder),
-                output_path=str(tmp_path / "out"),
-                client=MagicMock(),
-            )
-
-    def test_only_one_representative_part_allowed(self, ply_folder, tmp_path):
-        parts = [
-            ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply", representative_part=True),
-            ExperimentMesh("outsole", DEFAULT_OUTSOLE, "out.ply", representative_part=True),
-        ]
-        with pytest.raises(ValueError, match="At most one"):
-            CompressionSimulation(
-                parts=parts,
-                simulation_name="t",
-                stl_folder_path=str(ply_folder),
-                output_path=str(tmp_path / "out"),
-                client=MagicMock(),
-            )
-
-
 class TestWorkflowStepsInput:
     def test_accepts_workflow_step_instance(self):
         steps = CompressionSimulation._clean_workflow_steps_input([
@@ -248,8 +219,8 @@ class TestBuildWorkflow:
 
 
 class TestGridBounds:
-    """The grid must enclose every part, not just the representative one, so
-    nothing (e.g. an outsole below the midsole) gets clipped."""
+    """The grid (total box) must enclose every part, so nothing (e.g. an
+    outsole below the midsole) gets clipped."""
 
     def _grid_bounds(self, sim):
         """Return (lower, upper) of the generated UPS grid box, in metres."""
@@ -267,9 +238,9 @@ class TestGridBounds:
         sim.create_sim_config()
 
     def test_low_mesh_part_expands_grid_downward(self, sim):
-        # The regression: a mesh part (outsole) below the representative midsole
-        # must still expand the grid down. Before the fix, mesh parts were
-        # skipped and the outsole's bottom got clipped.
+        # The regression: a mesh part (outsole) below the midsole must still
+        # expand the grid down. Before the fix, mesh parts were skipped and the
+        # outsole's bottom got clipped.
         # Patch offsets/sizes are in mm; outsole bottom at -50 mm is below all
         # other parts (incl. the piston cylinder, whose lowest point is +25 mm).
         rep = {"size": [100.0, 100.0, 50.0], "offset": [0.0, 0.0, 0.0], "resolution": [32, 32, 16]}
@@ -415,8 +386,9 @@ class TestSampleAssets:
 
 
 class TestDensityMatchedSampling:
-    """Sampling resolutions are scaled per part so every mesh shares the
-    representative part's sample spacing (the piston-density regression)."""
+    """Sampling resolutions scale per part so every mesh shares one sample
+    spacing anchored to the total box (union of all parts) — the piston-density
+    regression, now decoupled from any 'representative' part."""
 
     def _make_job(self, name, longest_axis=None, asset_key=None, filename=None):
         params = {}
@@ -430,19 +402,32 @@ class TestDensityMatchedSampling:
         )
 
     @pytest.fixture
-    def sampled_sim(self, ply_folder, basic_parts, tmp_path):
-        # max_resolution=31 and rep (midsole) longest axis 300 → spacing 10
+    def sampled_sim(self, tmp_path):
+        folder = tmp_path / "ply"
+        folder.mkdir()
+        for n in ["pist.ply", "top.ply", "mid.ply", "out.ply"]:
+            (folder / n).write_bytes(b"ply\n")
+
+        # Total box longest axis = 600 (outsole); max_resolution=31 → spacing 20.
+        parts = [
+            ExperimentPistonMesh(filename="pist.ply"),
+            ExperimentMesh("upper_foam", DEFAULT_UPPER_FOAM, "top.ply"),
+            ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply"),
+            ExperimentMesh("outsole", DEFAULT_OUTSOLE, "out.ply"),
+        ]
         sim = CompressionSimulation(
-            parts=basic_parts,
+            parts=parts,
             simulation_name="t",
-            stl_folder_path=str(ply_folder),
+            stl_folder_path=str(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"),
+            "p-pi": self._make_job("preprocess-mesh-piston", 100.0, "mesh", "pre_pi.ply"),
+            "b-pi": self._make_job("compute-bvh-piston", None, "bvh", "bvh_pi.bin"),
+            "p-up": self._make_job("preprocess-mesh-upper_foam", 160.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"),
@@ -457,28 +442,29 @@ class TestDensityMatchedSampling:
         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_spacing_anchored_to_total_box(self, sampled_sim):
+        # Union longest axis 600 / (31 - 1) = 20
+        assert sampled_sim.sample_spacing == pytest.approx(20.0)
 
-    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_largest_part_gets_max_resolution(self, sampled_sim):
+        assert sampled_sim.get_part_info("outsole").sample_resolution == 31
 
-    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_parts_scale_to_shared_spacing(self, sampled_sim):
+        assert sampled_sim.get_part_info("piston").sample_resolution == 6      # 100/20
+        assert sampled_sim.get_part_info("upper_foam").sample_resolution == 9  # 160/20
+        assert sampled_sim.get_part_info("midsole").sample_resolution == 16    # 300/20
 
     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",
+            "sample-mesh-piston.resolution": "6",
+            "sample-mesh-upper_foam.resolution": "9",
+            "sample-mesh-midsole.resolution": "16",
+            "sample-mesh-outsole.resolution": "31",
         }
         assert kwargs["assets"] == {
+            "sample-mesh-piston.mesh": "pre_pi.ply",
+            "sample-mesh-piston.bvh": "bvh_pi.bin",
             "sample-mesh-upper_foam.mesh": "pre_up.ply",
             "sample-mesh-upper_foam.bvh": "bvh_up.bin",
             "sample-mesh-midsole.mesh": "pre_mid.ply",
@@ -495,15 +481,38 @@ class TestDensityMatchedSampling:
         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.
+        # A variant sampled in a later call reuses the cached spacing.
         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
+        sampled_sim._assign_sample_resolutions([variant], [variant])
+        assert variant.sample_resolution == 16  # 300 / 20 spacing
+
+    def test_union_bounds_includes_primitive(self, tmp_path):
+        # A primitive's analytic bounds (metres) contribute to the total box.
+        folder = tmp_path / "ply"
+        folder.mkdir()
+        (folder / "mid.ply").write_bytes(b"ply\n")
+        sim = CompressionSimulation(
+            parts=[
+                ExperimentPistonCylinder(),
+                ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply"),
+            ],
+            simulation_name="t",
+            stl_folder_path=str(folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+        )
+        sim.get_part_info("midsole").bounds = {
+            "min": [0.0, 0.0, 0.0], "max": [10.0, 10.0, 10.0]
+        }
+        umin, umax = sim._union_bounds_mm(sim.part_infos)
+        pmin, pmax = sim._part_bounds_mm(sim.get_part_info("piston"))
+        # Union contains both the mesh box and the (mm-converted) primitive box
+        assert (umin <= pmin).all() and (umax >= pmax).all()
+        assert umin[0] <= 0.0 and umax[0] >= 10.0
 
 
 
@@ -556,7 +565,19 @@ jobs:
     - compress
     assets:
       data: compress
-  stress-strain:
+  stress-strain-upper_foam:
+    type: sim/postprocess/stress-strain
+    needs:
+    - force-displacement
+    assets:
+      data: force-displacement
+  stress-strain-midsole:
+    type: sim/postprocess/stress-strain
+    needs:
+    - force-displacement
+    assets:
+      data: force-displacement
+  stress-strain-outsole:
     type: sim/postprocess/stress-strain
     needs:
     - force-displacement
@@ -617,8 +638,12 @@ jobs:
         "metrics-upper_foam.volume_resolution": "[32, 32, 16]",
         "metrics-upper_foam.volume_size": "[0.1, 0.1, 0.05]",
         "particle-displacement.keys": "[\"/material0/position\", \"/material1/position\", \"/material2/position\", \"/material3/position\"]",
-        "stress-strain.initial_length": "0.05",
-        "stress-strain.keys": "[\"/force_displacement\"]",
+        "stress-strain-midsole.initial_length": "0.05",
+        "stress-strain-midsole.keys": "[\"/force_displacement\"]",
+        "stress-strain-outsole.initial_length": "0.05",
+        "stress-strain-outsole.keys": "[\"/force_displacement\"]",
+        "stress-strain-upper_foam.initial_length": "0.05",
+        "stress-strain-upper_foam.keys": "[\"/force_displacement\"]",
         "von-mises-stress.keys": "[\"/material0/cauchy_stress\", \"/material1/cauchy_stress\", \"/material2/cauchy_stress\", \"/material3/cauchy_stress\"]"
         }
         """)
@@ -627,6 +652,52 @@ jobs:
             assert workflow_params[key] == value, f"mismatch for {key}: {workflow_params[key]!r} != {value!r}"
 
 
+class TestStressStrainPerPart:
+    """stress-strain runs once per deformable part (not one representative)."""
+
+    def _built_sim(self, ply_folder, basic_parts, tmp_path):
+        sim = CompressionSimulation(
+            parts=basic_parts,
+            simulation_name="t",
+            stl_folder_path=str(ply_folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+        )
+        # Distinct X/Y so compression_area = X*Y is unambiguous.
+        fake_patch = {"size": [0.1, 0.2, 0.05], "offset": [0.0, 0.0, 0.0], "resolution": [32, 32, 16]}
+        for info in sim.part_infos:
+            info.patch = fake_patch
+            if hasattr(info.part, "filename"):
+                info.volume_filename = f"{info.part_unique_name}_volume.bin"
+        sim.create_sim_config()
+        sim.build_workflow()
+        return sim
+
+    def test_one_job_per_deformable_part(self, ply_folder, basic_parts, tmp_path):
+        sim = self._built_sim(ply_folder, basic_parts, tmp_path)
+        for name in ("upper_foam", "midsole", "outsole"):
+            assert f"stress-strain-{name}" in sim.workflow_jobs
+
+    def test_no_single_or_rigid_job(self, ply_folder, basic_parts, tmp_path):
+        sim = self._built_sim(ply_folder, basic_parts, tmp_path)
+        assert "stress-strain" not in sim.workflow_jobs
+        assert "stress-strain-piston" not in sim.workflow_jobs
+
+    def test_each_job_reads_the_shared_force_displacement(self, ply_folder, basic_parts, tmp_path):
+        sim = self._built_sim(ply_folder, basic_parts, tmp_path)
+        for name in ("upper_foam", "midsole", "outsole"):
+            job = sim.workflow_jobs[f"stress-strain-{name}"]
+            assert job["type"] == "sim/postprocess/stress-strain"
+            assert job["needs"] == ["force-displacement"]
+            assert job["assets"] == {"data": "force-displacement"}
+
+    def test_params_normalized_by_own_patch(self, ply_folder, basic_parts, tmp_path):
+        sim = self._built_sim(ply_folder, basic_parts, tmp_path)
+        p = sim.workflow_params
+        assert p["stress-strain-midsole.compression_area"] == str(0.1 * 0.2)
+        assert p["stress-strain-midsole.initial_length"] == "0.05"
+        assert p["stress-strain-midsole.keys"] == json.dumps(["/force_displacement"])
+
 
 class TestMeshDataKey:
     def test_simple_name(self):
@@ -644,13 +715,18 @@ class TestMakeManifestV2:
 
     @pytest.fixture
     def sim_with_full_steps(self, ply_folder, basic_parts, tmp_path):
-        return CompressionSimulation(
+        sim = CompressionSimulation(
             parts=basic_parts,
             simulation_name="t",
             stl_folder_path=str(ply_folder),
             output_path=str(tmp_path / "out"),
             client=MagicMock(),
         )
+        # In the real flow create_sim_config() assigns material indices before
+        # make_manifest_v2() runs; mirror that so per-part cards key correctly.
+        for i, info in enumerate(sim.part_infos):
+            info.material_index = i
+        return sim
 
     def test_results_list_config_has_name_column_always(self, sim_with_full_steps):
         sim_with_full_steps.make_manifest_v2(results=[])
@@ -678,7 +754,6 @@ class TestMakeManifestV2:
     def test_card_c_present_when_energy_metrics_step_present(self, sim_with_full_steps):
         sim_with_full_steps.make_manifest_v2(results=[])
         card_c = sim_with_full_steps.manifest["cardsConfig"]["C"]
-        assert len(card_c) == 1
         assert card_c[0]["id"] == "energyVolume"
 
     def test_card_c_absent_when_no_energy_metrics(self, ply_folder, basic_parts, tmp_path):
@@ -771,6 +846,73 @@ class TestMakeManifestV2:
         sim.make_manifest_v2()
         assert sim.manifest["cardsConfig"]["A"] == []
 
+    def test_von_mises_cards_one_per_deformable_part(self, sim_with_full_steps):
+        sim_with_full_steps.make_manifest_v2()
+        cards = sim_with_full_steps.manifest["cardsConfig"]["B"]
+        ids = [c["id"] for c in cards]
+        assert ids == ["vonMisesStress1", "vonMisesStress2", "vonMisesStress3"]
+        for card in cards:
+            assert card["component"] == "SingleExperimentHistogram"
+            assert card["props"]["dataSource"] == card["id"].replace(
+                "vonMisesStress", "vonMisesStressHistogram"
+            )
+
+    def test_von_mises_cards_absent_when_step_missing(self, ply_folder, basic_parts, tmp_path):
+        sim = CompressionSimulation(
+            parts=basic_parts,
+            simulation_name="t",
+            stl_folder_path=str(ply_folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+            workflow_steps=[WorkflowStep(WorkflowStepType.COMPRESS)],
+        )
+        sim.make_manifest_v2()
+        assert sim.manifest["cardsConfig"]["B"] == []
+
+    def test_stress_strain_cards_in_pane_a_after_force_displacement(self, sim_with_full_steps):
+        sim_with_full_steps.make_manifest_v2()
+        ids = [c["id"] for c in sim_with_full_steps.manifest["cardsConfig"]["A"]]
+        assert ids == [
+            "forceDisplacement",
+            "stressStrain1",
+            "stressStrain2",
+            "stressStrain3",
+        ]
+        # Piston (material_index 0) gets no stress-strain card.
+        assert "stressStrain0" not in ids
+
+    def test_stress_strain_card_props(self, sim_with_full_steps):
+        sim_with_full_steps.make_manifest_v2()
+        cards = [
+            c
+            for c in sim_with_full_steps.manifest["cardsConfig"]["A"]
+            if c["id"].startswith("stressStrain")
+        ]
+        assert cards
+        for card in cards:
+            assert card["component"] == "MultiExperimentLineChart"
+            assert card["props"]["xColumn"] == "strain"
+            assert card["props"]["yColumn"] == "stress"
+            assert card["props"]["dataSource"] == card["id"]
+
+    def test_stress_strain_cards_absent_when_step_missing(self, ply_folder, basic_parts, tmp_path):
+        sim = CompressionSimulation(
+            parts=basic_parts,
+            simulation_name="t",
+            stl_folder_path=str(ply_folder),
+            output_path=str(tmp_path / "out"),
+            client=MagicMock(),
+            workflow_steps=[WorkflowStep(WorkflowStepType.COMPRESS)],
+        )
+        sim.make_manifest_v2()
+        ids = [c["id"] for c in sim.manifest["cardsConfig"]["A"]]
+        assert not any(i.startswith("stressStrain") for i in ids)
+
+    def test_pane_c_is_energy_volume_only(self, sim_with_full_steps):
+        sim_with_full_steps.make_manifest_v2(results=[])
+        ids = [c["id"] for c in sim_with_full_steps.manifest["cardsConfig"]["C"]]
+        assert ids == ["energyVolume"]
+
 
 class TestResultsHaveEnergyMetrics:
     def test_returns_true_when_energy_metrics_step_present(self, ply_folder, basic_parts, tmp_path):

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

@@ -153,7 +153,6 @@ class TestBuildParts:
                 "name": "midsole",
                 "material": "default_midsole_nominal",
                 "file": "mid.ply",
-                "representative": True,
             }
         ])
         p = parts[0]
@@ -161,7 +160,6 @@ class TestBuildParts:
         assert p.name == "midsole"
         assert p.material is DEFAULT_MIDSOLE_NOMINAL
         assert p.filename == "mid.ply"
-        assert p.representative_part is True
 
     def test_mesh_part_with_material_instance(self):
         parts = _build_parts([
@@ -169,12 +167,6 @@ class TestBuildParts:
         ])
         assert parts[0].material is DEFAULT_OUTSOLE
 
-    def test_representative_defaults_to_false(self):
-        parts = _build_parts([
-            {"name": "upper_foam", "material": "default_upper_foam", "file": "top.ply"}
-        ])
-        assert parts[0].representative_part is False
-
     def test_missing_name_raises(self):
         with pytest.raises(ValueError, match="missing 'name'"):
             _build_parts([{"material": "default_outsole", "file": "out.ply"}])
@@ -191,7 +183,7 @@ class TestBuildParts:
         parts = _build_parts([
             {"type": "piston_cylinder"},
             {"name": "upper_foam", "material": "default_upper_foam", "file": "top.ply"},
-            {"name": "midsole", "material": "default_midsole_nominal", "file": "mid.ply", "representative": True},
+            {"name": "midsole", "material": "default_midsole_nominal", "file": "mid.ply"},
             {"name": "outsole", "material": "default_outsole", "file": "out.ply"},
         ])
         assert len(parts) == 4
@@ -339,7 +331,7 @@ class TestRunExperiment:
                 "ply_folder": str(ply_folder),
                 "parts": [
                     {"type": "piston_cylinder"},
-                    {"name": "midsole", "material": "default_midsole_nominal", "file": "mid.ply", "representative": True},
+                    {"name": "midsole", "material": "default_midsole_nominal", "file": "mid.ply"},
                 ],
             })
         assert result == "proj-abc"
@@ -604,7 +596,6 @@ class TestRunExperimentFromZip:
                 "name": "midsole",
                 "material": "default_midsole_nominal",
                 "file": "mid.ply",
-                "representative": True,
             }],
         }
         zip_path = self._make_zip(tmp_path, manifest, mesh_files=["mid.ply"])

{metafold-0.12.dev8 → metafold-0.12.dev10}/tests/test_shear_simulation.py

@@ -31,7 +31,7 @@ def basic_parts():
     return [
         ExperimentPistonCylinder(),
         ExperimentMesh("upper_foam", DEFAULT_UPPER_FOAM, "top.ply"),
-        ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply", representative_part=True),
+        ExperimentMesh("midsole", DEFAULT_MIDSOLE_NOMINAL, "mid.ply"),
         ExperimentMesh("outsole", DEFAULT_OUTSOLE, "out.ply"),
     ]
 
@@ -290,7 +290,7 @@ class TestShearUPS:
                 material=piston_mat,
                 velocity=self.SHEAR_VELOCITY,
             ),
-            ExperimentMesh("puck", puck_mat, "puck.stl", representative_part=True),
+            ExperimentMesh("puck", puck_mat, "puck.stl"),
         ]
 
         sim_params = SimulationParameters(