tpmslab 0.3.0__py3-none-any.whl

tpmslab/__init__.py

@@ -0,0 +1,30 @@
+"""Public API for TPMS Lab. Mesh coordinates use millimetres."""
+
+from .model import Config
+from .volume import generate_volume, write_nastran
+from .io import save_model
+
+__version__ = "0.3.0"
+__all__ = ["Config", "generate", "generate_volume", "write_nastran", "save_model", "list_families"]
+
+
+def generate(config=None, *, progress=None):
+    """Return a mesh dictionary with points, tetrahedra, boundaries and report.
+
+    ``config`` may be Config, a configuration dictionary, or None for defaults.
+    Array connectivity is zero-based. Coordinates are millimetres.
+    """
+    if config is None:
+        config = Config()
+    if isinstance(config, dict):
+        config = Config.from_dict(config)
+    if not isinstance(config, Config):
+        raise TypeError("config must be Config or dict")
+    return generate_volume(config, progress=progress or (lambda message: None))
+
+
+def list_families():
+    """Return a copy of the built-in formula metadata, including aliases."""
+    from .model import FAMILIES
+
+    return {name: dict(data) for name, data in FAMILIES.items()}

tpmslab/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

tpmslab/cli.py

@@ -0,0 +1,63 @@
+"""Command-line entry points; core commands do not import Flask or COMSOL."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+from . import Config, generate, list_families, save_model, __version__
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="tpmslab", description="Direct TPMS solid volume meshes")
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("families", help="List built-in formulas and aliases")
+    init = sub.add_parser("init-config", help="Write a default JSON configuration")
+    init.add_argument("path", type=Path)
+    make = sub.add_parser("generate", help="Generate and validate a volume mesh")
+    make.add_argument("--config", type=Path)
+    make.add_argument("--out", type=Path, required=True)
+    make.add_argument("--mph", action="store_true")
+    make.add_argument("--solve", action="store_true")
+    web = sub.add_parser("web", help="Start the optional local browser interface")
+    web.add_argument("--output", type=Path, default=Path.cwd() / "tpmslab-output")
+    web.add_argument("--port", type=int, default=0)
+    web.add_argument("--no-browser", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "families":
+            print(json.dumps(list_families(), indent=2))
+            return 0
+        if args.command == "init-config":
+            with args.path.open("x", encoding="utf8") as stream:
+                json.dump(Config().to_dict(), stream, indent=2)
+            return 0
+        if args.command == "web":
+            os.environ["TPMSLAB_OUTPUT_DIR"] = str(args.output.resolve())
+            try:
+                from .web import serve
+            except ImportError as exc:
+                raise RuntimeError('Install the web extra: pip install "tpmslab[web]"') from exc
+            serve(args.port, args.no_browser)
+            return 0
+        config = (
+            Config.from_dict(json.loads(args.config.read_text(encoding="utf-8-sig")))
+            if args.config
+            else Config()
+        )
+        if args.out.exists():
+            raise FileExistsError(f"Output already exists: {args.out}")
+        model = generate(config, progress=print)
+        save_model(model, args.out)
+        if args.mph or args.solve:
+            from .comsol import build_mph
+
+            build_mph(args.out, model["report"], solve=args.solve, progress=print)
+        print(str(args.out.resolve()))
+        return 0
+    except (ValueError, TypeError, OSError, RuntimeError) as exc:
+        parser.exit(2, f"tpmslab: {exc}\n")
+
+
+if __name__ == "__main__":
+    main()

tpmslab/comsol.py

@@ -0,0 +1,250 @@
+"""COMSOL 6.3 Java bridge. Generated MPH embeds the volume mesh.
+No edits to user's existing MPH files; each export gets a new job directory.
+"""
+
+import json
+import re
+import os
+from pathlib import Path
+import subprocess
+import numpy as np
+
+TEMPLATE = r"""import com.comsol.model.*;
+import com.comsol.model.util.*;
+import java.util.*;
+import java.nio.file.*;
+import java.nio.charset.StandardCharsets;
+public class TPMSBuild {
+ static String ROOT=@@ROOT@@;
+ static boolean SOLVE=@@SOLVE@@;
+ static void face(Model m,String tag,double value) {
+  m.component("c").selection().create(tag,"Box");
+  m.component("c").selection(tag).geom("g",2);
+  m.component("c").selection(tag).set("condition","inside");
+  m.component("c").selection(tag).set("xmin",-1.0);
+  m.component("c").selection(tag).set("xmax",@@LX@@+1.0);
+  m.component("c").selection(tag).set("ymin",-1.0);
+  m.component("c").selection(tag).set("ymax",@@LY@@+1.0);
+  m.component("c").selection(tag).set("zmin",value-@@TOL@@);
+  m.component("c").selection(tag).set("zmax",value+@@TOL@@);
+  if(m.component("c").selection(tag).entities(2).length==0) throw new RuntimeException("Empty boundary "+tag);
+ }
+ public static void main(String[] args)throws Exception {
+  Model m=ModelUtil.create("Model");
+  m.label("TPMS Lab - direct solid volume mesh");m.modelPath(ROOT);
+  m.param().set("E0","@@E@@[Pa]");m.param().set("nu0","@@NU@@");
+  m.param().set("rho0","@@RHO@@[kg/m^3]");m.param().set("uamp","@@DISP@@[mm]");
+  m.component().create("c",true);m.component("c").geom().create("g",3);
+  m.component("c").geom("g").lengthUnit("mm");
+  m.component("c").mesh().create("mesh","g");m.component("c").mesh("mesh").geometricModel("");
+  m.component("c").mesh("mesh").create("imp","Import");
+  m.component("c").mesh("mesh").feature("imp").set("source","nastran");
+  m.component("c").mesh("mesh").feature("imp").set("filename",ROOT+"mesh.nas");
+  m.component("c").mesh("mesh").feature("imp").set("data","mesh");
+  m.component("c").mesh("mesh").feature("imp").set("allowshellpartition",false);
+  m.component("c").mesh("mesh").feature("imp").set("facepartition","minimal");
+  m.component("c").mesh("mesh").run();m.component("c").geometricModel("mesh");
+  m.component("c").sorder("linear");
+  m.component("c").physics().create("solid","SolidMechanics","g");
+  m.component("c").physics("solid").prop("ShapeProperty").set("order_displacement",1);
+  for(String prop:new String[]{"E","nu","rho"}) m.component("c").physics("solid").feature("lemm1").set(prop+"_mat","userdef");
+  m.component("c").physics("solid").feature("lemm1").set("E","E0");
+  m.component("c").physics("solid").feature("lemm1").set("nu","nu0");
+  m.component("c").physics("solid").feature("lemm1").set("rho","rho0");
+  @@BOUNDARIES@@
+  m.component("c").mesh("mesh").feature("imp").set("filename","mesh.nas");
+  m.save(ROOT+"model_unsolved.mph");
+  double volume=0,energy=0,maxdisp=0;
+  if(SOLVE) {
+   System.out.println("TPMS_SOLVE_START"); m.study("std").run();
+   m.result().numerical().create("integrals","IntVolume");m.result().numerical("integrals").selection().all();
+   m.result().numerical("integrals").set("expr",new String[]{"1","solid.Ws"});
+   m.result().numerical("integrals").set("unit",new String[]{"m^3","J"});
+   double[][] v=m.result().numerical("integrals").getReal();volume=v[0][0];energy=v[1][0];
+   m.result().numerical().create("umax","MaxVolume");m.result().numerical("umax").selection().all();
+   m.result().numerical("umax").set("expr","solid.disp");m.result().numerical("umax").set("unit",new String[]{"m"});maxdisp=m.result().numerical("umax").getReal()[0][0];
+   if(maxdisp<0.99*m.param().evaluate("uamp") || maxdisp>100*m.param().evaluate("uamp")) throw new RuntimeException("Displacement unit/magnitude check failed");
+   if(!Double.isFinite(volume)||!Double.isFinite(energy)||!Double.isFinite(maxdisp)||energy<=0||maxdisp<=0) throw new RuntimeException("Invalid result");
+   if(Math.abs(volume-@@VOL@@)/@@VOL@@>1e-6) throw new RuntimeException("Imported volume mismatch");
+   m.result().create("pg1","PlotGroup3D");m.result("pg1").label("Displacement - static demonstration");
+   m.result("pg1").create("surf1","Surface");m.result("pg1").feature("surf1").set("expr","solid.disp");
+   m.save(ROOT+"model_solved.mph");
+  }
+  String saved=ROOT+(SOLVE?"model_solved.mph":"model_unsolved.mph");
+  ModelUtil.remove("Model");m=ModelUtil.load("Check",saved);
+  int tetra=m.component("c").mesh("mesh").getNumElem("tet");
+  if(tetra!=@@TETS@@)throw new RuntimeException("Embedded mesh mismatch: "+tetra);
+  if(SOLVE) {
+   double[][] v=m.result().numerical("integrals").getReal();
+   if(Math.abs(v[0][0]-volume)>1e-15||Math.abs(v[1][0]-energy)>Math.abs(energy)*1e-10) throw new RuntimeException("Reopen result mismatch");
+  }
+  String text="{\"import_verified\":true,\"reopen_verified\":true,\"solved\":"+SOLVE+",\"tetrahedra\":"+tetra+",\"volume_m3\":"+volume+",\"strain_energy_J\":"+energy+",\"max_displacement_m\":"+maxdisp+",\"convergence_verified\":false}";
+  System.out.println("TPMS_REOPEN_VERIFIED "+text);ModelUtil.remove("Check");
+ }
+}"""
+BOUNDARIES = r"""
+  face(m,"bottom",0.0);face(m,"top",@@LZ@@);
+  m.component("c").physics("solid").create("fix1","Fixed",2);
+  m.component("c").physics("solid").feature("fix1").selection().named("bottom");
+  m.component("c").physics("solid").create("disp1","Displacement2",2);
+  m.component("c").physics("solid").feature("disp1").selection().named("top");
+  m.component("c").physics("solid").feature("disp1").setIndex("Direction","prescribed",2);
+  m.component("c").physics("solid").feature("disp1").setIndex("U0","-uamp",2);
+  m.study().create("std");m.study("std").create("stat","Stationary");
+"""
+
+
+def detect_comsol():
+    paths = [
+        os.environ.get("COMSOL_BIN", ""),
+        r"D:/Program Files/COMSOL/COMSOL63/Multiphysics/bin/win64",
+        r"C:/Program Files/COMSOL/COMSOL63/Multiphysics/bin/win64",
+    ]
+    for parent in [Path("C:/Program Files/COMSOL"), Path("D:/Program Files/COMSOL")]:
+        if parent.exists():
+            paths += [str(p / "Multiphysics/bin/win64") for p in parent.iterdir() if p.is_dir()]
+    for raw in paths:
+        p = Path(raw)
+        if (p / "comsolbatch.exe").is_file() and (p / "comsolcompile.exe").is_file():
+            return p
+    return None
+
+
+def export_java(folder, report, solve=False, material=None):
+    folder = Path(folder).resolve()
+    if report["config"].get("domain_mode") == "solid_fluid":
+        from .comsol_dual import export_dual_java
+
+        return export_dual_java(folder, report, solve)
+    material = material or {"E": 1.5e9, "nu": 0.3, "rho": 950.0}
+    if any(
+        type(material.get(k)) not in (int, float) or not np.isfinite(material[k])
+        for k in ("E", "nu", "rho")
+    ):
+        raise ValueError("材料参数必须是有限数。")
+    if not (
+        1e3 <= material["E"] <= 1e13 and 0 <= material["nu"] < 0.49 and 0 < material["rho"] <= 1e6
+    ):
+        raise ValueError("材料参数超出支持范围。")
+    size = report["config"]["size"]
+    connected = report["volume_components"] == 1
+    if solve and not connected:
+        raise ValueError("静力学演示要求材料连通；当前存在多个独立实体，请先调整结构。")
+    text = TEMPLATE.replace("@@BOUNDARIES@@", BOUNDARIES if connected else "")
+    values = {
+        "ROOT": json.dumps(folder.as_posix() + "/", ensure_ascii=True),
+        "SOLVE": str(solve).lower(),
+        "LX": repr(float(size[0])),
+        "LY": repr(float(size[1])),
+        "LZ": repr(float(size[2])),
+        "TOL": repr(max(size) * 1e-7),
+        "VOL": repr(report["volume_mm3"] * 1e-9),
+        "TETS": str(report["tetrahedra"]),
+        "E": repr(float(material["E"])),
+        "NU": repr(float(material["nu"])),
+        "RHO": repr(float(material["rho"])),
+        "DISP": repr(float(size[2]) * 0.001),
+    }
+    for key, value in values.items():
+        text = text.replace("@@" + key + "@@", value)
+    (folder / "TPMSBuild.java").write_text(text, encoding="ascii")
+    (folder / "simulation_settings.json").write_text(
+        json.dumps(
+            {
+                "material": material,
+                "test": "bottom fixed, top z displacement -0.001*Lz; lateral top free; P1, linear geometry",
+                "solve_requested": solve,
+            },
+            indent=2,
+        ),
+        encoding="utf8",
+    )
+    return folder / "TPMSBuild.java"
+
+
+def build_mph(
+    folder,
+    report,
+    solve=False,
+    material=None,
+    progress=lambda s: None,
+    *,
+    max_solve_tetrahedra=180_000,
+    build_timeout_s=600,
+):
+    if type(max_solve_tetrahedra) is not int or not 1 <= max_solve_tetrahedra <= 1_000_000:
+        raise ValueError("max_solve_tetrahedra must be an integer in [1, 1000000]")
+    if type(build_timeout_s) is not int or not 1 <= build_timeout_s <= 3600:
+        raise ValueError("build_timeout_s must be an integer in [1, 3600]")
+    folder = Path(folder).resolve()
+    exe = detect_comsol()
+    if not exe:
+        raise RuntimeError("未找到 COMSOL。已提供 NAS；请设置 COMSOL_BIN 后再创建 MPH。")
+    if solve and report["tetrahedra"] > max_solve_tetrahedra:
+        raise ValueError(
+            f"演示求解上限为 {max_solve_tetrahedra:,} 个体单元；请降低采样数或明确设置研究用上限。"
+        )
+    java = export_java(folder, report, solve, material)
+    flags = subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0
+    for name, cmd, timeout in [
+        ("compile", [str(exe / "comsolcompile.exe"), str(java)], 180),
+        (
+            "build",
+            [
+                str(exe / "comsolbatch.exe"),
+                "-np",
+                "2",
+                "-inputfile",
+                str(java.with_suffix(".class")),
+                "-batchlog",
+                str(folder / "comsol.log"),
+            ],
+            build_timeout_s,
+        ),
+    ]:
+        progress(
+            "编译 COMSOL 接口…"
+            if name == "compile"
+            else ("COMSOL 导入并执行演示求解…" if solve else "COMSOL 创建并重开实体模型…")
+        )
+        with (folder / (name + ".log")).open("w", encoding="utf8") as log:
+            process = subprocess.Popen(
+                cmd, cwd=folder, stdout=log, stderr=subprocess.STDOUT, creationflags=flags
+            )
+            try:
+                code = process.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                if os.name == "nt":
+                    subprocess.run(
+                        ["taskkill", "/PID", str(process.pid), "/T", "/F"],
+                        stdout=log,
+                        stderr=log,
+                        creationflags=flags,
+                    )
+                else:
+                    process.kill()
+                raise RuntimeError(
+                    "COMSOL 运行超时。日志已保留；请降低分辨率或明确设置更长的 build_timeout_s 后重试。"
+                )
+        if code:
+            raise RuntimeError(f"COMSOL {name} 失败，请查看 {name}.log 与 comsol.log。")
+    evidence = folder / "comsol_verification.json"
+    log_text = (folder / "build.log").read_text(encoding="utf8", errors="replace")
+    found = re.findall(r"TPMS_REOPEN_VERIFIED (\{[^\r\n]+\})", log_text)
+    if not found:
+        raise RuntimeError(
+            "COMSOL 未完成重开验证，请查看 build.log（可能是许可、导入或求解错误）。"
+        )
+    result = json.loads(found[-1])
+    evidence.write_text(json.dumps(result, indent=2), encoding="utf8")
+    if result.get("solved") != solve:
+        raise RuntimeError("求解验证记录与本次请求不一致。")
+    report.update(comsol_verified=True, comsol_solved=bool(result["solved"]), comsol=result)
+    (folder / "report.json").write_text(
+        json.dumps(report, ensure_ascii=False, indent=2), encoding="utf8"
+    )
+    from .io import refresh_manifest
+
+    refresh_manifest(folder)
+    progress("COMSOL 模型已重新打开并验证。")
+    return result

tpmslab/comsol_audit.py

@@ -0,0 +1,128 @@
+"""Read-only audits of saved COMSOL pore-flow solutions (COMSOL 6.3)."""
+
+import json
+import hashlib
+import os
+from pathlib import Path
+import re
+import subprocess
+from .comsol import detect_comsol
+
+JAVA = r"""import com.comsol.model.*;
+import com.comsol.model.util.*;
+import java.util.*;
+public class TPMSAudit {
+ static double integral(Model m,String tag,String selection,String expr,String unit) {
+  m.result().numerical().create(tag,"IntSurface");
+  m.result().numerical(tag).selection().named(selection);
+  m.result().numerical(tag).set("expr",expr);
+  m.result().numerical(tag).set("unit",unit);
+  return m.result().numerical(tag).getReal()[0][0];
+ }
+ static String intersect(Model m,String tag,int[] adjacent,String plane) {
+  HashSet<Integer> a=new HashSet<>();for(int i:adjacent)a.add(i);
+  int[] ids=Arrays.stream(m.component("c").selection(plane).entities(2)).filter(a::contains).toArray();
+  if(ids.length==0)throw new RuntimeException("Empty channel opening "+tag);
+  m.component("c").selection().create(tag,"Explicit");m.component("c").selection(tag).geom("g",2);m.component("c").selection(tag).set(ids);return tag;
+ }
+ public static void main(String[] args)throws Exception {
+  Model m=ModelUtil.load("Audit",@@MODEL@@);
+  double area=integral(m,"auditArea","solid_fluid_interface","1","mm^2");
+  double eta=Math.abs(area-@@AREA@@)/@@AREA@@;
+  if(!Double.isFinite(area)||eta>1e-8)throw new RuntimeException("Interface area mismatch: "+area);
+  StringBuilder rows=new StringBuilder(); double sumIn=0,sumOut=0;
+  int[] domainIds=new int[]{@@IDS@@};
+  for(int id:domainIds) {
+   String adj="auditAdj"+id;m.component("c").selection().create(adj,"Adjacent");
+   m.component("c").selection(adj).set("entitydim",3);m.component("c").selection(adj).set("outputdim",2);
+   m.component("c").selection(adj).set("input",new String[]{"fluid_"+id});
+   int[] boundaries=m.component("c").selection(adj).entities(2);
+   String in=intersect(m,"auditIn"+id,boundaries,"fluid_zmin"),out=intersect(m,"auditOut"+id,boundaries,"fluid_zmax");
+   double ai=integral(m,"auditAi"+id,in,"1","mm^2"),ao=integral(m,"auditAo"+id,out,"1","mm^2");
+   double qi=integral(m,"auditQi"+id,in,"-w","m^3/s"),qo=integral(m,"auditQo"+id,out,"w","m^3/s");
+   double balance=Math.abs(qi+qo)/Math.max(Math.abs(qi),Math.abs(qo));
+   if(!Double.isFinite(balance)||!(qi<0)||!(qo>0)||balance>0.05)throw new RuntimeException("Channel balance failed: "+id+" "+balance);
+   if(rows.length()>0)rows.append(",");
+   rows.append("{\"domain_id\":"+id+",\"inlet_area_mm2\":"+ai+",\"outlet_area_mm2\":"+ao+",\"inlet_outward_flux_m3_s\":"+qi+",\"outlet_flux_m3_s\":"+qo+",\"relative_flux_imbalance\":"+balance+",\"solver_domain_ids\":"+Arrays.toString(m.component("c").selection("fluid_"+id).entities(3))+"}");
+   sumIn+=qi;sumOut+=qo;
+  }
+  System.out.println("TPMS_AUDIT {\"interface_area_comsol_mm2\":"+area+",\"interface_area_relative_error\":"+eta+",\"channels\":["+rows+"],\"channel_sum_inlet_m3_s\":"+sumIn+",\"channel_sum_outlet_m3_s\":"+sumOut+"}");
+  ModelUtil.remove("Audit");
+ }
+}"""
+
+
+def audit_saved_flow(model_path, interface_area_mm2, domain_map, output):
+    """Audit the stored solution without changing its MPH; write separate audit files."""
+    output = Path(output).resolve()
+    output.mkdir(parents=True, exist_ok=False)
+    exe = detect_comsol()
+    if exe is None:
+        raise RuntimeError("COMSOL installation not found")
+    text = JAVA.replace("@@MODEL@@", json.dumps(Path(model_path).resolve().as_posix()))
+    text = text.replace("@@AREA@@", repr(float(interface_area_mm2)))
+    text = text.replace(
+        "@@IDS@@", ",".join(str(d["id"]) for d in domain_map if d["phase"] == "fluid")
+    )
+    java = output / "TPMSAudit.java"
+    java.write_text(text, encoding="ascii")
+    for name, cmd, timeout in [
+        ("compile", [str(exe / "comsolcompile.exe"), str(java)], 180),
+        (
+            "audit",
+            [
+                str(exe / "comsolbatch.exe"),
+                "-np",
+                "2",
+                "-inputfile",
+                str(java.with_suffix(".class")),
+                "-batchlog",
+                str(output / "comsol.log"),
+            ],
+            600,
+        ),
+    ]:
+        with (output / (name + ".log")).open("w", encoding="utf8") as log:
+            subprocess.run(
+                cmd,
+                cwd=output,
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                timeout=timeout,
+                check=True,
+                creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+            )
+    s = (output / "audit.log").read_text("utf8", errors="replace")
+    match = re.search(r"TPMS_AUDIT (\{[^\r\n]+\})", s)
+    if not match:
+        raise RuntimeError("COMSOL audit did not complete; inspect audit.log and comsol.log")
+    result = json.loads(match[1])
+    result["interface_area_mesh_mm2"] = interface_area_mm2
+    result["source_mph_sha256"] = hashlib.sha256(Path(model_path).read_bytes()).hexdigest()
+    mapping = {d["id"]: d for d in domain_map}
+    for channel in result["channels"]:
+        channel["tetrahedra"] = mapping[channel["domain_id"]]["tetrahedra"]
+        channel["volume_mm3"] = mapping[channel["domain_id"]]["volume_mm3"]
+    mesh_path = Path(model_path).parent / "mesh.npz"
+    if mesh_path.exists():
+        import numpy as np
+        from .verification import audit_openings
+
+        with np.load(mesh_path) as a:
+            mesh = dict(
+                points=a["points_mm"],
+                tetra=a["tetrahedra"],
+                phase_ids=a["phase_ids"],
+                domains=a["domain_ids"],
+            )
+        openings = {d["domain_id"]: d for d in audit_openings(mesh, mesh["points"].max(axis=0))}
+        for channel in result["channels"]:
+            for name in ("inlet", "outlet"):
+                area = openings[channel["domain_id"]][name + "_area_mesh_mm2"]
+                error = abs(channel[name + "_area_mm2"] - area) / area
+                if error > 1e-8:
+                    raise RuntimeError("Imported channel opening area mismatch")
+                channel[name + "_area_mesh_mm2"] = area
+                channel[name + "_area_relative_error"] = error
+    (output / "audit.json").write_text(json.dumps(result, indent=2), "utf8")
+    return result

tpmslab/comsol_dual.py

@@ -0,0 +1,165 @@
+"""COMSOL solid/fluid selections and optional fixed-wall creeping-flow smoke test."""
+
+import json
+from pathlib import Path
+
+TEMPLATE = r"""import com.comsol.model.*;
+import com.comsol.model.util.*;
+import java.util.*;
+import java.util.regex.*;
+public class TPMSBuild {
+ static String ROOT=@@ROOT@@;
+ static boolean SOLVE=@@SOLVE@@;
+ static void select(Model m,String name,int dim,int[] ids) {
+  m.component("c").selection().create(name,"Explicit");
+  m.component("c").selection(name).geom("g",dim);
+  m.component("c").selection(name).set(ids);
+  m.component("c").selection(name).label(name);
+ }
+ static int[] pid(Model m,int value,int dim) {
+  Pattern p=Pattern.compile("\\bID\\s+"+value+"\\b");
+  for(String tag:m.component("c").selection().tags()) {
+   if(p.matcher(m.component("c").selection(tag).label()).find()) {
+    int[] ids=m.component("c").selection(tag).entities(dim);
+    if(ids.length>0)return ids;
+   }
+  }
+  throw new RuntimeException("Missing NASTRAN PID "+value+" dimension "+dim);
+ }
+ static int[] join(List<Integer> ids) {return ids.stream().mapToInt(Integer::intValue).distinct().toArray();}
+ static void verify(Model m) {
+  if(m.component("c").mesh("mesh").getNumElem("tet")!=@@TETS@@)throw new RuntimeException("Tetrahedron count mismatch");
+  int[] es=m.component("c").mesh("mesh").getElemEntity("tet");
+  int[][] ts=m.component("c").mesh("mesh").getElem("tet");
+  double[][] ps=m.component("c").mesh("mesh").getVertex();
+  HashMap<Integer,Double> vol=new HashMap<>();
+  for(int i=0;i<es.length;i++) {
+   double[] a=new double[3],b=new double[3],c=new double[3];
+   for(int j=0;j<3;j++){a[j]=ps[j][ts[1][i]]-ps[j][ts[0][i]];b[j]=ps[j][ts[2][i]]-ps[j][ts[0][i]];c[j]=ps[j][ts[3][i]]-ps[j][ts[0][i]];}
+   double v=Math.abs(a[0]*(b[1]*c[2]-b[2]*c[1])+a[1]*(b[2]*c[0]-b[0]*c[2])+a[2]*(b[0]*c[1]-b[1]*c[0]))/6;
+   vol.put(es[i],vol.getOrDefault(es[i],0.0)+v);
+  }
+  @@CHECK_VOLUMES@@
+  if(m.component("c").selection("solid_domains").entities(3).length!=@@SOLID_COUNT@@ || m.component("c").selection("fluid_domains").entities(3).length!=@@FLUID_COUNT@@)throw new RuntimeException("Phase selection mismatch");
+  if(m.component("c").selection("solid_fluid_interface").entities(2).length==0)throw new RuntimeException("Missing interface");
+ }
+ static double integral(Model m,String tag,String selection,String expr) {
+  m.result().numerical().create(tag,"IntSurface");
+  m.result().numerical(tag).selection().named(selection);
+  m.result().numerical(tag).set("expr",expr);
+  m.result().numerical(tag).set("unit","m^3/s");
+  return m.result().numerical(tag).getReal()[0][0];
+ }
+ public static void main(String[] args)throws Exception {
+  Model m=ModelUtil.create("Model");m.modelPath(ROOT);m.label("TPMS Lab - solid and pore fluid domains");
+  m.component().create("c",true);m.component("c").geom().create("g",3);m.component("c").geom("g").lengthUnit("mm");
+  m.component("c").mesh().create("mesh","g");m.component("c").mesh("mesh").geometricModel("");
+  m.component("c").mesh("mesh").create("imp","Import");
+  m.component("c").mesh("mesh").feature("imp").set("source","nastran");
+  m.component("c").mesh("mesh").feature("imp").set("filename",ROOT+"mesh.nas");
+  m.component("c").mesh("mesh").feature("imp").set("data","mesh");
+  m.component("c").mesh("mesh").feature("imp").set("materialsplit",true);
+  m.component("c").mesh("mesh").feature("imp").set("selcreation",true);
+  m.component("c").mesh("mesh").feature("imp").set("allowshellpartition",false);
+  m.component("c").mesh("mesh").feature("imp").set("facepartition","minimal");
+  m.component("c").mesh("mesh").run();m.component("c").geometricModel("mesh");
+  List<Integer> solid=new ArrayList<>(),fluid=new ArrayList<>();
+  @@SELECTIONS@@
+  select(m,"solid_domains",3,join(solid));select(m,"fluid_domains",3,join(fluid));
+  verify(m);
+  m.component("c").material().create("mat_s","Common");m.component("c").material("mat_s").label("Solid - demonstration properties");
+  m.component("c").material("mat_s").selection().named("solid_domains");
+  m.component("c").material("mat_s").propertyGroup("def").set("youngsmodulus","1.5e9[Pa]");
+  m.component("c").material("mat_s").propertyGroup("def").set("poissonsratio","0.3");
+  m.component("c").material("mat_s").propertyGroup("def").set("density","950[kg/m^3]");
+  m.component("c").material().create("mat_f","Common");m.component("c").material("mat_f").label("Pore fluid - demonstration properties");
+  m.component("c").material("mat_f").selection().named("fluid_domains");
+  m.component("c").material("mat_f").propertyGroup("def").set("density","1000[kg/m^3]");
+  m.component("c").material("mat_f").propertyGroup("def").set("dynamicviscosity","0.001[Pa*s]");
+  if(SOLVE) {
+   m.component("c").sorder("linear");
+   m.component("c").physics().create("spf","CreepingFlow","g");
+   m.component("c").physics("spf").selection().named("fluid_domains");
+   m.component("c").physics("spf").create("inl1","InletBoundary",2);
+   m.component("c").physics("spf").feature("inl1").selection().named("fluid_zmin");
+   m.component("c").physics("spf").feature("inl1").set("BoundaryCondition","Pressure");
+   m.component("c").physics("spf").feature("inl1").set("p0","0.01[Pa]");
+   m.component("c").physics("spf").create("out1","OutletBoundary",2);
+   m.component("c").physics("spf").feature("out1").selection().named("fluid_zmax");
+   m.component("c").physics("spf").feature("out1").set("p0","0[Pa]");
+   m.study().create("std");m.study("std").create("stat","Stationary");
+  }
+  m.component("c").mesh("mesh").feature("imp").set("filename","mesh.nas");
+  m.save(ROOT+"model_unsolved.mph");
+  double qin=0,qout=0,balance=0;
+  if(SOLVE) {
+   m.study("std").run();
+   qin=integral(m,"qin","fluid_zmin","-w");qout=integral(m,"qout","fluid_zmax","w");
+   balance=Math.abs(qin+qout)/Math.max(Math.abs(qin),Math.abs(qout));
+   if(!Double.isFinite(qin)||!Double.isFinite(qout)||!(qin<0)||!(qout>0)||balance>0.05)throw new RuntimeException("Flow or conservation check failed: "+qin+" "+qout+" "+balance);
+   m.result().create("pg1","PlotGroup3D");m.result("pg1").label("Pore fluid speed - fixed-wall creeping-flow demonstration");
+   m.result("pg1").create("surf1","Surface");m.result("pg1").feature("surf1").set("expr","spf.U");
+   m.save(ROOT+"model_solved.mph");
+  }
+  ModelUtil.remove("Model");m=ModelUtil.load("Check",ROOT+(SOLVE?"model_solved.mph":"model_unsolved.mph"));verify(m);
+  if(SOLVE && Math.abs(m.result().numerical("qout").getReal()[0][0]-qout)>Math.abs(qout)*1e-10)throw new RuntimeException("Reopened flow result mismatch");
+  String result="{\"import_verified\":true,\"reopen_verified\":true,\"phase_volumes_verified\":true,\"solid_domains\":@@SOLID_COUNT@@,\"fluid_domains\":@@FLUID_COUNT@@,\"interface_selection_verified\":true,\"solved\":"+SOLVE+",\"test\":\"fixed_wall_creeping_flow\",\"inlet_outward_flux_m3_s\":"+qin+",\"outlet_flux_m3_s\":"+qout+",\"relative_flux_imbalance\":"+balance+",\"fsi_verified\":false,\"convergence_verified\":false}";
+  System.out.println("TPMS_REOPEN_VERIFIED "+result);ModelUtil.remove("Check");
+ }
+}"""
+
+
+def export_dual_java(folder, report, solve=False):
+    folder = Path(folder).resolve()
+    if solve and any(
+        not {16, 17}.issubset(d["exterior_boundary_ids"])
+        for d in report["domain_map"]
+        if d["phase"] == "fluid"
+    ):
+        raise ValueError(
+            "流动演示要求每个流体域都连通 Z- 和 Z+；请创建未求解 MPH 后按各流道设置边界。"
+        )
+    selections, checks = [], []
+    for d in report["domain_map"]:
+        var = f"d{d['id']}"
+        selections.append(
+            f'int[] {var}=pid(m,{d["nastran_pid"]},3); select(m,"{d["phase"]}_{d["id"]}",3,{var}); for(int id:{var}) {d["phase"]}.add(id);'
+        )
+        checks.append(
+            f'double v{d["id"]}=0; for(int id:m.component("c").selection("{d["phase"]}_{d["id"]}").entities(3)) v{d["id"]}+=vol.getOrDefault(id,0.0); if(Math.abs(v{d["id"]}-{d["volume_mm3"]})>{max(d["volume_mm3"] * 1e-8, 1e-10)})throw new RuntimeException("Volume mismatch for {var}: "+v{d["id"]});'
+        )
+    boundary_ids = {8}
+    for d in report["domain_map"]:
+        boundary_ids.update(d["exterior_boundary_ids"])
+    for pid in sorted(boundary_ids):
+        selections.append(f'select(m,"{report["boundary_tag_names"][str(pid)]}",2,pid(m,{pid},2));')
+    text = TEMPLATE
+    values = dict(
+        ROOT=json.dumps(folder.as_posix() + "/"),
+        SOLVE=str(solve).lower(),
+        TETS=str(report["tetrahedra"]),
+        SOLID_COUNT=str(report["solid_components"]),
+        FLUID_COUNT=str(report["fluid_components"]),
+        SELECTIONS="\n  ".join(selections),
+        CHECK_VOLUMES="\n  ".join(checks),
+    )
+    for key, value in values.items():
+        text = text.replace("@@" + key + "@@", value)
+    (folder / "TPMSBuild.java").write_text(text, encoding="ascii")
+    (folder / "simulation_settings.json").write_text(
+        json.dumps(
+            dict(
+                test="fixed-wall creeping flow in pore fluid only; no deformation/FSI",
+                solve_requested=solve,
+                inlet="fluid_zmin, 0.01 Pa",
+                outlet="fluid_zmax, 0 Pa",
+                walls="no slip on solid-fluid interface and other fluid exterior faces",
+                fluid_density_kg_m3=1000,
+                fluid_dynamic_viscosity_Pa_s=0.001,
+                convergence_verified=False,
+            ),
+            indent=2,
+        ),
+        encoding="utf8",
+    )
+    return folder / "TPMSBuild.java"