{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b0c63677",
   "metadata": {},
   "source": [
    "# Deploying a trained model as an MDI engine: liquid argon over the MolSSI Driver Interface\n",
    "\n",
    "The [MolSSI Driver Interface](https://github.com/MolSSI-MDI/MDI_Library) (MDI) couples\n",
    "simulation codes through a small, standardized command protocol: a **driver** (LAMMPS,\n",
    "SEAMM, or a plain Python script) steers one or more **engines** (quantum-chemistry codes,\n",
    "ML potentials, ...) by sending commands like `>COORDS` and `<FORCES` over TCP or MPI.\n",
    "\n",
    "`xnn.common.deploy.MDIEngine` implements the engine side for xnn. It is **model\n",
    "agnostic**: it talks to the model only through the `AtomicGraph` contract shared by every\n",
    "family in the library, so a trained MACE, NequIP, Allegro, CACE, SchNet, ANI, PhysNet or\n",
    "BAMBOO checkpoint is served by the *same* command, `xnn mdi`.\n",
    "\n",
    "This notebook runs the complete pipeline on the bundled `argon_md` hub dataset:\n",
    "\n",
    "| stage | tool |\n",
    "|---|---|\n",
    "| 1. data | `load_dataset(\"argon_md\")` (xnn hub, ships with the repo) |\n",
    "| 2. train | `xnn.common.train.Trainer` $\\rightarrow$ `runs/mdi_argon/best.pt` |\n",
    "| 3. serve | `xnn mdi --ckpt best.pt -mdi \"-role ENGINE ...\"` (engine subprocess) |\n",
    "| 4. validate | results over the wire $\\equiv$ direct `XNNCalculator` evaluation |\n",
    "| 5. use | **NVE MD of liquid argon**, velocity Verlet in a ~40-line Python driver |\n",
    "\n",
    "The Python driver below is deliberately minimal so the protocol is fully visible; at the\n",
    "end we show the one-line change that replaces it with LAMMPS. Requires the `mdi` extra\n",
    "(`pip install \"xnn[mdi]\"`).\n",
    "\n",
    "> **Note:** the MDI library can only be initialized once per process. Restart the kernel\n",
    "> before re-running the notebook.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36a1483b",
   "metadata": {},
   "source": [
    "## 0. Setup\n",
    "\n",
    "`float32` on the GPU for training speed; we switch to `float64` for deployment and\n",
    "dynamics (same convention as the `*_argon_density_md` notebooks).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "61444740",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:52:15.730835Z",
     "iopub.status.busy": "2026-08-04T20:52:15.730714Z",
     "iopub.status.idle": "2026-08-04T20:52:17.604409Z",
     "shell.execute_reply": "2026-08-04T20:52:17.603538Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: 0.1.0 | device: cuda | NVIDIA A100 80GB PCIe\n"
     ]
    }
   ],
   "source": [
    "# silence the expected warnings (TorchScript scripting + e3nn torch.load)\n",
    "import logging, warnings\n",
    "logging.getLogger(\"cuequivariance\").setLevel(logging.ERROR)\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning,\n",
    "                        message=\"The TorchScript type system doesn't support\")\n",
    "warnings.filterwarnings(\"ignore\", category=FutureWarning,\n",
    "                        message=\"You are using `torch.load` with `weights_only=False`\")\n",
    "warnings.filterwarnings(\"ignore\", message=\"Use thermalize_momenta\")\n",
    "\n",
    "import sys, time, subprocess\n",
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "torch.set_default_dtype(torch.float32)\n",
    "torch.manual_seed(0)\n",
    "\n",
    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "import xnn\n",
    "print(\"xnn:\", xnn.__version__, \"| device:\", DEVICE,\n",
    "      \"|\", torch.cuda.get_device_name(0) if DEVICE == \"cuda\" else \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc7ab482",
   "metadata": {},
   "source": [
    "## 1. Load the `argon_md` hub dataset\n",
    "\n",
    "Periodic liquid-argon MD frames (400 atoms each) with reference energies, forces and\n",
    "stress in eV / angstrom, bundled with the repository so this loads offline. The\n",
    "`config_type=IsolatedAtom` reference frame is dropped by the hub builder; for argon the\n",
    "isolated-atom energy $E_0$ is zero by construction.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3caeb7f1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:52:17.607674Z",
     "iopub.status.busy": "2026-08-04T20:52:17.607347Z",
     "iopub.status.idle": "2026-08-04T20:52:18.658362Z",
     "shell.execute_reply": "2026-08-04T20:52:18.657484Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: 200 frames | test: 50 frames | 400 atoms/frame | species: [18]\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import load_dataset\n",
    "\n",
    "train_structs = load_dataset(\"argon_md\", split=\"train\")\n",
    "test_structs = load_dataset(\"argon_md\", split=\"test\")\n",
    "\n",
    "CUTOFF = 6.0\n",
    "SPECIES = sorted({int(z) for s in train_structs for z in s[\"atomic_numbers\"]})\n",
    "E0 = {18: 0.0}\n",
    "n_at = len(train_structs[0][\"atomic_numbers\"])\n",
    "print(f\"train: {len(train_structs)} frames | test: {len(test_structs)} frames | \"\n",
    "      f\"{n_at} atoms/frame | species: {SPECIES}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "770251d7",
   "metadata": {},
   "source": [
    "## 2. Train a small MACE\n",
    "\n",
    "Same architecture and optimizer settings as `../gnn/mace/mace_argon_train_test.ipynb`\n",
    "(2 interactions, 32 channels, $\\ell_\\mathrm{max}=3$, $L_\\mathrm{max}=1$, per-atom\n",
    "energy + force loss), but only 30 epochs: deployment, not accuracy, is the point here.\n",
    "The `Trainer` writes the best-validation checkpoint to `runs/mdi_argon/best.pt`; that\n",
    "single file (weights **and** config) is everything the MDI engine needs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b63c092d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:52:18.660774Z",
     "iopub.status.busy": "2026-08-04T20:52:18.660453Z",
     "iopub.status.idle": "2026-08-04T20:53:52.803090Z",
     "shell.execute_reply": "2026-08-04T20:53:52.802109Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avg neighbours = 16.96\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0 | train loss 1.6979e-01 | val loss 1.1223e-01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    1 | train loss 4.2205e-02 | val loss 7.2734e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    2 | train loss 2.1054e-02 | val loss 3.4279e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    3 | train loss 9.7247e-03 | val loss 1.0851e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    4 | train loss 4.1363e-03 | val loss 7.2410e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    5 | train loss 2.8743e-03 | val loss 7.0642e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    6 | train loss 2.2595e-03 | val loss 3.8075e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    7 | train loss 1.9452e-03 | val loss 3.3339e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    8 | train loss 1.4030e-03 | val loss 2.5998e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    9 | train loss 1.2531e-03 | val loss 2.1951e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   10 | train loss 1.0680e-03 | val loss 2.0312e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   11 | train loss 1.0462e-03 | val loss 2.1602e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   12 | train loss 1.1194e-03 | val loss 1.7872e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   13 | train loss 9.2078e-04 | val loss 1.5490e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   14 | train loss 1.3386e-03 | val loss 2.6256e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   15 | train loss 1.1220e-03 | val loss 1.8298e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   16 | train loss 1.1244e-03 | val loss 1.3552e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   17 | train loss 1.0588e-03 | val loss 1.3890e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   18 | train loss 1.0304e-03 | val loss 1.3742e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   19 | train loss 1.0797e-03 | val loss 1.7713e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   20 | train loss 1.5142e-03 | val loss 2.6627e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   21 | train loss 1.0494e-03 | val loss 1.4176e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   22 | train loss 1.2966e-03 | val loss 1.6298e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   23 | train loss 8.5647e-04 | val loss 1.1694e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   24 | train loss 8.8634e-04 | val loss 1.1175e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   25 | train loss 6.7053e-04 | val loss 8.2944e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   26 | train loss 6.8954e-04 | val loss 8.7361e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   27 | train loss 9.5956e-04 | val loss 8.0108e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   28 | train loss 1.3346e-03 | val loss 3.1894e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   29 | train loss 1.4704e-03 | val loss 1.0907e-03\n",
      "\n",
      "trained 30 epochs in 94 s -> runs/mdi_argon/best.pt\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.config import from_dict\n",
    "from xnn.common.data import AtomicDataset\n",
    "from xnn.common.train import Trainer\n",
    "\n",
    "# average number of neighbours (MACE message normalization), from a few frames\n",
    "probe = AtomicDataset(train_structs[:10], CUTOFF)\n",
    "graphs = [probe[i] for i in range(len(probe))]\n",
    "LAMBDA = float(sum(g.num_edges for g in graphs) / sum(g.num_nodes for g in graphs))\n",
    "print(f\"avg neighbours = {LAMBDA:.2f}\")\n",
    "\n",
    "core = from_dict({\n",
    "    \"model\": {\"name\": \"mace\", \"cutoff\": CUTOFF, \"n_features\": 32, \"n_interactions\": 2,\n",
    "              \"n_rbf\": 8, \"species\": SPECIES, \"max_ell\": 3, \"max_L\": 1, \"correlation\": 3,\n",
    "              \"hidden_irreps\": \"32x0e+32x1o\", \"MLP_irreps\": \"16x0e\",\n",
    "              \"avg_num_neighbors\": LAMBDA, \"atomic_energies\": [E0[z] for z in SPECIES]},\n",
    "    \"data\": {\"batch_size\": 10},\n",
    "    \"optim\": {\"lr\": 0.01, \"weight_decay\": 5e-7, \"epochs\": 30,\n",
    "              \"energy_weight\": 1.0, \"force_weight\": 100.0, \"scheduler\": \"plateau\"},\n",
    "    \"device\": DEVICE, \"seed\": 0, \"output_dir\": \"runs/mdi_argon\",\n",
    "})\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "idx = rng.permutation(len(train_structs))\n",
    "train_set = AtomicDataset([train_structs[i] for i in idx[:180]], CUTOFF)\n",
    "val_set = AtomicDataset([train_structs[i] for i in idx[180:]], CUTOFF)\n",
    "\n",
    "t0 = time.time()\n",
    "Trainer(core, train_set, val_set).fit()\n",
    "print(f\"\\ntrained {core.optim.epochs} epochs in {time.time()-t0:.0f} s \"\n",
    "      f\"-> {core.output_dir}/best.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b320db56",
   "metadata": {},
   "source": [
    "## 3. Reload the checkpoint and sanity-check on the test set\n",
    "\n",
    "We reload `best.pt` exactly the way any deployment consumer does (and the way\n",
    "`MDIEngine.from_checkpoint` does internally): rebuild with `build_model` from the stored\n",
    "config, wrap in `ForceStressOutput`, load the state dict. A quick pass over ten test\n",
    "frames confirms the 30-epoch model is a physically usable argon potential before we\n",
    "serve it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bb46d648",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:53:52.805695Z",
     "iopub.status.busy": "2026-08-04T20:53:52.805571Z",
     "iopub.status.idle": "2026-08-04T20:53:56.811623Z",
     "shell.execute_reply": "2026-08-04T20:53:56.810721Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 test frames: energy MAE 13.34 meV/atom | force RMSE 2.1 meV/A\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 340x340 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.set_default_dtype(torch.float64)   # deployment and dynamics in float64\n",
    "\n",
    "from ase import Atoms\n",
    "from xnn.common.models import build_model, ForceStressOutput\n",
    "from xnn.common.deploy import XNNCalculator\n",
    "\n",
    "ckpt = torch.load(\"runs/mdi_argon/best.pt\", map_location=\"cpu\", weights_only=False)\n",
    "model = ForceStressOutput(build_model(ckpt[\"cfg\"].model), compute_stress=True).double()\n",
    "model.load_state_dict(ckpt[\"model\"])\n",
    "calc = XNNCalculator(model, cutoff=ckpt[\"cfg\"].model.cutoff, device=DEVICE)\n",
    "\n",
    "de, df = [], []\n",
    "for s in test_structs[:10]:\n",
    "    at = Atoms(numbers=s[\"atomic_numbers\"], positions=s[\"pos\"], cell=s[\"cell\"], pbc=True)\n",
    "    at.calc = calc\n",
    "    de.append((at.get_potential_energy() - s[\"energy\"]) / len(at))\n",
    "    df.append((at.get_forces() - s[\"forces\"]).ravel())\n",
    "de, df = np.array(de), np.concatenate(df)\n",
    "print(f\"10 test frames: energy MAE {np.abs(de).mean()*1000:.2f} meV/atom | \"\n",
    "      f\"force RMSE {np.sqrt((df**2).mean())*1000:.1f} meV/A\")\n",
    "\n",
    "f_ref = np.concatenate([s[\"forces\"].ravel() for s in test_structs[:10]])\n",
    "f_mod = f_ref + df\n",
    "pick = np.random.default_rng(0).choice(f_ref.size, 2000, replace=False)\n",
    "lim = np.abs(f_ref[pick]).max() * 1.1\n",
    "fig, ax = plt.subplots(figsize=(3.4, 3.4))\n",
    "ax.plot([-lim, lim], [-lim, lim], \"--\", color=\"0.6\", lw=1)\n",
    "ax.plot(f_ref[pick], f_mod[pick], \".\", ms=3, alpha=0.35, color=\"#1f77b4\")\n",
    "ax.set_xlabel(\"reference force [eV/A]\"); ax.set_ylabel(\"model force [eV/A]\")\n",
    "ax.set_title(\"force parity, 10 test frames\"); ax.set_aspect(\"equal\")\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f53a958",
   "metadata": {},
   "source": [
    "## 4. Serve the checkpoint as an MDI engine\n",
    "\n",
    "The engine runs as a **separate process**, exactly as it would next to LAMMPS. The\n",
    "subprocess below is literally the `xnn mdi` console command:\n",
    "\n",
    "```bash\n",
    "xnn mdi --ckpt runs/mdi_argon/best.pt --device cuda --dtype float64 \\\n",
    "    -mdi \"-role ENGINE -name xnn -method TCP -port 8021 -hostname localhost\"\n",
    "```\n",
    "\n",
    "`--dtype float64` upcasts the float32-trained weights so the NVE integration below is\n",
    "not limited by single precision. Order matters for TCP: the **driver initializes first**\n",
    "(it owns the listening socket), then the engine is launched and connects.\n",
    "\n",
    "The driver side is the ~40-line class below. It works in ASE units (angstrom / eV) and\n",
    "converts to MDI atomic units (Bohr / Hartree) at the wire, mirroring what the engine\n",
    "does on its side. We convert with the engine's own public constants\n",
    "(`xnn.common.deploy.mdi_engine.BOHR_TO_ANGSTROM` / `HARTREE_TO_EV`, CODATA 2018) so the\n",
    "round trip is bit-clean; a driver with a different CODATA vintage (e.g. `ase.units`,\n",
    "CODATA 2014) would differ at the physically irrelevant 1e-8 relative level.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e52ff71b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:53:56.813294Z",
     "iopub.status.busy": "2026-08-04T20:53:56.813170Z",
     "iopub.status.idle": "2026-08-04T20:53:56.819062Z",
     "shell.execute_reply": "2026-08-04T20:53:56.818267Z"
    }
   },
   "outputs": [],
   "source": [
    "import mdi\n",
    "from xnn.common.deploy.mdi_engine import (   # the engine's exact wire constants\n",
    "    BOHR_TO_ANGSTROM as Bohr, HARTREE_TO_EV as Hartree)\n",
    "\n",
    "\n",
    "class MDIDriver:\n",
    "    \"\"\"Minimal MDI driver speaking ASE units (angstrom / eV) to any MDI engine.\"\"\"\n",
    "\n",
    "    def __init__(self, port):\n",
    "        mdi.MDI_Init(f\"-role DRIVER -name driver -method TCP -port {port}\")\n",
    "        self.comm = None\n",
    "        self.natoms = 0\n",
    "\n",
    "    def accept(self):\n",
    "        \"\"\"Block until an engine connects.\"\"\"\n",
    "        self.comm = mdi.MDI_Accept_Communicator()\n",
    "\n",
    "    def send_system(self, atomic_numbers, cell):\n",
    "        n = self.natoms = len(atomic_numbers)\n",
    "        mdi.MDI_Send_Command(\">NATOMS\", self.comm)\n",
    "        mdi.MDI_Send(n, 1, mdi.MDI_INT, self.comm)\n",
    "        mdi.MDI_Send_Command(\">ELEMENTS\", self.comm)\n",
    "        mdi.MDI_Send([int(z) for z in atomic_numbers], n, mdi.MDI_INT, self.comm)\n",
    "        mdi.MDI_Send_Command(\">CELL\", self.comm)\n",
    "        mdi.MDI_Send((np.asarray(cell) / Bohr).flatten(), 9, mdi.MDI_DOUBLE, self.comm)\n",
    "\n",
    "    def send_positions(self, pos):\n",
    "        mdi.MDI_Send_Command(\">COORDS\", self.comm)\n",
    "        mdi.MDI_Send((np.asarray(pos) / Bohr).flatten(), 3 * self.natoms,\n",
    "                     mdi.MDI_DOUBLE, self.comm)\n",
    "\n",
    "    def energy(self):\n",
    "        mdi.MDI_Send_Command(\"<ENERGY\", self.comm)\n",
    "        return mdi.MDI_Recv(1, mdi.MDI_DOUBLE, self.comm) * Hartree\n",
    "\n",
    "    def forces(self):\n",
    "        mdi.MDI_Send_Command(\"<FORCES\", self.comm)\n",
    "        f = mdi.MDI_Recv(3 * self.natoms, mdi.MDI_DOUBLE, self.comm)\n",
    "        return np.asarray(f).reshape(-1, 3) * (Hartree / Bohr)\n",
    "\n",
    "    def stress(self):\n",
    "        mdi.MDI_Send_Command(\"<STRESS\", self.comm)\n",
    "        s = mdi.MDI_Recv(9, mdi.MDI_DOUBLE, self.comm)\n",
    "        return np.asarray(s).reshape(3, 3) * (Hartree / Bohr**3)\n",
    "\n",
    "    def exit(self):\n",
    "        mdi.MDI_Send_Command(\"EXIT\", self.comm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1750a022",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:53:56.820452Z",
     "iopub.status.busy": "2026-08-04T20:53:56.820334Z",
     "iopub.status.idle": "2026-08-04T20:53:59.582700Z",
     "shell.execute_reply": "2026-08-04T20:53:59.582066Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "engine connected after 2.8 s (model load + TCP handshake)\n"
     ]
    }
   ],
   "source": [
    "PORT = 8021\n",
    "driver = MDIDriver(PORT)                 # 1. driver listens on the port\n",
    "\n",
    "engine_log = open(\"runs/mdi_argon/engine.log\", \"w\")\n",
    "engine = subprocess.Popen(               # 2. engine loads the checkpoint and connects\n",
    "    [sys.executable, \"-W\", \"ignore\", \"-m\", \"xnn.common.deploy.mdi_engine\",\n",
    "     \"--ckpt\", \"runs/mdi_argon/best.pt\", \"--device\", DEVICE, \"--dtype\", \"float64\",\n",
    "     \"-mdi\", f\"-role ENGINE -name xnn -method TCP -port {PORT} -hostname localhost\"],\n",
    "    stdout=engine_log, stderr=subprocess.STDOUT)\n",
    "\n",
    "t0 = time.time()\n",
    "driver.accept()                          # 3. blocks until the engine is up\n",
    "print(f\"engine connected after {time.time()-t0:.1f} s (model load + TCP handshake)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7cabd64",
   "metadata": {},
   "source": [
    "## 5. Validate: results over the wire $\\equiv$ direct evaluation\n",
    "\n",
    "One test frame is pushed through both paths: the MDI round trip\n",
    "(angstrom $\\rightarrow$ Bohr $\\rightarrow$ engine $\\rightarrow$ Hartree $\\rightarrow$ eV)\n",
    "and the in-process `XNNCalculator` from section 3. The two must agree to floating-point\n",
    "precision. The only convention difference is the stress sign: MDI uses the pressure-like\n",
    "sign, negated relative to the $\\sigma = V^{-1}\\,\\partial E/\\partial\\epsilon$ tensor\n",
    "that ASE reports.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c664de02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:53:59.584150Z",
     "iopub.status.busy": "2026-08-04T20:53:59.584043Z",
     "iopub.status.idle": "2026-08-04T20:54:00.560371Z",
     "shell.execute_reply": "2026-08-04T20:54:00.559458Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy  MDI -28.76609863 eV | direct -28.76609863 eV | diff 1.1e-14 eV\n",
      "forces  max |MDI - direct| = 2.0e-14 eV/A\n",
      "stress  max |MDI - direct| = 7.0e-18 eV/A^3 (after undoing the MDI sign convention)\n",
      "vs dataset reference: dE = +5.68 meV/atom, force RMSE = 1.3 meV/A\n"
     ]
    }
   ],
   "source": [
    "s0 = test_structs[0]\n",
    "driver.send_system(s0[\"atomic_numbers\"], s0[\"cell\"])\n",
    "driver.send_positions(s0[\"pos\"])\n",
    "e_mdi, f_mdi, st_mdi = driver.energy(), driver.forces(), driver.stress()\n",
    "\n",
    "at = Atoms(numbers=s0[\"atomic_numbers\"], positions=s0[\"pos\"], cell=s0[\"cell\"], pbc=True)\n",
    "at.calc = calc\n",
    "e_dir, f_dir, s_dir = at.get_potential_energy(), at.get_forces(), at.get_stress()\n",
    "\n",
    "s_mdi_voigt = -np.array([st_mdi[0, 0], st_mdi[1, 1], st_mdi[2, 2],\n",
    "                         st_mdi[1, 2], st_mdi[0, 2], st_mdi[0, 1]])\n",
    "\n",
    "print(f\"energy  MDI {e_mdi:.8f} eV | direct {e_dir:.8f} eV | \"\n",
    "      f\"diff {abs(e_mdi - e_dir):.1e} eV\")\n",
    "print(f\"forces  max |MDI - direct| = {np.abs(f_mdi - f_dir).max():.1e} eV/A\")\n",
    "print(f\"stress  max |MDI - direct| = {np.abs(s_mdi_voigt - s_dir).max():.1e} eV/A^3 \"\n",
    "      f\"(after undoing the MDI sign convention)\")\n",
    "print(f\"vs dataset reference: dE = {(e_mdi - s0['energy'])/len(at)*1000:+.2f} meV/atom, \"\n",
    "      f\"force RMSE = {np.sqrt(((f_mdi - s0['forces'])**2).mean())*1000:.1f} meV/A\")\n",
    "assert abs(e_mdi - e_dir) < 1e-8\n",
    "assert np.abs(f_mdi - f_dir).max() < 1e-9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df59d7f0",
   "metadata": {},
   "source": [
    "## 6. Use it: NVE molecular dynamics driven over MDI\n",
    "\n",
    "The driver now plays the role LAMMPS would play: it owns positions and velocities and\n",
    "integrates velocity Verlet, while **every force evaluation happens in the engine\n",
    "process**. Per step only `>COORDS` is re-sent; the engine keeps elements and cell from\n",
    "section 5 and lazily re-evaluates once per geometry, so the paired `<FORCES` + `<ENERGY`\n",
    "requests cost a single model call. Positions are sent unwrapped: the engine's neighbor\n",
    "list handles coordinates outside the box.\n",
    "\n",
    "Liquid argon at $T \\approx 85$ K with a 5 fs timestep (as in the\n",
    "`*_argon_density_md` notebooks), 240 steps = 1.2 ps. NVE has no thermostat, so the\n",
    "initial velocities are drawn at **twice** the target temperature: during the first\n",
    "~0.2 ps roughly half of the fresh kinetic energy repartitions into potential energy\n",
    "(equipartition), leaving the run fluctuating near the target.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d0c0639f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:54:00.563167Z",
     "iopub.status.busy": "2026-08-04T20:54:00.562957Z",
     "iopub.status.idle": "2026-08-04T20:54:56.299746Z",
     "shell.execute_reply": "2026-08-04T20:54:56.298400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "240 NVE steps (1.2 ps) in 55 s = 4.3 steps/s (1735 atom-steps/s)\n"
     ]
    }
   ],
   "source": [
    "from ase import units as u\n",
    "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, Stationary\n",
    "\n",
    "T_K, DT, N_STEPS = 85.0, 5 * u.fs, 240\n",
    "\n",
    "at = Atoms(numbers=s0[\"atomic_numbers\"], positions=s0[\"pos\"], cell=s0[\"cell\"], pbc=True)\n",
    "# 2 x T: half the kinetic energy flows into potential during NVE equilibration\n",
    "MaxwellBoltzmannDistribution(at, temperature_K=2 * T_K, rng=np.random.default_rng(0))\n",
    "Stationary(at)\n",
    "\n",
    "pos, vel = at.get_positions(), at.get_velocities()\n",
    "m, N = at.get_masses()[:, None], len(at)\n",
    "\n",
    "epot, ekin = np.empty(N_STEPS + 1), np.empty(N_STEPS + 1)\n",
    "driver.send_positions(pos)\n",
    "f = driver.forces()\n",
    "epot[0], ekin[0] = driver.energy(), 0.5 * (m * vel**2).sum()\n",
    "\n",
    "t0 = time.time()\n",
    "for step in range(1, N_STEPS + 1):\n",
    "    vel += 0.5 * DT * f / m\n",
    "    pos += DT * vel\n",
    "    driver.send_positions(pos)\n",
    "    f = driver.forces()\n",
    "    vel += 0.5 * DT * f / m\n",
    "    epot[step], ekin[step] = driver.energy(), 0.5 * (m * vel**2).sum()\n",
    "wall = time.time() - t0\n",
    "print(f\"{N_STEPS} NVE steps ({N_STEPS * DT / u.fs / 1000:.1f} ps) in {wall:.0f} s = \"\n",
    "      f\"{N_STEPS / wall:.1f} steps/s ({N * N_STEPS / wall:.0f} atom-steps/s)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "29dc7625",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:54:56.302384Z",
     "iopub.status.busy": "2026-08-04T20:54:56.302170Z",
     "iopub.status.idle": "2026-08-04T20:54:56.597521Z",
     "shell.execute_reply": "2026-08-04T20:54:56.596732Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x310 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max |E_tot(t) - E_tot(0)| = 0.009 meV/atom over 1.2 ps | <T> (last half) = 87.3 K\n"
     ]
    }
   ],
   "source": [
    "t_ps = np.arange(N_STEPS + 1) * DT / u.fs / 1000\n",
    "etot = epot + ekin\n",
    "temp = 2 * ekin / (3 * N * u.kB)\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(9, 3.1))\n",
    "ax[0].plot(t_ps, (etot - etot[0]) / N * 1000, color=\"#1f77b4\", lw=1.2)\n",
    "ax[0].axhline(0, color=\"0.75\", lw=0.8, ls=\"--\")\n",
    "ax[0].set_xlabel(\"time [ps]\")\n",
    "ax[0].set_ylabel(\"$\\\\Delta E_\\\\mathrm{tot}$ [meV/atom]\")\n",
    "ax[0].set_title(\"NVE energy conservation\")\n",
    "ax[1].plot(t_ps, temp, color=\"#1f77b4\", lw=1.2)\n",
    "ax[1].axhline(T_K, color=\"0.75\", lw=0.8, ls=\"--\")\n",
    "ax[1].set_xlabel(\"time [ps]\"); ax[1].set_ylabel(\"T [K]\")\n",
    "ax[1].set_title(\"instantaneous temperature\")\n",
    "plt.tight_layout(); plt.show()\n",
    "\n",
    "drift = np.abs(etot - etot[0]).max() / N * 1000\n",
    "print(f\"max |E_tot(t) - E_tot(0)| = {drift:.3f} meV/atom over {t_ps[-1]:.1f} ps | \"\n",
    "      f\"<T> (last half) = {temp[N_STEPS // 2:].mean():.1f} K\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bd7876",
   "metadata": {},
   "source": [
    "## 7. Shut the engine down\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e1247ece",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-08-04T20:54:56.600083Z",
     "iopub.status.busy": "2026-08-04T20:54:56.599917Z",
     "iopub.status.idle": "2026-08-04T20:54:57.118680Z",
     "shell.execute_reply": "2026-08-04T20:54:57.117959Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "engine exited with code 0\n",
      "\n",
      "--- runs/mdi_argon/engine.log (tail) ---\n",
      "INFO:__main__:MDI connection established\n",
      "INFO:__main__:received 400 atoms, elements [18]\n",
      "INFO:__main__:step 100: avg 141.9 ms/step\n",
      "INFO:__main__:step 200: avg 108.5 ms/step\n",
      "INFO:__main__:engine finished: 242 calculations, avg 102.4 ms/step\n"
     ]
    }
   ],
   "source": [
    "driver.exit()\n",
    "engine.wait(timeout=60)\n",
    "engine_log.close()\n",
    "print(f\"engine exited with code {engine.returncode}\\n\")\n",
    "print(\"--- runs/mdi_argon/engine.log (tail) ---\")\n",
    "print(\"\\n\".join(open(\"runs/mdi_argon/engine.log\").read().splitlines()[-5:]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f44eee3",
   "metadata": {},
   "source": [
    "## Where to go from here\n",
    "\n",
    "**Drive it from LAMMPS instead of Python.** The engine side does not change; only the\n",
    "launch method does (MPI instead of TCP, `mpi4py` required):\n",
    "\n",
    "```bash\n",
    "mpirun -np 1 xnn mdi --ckpt runs/mdi_argon/best.pt --device cuda:0 --dtype float64 \\\n",
    "        -mdi \"-role ENGINE -name xnn -method MPI\" \\\n",
    "    : -np 4 lmp -mdi \"-role DRIVER -name LAMMPS -method MPI\" -in in.argon\n",
    "```\n",
    "\n",
    "with `fix mdi/qm` (or the `mdi` fix family) on the LAMMPS side. The same applies to any\n",
    "other MDI driver, e.g. SEAMM's LAMMPS step.\n",
    "\n",
    "**Serve a different model.** Nothing here is MACE specific: point `--ckpt` at any\n",
    "`best.pt` produced by the xnn `Trainer` (NequIP, Allegro, CACE, SchNet, ANI, PhysNet,\n",
    "BAMBOO, with or without the LES long-range wrapper) and the engine rebuilds it from the\n",
    "stored config and serves it through the identical protocol.\n",
    "\n",
    "**Embed it.** `MDIEngine` is a plain class\n",
    "(`from xnn.common.deploy import MDIEngine`); `MDIEngine.from_checkpoint(path)` plus\n",
    "`engine.run(mdi_options)` reproduces the CLI inside your own launcher, and\n",
    "`MDIEngine(model, cutoff)` accepts any in-memory model that follows the `AtomicGraph`\n",
    "contract.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}