- Deactivate automated kappa and j derivations, as it may give the wrong impressions.

-- Retain conversion capabilities
-- Add TODO for future integration
- Update tests to stop using quantum symbols

Changes to be committed:
	modified:   src/nomad_simulations/schema_packages/atoms_state.py
	modified:   tests/test_model_method.py

Author: ndaelman-hu

src/nomad_simulations/schema_packages/atoms_state.py

@@ -240,9 +240,9 @@ def compute_l_from_kappa(self, kappa: int) -> int:
         if kappa == 0:
             raise ValueError('κ = 0 is unphysical')
         if kappa < 0:
-            return abs(kappa) - 1  # l = |κ| - 1 for κ < 0
+            return abs(kappa) - 1
         else:
-            return kappa  # l = κ for κ > 0
+            return kappa
 
     def validate_kappa_j_relationship(self, logger: 'BoundLogger') -> bool:
         """
@@ -253,10 +253,8 @@ def validate_kappa_j_relationship(self, logger: 'BoundLogger') -> bool:
         """
         if self.kappa_quantum_number is not None and self.j_quantum_number is not None:
             try:
-                # Use factored computation for validation
                 expected_j = self.compute_j_from_kappa(self.kappa_quantum_number)
 
-                # Check if j value matches expected
                 if abs(self.j_quantum_number - expected_j) >= 1e-10:
                     logger.error(
                         f'Inconsistent κ={self.kappa_quantum_number} and j={self.j_quantum_number}. '
@@ -268,20 +266,6 @@ def validate_kappa_j_relationship(self, logger: 'BoundLogger') -> bool:
                 return False
         return True
 
-    def normalize_kappa_j_consistency(self):
-        """
-        Ensure κ and j are consistent during normalization using factored computation.
-        Populates missing values when possible.
-        """
-        if self.kappa_quantum_number is not None and self.j_quantum_number is None:
-            # Compute j from κ
-            self.j_quantum_number = self.compute_j_from_kappa(self.kappa_quantum_number)
-
-        elif self.j_quantum_number is not None and self.kappa_quantum_number is None:
-            # Cannot uniquely determine κ from j alone (need l as well)
-            # This would need orbital information
-            pass
-
     @log
     def validate_quantum_numbers(self) -> bool:
         """
@@ -458,14 +442,37 @@ def _jj_coupling(self, electron_data: list[dict]) -> list[float]:
         # Remove duplicates and sort
         return sorted(list(set(all_j_combinations)))
 
+    @log
+    def normalize_kappa_j_consistency(self) -> None:
+        """
+        Populate j and l quantum numbers from κ (kappa) when κ is defined but j/l are not.
+
+        This method is NOT called during normalization to avoid baking in physics assumptions
+        about relativistic coupling and the underlying Hamiltonian. It is retained for
+        higher-level search/matching operations where users can explicitly request conversion
+        between relativistic (κ) and non-relativistic (j, l) quantum number representations.
+        """
+        #TODO: Implement search/matching functionality at GUI or query level that allows users
+        # to explicitly convert between κ and (j, l) representations when searching for or
+        # comparing quantum states. This should be a user-driven operation, not an automatic
+        # schema-level conversion.
+
+        if self.kappa_quantum_number is not None:
+            if self.j_quantum_number is None:
+                self.j_quantum_number = self.compute_j_from_kappa(
+                    self.kappa_quantum_number
+                )
+            if self.l_quantum_number is None:
+                self.l_quantum_number = self.compute_l_from_kappa(
+                    self.kappa_quantum_number
+                )
+
     def normalize(self, archive: 'EntryArchive', logger: 'BoundLogger') -> None:
         super().normalize(archive, logger)
 
         if not self.validate_kappa_j_relationship(logger):
             return None
 
-        self.normalize_kappa_j_consistency()
-
         if not self.validate_quantum_numbers(logger=logger):
             return None
 

tests/test_model_method.py

@@ -322,19 +322,19 @@ class TestSlaterKosterBond:
     """
 
     @pytest.mark.parametrize(
-        'orb1_symbol, orb2_symbol, bravais_vector, expected_name',
+        'orb1_l_number, orb2_l_number, bravais_vector, expected_name',
         [
             (None, None, None, None),
-            ('s', None, None, None),
-            (None, 'p', None, None),
-            ('s', 's', (0, 0, 0), 'sss'),
-            ('s', 'p', (0, 0, 0), 'sps'),
+            (0, None, None, None),
+            (None, 1, None, None),
+            (0, 0, (0, 0, 0), 'sss'),
+            (0, 1, (0, 0, 0), 'sps'),
         ],
     )
     def test_resolve_bond_name_from_references(
         self,
-        orb1_symbol: str | None,
-        orb2_symbol: str | None,
+        orb1_l_number: int | None,
+        orb2_l_number: int | None,
         bravais_vector: tuple | None,
         expected_name: str | None,
     ):
@@ -344,13 +344,13 @@ def test_resolve_bond_name_from_references(
         sk_bond = SlaterKosterBond()
         # If there's an orbit1 or orbit2, build them
         orbit1 = None
-        if orb1_symbol:
-            spherical_state = SphericalSymmetryState(l_quantum_symbol=orb1_symbol)
+        if orb1_l_number is not None:
+            spherical_state = SphericalSymmetryState(l_quantum_number=orb1_l_number)
             orbit1 = ElectronicState(spin_orbit_state=spherical_state)
 
         orbit2 = None
-        if orb2_symbol:
-            spherical_state = SphericalSymmetryState(l_quantum_symbol=orb2_symbol)
+        if orb2_l_number is not None:
+            spherical_state = SphericalSymmetryState(l_quantum_number=orb2_l_number)
             orbit2 = ElectronicState(spin_orbit_state=spherical_state)
 
         name = sk_bond.resolve_bond_name_from_references(
@@ -362,17 +362,17 @@ def test_resolve_bond_name_from_references(
         assert name == expected_name
 
     @pytest.mark.parametrize(
-        'orb1_symbol, orb2_symbol, bravais_vector, expected',
+        'orb1_l_number, orb2_l_number, bravais_vector, expected',
         [
             (None, None, None, None),
-            ('s', None, None, None),
-            ('s', 'p', (0, 0, 0), 'sps'),
+            (0, None, None, None),
+            (0, 1, (0, 0, 0), 'sps'),
         ],
     )
     def test_normalize(
         self,
-        orb1_symbol: str | None,
-        orb2_symbol: str | None,
+        orb1_l_number: int | None,
+        orb2_l_number: int | None,
         bravais_vector: tuple | None,
         expected: str | None,
     ):
@@ -382,13 +382,13 @@ def test_normalize(
         # Prepare a model scenario
         bond = SlaterKosterBond()
         orbitals = []
-        if orb1_symbol:
-            spherical_state = SphericalSymmetryState(l_quantum_symbol=orb1_symbol)
+        if orb1_l_number is not None:
+            spherical_state = SphericalSymmetryState(l_quantum_number=orb1_l_number)
             electronic_state = ElectronicState(spin_orbit_state=spherical_state)
             orbitals.append(electronic_state)
             bond.orbital_1 = orbitals[-1]
-        if orb2_symbol:
-            spherical_state = SphericalSymmetryState(l_quantum_symbol=orb2_symbol)
+        if orb2_l_number is not None:
+            spherical_state = SphericalSymmetryState(l_quantum_number=orb2_l_number)
             electronic_state = ElectronicState(spin_orbit_state=spherical_state)
             orbitals.append(electronic_state)
             bond.orbital_2 = orbitals[-1]