Added testing

src/nomad_simulations/schema_packages/properties/greens_function.py

@@ -26,7 +26,6 @@
     from nomad.metainfo import Context, Section
     from structlog.stdlib import BoundLogger
 
-    from nomad_simulations.schema_packages.variables import Variables
 
 from nomad_simulations.schema_packages.atoms_state import AtomsState, OrbitalsState
 from nomad_simulations.schema_packages.physical_property import PhysicalProperty
@@ -157,7 +156,7 @@ def resolve_space_id(self) -> str:
             'iw': MatsubaraFrequency,
         }
 
-        def find_space_id(space_map: dict[str, 'Variables']) -> str:
+        def find_space_id(space_map: dict) -> str:
             """
             Finds the id string for a given map.
 
@@ -169,7 +168,7 @@ def find_space_id(space_map: dict[str, 'Variables']) -> str:
             """
             for space_id, variable_cls in space_map.items():
                 space_variable = get_variables(variables=self.variables, variable_cls=variable_cls)
-                if len(space_variable) >= 0:
+                if len(space_variable) > 0:
                     return space_id
             return ''
 
@@ -341,12 +340,13 @@ def __init__(
 
     def is_valid_quasiparticle_weight(self) -> bool:
         """
-        Check if the quasiparticle weight values are valid, i.e., if all `value` are defined positive.
+        Check if the quasiparticle weight values are valid, i.e., if all `value` are defined between
+        0 and 1.
 
         Returns:
             (bool): True if the quasiparticle weight is valid, False otherwise.
         """
-        if (self.value < 0.0).any():
+        if (self.value < 0.0).any() or (self.value > 1.0).any():
             return False
         return True
 
@@ -363,7 +363,7 @@ def resolve_system_correlation_strengths(self) -> str:
             return 'strongly-correlated metal'
         elif np.any(self.value == 0) and np.any(self.value > 0):
             return 'OSMI'
-        elif np.all(self.value == 0):
+        elif np.all(self.value < 1e-2):
             return 'Mott insulator'
         return ''
 

tests/test_greens_function.py

@@ -0,0 +1,115 @@
+#
+# Copyright The NOMAD Authors.
+#
+# This file is part of NOMAD. See https://nomad-lab.eu for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from typing import Optional, Union
+
+import pytest
+
+from nomad_simulations.schema_packages.properties import (
+    ElectronicGreensFunction,
+    ElectronicSelfEnergy,
+    HybridizationFunction,
+    QuasiparticleWeight,
+)
+from nomad_simulations.schema_packages.properties.greens_function import (
+    BaseGreensFunction,
+)
+from nomad_simulations.schema_packages.variables import (
+    Frequency,
+    ImaginaryTime,
+    KMesh,
+    MatsubaraFrequency,
+    Time,
+    WignerSeitz,
+)
+
+
+class TestBaseGreensFunction:
+    """
+    Test the `BaseGreensFunction` class defined in `properties/greens_function.py`.aa
+    """
+
+    @pytest.mark.parametrize(
+        'variables, result',
+        [
+            ([], ''),
+            ([WignerSeitz()], 'r'),
+            ([KMesh()], 'k'),
+            ([Time()], 't'),
+            ([ImaginaryTime()], 'it'),
+            ([Frequency()], 'w'),
+            ([MatsubaraFrequency()], 'iw'),
+            ([WignerSeitz(), Time()], 'rt'),
+            ([WignerSeitz(), ImaginaryTime()], 'rit'),
+            ([WignerSeitz(), Frequency()], 'rw'),
+            ([WignerSeitz(), MatsubaraFrequency()], 'riw'),
+            ([KMesh(), Time()], 'kt'),
+            ([KMesh(), ImaginaryTime()], 'kit'),
+            ([KMesh(), Frequency()], 'kw'),
+            ([KMesh(), MatsubaraFrequency()], 'kiw'),
+        ],
+    )
+    def test_resolve_space_id(self, variables: list[Union[WignerSeitz, KMesh, Time, ImaginaryTime, Frequency, MatsubaraFrequency]], result: str):
+        """
+        Test the `resolve_space_id` method of the `BaseGreensFunction` class.
+        """
+        gfs = BaseGreensFunction(n_atoms=1, n_correlated_orbitals=1)
+        gfs.variables = variables
+        assert gfs.resolve_space_id() == result
+
+
+
+class TestQuasiparticleWeight:
+    """
+    Test the `QuasiparticleWeight` class defined in `properties/greens_function.py`.
+    """
+
+    @pytest.mark.parametrize(
+        'value, result',
+        [
+            ([[1, 0.5, -2]], False),
+            ([[1, 0.5, 8]], False),
+            ([[1, 0.5, 0.8]], True),
+        ],
+    )
+    def test_is_valid_quasiparticle_weight(self, value: list[float], result: bool):
+        """
+        Test the `is_valid_quasiparticle_weight` method of the `QuasiparticleWeight` class.
+        """
+        quasiparticle_weight = QuasiparticleWeight(n_atoms=1, n_correlated_orbitals=3)
+        quasiparticle_weight.value = value
+        assert quasiparticle_weight.is_valid_quasiparticle_weight() == result
+
+
+    @pytest.mark.parametrize(
+        'value, result',
+        [
+            ([[1, 0.9, 0.8]], 'non-correlated metal'),
+            ([[0.2, 0.3, 0.1]], 'strongly-correlated metal'),
+            ([[0, 0.3, 0.1]], 'OSMI'),
+            ([[0, 0, 0]], 'Mott insulator'),
+            ([[1.0, 0.8, 0.2]], ''),
+        ],
+    )
+    def test_resolve_system_correlation_strengths(self, value: list[float], result: str):
+        """
+        Test the `resolve_system_correlation_strengths` method of the `QuasiparticleWeight` class.
+        """
+        quasiparticle_weight = QuasiparticleWeight(n_atoms=1, n_correlated_orbitals=3)
+        quasiparticle_weight.value = value
+        assert quasiparticle_weight.resolve_system_correlation_strengths() == result