fix(model): register magnetic cell derivatives correctly (#5836)

## Summary

- register magnetic cell derivatives in the cell-derivative bucket
instead of the coordinate bucket
- generate the corresponding reduced magnetic virial definition
- add the optional DeepEval backend name mapping so spin evaluation
request construction remains valid
- extend output-definition tests for bucket membership, shape, category,
reduction, and atomic metadata

## Why existing tests missed this

The existing comprehensive output-definition test only compared the
flattened ModelOutputDef key set. The magnetic cell derivative appeared
in that flattened set even while stored in the wrong internal bucket, so
the test passed. It did not inspect keys_derv_c versus keys_derv_r and
did not expect the reduced magnetic virial definition. The new
regression asserts both internal bucket membership and the derived
reduced definition.

## Validation

- ruff format .
- ruff check .
- complete output-definition test file plus TensorFlow C++ core
regression: 17 passed
- verified the new reduced output has a DeepEval backend mapping;
unsupported backend values keep the existing optional-output NaN/removal
behavior

An additional pt_expt spin-test collection attempt hit an environment
Triton plugin import segmentation fault before test collection; the
focused pure-metadata and core tests are unaffected.

Closes #5632

Coding agent: Codex
Codex version: codex-cli 0.144.4
Model: gpt-5.6-sol
Reasoning effort: xhigh

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Corrected magnetic cell-derivative outputs so they are registered and
reduced through the appropriate cell-based pathway.
* Added support for magnetic cell-derivative output mapping to backend
virial results.
* Ensured magnetic derivative outputs have the correct reduced shape and
classification.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: njzjz-bot <njzjz.bot@gmail.com>

Author: njzjz-bot

deepmd/dpmodel/output_def.py

@@ -512,7 +512,7 @@ def do_derivative(
                 category=apply_operation(vv, OutputVariableOperation.DERV_C),
             )
             if vv.magnetic:
-                def_derv_r[rkcm] = OutputVariableDef(
+                def_derv_c[rkcm] = OutputVariableDef(
                     rkcm,
                     vv.shape + [9],  # noqa: RUF005
                     reducible=True,

deepmd/infer/deep_eval.py

@@ -61,6 +61,7 @@ class DeepEvalBackend(ABC):
         "energy_derv_c": "atom_virial",
         "energy_derv_c_mag": "atom_virial_mag",
         "energy_derv_c_redu": "virial",
+        "energy_derv_c_mag_redu": "virial_mag",
         "polar": "polar",
         "polar_redu": "global_polar",
         "polar_derv_r": "force",

source/tests/common/dpmodel/test_output_def.py

@@ -17,6 +17,9 @@
     apply_operation,
     check_var,
 )
+from deepmd.infer.deep_eval import (
+    DeepEvalBackend,
+)
 
 
 class VariableDef:
@@ -32,6 +35,34 @@ def __init__(
 
 
 class TestDef(unittest.TestCase):
+    def test_magnetic_cell_derivative_uses_cell_bucket(self) -> None:
+        """Magnetic cell derivatives must participate in virial reduction."""
+        model_def = ModelOutputDef(
+            FittingOutputDef(
+                [
+                    OutputVariableDef(
+                        "energy",
+                        [1],
+                        reducible=True,
+                        r_differentiable=True,
+                        c_differentiable=True,
+                        magnetic=True,
+                    )
+                ]
+            )
+        )
+
+        self.assertIn("energy_derv_c_mag", model_def.keys_derv_c())
+        self.assertNotIn("energy_derv_c_mag", model_def.keys_derv_r())
+        self.assertIn("energy_derv_c_mag_redu", model_def.keys_derv_c_redu())
+        self.assertEqual(
+            DeepEvalBackend._OUTDEF_DP2BACKEND["energy_derv_c_mag_redu"],
+            "virial_mag",
+        )
+        reduced_def = model_def["energy_derv_c_mag_redu"]
+        self.assertEqual(reduced_def.shape, [1, 9])
+        self.assertFalse(reduced_def.atomic)
+
     def test_model_output_def(self) -> None:
         defs = [
             OutputVariableDef(
@@ -161,6 +192,7 @@ def test_model_output_def(self) -> None:
             "energy3_derv_c_redu",
             "energy3_derv_r_mag",
             "energy3_derv_c_mag",
+            "energy3_derv_c_mag_redu",
             "dos_redu",
             "mask",
             "mask_mag",
@@ -218,6 +250,7 @@ def test_model_output_def(self) -> None:
         self.assertEqual(md["energy3_derv_c_redu"].shape, [1, 9])
         self.assertEqual(md["energy3_derv_r_mag"].shape, [1, 3])
         self.assertEqual(md["energy3_derv_c_mag"].shape, [1, 9])
+        self.assertEqual(md["energy3_derv_c_mag_redu"].shape, [1, 9])
         self.assertEqual(md["gap"].shape, [13])
         self.assertEqual(md["gap_redu"].shape, [13])
         # atomic
@@ -240,6 +273,7 @@ def test_model_output_def(self) -> None:
         self.assertEqual(md["energy3_derv_r_mag"].atomic, True)
         self.assertEqual(md["energy3_derv_c_mag"].atomic, True)
         self.assertEqual(md["energy3_derv_c_redu"].atomic, False)
+        self.assertEqual(md["energy3_derv_c_mag_redu"].atomic, False)
         self.assertEqual(md["gap"].atomic, True)
         self.assertEqual(md["gap_redu"].atomic, False)
         # category
@@ -277,6 +311,10 @@ def test_model_output_def(self) -> None:
         self.assertEqual(
             md["energy3_derv_c_mag"].category, OutputVariableCategory.DERV_C
         )
+        self.assertEqual(
+            md["energy3_derv_c_mag_redu"].category,
+            OutputVariableCategory.DERV_C_REDU,
+        )
         self.assertEqual(md["gap"].category, OutputVariableCategory.OUT)
         self.assertEqual(md["gap_redu"].category, OutputVariableCategory.REDU)
         # flag
@@ -393,6 +431,15 @@ def test_model_output_def(self) -> None:
             md["energy3_derv_c_mag"].category & OVO.DERV_C,
             OVO.DERV_C,
         )
+        self.assertEqual(
+            md["energy3_derv_c_mag_redu"].category & OVO.REDU,
+            OVO.REDU,
+        )
+        self.assertEqual(md["energy3_derv_c_mag_redu"].category & OVO.DERV_R, 0)
+        self.assertEqual(
+            md["energy3_derv_c_mag_redu"].category & OVO.DERV_C,
+            OVO.DERV_C,
+        )
         # apply_operation: energy
         self.assertEqual(
             apply_operation(md["energy"], OVO.REDU),
@@ -456,6 +503,10 @@ def test_model_output_def(self) -> None:
             apply_operation(md["energy3"], OVO.DERV_C),
             md["energy3_derv_c_mag"].category,
         )
+        self.assertEqual(
+            apply_operation(md["energy3_derv_c_mag"], OVO.REDU),
+            md["energy3_derv_c_mag_redu"].category,
+        )
         # raise ValueError
         with self.assertRaises(ValueError):
             apply_operation(md["energy_redu"], OVO.REDU)
@@ -481,6 +532,8 @@ def test_model_output_def(self) -> None:
             apply_operation(md["energy3_derv_c_redu"], OVO.REDU)
         with self.assertRaises(ValueError):
             apply_operation(md["energy3_derv_c_mag"], OVO.DERV_C)
+        with self.assertRaises(ValueError):
+            apply_operation(md["energy3_derv_c_mag_redu"], OVO.REDU)
         # hession
         hession_cat = apply_operation(md["energy_derv_r"], OVO.DERV_R)
         self.assertEqual(hession_cat & OVO.DERV_R, OVO.DERV_R)