Added check_simulation_cell in utils (#117)

* Added equal cell tolerance

* Defining logic in __eq__ methods of Cell and AtomicCell

* Moved testing to test_model_system

Added __ne__ method

* Add todo

* Fix == testing failing

* Added __ne__ testing

src/nomad_simulations/schema_packages/__init__.py

@@ -23,19 +23,19 @@
 class NOMADSimulationsEntryPoint(SchemaPackageEntryPoint):
     dos_energy_tolerance: float = Field(
         8.01088e-21,
-        description='Tolerance of the DOS energies in Joules to match the reference of energies in the DOS normalize function.',
+        description='Tolerance (in joules) of the DOS energies to match the reference of energies in the DOS normalize function.',
     )
     dos_intensities_threshold: float = Field(
         1e-8,
-        description='Threshold value at which the DOS intensities are considered non-zero.',
+        description='Threshold value (in joules^-1) at which the DOS intensities are considered non-zero.',
     )
     occupation_tolerance: float = Field(
         1e-3,
         description='Tolerance for the occupation of a eigenstate to be non-occupied.',
     )
     fermi_surface_tolerance: float = Field(
         1e-8,
-        description='Tolerance for energies to be close to the Fermi level and hence define the Fermi surface of a material.',
+        description='Tolerance (in joules) for energies to be close to the Fermi level and hence define the Fermi surface of a material.',
     )
     symmetry_tolerance: float = Field(
         0.1, description='Tolerance for the symmetry analyzer used from MatID.'
@@ -48,6 +48,10 @@ class NOMADSimulationsEntryPoint(SchemaPackageEntryPoint):
         64,
         description='Limite of the number of atoms in the unit cell to be treated for the system type classification from MatID to work. This is done to avoid overhead of the package.',
     )
+    equal_cell_positions_tolerance: float = Field(
+        1e-12,
+        description='Tolerance (in meters) for the cell positions to be considered equal.',
+    )
 
     def load(self):
         from nomad_simulations.schema_packages.general import m_package

src/nomad_simulations/schema_packages/model_system.py

@@ -296,6 +296,40 @@ class Cell(GeometricSpace):
         """,
     )
 
+    def _check_positions(self, positions_1, positions_2) -> list:
+        # Check that all the `positions`` of `cell_1` match with the ones in `cell_2`
+        check_positions = []
+        for i1, pos1 in enumerate(positions_1):
+            for i2, pos2 in enumerate(positions_2):
+                if np.allclose(
+                    pos1, pos2, atol=configuration.equal_cell_positions_tolerance
+                ):
+                    check_positions.append([i1, i2])
+                    break
+        return check_positions
+
+    def __eq__(self, other) -> bool:
+        # TODO implement checks on `lattice_vectors` and other quantities to ensure the equality of primitive cells
+        if not isinstance(other, Cell):
+            return False
+
+        # If the `positions` are empty, return False
+        if self.positions is None or other.positions is None:
+            return False
+
+        # The `positions` should have the same length (same number of positions)
+        if len(self.positions) != len(other.positions):
+            return False
+        n_positions = len(self.positions)
+
+        check_positions = self._check_positions(self.positions, other.positions)
+        if len(check_positions) != n_positions:
+            return False
+        return True
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
     def normalize(self, archive: 'EntryArchive', logger: 'BoundLogger') -> None:
         super().normalize(archive, logger)
 
@@ -339,6 +373,29 @@ def __init__(self, m_def: 'Section' = None, m_context: 'Context' = None, **kwarg
         # Set the name of the section
         self.name = self.m_def.name
 
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, AtomicCell):
+            return False
+
+        # Compare positions using the parent sections's `__eq__` method
+        if not super().__eq__(other):
+            return False
+
+        # Check that the `chemical_symbol` of the atoms in `cell_1` match with the ones in `cell_2`
+        check_positions = self._check_positions(self.positions, other.positions)
+        try:
+            for atom in check_positions:
+                element_1 = self.atoms_state[atom[0]].chemical_symbol
+                element_2 = other.atoms_state[atom[1]].chemical_symbol
+                if element_1 != element_2:
+                    return False
+        except Exception:
+            return False
+        return True
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
     def to_ase_atoms(self, logger: 'BoundLogger') -> Optional[ase.Atoms]:
         """
         Generates an ASE Atoms object with the most basic information from the parsed `AtomicCell`

src/nomad_simulations/schema_packages/utils/utils.py

@@ -21,13 +21,20 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
+from nomad.config import config
 
 if TYPE_CHECKING:
     from typing import Optional
 
     from nomad.datamodel.data import ArchiveSection
     from structlog.stdlib import BoundLogger
 
+    from nomad_simulations.schema_packages.model_system import Cell
+
+configuration = config.get_plugin_entry_point(
+    'nomad_simulations.schema_packages:nomad_simulations_plugin'
+)
+
 
 def get_sibling_section(
     section: 'ArchiveSection',

tests/test_model_system.py

@@ -22,7 +22,10 @@
 import pytest
 from nomad.datamodel import EntryArchive
 
+from nomad_simulations.schema_packages.atoms_state import AtomsState
 from nomad_simulations.schema_packages.model_system import (
+    AtomicCell,
+    Cell,
     ChemicalFormula,
     ModelSystem,
     Symmetry,
@@ -32,11 +35,162 @@
 from .conftest import generate_atomic_cell
 
 
+class TestCell:
+    """
+    Test the `Cell` section defined in model_system.py
+    """
+
+    @pytest.mark.parametrize(
+        'cell_1, cell_2, result',
+        [
+            (Cell(), None, False),  # one cell is None
+            (Cell(), Cell(), False),  # both cells are empty
+            (
+                Cell(positions=[[1, 0, 0]]),
+                Cell(),
+                False,
+            ),  # one cell has positions, the other is empty
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0]]),
+                Cell(positions=[[1, 0, 0]]),
+                False,
+            ),  # length mismatch
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0]]),
+                Cell(positions=[[1, 0, 0], [0, -1, 0]]),
+                False,
+            ),  # different positions
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                True,
+            ),  # same ordered positions
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                Cell(positions=[[1, 0, 0], [0, 0, 1], [0, 1, 0]]),
+                True,
+            ),  # different ordered positions but same cell
+        ],
+    )
+    def test_eq_ne(self, cell_1: Cell, cell_2: Cell, result: bool):
+        """
+        Test the `__eq__` and `__ne__` operator functions of `Cell`.
+        """
+        assert (cell_1 == cell_2) == result
+        assert (cell_1 != cell_2) != result
+
+
 class TestAtomicCell:
     """
     Test the `AtomicCell`, `Cell` and `GeometricSpace` classes defined in model_system.py
     """
 
+    @pytest.mark.parametrize(
+        'cell_1, cell_2, result',
+        [
+            (Cell(), None, False),  # one cell is None
+            (Cell(), Cell(), False),  # both cells are empty
+            (
+                Cell(positions=[[1, 0, 0]]),
+                Cell(),
+                False,
+            ),  # one cell has positions, the other is empty
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0]]),
+                Cell(positions=[[1, 0, 0]]),
+                False,
+            ),  # length mismatch
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0]]),
+                Cell(positions=[[1, 0, 0], [0, -1, 0]]),
+                False,
+            ),  # different positions
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                True,
+            ),  # same ordered positions
+            (
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                Cell(positions=[[1, 0, 0], [0, 0, 1], [0, 1, 0]]),
+                True,
+            ),  # different ordered positions but same cell
+            (
+                AtomicCell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                Cell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                False,
+            ),  # one atomic cell and another cell (missing chemical symbols)
+            (
+                AtomicCell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                AtomicCell(positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+                False,
+            ),  # missing chemical symbols
+            (
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='O'),
+                    ],
+                ),
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='O'),
+                    ],
+                ),
+                True,
+            ),  # same ordered positions and chemical symbols
+            (
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='O'),
+                    ],
+                ),
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='Cu'),
+                        AtomsState(chemical_symbol='O'),
+                    ],
+                ),
+                False,
+            ),  # same ordered positions but different chemical symbols
+            (
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='O'),
+                    ],
+                ),
+                AtomicCell(
+                    positions=[[1, 0, 0], [0, 0, 1], [0, 1, 0]],
+                    atoms_state=[
+                        AtomsState(chemical_symbol='H'),
+                        AtomsState(chemical_symbol='O'),
+                        AtomsState(chemical_symbol='H'),
+                    ],
+                ),
+                True,
+            ),  # different ordered positions but same chemical symbols
+        ],
+    )
+    def test_eq_ne(self, cell_1: Cell, cell_2: Cell, result: bool):
+        """
+        Test the `__eq__` and `__ne__` operator functions of `AtomicCell`.
+        """
+        assert (cell_1 == cell_2) == result
+        assert (cell_1 != cell_2) != result
+
     @pytest.mark.parametrize(
         'chemical_symbols, atomic_numbers, formula, lattice_vectors, positions, periodic_boundary_conditions',
         [

tests/test_utils.py

@@ -45,16 +45,25 @@ def test_get_sibling_section():
     parent_section.symmetry.append(sibling_section)
     assert get_sibling_section(section, '', logger) is None
     assert get_sibling_section(section, 'symmetry', logger) == sibling_section
-    assert get_sibling_section(sibling_section, 'cell', logger) == section
+    assert get_sibling_section(sibling_section, 'cell', logger).type == section.type
     assert get_sibling_section(section, 'symmetry', logger, index_sibling=2) is None
     section2 = AtomicCell(type='primitive')
     parent_section.cell.append(section2)
     assert (
-        get_sibling_section(sibling_section, 'cell', logger, index_sibling=0) == section
+        get_sibling_section(sibling_section, 'cell', logger, index_sibling=0).type
+        == 'original'
     )
     assert (
-        get_sibling_section(sibling_section, 'cell', logger, index_sibling=1)
-        == section2
+        get_sibling_section(sibling_section, 'cell', logger, index_sibling=0).type
+        == section.type
+    )
+    assert (
+        get_sibling_section(sibling_section, 'cell', logger, index_sibling=1).type
+        == section2.type
+    )
+    assert (
+        get_sibling_section(sibling_section, 'cell', logger, index_sibling=1).type
+        == 'primitive'
     )