tpmslab 0.3.0__py3-none-any.whl

tpmslab/families.json

@@ -0,0 +1,119 @@
+{
+  "Primitive Schwartz": {
+    "expression": "cos(X)+cos(Y)+cos(Z)",
+    "source_label": "Primitive Schwartz Surface"
+  },
+  "Double P": {
+    "expression": "0.5*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))+0.2*(cos(2*X)+cos(2*Y)+cos(2*Z))",
+    "source_label": "Double P Surface"
+  },
+  "Gyroid": {
+    "expression": "sin(X)*cos(Y) + sin(Z)*cos(X) + sin(Y)*cos(Z)",
+    "source_label": "Gyroid Surface"
+  },
+  "Double Gyroid": {
+    "expression": "2.75*(sin(2*X)*sin(Z)*cos(Y) + sin(2*Y)*sin(X)*cos(Z) + sin(2*Z)*sin(Y)*cos(X))-(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))",
+    "source_label": "Double Gyroid Surface"
+  },
+  "Diamond": {
+    "expression": "(cos(X)*cos(Y)*cos(Z)) - (sin(X)*sin(Y)*sin(Z))",
+    "source_label": "Diamond Surface"
+  },
+  "Double Diamond 1": {
+    "expression": "sin(2*X)*sin(2*Y)+sin(2*Y)*sin(2*Z)+sin(2*X)*sin(2*Z)+cos(2*X)*cos(2*Y)*cos(2*Z)",
+    "source_label": "Double Diamond 1 Surface"
+  },
+  "Double Diamond 2": {
+    "expression": "cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*X)*cos(2*Z)+sin(2*X)*sin(2*Y)*sin(2*Z)",
+    "source_label": "Double Diamond 2 Surface"
+  },
+  "IWP": {
+    "expression": "2*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))-(cos(2*X)+cos(2*Y)+cos(2*Z))",
+    "source_label": "IWP Surface"
+  },
+  "FRD Prime": {
+    "expression": "4*(cos(X)*cos(Y)*cos(Z))-(cos(2*X)*cos(2*Y)+cos(2*X)*cos(2*Z)+cos(2*Y)*cos(2*Z))",
+    "source_label": "FRD Prime Surface"
+  },
+  "I2-Y": {
+    "expression": "-2*(sin(2*X)*cos(Y)*sin(Z) + sin(X)*sin(2*Y)*cos(Z) + cos(X)*sin(Y)*sin(2*Z)) + cos(2*X)*cos(2*Y) + cos(2*Y)*cos(2*Z) + cos(2*X)*cos(2*Z)",
+    "source_label": "I2-Y Surface"
+  },
+  "G Prime 1": {
+    "expression": "5*(sin(2*X)*sin(Z)*cos(Y)+sin(2*Y)*sin(X)*cos(Z)+sin(2*Z)*sin(Y)*cos(X))+(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))",
+    "source_label": "G Prime 1 Surface"
+  },
+  "G Prime 2": {
+    "expression": "(sin(2*X)*sin(Z)*cos(Y)+sin(2*Y)*sin(X)*cos(Z)+sin(2*Z)*sin(Y)*cos(X))+0.32",
+    "source_label": "G Prime 2 Surface"
+  },
+  "Neovius": {
+    "expression": "3*(cos(X)+cos(Y)+cos(Z))+4*(cos(X)*cos(Y)*cos(Z))",
+    "source_label": "Neovius Surface"
+  },
+  "Lidinoid": {
+    "expression": "(sin(2*X)*sin(Z)*cos(Y)+sin(2*Y)*sin(X)*cos(Z)+sin(2*Z)*sin(Y)*cos(X))-(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))+0.3",
+    "source_label": "Lidinoid Surface"
+  },
+  "D Prime": {
+    "expression": "0.5*(sin(X)*sin(Y)*sin(Z)+cos(X)*cos(Y)*cos(Z))-0.5*(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))-0.2",
+    "source_label": "D Prime Surface"
+  },
+  "KP": {
+    "expression": "0.3*(cos(X)+cos(Y)+cos(Z))+0.3*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))-0.4*(cos(2*X)+cos(2*Y)+cos(2*Z))+0.2",
+    "source_label": "KP Surface"
+  },
+  "S": {
+    "expression": "cos(2*X)*sin(Y)*cos(Z)+cos(2*Y)*sin(Z)*cos(X)+cos(2*Z)*sin(X)*cos(Y)-0.4",
+    "source_label": "S Surface"
+  },
+  "Fischer-Koch": {
+    "expression": "(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))-(cos(2*X)+cos(2*Y)+cos(2*Z))",
+    "source_label": "Fischer-Koch Surface"
+  },
+  "Bionic Bone 1": {
+    "expression": "20*(cos(X)*sin(Y)+cos(Y)*sin(Z)+cos(Z)*sin(X))-0.5*(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))-4",
+    "source_label": "Bionic Bone 1 Surface"
+  },
+  "Bionic Bone 2": {
+    "expression": "10*(cos(X)*sin(Y)+cos(Y)*sin(Z)+cos(Z)*sin(X))-2*(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))-12",
+    "source_label": "Bionic Bone 2 Surface"
+  },
+  "Octo 1": {
+    "expression": "4*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))-2.8*(cos(X)*cos(Y)*cos(Z))+(cos(X)+cos(Y)+cos(Z))+1.5",
+    "source_label": "Octo 1 Surface"
+  },
+  "Octo 2": {
+    "expression": "4*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))-3*(cos(X)+cos(Y)+cos(Z))+2.4",
+    "source_label": "Octo 2 Surface"
+  },
+  "PN": {
+    "expression": "0.6*(cos(X)*cos(Y)*cos(Z))+0.4*(cos(X)+cos(Y)+cos(Z))+0.2*(cos(2*X)*cos(2*Y)*cos(2*Z))+0.2*(cos(2*X)+cos(2*Y)+cos(2*Z))+0.1*(cos(3*X)+cos(3*Y)+cos(3*Z))+0.2*(cos(X)*cos(Y)+cos(Y)*cos(Z)+cos(Z)*cos(X))",
+    "source_label": "PN Surface"
+  },
+  "C(Y)": {
+    "expression": "sin(X)*sin(Y)*sin(Z)+sin(2*X)*sin(Y)+sin(2*Y)*sin(Z)+sin(2*Z)*sin(X)-cos(X)*cos(Y)*cos(Z)+sin(2*X)*cos(Z)+sin(2*Y)*cos(X)+sin(2*Z)*cos(Y)",
+    "source_label": "C(Y) Surface"
+  },
+  "Black D": {
+    "expression": "sin(X)*sin(Y)*sin(Z)+sin(X)*cos(Y)*cos(Z)+cos(X)*sin(Y)*cos(Z)+cos(X)*cos(Y)*sin(Z)",
+    "source_label": "Black D Surface"
+  },
+  "FRD": {
+    "expression": "8*(cos(X)*cos(Y)*cos(Z))+cos(2*X)*cos(2*Y)*cos(2*Z)-cos(2*X)*cos(2*Y)-cos(2*Y)*cos(2*Z)-cos(2*Z)*cos(2*X)",
+    "source_label": "FRD Surface"
+  },
+  "Diamond D": {
+    "expression": "sin(X)*sin(Y)*sin(Z)+sin(X)*cos(Y)*cos(Z)+cos(X)*sin(Y)*cos(Z)+cos(X)*cos(Y)*sin(Z)",
+    "source_label": "Diamond D Surface",
+    "alias_of": "Black D"
+  },
+  "D": {
+    "expression": "cos(X)*cos(Y)*cos(Z)-sin(X)*sin(Y)*sin(Z)",
+    "source_label": "D Surface"
+  },
+  "Split P": {
+    "expression": "1.1*(sin(2*X)*sin(Z)*cos(Y)+sin(2*Y)*sin(X)*cos(Z)+sin(2*Z)*sin(Y)*cos(X))-0.2*(cos(2*X)*cos(2*Y)+cos(2*Y)*cos(2*Z)+cos(2*Z)*cos(2*X))-0.4*(cos(X)+cos(Y)+cos(Z))",
+    "source_label": "Split P Surface"
+  }
+}

tpmslab/io.py

@@ -0,0 +1,72 @@
+"""Deterministic model export and file-integrity manifest."""
+
+import hashlib
+import importlib.metadata
+import json
+from pathlib import Path
+import platform
+import numpy as np
+from .volume import write_nastran
+
+
+def save_model(model, directory):
+    """Write NAS, NPZ, STL preview, parameters, checks and hashes to a NEW folder.
+
+    Existing directories are rejected. STL is a preview, not the solver mesh.
+    """
+    folder = Path(directory).resolve()
+    if folder.exists():
+        raise FileExistsError(f"Output already exists: {folder}")
+    folder.mkdir(parents=True)
+    write_nastran(model, folder / "mesh.nas")
+    np.savez_compressed(
+        folder / "mesh.npz",
+        points_mm=model["points"],
+        tetrahedra=model["tetra"],
+        boundary=model["boundary"],
+        boundary_ids=model["boundary_ids"],
+        domain_ids=model["domains"],
+        **{
+            k: model[k]
+            for k in ("phase_ids", "interface", "solid_boundary", "fluid_boundary")
+            if k in model
+        },
+    )
+    model["surface"].export(folder / "preview.stl")
+    if "fluid_surface" in model:
+        model["fluid_surface"].export(folder / "fluid_preview.stl")
+        (folder / "domains.json").write_text(
+            json.dumps(
+                {
+                    "domains": model["report"]["domain_map"],
+                    "boundaries": model["report"]["boundary_tag_names"],
+                },
+                indent=2,
+            ),
+            encoding="utf8",
+        )
+    for filename, data in (
+        ("config.json", model["report"]["config"]),
+        ("report.json", model["report"]),
+    ):
+        (folder / filename).write_text(
+            json.dumps(data, ensure_ascii=False, indent=2), encoding="utf8"
+        )
+    environment = {"python": platform.python_version(), "platform": platform.platform()}
+    for name in ("numpy", "scipy", "trimesh"):
+        environment[name] = importlib.metadata.version(name)
+    (folder / "environment.json").write_text(json.dumps(environment, indent=2), encoding="utf8")
+    refresh_manifest(folder)
+    return folder
+
+
+def refresh_manifest(directory):
+    """Refresh checksums after optional COMSOL artifacts change."""
+    folder = Path(directory)
+    manifest = {
+        p.name: {"bytes": p.stat().st_size, "sha256": hashlib.sha256(p.read_bytes()).hexdigest()}
+        for p in sorted(folder.iterdir())
+        if p.is_file() and p.name != "manifest.json"
+    }
+    (folder / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf8")
+    return folder

tpmslab/model.py

@@ -0,0 +1,258 @@
+"""Implicit field definitions and density calibration for direct volume meshing.
+
+The trigonometric functions are level-set approximations, not exact minimal
+surfaces. Density grading uses the CDF of a sampled periodic unit cell.
+"""
+
+from __future__ import annotations
+import ast
+from dataclasses import asdict, dataclass
+from functools import lru_cache
+import json
+from pathlib import Path
+import operator
+import numpy as np
+
+DATA = Path(__file__).with_name("families.json")
+FAMILIES = json.loads(DATA.read_text(encoding="utf-8"))
+FUNCTIONS = {name: getattr(np, name) for name in ("sin", "cos", "tan", "sqrt", "abs", "exp")}
+OPS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.Pow: operator.pow,
+}
+
+
+@lru_cache(maxsize=128)
+def parse_expression(expression):
+    if not isinstance(expression, str) or len(expression) > 2000:
+        raise ValueError("自定义公式过长（最多 2000 字符）。")
+    tree = ast.parse(expression, mode="eval")
+    nodes = list(ast.walk(tree))
+    if len(nodes) > 500:
+        raise ValueError("公式过于复杂。")
+    for node in nodes:
+        if not isinstance(
+            node,
+            (
+                ast.Expression,
+                ast.BinOp,
+                ast.UnaryOp,
+                ast.Call,
+                ast.Name,
+                ast.Load,
+                ast.Constant,
+                ast.Add,
+                ast.Sub,
+                ast.Mult,
+                ast.Div,
+                ast.Pow,
+                ast.USub,
+                ast.UAdd,
+            ),
+        ):
+            raise ValueError("公式只允许 X/Y/Z、pi、数字、数学运算和已列出的函数。")
+        if isinstance(node, ast.Name) and node.id not in {*FUNCTIONS, "X", "Y", "Z", "pi"}:
+            raise ValueError(f"不支持的名称：{node.id}")
+        if isinstance(node, ast.Constant) and (
+            type(node.value) not in (int, float) or abs(node.value) > 1e6
+        ):
+            raise ValueError("公式常量必须是绝对值不超过 1e6 的数字。")
+        if isinstance(node, ast.Call) and (
+            not isinstance(node.func, ast.Name)
+            or node.func.id not in FUNCTIONS
+            or len(node.args) != 1
+            or node.keywords
+        ):
+            raise ValueError("函数必须是单参数数学函数。")
+        if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Pow):
+            if (
+                not isinstance(node.right, ast.Constant)
+                or not isinstance(node.right.value, (int, float))
+                or abs(node.right.value) > 8
+            ):
+                raise ValueError("指数必须是 -8 到 8 之间的数值常量。")
+    return tree.body
+
+
+def evaluate(expression, X, Y, Z):
+    variables = {"X": X, "Y": Y, "Z": Z, "pi": np.pi}
+
+    def visit(node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        if isinstance(node, ast.Name):
+            if node.id not in variables:
+                raise ValueError("A function name must be followed by parentheses")
+            return variables[node.id]
+        if isinstance(node, ast.BinOp):
+            return OPS[type(node.op)](visit(node.left), visit(node.right))
+        if isinstance(node, ast.UnaryOp):
+            return -visit(node.operand) if isinstance(node.op, ast.USub) else visit(node.operand)
+        if isinstance(node, ast.Call):
+            return FUNCTIONS[node.func.id](visit(node.args[0]))
+        raise ValueError("公式节点不受支持。")
+
+    with np.errstate(all="ignore"):
+        value = np.asarray(visit(parse_expression(expression)), dtype=np.float64)
+    if not np.all(np.isfinite(value)):
+        raise ValueError("公式在采样范围内出现无穷或无效值，请检查除法、开方和指数。")
+    return value
+
+
+@dataclass(frozen=True)
+class Config:
+    family: str = "Gyroid"
+    mode: str = "sheet"
+    size: tuple = (5.0, 5.0, 5.0)
+    cells: tuple = (1, 1, 1)
+    density_start: float = 0.25
+    density_end: float = 0.50
+    gradient: str = "linear"
+    axis: str = "z"
+    shape: str = "box"
+    resolution: int = 16
+    quality_strategy: str = "quality_fan"
+    domain_mode: str = "solid"
+    periodic_amplitudes: tuple = (0.05, 0.05, 0.05)
+    phase_degrees: tuple = (0.0, 0.0, 90.0)
+    custom: str = "sin(X)*cos(Y)+sin(Y)*cos(Z)+sin(Z)*cos(X)"
+
+    def __post_init__(self):
+        for name in ("size", "cells", "periodic_amplitudes", "phase_degrees"):
+            value = getattr(self, name)
+            if not isinstance(value, (list, tuple)):
+                raise ValueError(f"{name} must be a sequence of length 3")
+            object.__setattr__(self, name, tuple(value))
+
+    @classmethod
+    def from_dict(cls, data):
+        if not isinstance(data, dict):
+            raise ValueError("参数必须是 JSON 对象。")
+        try:
+            c = cls(**data)
+        except TypeError as exc:
+            raise ValueError("存在未知参数字段。") from exc
+        c.validate()
+        return c
+
+    def validate(self):
+        if self.domain_mode not in ("solid", "solid_fluid"):
+            raise ValueError("domain_mode must be solid or solid_fluid")
+        if self.quality_strategy not in ("pulling", "quality_fan"):
+            raise ValueError("quality_strategy must be pulling or quality_fan")
+        if self.family not in FAMILIES and self.family != "Custom":
+            raise ValueError("未知曲面族。")
+        if self.mode not in ("sheet", "solid_above", "solid_below"):
+            raise ValueError("未知结构形式。")
+        if self.gradient not in (
+            "uniform",
+            "linear",
+            "quadratic",
+            "cubic",
+            "cosine",
+            "exponential",
+            "radial",
+            "periodic",
+        ):
+            raise ValueError("未知梯度。")
+        if self.axis not in ("x", "y", "z"):
+            raise ValueError("未知梯度方向。")
+        if self.shape != "box":
+            raise ValueError("未知外形。")
+        if len(self.size) != 3 or any(
+            type(v) not in (int, float) or not np.isfinite(v) or not 0.1 <= v <= 1000
+            for v in self.size
+        ):
+            raise ValueError("三个外形尺寸必须在 0.1–1000 mm 之间。")
+        if len(self.cells) != 3 or any(type(v) is not int or not 1 <= v <= 6 for v in self.cells):
+            raise ValueError("胞元数必须为 1–6 的整数。")
+        if type(self.resolution) is not int or not 8 <= self.resolution <= 64:
+            raise ValueError("每胞元采样数必须为 8–64 的整数。")
+        if np.prod(np.array(self.cells) * self.resolution) > 200_000:
+            raise ValueError("背景立方网格超过 20 万，请减少胞元数或分辨率。")
+        for v in (self.density_start, self.density_end):
+            if type(v) not in (int, float) or not np.isfinite(v) or not 0.08 <= v <= 0.85:
+                raise ValueError("相对密度必须在 0.08–0.85 之间。")
+        if len(self.periodic_amplitudes) != 3 or any(
+            type(v) not in (int, float) or not np.isfinite(v) or abs(v) > 0.4
+            for v in self.periodic_amplitudes
+        ):
+            raise ValueError("周期梯度幅值必须为三个绝对值不超过 0.4 的有限数。")
+        if self.gradient == "periodic" and (
+            self.density_start - sum(map(abs, self.periodic_amplitudes)) < 0.08 - 1e-10
+            or self.density_start + sum(map(abs, self.periodic_amplitudes)) > 0.85 + 1e-10
+        ):
+            raise ValueError("周期梯度的密度范围超出 0.08–0.85，请减小幅值或调整平均密度。")
+        if len(self.phase_degrees) != 3 or any(
+            type(v) not in (int, float) or not np.isfinite(v) or abs(v) > 360
+            for v in self.phase_degrees
+        ):
+            raise ValueError("相位必须是三个 -360 到 360 度之间的数。")
+        parse_expression(self.expression)
+
+    @property
+    def expression(self):
+        return self.custom if self.family == "Custom" else FAMILIES[self.family]["expression"]
+
+    def to_dict(self):
+        return asdict(self)
+
+
+@lru_cache(maxsize=64)
+def calibration(expression, mode):
+    # Midpoints avoid bias from duplicated periodic endpoints.
+    a = (np.arange(56) + 0.5) * (2 * np.pi / 56)
+    values = evaluate(expression, a[:, None, None], a[None, :, None], a[None, None, :])
+    values = np.broadcast_to(values, (56, 56, 56))
+    if mode == "sheet":
+        values = np.abs(values)
+    elif mode == "solid_above":
+        values = -values
+    values = np.sort(values.ravel())
+    if np.ptp(values) < 1e-10:
+        raise ValueError("公式场是常量，不能生成指定密度的结构。")
+    return np.linspace(0, 1, len(values)), values
+
+
+def target_density(config, X, Y, Z):
+    pos = (X, Y, Z)
+    if config.gradient == "periodic":
+        return config.density_start + sum(
+            a * np.cos(2 * np.pi * p / L)
+            for a, p, L in zip(config.periodic_amplitudes, pos, config.size)
+        )
+    k = "xyz".index(config.axis)
+    t = np.clip(pos[k] / config.size[k], 0, 1)
+    if config.gradient == "uniform":
+        t = np.zeros_like(t)
+    elif config.gradient == "quadratic":
+        t = t**2
+    elif config.gradient == "cubic":
+        t = t**3
+    elif config.gradient == "cosine":
+        t = (1 - np.cos(np.pi * t)) / 2
+    elif config.gradient == "exponential":
+        t = np.expm1(3 * t) / np.expm1(3)
+    elif config.gradient == "radial":
+        axes = [i for i in range(3) if i != k]
+        radius = min(config.size[i] for i in axes) / 2
+        t = np.clip(np.sqrt(sum((pos[i] - config.size[i] / 2) ** 2 for i in axes)) / radius, 0, 1)
+    return config.density_start + (config.density_end - config.density_start) * t
+
+
+def raw_field(config, X, Y, Z):
+    angles = [
+        2 * np.pi * p * n / L + np.deg2rad(phase)
+        for p, n, L, phase in zip((X, Y, Z), config.cells, config.size, config.phase_degrees)
+    ]
+    f = evaluate(config.expression, *angles)
+    probabilities, values = calibration(config.expression, config.mode)
+    q = np.interp(target_density(config, X, Y, Z), probabilities, values)
+    if config.mode == "sheet":
+        f = np.abs(f)
+    elif config.mode == "solid_above":
+        f = -f
+    return q - f  # Positive means solid material.

tpmslab/multidomain.py

@@ -0,0 +1,196 @@
+"""Complementary solid/fluid meshes sharing exact cut-edge identities."""
+
+from dataclasses import replace
+import hashlib
+import time
+import numpy as np
+import trimesh
+from scipy.sparse import coo_matrix
+from scipy.sparse.csgraph import connected_components
+from .volume import generate_volume, TET_FACES, EDGES, boundary_digest
+
+
+def generate_solid_fluid(config, progress):
+    start = time.monotonic()
+    single = replace(config, domain_mode="solid")
+    progress("生成固体域及互补孔隙流体域…")
+    parts = [generate_volume(single, progress)]
+    for side in range(2 if config.mode == "sheet" else 1):
+        part = generate_volume(single, progress, _fluid_side=side)
+        if part is not None:
+            parts.append(part)
+    points, lookup, cells, phases = [], {}, [], []
+    for part_index, part in enumerate(parts):
+        remap = []
+        for key, point in zip(part["vertex_keys"], part["points"]):
+            # Interior fan vertices belong to a single clipped region.
+            key = (*key, part_index) if key[0] == 2 else key
+            if key not in lookup:
+                lookup[key] = len(points)
+                points.append(point)
+            elif not np.allclose(points[lookup[key]], point, rtol=0, atol=max(config.size) * 1e-12):
+                raise ValueError("Solid/fluid cut vertex coordinates disagree")
+            remap.append(lookup[key])
+        cells.append(np.asarray(remap)[part["tetra"]])
+        phases.extend([1 if part_index == 0 else 2] * len(part["tetra"]))
+    points = np.asarray(points)
+    tetra = np.concatenate(cells).astype(np.int32)
+    phases = np.asarray(phases, dtype=np.int32)
+    faces = tetra[:, TET_FACES].reshape(-1, 3)
+    _, inverse, counts = np.unique(
+        np.sort(faces, axis=1), axis=0, return_inverse=True, return_counts=True
+    )
+    if counts.max() > 2:
+        raise ValueError("Nonmanifold solid/fluid partition")
+    order = np.argsort(inverse, kind="stable")
+    starts = np.r_[0, np.cumsum(counts)[:-1]]
+    exterior = order[starts[counts == 1]]
+    pairs = starts[counts == 2]
+    a, b = order[pairs], order[pairs + 1]
+    interface_pair = phases[a // 4] != phases[b // 4]
+    # Consistent positive tetrahedron orientation implies opposite face normals.
+    fa, fb = faces[a], faces[b]
+    na = np.cross(points[fa[:, 1]] - points[fa[:, 0]], points[fa[:, 2]] - points[fa[:, 0]])
+    nb = np.cross(points[fb[:, 1]] - points[fb[:, 0]], points[fb[:, 2]] - points[fb[:, 0]])
+    if np.any(np.einsum("ij,ij->i", na, nb) >= 0):
+        raise ValueError("Overlapping or inconsistently oriented adjacent cells")
+    interface = np.where(phases[a[interface_pair] // 4] == 1, a[interface_pair], b[interface_pair])
+    if not len(interface):
+        raise ValueError("No solid-fluid interface generated")
+    exterior_faces = faces[exterior]
+    side_ids = np.zeros(len(exterior), dtype=np.int32)
+    tol = max(config.size) * 1e-9
+    for axis in range(3):
+        for side, value in enumerate((0, config.size[axis])):
+            mask = np.all(np.abs(points[exterior_faces, axis] - value) < tol, axis=1)
+            side_ids[mask] = 2 + 2 * axis + side
+    if np.any(side_ids == 0):
+        raise ValueError("Solid/fluid partition has an internal crack or unmatched interface")
+    side_ids += np.where(phases[exterior // 4] == 2, 10, 0)
+    boundary = np.concatenate([exterior_faces, faces[interface]])
+    boundary_ids = np.r_[side_ids, np.full(len(interface), 8)].astype(np.int32)
+    same = ~interface_pair
+    graph = coo_matrix(
+        (np.ones(np.sum(same)), (a[same] // 4, b[same] // 4)), shape=(len(tetra), len(tetra))
+    )
+    components, labels = connected_components(graph, directed=False)
+    # Number all solid components first, then all fluid components.
+    _, representatives = np.unique(labels, return_index=True)
+    raw = sorted(range(components), key=lambda k: (int(phases[representatives[k]]), k))
+    mapping = np.empty(components, dtype=np.int32)
+    mapping[raw] = np.arange(1, components + 1)
+    domains = mapping[labels]
+    p = points[tetra]
+    volumes = (
+        np.einsum("ij,ij->i", p[:, 1] - p[:, 0], np.cross(p[:, 2] - p[:, 0], p[:, 3] - p[:, 0])) / 6
+    )
+    expected = float(np.prod(config.size))
+    if np.any(volumes <= 0) or not np.isclose(volumes.sum(), expected, rtol=1e-10):
+        raise ValueError("Solid and fluid do not form a positive-volume partition of the box")
+    domain_map = []
+    for d in np.unique(domains):
+        mask = domains == d
+        phase = "solid" if phases[mask][0] == 1 else "fluid"
+        touching = sorted(set(map(int, side_ids[domains[exterior // 4] == d])))
+        domain_map.append(
+            dict(
+                id=int(d),
+                nastran_pid=100 + int(d),
+                phase=phase,
+                tetrahedra=int(mask.sum()),
+                volume_mm3=float(volumes[mask].sum()),
+                exterior_boundary_ids=touching,
+            )
+        )
+    quality = (
+        12
+        * (3 * volumes) ** (2 / 3)
+        / sum(np.sum((p[:, a] - p[:, b]) ** 2, axis=1) for a, b in EDGES)
+    )
+    solid_volume = float(volumes[phases == 1].sum())
+    fluid_volume = float(volumes[phases == 2].sum())
+    solid_faces = np.concatenate([exterior_faces[phases[exterior // 4] == 1], faces[interface]])
+    fluid_faces = np.concatenate(
+        [exterior_faces[phases[exterior // 4] == 2], faces[interface][:, [0, 2, 1]]]
+    )
+    surface = trimesh.Trimesh(points.copy(), solid_faces, process=False)
+    surface.remove_unreferenced_vertices()
+    fluid_surface = trimesh.Trimesh(points.copy(), fluid_faces, process=False)
+    fluid_surface.remove_unreferenced_vertices()
+    report = dict(parts[0]["report"])
+    report.update(
+        config=config.to_dict(),
+        representation="conforming complementary solid/fluid tetrahedral domains",
+        vertices=len(points),
+        bounds_mm=[points.min(axis=0).tolist(), points.max(axis=0).tolist()],
+        tetrahedra=len(tetra),
+        triangles=len(boundary),
+        volume_components=components,
+        solid_components=sum(x["phase"] == "solid" for x in domain_map),
+        fluid_components=sum(x["phase"] == "fluid" for x in domain_map),
+        domain_map=domain_map,
+        volume_mm3=solid_volume,
+        solid_volume_mm3=solid_volume,
+        fluid_volume_mm3=fluid_volume,
+        total_mesh_volume_mm3=float(volumes.sum()),
+        actual_density=solid_volume / expected,
+        porosity=fluid_volume / expected,
+        partition_volume_error_mm3=float(abs(volumes.sum() - expected)),
+        interface_triangles=len(interface),
+        interface_conforming=True,
+        interface_invalid_triangles=int(np.sum(counts[inverse[interface]] != 2)),
+        interface_area_mm2=float(np.linalg.norm(na[interface_pair], axis=1).sum() / 2),
+        boundary_tag_names={
+            **{
+                str(2 + i): "solid_" + name
+                for i, name in enumerate(("xmin", "xmax", "ymin", "ymax", "zmin", "zmax"))
+            },
+            **{
+                str(12 + i): "fluid_" + name
+                for i, name in enumerate(("xmin", "xmax", "ymin", "ymax", "zmin", "zmax"))
+            },
+            "8": "solid_fluid_interface",
+        },
+        minimum_tetra_volume_mm3=float(volumes.min()),
+        quality_quantiles=dict(
+            zip(
+                ("min", "p01", "median", "max"), map(float, np.quantile(quality, [0, 0.01, 0.5, 1]))
+            )
+        ),
+        low_quality_count_below_001=int(np.sum(quality < 0.01)),
+        low_quality_volume_fraction_below_001=float(volumes[quality < 0.01].sum() / expected),
+        improved_cut_cells=sum(part["report"]["improved_cut_cells"] for part in parts),
+        minimum_selected_local_quality_ratio=None,
+        mesh_sha256=hashlib.sha256(
+            points.astype("<f8").tobytes()
+            + tetra.astype("<i4").tobytes()
+            + domains.astype("<i4").tobytes()
+        ).hexdigest(),
+        boundary_sha256=boundary_digest(points, boundary),
+        schema_version=2,
+        generator_version="0.3.0rc1",
+        elapsed_seconds=round(time.monotonic() - start, 3),
+    )
+    report["warnings"] = [w for w in report["warnings"] if "静力学演示" not in w]
+    report["warnings"] += [
+        "固体与流体仅填充同一长方体外形内部；不包含外部流场或入口缓冲段。",
+        "固液界面为共享节点的共形网格；流体边界层和流动网格收敛尚需按工况检查。",
+        "流体可能含多个独立流道或封闭孔隙，应按连通域选择进出口。",
+    ]
+    progress(
+        f"双域分区通过：{report['solid_components']} 个固体域，{report['fluid_components']} 个流体域，共享 {len(interface):,} 个界面三角形。"
+    )
+    return dict(
+        points=points,
+        tetra=tetra,
+        boundary=boundary,
+        boundary_ids=boundary_ids,
+        domains=domains,
+        phase_ids=phases,
+        interface=faces[interface],
+        solid_boundary=solid_faces,
+        fluid_boundary=fluid_faces,
+        surface=surface,
+        fluid_surface=fluid_surface,
+        report=report,
+    )