metafold 0.12.dev2__py3-none-any.whl → 0.12.dev4__py3-none-any.whl

metafold/client.py

@@ -55,11 +55,16 @@ class Client:
             headers = {"Authorization": f"Bearer {self._auth.get_token()}"}
         r: Response = request(url, *args, **kwargs, headers=headers)
         if not r.ok:
-            body: dict[str, Any] = r.json()
-            # Error responses aren't entirely consistent in the Metafold API,
-            # for now we check for a handful of possible fields.
+            # Not all error responses are JSON so fall back to the status reason
+            try:
+                body: dict[str, Any] = r.json()
+            except ValueError:
+                body = {}
             reason = body.get("errors") or body.get("msg") or body.get("description")
-            raise HTTPError(f"HTTP error occurred: {reason or r.reason}")
+            raise HTTPError(
+                f"HTTP error occurred: {reason or r.reason} "
+                f"(status {r.status_code} for {r.request.method} {r.url})"
+            )
         return r
 
     def get(self, url: str, *args: Any, **kwargs: Any) ->  Response:

metafold/simulation/__init__.py

@@ -1,4 +1,5 @@
 from metafold.simulation.compression_simulation import (
+    BoundaryCondition,
     CompressionSimulation,
     ExperimentBox,
     ExperimentCylinder,
@@ -14,6 +15,7 @@ from metafold.simulation.compression_simulation import (
     ExperimentSupportCylinder,
     ExperimentSupportMesh,
     ExperimentSupportParallelepiped,
+    ForceSource,
     ReferenceData,
     SimulationParameters,
     WorkflowStep,

metafold/simulation/compression_simulation.py

@@ -21,6 +21,7 @@ from simulation_configurator import (
     Contact,
     Mpm,
 )
+from simulation_configurator.element import CompositeElement, Element
 from simulation_configurator.grid import Face
 from simulation_configurator.shapes import Box, File, Cylinder, Parallelepiped
 from plyfile import PlyData, PlyElement
@@ -71,6 +72,68 @@ ZERO_VELOCITY = [
 ]
 
 
+class BoundaryCondition(Enum):
+    SYMMETRIC          = "symmetric"           # symmetry plane (acts as frictionless wall)
+    VELOCITY_DIRICHLET = "velocity_dirichlet"  # velocity fixed to zero at the face
+    VELOCITY_NEUMANN   = "velocity_neumann"    # zero velocity gradient (free face)
+
+
+DEFAULT_BOUNDARY_CONDITIONS = {
+    "x-": BoundaryCondition.SYMMETRIC,
+    "x+": BoundaryCondition.SYMMETRIC,
+    "y-": BoundaryCondition.SYMMETRIC,
+    "y+": BoundaryCondition.SYMMETRIC,
+    "z-": BoundaryCondition.VELOCITY_DIRICHLET,
+    "z+": BoundaryCondition.VELOCITY_DIRICHLET,
+}
+
+
+def _velocity_neumann_face(side: str):
+    # simulation_configurator.Face only provides fixed (symmetry) and unfixed
+    # (velocity Dirichlet) faces; build the Neumann variant here until it can
+    # move into a simulation-configurator release.
+    face = CompositeElement("Face", {"side": side})
+    bc_type = CompositeElement(
+        "BCType",
+        {"id": "all", "label": "Velocity", "var": "Neumann"},
+    )
+    bc_type.add(Element("value", data="[0.0, 0.0, 0.0]"))
+    face.add(bc_type)
+    return face
+
+
+_FACE_BUILDERS = {
+    BoundaryCondition.SYMMETRIC: Face.fixed,
+    BoundaryCondition.VELOCITY_DIRICHLET: Face.unfixed,
+    BoundaryCondition.VELOCITY_NEUMANN: _velocity_neumann_face,
+}
+
+
+def _normalize_boundary_conditions(
+    boundary_conditions: dict,
+) -> dict[str, BoundaryCondition]:
+    """Merge per-face boundary conditions over the defaults.
+
+    Values may be BoundaryCondition members or their string values (as parsed
+    from an experiment manifest). Faces not present keep their default.
+    """
+    unknown = set(boundary_conditions) - set(DEFAULT_BOUNDARY_CONDITIONS)
+    if unknown:
+        raise ValueError(
+            f"Unknown boundary condition face(s) {sorted(unknown)}; "
+            f"expected faces {sorted(DEFAULT_BOUNDARY_CONDITIONS)}"
+        )
+    resolved = dict(DEFAULT_BOUNDARY_CONDITIONS)
+    for side, bc in boundary_conditions.items():
+        resolved[side] = BoundaryCondition(bc) if isinstance(bc, str) else bc
+    return resolved
+
+
+class ForceSource(Enum):
+    BOUNDARY_FORCE       = "boundary_force"        # uses boundary_force_zminus (default)
+    RIGID_REACTION_FORCE = "rigid_reaction_force"  # uses rigid reaction force of force_source_part
+
+
 @dataclass
 class SimulationParameters:
     init_time: float = 0.0
@@ -89,6 +152,15 @@ class SimulationParameters:
     extra_cells: list[int] = field(default_factory=lambda: [1, 1, 1])
     patches: list[int] = field(default_factory=lambda: [4, 2, 2])
 
+    # Per-face boundary conditions; faces omitted here use the default.
+    boundary_conditions: dict[str, BoundaryCondition] = field(
+        default_factory=lambda: dict(DEFAULT_BOUNDARY_CONDITIONS)
+    )
+    force_source: ForceSource = ForceSource.BOUNDARY_FORCE
+    # Part whose rigid_reaction_force feeds force-displacement when
+    # force_source is RIGID_REACTION_FORCE. Empty string means the piston.
+    force_source_part: str = ""
+
 
 @dataclass
 class ExperimentPart:
@@ -506,6 +578,25 @@ class CompressionSimulation:
                     p.restore_from_state_dict(saved)
                     break
 
+    @staticmethod
+    def cancel_active_workflows(client: MetafoldClient, project_id: str) -> list[str]:
+        """Cancel all in-flight (pending/started) workflows for a project.
+
+        Returns the number of workflows cancelled. Used when re-running an
+        experiment on an existing project, whose previous results we're about
+        to overwrite anyway.
+        """
+        cancelled = []
+        for state in ("pending", "started"):
+            for wf in client.workflows.list(q=f"state:{state}", project_id=project_id):
+                try:
+                    client.workflows.cancel(wf.id, project_id=project_id)
+                    cancelled.append(wf.id)
+                except HTTPError:
+                    # Workflow already finished/uncancellable — ignore and move on.
+                    pass
+        return cancelled
+
     @staticmethod
     def find_or_create_project(
         project_name: str,
@@ -514,12 +605,17 @@ class CompressionSimulation:
         client_secret: Optional[str] = None,
         auth_domain: str = "metafold3d.us.auth0.com",
         base_url: str = "https://api.metafold3d.com/",
+        cancel_existing_workflows: bool = True,
     ) -> str:
         """Find an existing project by name or create a new one.
 
         Supply either access_token (server context — never reads from env) or
         client_id + client_secret (local/programmable use, reads from env via
         setup_client). base_url must match the audience the token was issued for.
+
+        When cancel_existing_workflows is True and an existing project is
+        reused, its running workflows are cancelled first.
+
         Returns the project_id string.
         """
         client = MetafoldClient(
@@ -534,7 +630,10 @@ class CompressionSimulation:
         except HTTPError:
             existing = []
         if existing:
-            return existing[0].id
+            project_id = existing[0].id
+            if cancel_existing_workflows:
+                CompressionSimulation.cancel_active_workflows(client, project_id)
+            return project_id
         created = client.projects.create(
             project_name,
             access=Access.PRIVATE,
@@ -775,17 +874,28 @@ class CompressionSimulation:
 
         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
-        grid_min[:2] -= self.simulation_parameters.margin_xy
-        grid_max[:2] += self.simulation_parameters.margin_xy
-        grid_max[2] += self.simulation_parameters.margin_z
 
-        # Expand grid to contain every rigid primitive's bounding box
+        # 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)
         for info in self.part_infos:
             part = info.part
             if isinstance(part, ExperimentPrimitive):
                 pmin, pmax = part.get_bounds()
-                grid_min = np.minimum(grid_min, pmin)
-                grid_max = np.maximum(grid_max, pmax)
+            elif info.patch:
+                pmin = np.array(info.patch["offset"], dtype=np.float32) / 1000.0
+                pmax = np.array(info.patch["size"], dtype=np.float32) / 1000.0 + pmin
+            else:
+                continue
+            grid_min = np.minimum(grid_min, pmin)
+            grid_max = np.maximum(grid_max, pmax)
+
+        # Apply margins after all parts are included. Note z- gets no margin
+        # since the bottom of the grid is the support boundary the stack sits on
+        grid_min[:2] -= self.simulation_parameters.margin_xy
+        grid_max[:2] += self.simulation_parameters.margin_xy
+        grid_max[2] += self.simulation_parameters.margin_z
 
         grid_size = grid_max - grid_min
         spacing = (
@@ -807,10 +917,11 @@ class CompressionSimulation:
             }
         )
         bcs = BoundaryConditions()
-        for side in ["x-", "x+", "y-", "y+"]:
-            bcs._sub_elements[side] = Face.fixed(side)
-        for side in ["z-", "z+"]:
-            bcs._sub_elements[side] = Face.unfixed(side)
+        boundary_conditions = _normalize_boundary_conditions(
+            self.simulation_parameters.boundary_conditions
+        )
+        for side, bc in boundary_conditions.items():
+            bcs._sub_elements[side] = _FACE_BUILDERS[bc](side)
         grid.add(bcs)
 
         store = GeometryStore()
@@ -867,16 +978,18 @@ class CompressionSimulation:
             store.add(geometry_element)
 
         outputs_indices_key = ",".join(str(i) for i in range(len(self.part_infos)))
+        all_outputs = [
+            "boundary_force_zminus",
+            "boundary_force_zplus",
+            "kinetic_energy",
+            "strain_energy",
+        ]
+        if self.simulation_parameters.force_source == ForceSource.RIGID_REACTION_FORCE:
+            all_outputs.append("rigid_reaction_force")
         archive = Archive(
             outputs={
                 outputs_indices_key: ["deformation_measure", "position", "stress"],
-                "all": [
-                    "boundary_force_zminus",
-                    "boundary_force_zplus",
-                    "rigid_reaction_force_0",
-                    "kinetic_energy",
-                    "strain_energy",
-                ],
+                "all": all_outputs,
             },
             output_interval=self.simulation_parameters.output_int,
         )
@@ -1052,6 +1165,22 @@ class CompressionSimulation:
         )
         return piston_info
 
+    def _get_force_source_info(self):
+        """PartInfo of the body whose rigid_reaction_force is measured."""
+        name = self.simulation_parameters.force_source_part
+        if name:
+            info = self.get_part_info(name)
+            if info is None:
+                raise RuntimeError(f"Unknown force_source_part: {name}")
+            return info
+        piston_info = self._get_piston_info()
+        if piston_info is None:
+            raise RuntimeError(
+                "force_source RIGID_REACTION_FORCE requires a piston part "
+                "or an explicit force_source_part"
+            )
+        return piston_info
+
     def _add_to_workflow_von_mises_stress(self, part_infos: list[PartInfo]):
         self._add_to_workflow_postprocess(
             part_infos, "compress", "von-mises-stress", "cauchy_stress"
@@ -1065,9 +1194,12 @@ class CompressionSimulation:
     def _add_to_workflow_force_displacement(self, part_infos: list[PartInfo]):
         job_name_base = "force-displacement"
         self._add_to_workflow_postprocess(part_infos, "compress", job_name_base)
-        self.workflow_params[f"{job_name_base}.keys"] = json.dumps(
-            ["/boundary_force_zminus"]
-        )
+        if self.simulation_parameters.force_source == ForceSource.RIGID_REACTION_FORCE:
+            source = self._get_force_source_info()
+            keys = [f"/material{source.material_index}/rigid_reaction_force"]
+        else:
+            keys = ["/boundary_force_zminus"]
+        self.workflow_params[f"{job_name_base}.keys"] = json.dumps(keys)
         self.workflow_params[f"{job_name_base}.method"] = "BoundaryForce"
         # Find the piston part — there should be exactly one
         piston_info = self._get_piston_info()

metafold/simulation/run_experiment.py

@@ -56,7 +56,19 @@ JSON manifest format
 
     "simulation": {
         "max_time": 0.04,
-        "max_resolution": 512
+        "max_resolution": 512,
+
+        # Force source for force-displacement: "boundary_force" (default) or
+        # "rigid_reaction_force". When using rigid_reaction_force, optionally
+        # name the part it's measured on (defaults to the piston):
+        "force_source": "rigid_reaction_force",
+        "force_source_part": "puck",
+
+        # Per-face boundary conditions. Only the faces you list are overridden;
+        # the rest keep their defaults (x/y faces "symmetric", z faces
+        # "velocity_dirichlet"). Each value is one of: "symmetric",
+        # "velocity_dirichlet", "velocity_neumann".
+        "boundary_conditions": {"z-": "symmetric", "y+": "velocity_neumann"}
     },
 
     "workflow_steps": [
@@ -100,6 +112,7 @@ from __future__ import annotations
 
 import json
 import tempfile
+from enum import Enum
 from pathlib import Path
 from typing import Optional, Union
 from zipfile import ZipFile
@@ -234,6 +247,13 @@ def _build_simulation_parameters(sim_config: dict) -> SimulationParameters:
         obj = params
         for part in parts[:-1]:
             obj = getattr(obj, part)
+        # Manifest values for enum fields (e.g. force_source) arrive as plain
+        # strings; coerce them to the field's enum type. Non-enum fields (e.g.
+        # the boundary_conditions dict) pass through and are normalized later
+        # in create_sim_config.
+        current = getattr(obj, parts[-1], None)
+        if isinstance(current, Enum) and isinstance(value, str):
+            value = type(current)(value)
         setattr(obj, parts[-1], value)
     return params
 

{metafold-0.12.dev2.dist-info → metafold-0.12.dev4.dist-info}/METADATA

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

{metafold-0.12.dev2.dist-info → metafold-0.12.dev4.dist-info}/RECORD

@@ -2,19 +2,19 @@ metafold/__init__.py,sha256=fDZ2HCBNDOJfs1zAhCse6h2lOiqxl2uUMJT-JuO0XNE,1899
 metafold/api.py,sha256=SrlDgvaqy0Vjf9w67OmmOUs3YAQaIEFHb1rpxvpwFWw,1052
 metafold/assets.py,sha256=41OUQ1wKiYitEZMBRPbFfxtM3m4TYb_5S6wXNEbgi40,4569
 metafold/auth.py,sha256=O4B5vGUr2UmHbw_1BfWqZn-GWvmf_eFpZEpKGgBGrQQ,1079
-metafold/client.py,sha256=z34w7vN7sN3CD4QtfHXy-rBIpObykI3D_uOC-Jef6B8,3592
+metafold/client.py,sha256=ZFftCr5gbRFkrxgBK7NYspBQEQnNzj2tWCbjPqxg5gw,3714
 metafold/exceptions.py,sha256=dJhBgbryBhJUf20FT3eU1rjQJQ-aDEZ25g-YCn_TwQk,110
 metafold/jobs.py,sha256=DxpQ9yrN7Th67XyW8UqjAIX0wfhwgPPCA9mNSKG_Z_Y,7029
 metafold/materials.py,sha256=heiK_kpU3YhKMPy1P9Zfds8yyUib0yqq3zethufchOc,10814
 metafold/projects.py,sha256=4APFtJQjycFhlIHCWTrOAuU3CLX8drSlgPz8lhVXhzI,6295
 metafold/utils.py,sha256=DnsW1Xr9mLpVHBNdPrdxNLLcjxSNMkWVvr7cH7UTAxY,1174
 metafold/workflows.py,sha256=Mhv3n3ChUHw1Vaj3q8HNDbOgljn03AF6WslZfXzexsI,7802
-metafold/simulation/__init__.py,sha256=siIIJv3hjiHLohSztAZcMi0eePqEkc_K5Q8Azsf90d4,776
+metafold/simulation/__init__.py,sha256=tUW4PfyWnI6UFvIR__JKUD2FjNTM74fSeKuee7Ewjfo,816
 metafold/simulation/compression_experiment.py,sha256=Dc7EKPAmKEZsNcH5vnKuj3dQcFFeh0hsus9CIA0Ycv4,14221
-metafold/simulation/compression_simulation.py,sha256=-amZGNGJthXI4zvFlYm9xdYPjRJue04JJu8Ra2QAfaE,97589
-metafold/simulation/run_experiment.py,sha256=i-ZsYDYTbo-0EFXAjCqBvmA67b8VnRtLimGQNF76z8k,13647
-metafold-0.12.dev2.dist-info/licenses/LICENSE,sha256=LejZXzGwe9t0Ezk6g0bRmWUuFSI9vQSk1wJAc1NrrhE,1059
-metafold-0.12.dev2.dist-info/METADATA,sha256=I4rXO9-j762tHilLAHCvP1yYLYkgdCqfK2CTO4XFHNM,3495
-metafold-0.12.dev2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-metafold-0.12.dev2.dist-info/top_level.txt,sha256=0dvwa2N6gvl2x4T9c62V4MbYD2soFedI6hm3-lWgyew,9
-metafold-0.12.dev2.dist-info/RECORD,,
+metafold/simulation/compression_simulation.py,sha256=akAEJhYQrfWATnVXsOaa-zfx-ufWykEYEjEpR_ov0l4,103193
+metafold/simulation/run_experiment.py,sha256=jj5tZgOhEdPGZZcJFPL_pELfcFlosTMlWMRxgtur9Uk,14748
+metafold-0.12.dev4.dist-info/licenses/LICENSE,sha256=LejZXzGwe9t0Ezk6g0bRmWUuFSI9vQSk1wJAc1NrrhE,1059
+metafold-0.12.dev4.dist-info/METADATA,sha256=mqzqN_sPPpFDIspJiBtnRi8PqkxuZEaDGVCXAfokWdU,3495
+metafold-0.12.dev4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+metafold-0.12.dev4.dist-info/top_level.txt,sha256=0dvwa2N6gvl2x4T9c62V4MbYD2soFedI6hm3-lWgyew,9
+metafold-0.12.dev4.dist-info/RECORD,,