fix(dpa4c): address review on metrics, compression and charge states

Full validation reports stress alongside the per-atom virial instead of
replacing it, so the released `v:mae`/`v:rmse` selectors keep working. Stress
becomes a field of the shared energy-type metrics, which repairs the TF2 and
JAX validators that project the shared key map and had silently lost the
second-rank column. The five parallel tables of a metric profile collapse into
one family declaration, and the log reports whichever of stress and per-atom
virial the selected metric names.

Compression now rejects a non-empty `exclude_types` instead of emitting an
artifact that can never reach the fused kernel, and the charge-state domain
travels from the model through the archive metadata to the evaluator, so a
condition that addresses no table row is refused on both the folded and the
input-tensor path. Descriptors that embed the condition continuously declare
no ranges and are unaffected.

Also repairs a broken `LOG_COLUMN_ORDER` import that left TF2 full validation
unimportable, corrects the `@since` of `DP_DeepPotComputeCanonicalGraphGPU`,
fixes the LAMMPS spin example workflow, and restructures the DPA4C manual
around deployment, including the Kokkos requirement of the device-resident
inference path.

Author: OutisLi

deepmd/dpmodel/atomic_model/base_atomic_model.py

@@ -254,6 +254,10 @@ def get_default_chg_spin(self) -> list[float] | None:
         """Get the default charge_spin values."""
         return None
 
+    def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+        """Get the row range each charge_spin value indexes, or None."""
+        return None
+
     def reinit_atom_exclude(
         self,
         exclude_types: list[int] = [],

deepmd/dpmodel/atomic_model/dp_atomic_model.py

@@ -154,6 +154,12 @@ def get_default_chg_spin(self) -> list[float] | None:
             return self.descriptor.get_default_chg_spin()
         return None
 
+    def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+        """Get the row range each charge_spin value indexes, or None."""
+        if self.add_chg_spin_ebd:
+            return self.descriptor.get_chg_spin_table_ranges()
+        return None
+
     def uses_graph_lower(self) -> bool:
         """Delegates to this model's own descriptor."""
         return bool(self.descriptor.uses_graph_lower())

deepmd/dpmodel/atomic_model/linear_atomic_model.py

@@ -740,6 +740,20 @@ def get_default_chg_spin(self) -> "Array | None":
             lambda m: m.get_default_chg_spin(),
         )[1]
 
+    def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+        """The shared table row ranges, if the children agree.
+
+        A condition reaches every consuming child, so it must address the
+        tables of all of them. Children that disagree share no acceptable
+        state, which the composition reports as an unconstrained domain
+        rather than silently enforcing one child's tables on the others.
+        """
+        return self._agreed_default(
+            self._chg_spin_consumers(),
+            lambda m: m.get_chg_spin_table_ranges() is not None,
+            lambda m: m.get_chg_spin_table_ranges(),
+        )[1]
+
     def has_default_fparam(self) -> bool:
         """Whether every active child shares one default frame parameter."""
         return self._agreed_default(

deepmd/dpmodel/descriptor/dpa4c.py

@@ -73,6 +73,7 @@
     resolve_swiglu_hidden_width,
 )
 from .dpa4c_nn import (
+    CHARGE_STATE_TABLE_RANGES,
     ChargeStateEmbedding,
     InvariantReadout,
     OrderedPairFiLM,
@@ -2003,6 +2004,19 @@ def get_default_chg_spin(self) -> list[float] | None:
         """Return the fallback ``[charge, multiplicity]``, if configured."""
         return self.default_chg_spin
 
+    def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+        """Return the row range each value of the frame condition indexes.
+
+        The condition is embedded by gathering one row of the charge table and
+        one of the multiplicity table, so an acceptable state is a pair of
+        integers inside these half-open ranges. A folded condition indexes the
+        same tables at rebuild time, so the ranges hold whether or not the
+        descriptor is compressed.
+        """
+        if self.charge_spin_embedding is None:
+            return None
+        return [tuple(rng) for rng in CHARGE_STATE_TABLE_RANGES]
+
     def has_message_passing_across_ranks(self) -> bool:
         """Return whether intermediate halo communication is required."""
         return False

deepmd/dpmodel/descriptor/dpa4c_nn/__init__.py

@@ -8,6 +8,7 @@
     enumerate_degree_triples,
 )
 from .charge_state import (
+    CHARGE_STATE_TABLE_RANGES,
     ChargeStateEmbedding,
     canonicalize_charge_spin,
     validate_charge_state,
@@ -33,6 +34,7 @@
 )
 
 __all__ = [
+    "CHARGE_STATE_TABLE_RANGES",
     "MAX_ANGULAR_DEGREE",
     "NEIGHBOR_QUADRUPOLE_CHANNELS",
     "BispectrumLayout",

deepmd/dpmodel/descriptor/dpa4c_nn/charge_state.py

@@ -85,6 +85,15 @@
 #: Half-open range of representable spin multiplicities.
 MULTIPLICITY_RANGE = (0, MULTIPLICITY_TABLE_ROWS)
 
+#: Name of each value of a charge state, in order, for diagnostics.
+CHARGE_STATE_FIELDS = ("charge", "multiplicity")
+
+#: Half-open row range addressed by each value of a charge state, in order.
+#: A condition is a pair of table row indices, so a host-side boundary that
+#: knows these ranges can reject an unaddressable state without knowing which
+#: descriptor holds the tables.
+CHARGE_STATE_TABLE_RANGES = (CHARGE_RANGE, MULTIPLICITY_RANGE)
+
 
 def validate_charge_state(charge_spin: Any) -> list[float]:
     """Check that a frame condition addresses a row of each embedding table.
@@ -120,11 +129,11 @@ def validate_charge_state(charge_spin: Any) -> list[float]:
         )
     for value, name, (low, high) in zip(
         values,
-        ("charge", "multiplicity"),
-        (CHARGE_RANGE, MULTIPLICITY_RANGE),
+        CHARGE_STATE_FIELDS,
+        CHARGE_STATE_TABLE_RANGES,
         strict=True,
     ):
-        if value != int(value):
+        if not np.isfinite(value) or value != int(value):
             raise ValueError(f"The {name} must be an integer, got {value}")
         if not low <= value < high:
             raise ValueError(

deepmd/dpmodel/descriptor/make_base_descriptor.py

@@ -113,6 +113,17 @@ def get_default_chg_spin(self) -> Any:
             """Returns the default charge_spin value, or None."""
             return None
 
+        def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+            """Returns the row range each charge_spin value indexes, or None.
+
+            A descriptor that embeds the condition by indexing tables reports
+            one half-open range per value, which makes every acceptable state
+            an integer tuple inside those ranges. ``None``, the default, means
+            the condition enters as a continuous quantity and only its width
+            is constrained.
+            """
+            return None
+
         def get_geo_compress(self) -> bool:
             """Return whether geometric tabulated compression is active.
 

deepmd/dpmodel/model/base_model.py

@@ -125,6 +125,15 @@ def get_default_chg_spin(self) -> list | None:
             """
             return None
 
+        def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+            """Return the row range each charge/spin value indexes, or ``None``.
+
+            ``None`` means the condition is a continuous quantity, so only its
+            width is constrained; a list means every acceptable value is an
+            integer inside the matching half-open range.
+            """
+            return None
+
         def get_var_name(self) -> str | None:
             """Return the fitted property's variable name, or ``None`` if
             this is not a property model. ``is not None`` is the support

deepmd/dpmodel/model/make_model.py

@@ -1163,6 +1163,10 @@ def get_default_chg_spin(self) -> list[float] | None:
             """Get the default charge_spin values."""
             return self.atomic_model.get_default_chg_spin()
 
+        def get_chg_spin_table_ranges(self) -> list[tuple[int, int]] | None:
+            """Get the row range each charge_spin value indexes, or None."""
+            return self.atomic_model.get_chg_spin_table_ranges()
+
         def get_sel_type(self) -> list[int]:
             """Get the selected atom types of this model.
 

deepmd/dpmodel/train/validation.py

@@ -232,7 +232,7 @@ def __init__(
             restart_training and self.full_val_file.exists()
         )
         self.table_column_specs = []
-        for column_name, metric_key in self.profile.column_order:
+        for column_name, metric_key in self.profile.columns(self.metric_name):
             _, metric_unit = format_metric_value_for_table(metric_key, 1.0)
             header_label = f"{column_name}({metric_unit})"
             self.table_column_specs.append(