poker-mcp 1.9.8 → 1.9.9

package/README.md

@@ -4,7 +4,7 @@ YAML-based input file management tool for radiation-shielding calculation code P
 
 ## 📋 クイック情報
 
-- **バージョン**: 1.9.8
+- **バージョン**: 1.9.9
 - **ツール数**: 36メソッド
 - **プロトコル**: MCP (Model Context Protocol) 1.0.0 完全準拠
 - **メインサーバー**: `src/mcp_server_stdio_v4.js`
@@ -12,6 +12,35 @@ YAML-based input file management tool for radiation-shielding calculation code P
 - **核種データ**: `${POKER_INSTALL_PATH}/LIB/ICRP-07.NDX` を直接参照
 - **実行方式**: STDIO通信（MCPプロトコル標準）
 
+## 🐛 バージョン1.9.9の修正
+
+npm で入れた環境（`npx poker-mcp`）でだけ現れる不具合と、失敗の伝え方の不具合を
+直しました。まっさらな Windows に npm パッケージから入れた環境で、CAD 連携を含む
+計算結果がリポジトリ上の実行と全行一致することを確認しています。
+
+### `poker_generateInput` が npm 版で動かなかった
+
+`tools/gen_input.py` と、それが読み込む `tools/scatter.py` が `package.json` の
+`files` から漏れていました。リポジトリから動かすと問題なく、npm から入れた環境で
+だけ `No module named 'gen_input'` で失敗していました。
+
+### 失敗が成功として返っていた
+
+CAD 系などのハンドラが返す `{ content, isError }` を、共通の処理がもう一度包んで
+いたため、`isError: true` が本文の中に埋もれ、MCP の上では成功として伝わって
+いました。AI クライアントは失敗に気づかないまま次の手順へ進みます。
+
+すでに MCP の応答形式になっている戻り値はそのまま返し、`{ success: false, ... }`
+を返すハンドラには `isError: true` を付けるようにしました。立体・ゾーン・線源など
+の検証エラーも、MCP の上で失敗として伝わります。
+
+### 計算エラーの処理そのものが落ちていた
+
+`poker_executeCalculation` が計算エラーを返す途中で
+`Cannot read properties of undefined (reading '_isRecoverableError')` になり、
+本来のエラー内容が隠れていました。ハンドラがオブジェクトから切り離して呼ばれる
+ため `this` が未定義になっていたのが原因です。
+
 ## 🆕 バージョン1.9.8の新機能
 
 ### 📜 `poker_getSchema` — ファイル書式を JSON Schema で取得
@@ -659,6 +688,11 @@ POKER_MCP_HOME/
 
 ## 📝 更新履歴
 
+### v1.9.9 (2026-10)
+- 🐛 `tools/gen_input.py` と `tools/scatter.py` を npm パッケージに同梱（`poker_generateInput` が npm 版で動かなかった）
+- 🐛 ツールの失敗が `isError: true` として伝わるよう修正（応答の二重包みを解消、`success: false` に `isError` を付与）
+- 🐛 `poker_executeCalculation` の計算エラー処理が `this` 未定義で落ちていた問題を修正
+
 ### v1.9.8 (2026-10)
 - ✨ `poker_getSchema`（入力YAML・`.paths`・`.summary`・`.dose` の書式を JSON Schema で取得）
 - 🐛 `poker_getDoseMap` が `.dose` の列構成を `information` から読むようになり、線量種別の増加に追随
@@ -749,6 +783,6 @@ obtained separately and licensed separately. poker-mcp は `poker_cui` を外部
 
 ---
 
-**🎯 Poker MCP Server v1.9.8**  
+**🎯 Poker MCP Server v1.9.9**  
 **プロトコル**: MCP 1.0.0 完全準拠  
 **作者**: Yoshihiro Hirao | **ライセンス**: MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poker-mcp",
-  "version": "1.9.8",
+  "version": "1.9.9",
   "description": "YAML-based input file management tool for radiation shielding calculation code POKER with MCP support - Enhanced with collision detection, daughter nuclide auto-completion, and environment variable support",
   "main": "src/mcp_server_stdio_v4.js",
   "type": "module",
@@ -56,7 +56,9 @@
   },
   "files": [
     "src/",
+    "tools/gen_input.py",
     "tools/gen_paths.py",
+    "tools/scatter.py",
     "tools/ray_trace_tri.py",
     "tools/poker_lib.py",
     "tools/audit_mfp.py",

package/src/mcp/handlers/calculationHandlers.js

@@ -10,7 +10,9 @@ import { parseDoseMap } from '../../utils/doseMapParser.js';
 export function createCalculationHandlers(taskManager) {
   const calculationService = new CalculationService();
 
-  return {
+  // server.js はハンドラを handler(args) の形でオブジェクトから切り離して呼ぶため、
+  // 内部の補助関数は this ではなくこの変数経由で参照する。
+  const handlers = {
     async getDoseMap(args) {
       try {
         if (!args.detector_name) {
@@ -231,8 +233,8 @@ export function createCalculationHandlers(taskManager) {
             mcp_error_code: error.mcpErrorCode,
             details: {
               category: 'calculation_error',
-              recoverable: this._isRecoverableError(error.code),
-              suggestions: this._getErrorSuggestions(error.code, error.context)
+              recoverable: handlers._isRecoverableError(error.code),
+              suggestions: handlers._getErrorSuggestions(error.code, error.context)
             }
           };
         }
@@ -343,4 +345,6 @@ export function createCalculationHandlers(taskManager) {
       }
     }
   };
+
+  return handlers;
 }

package/src/mcp/middleware/errorHandler.js

@@ -37,11 +37,29 @@ export function handleMcpError(error, context = {}) {
   return new McpError(ErrorCode.InternalError, `内部エラー: ${error.message}`);
 }
 
+/**
+ * ハンドラの戻り値を MCP の CallToolResult に整える。
+ *  - すでに CallToolResult の形（content 配列を持つ）ならそのまま返す。
+ *    包み直すと isError が text の中に埋もれ、失敗が成功として伝わってしまう。
+ *  - { success: false, ... } を返すハンドラは失敗として isError: true を付ける。
+ *    AI クライアントは本文を読まずに isError で成否を判断することがあるため。
+ */
+export function toCallToolResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result;
+  }
+  const wrapped = { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  if (result && typeof result === 'object' && result.success === false) {
+    wrapped.isError = true;
+  }
+  return wrapped;
+}
+
 export function safeExecute(fn, context = {}) {
   return async (request) => {
     try {
       const result = await fn(request);
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      return toCallToolResult(result);
     } catch (error) {
       throw handleMcpError(error, context);
     }

package/tools/gen_input.py

@@ -0,0 +1,717 @@
+# gen_input.py -- CAD モデルから POKER の YAML 入力を組み立てる
+#
+# CAD が正本という前提。線源・検出器・材質・分割数を CAD のカスタムプロパティに
+# 持たせ、そこから YAML を生成する。人が YAML を書く必要をなくすのが目的。
+#
+# 使い方:
+#   freecadcmd -c "import gen_input; gen_input.main('spec.json')"
+#
+# spec.json:
+#   { "fcstd": "...", "out": "poker.yaml", "poker_dir": "C:/Poker" }
+#
+# CAD 側のカスタムプロパティ:
+#
+#   全オブジェクト共通
+#     PokerRole      shield(既定) / source / detector
+#
+#   遮蔽体 (PokerRole=shield)
+#     PokerMaterial  材質名（Iron, Concrete, ...）
+#     PokerDensity   密度の上書き [g/cm3]（省略可）
+#
+#   線源 (PokerRole=source)
+#     PokerNuclides  "Co60:3.7e10, Cs137:1.0e11"
+#     PokerDivision  "8 16 30"（軸の順は形状で決まる。省略時は既定値）
+#     PokerCutoff    打ち切り率（省略時 1e-4）
+#
+#   検出器 (PokerRole=detector)
+#     PokerDivision      "5 5"（2D）/ "5 5 5"（3D）。省略時は各方向 5
+#                        グリッドの次元は形状から決まる:
+#                          球・小さい立体 -> 点検出器
+#                          薄い直方体     -> 2D（面線量マップ）
+#                          直方体         -> 3D（体積線量マップ）
+#     PokerShowPathTrace True/False（省略時 False）
+
+import json
+import os
+import re
+
+import FreeCAD as App
+
+import poker_lib
+import scatter
+
+# CAD(mm) -> POKER(cm)
+#   FreeCAD の内部表現は常に mm で、表示の単位系設定(UserSchema)は Shape の
+#   座標に影響しない。UnitsSchemaInternal の定義に「FreeCAD uses a mm/kg/deg
+#   scala」と明記されており、UserSchema(SI1/SI2/Imperial/Centimeters 等)は
+#   表示の切り替えにすぎない。実測でも Quantity("1 m").Value == 1000.0。
+#   よってこの係数は固定でよい。
+SCALE = 0.1
+
+# 線源の分割数を寸法から決めるときの基準。
+#
+#   1 区画の厚さが DIV_MFP mfp 以下になるよう分割する。
+#
+# これは出発点であって最適値ではない。本来は分割数を変えて線量の収束を
+# 確認し、それで決めるもの。ここでの既定値は「収束解析を始める前の、
+# ひとまず妥当な値」という位置づけ。利用者は PokerDivision で上書きできる。
+#
+# 2 mfp としたのは、実運用の分割（キャスクで r 方向 1.9 mfp、z 方向 2.7 mfp）
+# に近いため。1 mfp だと点数が現実的でなくなる（キャスクで半径 16 分割、
+# 高さ 81 分割）。
+DIV_MFP = 2.0
+
+# 軸ごとの上限は設けない。2 mfp という基準を軸によって変える理由がなく、
+# 細長い線源では z 方向に、扁平な線源では r 方向に、自然に多く配分される。
+#
+# 周方向(phi)だけは寸法で決まらないので固定値を使う。円周を何分割するかは
+# 半径の mfp とは別の話で、方位角方向の線量分布をどれだけ解像したいかで決まる。
+DIV_PHI = 16
+DIV_MIN = 2
+
+# 点数が過大になったときに気づけるよう、この数を超えたら警告する。
+# 止めはしない（利用者が意図して細かくしている場合もある）。
+DIV_WARN_POINTS = 20000
+
+
+def _div_from_size(size_cm, mu):
+    # size_cm を DIV_MFP mfp 以下に刻むのに必要な分割数
+    if mu is None or mu <= 0:
+        return DIV_MIN
+    n = int(size_cm * mu / DIV_MFP + 0.999)
+    return max(DIV_MIN, n)
+
+
+def _num(v, default=None):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return default
+
+
+def _xyz(v, scale=SCALE):
+    # 重心計算などで 1e-17 のような値が出るので、実質ゼロは 0 に丸める。
+    # POKER の入力に指数表記の微小値が並ぶと読みにくい。
+    def f(x):
+        x = x * scale
+        return 0.0 if abs(x) < 1e-9 else x
+    return '%g %g %g' % (f(v.x), f(v.y), f(v.z))
+
+
+def role_of(obj):
+    r = (getattr(obj, 'PokerRole', None) or 'shield').strip().lower()
+    return r if r in ('shield', 'source', 'detector') else 'shield'
+
+
+def parse_nuclides(text):
+    # "Co60:3.7e10, Cs137:1.0e11" -> [("Co60", 3.7e10), ("Cs137", 1.0e11)]
+    out = []
+    for part in re.split(r'[,;]', text or ''):
+        part = part.strip()
+        if not part:
+            continue
+        m = re.match(r'^([A-Za-z]+[-_]?\d+m?)\s*[:=]\s*([\d.eE+-]+)$', part)
+        if not m:
+            raise SystemExit(
+                'PokerNuclides の書式が不正です: %r\n'
+                '  例: "Co60:3.7e10, Cs137:1.0e11"' % part)
+        out.append((m.group(1).replace('-', '').replace('_', ''), float(m.group(2))))
+    return out
+
+
+def surface_types(sh):
+    # 面の種類を数える。OCC は Surface の型で曲面種別が分かる。
+    #   Cylinder / Sphere / Cone / Toroid / Plane / BSplineSurface ...
+    from collections import Counter
+    return Counter(type(f.Surface).__name__ for f in sh.Faces)
+
+
+def classify(sh):
+    # ソリッドの形から POKER の立体型を判定する。
+    #
+    # 面の数だけで判定すると誤る。三角柱も五面体も「平面だけ」だが、
+    # 面数は形によって変わる。曲面の種別で分ける方が確実。
+    #
+    # 返り値: ('RCC'|'SPH'|'BOX'|None, 補足情報)
+    t = surface_types(sh)
+    n_plane = t.get('Plane', 0)
+    n_face = len(sh.Faces)
+
+    # 球: 球面1枚だけ
+    if t.get('Sphere', 0) == 1 and n_face == 1:
+        s = sh.Faces[0].Surface
+        return 'SPH', {'center': s.Center, 'radius': s.Radius}
+
+    # 円柱: 円柱面1枚 + 平面2枚（上下の蓋）
+    if t.get('Cylinder', 0) == 1 and n_plane == 2 and n_face == 3:
+        cyl = [f for f in sh.Faces if type(f.Surface).__name__ == 'Cylinder'][0]
+        s = cyl.Surface
+        ax = s.Axis
+        # 底面と上面を軸方向の位置で見分ける
+        planes = [f for f in sh.Faces if type(f.Surface).__name__ == 'Plane']
+        ts = sorted(((f.CenterOfMass - s.Center).dot(ax), f.CenterOfMass)
+                    for f in planes)
+        h = ts[-1][0] - ts[0][0]
+        return 'RCC', {'bottom': ts[0][1], 'axis': ax, 'height': h,
+                       'radius': s.Radius}
+
+    # 直方体: 平面6枚で、法線が3方向（各2枚ずつ）
+    if n_plane == 6 and n_face == 6:
+        axes = []
+        for f in sh.Faces:
+            a = f.Surface.Axis
+            if not any(abs(abs(a.dot(b)) - 1.0) < 1e-6 for b in axes):
+                axes.append(a)
+        if len(axes) == 3:
+            # 直交しているか（斜方体でないか）確認
+            ok = (abs(axes[0].dot(axes[1])) < 1e-6 and
+                  abs(axes[1].dot(axes[2])) < 1e-6 and
+                  abs(axes[0].dot(axes[2])) < 1e-6)
+            if ok:
+                return 'BOX', {'axes': axes}
+
+    return None, {'faces': n_face, 'types': dict(t)}
+
+
+def read_source(obj, nuclide_override=None, mu_src=None):
+    # mu_src: 線源材質の線減弱係数 [1/cm]。分割数を寸法から決めるのに使う。
+    #   線源自身の自己遮蔽が効くので、1区画が厚すぎると精度が落ちる。
+    # 形状から線源の型と幾何を決める。核種と分割は プロパティから。
+    sh = obj.Shape
+    kind, geo = classify(sh)
+    bb = sh.BoundBox
+
+    nuc = parse_nuclides(getattr(obj, 'PokerNuclides', None) or '')
+    # 子孫核種を補完した結果が spec で渡されていればそちらを使う。
+    #   Cs137 は β 崩壊のみで光子をほぼ出さず、0.662 MeV は娘核種 Ba137m から
+    #   出る。忘れると線量が 1/3 になるため、poker_mcp 側で補完した結果を渡す。
+    if nuclide_override and obj.Name in nuclide_override:
+        nuc = [(d['nuclide'], float(d['radioactivity']))
+               for d in nuclide_override[obj.Name]]
+    if not nuc:
+        raise SystemExit(
+            '線源 %s に PokerNuclides が設定されていません\n'
+            '  例: "Co60:3.7e10"' % obj.Name)
+
+    src = {
+        'name': obj.Name,
+        'inventory': [{'nuclide': n, 'radioactivity': a} for n, a in nuc],
+        'cutoff_rate': _num(getattr(obj, 'PokerCutoff', None), 1e-4),
+    }
+
+    div_text = (getattr(obj, 'PokerDivision', None) or '').strip()
+    div = [int(x) for x in div_text.split()] if div_text else None
+
+    # 体積が無視できるほど小さければ点線源として扱う（印として置いた球など）
+    if sh.Volume * (SCALE ** 3) < 1.0:      # 1 cm3 未満
+        src['type'] = 'POINT'
+        src['position'] = _xyz(sh.CenterOfMass)
+        return src
+
+    if kind == 'RCC':
+        # 軸は円柱面から取る。バウンディングボックスから作ると傾いた円柱に
+        # 対応できず、横倒しの燃料棒や斜めの配管がまったく違う形になる。
+        b, ax, h = geo['bottom'], geo['axis'], geo['height']
+        src['type'] = 'RCC'
+        src['geometry'] = {
+            'bottom_center': _xyz(b),
+            'height_vector': '%g %g %g' % (ax.x * h * SCALE,
+                                           ax.y * h * SCALE,
+                                           ax.z * h * SCALE),
+            'radius': geo['radius'] * SCALE,
+        }
+        d = div or [
+            _div_from_size(geo['radius'] * SCALE, mu_src),
+            DIV_PHI,
+            _div_from_size(abs(h) * SCALE, mu_src),
+        ]
+        src['division'] = {
+            'r': {'number': d[0], 'type': 'UNIFORM'},
+            'phi': {'number': d[1], 'type': 'UNIFORM'},
+            'z': {'number': d[2], 'type': 'UNIFORM'},
+        }
+        return src
+
+    if kind == 'SPH':
+        # POKER の SPH 線源。分割は r/phi/theta。
+        src['type'] = 'SPH'
+        src['geometry'] = {
+            'center': _xyz(geo['center']),
+            'radius': geo['radius'] * SCALE,
+        }
+        d = div or [
+            _div_from_size(geo['radius'] * SCALE, mu_src),
+            DIV_PHI,
+            DIV_PHI,
+        ]
+        src['division'] = {
+            'r': {'number': d[0], 'type': 'UNIFORM'},
+            'phi': {'number': d[1], 'type': 'UNIFORM'},
+            'theta': {'number': d[2], 'type': 'UNIFORM'},
+        }
+        return src
+
+    if kind == 'BOX':
+        src['type'] = 'BOX'
+        src['geometry'] = {
+            'vertex': '%g %g %g' % (bb.XMin * SCALE, bb.YMin * SCALE, bb.ZMin * SCALE),
+            'edge_1': '%g 0 0' % (bb.XLength * SCALE),
+            'edge_2': '0 %g 0' % (bb.YLength * SCALE),
+            'edge_3': '0 0 %g' % (bb.ZLength * SCALE),
+        }
+        d = div or [
+            _div_from_size(bb.XLength * SCALE, mu_src),
+            _div_from_size(bb.YLength * SCALE, mu_src),
+            _div_from_size(bb.ZLength * SCALE, mu_src),
+        ]
+        src['division'] = {
+            'edge_1': {'number': d[0], 'type': 'UNIFORM'},
+            'edge_2': {'number': d[1], 'type': 'UNIFORM'},
+            'edge_3': {'number': d[2], 'type': 'UNIFORM'},
+        }
+        return src
+
+    # 判定できない形（円錐、トーラス、自由曲面、フィレット付きなど）。
+    # 黙って外接直方体で近似すると、利用者が気づかないまま違う線源分布で
+    # 計算することになる。明示的に拒否し、対処法を示す。
+    raise SystemExit(
+        '線源 %s の形状を判定できません（面: %s）\n'
+        '  POKER の線源は POINT / RCC(円柱) / SPH(球) / BOX(直方体) です。\n'
+        '  この形状を線源に使うには、外接する円柱か直方体に置き換えるか、\n'
+        '  YAML を手で書いてください。' % (obj.Name, geo))
+
+    if kind == 'RCC':
+        # 円柱。軸は最も長い辺の方向とみなす
+        src['type'] = 'RCC'
+        src['geometry'] = {
+            'bottom_center': '%g %g %g' % (
+                (bb.XMin + bb.XMax) / 2 * SCALE,
+                (bb.YMin + bb.YMax) / 2 * SCALE,
+                bb.ZMin * SCALE),
+            'height_vector': '0 0 %g' % (bb.ZLength * SCALE),
+            'radius': max(bb.XLength, bb.YLength) / 2 * SCALE,
+        }
+        d = div or [
+            _div_from_size(geo['radius'] * SCALE, mu_src),
+            DIV_PHI,
+            _div_from_size(abs(h) * SCALE, mu_src),
+        ]
+        src['division'] = {
+            'r': {'number': d[0], 'type': 'UNIFORM'},
+            'phi': {'number': d[1], 'type': 'UNIFORM'},
+            'z': {'number': d[2], 'type': 'UNIFORM'},
+        }
+    elif kind == 'BOX':
+        src['type'] = 'BOX'
+        src['geometry'] = {
+            'vertex': '%g %g %g' % (bb.XMin * SCALE, bb.YMin * SCALE, bb.ZMin * SCALE),
+            'edge_1': '%g 0 0' % (bb.XLength * SCALE),
+            'edge_2': '0 %g 0' % (bb.YLength * SCALE),
+            'edge_3': '0 0 %g' % (bb.ZLength * SCALE),
+        }
+        d = div or [
+            _div_from_size(bb.XLength * SCALE, mu_src),
+            _div_from_size(bb.YLength * SCALE, mu_src),
+            _div_from_size(bb.ZLength * SCALE, mu_src),
+        ]
+        src['division'] = {
+            'edge_1': {'number': d[0], 'type': 'UNIFORM'},
+            'edge_2': {'number': d[1], 'type': 'UNIFORM'},
+            'edge_3': {'number': d[2], 'type': 'UNIFORM'},
+        }
+    else:
+        # 判定できない形は外接直方体で近似する。
+        # 線源の分割点は幾何の中に収まればよく、遮蔽体ほど形状に厳密さを要さない。
+        src['type'] = 'BOX'
+        src['geometry'] = {
+            'vertex': '%g %g %g' % (bb.XMin * SCALE, bb.YMin * SCALE, bb.ZMin * SCALE),
+            'edge_1': '%g 0 0' % (bb.XLength * SCALE),
+            'edge_2': '0 %g 0' % (bb.YLength * SCALE),
+            'edge_3': '0 0 %g' % (bb.ZLength * SCALE),
+        }
+        d = div or [
+            _div_from_size(bb.XLength * SCALE, mu_src),
+            _div_from_size(bb.YLength * SCALE, mu_src),
+            _div_from_size(bb.ZLength * SCALE, mu_src),
+        ]
+        src['division'] = {
+            'edge_1': {'number': d[0], 'type': 'UNIFORM'},
+            'edge_2': {'number': d[1], 'type': 'UNIFORM'},
+            'edge_3': {'number': d[2], 'type': 'UNIFORM'},
+        }
+    return src
+
+
+def read_detector(obj):
+    # 検出器の形状からグリッドを決める。
+    #   球や小さな立体 -> 点検出器
+    #   薄い直方体     -> 2D グリッド（面線量マップ）
+    #   直方体         -> 3D グリッド（体積線量マップ）
+    #
+    # 従来は PokerGrid に "120 0 0 / 0 120 0 / 5 5" と書かせていたが、
+    # 書式を間違えやすく、CAD で形を見ながら決められない。形状から読めば
+    # 「この面の線量マップが欲しい」という意図がそのまま伝わる。
+    sh = obj.Shape
+    kind, geo = classify(sh)
+    bb = sh.BoundBox
+
+    det = {
+        'name': obj.Name,
+        'origin': _xyz(sh.CenterOfMass),
+        'show_path_trace': bool(getattr(obj, 'PokerShowPathTrace', False)),
+    }
+
+    # 分割数。"5 5" なら 2 方向、"5 5 5" なら 3 方向。
+    div_text = (getattr(obj, 'PokerDivision', None) or '').strip()
+    div = [int(x) for x in div_text.split()] if div_text else None
+
+    # 点検出器とみなす条件: 球、または十分小さい立体
+    if kind == 'SPH' or sh.Volume * (SCALE ** 3) < 1.0:
+        return det
+
+    if kind != 'BOX':
+        # グリッドは直方体でしか作れない。判定できない形は点として扱い、
+        # 重心を評価点にする（黙って外接箱にすると意図と違う点を評価する）。
+        return det
+
+    # 辺の長さで次元を決める。最も短い辺が他の 1/20 未満なら平板とみなす。
+    L = sorted([(bb.XLength, 0), (bb.YLength, 1), (bb.ZLength, 2)])
+    edges = [
+        ('%g 0 0' % (bb.XLength * SCALE), bb.XLength),
+        ('0 %g 0' % (bb.YLength * SCALE), bb.YLength),
+        ('0 0 %g' % (bb.ZLength * SCALE), bb.ZLength),
+    ]
+    thin = L[0][0] < L[2][0] / 20.0
+
+    if thin:
+        # 2D: 薄い方向を除く 2 辺
+        use = [k for _, k in L[1:]]
+        n = div or [5, 5]
+    else:
+        use = [0, 1, 2]
+        n = div or [5, 5, 5]
+
+    if len(n) < len(use):
+        raise SystemExit(
+            '検出器 %s の PokerDivision は %d 個の数が必要です（指定: %r）'
+            % (obj.Name, len(use), div_text))
+
+    # 原点はグリッドの隅（POKER の grid は origin から edge 方向に伸びる）
+    det['origin'] = '%g %g %g' % (bb.XMin * SCALE, bb.YMin * SCALE, bb.ZMin * SCALE)
+    det['grid'] = [{'edge': edges[k][0], 'number': n[i]} for i, k in enumerate(use)]
+    return det
+
+
+def build_yaml(doc, materials, sources, detectors, mfp_order=None, lib_density=None, buildup_equiv=None):
+    # materials: {材質名: 密度 or None}（CAD の PokerDensity）
+    # lib_density: {材質名: カタログ密度}（poker_lib から）
+    # mfp_order: [材質名, ...] mfp の大きい順。None なら材質名順。
+    lib_density = lib_density or {}
+    buildup_equiv = buildup_equiv or {}
+
+    # 分割点の総数（最大の線源）と、検出器の評価点の総数を数える
+    n_src_points = 1
+    for s_ in sources:
+        n = 1
+        for d_ in (s_.get('division') or {}).values():
+            n *= d_['number']
+        n_src_points = max(n_src_points, n)
+    n_det_points = 1
+    for d_ in detectors:
+        n = 1
+        for g in d_.get('grid', []):
+            n *= g['number']
+        n_det_points = max(n_det_points, n)
+
+    L = []
+    L.append('# このファイルは gen_input.py が CAD モデルから生成したものです。')
+    L.append('# 正本は CAD モデルです。形状を変えたら再生成してください。')
+    L.append('')
+    # サマリーの出力量。既定では分割点も評価点も間引かれるため、.paths の生成に
+    # 必要な全点が得られない。入力の実数に合わせて設定する。
+    L.append('thinnedindices:')
+    L.append('  sourcepoint: %d' % max(10, n_src_points))
+    L.append('  pseudosourcepoint: 10')
+    L.append('  detectorgrid: %d' % max(10, n_det_points))
+    L.append('  detectorevaluation: %d' % max(10, n_det_points))
+    L.append('  pathtrace: 5')
+    L.append('  buildupenergy: 3')
+    L.append('  buildupmfp: 3')
+    L.append('')
+    L.append('unit:')
+    L.append('  length: cm')
+    L.append('  angle: degree')
+    L.append('  density: g/cm3')
+    L.append('  radioactivity: Bq')
+    L.append('')
+
+    # --- body / zone ---
+    # --path-input で計算する場合、幾何は .paths から来るのでここの立体は
+    # 使われない。ただし POKER の入力規約上、ゾーンには実在する立体が要り、
+    # 密度もここから引かれるため、材質ごとにダミーを1つ置く。
+    L.append('# [ダミー] 以下の body / zone は --path-input では幾何として使われません。')
+    L.append('# 幾何は .paths から読み込まれます。ここに置くのは、POKER の入力規約上')
+    L.append('# ゾーンに実在する立体が必要なことと、材質の密度をここから引くためです。')
+    L.append('# 立体どうしが重ならないよう x 方向に並べてあります。')
+    L.append('body:')
+    names = mfp_order or sorted(materials)
+    for i, m in enumerate(names):
+        x = i * 10
+        L.append('  - name: REF_%s' % m)
+        L.append('    type: RPP')
+        L.append('    min: %d -1 -1' % x)
+        L.append('    max: %d 1 1' % (x + 1))
+    L.append('')
+    L.append('zone:')
+    L.append('  - body_name: ATMOSPHERE')
+    L.append('    material: VOID')
+    for m in names:
+        L.append('  - body_name: REF_%s' % m)
+        L.append('    material: %s' % m)
+        # 密度は省略できない。CAD で PokerDensity が指定されていればその値、
+        # 無ければ材料ライブラリのカタログ密度を書く。
+        d = materials.get(m)
+        if not d:
+            d = lib_density.get(m)
+        if d:
+            L.append('    density: %g' % d)
+    L.append('')
+    L.append('transform: []')
+    L.append('')
+
+    # --- buildup_factor ---
+    # POKER は並び順でビルドアップ材料を選ぶため、透過線上で最も効く材質
+    # (mfp 合計が大きい材質) を先頭に置く。
+    L.append('# 並び順で選択されるビルドアップ材料が変わります。')
+    if mfp_order:
+        L.append('# 全経路の mfp 合計が大きい順に並べてあります。')
+    L.append('buildup_factor:')
+    for m in names:
+        if m in ('VOID', 'Air'):
+            continue
+        # ビルドアップ係数データがある材質に読み替える。
+        #   lib_setting.dat の buildup_material に列挙された材質しか使えない。
+        #   SUS_A や Source_Dry のようなカスタム材料は、実効原子番号が近い
+        #   標準材料（SUS_A なら Iron）に読み替える。POKER 側も同じ表を見る。
+        bu = buildup_equiv.get(m, m)
+        L.append('  - material: %s' % bu)
+        if bu != m:
+            L.append('    # %s の等価材料として指定' % m)
+        L.append('    use_slant_correction: false')
+        L.append('    use_finite_medium_correction: false')
+    L.append('')
+
+    # --- source ---
+    L.append('source:')
+    for s in sources:
+        if s.get('scatter'):
+            # 散布線源: 点線源の集まりとして展開する。
+            #   汚染密度から各点の強度を決めてあるので、ここでは並べるだけ。
+            L.append('  # %s: %s（%d 点, 合計 %.4g Bq）'
+                     % (s['name'], s.get('kind', '散布'),
+                        len(s['points']), s.get('total_bq', 0.0)))
+            for k, (x, y, z, inv) in enumerate(s['points']):
+                L.append('  - name: %s_%04d' % (s['name'], k + 1))
+                L.append('    type: POINT')
+                L.append('    position: %g %g %g' % (x, y, z))
+                L.append('    inventory:')
+                for nu, bq in inv:
+                    L.append('      - nuclide: %s' % nu)
+                    L.append('        radioactivity: %g' % bq)
+                L.append('    cutoff_rate: %g' % s.get('cutoff_rate', 1e-4))
+            continue
+
+        L.append('  - name: %s' % s['name'])
+        L.append('    type: %s' % s['type'])
+        L.append('    inventory:')
+        for inv in s['inventory']:
+            L.append('      - nuclide: %s' % inv['nuclide'])
+            L.append('        radioactivity: %g' % inv['radioactivity'])
+        L.append('    cutoff_rate: %g' % s['cutoff_rate'])
+        if s['type'] == 'POINT':
+            L.append('    position: %s' % s['position'])
+        else:
+            L.append('    geometry:')
+            for k, v in s['geometry'].items():
+                L.append('      %s: %s' % (k, v))
+            L.append('    division:')
+            for ax, d in s['division'].items():
+                L.append('      %s:' % ax)
+                L.append('        number: %d' % d['number'])
+                L.append('        type: %s' % d['type'])
+    L.append('')
+
+    # --- detector ---
+    L.append('detector:')
+    for d in detectors:
+        L.append('  - name: %s' % d['name'])
+        L.append('    origin: %s' % d['origin'])
+        if 'grid' in d:
+            L.append('    grid:')
+            for g in d['grid']:
+                L.append('      - edge: %s' % g['edge'])
+                L.append('        number: %d' % g['number'])
+        L.append('    show_path_trace: %s' % ('true' if d['show_path_trace'] else 'false'))
+    L.append('')
+    return '\n'.join(L)
+
+
+def _nearest_buildup(mat, lib, avail):
+    # ビルドアップ係数データがある材質のうち、実効原子番号が最も近いものを返す。
+    #   SUS_A -> Iron、Source_Dry -> Tungsten のような読み替え。
+    #   POKER の等価材料テーブル(lib_equivalent.dat)があればそれを優先する。
+    try:
+        rho, comp = lib.materials[mat]
+    except Exception:
+        return None
+
+    def zeff(composition):
+        # 実効原子番号（光電効果の m=2.94 乗則）
+        num = den = 0.0
+        for z, w in composition.items():
+            num += w * (z ** 2.94)
+            den += w
+        return (num / den) ** (1.0 / 2.94) if den > 0 else 0.0
+
+    target = zeff(comp)
+    best, best_d = None, None
+    for cand in avail:
+        if cand in ('VOID', 'Air'):
+            continue
+        try:
+            _, c2 = lib.materials[cand]
+        except Exception:
+            continue
+        d = abs(zeff(c2) - target)
+        if best_d is None or d < best_d:
+            best, best_d = cand, d
+    return best
+
+
+def _source_mu(obj, lib, spec):
+    # 線源材質の線減弱係数。PokerMaterial が設定されていればその材質、
+    # 無ければ既定として Water を使う（多くの線源は水と同程度の減衰）。
+    #
+    # 参照エネルギーは spec.mu_energy、無ければ 0.662 MeV（Cs-137）。
+    # ここでは分割数を決めるだけなので、厳密なエネルギーは要らない。
+    mat = getattr(obj, 'PokerMaterial', None) or 'Water'
+    energy = float(spec.get('mu_energy', 0.6617))
+    try:
+        return lib.mu(mat, energy)
+    except Exception:
+        try:
+            return lib.mu('Water', energy)
+        except Exception:
+            return None
+
+
+def main(spec_path):
+    spec = json.load(open(spec_path, encoding='utf-8-sig'))
+    fcstd = spec['fcstd']
+    out = spec.get('out') or os.path.splitext(fcstd)[0] + '.yaml'
+
+    name = os.path.splitext(os.path.basename(fcstd))[0]
+    if name in App.listDocuments():
+        App.closeDocument(name)
+    doc = App.openDocument(fcstd)
+
+    # mfp 順は .paths 生成後にしか分からないので、spec で渡された場合のみ使う
+    # カタログ密度を読む。CAD 側の PokerDensity が無い材質に使う。
+    lib = poker_lib.PokerLib(spec.get('poker_dir', r'C:\Poker'))
+    lib_density = dict((m, v[0]) for m, v in lib.materials.items())
+
+    # 散布線源のピッチを決めるのに検出器の位置が要るので、先に集める。
+    #   点線源近似では線源片の大きさが検出器までの距離に対して十分小さい
+    #   必要があり、既定ピッチはその距離から決まる。
+    det_positions = []
+    for o in doc.Objects:
+        if (getattr(o, 'PokerRole', None) or '').strip().lower() != 'detector':
+            continue
+        sh = getattr(o, 'Shape', None)
+        if sh is None or sh.isNull():
+            continue
+        c = sh.CenterOfMass
+        det_positions.append((c.x, c.y, c.z))
+
+    warnings = []
+
+    materials, sources, detectors = {}, [], []
+    for o in doc.Objects:
+        sh = getattr(o, 'Shape', None)
+        if sh is None or sh.isNull() or not sh.Solids:
+            continue
+        r = role_of(o)
+        if r == 'source':
+            # 散布指定（体積汚染・表面汚染）があるか
+            #   PokerSourceType=volume、または PokerInner*/PokerOuter* が設定
+            #   されていれば、点線源の集まりとして展開する。
+            # 散布線源のオブジェクトが材質を持つなら遮蔽体としても登録する。
+            #   表面汚染した配管の管壁は、線源であると同時に遮蔽体でもある。
+            #   これを登録しないと管壁が透明になり、自己遮蔽が効かない。
+            m = getattr(o, 'PokerMaterial', None)
+            if m:
+                d = _num(getattr(o, 'PokerDensity', None))
+                if m not in materials or (d and not materials[m]):
+                    materials[m] = d
+
+            sc = scatter.build_scatter_sources(o, doc, SCALE, det_positions, warnings)
+            if sc:
+                for s in sc:
+                    s['scatter'] = True
+                    s['cutoff_rate'] = _num(getattr(o, 'PokerCutoff', None), 1e-4)
+                    s['kind'] = ('表面汚染' if s['name'].endswith(('_inner', '_outer'))
+                                 else '体積汚染')
+                    sources.append(s)
+            else:
+                sources.append(read_source(o, spec.get('nuclides'), _source_mu(o, lib, spec)))
+        elif r == 'detector':
+            detectors.append(read_detector(o))
+        else:
+            m = getattr(o, 'PokerMaterial', None)
+            if not m:
+                raise SystemExit(
+                    '遮蔽体 %s に PokerMaterial が設定されていません\n'
+                    '  材質を設定するか、PokerRole を source/detector にしてください'
+                    % o.Name)
+            d = _num(getattr(o, 'PokerDensity', None))
+            if m not in materials or (d and not materials[m]):
+                materials[m] = d
+
+    if not sources:
+        raise SystemExit('PokerRole=source のオブジェクトがありません')
+    if not detectors:
+        raise SystemExit('PokerRole=detector のオブジェクトがありません')
+
+
+    # ビルドアップ係数データがある材質への読み替え表を作る。
+    #   lib_setting.dat の buildup_material に無い材質（SUS_A, Source_Dry など）は
+    #   そのままでは POKER が受け付けない。実効原子番号が近い標準材料に読み替える。
+    #   spec.buildup_equivalent で明示指定もできる。
+    buildup_equiv = dict(spec.get('buildup_equivalent', {}))
+    try:
+        avail = set(lib.single)
+    except Exception:
+        avail = set()
+    for m in materials:
+        if m in buildup_equiv or m in avail or m in ('VOID', 'Air'):
+            continue
+        e = _nearest_buildup(m, lib, avail)
+        if e:
+            buildup_equiv[m] = e
+
+    text = build_yaml(doc, materials, sources, detectors,
+                      spec.get('mfp_order'), lib_density, buildup_equiv)
+    open(out, 'w', encoding='utf-8').write(text)
+
+    rep = {
+        'out': out,
+        'materials': sorted(materials),
+        'sources': [s['name'] for s in sources],
+        'detectors': [d['name'] for d in detectors],
+        'scatter_sources': [{'name': s['name'], 'points': len(s['points']),
+                            'total_bq': s['total_bq']}
+                           for s in sources if s.get('scatter')],
+        'warnings': warnings,
+    }
+    print(json.dumps(rep, ensure_ascii=False, indent=2))
+    return rep

package/tools/scatter.py

@@ -0,0 +1,474 @@
+# scatter.py -- 任意形状への点線源散布
+#
+# POKER の立体型（POINT / SPH / RCC / RPP / BOX）で表現できない形状を線源として
+# 扱う。形状の内部（または面上）に点線源を格子状に配置し、指定した汚染密度と
+# 矛盾しない強度を配分する。
+#
+# 用途:
+#   体積汚染  不定形の廃棄物、スラッジ、曲がった配管内の流体   Bq/cm3
+#   表面汚染  床の汚染、配管内面の付着、機器表面               Bq/cm2
+#
+# 決定論的な格子配置を使う。MCNP/PHITS は棄却法（乱数）で点を撒くが、点減衰核
+# では各点の強度を確定値として決める必要がある。乱数だと同じ入力で答えが変わり、
+# 収束解析ができない。
+
+import math
+
+
+# 点数がこれを超えたら警告する。止めはしない（利用者が意図している場合もある）。
+SCATTER_WARN_POINTS = 10000
+
+# ピッチの既定値を決めるときの基準。
+#   最も近い検出器までの距離の何分の1にするか。
+#   点線源近似では、線源の大きさが距離に対して十分小さい必要がある。
+#   1/10 なら立体角の誤差が 1% 程度に収まる。
+PITCH_DISTANCE_RATIO = 10.0
+
+
+def _bbox_grid(bb, pitch_mm):
+    # 外接直方体を pitch で刻んだ格子点（セル中心）を返す
+    nx = max(1, int(math.ceil(bb.XLength / pitch_mm)))
+    ny = max(1, int(math.ceil(bb.YLength / pitch_mm)))
+    nz = max(1, int(math.ceil(bb.ZLength / pitch_mm)))
+    dx, dy, dz = bb.XLength / nx, bb.YLength / ny, bb.ZLength / nz
+    for i in range(nx):
+        for j in range(ny):
+            for k in range(nz):
+                yield (bb.XMin + dx * (i + 0.5),
+                       bb.YMin + dy * (j + 0.5),
+                       bb.ZMin + dz * (k + 0.5))
+
+
+def scatter_volume(shape, pitch_mm, total_bq, scale):
+    """ソリッドの内部に点を散布する。
+
+    各点の強度は総放射能の等分。セルごとの内部体積を厳密に求めるには
+    ブーリアン演算が要り重いので、等分で済ませる。総量は Shape.Volume から
+    出すので必ず合う。縁のセルで位置がずれるのが誤差だが、ピッチを細かく
+    すれば小さくなる。
+
+    返り値: [(x, y, z, bq), ...]  座標は POKER 単位
+    """
+    import FreeCAD as App
+    bb = shape.BoundBox
+    pts = []
+    for (x, y, z) in _bbox_grid(bb, pitch_mm):
+        if shape.isInside(App.Vector(x, y, z), 1e-7, True):
+            pts.append((x, y, z))
+    if not pts:
+        return []
+    a = total_bq / len(pts)
+    return [(x * scale, y * scale, z * scale, a) for (x, y, z) in pts]
+
+
+def _cell_area(surf, ua, ub, va, vb):
+    # パラメータ空間のセルが面上で占める面積を、4隅から概算する
+    p00 = surf.value(ua, va)
+    p10 = surf.value(ub, va)
+    p01 = surf.value(ua, vb)
+    p11 = surf.value(ub, vb)
+    a1 = (p10 - p00).cross(p01 - p00).Length / 2.0
+    a2 = (p10 - p11).cross(p01 - p11).Length / 2.0
+    return a1 + a2
+
+
+def scatter_surface(face, pitch_mm, total_bq, scale):
+    """面の上に点を散布する。
+
+    パラメータ空間を等間隔に刻むが、面上で等間隔になるとは限らない。
+    実測では球面で セル面積が 4.23 倍ばらつく（極で潰れる）。等分すると
+    極付近に強度が集中するので、セル面積で重み付けする。
+
+    平面と円筒では重みが一様になるので、実務で多い床や配管では面積等分と
+    同じ結果になる。
+
+    返り値: [(x, y, z, bq), ...]
+    """
+    surf = face.Surface
+    u0, u1, v0, v1 = face.ParameterRange
+
+    # パラメータ空間の刻み数を決める。
+    #   u, v 方向それぞれが面上で何 mm に相当するかを、複数点で測って平均する。
+    #   1 本の線分で測ると、円筒の u（角度 0〜2π）や自由曲面で破綻する。
+    def span(fix_v):
+        # v を固定して u 方向の弧長を折れ線で概算
+        m, L = 8, 0.0
+        prev = surf.value(u0, fix_v)
+        for t in range(1, m + 1):
+            cur = surf.value(u0 + (u1 - u0) * t / m, fix_v)
+            L += (cur - prev).Length
+            prev = cur
+        return L
+
+    def span_v(fix_u):
+        m, L = 8, 0.0
+        prev = surf.value(fix_u, v0)
+        for t in range(1, m + 1):
+            cur = surf.value(fix_u, v0 + (v1 - v0) * t / m)
+            L += (cur - prev).Length
+            prev = cur
+        return L
+
+    # 3 箇所で測って平均（曲率が場所で変わる面に備える）
+    du = sum(span(v0 + (v1 - v0) * t) for t in (0.25, 0.5, 0.75)) / 3.0
+    dv = sum(span_v(u0 + (u1 - u0) * t) for t in (0.25, 0.5, 0.75)) / 3.0
+    nu = max(1, int(math.ceil(du / pitch_mm)))
+    nv = max(1, int(math.ceil(dv / pitch_mm)))
+
+    cells = []
+    for i in range(nu):
+        ua = u0 + (u1 - u0) * i / nu
+        ub = u0 + (u1 - u0) * (i + 1) / nu
+        uc = (ua + ub) / 2.0
+        for j in range(nv):
+            va = v0 + (v1 - v0) * j / nv
+            vb = v0 + (v1 - v0) * (j + 1) / nv
+            vc = (va + vb) / 2.0
+            # トリムされた面では、パラメータ範囲内でも面の外側があり得る
+            try:
+                if not face.isPartOfDomain(uc, vc):
+                    continue
+            except Exception:
+                pass
+            w = _cell_area(surf, ua, ub, va, vb)
+            if w <= 0:
+                continue
+            p = surf.value(uc, vc)
+            cells.append((p, w))
+
+    if not cells:
+        return []
+    wsum = sum(w for _, w in cells)
+    return [(p.x * scale, p.y * scale, p.z * scale, total_bq * w / wsum)
+            for (p, w) in cells]
+
+
+def default_pitch(shape, detectors_mm):
+    """ピッチの既定値。
+
+    最も近い検出器までの距離の 1/PITCH_DISTANCE_RATIO とする。点線源近似では
+    線源片の大きさが距離に対して十分小さい必要があり、1/10 なら立体角の誤差が
+    1% 程度に収まる。
+
+    ただし形状より粗くしても点が入らないので、形状の最短辺の 1/4 を上限とする
+    （最短辺に最低 4 点は入るようにする）。細長い配管では直径方向が支配する。
+
+    detectors_mm: [(x, y, z), ...]  CAD 単位(mm)の検出器位置
+    """
+    import FreeCAD as App
+    bb = shape.BoundBox
+    try:
+        c = shape.CenterOfMass
+    except AttributeError:
+        c = App.Vector(bb.XMin + bb.XLength / 2,
+                       bb.YMin + bb.YLength / 2,
+                       bb.ZMin + bb.ZLength / 2)
+
+    # 形状の最短辺から上限を決める。ゼロ厚（面）の方向は除く。
+    sides = [s for s in (bb.XLength, bb.YLength, bb.ZLength) if s > 1e-6]
+    cap = max(1.0, min(sides) / 4.0) if sides else 1.0
+
+    dmin = None
+    for (x, y, z) in (detectors_mm or []):
+        d = (App.Vector(x, y, z) - c).Length
+        if dmin is None or d < dmin:
+            dmin = d
+
+    if dmin is None or dmin <= 0:
+        return cap
+    return max(1.0, min(cap, dmin / PITCH_DISTANCE_RATIO))
+
+
+def clip_face(face, region_shape):
+    """面を領域立体で切り取る。
+
+    自由曲面の一部だけが汚染している場合、その範囲を面として作るのは GUI では
+    難しい。汚染範囲を単純な立体（直方体など）で囲めば、その共通部分として
+    切り出せる。MCNP のクッキーカッター（サンプリング領域を別セルで制限する
+    手法）と同じ考え方。
+
+    返り値: 切り取られた面のリスト。共通部分が無ければ空。
+    """
+    try:
+        cut = face.common(region_shape)
+    except Exception:
+        return []
+    return [f for f in cut.Faces if f.Area > 1e-9]
+
+
+def clip_solid(shape, region_shape):
+    """ソリッドを領域立体で切り取る。体積汚染の範囲指定に使う。"""
+    try:
+        cut = shape.common(region_shape)
+    except Exception:
+        return None
+    return cut if (cut.Solids and cut.Volume > 1e-9) else None
+
+
+def pick_faces(shape, which):
+    """ソリッドから汚染面を選ぶ。
+
+    which:
+      'inner'  内面（法線が重心を向く面）
+      'outer'  外面
+      'top'    上面（法線の Z 成分が正で最大）
+      'bottom' 下面
+      'all'    すべての面
+      数字     Face のインデックス（1 始まり）
+
+    内外の判定は、面の中心から法線方向に少し進んだ点がソリッドの内部かで見る。
+    """
+    import FreeCAD as App
+    faces = list(shape.Faces)
+    if not faces:
+        return []
+
+    w = (which or 'all').strip().lower()
+
+    if w.isdigit():
+        i = int(w) - 1
+        return [faces[i]] if 0 <= i < len(faces) else []
+
+    if w == 'all':
+        return faces
+
+    if w in ('top', 'bottom'):
+        sign = 1.0 if w == 'top' else -1.0
+        best, best_z = None, None
+        for f in faces:
+            try:
+                u0, u1, v0, v1 = f.ParameterRange
+                n = f.normalAt((u0 + u1) / 2, (v0 + v1) / 2)
+            except Exception:
+                continue
+            if n.z * sign < 0.7:      # ほぼ真上／真下を向く面だけ
+                continue
+            z = f.CenterOfMass.z * sign
+            if best_z is None or z > best_z:
+                best, best_z = f, z
+        return [best] if best else []
+
+    if w in ('inner', 'outer'):
+        # 管状の形状の内面／外面を分ける。
+        #
+        # 曲がった配管には直線の中心軸が無いので、軸からの距離では判定
+        # できない（実測で誤判定した）。法線の向きも使えない。OCC は各面の
+        # 表側が外部を向くよう向き付けするので、内面も外面も「法線の逆側が
+        # 形状の内部」で同じになる。
+        #
+        # 面から法線の逆方向にレイを飛ばし、形状と交わる回数で判定する。
+        #   外面から内向きに飛ばす -> 管壁を抜けて中空に出て、反対側の壁を
+        #                             通り、外へ抜ける
+        #   内面から内向き（＝中空側）に飛ばす -> すぐ中空で、反対側の壁だけ
+        # 交点の数が違うので分けられるが、接線方向で不安定になる。
+        #
+        # 実用上は「外面の方が広い」で足りる。同じ長さの管なら半径が大きい
+        # 分だけ外面が広く、曲がっていれば外側の曲率でさらに広がる。
+        # 端面は法線が隣接面の法線とほぼ直交するので、それで除く。
+        cand = []
+        for f in faces:
+            try:
+                u0, u1, v0, v1 = f.ParameterRange
+                uc, vc = (u0 + u1) / 2.0, (v0 + v1) / 2.0
+                f.normalAt(uc, vc)
+            except Exception:
+                continue
+            cand.append(f)
+        if len(cand) < 2:
+            return cand
+        # 面積の大きい2面を内外とみなす。端面は管壁より小さい。
+        cand.sort(key=lambda f: -f.Area)
+        big = cand[:2]
+        big.sort(key=lambda f: -f.Area)
+        return [big[0]] if w == 'outer' else [big[1]]
+
+    return faces
+
+
+
+# ---------------------------------------------------------------------------
+# CAD プロパティの読み取り
+# ---------------------------------------------------------------------------
+
+def parse_nuclide_values(text):
+    """'Cs137:1.0e6, Co60:2.0e5' -> [('Cs137', 1.0e6), ('Co60', 2.0e5)]
+
+    値の意味（濃度か総放射能か）は呼び出し側の文脈で決まる。
+    """
+    import re
+    out = []
+    for part in re.split(r'[,;]', text or ''):
+        part = part.strip()
+        if not part:
+            continue
+        m = re.match(r'^([A-Za-z]+[-_]?\d+m?)\s*[:=]\s*([\d.eE+-]+)$', part)
+        if not m:
+            raise SystemExit(
+                '核種の書式が不正です: %r\n'
+                '  例: "Cs137:1.0e6, Co60:2.0e5"' % part)
+        out.append((m.group(1).replace('-', '').replace('_', ''), float(m.group(2))))
+    return out
+
+
+def resolve_inventory(obj, amount, prefix=''):
+    """CAD のプロパティから核種と量を決める。
+
+    3 つの指定方法を許す:
+      (a) PokerNuclides = 'Cs137:1.0e6, Co60:2.0e5'
+          核種ごとの濃度（または総放射能）を直接指定
+      (b) PokerComposition = 'Cs137:5, Co60:1' と PokerConcentration = '1.0e6'
+          組成比と総量。比率の合計で正規化して配分する。
+          組成が既知で濃度だけ違う場合に使う
+      (c) PokerActivity = 'Co60:3.7e10'
+          総放射能を直接
+
+    amount: 濃度指定のときに掛ける量（体積 cm3 または面積 cm2）。
+            総放射能指定のときは使わない。
+    prefix: 面ごとに別の濃度を与える場合の接頭辞（'Inner' / 'Outer'）
+
+    返り値: [(核種, Bq), ...]
+    """
+    def get(name):
+        key = (prefix or 'Poker') + name
+        return (getattr(obj, key, None) or '').strip()
+
+    # (c) 総放射能
+    act = get('Activity')
+    if act:
+        return parse_nuclide_values(act)
+
+    # (b) 組成比 + 総濃度
+    comp = get('Composition')
+    conc = get('Concentration')
+    if comp and conc:
+        pairs = parse_nuclide_values(comp)
+        total_ratio = sum(v for _, v in pairs)
+        if total_ratio <= 0:
+            raise SystemExit('%s の組成比の合計が 0 です' % obj.Name)
+        try:
+            c = float(conc)
+        except ValueError:
+            raise SystemExit('%s の濃度が数値ではありません: %r' % (obj.Name, conc))
+        return [(n, c * amount * v / total_ratio) for n, v in pairs]
+
+    # (a) 核種ごとの濃度
+    nuc = get('Nuclides')
+    if nuc:
+        pairs = parse_nuclide_values(nuc)
+        return [(n, v * amount) for n, v in pairs]
+
+    return []
+
+
+
+def find_region(obj, doc):
+    """この線源の汚染範囲を制限する立体を探す。
+
+    別オブジェクトに PokerRegionFor でこの線源を指させる。
+    App::PropertyLink を使うので、オブジェクト名を変えてもリンクは保たれる
+    （名前の一致に頼ると壊れる）。
+    """
+    for o in doc.Objects:
+        tgt = getattr(o, 'PokerRegionFor', None)
+        if tgt is None:
+            continue
+        # リンクなら Object そのもの、文字列なら名前で比較
+        name = getattr(tgt, 'Name', None) or str(tgt)
+        if name == obj.Name:
+            sh = getattr(o, 'Shape', None)
+            if sh is not None and not sh.isNull():
+                return sh
+    return None
+
+
+def build_scatter_sources(obj, doc, scale, detectors_mm, warn):
+    """CAD オブジェクトから散布線源を作る。
+
+    返り値: [{'name':..., 'points':[(x,y,z,{核種:Bq}), ...]}, ...]
+            線源の種類ごとに 1 つ（体積／内面／外面）
+
+    warn: 警告を受け取るリスト
+    """
+    sh = obj.Shape
+    region = find_region(obj, doc)
+    pitch = _num(getattr(obj, 'PokerPointSpacing', None)) or default_pitch(sh, detectors_mm)
+
+    out = []
+
+    # --- 体積汚染 ---
+    vol_spec = (getattr(obj, 'PokerNuclides', None) or
+                getattr(obj, 'PokerComposition', None) or
+                getattr(obj, 'PokerActivity', None))
+    stype = (getattr(obj, 'PokerSourceType', None) or '').strip().lower()
+    if stype == 'volume' and vol_spec:
+        target = clip_solid(sh, region) if region is not None else sh
+        if target is None:
+            warn.append('%s: 領域との共通部分がありません' % obj.Name)
+        else:
+            vol_cm3 = target.Volume * (scale ** 3)
+            inv = resolve_inventory(obj, vol_cm3)
+            if inv:
+                total = sum(a for _, a in inv)
+                pts = scatter_volume(target, pitch, total, scale)
+                if pts:
+                    out.append(_mk(obj.Name, pts, inv, total))
+                else:
+                    warn.append('%s: 点が 1 つも入りませんでした（ピッチ %.1f mm）'
+                                % (obj.Name, pitch))
+
+    # --- 表面汚染（内面・外面を別々に）---
+    for side, prefix in (('inner', 'PokerInner'), ('outer', 'PokerOuter')):
+        spec = (getattr(obj, prefix + 'Nuclides', None) or
+                getattr(obj, prefix + 'Composition', None) or
+                getattr(obj, prefix + 'Activity', None))
+        if not spec:
+            continue
+        faces = pick_faces(sh, side)
+        if region is not None:
+            clipped = []
+            for f in faces:
+                clipped += clip_face(f, region)
+            faces = clipped
+        if not faces:
+            warn.append('%s: %s 面が見つかりません' % (obj.Name, side))
+            continue
+        area_cm2 = sum(f.Area for f in faces) * (scale ** 2)
+        inv = resolve_inventory(obj, area_cm2, prefix=prefix)
+        if not inv:
+            continue
+        total = sum(a for _, a in inv)
+        pts = []
+        for f in faces:
+            a = f.Area * (scale ** 2)
+            pts += scatter_surface(f, pitch, total * a / area_cm2, scale)
+        if pts:
+            out.append(_mk('%s_%s' % (obj.Name, side), pts, inv, total))
+        else:
+            warn.append('%s: %s 面に点が入りませんでした' % (obj.Name, side))
+
+    # 点数の警告
+    n = sum(len(s['points']) for s in out)
+    if n > SCATTER_WARN_POINTS:
+        warn.append('%s: 点線源が %d 個になります（ピッチ %.1f mm）。'
+                    '計算時間が長くなるので PokerPointSpacing での調整を検討してください'
+                    % (obj.Name, n, pitch))
+    return out
+
+
+def _mk(name, pts, inv, total):
+    """散布点を線源の形にする。核種の比率は全点で同じ。"""
+    ratio = [(nu, a / total) for nu, a in inv] if total > 0 else []
+    return {
+        'name': name,
+        'pitch_points': len(pts),
+        'total_bq': total,
+        'points': [(x, y, z, [(nu, bq * r) for nu, r in ratio])
+                   for (x, y, z, bq) in pts],
+    }
+
+
+def _num(v):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None