reaxkit 1.0.0__py3-none-any.whl

reaxkit/cli.py

@@ -0,0 +1,181 @@
+"""
+Top-level command-line interface for ReaxKit workflows.
+
+Works on: ReaxKit CLI (`reaxkit`) → dispatches to workflow modules under `reaxkit.workflows`.
+
+This module defines the `reaxkit` entry point and routes each top-level subcommand
+("kind") to its corresponding workflow module, which then registers task-level
+subcommands (or runs as a kind-level workflow such as `help` / `intspec`).
+"""
+
+import argparse
+import sys
+
+from reaxkit.workflows.meta import make_video_workflow, plotter_workflow, help_workflow, introspection_workflow
+from reaxkit.workflows.per_file import fort57_workflow, summary_workflow, geo_workflow, trainset_workflow, \
+    fort76_workflow, fort78_workflow, xmolout_workflow, fort83_workflow, eregime_workflow, fort79_workflow, \
+    fort99_workflow, control_workflow, ffield_workflow, vels_workflow, fort13_workflow, tregime_workflow, \
+    params_workflow, fort7_workflow, vregime_workflow, molfra_workflow, fort73_workflow, fort74_workflow
+from reaxkit.workflows.composed import coordination_workflow, xmolout_fort7_workflow, electrostatics_workflow
+
+# Mapping from top-level CLI "kind" (subcommand) to the workflow module
+# that knows how to register its own tasks and arguments.
+
+# important note: energylog and fort.58 have exactly the same structure as fort.73, hence they should map to fort.73
+# also, fort.8 is similar to fort.7 in the same way
+# same for molsav and moldyn which are similar to vels
+WORKFLOW_MODULES = {
+    "fort78": fort78_workflow, "xmolout": xmolout_workflow, "summary": summary_workflow,
+    "eregime": eregime_workflow, "molfra": molfra_workflow, "fort13": fort13_workflow,
+    "fort79": fort79_workflow, "fort7": fort7_workflow, "xmolfort7": xmolout_fort7_workflow,
+    "coord": coordination_workflow, "intspec": introspection_workflow, "geo": geo_workflow,
+    "fort99": fort99_workflow, "trainset": trainset_workflow, "fort83": fort83_workflow,
+    "fort73": fort73_workflow, "elect": electrostatics_workflow, "video": make_video_workflow,
+    "plotter": plotter_workflow, "control": control_workflow, "fort76": fort76_workflow,
+    "fort74.md": fort74_workflow, "ffield": ffield_workflow, "params": params_workflow,
+    "energylog": fort73_workflow, "fort58": fort73_workflow, "fort57.md": fort57_workflow,
+    "vels": vels_workflow, "help": help_workflow, "fort8": fort7_workflow,
+    "moldyn": vels_workflow, "molsav": vels_workflow, "tregime": tregime_workflow,
+    "vregime": vregime_workflow,
+}
+
+
+# Workflows that are allowed to omit an explicit task; a default task
+# will be injected for them if the user does not provide one.
+DEFAULTABLE = {}
+
+# Names that are treated as "known tasks" when deciding whether to inject
+# a synthetic `_default` task for DEFAULTABLE workflows.
+DEFAULT_TASKS = {}
+
+
+def _preinject(argv):
+    """
+    Inject a default task for selected workflows before argparse parsing.
+
+    Works on: CLI argv preprocessing for workflows that allow omitting an explicit task.
+
+    Parameters
+    ----------
+    argv : Sequence[str]
+        Raw argument vector (typically `sys.argv`).
+
+    Returns
+    -------
+    list[str]
+        A rewritten argv where a synthetic `_default` task is inserted for
+        workflows in `DEFAULTABLE` when the next token is not a known task.
+
+    Examples
+    --------
+    >>> _preinject(["reaxkit", "gplot", "file.txt"])
+    ['reaxkit', 'gplot', '_default', 'file.txt']
+    """
+    out = list(argv)
+    for i, tok in enumerate(out):
+        if tok in DEFAULTABLE:
+            j = i + 1
+            if j >= len(out):
+                break
+            nxt = out[j]
+            if nxt in ("-h", "--help"):
+                break  # allow `reaxkit gplot -h` to show help normally
+            if nxt not in DEFAULT_TASKS:  # filename or option → inject default task
+                out.insert(j, "_default")
+            break
+    return out
+
+
+def _intspec_default_runner(args):
+    """
+    Run the `intspec` workflow without requiring a task subcommand.
+
+    Works on: `intspec` kind-level workflow (introspection).
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Parsed CLI arguments; may include `file` and/or `folder`.
+
+    Returns
+    -------
+    int
+        Workflow exit code returned by `introspection_workflow.run_main(...)`.
+
+    Examples
+    --------
+    # Equivalent CLI calls:
+    # reaxkit intspec --file fort7_analyzer
+    # reaxkit intspec --folder workflow
+    """
+    return introspection_workflow.run_main(
+        getattr(args, "file", None),
+        getattr(args, "folder", None),
+    )
+
+
+def main():
+    """
+    Build and execute the `reaxkit` CLI dispatcher.
+
+    Works on: ReaxKit CLI (`reaxkit`) and registered workflow modules.
+
+    This function:
+      1. Preprocesses argv to inject default tasks where needed.
+      2. Creates the top-level parser and the `kind` subparsers.
+      3. Lets each workflow module register its own `task` subparsers.
+      4. Parses the CLI and dispatches to the selected task's `_run` function.
+
+    Returns
+    -------
+    int
+        Exit code returned by the selected workflow task runner.
+
+    Examples
+    --------
+    Per-file workflow with task:
+
+      - reaxkit fort7 get --file fort.7
+
+    Kind-level workflow without task:
+
+      - reaxkit help --query "fort.7"
+
+      - reaxkit intspec --folder workflows
+    """
+    # Preprocess argv so DEFAULTABLE workflows can omit an explicit task.
+    sys_argv = _preinject(sys.argv)
+
+    # Top-level parser for `reaxkit`
+    parser = argparse.ArgumentParser("reaxkit CLI")
+
+    # First level of subcommands: the workflow "kind" (summary, xmolout, etc.)
+    sub = parser.add_subparsers(dest="kind", required=True)
+
+    # For each workflow module, create its own subparser and let it
+    # register its internal tasks (second-level subcommands).
+    for kind, module in WORKFLOW_MODULES.items():
+        # e.g. `reaxkit summary ...`, `reaxkit xmolout ...`
+        kp = sub.add_parser(kind, help=f"{kind} workflows")
+
+        if kind == "intspec":
+            # Kind-level workflow: no subcommands
+            if hasattr(module, "build_parser"):
+                module.build_parser(kp)
+            kp.set_defaults(_run=_intspec_default_runner)
+
+        elif kind == "help":
+            # Kind-level workflow: no subcommands
+            if hasattr(module, "build_parser"):
+                module.build_parser(kp)
+            kp.set_defaults(_run=module.run_main)
+
+        else:
+            # Normal workflows: require a task unless the kind is in DEFAULTABLE.
+            # e.g. `reaxkit summary get ...`
+            tasks = kp.add_subparsers(dest="task", required=kind not in DEFAULTABLE)
+            module.register_tasks(tasks)
+
+    # Parse the CLI (minus the program name) and dispatch to the chosen task.
+    args = parser.parse_args(sys_argv[1:])
+    return args._run(args)

reaxkit/count_loc.py

@@ -0,0 +1,276 @@
+"""Count lines of code in a Python project.
+
+Usage (from inside your project directory):
+    python count_loc.py
+Optional:
+    python count_loc.py --root . --out loc_report.csv
+"""
+
+from __future__ import annotations
+import argparse
+import ast
+import csv
+from pathlib import Path
+
+# Folders to skip during the walk
+DEFAULT_EXCLUDES = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".mypy_cache",
+    ".pytest_cache",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "env",
+    "build",
+    "dist",
+    ".idea",
+    ".vscode",
+    "site-packages",
+    "node_modules",
+}
+
+
+def is_comment_or_blank(line: str) -> bool:
+    """
+    Legacy helper: returns True if the line is blank or a comment-only line.
+    Kept for backward compatibility but not used in main logic.
+    """
+    s = line.strip()
+    return (not s) or s.startswith("#")
+
+
+def iter_python_files(root: Path, excludes: set[str]) -> list[Path]:
+    """Recursively find all .py files under root, skipping excluded dirs."""
+    files = []
+    for p in root.rglob("*.py"):
+        # Skip excluded directories anywhere in the path
+        if any(part in excludes for part in p.parts):
+            continue
+        files.append(p)
+    return files
+
+
+def _docstring_line_numbers(source: str, filename: str) -> set[int]:
+    """
+    Return a set of line numbers (1-based) that belong to *docstrings*
+    (module, class, function/async function) based on the AST.
+    """
+    doc_lines: set[int] = set()
+    try:
+        tree = ast.parse(source, filename=filename)
+    except SyntaxError:
+        # If the file is not valid Python (or incomplete), treat everything
+        # as non-docstring.
+        return doc_lines
+
+    # Module-level and all function/class nodes
+    targets = [tree]
+    targets.extend(
+        node
+        for node in ast.walk(tree)
+        if isinstance(
+            node,
+            (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef),
+        )
+    )
+
+    for node in targets:
+        # ast.get_docstring tells us whether a docstring exists
+        if ast.get_docstring(node, clean=False) is None:
+            continue
+
+        # Docstring must be the first statement in the body
+        body = getattr(node, "body", [])
+        if not body:
+            continue
+        expr0 = body[0]
+        if not isinstance(expr0, ast.Expr):
+            continue
+
+        value = expr0.value
+        # Py3.8+: docstring is usually ast.Constant; older: ast.Str
+        lineno = getattr(value, "lineno", None)
+        end_lineno = getattr(value, "end_lineno", None) or lineno
+        if lineno is None:
+            continue
+
+        for ln in range(lineno, end_lineno + 1):
+            doc_lines.add(ln)
+
+    return doc_lines
+
+
+def classify_python_file(py_path: Path) -> dict[str, int]:
+    """
+    Classify each line in a .py file as code, comment, docstring, or blank.
+
+    Returns a dict with keys:
+        - code
+        - comments
+        - docstrings
+        - blank
+        - total
+    """
+    try:
+        text = py_path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        # If unreadable, treat as 0 for all categories.
+        return {"code": 0, "comments": 0, "docstrings": 0, "blank": 0, "total": 0}
+
+    lines = text.splitlines()
+    docstring_lines = _docstring_line_numbers(text, str(py_path))
+
+    code = comments = docstrings = blank = 0
+
+    for lineno, line in enumerate(lines, start=1):
+        stripped = line.strip()
+
+        if not stripped:
+            blank += 1
+        elif lineno in docstring_lines:
+            # Mark docstring lines first to avoid misclassifying them
+            # as comments or code.
+            docstrings += 1
+        elif stripped.startswith("#"):
+            # Comment-only line
+            comments += 1
+        else:
+            # Everything else is treated as code (includes regular strings,
+            # inline comments, etc.).
+            code += 1
+
+    total = code + comments + docstrings + blank
+    return {
+        "code": code,
+        "comments": comments,
+        "docstrings": docstrings,
+        "blank": blank,
+        "total": total,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Recursively count Python LOC and export CSV with per-file breakdown "
+            "(code, comments, docstrings, blank)."
+        )
+    )
+    parser.add_argument(
+        "--root",
+        type=str,
+        default=".",
+        help="Root directory to scan (default: current directory).",
+    )
+    parser.add_argument(
+        "--out",
+        type=str,
+        default="loc_report.csv",
+        help="Output CSV filename (default: loc_report.csv).",
+    )
+    parser.add_argument(
+        "--include-comments",
+        action="store_true",
+        help=(
+            "Count all physical lines as LOC metric (code + comments + docstrings + blank). "
+            "By default, only code lines are used for the LOC metric."
+        ),
+    )
+    parser.add_argument(
+        "--extra-exclude",
+        action="append",
+        default=[],
+        help="Extra folder name(s) to exclude (can be used multiple times).",
+    )
+
+    args = parser.parse_args()
+    root = Path(args.root).resolve()
+    out_csv = Path(args.out).resolve()
+    excludes = set(DEFAULT_EXCLUDES) | set(args.extra_exclude)
+
+    if not root.exists():
+        raise SystemExit(f"Root path not found: {root}")
+
+    py_files = iter_python_files(root, excludes)
+    py_files.sort()
+
+    csv_rows = []
+    total_loc_metric = 0  # what we print as "Total lines of code" or "Total counted lines"
+
+    # Global totals for summary
+    global_counts = {"code": 0, "comments": 0, "docstrings": 0, "blank": 0, "total": 0}
+
+    # Index to sort by: code (1) or total (5)
+    sort_index = 5 if args.include_comments else 1
+
+    for f in py_files:
+        counts = classify_python_file(f)
+
+        # Update global totals
+        for key in global_counts:
+            global_counts[key] += counts[key]
+
+        # Metric used for totals & ranking
+        loc_metric = counts["total"] if args.include_comments else counts["code"]
+        total_loc_metric += loc_metric
+
+        rel = f.relative_to(root)
+        csv_rows.append(
+            (
+                str(rel),
+                counts["code"],
+                counts["comments"],
+                counts["docstrings"],
+                counts["blank"],
+                counts["total"],
+            )
+        )
+
+    # Sort CSV rows by chosen metric (code or total)
+    csv_rows.sort(key=lambda row: row[sort_index], reverse=True)
+
+    # Write CSV
+    out_csv.parent.mkdir(parents=True, exist_ok=True)
+    with out_csv.open("w", newline="", encoding="utf-8") as fh:
+        writer = csv.writer(fh)
+        writer.writerow(["file", "code", "comments", "docstrings", "blank", "total"])
+        writer.writerows(csv_rows)
+
+    # Print metric summary
+    metric_label = (
+        "Total counted lines (code + comments + docstrings + blank)"
+        if args.include_comments
+        else "Total lines of code (excluding comments/docstrings/blanks)"
+    )
+
+    print(f"\nWrote {len(csv_rows)} files to: {out_csv}")
+    print(f"{metric_label}: {total_loc_metric:,}\n")
+
+    # Print top 6 files
+    print("Top 6 files by this metric:")
+    for file, code, comments, docs, blank, total in csv_rows[:6]:
+        loc_metric = total if args.include_comments else code
+        print(f"  {file:<40} {loc_metric:,}")
+    print()
+
+    # --- Global summary by line type with percentages ---
+    total_lines = global_counts["total"] or 1  # avoid division by zero
+
+    def fmt(name: str, count: int) -> str:
+        pct = (count / total_lines) * 100.0
+        return f"{name:<25} {count:>8,} ({pct:>3.0f}%)"
+
+    print("Summary by Line Type:")
+    print(fmt("Total lines of code:", global_counts["code"]))
+    print(fmt("Total comment lines:", global_counts["comments"]))
+    print(fmt("Total docstring lines:", global_counts["docstrings"]))
+    print(fmt("Total blank lines:", global_counts["blank"]))
+    print("-" * 50)
+    print(f"{'Total physical lines:':<25} {global_counts['total']:>8,}")
+    print()
+
+
+if __name__ == "__main__":
+    main()

reaxkit/data/alias.yaml

@@ -0,0 +1,89 @@
+# Canonical-to-alias mappings for resolving equivalent column and variable names across ReaxFF files.
+# In the CLI, aliases allow users to reference variables using familiar or abbreviated names.
+# In the Python API, canonical names are used internally to ensure consistency and predictability.
+
+aliases:
+  iter:
+    - iteration
+    - Iter
+    - Iter.
+    - Iteration
+    - "#start"
+    - start
+
+  E_pot:
+    - Epot(kcal)
+    - Epot(kcal/mol)
+    - E_potential
+
+  frame: [frm]
+  time: ["Time(fs)", "Time"]
+  num_of_atoms: [num_atoms, number_of_atoms, count_of_atoms]
+  V: ["Vol(A^3)", "Volume", "volume"]
+  D: ["Dens(kg/dm3)", "Density", "density"]
+
+  # molfra.out
+  freq: [frequency, count]
+  molecular_formula: [mol_formula, molecule_formula, molecule]
+  molecular_mass: [mol_mass, mass]
+  total_molecules: [tot_mol]
+  total_atoms: [tot_atom]
+  total_molecular_mass: [tot_mol_mass]
+
+  # fort.78
+  field_x: [Ex, Efield_x, Field_x, fieldX]
+  field_y: [Ey, Efield_y, Field_y, fieldY]
+  field_z: [Ez, Efield_z, Field_z, fieldZ]
+  E_field_x: [Efx]
+  E_field_y: [Efy]
+  E_field_z: [Efz]
+  E_field: [Ef]
+
+  # summary.txt
+  nmol: [Nmol]
+  T: ["T(K)", Temp, temp]
+  P: ["Pres(MPa)", Pressure, pressure]
+  elap_time: [Elap, time_elapsed, elapsed_time]
+
+  # fort.13
+  total_ff_error: [tot_err, err_tot]
+
+  # eregime.in
+  field_zones: ["#V", V]
+  field_dir: [direction, dir, direction1]
+  field: ["E", "Magnitude(V/A)", "Magnitude1(V/A)", E1]
+  field_dir1: [direction1]
+  field1: ["Magnitude1(V/A)", E1]
+  field_dir2: [direction2]
+  field2: ["Magnitude2(V/A)", E2]
+  field_dir3: [direction3]
+  field3: ["Magnitude3(V/A)", E3]
+
+  # xmolout
+  atom_type: [type_of_atom, atm_type]
+  x: [x_coordinate, x_coord, coord_x, coordinate_x]
+  y: [y_coordinate, y_coord, coord_y, coordinate_y]
+  z: [z_coordinate, z_coord, coord_z, coordinate_z]
+
+  # fort.7
+  molecule_num: [molecular_number, molecular_num]
+  partial_charge: [charge, q, total_charge]
+
+  # fort.99
+  error: [Err, Error]
+
+  # electrostatics
+  "mu_x (debye)": [mu_x, dipole_x, dipole_moment_x]
+  "mu_y (debye)": [mu_y, dipole_y, dipole_moment_y]
+  "mu_z (debye)": [mu_z, dipole_z, dipole_moment_z]
+  "P_x (uC/cm^2)": [pol_x, polarization_x]
+  "P_y (uC/cm^2)": [pol_y, polarization_y]
+  "P_z (uC/cm^2)": [pol_z, polarization_z]
+
+  # fort.76
+  E_res: [Eres(kcal), Eres(kcal/mol), E_restraint, restraint_energy, restraint_E]
+
+  # fort.57
+  T_set: [Tset, "Tset(K)", "Tset (K)", "T_set(K)"]
+  RMSG: [rmsg, RmsG, RMSg]
+  nfc: [NFC]

reaxkit/data/constants.yaml

@@ -0,0 +1,27 @@
+# Physical constants and fixed conversion factors used across ReaxKit
+
+constants:
+  # Electric field
+  electric_field_VA_to_MVcm: 100.0        # V/Å → MV/cm
+
+  # Energies
+  energy_kcalmol_to_eV: 0.0433634
+
+  # Fundamental constants
+  electron_charge_C: 1.602176634e-19      # Coulomb
+  electron_charge_e: 1.0                 # dimensionless charge
+
+  # Dipole moment
+  ea_to_debye: 4.80320427                # e·Å → Debye
+  debye_to_ea: 0.20819434                # Debye → e·Å
+
+  # Polarization (dipole / volume)
+  ea3_to_uC_cm2: 1602.176634              # (e·Å)/ų → μC/cm²
+
+  # Pressure
+  eV_per_A3_to_GPa: 160.21766208          # eV/ų → GPa
+
+  # AVOGADRO_CONSTANT
+  AVOGADRO_CONSTANT: 6.022140857
+
+