abmptools 2.1.0__tar.gz → 2.2.0__tar.gz

{abmptools-2.1.0/abmptools.egg-info → abmptools-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abmptools
-Version: 2.1.0
+Version: 2.2.0
 Summary: Pre/post-processing and analysis toolkit for ABINIT-MP Fragment Molecular Orbital calculations
 Author-email: Koji Okuwaki <koujioku81@gmail.com>
 License-Expression: Apache-2.0
@@ -59,6 +59,18 @@ Provides-Extra: formulation-analysis
 Requires-Dist: MDAnalysis<3.0,>=2.6; extra == "formulation-analysis"
 Requires-Dist: networkx>=3.0; extra == "formulation-analysis"
 Requires-Dist: matplotlib>=3.5; extra == "formulation-analysis"
+Provides-Extra: formulation-openff
+Requires-Dist: openff-toolkit>=0.14.0; extra == "formulation-openff"
+Requires-Dist: openff-interchange>=0.3.0; extra == "formulation-openff"
+Requires-Dist: openff-amber-ff-ports>=0.0.3; extra == "formulation-openff"
+Requires-Dist: openff-nagl>=0.3; extra == "formulation-openff"
+Requires-Dist: openff-nagl-models>=0.1; extra == "formulation-openff"
+Requires-Dist: openmm>=8.0; extra == "formulation-openff"
+Requires-Dist: pdbfixer>=1.9; extra == "formulation-openff"
+Requires-Dist: rdkit-pypi>=2022.09; extra == "formulation-openff"
+Requires-Dist: matplotlib>=3.5; extra == "formulation-openff"
+Requires-Dist: PeptideBuilder>=1.1; extra == "formulation-openff"
+Requires-Dist: biopython>=1.79; extra == "formulation-openff"
 Provides-Extra: geomopt
 Requires-Dist: pyscf; extra == "geomopt"
 Requires-Dist: ase; extra == "geomopt"
@@ -109,6 +121,7 @@ A Python toolkit for pre-processing, post-processing, and analysis of Fragment M
 
 - **udf2gro**: Convert OCTA UDF files to GROMACS format (`.gro`, `.top`, `.mdp`, `.itp`)
 - **gro2udf**: Convert GROMACS files to OCTA UDF format (supports `--from-top` mode)
+- **udfcharge**: Transfer per-atom partial charges from a single-molecule UDF to every same-named molecule in a bulk UDF
 
 ### Geometry Optimization (`geomopt`)
 
@@ -300,6 +313,9 @@ python -m abmptools.udf2gro.cli -i system.udf -o output
 # Convert GROMACS to UDF
 python -m abmptools.gro2udf.cli -i system.gro -t system.top -o output.udf
 
+# Transfer charges from a single-molecule UDF to all same-named molecules in a bulk UDF
+python -m abmptools.udfcharge --template mol.udf --bulk bulk.udf --out bulk_charged.udf
+
 # Build an amorphous mixture from SMILES (50 ketoprofen molecules, density 0.8 g/cm^3)
 python -m abmptools.amorphous --smiles "OC(=O)C(C)c1cccc(C(=O)c2ccccc2)c1" \
     --name ketoprofen --n_mol 50 --density 0.8 --output_dir ./ketoprofen
@@ -349,6 +365,7 @@ Use `-h` with any module for full option details.
 - **[Developer Quickstart](docs/dev_quickstart.md)** — Setup and code conventions
 - **[I/O Spec](docs/io_spec.md)** — File format specifications
 - **[gro2udf](docs/gro2udf.md)** / **[udf2gro](docs/udf2gro.md)** — GROMACS ↔ OCTA conversion
+- **[udfcharge](docs/udfcharge.md)** / **[tutorial_udfcharge](docs/tutorial_udfcharge.md)** — single-molecule → bulk UDF charge transfer
 - **[geomopt](docs/geomopt.md)** / **[amorphous](docs/amorphous.md)** — Optimization and structure building
 - **[membrane](docs/membrane.md)** / **[tutorial_membrane_us](docs/tutorial_membrane_us.md)** — Peptide-bilayer umbrella-sampling PMF (AA, CHARMM36 / Lipid21)
 - **[cg_membrane](docs/cg_membrane.md)** / **[tutorial_cg_membrane_us](docs/tutorial_cg_membrane_us.md)** — Martini 3 peptide-bilayer PMF (CG, 30-100× faster than AA, KGG-POPC smoke 5 min / production 45 min)

{abmptools-2.1.0 → abmptools-2.2.0}/README.md

@@ -37,6 +37,7 @@ A Python toolkit for pre-processing, post-processing, and analysis of Fragment M
 
 - **udf2gro**: Convert OCTA UDF files to GROMACS format (`.gro`, `.top`, `.mdp`, `.itp`)
 - **gro2udf**: Convert GROMACS files to OCTA UDF format (supports `--from-top` mode)
+- **udfcharge**: Transfer per-atom partial charges from a single-molecule UDF to every same-named molecule in a bulk UDF
 
 ### Geometry Optimization (`geomopt`)
 
@@ -228,6 +229,9 @@ python -m abmptools.udf2gro.cli -i system.udf -o output
 # Convert GROMACS to UDF
 python -m abmptools.gro2udf.cli -i system.gro -t system.top -o output.udf
 
+# Transfer charges from a single-molecule UDF to all same-named molecules in a bulk UDF
+python -m abmptools.udfcharge --template mol.udf --bulk bulk.udf --out bulk_charged.udf
+
 # Build an amorphous mixture from SMILES (50 ketoprofen molecules, density 0.8 g/cm^3)
 python -m abmptools.amorphous --smiles "OC(=O)C(C)c1cccc(C(=O)c2ccccc2)c1" \
     --name ketoprofen --n_mol 50 --density 0.8 --output_dir ./ketoprofen
@@ -277,6 +281,7 @@ Use `-h` with any module for full option details.
 - **[Developer Quickstart](docs/dev_quickstart.md)** — Setup and code conventions
 - **[I/O Spec](docs/io_spec.md)** — File format specifications
 - **[gro2udf](docs/gro2udf.md)** / **[udf2gro](docs/udf2gro.md)** — GROMACS ↔ OCTA conversion
+- **[udfcharge](docs/udfcharge.md)** / **[tutorial_udfcharge](docs/tutorial_udfcharge.md)** — single-molecule → bulk UDF charge transfer
 - **[geomopt](docs/geomopt.md)** / **[amorphous](docs/amorphous.md)** — Optimization and structure building
 - **[membrane](docs/membrane.md)** / **[tutorial_membrane_us](docs/tutorial_membrane_us.md)** — Peptide-bilayer umbrella-sampling PMF (AA, CHARMM36 / Lipid21)
 - **[cg_membrane](docs/cg_membrane.md)** / **[tutorial_cg_membrane_us](docs/tutorial_cg_membrane_us.md)** — Martini 3 peptide-bilayer PMF (CG, 30-100× faster than AA, KGG-POPC smoke 5 min / production 45 min)

{abmptools-2.1.0 → abmptools-2.2.0}/abmptools/amorphous/molecule_prep.py

@@ -217,8 +217,15 @@ def _maybe_assign_partial_charges(mol: Any, method: str, nagl_model: str) -> Non
     if not method or method == "am1bcc":
         return
     if method == "nagl":
+        # NAGLToolkitWrapper は global toolkit registry に自動登録されないため
+        # 明示的に渡す (openff-nagl が登録済みか否かに依らず動く)。 これが
+        # ML-AM1-BCC 電荷を sqm / AmberTools 無し = Windows native で得る肝。
         try:
-            mol.assign_partial_charges(partial_charge_method=nagl_model)
+            from openff.toolkit.utils.nagl_wrapper import NAGLToolkitWrapper
+            mol.assign_partial_charges(
+                partial_charge_method=nagl_model,
+                toolkit_registry=NAGLToolkitWrapper(),
+            )
         except Exception as e:
             raise RuntimeError(
                 f"Failed to assign NAGL charges using model '{nagl_model}'. "

{abmptools-2.1.0 → abmptools-2.2.0}/abmptools/cg/dpd/__init__.py

@@ -37,6 +37,8 @@ from .dpm_writer import (
     DEFAULT_PATCH_FIELDS, MESSAGE_TXT_CONTENT,
 )
 from .udf_writer import write_dpd_udf
+from .udf_writer_udfm import write_dpd_udf_udfm
+from .aij_assign import assign_aij_to_udf, match_aij_to_pairs, build_a_lookup
 from .orchestrator import CGDpdBuilder
 
 
@@ -54,7 +56,8 @@ __all__ = [
     "read_calc_sett",
     "patch_dpm", "propagate_virtual_mom", "write_message_txt",
     "DEFAULT_PATCH_FIELDS", "MESSAGE_TXT_CONTENT",
-    "write_dpd_udf",
+    "write_dpd_udf", "write_dpd_udf_udfm",
+    "assign_aij_to_udf", "match_aij_to_pairs", "build_a_lookup",
     "CGDpdBuilder",
     "open_panel",
 ]

{abmptools-2.1.0 → abmptools-2.2.0}/abmptools/cg/dpd/__main__.py

@@ -108,6 +108,21 @@ def main(argv=None) -> int:
                     help="comma-separated segment 名 (single monomer 時、 例 'segA,segB,WAT')")
     p1.add_argument("--project-name", default="abmptools-cg-dpd")
 
+    # assign-aij: 既存 UDF の Pair_Interaction.DPD.a を aij.dat で割り当て
+    pa = sub.add_parser(
+        "assign-aij",
+        help="既存 cognac DPD UDF の Interactions.Pair_Interaction[].DPD.a を "
+             "aij.dat で割り当て (粒子名で順不同照合)",
+    )
+    pa.add_argument("--udf", required=True, help="既存 cognac DPD UDF")
+    pa.add_argument("--aij", required=True, help="aij.dat (mode='a' 直値 or 'chi')")
+    pa.add_argument("--aii", type=float, default=25.0,
+                    help="chi モード変換の基準同種 a (a=aii+χ/0.306、default 25.0)")
+    pa.add_argument("--output", default=None,
+                    help="出力 UDF (省略時は --udf を上書き)")
+    pa.add_argument("--all-types", action="store_true",
+                    help="DPD 以外の Pair_Interaction も対象にする (default は DPD のみ)")
+
     args = parser.parse_args(argv)
 
     if args.cmd == "verify":
@@ -142,6 +157,21 @@ def main(argv=None) -> int:
         print(f"udf: {out}")
         return 0
 
+    if args.cmd == "assign-aij":
+        from .aij_assign import assign_aij_to_udf
+        result = assign_aij_to_udf(
+            args.udf, args.aij, out_path=args.output, aii=args.aii,
+            only_dpd=not args.all_types,
+        )
+        print(f"assigned: {len(result['assigned'])}/{result['total_pairs']} "
+              f"pair(s) -> {result['out_path']}")
+        if result["unmatched"]:
+            print(f"  unmatched (aij.dat に無し): "
+                  f"{[(s1, s2) for _, s1, s2 in result['unmatched']]}")
+        if result["unused_aij_pairs"]:
+            print(f"  unused aij pairs (UDF に無し): {result['unused_aij_pairs']}")
+        return 0
+
     return 1
 
 

abmptools-2.2.0/abmptools/cg/dpd/aij_assign.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""
+abmptools.cg.dpd.aij_assign
+---------------------------
+**既存の Cognac DPD 入力 UDF** の相互作用パラメータ a を、aij.dat の内容で
+割り当て直す (build-udf のように新規生成するのではなく、既存 UDF をパッチする)。
+
+割り当て規則:
+    - aij.dat が `aij` モード … 値をそのまま a に入れる
+    - aij.dat が `chi` モード … `a = aii + chi / 0.306` (= aii + 3.268·χ、
+      Groot-Warren。`AijMatrix.to_a_values()` が実施)。`aii` は基準同種 a (引数)
+
+照合:
+    UDF の `Interactions.Pair_Interaction[]` 各エントリの `Site1_Name` /
+    `Site2_Name` (= 粒子名ペア) を読み、aij.dat のペアと **順不同で照合**して
+    `Interactions.Pair_Interaction[].DPD.a` を書き換える。
+
+挿入パス (Cognac 標準。dpdgen `udfdpd_io` と同じ):
+    Interactions.Pair_Interaction[N].Site1_Name / Site2_Name / Potential_Type
+    Interactions.Pair_Interaction[N].DPD.a          ← ここに a を put
+
+I/O は `UDFManager` round-trip (OCTA 同梱、`abmptools.udfcharge` と同方式)。
+`UDFManager.put` は numpy 値をサイレントに 0 化するため **`float()` cast 必須**
+(`reference_udfmanager_put_numpy_silent_zero`)。
+
+照合・変換ロジック (`build_a_lookup` / `match_aij_to_pairs`) は UDFManager 非依存で
+単体テスト可能。`assign_aij_to_udf` のみ UDFManager を lazy import する。
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from .models import AijMatrix
+
+logger = logging.getLogger(__name__)
+
+_PI = "Interactions.Pair_Interaction[]"
+
+
+def _pair_key(a: str, b: str) -> frozenset:
+    """順不同のペアキー (同種 a==b は 1 要素 frozenset)。"""
+    return frozenset((a, b))
+
+
+def build_a_lookup(aij: AijMatrix) -> Dict[frozenset, float]:
+    """AijMatrix → 順不同ペアキー dict ``{frozenset({i, j}): a}``。
+
+    chi モードは ``to_a_values()`` で a に変換済みの値が入る。
+    """
+    lut: Dict[frozenset, float] = {}
+    for i, j, a in aij.to_a_values():
+        lut[_pair_key(i, j)] = float(a)
+    return lut
+
+
+def match_aij_to_pairs(
+    udf_pairs: List[Tuple[int, str, str]],
+    aij: AijMatrix,
+) -> Tuple[List[Tuple[int, float]], List[Tuple[int, str, str]]]:
+    """UDF の Pair_Interaction ペアと aij を照合し、割当値と未照合を返す。
+
+    Parameters
+    ----------
+    udf_pairs
+        ``(pair_index, site1_name, site2_name)`` のリスト (UDF から読んだ順)。
+    aij
+        aij.dat 由来の AijMatrix。
+
+    Returns
+    -------
+    (assignments, unmatched)
+        assignments : ``(pair_index, a_value)`` のリスト (aij.dat に該当あり)
+        unmatched   : ``(pair_index, site1, site2)`` のリスト (aij.dat に無し)
+    """
+    lut = build_a_lookup(aij)
+    assignments: List[Tuple[int, float]] = []
+    unmatched: List[Tuple[int, str, str]] = []
+    for idx, s1, s2 in udf_pairs:
+        key = _pair_key(s1, s2)
+        if key in lut:
+            assignments.append((idx, lut[key]))
+        else:
+            unmatched.append((idx, s1, s2))
+    return assignments, unmatched
+
+
+def assign_aij_to_udf(
+    udf_path: Union[str, Path],
+    aij: Union[AijMatrix, str, Path],
+    out_path: Optional[Union[str, Path]] = None,
+    aii: float = 25.0,
+    only_dpd: bool = True,
+    record: int = -1,
+) -> Dict[str, Any]:
+    """既存 Cognac DPD UDF の Pair_Interaction の a を aij で割り当てる。
+
+    Parameters
+    ----------
+    udf_path
+        既存 DPD 入力 UDF (Cognac、`Interactions.Pair_Interaction[]` を持つ)。
+    aij
+        `AijMatrix` か、aij.dat のパス (パスなら `read_aij(path, aii)` で読む)。
+    out_path
+        出力先。None なら ``udf_path`` を上書き。
+    aii
+        chi モード変換の基準同種 a (aij がパスのときのみ使用)。
+    only_dpd
+        True なら `Potential_Type == "DPD"` のペアのみ対象。
+    record
+        UDFManager の jump 先レコード (default -1 = static/最終)。
+
+    Returns
+    -------
+    dict
+        {assigned, unmatched, total_pairs, out_path, unused_aij_pairs}
+    """
+    from UDFManager import UDFManager  # OCTA 同梱 (PyPI 非配布)
+
+    if not isinstance(aij, AijMatrix):
+        from .aij_io import read_aij
+        aij = read_aij(aij, aii=aii)
+
+    u = UDFManager(str(udf_path))
+    u.jump(record)
+
+    n = int(u.size(_PI) or 0)
+    udf_pairs: List[Tuple[int, str, str]] = []
+    skipped_non_dpd = 0
+    for k in range(n):
+        ptype = u.get(f"{_PI}.Potential_Type", [k])
+        if only_dpd and ptype != "DPD":
+            skipped_non_dpd += 1
+            continue
+        s1 = u.get(f"{_PI}.Site1_Name", [k])
+        s2 = u.get(f"{_PI}.Site2_Name", [k])
+        udf_pairs.append((k, str(s1), str(s2)))
+
+    assignments, unmatched = match_aij_to_pairs(udf_pairs, aij)
+
+    for idx, a in assignments:
+        u.put(float(a), f"{_PI}.DPD.a", [idx])  # float() cast 必須 (numpy silent-0)
+
+    out = Path(out_path) if out_path else Path(udf_path)
+    u.write(str(out))
+
+    # aij.dat 側で UDF に使われなかったペア (情報提供用)
+    udf_keys = {_pair_key(s1, s2) for _, s1, s2 in udf_pairs}
+    unused = [
+        (i, j) for (i, j, _a) in aij.to_a_values()
+        if _pair_key(i, j) not in udf_keys
+    ]
+
+    logger.info(
+        "assign_aij_to_udf: %d/%d pair(s) assigned, %d unmatched, "
+        "%d non-DPD skipped -> %s",
+        len(assignments), len(udf_pairs), len(unmatched), skipped_non_dpd, out,
+    )
+    if unmatched:
+        logger.warning(
+            "aij.dat に無く未割当のペア (UDF 側): %s",
+            [(s1, s2) for _, s1, s2 in unmatched],
+        )
+
+    return {
+        "assigned": assignments,
+        "unmatched": unmatched,
+        "total_pairs": len(udf_pairs),
+        "skipped_non_dpd": skipped_non_dpd,
+        "unused_aij_pairs": unused,
+        "out_path": str(out),
+    }

{abmptools-2.1.0 → abmptools-2.2.0}/abmptools/cg/dpd/orchestrator.py

@@ -26,6 +26,7 @@ from .dpm_writer import (
 from .models import AijMatrix, CalcSett, DpdSystemSpec, MonomerSpec
 from .monomer_io import assign_particle_names, read_monomer
 from .udf_writer import write_dpd_udf
+from .udf_writer_udfm import write_dpd_udf_udfm
 
 logger = logging.getLogger(__name__)
 
@@ -251,7 +252,11 @@ class CGDpdBuilder:
         *,
         include_file: str = "cognac112.udf",
     ) -> Path:
-        """**R1**: Cognac DPD 入力 UDF (skeleton) を plain text で出力。
+        """**R1**: Cognac DPD 入力 UDF を **UDFManager** で出力 (cognac112 スキーマ準拠)。
+
+        named-path put で組み立てるため cognac でロード可能な UDF になる。
+        ``UDFManager`` (OCTA 同梱) が必須 (`include_file` の cognac クラス定義も
+        UDFManager が解決できる場所に必要)。
 
         Parameters
         ----------
@@ -261,4 +266,4 @@ class CGDpdBuilder:
             冒頭 ``\\include`` で参照する Cognac class 定義 file (default
             ``"cognac112.udf"``、 J-OCTA 11.x 同梱)。
         """
-        return write_dpd_udf(self.spec, output_path, include_file=include_file)
+        return write_dpd_udf_udfm(self.spec, output_path, include_file=include_file)

{abmptools-2.1.0 → abmptools-2.2.0}/abmptools/cg/dpd/udf_writer.py

@@ -2,10 +2,18 @@
 """
 abmptools.cg.dpd.udf_writer
 ---------------------------
-**Route R1**: Cognac DPD 入力 UDF (``*_uin.udf``) を **plain text で直接書き出す**。
-
-設計指針
-~~~~~~~~
+**[DEPRECATED / 非使用]** Route R1 の旧 plain-text writer。
+
+.. warning::
+   この writer の出力は **cognac112 スキーマ非準拠で UDFManager にロードできない**
+   (``Pair_Interaction`` を ``Molecular_Attributes`` 配下に positional で書く /
+   ``Interaction_Site_Type[]`` 未定義)。2026-06-22 に判明し、現行 R1 は
+   :mod:`abmptools.cg.dpd.udf_writer_udfm` (UDFManager named-path、cognac112 準拠)
+   に置き換え済み。``CGDpdBuilder.build_udf`` / CLI ``build-udf`` はそちらを使う。
+   本モジュールは参照用に残置 (新規利用不可)。
+
+設計指針 (旧)
+~~~~~~~~~~~~~
 - ``\\include{"cognac112.udf"}`` 1 行で class 定義を J-OCTA install 環境に委譲
   (abmptools 側に OCTA spec を持たない、 権利配慮)
 - UDFManager (OCTA) **に依存しない** plain text writer

abmptools-2.2.0/abmptools/cg/dpd/udf_writer_udfm.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+"""
+abmptools.cg.dpd.udf_writer_udfm
+--------------------------------
+**UDFManager ベース** の Cognac DPD 入力 UDF writer。
+
+旧 ``udf_writer.py`` は positional plain-text で UDF を手書きしていたが、
+Pair_Interaction (14 union サブフィールドを持つ class) を positional で書く方式は
+脆く、生成 UDF が **cognac112 スキーマに非準拠で UDFManager ロード不可** だった
+(Pair_Interaction を `Molecular_Attributes` 配下に置く / `Interaction_Site_Type[]`
+未定義、等)。
+
+本モジュールは dpdgen `udfdpd_io` と同じく **UDFManager の named-path put** で
+組み立てるため、cognac112 スキーマ準拠が保証される (= 実際に cognac でロード可能)。
+
+正しい配置 (cognac112.udf スキーマ準拠):
+    Molecular_Attributes.Atom_Type[].Name / Mass
+    Molecular_Attributes.Interaction_Site_Type[].Name / Num_of_Atoms / Range
+    Molecular_Attributes.Bond_Potential[].Name / Potential_Type / R0 / Harmonic.K
+    Molecular_Attributes.Angle_Potential[].Name / Potential_Type / theta0 / Theta.K
+    Interactions.Pair_Interaction[].Name / Potential_Type / Site1_Name / Site2_Name
+                                   / Cutoff / Scale_1_4_Pair / DPD.a / DPD.gamma
+    Set_of_Molecules.molecule[].Mol_Name / atom[] / bond[] / angle[] / interaction_Site[]
+
+``UDFManager`` は OCTA 同梱 (PyPI 非配布) で **lazy import**。`put` は numpy 値を
+サイレント 0 化するため全数値 `float()`/`int()` cast 済 (`reference_udfmanager_
+put_numpy_silent_zero`)。
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Tuple, Union
+
+from .models import DpdSystemSpec
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INCLUDE = "cognac112.udf"
+_MA = "Molecular_Attributes"
+_PI = "Interactions.Pair_Interaction"
+_SM = "Set_of_Molecules.molecule"
+# cognac90 互換 calc flag [Bond, Angle, Torsion, Non_Bonding, ?, Non_Bonding_1_3, ...]
+_CALC_FLAGS = [1, 1, 0, 1, 1, 0, 1, 0, 0, 0]
+_DPD_GAMMA = 4.5
+
+
+def _skeleton(include_file: str, project_name: str, comment: str) -> str:
+    """UDFManager が開ける最小 UDF (──include + header + 空 data)。"""
+    return (
+        f'\\include{{"{include_file}"}}\n'
+        "\\begin{header}\n\\begin{data}\n"
+        'EngineType:"COGNAC"\n'
+        'EngineVersion:"Ver112"\n'
+        'IOType:"IN"\n'
+        f'ProjectName:"{project_name}"\n'
+        f'Comment:"{comment}"\n'
+        'Action:""\n'
+        "\\end{data}\n\\end{header}\n"
+        "\\begin{data}\n\\end{data}\n"
+    )
+
+
+def write_dpd_udf_udfm(
+    spec: DpdSystemSpec,
+    output_path: Union[str, Path],
+    *,
+    include_file: str = DEFAULT_INCLUDE,
+) -> Path:
+    """DpdSystemSpec から cognac DPD 入力 UDF を UDFManager で書き出す。
+
+    Returns
+    -------
+    Path
+        出力 UDF path。
+    """
+    from UDFManager import UDFManager  # OCTA 同梱 (PyPI 非配布)
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(
+        _skeleton(include_file, spec.project_name, spec.comment), encoding="utf-8"
+    )
+
+    u = UDFManager(str(output_path))
+
+    _put_simulation_conditions(u, spec)
+    _put_structure(u, spec)
+    _put_molecular_attributes(u, spec)
+    _put_interactions(u, spec)
+    _put_set_of_molecules(u, spec)
+
+    u.write(str(output_path))
+    logger.info(
+        "write_dpd_udf_udfm: %s (%d segment(s), %d monomer(s), %d pair(s))",
+        output_path, len(spec.segment_names()), len(spec.monomers),
+        len(spec.aij.to_a_values()),
+    )
+    return output_path
+
+
+def _box(spec: DpdSystemSpec) -> float:
+    calc = spec.calc_sett
+    if calc and calc.box_size:
+        return float(calc.box_size[0])
+    return 10.0
+
+
+def _put_simulation_conditions(u, spec: DpdSystemSpec) -> None:
+    calc = spec.calc_sett
+    dt = float(calc.dt) if calc else 0.05
+    steps = int(calc.step_list[0]) if calc and calc.step_list else 10000
+    out_interval = int(calc.output_interval) if calc else 100
+    lam = float(calc.phys_param.get("lambda", 0.65)) if calc and calc.phys_param else 0.65
+
+    u.put("DPD", "Simulation_Conditions.Solver.Dynamics.Dynamics_Algorithm")
+    u.put(0.65 if lam is None else lam, "Simulation_Conditions.Solver.Dynamics.DPD.lambda")
+    u.put(1.0e12, "Simulation_Conditions.Dynamics_Conditions.Max_Force")
+    u.put(dt, "Simulation_Conditions.Dynamics_Conditions.Time.delta_T")
+    u.put(steps, "Simulation_Conditions.Dynamics_Conditions.Time.Total_Steps")
+    u.put(out_interval, "Simulation_Conditions.Dynamics_Conditions.Time.Output_Interval_Steps")
+    u.put(1.0, "Simulation_Conditions.Dynamics_Conditions.Temperature.Temperature")
+    u.put(1.0, "Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Pressure")
+
+    # calc flags (cognac112: Non_Bonding は Interchain / Intrachain に分割)
+    cf = "Simulation_Conditions.Calc_Potential_Flags"
+    u.put(1, f"{cf}.Bond")
+    u.put(1, f"{cf}.Angle")
+    u.put(0, f"{cf}.Torsion")
+    u.put(1, f"{cf}.Non_Bonding_Interchain")
+    u.put(1, f"{cf}.Non_Bonding_Intrachain")
+    u.put(0, f"{cf}.Non_Bonding_1_3")
+
+
+def _put_structure(u, spec: DpdSystemSpec) -> None:
+    box = _box(spec)
+    # initial structure: Random 生成 + density
+    u.put("Random", "Initial_Structure.Generate_Method.Method")
+    u.put(3.0, "Initial_Structure.Initial_Unit_Cell.Density")
+    u.put(box, "Initial_Structure.Initial_Unit_Cell.Cell_Size.a")
+    u.put(box, "Initial_Structure.Initial_Unit_Cell.Cell_Size.b")
+    u.put(box, "Initial_Structure.Initial_Unit_Cell.Cell_Size.c")
+    u.put(0, "Initial_Structure.Relaxation.Relaxation")
+    # unit cell
+    u.put(3.0, "Structure.Unit_Cell.Density")
+    u.put(box, "Structure.Unit_Cell.Cell_Size.a")
+    u.put(box, "Structure.Unit_Cell.Cell_Size.b")
+    u.put(box, "Structure.Unit_Cell.Cell_Size.c")
+    # unit parameter (DPD reduced units)
+    u.put(1.0, "Unit_Parameter.Energy")
+    u.put(0.71137866, "Unit_Parameter.Length")
+
+
+def _bond_table(spec: DpdSystemSpec) -> Dict[Tuple[str, str], Tuple[float, float]]:
+    """(name_i, name_j) -> (R0, K) を全 monomer から集約 (重複は先勝ち)。"""
+    seen: Dict[Tuple[str, str], Tuple[float, float]] = {}
+    for mono in spec.monomers:
+        for entry in mono.bond12h:
+            if len(entry) < 5:
+                continue
+            _, i, j, dist, stiff = entry[:5]
+            ni = mono.particle_names[i] if i < mono.n_particles else f"P{i}"
+            nj = mono.particle_names[j] if j < mono.n_particles else f"P{j}"
+            key = tuple(sorted([ni, nj]))
+            seen.setdefault(key, (float(dist), float(stiff)))
+    return seen
+
+
+def _angle_table(spec: DpdSystemSpec) -> Dict[Tuple[str, str, str], Tuple[float, float]]:
+    seen: Dict[Tuple[str, str, str], Tuple[float, float]] = {}
+    for mono in spec.monomers:
+        for entry in mono.angle13data:
+            if len(entry) < 5:
+                continue
+            a, b, c, eq, stiff = entry[:5]
+            na = mono.particle_names[a] if a < mono.n_particles else f"P{a}"
+            nb = mono.particle_names[b] if b < mono.n_particles else f"P{b}"
+            nc = mono.particle_names[c] if c < mono.n_particles else f"P{c}"
+            seen.setdefault((na, nb, nc), (float(eq), float(stiff)))
+    return seen
+
+
+def _put_molecular_attributes(u, spec: DpdSystemSpec) -> None:
+    segs = spec.segment_names()
+    for n, s in enumerate(segs):
+        u.put(str(s), f"{_MA}.Atom_Type[{n}].Name")
+        u.put(1.0, f"{_MA}.Atom_Type[{n}].Mass")
+        u.put(str(s), f"{_MA}.Interaction_Site_Type[{n}].Name")
+        u.put(1, f"{_MA}.Interaction_Site_Type[{n}].Num_of_Atoms")
+        u.put(0.6, f"{_MA}.Interaction_Site_Type[{n}].Range")
+
+    for n, ((ni, nj), (R0, K)) in enumerate(_bond_table(spec).items()):
+        u.put(f"{ni}-{nj}", f"{_MA}.Bond_Potential[{n}].Name")
+        u.put("Harmonic", f"{_MA}.Bond_Potential[{n}].Potential_Type")
+        u.put(float(R0), f"{_MA}.Bond_Potential[{n}].R0")
+        u.put(float(K), f"{_MA}.Bond_Potential[{n}].Harmonic.K")
+
+    for n, ((na, nb, nc), (eq, K)) in enumerate(_angle_table(spec).items()):
+        u.put(f"{na}-{nb}-{nc}", f"{_MA}.Angle_Potential[{n}].Name")
+        u.put("Theta", f"{_MA}.Angle_Potential[{n}].Potential_Type")
+        u.put(float(eq), f"{_MA}.Angle_Potential[{n}].theta0")
+        u.put(float(K), f"{_MA}.Angle_Potential[{n}].Theta.K")
+
+
+def _put_interactions(u, spec: DpdSystemSpec) -> None:
+    for n, (i, j, a) in enumerate(spec.aij.to_a_values()):
+        u.put(f"{i}-{j}", f"{_PI}[{n}].Name")
+        u.put("DPD", f"{_PI}[{n}].Potential_Type")
+        u.put(str(i), f"{_PI}[{n}].Site1_Name")
+        u.put(str(j), f"{_PI}[{n}].Site2_Name")
+        u.put(1.0, f"{_PI}[{n}].Cutoff")
+        u.put(1.0, f"{_PI}[{n}].Scale_1_4_Pair")
+        u.put(float(a), f"{_PI}[{n}].DPD.a")
+        u.put(float(_DPD_GAMMA), f"{_PI}[{n}].DPD.gamma")
+
+
+def _put_set_of_molecules(u, spec: DpdSystemSpec) -> None:
+    """各 monomer 種を 1 molecule テンプレートとして登録 (atoms/bonds/angles)。"""
+    bond_names = _bond_table(spec)
+    angle_names = _angle_table(spec)
+    for mid, mono in enumerate(spec.monomers):
+        u.put(str(mono.name), f"{_SM}[{mid}].Mol_Name")
+        names = list(mono.particle_names) or [f"P{k}" for k in range(mono.n_particles)]
+        for k, pn in enumerate(names):
+            u.put(int(k), f"{_SM}[{mid}].atom[{k}].Atom_ID")
+            u.put(str(pn), f"{_SM}[{mid}].atom[{k}].Atom_Name")
+            u.put(str(pn), f"{_SM}[{mid}].atom[{k}].Atom_Type_Name")
+            u.put(0, f"{_SM}[{mid}].atom[{k}].Chirality")
+            u.put(1, f"{_SM}[{mid}].atom[{k}].Main_Chain")
+            u.put(str(pn), f"{_SM}[{mid}].interaction_Site[{k}].Type_Name")
+            u.put(int(k), f"{_SM}[{mid}].interaction_Site[{k}].atom[0]")
+        for bk, (i, j) in enumerate(mono.bond12):
+            ni = names[i] if i < len(names) else f"P{i}"
+            nj = names[j] if j < len(names) else f"P{j}"
+            key = tuple(sorted([ni, nj]))
+            pname = f"{key[0]}-{key[1]}" if key in bond_names else f"{ni}-{nj}"
+            u.put(str(pname), f"{_SM}[{mid}].bond[{bk}].Potential_Name")
+            u.put(int(i), f"{_SM}[{mid}].bond[{bk}].atom1")
+            u.put(int(j), f"{_SM}[{mid}].bond[{bk}].atom2")
+            u.put(1, f"{_SM}[{mid}].bond[{bk}].Order")
+        for ak, (a, b, c) in enumerate(mono.angle13):
+            na = names[a] if a < len(names) else f"P{a}"
+            nb = names[b] if b < len(names) else f"P{b}"
+            nc = names[c] if c < len(names) else f"P{c}"
+            pname = f"{na}-{nb}-{nc}"
+            u.put(str(pname), f"{_SM}[{mid}].angle[{ak}].Potential_Name")
+            u.put(int(a), f"{_SM}[{mid}].angle[{ak}].atom1")
+            u.put(int(b), f"{_SM}[{mid}].angle[{ak}].atom2")
+            u.put(int(c), f"{_SM}[{mid}].angle[{ak}].atom3")