{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "45dec57d",
   "metadata": {},
   "source": [
    "# Argon MD with PhysNet: `xnn` NPT density + lock-step NVE against the original\n",
    "\n",
    "The sharpest test of a potential is *simulation*. This notebook trains the\n",
    "`xnn` PhysNet on the Argon data and\n",
    "\n",
    "* runs **NPT MD** at 85 K / 1 bar to recover the liquid-argon **density**\n",
    "  (~1.41 g/cm³) through the standard xnn ASE deployment, and\n",
    "* validates the MD *forces* against the **original TF1 PhysNet** in a\n",
    "  **lock-step NVE run**: both codes propagate the *same* trajectory from the\n",
    "  same initial conditions, and we track how the two force engines agree\n",
    "  step by step.\n",
    "\n",
    "(The original TF implementation exposes no stress, so the NPT track is\n",
    "xnn-only; the lock-step NVE comparison plays the role of the \"same potential,\n",
    "two MD engines\" track of the other model series.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7087b079",
   "metadata": {},
   "source": [
    "## 0. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "de06d555",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:58:08.716046Z",
     "iopub.status.busy": "2026-07-20T04:58:08.715892Z",
     "iopub.status.idle": "2026-07-20T04:58:12.963584Z",
     "shell.execute_reply": "2026-07-20T04:58:12.962629Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: 0.1.0 | tensorflow: 2.21.0 | torch: 2.12.1+cpu\n"
     ]
    }
   ],
   "source": [
    "# silence the expected warnings / TF chatter\n",
    "import logging, os, warnings\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
    "logging.disable(logging.WARNING)\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import subprocess, sys, tempfile\n",
    "import numpy as np\n",
    "\n",
    "# ---- the original TF1 PhysNet (cloned on demand) ----\n",
    "UPSTREAM = os.environ.get(\"PHYSNET_UPSTREAM_PATH\",\n",
    "                          os.path.join(tempfile.gettempdir(), \"physnet-upstream\"))\n",
    "if not os.path.isdir(UPSTREAM):\n",
    "    subprocess.run([\"git\", \"clone\", \"--depth\", \"1\",\n",
    "                    \"https://github.com/MMunibas/PhysNet\", UPSTREAM], check=True)\n",
    "\n",
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_eager_execution()\n",
    "tf.get_logger().setLevel(\"ERROR\")\n",
    "sys.modules[\"tensorflow\"] = tf          # upstream modules do `import tensorflow as tf`\n",
    "# upstream applies dropout with keep_prob = 1.0 (identity); its float32\n",
    "# placeholder trips TF2's dtype check in float64 graphs\n",
    "tf.nn.dropout = lambda x, keep_prob=None, **kw: x\n",
    "\n",
    "sys.path.insert(0, UPSTREAM)\n",
    "import neural_network.NeuralNetwork as _nnmod\n",
    "from neural_network.NeuralNetwork import NeuralNetwork\n",
    "\n",
    "import time\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import ase.io\n",
    "import ase.units as u\n",
    "\n",
    "torch.set_default_dtype(torch.float32)\n",
    "torch.manual_seed(0)\n",
    "import xnn\n",
    "DATA = \"../../../datasets/argon_md\"\n",
    "print(\"xnn:\", xnn.__version__, \"| tensorflow:\", tf.__version__, \"| torch:\", torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "702c5e44",
   "metadata": {},
   "source": [
    "## 1. Data and training (same recipe as notebook 02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "982ed0ef",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:58:12.965690Z",
     "iopub.status.busy": "2026-07-20T04:58:12.965568Z",
     "iopub.status.idle": "2026-07-20T05:09:03.923686Z",
     "shell.execute_reply": "2026-07-20T05:09:03.922773Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0 | train loss 4.7140e-01 | val loss 2.5822e-01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    1 | train loss 1.8560e-01 | val loss 3.7692e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    2 | train loss 6.3110e-02 | val loss 3.5621e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    3 | train loss 5.0543e-02 | val loss 2.4506e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    4 | train loss 4.7849e-02 | val loss 1.9057e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    5 | train loss 3.8664e-02 | val loss 1.9313e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    6 | train loss 3.0876e-02 | val loss 1.0408e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    7 | train loss 2.3626e-02 | val loss 9.0636e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    8 | train loss 2.0186e-02 | val loss 1.2919e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    9 | train loss 2.5467e-02 | val loss 5.3755e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   10 | train loss 2.1892e-02 | val loss 5.4260e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   11 | train loss 1.1486e-02 | val loss 3.1817e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   12 | train loss 6.9648e-03 | val loss 2.1769e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   13 | train loss 3.0863e-03 | val loss 1.6135e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   14 | train loss 2.8454e-03 | val loss 1.9666e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   15 | train loss 2.3501e-03 | val loss 2.3093e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   16 | train loss 2.6336e-03 | val loss 1.6540e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   17 | train loss 2.4391e-03 | val loss 9.6281e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   18 | train loss 1.6867e-03 | val loss 1.2776e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   19 | train loss 2.7070e-03 | val loss 2.2435e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   20 | train loss 2.2711e-03 | val loss 1.6506e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   21 | train loss 2.2557e-03 | val loss 6.5485e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   22 | train loss 1.5929e-03 | val loss 7.7035e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   23 | train loss 1.2312e-03 | val loss 7.0060e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   24 | train loss 1.2285e-03 | val loss 8.0826e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   25 | train loss 1.0848e-03 | val loss 6.6145e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   26 | train loss 9.8990e-04 | val loss 5.0774e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   27 | train loss 1.0486e-03 | val loss 5.8040e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   28 | train loss 9.7981e-04 | val loss 5.1109e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   29 | train loss 1.3062e-03 | val loss 5.8546e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   30 | train loss 9.6341e-04 | val loss 6.2076e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   31 | train loss 1.0153e-03 | val loss 5.6034e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   32 | train loss 8.8316e-04 | val loss 4.5292e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   33 | train loss 8.3077e-04 | val loss 4.6272e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   34 | train loss 8.1185e-04 | val loss 4.7252e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   35 | train loss 8.5183e-04 | val loss 6.1312e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   36 | train loss 1.1504e-03 | val loss 4.3789e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   37 | train loss 9.2245e-04 | val loss 3.9981e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   38 | train loss 8.0201e-04 | val loss 5.2919e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   39 | train loss 8.6198e-04 | val loss 4.3481e-04\n",
      "xnn PhysNet trained 40 epochs in 648 s\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import AtomicDataset, load_dataset\n",
    "from xnn.common.config import from_dict\n",
    "from xnn.common.models import build_model, ForceStressOutput\n",
    "from xnn.common.train import Trainer\n",
    "from torch.utils.data import Subset\n",
    "\n",
    "SR_CUT, LR_CUT = 6.0, 9.0\n",
    "F_DIM, K, NB, NRA, NRI, NRO = 64, 32, 3, 2, 3, 1\n",
    "EW, FW, LR, BS, EPOCHS = 1.0, 100.0, 1e-3, 10, 40\n",
    "\n",
    "E0 = {18: 0.0}   # argon isolated-atom reference energy\n",
    "train_structs = load_dataset(\"argon_md\", split=\"train\")\n",
    "ds_all = AtomicDataset(train_structs, LR_CUT)\n",
    "train_structs = [s for i, s in enumerate(train_structs) if ds_all[i].num_edges > 0]\n",
    "xnn_train = AtomicDataset(train_structs, LR_CUT)\n",
    "g = torch.Generator().manual_seed(0)\n",
    "perm = torch.randperm(len(train_structs), generator=g).tolist()\n",
    "n_val = max(1, int(0.1 * len(train_structs)))\n",
    "val_idx, train_idx = perm[:n_val], perm[n_val:]\n",
    "\n",
    "core = from_dict({\n",
    "    \"model\": {\"name\": \"physnet\", \"cutoff\": SR_CUT, \"n_features\": F_DIM,\n",
    "              \"n_rbf\": K, \"n_interactions\": NB, \"lr_cutoff\": LR_CUT,\n",
    "              \"num_residual_atomic\": NRA, \"num_residual_interaction\": NRI,\n",
    "              \"num_residual_output\": NRO, \"species\": [18],\n",
    "              \"atomic_energies\": [E0[18]]},\n",
    "    \"data\": {\"batch_size\": BS},\n",
    "    \"optim\": {\"lr\": LR, \"epochs\": EPOCHS, \"energy_weight\": EW, \"force_weight\": FW,\n",
    "              \"scheduler\": \"plateau\"},\n",
    "    \"device\": \"cpu\", \"seed\": 0, \"output_dir\": \"runs/argon_md\",\n",
    "})\n",
    "t0 = time.time()\n",
    "trainer = Trainer(core, Subset(xnn_train, train_idx), Subset(xnn_train, val_idx))\n",
    "trainer.fit()\n",
    "print(f\"xnn PhysNet trained {EPOCHS} epochs in {time.time()-t0:.0f} s\")\n",
    "model = trainer.model.model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b712c58",
   "metadata": {},
   "source": [
    "## 2. NPT density: `xnn` PhysNet through ASE (float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cf6a722c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:09:03.925328Z",
     "iopub.status.busy": "2026-07-20T05:09:03.925203Z",
     "iopub.status.idle": "2026-07-20T05:12:38.786642Z",
     "shell.execute_reply": "2026-07-20T05:12:38.785726Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NPT: 1000 steps in 214 s | rho_eq = 1.4122 ± 0.007 g/cm3 (exp ~1.41)\n"
     ]
    }
   ],
   "source": [
    "torch.set_default_dtype(torch.float64)\n",
    "from ase import Atoms\n",
    "from ase.md.nptberendsen import NPTBerendsen\n",
    "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, Stationary\n",
    "from xnn.common.deploy import XNNCalculator\n",
    "\n",
    "model64 = model.double().eval()\n",
    "md_model = ForceStressOutput(model64, compute_forces=True, compute_stress=True)\n",
    "\n",
    "T_K, P_BAR, DT = 85.0, 1.0, 5 * u.fs\n",
    "N_EQUIL, N_PROD = 300, 700\n",
    "AMU_A3_TO_G_CM3 = 1.6605390666\n",
    "RHO_EXP = 1.41\n",
    "a0 = train_structs[0]\n",
    "\n",
    "def density(atoms):\n",
    "    return atoms.get_masses().sum() / atoms.get_volume() * AMU_A3_TO_G_CM3\n",
    "\n",
    "at = Atoms(numbers=a0[\"atomic_numbers\"], positions=a0[\"pos\"], cell=a0[\"cell\"], pbc=True)\n",
    "at.calc = XNNCalculator(md_model, cutoff=model64.cutoff)\n",
    "MaxwellBoltzmannDistribution(at, temperature_K=T_K, rng=np.random.default_rng(0)); Stationary(at)\n",
    "dyn = NPTBerendsen(at, timestep=DT, temperature_K=T_K, pressure_au=P_BAR * u.bar,\n",
    "                   taut=100 * u.fs, taup=1000 * u.fs, compressibility_au=2e-4 / u.bar)\n",
    "rho = np.empty(N_EQUIL + N_PROD)\n",
    "t0 = time.time()\n",
    "for k in range(N_EQUIL + N_PROD):\n",
    "    dyn.run(1); rho[k] = density(at)\n",
    "print(f\"NPT: {N_EQUIL+N_PROD} steps in {time.time()-t0:.0f} s | \"\n",
    "      f\"rho_eq = {rho[N_EQUIL:].mean():.4f} ± {rho[N_EQUIL:].std():.3f} g/cm3 \"\n",
    "      f\"(exp ~{RHO_EXP})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "838e14c8",
   "metadata": {},
   "source": [
    "## 3. Lock-step NVE: the trained xnn weights through both codes\n",
    "\n",
    "The trained weights are transplanted **into the original TF graph** (the\n",
    "reverse of the usual direction), an ASE calculator is wrapped around the TF1\n",
    "session, and both engines propagate velocity-Verlet NVE from identical initial\n",
    "conditions. With the same potential, positions/energies should track each other\n",
    "at float32 round-off (slow chaotic divergence is expected in any two float32\n",
    "force engines)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "af86d592",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:12:38.788311Z",
     "iopub.status.busy": "2026-07-20T05:12:38.788199Z",
     "iopub.status.idle": "2026-07-20T05:13:15.270320Z",
     "shell.execute_reply": "2026-07-20T05:13:15.269506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 x 200 NVE steps in 23 s\n",
      "energy drift over 400 fs:  xnn 0.002 | original 0.002 meV/atom\n",
      "max |pos diff|: step 1: 1.29e-09 A | step 50: 4.50e-05 A | step 200: 2.14e-05 A (float32 round-off, chaotic growth)\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import build_neighbor_list\n",
    "from ase.calculators.calculator import Calculator, all_changes\n",
    "from ase.md.verlet import VelocityVerlet\n",
    "\n",
    "# --- TF graph (float32) + reverse transplant of the trained torch weights ---\n",
    "tf.reset_default_graph()\n",
    "tf_nn = NeuralNetwork(F=F_DIM, K=K, sr_cut=SR_CUT, lr_cut=LR_CUT, num_blocks=NB,\n",
    "                      num_residual_atomic=NRA, num_residual_interaction=NRI,\n",
    "                      num_residual_output=NRO, use_electrostatic=True,\n",
    "                      use_dispersion=True, scope=\"nn\", seed=0)\n",
    "ph = {\"Z\": tf.placeholder(tf.int32, [None]), \"R\": tf.placeholder(tf.float32, [None, 3]),\n",
    "      \"idx_i\": tf.placeholder(tf.int32, [None]), \"idx_j\": tf.placeholder(tf.int32, [None]),\n",
    "      \"offsets\": tf.placeholder(tf.float32, [None, 3])}\n",
    "E_op = tf_nn.energy(ph[\"Z\"], ph[\"R\"], ph[\"idx_i\"], ph[\"idx_j\"], offsets=ph[\"offsets\"])\n",
    "F_op = -tf.gradients(tf.reduce_sum(E_op), ph[\"R\"])[0]\n",
    "sess = tf.Session()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "def torch_to_tf(x, num_blocks, scope=\"nn\"):\n",
    "    \"\"\"Assign every xnn PhysNet weight into the TF1 graph.\"\"\"\n",
    "    named = dict(x.named_parameters()); named.update(dict(x.named_buffers()))\n",
    "    def put(vname, key):\n",
    "        v = [v for v in tf.global_variables() if v.name == f\"{scope}/{vname}:0\"][0]\n",
    "        sess.run(v.assign(named[key].detach().cpu().numpy()))\n",
    "    put(\"embeddings\", \"embeddings\")\n",
    "    put(\"rbf_layer/centers\", \"rbf_layer.centers\"); put(\"rbf_layer/widths\", \"rbf_layer.widths\")\n",
    "    for t in [\"Eshift\", \"Escale\", \"Qshift\", \"Qscale\"]: put(t, t)\n",
    "    for t in [\"s6\", \"s8\", \"a1\", \"a2\"]: put(t, f\"_{t}\")\n",
    "    for b in range(num_blocks):\n",
    "        sc, pb = f\"interaction_block{b}\", f\"interaction_blocks.{b}\"\n",
    "        put(f\"{sc}/interaction_layer/k2f/W\", f\"{pb}.interaction.k2f.weight\")\n",
    "        for nm in [\"dense_i\", \"dense_j\", \"dense\"]:\n",
    "            put(f\"{sc}/interaction_layer/{nm}/W\", f\"{pb}.interaction.{nm}.weight\")\n",
    "            put(f\"{sc}/interaction_layer/{nm}/b\", f\"{pb}.interaction.{nm}.bias\")\n",
    "        put(f\"{sc}/interaction_layer/u\", f\"{pb}.interaction.u\")\n",
    "        for k in range(NRI):\n",
    "            for part in [\"dense\", \"residual\"]:\n",
    "                put(f\"{sc}/interaction_layer/residual_layer{k}/{part}/W\",\n",
    "                    f\"{pb}.interaction.residuals.{k}.{part}.weight\")\n",
    "                put(f\"{sc}/interaction_layer/residual_layer{k}/{part}/b\",\n",
    "                    f\"{pb}.interaction.residuals.{k}.{part}.bias\")\n",
    "        for k in range(NRA):\n",
    "            for part in [\"dense\", \"residual\"]:\n",
    "                put(f\"{sc}/residual_layer{k}/{part}/W\", f\"{pb}.residuals.{k}.{part}.weight\")\n",
    "                put(f\"{sc}/residual_layer{k}/{part}/b\", f\"{pb}.residuals.{k}.{part}.bias\")\n",
    "        for k in range(NRO):\n",
    "            for part in [\"dense\", \"residual\"]:\n",
    "                put(f\"output_block{b}/residual_layer{k}/{part}/W\",\n",
    "                    f\"output_blocks.{b}.residuals.{k}.{part}.weight\")\n",
    "                put(f\"output_block{b}/residual_layer{k}/{part}/b\",\n",
    "                    f\"output_blocks.{b}.residuals.{k}.{part}.bias\")\n",
    "        put(f\"output_block{b}/dense_layer/W\", f\"output_blocks.{b}.dense.weight\")\n",
    "\n",
    "torch_to_tf(model64, NB)\n",
    "\n",
    "class PhysNetTFCalculator(Calculator):\n",
    "    \"\"\"Minimal ASE calculator around the original TF1 PhysNet session.\"\"\"\n",
    "    implemented_properties = [\"energy\", \"forces\"]\n",
    "    def __init__(self, cutoff, **kw):\n",
    "        super().__init__(**kw); self.cutoff = cutoff\n",
    "    def calculate(self, atoms=None, properties=(\"energy\",), system_changes=all_changes):\n",
    "        super().calculate(atoms, properties, system_changes)\n",
    "        pos = torch.tensor(atoms.get_positions())\n",
    "        cell = torch.tensor(atoms.cell.array)\n",
    "        ei, shifts = build_neighbor_list(pos, self.cutoff, cell=cell,\n",
    "                                         pbc=torch.tensor([True] * 3))\n",
    "        order = np.argsort(ei[1].numpy(), kind=\"stable\")\n",
    "        # TF computes Dij = |R[i] - (R[j] + offset)|, while the xnn edge vector\n",
    "        # is r_i - r_j + shift@cell, so the offset TF needs is the NEGATED cell\n",
    "        # shift; without the minus sign every boundary-crossing pair lands far\n",
    "        # outside the cutoff and the TF engine loses all cross-boundary forces\n",
    "        offsets = -(shifts.to(cell.dtype) @ cell).numpy()[order]\n",
    "        feed = {ph[\"Z\"]: atoms.numbers, ph[\"R\"]: atoms.get_positions().astype(np.float32),\n",
    "                ph[\"idx_i\"]: ei[1].numpy()[order], ph[\"idx_j\"]: ei[0].numpy()[order],\n",
    "                ph[\"offsets\"]: offsets.astype(np.float32)}\n",
    "        E, F = sess.run([E_op, F_op], feed)\n",
    "        self.results[\"energy\"] = float(np.squeeze(E))\n",
    "        self.results[\"forces\"] = np.asarray(F, dtype=np.float64)\n",
    "\n",
    "# float32 xnn side for a like-for-like comparison; the default dtype is still\n",
    "# float64 from the NPT section (build_model and the calculator's graphs follow\n",
    "# it, and load_state_dict casts to the parameter dtype), so switch it back first\n",
    "torch.set_default_dtype(torch.float32)\n",
    "model32 = build_model(core.model)\n",
    "model32.load_state_dict({k: v.float() for k, v in model64.state_dict().items()})\n",
    "xnn32 = ForceStressOutput(model32.eval())\n",
    "\n",
    "def run_nve(calc, n_steps=200):\n",
    "    at = Atoms(numbers=a0[\"atomic_numbers\"], positions=a0[\"pos\"], cell=a0[\"cell\"], pbc=True)\n",
    "    at.calc = calc\n",
    "    MaxwellBoltzmannDistribution(at, temperature_K=T_K, rng=np.random.default_rng(1)); Stationary(at)\n",
    "    dyn = VelocityVerlet(at, timestep=2 * u.fs)\n",
    "    E_pot, E_tot, traj = [], [], []\n",
    "    for _ in range(n_steps):\n",
    "        dyn.run(1)\n",
    "        E_pot.append(at.get_potential_energy())\n",
    "        E_tot.append(at.get_potential_energy() + at.get_kinetic_energy())\n",
    "        traj.append(at.get_positions().copy())\n",
    "    return np.array(E_pot), np.array(E_tot), traj\n",
    "\n",
    "t0 = time.time()\n",
    "Ex, Etx, trx = run_nve(XNNCalculator(xnn32, cutoff=model32.cutoff))\n",
    "Et, Ett, trt = run_nve(PhysNetTFCalculator(cutoff=model32.cutoff))\n",
    "print(f\"2 x 200 NVE steps in {time.time()-t0:.0f} s\")\n",
    "drift_x = abs(Etx[-1] - Etx[0]) / len(a0[\"atomic_numbers\"]) * 1000\n",
    "drift_t = abs(Ett[-1] - Ett[0]) / len(a0[\"atomic_numbers\"]) * 1000\n",
    "dpos = [np.abs(a - b).max() for a, b in zip(trx, trt)]\n",
    "print(f\"energy drift over 400 fs:  xnn {drift_x:.3f} | original {drift_t:.3f} meV/atom\")\n",
    "print(f\"max |pos diff|: step 1: {dpos[0]:.2e} A | step 50: {dpos[49]:.2e} A | \"\n",
    "      f\"step 200: {dpos[-1]:.2e} A (float32 round-off, chaotic growth)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5043bd94",
   "metadata": {},
   "source": [
    "## 4. Overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7564a45f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:13:15.272299Z",
     "iopub.status.busy": "2026-07-20T05:13:15.272185Z",
     "iopub.status.idle": "2026-07-20T05:13:15.936300Z",
     "shell.execute_reply": "2026-07-20T05:13:15.935449Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x420 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_ps = np.arange(N_EQUIL + N_PROD) * (DT / u.fs) / 1000.0\n",
    "fig, ax = plt.subplots(1, 2, figsize=(12, 4.2))\n",
    "ax[0].plot(t_ps, rho, lw=1)\n",
    "ax[0].axvline(N_EQUIL * (DT / u.fs) / 1000.0, color=\"gray\", ls=\":\", lw=1)\n",
    "ax[0].axhline(RHO_EXP, color=\"k\", ls=\"-.\", lw=1, label=f\"exp ≈ {RHO_EXP}\")\n",
    "ax[0].set_xlabel(\"time [ps]\"); ax[0].set_ylabel(\"density [g/cm³]\")\n",
    "ax[0].set_title(f\"xnn PhysNet NPT: ρ = {rho[N_EQUIL:].mean():.3f} g/cm³\"); ax[0].legend()\n",
    "\n",
    "ts = np.arange(1, 201) * 2 / 1000.0\n",
    "ax[1].plot(ts, Ex, label=\"xnn (PyTorch)\", lw=1)\n",
    "ax[1].plot(ts, Et, \"--\", label=\"original (TF1)\", lw=1)\n",
    "ax[1].set_xlabel(\"time [ps]\"); ax[1].set_ylabel(\"potential energy [eV]\")\n",
    "ax[1].set_title(\"lock-step NVE, same trained weights\"); ax[1].legend()\n",
    "plt.tight_layout(); plt.savefig(\"argon_density_md.png\", dpi=120); plt.show()\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e693fa18",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "* The trained xnn PhysNet runs stable **NPT MD** through the standard xnn\n",
    "  ASE deployment and lands near the experimental liquid-argon density.\n",
    "* With the trained weights transplanted back into the **original TF1 graph**,\n",
    "  a lock-step NVE run shows both force engines propagating the same\n",
    "  trajectory (float32 round-off at early times, the usual chaotic divergence\n",
    "  later) with comparable energy conservation.\n",
    "\n",
    "Same conclusions, same pipeline: PhysNet joins the xnn family as a faithful,\n",
    "pure-PyTorch port of a TensorFlow-era reference code, with charges, dipoles,\n",
    "electrostatics and D3 dispersion intact."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-tf (3.13.12)",
   "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
}