metafold 0.12.dev7__tar.gz → 0.12.dev9__tar.gz

{metafold-0.12.dev7 → metafold-0.12.dev9}/PKG-INFO

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

{metafold-0.12.dev7 → metafold-0.12.dev9}/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.dev7 → metafold-0.12.dev9}/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
@@ -345,6 +344,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 = ""
@@ -380,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]]
@@ -407,6 +414,10 @@ class CompressionSimulation:
     prep_workflows: list[Workflow] = []
     prep_workflow_batch_size: int = 10
     write_ups: bool = True
+    # 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__(
         self,
@@ -465,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:
@@ -525,16 +535,19 @@ 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 _get_primary_deformable_info(self):
+        """The specimen part for stress/strain and the featured histogram: the
+        first part that isn't a rigid piston/support (pistons are inserted at
+        index 0, so this is the first deformable body in the stack)."""
+        return next(
+            (
+                p for p in self.part_infos
+                if not isinstance(
+                    p.part, (ExperimentPistonBase, ExperimentSupportBase)
+                )
+            ),
+            None,
+        )
 
     def setup_results(self, output_path):
         self.out_dir = Path(output_path)
@@ -722,7 +735,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]
@@ -735,8 +753,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 +773,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 +782,196 @@ 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))
+
+    @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:
+                # Fallback: sample at max_resolution over the part's own bounds.
+                info.sample_resolution = max_resolution
+
     def sample_assets(self, part_infos=None):
         if part_infos is None:
             part_infos = self.part_infos
@@ -793,25 +983,24 @@ 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 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)
 
-        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:
@@ -858,11 +1047,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,
@@ -873,13 +1062,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):
@@ -899,11 +1086,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)
@@ -1213,20 +1399,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(
@@ -1815,16 +2017,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.
@@ -2060,18 +2271,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
@@ -2217,11 +2436,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
 
@@ -2447,8 +2674,9 @@ class CompressionSimulation:
             ]
 
         self.manifest["cardsConfig"]["B"] = []
-        if self._contains_step(WorkflowStepType.VON_MISES_STRESS):
-            rep_idx = self.get_part_info(self.representative_part).material_index
+        specimen = self._get_primary_deformable_info()
+        if self._contains_step(WorkflowStepType.VON_MISES_STRESS) and specimen is not None:
+            rep_idx = specimen.material_index
             self.manifest["cardsConfig"]["B"].append(
                 {
                     "id": "vonMisesStress",
@@ -2462,6 +2690,30 @@ class CompressionSimulation:
                 }
             )
 
+        # One stress-strain card per deformable part (keyed stressStrain{i}).
+        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"]["B"].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}",
+                        },
+                    }
+                )
+
         if self._results_have_energy_metrics(results):
             self.manifest["resultsListConfig"].append(
                 {"key": "volume", "heading": "Volume (mm³)", "filtering": False},

{metafold-0.12.dev7 → metafold-0.12.dev9}/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,6 +60,9 @@ JSON manifest format
 
     "simulation": {
         "max_time": 0.04,
+        # 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
@@ -214,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