metafold 0.14.dev0__tar.gz → 0.15.0__tar.gz

{metafold-0.14.dev0 → metafold-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.14.dev0
+Version: 0.15.0
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D
@@ -38,7 +38,7 @@ Requires-Dist: dotenv>=0.9.9; extra == "simulation"
 Requires-Dist: pandas>=2.3.3; extra == "simulation"
 Requires-Dist: plyfile>=1.1.3; extra == "simulation"
 Requires-Dist: pyyaml>=6.0.3; extra == "simulation"
-Requires-Dist: simulation-configurator==0.2.*; extra == "simulation"
+Requires-Dist: simulation-configurator==0.3.*; extra == "simulation"
 Requires-Dist: tables>=3.11.1; extra == "simulation"
 Dynamic: license-file
 

{metafold-0.14.dev0 → metafold-0.15.0}/metafold/materials.py

@@ -211,6 +211,111 @@ class MaxwellWeichertParams(ParamsBase):
         )
 
 
+@dataclass
+class HyperfoamTerm:
+    """One Ogden term of a hyperfoam material (mpmgpu allows up to 3)."""
+    mu: float
+    alpha: float
+    poisson_ratio: float
+
+    def to_dict(self):
+        # "_element" tells the ups emitter to render this as a <term>.
+        return {
+            "_element": "term",
+            "mu": float(self.mu),
+            "alpha": float(self.alpha),
+            "poisson_ratio": float(self.poisson_ratio),
+        }
+
+
+@dataclass
+class HyperfoamParams(ParamsBase):
+    """Ogden hyperfoam (mpmgpu only; no Uintah equivalent).
+
+    The Ogden hyperfoam model is defined entirely by its terms (bulk_modulus is
+    not used, so it is not part of this material; a legacy "bulk_modulus"/"K" is
+    ignored if present on from_dict).
+
+    An optional viscoelastic overlay (Prony series) may be supplied via
+    terminal_shear_modulus + viscoelastic_series, matching the MaxwellWeichert
+    mode structure. Omit both for a purely elastic hyperfoam.
+    """
+    terms: List[HyperfoamTerm]
+    terminal_shear_modulus: Optional[float] = None
+    viscoelastic_series: Optional[List[ViscoelasticMode]] = None
+
+    @classmethod
+    def get_type(self):
+        return "hyperfoam"
+
+    def to_dict(self):
+        d = {
+            "terms": [t.to_dict() for t in self.terms],
+        }
+        if self.terminal_shear_modulus is not None:
+            d["terminal_shear_modulus"] = float(self.terminal_shear_modulus)
+        if self.viscoelastic_series:
+            d["viscoelastic_series"] = [m.to_dict() for m in self.viscoelastic_series]
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "HyperfoamParams":
+        # A legacy bulk_modulus/K is ignored (older scripts may still send it).
+        series = d.get("viscoelastic_series")
+        return cls(
+            terms=[
+                HyperfoamTerm(
+                    mu=t["mu"], alpha=t["alpha"], poisson_ratio=t["poisson_ratio"])
+                for t in d["terms"]
+            ],
+            terminal_shear_modulus=d.get("terminal_shear_modulus"),
+            viscoelastic_series=(
+                [ViscoelasticMode(**m) for m in series] if series else None),
+        )
+
+
+@dataclass
+class OrthotropicParams(ParamsBase):
+    """Linear-elastic orthotropic (mpmgpu only; no Uintah equivalent)."""
+    E1: float
+    E2: float
+    E3: float
+    nu12: float
+    nu13: float
+    nu23: float
+    G12: float
+    G13: float
+    G23: float
+    direction_a: List[float]
+    direction_b: List[float]
+
+    @classmethod
+    def get_type(self):
+        return "orthotropic"
+
+    def to_dict(self):
+        return {
+            "E1": float(self.E1), "E2": float(self.E2), "E3": float(self.E3),
+            "nu12": float(self.nu12), "nu13": float(self.nu13), "nu23": float(self.nu23),
+            "G12": float(self.G12), "G13": float(self.G13), "G23": float(self.G23),
+            # Numeric lists so simulation_configurator emits them as vectors.
+            "direction_a": [float(x) for x in self.direction_a],
+            "direction_b": [float(x) for x in self.direction_b],
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "OrthotropicParams":
+        def vec(v):
+            return [float(x) for x in (v.split() if isinstance(v, str) else v)]
+        return cls(
+            E1=d["E1"], E2=d["E2"], E3=d["E3"],
+            nu12=d["nu12"], nu13=d["nu13"], nu23=d["nu23"],
+            G12=d["G12"], G13=d["G13"], G23=d["G23"],
+            direction_a=vec(d["direction_a"]),
+            direction_b=vec(d["direction_b"]),
+        )
+
+
 @dataclass
 class CompNeoHookParams(ParamsBase):
     bulk_modulus: float
@@ -351,10 +456,24 @@ class Material:
             ElasticPlasticParams,
             HypoElasticParams,
             ViscoTransIsoHyperParams,
+            HyperfoamParams,
+            OrthotropicParams,
         ]
         PARAMS_CLASSES = {c.get_type(): c for c in params_classes}
         cm = d["constitutive_model"]
-        params = PARAMS_CLASSES[cm["type"]].from_dict(cm["params"])
+        model_type = cm.get("type")
+        if model_type not in PARAMS_CLASSES:
+            # ValueError so API callers reject with a 400, not a 500. An
+            # unknown type usually means a client newer than the server.
+            raise ValueError(
+                f"Unknown constitutive model type {model_type!r}. "
+                f"Known types: {', '.join(sorted(PARAMS_CLASSES))}.")
+        try:
+            params = PARAMS_CLASSES[model_type].from_dict(cm["params"])
+        except KeyError as e:
+            # Missing param -> ValueError (400) rather than an uncaught 500.
+            raise ValueError(
+                f"{model_type} material is missing required param {e}.")
         return cls(
             density=d["density"],
             thermal_conductivity=d["thermal_conductivity"],

{metafold-0.14.dev0 → metafold-0.15.0}/metafold/simulation/compression_simulation.py

@@ -474,6 +474,8 @@ class CompressionSimulation:
     # experiment variants sampled later match the base simulation's density.
     sample_spacing: Optional[float] = None
 
+    use_experimental_solver: bool = False
+
     def __init__(
         self,
         parts: list[ExperimentPart],
@@ -503,6 +505,7 @@ class CompressionSimulation:
         project_name: str = "",
         use_legacy_results_format: bool = False,
         write_ups: bool = True,
+        use_experimental_solver: bool = False,
     ):
         if not output_path:
             if project_name:
@@ -542,6 +545,8 @@ class CompressionSimulation:
         else:
             self.client = client
 
+        self.use_experimental_solver = use_experimental_solver
+
     def _write_ups(self, content: str, filename: str) -> None:
         if self.write_ups and self.out_dir is not None:
             (self.out_dir / filename).write_text(content)
@@ -1370,8 +1375,12 @@ class CompressionSimulation:
         # Only parts that have a volume go into the compress assets list
         parts_with_volume = [p for p in part_infos if p.volume_filename]
 
+        job_type = "sim/custom"
+        if self.use_experimental_solver:
+            job_type = "sim/custom-gpu"
+
         self.workflow_jobs[compress_job_name] = {
-            "type": "sim/custom",
+            "type": job_type,
         }
 
         # compress.volume is a list of volume asset filenames in part order
@@ -1505,6 +1514,11 @@ class CompressionSimulation:
                     for row in piston_info.part.velocity
                 ]
             )
+            if piston_info.part.force_limit:
+                # Switch to using piston particle positions to determine displacement
+                self.workflow_params[f"{job_name_base}.piston_position"] = (
+                    f"/material{piston_info.material_index}/position"
+                )
 
     def _add_to_workflow_stress_strain(self, part_infos: list[PartInfo]):
         # One stress-strain job per deformable part, each normalizing the shared

{metafold-0.14.dev0 → metafold-0.15.0}/metafold/simulation/run_experiment.py

@@ -251,6 +251,34 @@ def _build_parts(parts_config: list[dict]) -> list[ExperimentPart]:
     return parts
 
 
+# Constitutive models that only the experimental (mpmgpu GPU) solver supports;
+# Uintah has no equivalent, so they require use_experimental_solver.
+_EXPERIMENTAL_ONLY_MATERIALS = {
+    _materials_module.OrthotropicParams.get_type(),
+    _materials_module.HyperfoamParams.get_type(),
+}
+
+
+def _material_type(material: Material) -> str:
+    return material.constitutive_model.params.get_type()
+
+
+def _validate_experimental_materials(config: dict, parts, varying) -> None:
+    """Reject experimental-only materials unless use_experimental_solver is set."""
+    if config.get("use_experimental_solver", False):
+        return
+    materials = [p.material for p in parts]
+    for v in varying:
+        if isinstance(v, VaryMaterial):
+            materials.extend(v.materials)
+    used = {_material_type(m) for m in materials} & _EXPERIMENTAL_ONLY_MATERIALS
+    if used:
+        names = ", ".join(sorted(used))
+        raise ValueError(
+            f"Material(s) {names} are only supported with the experimental "
+            f"solver. Set use_experimental_solver to true to use them.")
+
+
 def validate_experiment_config(config: dict) -> None:
     """Raise ValueError if a manifest can't produce a runnable experiment.
     Mirrors the checks run_experiment performs so an API can reject bad
@@ -258,7 +286,10 @@ def validate_experiment_config(config: dict) -> None:
     """
     if not config.get("project_name", ""):
         raise ValueError("project_name is required")
-    validate_simulation_parts(_build_parts(config.get("parts", [])))
+    parts = _build_parts(config.get("parts", []))
+    validate_simulation_parts(parts)
+    _validate_experimental_materials(
+        config, parts, _build_varying(config.get("varying", [])))
 
 
 def _build_varying(varying_config: list[dict]) -> list[ExperimentVarying]:
@@ -329,6 +360,12 @@ def _build_simulation_parameters(sim_config: dict) -> SimulationParameters:
     return params
 
 
+def num_simulations(config: dict) -> int:
+    """Count number of simulation variations to be generated by a given configuration.
+    """
+    return len(_build_varying(config.get("varying", [])))
+
+
 def run_experiment(
     config: dict,
     output_path: str = "",
@@ -373,6 +410,10 @@ def run_experiment(
     varying = _build_varying(config.get("varying", []))
     sim_params = _build_simulation_parameters(config.get("simulation", {}))
 
+    _validate_experimental_materials(config, parts, varying)
+
+    use_experimental_solver = config.get("use_experimental_solver", False)
+
     sim_kwargs: dict = dict(
         parts=parts,
         simulation_name=project_name,
@@ -381,6 +422,7 @@ def run_experiment(
         simulation_parameters=sim_params,
         project_id=project_id,
         create_project_if_needed=not bool(project_id),
+        use_experimental_solver=use_experimental_solver,
     )
     # Only pass project_name when we have to create a project. When a
     # project_id is supplied the project already exists, and passing the name

{metafold-0.14.dev0 → metafold-0.15.0}/metafold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metafold
-Version: 0.14.dev0
+Version: 0.15.0
 Summary: Metafold SDK for Python
 Author-email: Metafold 3D <info@metafold3d.com>
 License: Copyright 2024 Metafold 3D
@@ -38,7 +38,7 @@ Requires-Dist: dotenv>=0.9.9; extra == "simulation"
 Requires-Dist: pandas>=2.3.3; extra == "simulation"
 Requires-Dist: plyfile>=1.1.3; extra == "simulation"
 Requires-Dist: pyyaml>=6.0.3; extra == "simulation"
-Requires-Dist: simulation-configurator==0.2.*; extra == "simulation"
+Requires-Dist: simulation-configurator==0.3.*; extra == "simulation"
 Requires-Dist: tables>=3.11.1; extra == "simulation"
 Dynamic: license-file
 

{metafold-0.14.dev0 → metafold-0.15.0}/metafold.egg-info/requires.txt

@@ -9,5 +9,5 @@ dotenv>=0.9.9
 pandas>=2.3.3
 plyfile>=1.1.3
 pyyaml>=6.0.3
-simulation-configurator==0.2.*
+simulation-configurator==0.3.*
 tables>=3.11.1

{metafold-0.14.dev0 → metafold-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metafold"
-version = "0.14.dev0"
+version = "0.15.0"
 authors = [
     {name = "Metafold 3D", email = "info@metafold3d.com"},
 ]
@@ -38,7 +38,7 @@ simulation = [
     "pandas>=2.3.3",
     "plyfile>=1.1.3",
     "pyyaml>=6.0.3",
-    "simulation-configurator==0.2.*",
+    "simulation-configurator==0.3.*",
     "tables>=3.11.1",
 ]
 

{metafold-0.14.dev0 → metafold-0.15.0}/tests/test_materials.py

@@ -5,10 +5,13 @@ from metafold.materials import (
     ConstitutiveModel,
     ElasticPlasticParams,
     FlowModel,
+    HyperfoamParams,
+    HyperfoamTerm,
     HypoElasticParams,
     JohnsonCookParams,
     Material,
     MaxwellWeichertParams,
+    OrthotropicParams,
     RigidParams,
     StabilityCheck,
     UCNHParams,
@@ -279,3 +282,155 @@ class TestMaterialOptionalFields:
         r = roundtrip(m)
         assert r.room_temp == 300.0
         assert r.melt_temp == 1500.0
+
+
+class TestHyperfoamParams:
+    def _material(self):
+        return Material(
+            density=600.0,
+            thermal_conductivity=0.15,
+            specific_heat=1.36,
+            constitutive_model=ConstitutiveModel(
+                params=HyperfoamParams(
+                    terms=[
+                        HyperfoamTerm(mu=0.16e6, alpha=8.9, poisson_ratio=0.0),
+                        HyperfoamTerm(mu=0.01e6, alpha=-2.0, poisson_ratio=0.0),
+                    ],
+                )
+            ),
+        )
+
+    def test_roundtrip(self):
+        m = self._material()
+        assert roundtrip(m).to_dict() == m.to_dict()
+
+    def test_type_key(self):
+        d = ConstitutiveModel(
+            params=HyperfoamParams(terms=[])
+        ).to_dict()
+        assert d["type"] == "hyperfoam"
+
+    def test_bulk_modulus_not_emitted(self):
+        # bulk_modulus is not part of the Ogden hyperfoam model.
+        d = self._material().constitutive_model.params.to_dict()
+        assert "bulk_modulus" not in d
+        assert "K" not in d
+
+    def test_legacy_bulk_modulus_ignored_on_from_dict(self):
+        # Older scripts / GH plugins may still send bulk_modulus or K — ignore it.
+        d = {
+            "type": "hyperfoam",
+            "params": {
+                "bulk_modulus": 1.0e6,
+                "K": 2.0e6,
+                "terms": [{"mu": 0.16e6, "alpha": 8.9, "poisson_ratio": 0.0}],
+            },
+        }
+        params = HyperfoamParams.from_dict(d["params"])
+        assert len(params.terms) == 1
+        assert "bulk_modulus" not in params.to_dict()
+
+    def test_terms_preserved(self):
+        d = self._material().constitutive_model.params.to_dict()
+        assert len(d["terms"]) == 2
+        # "_element" marks how the ups emitter renders each term.
+        assert d["terms"][0]["_element"] == "term"
+        assert d["terms"][0]["mu"] == 0.16e6
+        assert d["terms"][1]["alpha"] == -2.0
+
+    def test_pure_elastic_omits_viscoelastic_fields(self):
+        d = self._material().constitutive_model.params.to_dict()
+        assert "terminal_shear_modulus" not in d
+        assert "viscoelastic_series" not in d
+
+    def _viscoelastic_material(self):
+        return Material(
+            density=600.0,
+            thermal_conductivity=0.15,
+            specific_heat=1.36,
+            constitutive_model=ConstitutiveModel(
+                params=HyperfoamParams(
+                    terms=[HyperfoamTerm(mu=0.16e6, alpha=8.9, poisson_ratio=0.0)],
+                    terminal_shear_modulus=5.0e4,
+                    viscoelastic_series=[
+                        ViscoelasticMode("m1", 0.15, 25000),
+                        ViscoelasticMode("m2", 0.20, 30000),
+                    ],
+                )
+            ),
+        )
+
+    def test_viscoelastic_overlay_roundtrip(self):
+        m = self._viscoelastic_material()
+        assert roundtrip(m).to_dict() == m.to_dict()
+
+    def test_viscoelastic_overlay_emitted(self):
+        d = self._viscoelastic_material().constitutive_model.params.to_dict()
+        assert d["terminal_shear_modulus"] == 5.0e4
+        assert len(d["viscoelastic_series"]) == 2
+        assert d["viscoelastic_series"][0]["mode"] == "m1"
+
+
+class TestOrthotropicParams:
+    def _material(self):
+        return Material(
+            density=1000.0,
+            thermal_conductivity=1.0,
+            specific_heat=1500,
+            constitutive_model=ConstitutiveModel(
+                params=OrthotropicParams(
+                    E1=1e9, E2=2e9, E3=3e9,
+                    nu12=0.3, nu13=0.3, nu23=0.3,
+                    G12=0.5e9, G13=0.5e9, G23=0.5e9,
+                    direction_a=[1.0, 0.0, 0.0],
+                    direction_b=[0.0, 1.0, 0.0],
+                )
+            ),
+        )
+
+    def test_roundtrip(self):
+        m = self._material()
+        assert roundtrip(m).to_dict() == m.to_dict()
+
+    def test_type_key(self):
+        d = ConstitutiveModel(params=self._material().constitutive_model.params).to_dict()
+        assert d["type"] == "orthotropic"
+
+    def test_directions_are_numeric_lists(self):
+        d = self._material().constitutive_model.params.to_dict()
+        assert d["direction_a"] == [1.0, 0.0, 0.0]
+        assert d["direction_b"] == [0.0, 1.0, 0.0]
+
+    def test_from_dict_accepts_string_direction(self):
+        # Directions may arrive as "x y z" strings (manifest form).
+        m = self._material()
+        d = m.to_dict()
+        d["constitutive_model"]["params"]["direction_a"] = "1 0 0"
+        assert OrthotropicParams.from_dict(d["constitutive_model"]["params"]).direction_a == [1.0, 0.0, 0.0]
+
+
+class TestMaterialFromDictErrors:
+    # from_dict must raise ValueError (not KeyError) so API callers return 400,
+    # not 500. See lightcycle experiments blueprint.
+    def _material_dict(self, mtype, params):
+        return {
+            "density": 1000.0, "thermal_conductivity": 1.0, "specific_heat": 1500,
+            "constitutive_model": {"type": mtype, "params": params},
+        }
+
+    def test_unknown_type_raises_value_error(self):
+        # A client newer than the server sends a type we don't know.
+        d = self._material_dict("some_future_type", {})
+        with pytest.raises(ValueError, match="Unknown constitutive model type"):
+            Material.from_dict(d)
+
+    def test_missing_param_raises_value_error(self):
+        params = {
+            "E1": 1e9, "E2": 1e9, "E3": 1e9,
+            "nu12": 0.3, "nu13": 0.3, "nu23": 0.3,
+            "G12": 5e8, "G13": 5e8, "G23": 5e8,
+            "direction_a": [1.0, 0.0, 0.0], "direction_b": [0.0, 1.0, 0.0],
+        }
+        del params["E1"]
+        with pytest.raises(ValueError, match="missing required param"):
+            Material.from_dict(self._material_dict("orthotropic", params))

{metafold-0.14.dev0 → metafold-0.15.0}/tests/test_run_experiment.py

@@ -31,6 +31,7 @@ from metafold.simulation.run_experiment import (
     _resolve_material,
     run_experiment,
     run_experiment_from_zip,
+    validate_experiment_config,
 )
 from metafold.simulation.compression_experiment import (
     VaryMaterial,
@@ -657,3 +658,61 @@ class TestRunExperimentFromZip:
             result = run_experiment_from_zip(zip_path, output_path=str(tmp_path / "out"))
 
         assert result == "p"
+
+
+class TestExperimentalMaterialGuard:
+    """Orthotropic/hyperfoam are mpmgpu-only; rejected unless use_experimental_solver."""
+
+    HYPERFOAM = {
+        "density": 600.0,
+        "thermal_conductivity": 0.15,
+        "specific_heat": 1.36,
+        "constitutive_model": {
+            "type": "hyperfoam",
+            "params": {
+                "bulk_modulus": 1.0e6,
+                "terms": [{"mu": 1.6e5, "alpha": 8.9, "poisson_ratio": 0.0}],
+            },
+        },
+    }
+
+    def _config(self, **extra):
+        cfg = {
+            "project_name": "t",
+            "parts": [
+                {"type": "piston_cylinder"},
+                {"name": "foam", "material": self.HYPERFOAM, "file": "foam.ply"},
+            ],
+        }
+        cfg.update(extra)
+        return cfg
+
+    def test_rejected_without_experimental_flag(self):
+        with pytest.raises(ValueError, match="experimental solver"):
+            validate_experiment_config(self._config())
+
+    def test_allowed_with_experimental_flag(self):
+        # Should not raise.
+        validate_experiment_config(self._config(use_experimental_solver=True))
+
+    def test_ordinary_material_unaffected(self):
+        cfg = {
+            "project_name": "t",
+            "parts": [
+                {"type": "piston_cylinder"},
+                {"name": "foam", "material": "default_midsole_nominal", "file": "foam.ply"},
+            ],
+        }
+        validate_experiment_config(cfg)  # no raise
+
+    def test_varied_experimental_material_rejected(self):
+        cfg = {
+            "project_name": "t",
+            "parts": [
+                {"type": "piston_cylinder"},
+                {"name": "foam", "material": "default_midsole_nominal", "file": "foam.ply"},
+            ],
+            "varying": [{"part": "foam", "material": [self.HYPERFOAM]}],
+        }
+        with pytest.raises(ValueError, match="experimental solver"):
+            validate_experiment_config(cfg)