test(cc): regression test for atomic_virial fail-fast guard

Closes the coverage gap left by commit c80db58: the
'atomic && !do_atomic_virial' throw branch in DeepPotPTExpt::compute
was not exercised by any existing test.

Approach:

* gen_sea.py: after exporting deeppot_sea.pt2 with do_atomic_virial=
  True, copy the archive to deeppot_sea_no_atomic_virial.pt2 and
  patch its metadata.json so do_atomic_virial=False.  Cheap (ZIP
  rewrite, no AOTInductor recompile — adds <1s to gen time).  Use
  ZIP_STORED to match the format expected by the C++ read_zip_entry
  in commonPTExpt.h.

* test_deeppot_ptexpt.cc: new TYPED_TEST cpu_atomic_throws_when_
  disabled — load the patched .pt2, call compute() with atomic=true,
  expect deepmd_exception.  Also verify atomic=false on the same
  model still works (sanity check that the guard fires only when
  actually requested).

Covers the most-impactful gap from PR #5407's review: the change in
.pt2 default (do_atomic_virial off) made this code path the typical
failure mode for users who'd previously been getting per-atom virial
"for free".  Without this test, regressions in the throw or in the
metadata round-trip would slip through.

Author: Han Wang

source/api_cc/tests/test_deeppot_ptexpt.cc

@@ -581,6 +581,52 @@ TYPED_TEST(TestInferDeepPotAPtExpt, print_summary) {
   dp.print_summary("");
 }
 
+// Regression test for the fail-fast guard hoisted in commit c80db58d.
+// `deeppot_sea_no_atomic_virial.pt2` is a copy of deeppot_sea.pt2 with
+// the do_atomic_virial=false flag patched into its metadata.json.
+// Calling compute() with atomic=true on this model must throw before
+// any tensors are allocated.
+TYPED_TEST(TestInferDeepPotAPtExpt, cpu_atomic_throws_when_disabled) {
+  using VALUETYPE = TypeParam;
+  deepmd::DeepPot dp_no_av;
+  ASSERT_NO_THROW(
+      dp_no_av.init("../../tests/infer/deeppot_sea_no_atomic_virial.pt2"));
+
+  std::vector<VALUETYPE>& coord = this->coord;
+  std::vector<int>& atype = this->atype;
+  std::vector<VALUETYPE>& box = this->box;
+  int& natoms = this->natoms;
+
+  // Build an LMP-style nlist so we exercise the nlist-overload of
+  // compute(); the no-nlist overload has the same guard but is
+  // covered by symmetry.
+  float rc = dp_no_av.cutoff();
+  int nloc = coord.size() / 3;
+  std::vector<VALUETYPE> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int> > nlist_data;
+  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc);
+  int nall = coord_cpy.size() / 3;
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
+  convert_nlist(inlist, nlist_data);
+
+  double ener;
+  std::vector<VALUETYPE> force(nall * 3, 0.0), virial(9, 0.0), atom_ener,
+      atom_vir;
+  // atomic=true => guard must trip and throw deepmd_exception.
+  EXPECT_THROW(
+      dp_no_av.compute(ener, force, virial, atom_ener, atom_vir, coord_cpy,
+                       atype_cpy, box, nall - nloc, inlist, 0),
+      deepmd::deepmd_exception);
+  // atomic=false on the same model must work normally (sanity check
+  // that the guard fires only when actually requested).
+  EXPECT_NO_THROW(dp_no_av.compute(ener, force, virial, coord_cpy, atype_cpy,
+                                   box, nall - nloc, inlist, 0));
+}
+
 template <class VALUETYPE>
 class TestInferDeepPotAPtExptNoPbc : public ::testing::Test {
  protected:

source/tests/infer/gen_sea.py

@@ -59,8 +59,50 @@ def main():
     print(f"Exporting to {pt2_path} ...")  # noqa: T201
     deserialize_to_file(pt2_path, data, do_atomic_virial=True)
 
+    # Produce a variant for regression-testing the C++ "atomic &&
+    # !do_atomic_virial" throw path by copying the .pt2 archive and
+    # flipping the do_atomic_virial flag in its metadata.json — much
+    # cheaper than running a second AOTInductor compile.  The compiled
+    # graph itself supports atomic virial; only the C++ guard differs.
+    import shutil
+
+    pt2_no_aviral = os.path.join(base_dir, "deeppot_sea_no_atomic_virial.pt2")
+    print(f"Patching to {pt2_no_aviral} ...")  # noqa: T201
+    shutil.copyfile(pt2_path, pt2_no_aviral)
+    _patch_no_atomic_virial(pt2_no_aviral)
+
     print("Done!")  # noqa: T201
 
 
+def _patch_no_atomic_virial(pt2_path: str) -> None:
+    """Flip do_atomic_virial=False in the metadata.json of a .pt2 archive.
+
+    The .pt2 is a ZIP archive; the metadata blob lives at
+    ``extra/metadata.json``.  We rewrite the archive with that one entry
+    replaced and all other entries preserved verbatim.
+    """
+    import json
+    import zipfile
+
+    metadata_name = "extra/metadata.json"
+    tmp_path = pt2_path + ".tmp"
+    # PyTorch .pt2 archives use ZIP_STORED (uncompressed) so that the C++
+    # reader (read_zip_entry in commonPTExpt.h) and torch's mmap-based
+    # tensor loader can read entries without decompression.  Preserve
+    # that on rewrite — using ZIP_DEFLATED would yield bytes the C++
+    # reader treats as raw, resulting in JSON parse errors.
+    with zipfile.ZipFile(pt2_path, "r") as src:
+        names = src.namelist()
+        meta = json.loads(src.read(metadata_name).decode("utf-8"))
+        meta["do_atomic_virial"] = False
+        with zipfile.ZipFile(tmp_path, "w", zipfile.ZIP_STORED) as dst:
+            for name in names:
+                if name == metadata_name:
+                    dst.writestr(name, json.dumps(meta))
+                else:
+                    dst.writestr(name, src.read(name))
+    os.replace(tmp_path, pt2_path)
+
+
 if __name__ == "__main__":
     main()