fix(dpa4): atom exclusion and stat capabilities must reach the composition

Two more capabilities the ZBL composition dropped.

atom_exclude_types was NOT forwarded, and my earlier commit 749fd49
justified that with the claim that forwarding would double-apply. That was
wrong. The composition's own atom_excl was None, the learned child masked
only itself, and the analytical child never heard about the exclusion, so
an atom the user excluded still collected its share of the ZBL energy: on
an Ni-O dimer at 0.9 A, excluding type 1 moved the energy only 80.553 ->
80.201 while the ~80 eV analytical term stayed. Masking to zero is
idempotent, so the child keeping its own copy is harmless -- forwarding
applies it once, at the layer that owns the shared graph. Now 80.201 ->
40.219; the residual is correct, being Ni's half of a pair term whose
other half belonged to the excluded atom, exactly as an excluded atom
still contributes to its neighbours' learned energies.

get_intensive and get_compute_stats_distinguish_types fell through to the
base defaults instead of asking the children, so a bridged model would fit
its out-stat bias with the wrong extensivity and the wrong
type-distinguishing rule. Aggregated deliberately differently: intensive
iff EVERY child is (a sum cannot be intensive while one child scales),
type-distinguishing if ANY child needs it (the stricter rule is safe for
children that do not care).

The atom-exclusion regression fails without the fix. The stat-capability
one does NOT discriminate for an energy DPA4 -- its children happen to
agree with the base defaults -- so it is a structural pin only.

Author: Han Wang

deepmd/dpmodel/atomic_model/linear_atomic_model.py

@@ -612,6 +612,27 @@ def has_chg_spin_ebd(self) -> bool:
         """Whether ANY child consumes the frame-level charge/spin FiLM input."""
         return any(model.has_chg_spin_ebd() for model in self.models)
 
+    def get_intensive(self) -> bool:
+        """Intensive iff EVERY child is -- a sum of children cannot be
+        intensive while any of them scales with system size.
+
+        ``all``, not ``any``: mixing an intensive with an extensive child is
+        physically incoherent, and defaulting to the base ``False`` would
+        silently pick the extensive out-stat rule for a composition of
+        intensive fittings.
+        """
+        return all(model.get_intensive() for model in self.models)
+
+    def get_compute_stats_distinguish_types(self) -> bool:
+        """Type-distinguishing stats are needed if ANY child needs them.
+
+        ``any``, because the rule decides how out-stat bias is fitted for
+        the WHOLE composition: one child that distinguishes types would get
+        a wrong bias under the type-agnostic rule, whereas a child that does
+        not care is unharmed by the stricter one.
+        """
+        return any(model.get_compute_stats_distinguish_types() for model in self.models)
+
     def get_dim_chg_spin(self) -> int:
         """Dimension of the charge_spin input (max over children, like fparam)."""
         return max([model.get_dim_chg_spin() for model in self.models])

deepmd/dpmodel/model/model.py

@@ -154,6 +154,14 @@ def get_standard_model(data: dict) -> EnergyModel:
             models=[model.atomic_model, zbl_atomic],
             type_map=data["type_map"],
             weights="sum",
+            # Atom exclusion belongs to the composition for the same reason
+            # pair exclusion does: both children evaluate on the one shared
+            # graph, so "excluded" has to mean excluded from the analytical
+            # term too, not just the learned one. Masking to zero is
+            # idempotent, so the learned child keeping its own copy is
+            # harmless -- but WITHOUT this the composition's atom_excl is
+            # None and an excluded atom still collects its full ZBL energy.
+            atom_exclude_types=atom_exclude_types,
             # The composition is the atomic model the freeze metadata reads,
             # so it must carry the model-level pair exclusion too -- otherwise
             # a configured ``pair_exclude_types`` reaches neither the exported

deepmd/pt_expt/model/get_model.py

@@ -242,6 +242,14 @@ def get_sezm_model(data: dict) -> EnergyModel:
             models=[model.atomic_model, zbl_atomic],
             type_map=data["type_map"],
             weights="sum",
+            # Atom exclusion belongs to the composition for the same reason
+            # pair exclusion does: both children evaluate on the one shared
+            # graph, so "excluded" has to mean excluded from the analytical
+            # term too, not just the learned one. Masking to zero is
+            # idempotent, so the learned child keeping its own copy is
+            # harmless -- but WITHOUT this the composition's atom_excl is
+            # None and an excluded atom still collects its full ZBL energy.
+            atom_exclude_types=data.get("atom_exclude_types", []),
             # Same ownership assignment as the dpmodel builder: the
             # composition is what the freeze metadata reads, so it carries the
             # model-level pair exclusion. Config only -- model-level pair

source/tests/common/dpmodel/test_zbl_bridging.py

@@ -448,3 +448,63 @@ def test_no_exclusion_stays_empty(self) -> None:
         config = copy.deepcopy(ZBL_CONFIG)
         config.pop("pair_exclude_types", None)
         assert get_model(config).atomic_model.pair_exclude_types == []
+
+
+class TestCompositionCarriesAtomExclusion:
+    """``atom_exclude_types`` must reach the ZBL term too.
+
+    The twin of :class:`TestCompositionCarriesPairExclusion`. Unlike pair
+    exclusion this one IS applied at runtime, which is why it was initially
+    (and wrongly) left unforwarded on the theory that forwarding would
+    double-apply. It does not: the composition's own ``atom_excl`` was
+    ``None``, the learned child masked only itself, and the analytical child
+    never heard about the exclusion -- so an excluded atom still collected
+    its full share of the ZBL energy. Masking to zero is idempotent, so the
+    child keeping its own copy is harmless.
+    """
+
+    @staticmethod
+    def _model(bridging: bool):
+        config = copy.deepcopy(ZBL_CONFIG)
+        config["atom_exclude_types"] = [1]
+        if not bridging:
+            for key in ("bridging_method", "bridging_r_inner", "bridging_r_outer"):
+                config.pop(key, None)
+        return get_model(config)
+
+    def test_atom_exclusion_reaches_the_composition(self) -> None:
+        bridged = self._model(bridging=True)
+        plain = self._model(bridging=False)
+        # anti-vacuity: the unbridged model must actually carry it
+        assert plain.atomic_model.atom_exclude_types == [1]
+        assert bridged.atomic_model.atom_exclude_types == [1]
+        # the mask is what actually zeroes the analytical child's output
+        assert bridged.atomic_model.atom_excl is not None
+
+    def test_no_exclusion_stays_empty(self) -> None:
+        """Nothing is invented when none is configured."""
+        config = copy.deepcopy(ZBL_CONFIG)
+        config.pop("atom_exclude_types", None)
+        model = get_model(config)
+        assert model.atomic_model.atom_exclude_types == []
+        assert model.atomic_model.atom_excl is None
+
+
+class TestCompositionForwardsStatCapabilities:
+    """``get_intensive`` / ``get_compute_stats_distinguish_types`` aggregate.
+
+    Both silently fell through to ``BaseAtomicModel``'s defaults, so a
+    bridged model would fit its out-stat bias with the wrong extensivity and
+    the wrong type-distinguishing rule -- the same class of gap as the
+    charge-spin and pair-exclusion accessors.
+    """
+
+    def test_forwarded_from_children(self) -> None:
+        bridged = get_model(copy.deepcopy(ZBL_CONFIG))
+        children = bridged.atomic_model.models
+        assert bridged.atomic_model.get_intensive() == all(
+            c.get_intensive() for c in children
+        )
+        assert bridged.atomic_model.get_compute_stats_distinguish_types() == any(
+            c.get_compute_stats_distinguish_types() for c in children
+        )