abmptools 2.2.0__tar.gz → 2.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abmptools
-Version: 2.2.0
+Version: 2.2.1
 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
@@ -121,7 +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
+- **udfcharge**: Transfer per-atom partial charges from a single-molecule UDF to bulk molecules (`transfer`), or restore a neutralized UDF's charges to a target integer formal charge (`restore`)
 
 ### Geometry Optimization (`geomopt`)
 
@@ -314,7 +314,10 @@ python -m abmptools.udf2gro.cli -i system.udf -o output
 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
+python -m abmptools.udfcharge transfer --template mol.udf --bulk bulk.udf --out bulk_charged.udf
+
+# Restore a neutralized UDF's charges to a target integer formal charge
+python -m abmptools.udfcharge restore --udf mol.udf --formal-charge 12 --out mol_q+12.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" \

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

@@ -37,7 +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
+- **udfcharge**: Transfer per-atom partial charges from a single-molecule UDF to bulk molecules (`transfer`), or restore a neutralized UDF's charges to a target integer formal charge (`restore`)
 
 ### Geometry Optimization (`geomopt`)
 
@@ -230,7 +230,10 @@ python -m abmptools.udf2gro.cli -i system.udf -o output
 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
+python -m abmptools.udfcharge transfer --template mol.udf --bulk bulk.udf --out bulk_charged.udf
+
+# Restore a neutralized UDF's charges to a target integer formal charge
+python -m abmptools.udfcharge restore --udf mol.udf --formal-charge 12 --out mol_q+12.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" \

{abmptools-2.2.0 → abmptools-2.2.1}/abmptools/hbond/analyzer.py

@@ -302,6 +302,36 @@ class Analyzer:
                 meta_by_type["ether_O"] = [(s.mol_index, s.acceptor_a) for s in sites]
         return sites_by_type, meta_by_type
 
+    def _auto_groups(self) -> Tuple[List[str], List[str]]:
+        """Auto-detect donor/acceptor group types present in the system.
+
+        Used by ``classify_mode='auto'``. Returns ``(donor_groups,
+        acceptor_groups)`` listing only the functional-group types actually
+        detected (carboxyl / amide / secondary-amide N-H / amine N-H /
+        hydroxyl). ``ether_O`` is NOT auto-listed because there is no reliable
+        ether detector yet (GAFF2 ``os``-tag only); pass ``--acceptor-groups
+        ether_O`` explicitly if needed.
+        """
+        if self.traj is None:
+            self.load()
+        from .functional_groups import detect_hydroxyls
+        donors: List[str] = []
+        acceptors: List[str] = []
+        if self.carboxyls:
+            donors.append("carboxyl")
+            acceptors.append("carboxyl_O")
+        if any(g.from_amide for g in self.amine_donors):
+            donors.append("amide_donor")
+        if any(not g.from_amide for g in self.amine_donors):
+            donors.append("amine_donor")
+        hydroxyls = detect_hydroxyls(self.traj.molecules, mapping=self.mapping)
+        if hydroxyls:
+            donors.append("hydroxyl")
+            acceptors.append("hydroxyl_O")
+        if self.amides:
+            acceptors.append("amide_O")
+        return donors, acceptors
+
     def run(self) -> List[FrameResult]:
         if self.traj is None:
             self.load()
@@ -309,12 +339,28 @@ class Analyzer:
         end = c.record_end if c.record_end >= 0 else self.traj.n_records
         criteria = c.get_criteria()
         mode = (c.classify_mode or "imc").lower()
-        if mode not in {"imc", "generic"}:
+        if mode not in {"imc", "generic", "auto"}:
             raise ValueError(
                 f"Unknown classify_mode={c.classify_mode!r}; "
-                "must be 'imc' or 'generic'"
+                "must be 'imc', 'generic', or 'auto'"
             )
 
+        if mode == "auto":
+            # Detect which functional-group donor/acceptor types are present and
+            # run them through the generic pair-stats path. Explicit
+            # --donor-groups / --acceptor-groups still override the auto picks.
+            auto_donors, auto_acceptors = self._auto_groups()
+            if c.donor_groups is None:
+                c.donor_groups = auto_donors
+            if c.acceptor_groups is None:
+                c.acceptor_groups = auto_acceptors
+            if c.verbose:
+                print(f"  [auto] donor groups   : {c.donor_groups or '(none detected)'}")
+                print(f"  [auto] acceptor groups: {c.acceptor_groups or '(none detected)'}")
+            # Resolve to generic so run()/write_outputs use the generic path.
+            c.classify_mode = "generic"
+            mode = "generic"
+
         donor_groups = c.donor_groups or (
             ["carboxyl"] if mode == "imc" else []
         )

{abmptools-2.2.0 → abmptools-2.2.1}/abmptools/hbond/cli.py

@@ -62,9 +62,11 @@ def main(argv=None) -> int:
         help="Base molecule name for renamed groups (default: IMC)"
     )
     parser.add_argument(
-        "--classify-mode", choices=["imc", "generic"], default="imc",
+        "--classify-mode", choices=["imc", "generic", "auto"], default="imc",
         help="imc: COOH-centric 4-species (dual/chain/single/free, IMC default). "
-             "generic: donor-type x acceptor-type pair stats (PVA/peptide/etc.)"
+             "generic: donor-type x acceptor-type pair stats (PVA/peptide/etc.). "
+             "auto: detect functional groups present and run generic with them "
+             "(no need to pass --donor-groups/--acceptor-groups; ether_O excluded)"
     )
     parser.add_argument(
         "--no-element-fallback", action="store_true",

{abmptools-2.2.0 → abmptools-2.2.1}/abmptools/udfcharge/__init__.py

@@ -14,8 +14,10 @@ from .core import (
     POINT_CHARGE,
     AssignResult,
     MoleculeChargeTemplate,
+    RestoreResult,
     assign_charges_to_bulk,
     read_molecule_charges,
+    restore_formal_charge,
 )
 
 __all__ = [
@@ -23,6 +25,8 @@ __all__ = [
     "POINT_CHARGE",
     "AssignResult",
     "MoleculeChargeTemplate",
+    "RestoreResult",
     "assign_charges_to_bulk",
     "read_molecule_charges",
+    "restore_formal_charge",
 ]

abmptools-2.2.1/abmptools/udfcharge/__main__.py

@@ -0,0 +1,117 @@
+"""CLI: OCTA/COGNAC UDF の per-atom 電荷操作。
+
+    # 単分子 UDF の電荷をバルク UDF の同名分子へ転写
+    python -m abmptools.udfcharge transfer --template mol.udf --bulk bulk.udf \
+        [--out bulk_charged.udf] [--mol-name NAME] [--mol-index I] \
+        [--no-verify-types] [--non-strict]
+
+    # 中和 (Σq≈0) された 1 分子 UDF の電荷を指定形式電荷に復元
+    python -m abmptools.udfcharge restore --udf mol.udf --formal-charge 12 \
+        [--out mol_q+12.udf] [--mol-index I] [--mol-name NAME]
+
+後方互換: サブコマンド省略時は ``transfer`` として解釈する。
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+from .core import (
+    assign_charges_to_bulk,
+    read_molecule_charges,
+    restore_formal_charge,
+)
+
+_SUBCOMMANDS = {"transfer", "restore"}
+
+
+def _run_transfer(args) -> int:
+    tmpl = read_molecule_charges(
+        args.template, mol_name=args.mol_name, mol_index=args.mol_index,
+    )
+    res = assign_charges_to_bulk(
+        args.bulk, tmpl, args.out,
+        verify_atom_types=not args.no_verify_types,
+        strict=not args.non_strict,
+    )
+    print(f"template : {tmpl.mol_name} (n_atoms={tmpl.n_atoms}, "
+          f"net_charge={tmpl.net_charge:+.4f})")
+    print(f"assigned : {res.n_molecules_assigned}/{res.n_molecules_total} molecules")
+    if res.skipped_indices:
+        print(f"skipped  : {res.skipped_indices}")
+    print(f"output   : {res.out_path}")
+    return 0
+
+
+def _run_restore(args) -> int:
+    res = restore_formal_charge(
+        args.udf, args.formal_charge, args.out,
+        mol_index=args.mol_index, mol_name=args.mol_name, mode=args.mode,
+    )
+    detail = (f"λ={res.lam:.8f}" if res.mode == "proportional"
+              else f"shift=S/N={res.shift:.8f}")
+    print(f"molecule     : {res.mol_name} (n_atoms={res.n_atoms})")
+    print(f"mode         : {res.mode}")
+    print(f"input total  : {res.input_total:+.6f}  (中和済み想定)")
+    print(f"formal charge: {res.formal_charge:+d}  ({detail})")
+    print(f"output total : {res.output_total:+.6f}")
+    print(f"output       : {res.out_path}")
+    return 0
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    # 後方互換: 旧フラット呼び出し (transfer の --template ...) を許容
+    if argv and argv[0] not in _SUBCOMMANDS and not argv[0].startswith("-"):
+        pass  # 不明な位置引数 → そのまま argparse にエラーさせる
+    elif argv and argv[0].startswith("-") and "--template" in argv:
+        argv = ["transfer"] + argv
+
+    p = argparse.ArgumentParser(
+        prog="python -m abmptools.udfcharge",
+        description="OCTA/COGNAC UDF の per-atom 電荷操作 (転写 / 形式電荷復元)。",
+    )
+    sub = p.add_subparsers(dest="cmd")
+
+    pt = sub.add_parser("transfer",
+                        help="単分子 UDF の電荷をバルク UDF の同名分子へ転写")
+    pt.add_argument("--template", required=True, help="電荷を持つ単分子 UDF")
+    pt.add_argument("--bulk", required=True, help="割り当て先のバルク UDF")
+    pt.add_argument("--out", default=None, help="出力 (省略時 <bulk>_charged.udf)")
+    pt.add_argument("--mol-name", default=None)
+    pt.add_argument("--mol-index", type=int, default=None)
+    pt.add_argument("--no-verify-types", action="store_true")
+    pt.add_argument("--non-strict", action="store_true")
+    pt.add_argument("-v", "--verbose", action="store_true")
+    pt.set_defaults(func=_run_transfer)
+
+    pr = sub.add_parser("restore",
+                        help="中和済み 1 分子 UDF の電荷を指定形式電荷に復元")
+    pr.add_argument("--udf", required=True, help="中和 (Σq≈0) された 1 分子 UDF")
+    pr.add_argument("--formal-charge", type=int, required=True,
+                    help="目標の形式電荷 (整数)")
+    pr.add_argument("--out", default=None, help="出力 (省略時 <udf>_q<±S>.udf)")
+    pr.add_argument("--mode", choices=["proportional", "uniform"],
+                    default="proportional",
+                    help="中和ルール: proportional (|q| 比例、 既定) / uniform (均等分配)")
+    pr.add_argument("--mol-name", default=None)
+    pr.add_argument("--mol-index", type=int, default=0)
+    pr.add_argument("-v", "--verbose", action="store_true")
+    pr.set_defaults(func=_run_restore)
+
+    args = p.parse_args(argv)
+    if not getattr(args, "cmd", None):
+        p.print_help()
+        return 2
+
+    logging.basicConfig(
+        level=logging.INFO if getattr(args, "verbose", False) else logging.WARNING,
+        format="%(levelname)s %(name)s: %(message)s",
+    )
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{abmptools-2.2.0 → abmptools-2.2.1}/abmptools/udfcharge/core.py

@@ -21,6 +21,7 @@ COGNAC UDF の電荷規約 (gro2udf / udf2gro と共通):
 from __future__ import annotations
 
 import logging
+import math
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional
@@ -32,8 +33,10 @@ __all__ = [
     "POINT_CHARGE",
     "MoleculeChargeTemplate",
     "AssignResult",
+    "RestoreResult",
     "read_molecule_charges",
     "assign_charges_to_bulk",
+    "restore_formal_charge",
 ]
 
 # COGNAC: ES_Element = charge[e] * CHARGE_UNIT  (gro2udf/udf2gro と同一定数)
@@ -45,6 +48,17 @@ _ATOM = "Set_of_Molecules.molecule[].atom[]"
 _ES = "Set_of_Molecules.molecule[].electrostatic_Site[]"
 
 
+def _put_molecule_charges(u, imol, charges) -> None:
+    """molecule[imol] の各 atom に electrostatic_Site (POINT_CHARGE) を書く。
+
+    float() cast 必須: numpy 値だと UDFManager が silent 0 化する。
+    """
+    for k, q in enumerate(charges):
+        u.put(POINT_CHARGE, f"{_ES}.Type_Name", [imol, k])
+        u.put(float(q) * CHARGE_UNIT, f"{_ES}.ES_Element", [imol, k])
+        u.put(int(k), f"{_ES}.atom[]", [imol, k, 0])
+
+
 def _open(udf_path) -> "object":
     """UDFManager を開いて static record (jump(-1)) に移動して返す。"""
     from UDFManager import UDFManager  # OCTA 同梱 (PyPI 非配布)
@@ -251,11 +265,7 @@ def assign_charges_to_bulk(
                 skipped.append(i)
                 continue
 
-        for k in range(n_atoms):
-            u.put(POINT_CHARGE, f"{_ES}.Type_Name", [i, k])
-            # float() cast 必須: numpy 値だと UDFManager が silent 0 化する
-            u.put(float(template.charges[k] * CHARGE_UNIT), f"{_ES}.ES_Element", [i, k])
-            u.put(int(k), f"{_ES}.atom[]", [i, k, 0])
+        _put_molecule_charges(u, i, template.charges)
         assigned.append(i)
 
     if not assigned and strict:
@@ -277,3 +287,174 @@ def assign_charges_to_bulk(
         res.n_molecules_assigned, res.n_molecules_total, res.mol_name, out_path.name,
     )
     return res
+
+
+# ---------------------------------------------------------------------------
+# 形式電荷の復元 (neutralize の逆変換)
+# ---------------------------------------------------------------------------
+#
+# 前提となる中和ルール (forward): 元電荷 A_i (Σ A = S = 形式電荷) を、 過剰分 S を
+# ``|A_i|`` 比例で各原子に分散して中和し、 B_i (Σ B ≈ 0) を得る:
+#
+#     B_i = A_i - S·|A_i| / Σ|A|          (λ = S/Σ|A| とおくと)
+#     B_i = (1-λ)A_i   (A_i>0)
+#     B_i = (1+λ)A_i   (A_i<0)
+#
+# reverse (本機能): B_i と目標形式電荷 S だけから A_i を復元する。 符号は保存される
+# (λ<1 のとき) ので:
+#
+#     A_i = B_i/(1-λ)   (B_i>0)
+#     A_i = B_i/(1+λ)   (B_i<0)
+#
+# λ は Σ A = S の制約から、 P=Σ_{B>0}B / N=Σ_{B<0}B を用いて
+#
+#     S·λ² + (P-N)·λ + (P+N-S) = 0
+#
+# の |λ|<1 の根として求まる (詳細は docs/udfcharge.md / SI/A列再現方法.md)。
+#
+# もう一つの中和ルール ``mode="uniform"`` (均等分配): 過剰分 S を全原子に均等に
+# 分散して中和する。
+#
+#     forward:  B_i = A_i - S/N        (N = 原子数、 Σ B = 0)
+#     reverse:  A_i = B_i + S/N
+#
+# こちらは二次方程式も符号反転問題も無く、 常に厳密・一意に復元できる。
+
+
+@dataclass
+class RestoreResult:
+    """:func:`restore_formal_charge` の結果サマリ。"""
+
+    out_path: str
+    mol_name: str
+    n_atoms: int
+    formal_charge: int
+    input_total: float       # 入力 UDF の総電荷 (≈0 を想定)
+    output_total: float      # 出力 UDF の総電荷 (= formal_charge)
+    mode: str = "proportional"          # "proportional" | "uniform"
+    lam: Optional[float] = None         # proportional 時の λ (uniform では None)
+    shift: Optional[float] = None       # uniform 時の S/N (proportional では None)
+
+
+def _solve_neutralization_lambda(charges: List[float], formal_charge: float) -> float:
+    """中和電荷 (B) と目標形式電荷 S から逆変換用 λ を解く。
+
+    ``S·λ² + (P-N)·λ + (P+N-S) = 0`` (P=Σ_{B>0}B, N=Σ_{B<0}B) の |λ|<1 の根。
+    S≈0 のときは線形に縮退する。
+    """
+    P = sum(b for b in charges if b > 0.0)
+    N = sum(b for b in charges if b < 0.0)
+    S = float(formal_charge)
+    a, b, c = S, (P - N), (P + N - S)
+
+    if abs(a) < 1e-12:                       # S ≈ 0 → 線形 (P-N)λ + (P+N) = 0
+        if abs(b) < 1e-12:
+            return 0.0
+        lam = -(P + N) / b
+    else:
+        disc = b * b - 4.0 * a * c
+        if disc < 0:
+            raise ValueError(
+                f"形式電荷 {S:g} は |q| 比例分配ルールで到達不能です (判別式 < 0)"
+            )
+        sq = math.sqrt(disc)
+        roots = [(-b + sq) / (2.0 * a), (-b - sq) / (2.0 * a)]
+        valid = [r for r in roots if abs(r) < 1.0]
+        if not valid:
+            raise ValueError(
+                f"|λ|<1 の根が無く電荷符号が反転します (formal_charge={S:g} が大きすぎ、 "
+                "B 列と総和だけからは一意に復元できないケース)"
+            )
+        lam = min(valid, key=abs)
+    return lam
+
+
+def restore_formal_charge(
+    udf_path,
+    formal_charge: int,
+    out_path=None,
+    *,
+    mol_index: int = 0,
+    mol_name: Optional[str] = None,
+    mode: str = "proportional",
+) -> RestoreResult:
+    """中和 (Σq≈0) された 1 分子 UDF の電荷を、 指定形式電荷になるよう逆変換して出力。
+
+    過剰電荷を分散して中和した UDF (Σ電荷≈0) を入力に、 目標の **形式電荷 (整数) S**
+    を与えると、 中和前の per-atom 電荷 (Σ=S) を復元して別 UDF に書き出す。
+    ``electrostatic_Site`` のみ更新し、 座標・結合等は無改変。
+
+    **中和ルール (``mode``) を正しく選ぶこと** — UDF を中和した方法に一致させる:
+
+    - ``"proportional"`` (既定): 過剰分 S を ``|q|`` 比例で分散
+      (`B_i = A_i − S·|A_i|/Σ|A|`)。 逆変換は二次方程式で λ を解く。
+      ``|S| ≥ Σ|q|`` (符号反転) のケースは ``ValueError``。
+    - ``"uniform"``: 過剰分 S を全原子に**均等**に分散 (`B_i = A_i − S/N`)。
+      逆変換は `A_i = B_i + S/N` で常に厳密・一意 (符号問題なし)。
+
+    Parameters
+    ----------
+    udf_path
+        中和済み電荷を持つ 1 分子 UDF。
+    formal_charge
+        目標の形式電荷 (整数)。 出力 UDF の総電荷がこの値になる。
+    out_path
+        出力 UDF。 省略時 ``<udf>_q<±S>.udf``。
+    mol_index / mol_name
+        対象分子 (既定は先頭=0、 単分子 UDF を想定)。
+    mode
+        中和ルール: ``"proportional"`` (既定) または ``"uniform"``。
+
+    Returns
+    -------
+    RestoreResult
+    """
+    udf_path = Path(udf_path)
+    S = int(formal_charge)
+    if out_path is None:
+        out_path = udf_path.with_name(f"{udf_path.stem}_q{S:+d}{udf_path.suffix}")
+    out_path = Path(out_path)
+
+    tmpl = read_molecule_charges(udf_path, mol_index=mol_index, mol_name=mol_name)
+    B = tmpl.charges
+    input_total = float(sum(B))
+
+    lam: Optional[float] = None
+    shift: Optional[float] = None
+    if mode == "proportional":
+        lam = _solve_neutralization_lambda(B, S)
+        A = [
+            (b / (1.0 - lam) if b > 0.0 else (b / (1.0 + lam) if b < 0.0 else 0.0))
+            for b in B
+        ]
+    elif mode == "uniform":
+        shift = float(S) / tmpl.n_atoms
+        A = [b + shift for b in B]
+    else:
+        raise ValueError(
+            f"mode={mode!r} は未対応です ('proportional' / 'uniform' から選択)"
+        )
+    output_total = float(sum(A))
+
+    u = _open(udf_path)
+    _put_molecule_charges(u, tmpl.source_index, A)
+    u.write(str(out_path))
+
+    res = RestoreResult(
+        out_path=str(out_path),
+        mol_name=tmpl.mol_name,
+        n_atoms=tmpl.n_atoms,
+        formal_charge=S,
+        input_total=input_total,
+        output_total=output_total,
+        mode=mode,
+        lam=lam,
+        shift=shift,
+    )
+    detail = f"λ={lam:.8f}" if mode == "proportional" else f"shift=S/N={shift:.8f}"
+    logger.info(
+        "restore[%s]: %r %d atoms, Σq %.6f → %.6f (target %d, %s) → %s",
+        mode, res.mol_name, res.n_atoms, input_total, output_total, S, detail,
+        out_path.name,
+    )
+    return res

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abmptools
-Version: 2.2.0
+Version: 2.2.1
 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
@@ -121,7 +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
+- **udfcharge**: Transfer per-atom partial charges from a single-molecule UDF to bulk molecules (`transfer`), or restore a neutralized UDF's charges to a target integer formal charge (`restore`)
 
 ### Geometry Optimization (`geomopt`)
 
@@ -314,7 +314,10 @@ python -m abmptools.udf2gro.cli -i system.udf -o output
 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
+python -m abmptools.udfcharge transfer --template mol.udf --bulk bulk.udf --out bulk_charged.udf
+
+# Restore a neutralized UDF's charges to a target integer formal charge
+python -m abmptools.udfcharge restore --udf mol.udf --formal-charge 12 --out mol_q+12.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" \

{abmptools-2.2.0 → abmptools-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "abmptools"
-version = "2.2.0"
+version = "2.2.1"
 description = "Pre/post-processing and analysis toolkit for ABINIT-MP Fragment Molecular Orbital calculations"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = "Apache-2.0"

abmptools-2.2.0/abmptools/udfcharge/__main__.py

@@ -1,63 +0,0 @@
-"""CLI: 単分子 UDF の電荷をバルク UDF の同名分子へ割り当てる。
-
-    python -m abmptools.udfcharge --template mol.udf --bulk bulk.udf \
-        [--out bulk_charged.udf] [--mol-name NAME] [--mol-index I] \
-        [--no-verify-types] [--non-strict]
-"""
-
-from __future__ import annotations
-
-import argparse
-import logging
-import sys
-
-from .core import assign_charges_to_bulk, read_molecule_charges
-
-
-def main(argv=None) -> int:
-    p = argparse.ArgumentParser(
-        prog="python -m abmptools.udfcharge",
-        description="単分子 UDF (電荷あり) の per-atom 電荷を、 バルク UDF の同名分子"
-                    "すべてへ割り当てる (OCTA/COGNAC electrostatic_Site)。",
-    )
-    p.add_argument("--template", required=True,
-                   help="電荷を持つ単分子 UDF")
-    p.add_argument("--bulk", required=True,
-                   help="割り当て先のバルク UDF (同名分子が複数、 電荷なし)")
-    p.add_argument("--out", default=None,
-                   help="出力 UDF (省略時 <bulk>_charged.udf)")
-    p.add_argument("--mol-name", default=None,
-                   help="template から抽出する分子の Mol_Name (省略時 先頭分子)")
-    p.add_argument("--mol-index", type=int, default=None,
-                   help="template から抽出する分子の index (--mol-name より優先)")
-    p.add_argument("--no-verify-types", action="store_true",
-                   help="Atom_Type_Name 列の一致検証を無効化")
-    p.add_argument("--non-strict", action="store_true",
-                   help="検証不一致を例外でなく warning + skip で処理")
-    p.add_argument("-v", "--verbose", action="store_true", help="INFO ログを出力")
-    args = p.parse_args(argv)
-
-    logging.basicConfig(
-        level=logging.INFO if args.verbose else logging.WARNING,
-        format="%(levelname)s %(name)s: %(message)s",
-    )
-
-    tmpl = read_molecule_charges(
-        args.template, mol_name=args.mol_name, mol_index=args.mol_index,
-    )
-    res = assign_charges_to_bulk(
-        args.bulk, tmpl, args.out,
-        verify_atom_types=not args.no_verify_types,
-        strict=not args.non_strict,
-    )
-    print(f"template : {tmpl.mol_name} (n_atoms={tmpl.n_atoms}, "
-          f"net_charge={tmpl.net_charge:+.4f})")
-    print(f"assigned : {res.n_molecules_assigned}/{res.n_molecules_total} molecules")
-    if res.skipped_indices:
-        print(f"skipped  : {res.skipped_indices}")
-    print(f"output   : {res.out_path}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())