Added check_simulation_cell in utils

Added testing

src/nomad_simulations/schema_packages/utils/__init__.py

@@ -18,6 +18,7 @@
 
 from .utils import (
     RussellSaundersState,
+    check_simulation_cell,
     get_composition,
     get_sibling_section,
     get_variables,

src/nomad_simulations/schema_packages/utils/utils.py

@@ -28,6 +28,8 @@
     from nomad.datamodel.data import ArchiveSection
     from structlog.stdlib import BoundLogger
 
+    from nomad_simulations.schema_packages.model_system import Cell
+
 
 def get_sibling_section(
     section: 'ArchiveSection',
@@ -168,3 +170,54 @@ def get_composition(children_names: 'list[str]') -> str:
     children_count_tup = np.unique(children_names, return_counts=True)
     formula = ''.join([f'{name}({count})' for name, count in zip(*children_count_tup)])
     return formula if formula else None
+
+
+def check_simulation_cell(cell_1: 'Cell', cell_2: 'Cell') -> bool:
+    """
+    Check if the two `Cell` objects are the same by checking if the defined `positions` are all matching. If
+    the objects are `AtomicCell`, it checks if the `AtomsState[*].chemical_symbol` are the same.
+
+    Args:
+        cell_1 (Cell): The first `Cell` to compare.
+        cell_2 (Cell): The second `Cell` to compare.
+
+    Returns:
+        bool: True if the cells are the same, False otherwise.
+    """
+    # If any of the cells is None or the positions are empty, return False
+    if cell_1 is None or cell_2 is None:
+        return False
+    if cell_1.positions is None or cell_2.positions is None:
+        return False
+
+    # The `positions` should have the same length (same number of positions)
+    if len(cell_1.positions) != len(cell_2.positions):
+        return False
+    n_positions = len(cell_1.positions)
+
+    # Check that all the `positions`` of `cell_1` match with the ones in `cell_2`
+    check_positions = []
+    for i1, pos1 in enumerate(cell_1.positions):
+        for i2, pos2 in enumerate(cell_2.positions):
+            if np.allclose(pos1, pos2):
+                check_positions.append([i1, i2])
+                break
+    if len(check_positions) != n_positions:
+        return False
+
+    # If the cells are not `AtomicCell`, finish function (using m_def.name to avoid circular import problems)
+    if cell_1.m_def.name == 'Cell' and cell_2.m_def.name == 'Cell':
+        return True
+    if cell_1.m_def.name != 'AtomicCell' or cell_2.m_def.name != 'AtomicCell':
+        return False
+
+    # Check that the `chemical_symbol` of the atoms in `cell_1` match with the ones in `cell_2`
+    try:
+        for atom in check_positions:
+            element_1 = cell_1.atoms_state[atom[0]].chemical_symbol
+            element_2 = cell_2.atoms_state[atom[1]].chemical_symbol
+            if element_1 != element_2:
+                return False
+    except Exception:
+        return False
+    return True

tests/test_utils.py

@@ -18,12 +18,15 @@
 
 import pytest
 
+from nomad_simulations.schema_packages.atoms_state import AtomsState
 from nomad_simulations.schema_packages.model_system import (
     AtomicCell,
+    Cell,
     ModelSystem,
     Symmetry,
 )
 from nomad_simulations.schema_packages.utils import (
+    check_simulation_cell,
     get_sibling_section,
     get_variables,
     is_not_representative,
@@ -93,3 +96,110 @@ def test_get_variables(variables: list, result: list, result_length: int):
     assert len(energies) == result_length
     for i, energy in enumerate(energies):  # asserting energies == result does not work
         assert energy.n_points == result[i].n_points
+
+
+@pytest.mark.parametrize(
+    'cell_1, cell_2, result',
+    [
+        (None, None, False),  # both are None
+        (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_check_simulation_cell(cell_1: Cell, cell_2: Cell, result: bool):
+    """
+    Test the `check_simulation_cell` utility function.
+    """
+    assert check_simulation_cell(cell_1=cell_1, cell_2=cell_2) == result