@mat3ra/made 2025.8.9-0 → 2025.8.23-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2025.8.9-0",
+    "version": "2025.8.23-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",

package/src/py/mat3ra/made/basis/__init__.py

@@ -184,9 +184,17 @@ class Basis(BasisSchema, InMemoryEntityPydantic):
         self.coordinates.filter_by_ids(ids)
         return self
 
-    def set_labels_from_list(self, labels: List[Union[int, str]]) -> None:
+    def set_labels_from_list(self, labels: Optional[List[Union[int, str]]]) -> None:
+        """
+        Set the labels of the basis from a list of labels (i. e. [1,1,1] for a 3-atom basis).
+            If None or [] are passed, the labels are removed (set to an empty array).
+        """
         num_atoms = len(self.elements.values)
 
+        if labels is None or len(labels) == 0:
+            self.labels = ArrayWithIds.from_values([])
+            return
+
         if len(labels) != num_atoms:
             raise ValueError(f"Number of labels ({len(labels)}) must match number of atoms ({num_atoms})")
 

package/src/py/mat3ra/made/material.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Union
+from typing import Any, List, Optional, Union
 
 from mat3ra.code.constants import AtomicCoordinateUnits, Units
 from mat3ra.code.entity import HasDescriptionHasMetadataNamedDefaultableInMemoryEntityPydantic
@@ -103,7 +103,7 @@ class Material(MaterialSchema, HasDescriptionHasMetadataNamedDefaultableInMemory
     def add_atom(self, element: str, coordinate: List[float], use_cartesian_coordinates: bool = False) -> None:
         self.basis.add_atom(element, coordinate, use_cartesian_coordinates)
 
-    def set_labels_from_list(self, labels: List[Union[int, str]]) -> None:
+    def set_labels_from_list(self, labels: Optional[List[Union[int, str]]]) -> None:
         self.basis.set_labels_from_list(labels)
 
     def set_labels_from_value(self, value: Union[int, str]) -> None:

package/src/py/mat3ra/made/tools/analyze/basis/__init__.py

@@ -0,0 +1,4 @@
+from .analyzer import BasisMaterialAnalyzer
+from .fingerprint import LayeredFingerprintAlongAxis
+
+__all__ = ["BasisMaterialAnalyzer", "LayeredFingerprintAlongAxis"]

package/src/py/mat3ra/made/tools/analyze/basis/analyzer.py

@@ -0,0 +1,82 @@
+from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
+from mat3ra.made.utils import AXIS_TO_INDEX_MAP
+
+from ...build_components.metadata import MaterialWithBuildMetadata
+from .. import BaseMaterialAnalyzer
+from .fingerprint import LayeredFingerprintAlongAxis, LayerFingerprint
+
+
+class BasisMaterialAnalyzer(BaseMaterialAnalyzer):
+    def get_layer_fingerprint(
+        self, layer_thickness: float = 1.0, axis: AxisEnum = AxisEnum.z
+    ) -> LayeredFingerprintAlongAxis:
+        """
+        Create a fingerprint of the material by analyzing layers along the specified axis.
+
+        Args:
+            layer_thickness: Thickness of each layer in Angstroms
+            axis: Axis along which to compute the fingerprint
+
+        Returns:
+            LayeredFingerprintAlongAxis: Structured fingerprint with layer information
+        """
+        material_cartesian = self.material.clone()
+        material_cartesian.to_cartesian()
+
+        coordinates = material_cartesian.basis.coordinates.values
+        elements = material_cartesian.basis.elements.values
+
+        axis_index = AXIS_TO_INDEX_MAP[axis.value]
+        axis_coords = [coord[axis_index] for coord in coordinates]
+        min_coord, max_coord = min(axis_coords), max(axis_coords)
+
+        fingerprint = LayeredFingerprintAlongAxis(axis=axis, layer_thickness=layer_thickness)
+
+        current_coord = min_coord
+        while current_coord < max_coord:
+            layer_min = current_coord
+            layer_max = current_coord + layer_thickness
+
+            layer_elements = []
+            for i, coord_val in enumerate(axis_coords):
+                if layer_min <= coord_val < layer_max:
+                    layer_elements.append(elements[i])
+
+            unique_elements = sorted(list(set(layer_elements))) if layer_elements else []
+            layer = LayerFingerprint(min_coord=layer_min, max_coord=layer_max, elements=unique_elements)
+            fingerprint.layers.append(layer)
+
+            current_coord += layer_thickness
+
+        return fingerprint
+
+    def is_orientation_flipped(
+        self, original_material: MaterialWithBuildMetadata, layer_thickness: float = 1.0
+    ) -> bool:
+        """
+        Detect if the material orientation is flipped compared to the original.
+        Uses Jaccard similarity to compare fingerprints in normal and flipped orientations.
+
+        Args:
+            original_material: The original material before primitivization
+            layer_thickness: Thickness of layers for fingerprint comparison
+
+        Returns:
+            bool: True if orientation is flipped, False otherwise
+        """
+        original_analyzer = BasisMaterialAnalyzer(material=original_material)
+        original_fingerprint = original_analyzer.get_layer_fingerprint(layer_thickness)
+        current_fingerprint = self.get_layer_fingerprint(layer_thickness)
+
+        normal_score = original_fingerprint.get_similarity_score(current_fingerprint)
+        flipped_score = original_fingerprint.get_similarity_score(self._reverse_fingerprint(current_fingerprint))
+
+        # If flipped orientation has significantly higher similarity, material is flipped
+        threshold = 0.1
+        return flipped_score > normal_score + threshold
+
+    def _reverse_fingerprint(self, fingerprint: LayeredFingerprintAlongAxis) -> LayeredFingerprintAlongAxis:
+        reversed_layers = list(reversed(fingerprint.layers))
+        return LayeredFingerprintAlongAxis(
+            layers=reversed_layers, axis=fingerprint.axis, layer_thickness=fingerprint.layer_thickness
+        )

package/src/py/mat3ra/made/tools/analyze/basis/fingerprint.py

@@ -0,0 +1,65 @@
+from typing import List
+
+from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
+from pydantic import BaseModel, Field
+
+
+class LayerFingerprint(BaseModel):
+    min_coord: float = Field(..., description="Minimum coordinate value for the layer")
+    max_coord: float = Field(..., description="Maximum coordinate value for the layer")
+    elements: List[str] = Field(default_factory=list, description="Sorted unique chemical elements in the layer")
+
+
+class LayeredFingerprintAlongAxis(BaseModel):
+    layers: List[LayerFingerprint] = Field(default_factory=list, description="List of layer fingerprints")
+    axis: AxisEnum = Field(default=AxisEnum.z, description="Axis along which the fingerprint is computed")
+    layer_thickness: float = Field(default=1.0, gt=0, description="Thickness of each layer in Angstroms")
+
+    def get_non_empty_layers(self) -> List[LayerFingerprint]:
+        return [layer for layer in self.layers if layer.elements]
+
+    def get_element_sequence(self) -> List[List[str]]:
+        return [layer.elements for layer in self.layers]
+
+    def get_non_empty_element_sequence(self) -> List[List[str]]:
+        return [layer.elements for layer in self.layers if layer.elements]
+
+    def get_similarity_score(self, other: "LayeredFingerprintAlongAxis") -> float:
+        """
+        Calculate Jaccard similarity score between this and another fingerprint.
+
+        Args:
+            other: Another LayeredFingerprintAlongAxis to compare with
+
+        Returns:
+            float: Average Jaccard similarity score (0.0 to 1.0)
+        """
+        if not self.layers or not other.layers:
+            return 0.0
+
+        min_length = min(len(self.layers), len(other.layers))
+        if min_length == 0:
+            return 0.0
+
+        total_score = 0.0
+
+        for i in range(min_length):
+            elements1 = self.layers[i].elements
+            elements2 = other.layers[i].elements
+
+            # Handle empty layers
+            if len(elements1) == 0 and len(elements2) == 0:
+                layer_score = 1.0
+            elif len(elements1) == 0 or len(elements2) == 0:
+                layer_score = 0.0
+            else:
+                # Calculate Jaccard similarity
+                set1 = set(elements1)
+                set2 = set(elements2)
+                intersection = len(set1.intersection(set2))
+                union = len(set1.union(set2))
+                layer_score = intersection / union if union > 0 else 0.0
+
+            total_score += layer_score
+
+        return total_score / min_length

package/src/py/mat3ra/made/tools/analyze/interface/zsl.py

@@ -84,38 +84,49 @@ class ZSLInterfaceAnalyzer(InterfaceAnalyzer):
                 continue
             match_holders.append(match_holder)
 
+        match_holders = self.purge_equivalent_matches(match_holders)
+
         # sort matches by strain in ascending order, then for each equal strain by area in ascending order
         match_holders = self.sort_by_strain_then_area(match_holders)
 
         return match_holders
 
+    def purge_equivalent_matches(self, match_holders: List[ZSLMatchHolder]) -> List[ZSLMatchHolder]:
+        unique_matches = []
+        seen_matches = set()
+
+        for holder in match_holders:
+            match_key = (
+                round(holder.match_area / self.math_precision) * self.math_precision,
+                round(holder.total_strain_percentage / self.math_precision) * self.math_precision,
+            )
+
+            if match_key not in seen_matches:
+                seen_matches.add(match_key)
+                unique_matches.append(holder)
+
+        return unique_matches
+
     def convert_generated_match_to_match_holder(self, match_id: int, match_pymatgen) -> Optional[ZSLMatchHolder]:
         film_slab_vectors = np.array(self.film_slab.lattice.vector_arrays[0:2])[:, :2]
         substrate_slab_vectors = np.array(self.substrate_slab.lattice.vector_arrays[0:2])[:, :2]
 
         pymatgen_film_sl_vectors = match_pymatgen.film_sl_vectors[:, :2]
-        pymatgen_film_sl_vectors = align_first_vector_to_x_2d_right_handed(pymatgen_film_sl_vectors)
-
         pymatgen_substrate_sl_vectors = match_pymatgen.substrate_sl_vectors[:, :2]
-        pymatgen_substrate_sl_vectors = align_first_vector_to_x_2d_right_handed(pymatgen_substrate_sl_vectors)
 
-        a_colinear = are_vectors_colinear(pymatgen_film_sl_vectors[0], pymatgen_substrate_sl_vectors[0])
-        b_colinear = are_vectors_colinear(pymatgen_film_sl_vectors[1], pymatgen_substrate_sl_vectors[1])
-        if not (a_colinear and b_colinear):
+        film_sl_vectors, substrate_sl_vectors = self._get_sl_vectors_for_supercell_calculation(
+            pymatgen_film_sl_vectors, pymatgen_substrate_sl_vectors
+        )
+        if film_sl_vectors is None:
             return None
 
-        film_supercell_matrix = np.rint(np.linalg.solve(film_slab_vectors, pymatgen_film_sl_vectors)).astype(int)
-        substrate_supercell_matrix = np.rint(
-            np.linalg.solve(substrate_slab_vectors, pymatgen_substrate_sl_vectors)
-        ).astype(int)
-
-        area = match_pymatgen.match_area
-        if self.reduce_result_cell:
-            # If possible, reduce supercell matrices by their GCD
-            g = get_global_gcd(film_supercell_matrix, substrate_supercell_matrix)
-            film_supercell_matrix = film_supercell_matrix // g
-            substrate_supercell_matrix = substrate_supercell_matrix // g
-            area = area / g**2
+        film_supercell_matrix, substrate_supercell_matrix, area = self._calculate_and_reduce_supercell_matrices(
+            film_slab_vectors,
+            substrate_slab_vectors,
+            film_sl_vectors,
+            substrate_sl_vectors,
+            match_pymatgen.match_area,
+        )
 
         film_sl_supercell_vectors = film_supercell_matrix @ film_slab_vectors
         substrate_sl_supercell_vectors = substrate_supercell_matrix @ substrate_slab_vectors
@@ -126,10 +137,9 @@ class ZSLInterfaceAnalyzer(InterfaceAnalyzer):
         ):
             return None
 
-        real_strain_matrix = np.linalg.solve(film_sl_supercell_vectors, substrate_sl_supercell_vectors)
-
-        real_strain_matrix = convert_2x2_to_3x3(real_strain_matrix.tolist())
-        strain_percentage = self.calculate_total_strain_percentage(real_strain_matrix)
+        real_strain_matrix, strain_percentage = self._calculate_strain(
+            film_sl_supercell_vectors, substrate_sl_supercell_vectors
+        )
 
         return ZSLMatchHolder(
             match_id=match_id,
@@ -140,6 +150,65 @@ class ZSLInterfaceAnalyzer(InterfaceAnalyzer):
             total_strain_percentage=strain_percentage,
         )
 
+    def _get_sl_vectors_for_supercell_calculation(self, pymatgen_film_sl_vectors, pymatgen_substrate_sl_vectors):
+        """
+        Determine which superlattice vectors to use for supercell matrix calculation.
+
+        Calculating the supercell transformation matrix requires that corresponding
+        superlattice vectors of film and substrate are colinear. Non-colinear vectors
+        cannot be used to derive a valid integer transformation matrix from original to supercell.
+        While diagonal matrices can be used, and can give smaller area match, so they should be preserved.
+        """
+        pymatgen_substrate_sl_vectors_aligned = align_first_vector_to_x_2d_right_handed(pymatgen_substrate_sl_vectors)
+        pymatgen_film_sl_vectors_aligned = align_first_vector_to_x_2d_right_handed(pymatgen_film_sl_vectors)
+
+        a_colinear = are_vectors_colinear(pymatgen_film_sl_vectors_aligned[0], pymatgen_substrate_sl_vectors_aligned[0])
+        b_colinear = are_vectors_colinear(pymatgen_film_sl_vectors_aligned[1], pymatgen_substrate_sl_vectors_aligned[1])
+
+        if not (a_colinear and b_colinear):
+            return None, None
+
+        is_film_diag = np.allclose(pymatgen_film_sl_vectors_aligned, np.diag(np.diag(pymatgen_film_sl_vectors_aligned)))
+        is_substrate_diag = np.allclose(
+            pymatgen_substrate_sl_vectors_aligned, np.diag(np.diag(pymatgen_substrate_sl_vectors_aligned))
+        )
+
+        if is_film_diag and is_substrate_diag:
+            return pymatgen_film_sl_vectors, pymatgen_substrate_sl_vectors
+        else:
+            return pymatgen_film_sl_vectors_aligned, pymatgen_substrate_sl_vectors_aligned
+
+    def _calculate_and_reduce_supercell_matrices(
+        self, film_slab_vectors, substrate_slab_vectors, film_sl_vectors, substrate_sl_vectors, match_area
+    ):
+        film_supercell_matrix = np.rint(np.linalg.solve(film_slab_vectors, film_sl_vectors)).astype(int)
+        substrate_supercell_matrix = np.rint(np.linalg.solve(substrate_slab_vectors, substrate_sl_vectors)).astype(int)
+
+        area = match_area
+        if self.reduce_result_cell:
+            g = get_global_gcd(film_supercell_matrix, substrate_supercell_matrix)
+            film_supercell_matrix = film_supercell_matrix // g
+            substrate_supercell_matrix = substrate_supercell_matrix // g
+            area = area / g**2
+
+        return film_supercell_matrix, substrate_supercell_matrix, area
+
+    def _calculate_strain(self, film_sl_supercell_vectors, substrate_sl_supercell_vectors):
+        film_det = np.linalg.det(film_sl_supercell_vectors)
+        substrate_det = np.linalg.det(substrate_sl_supercell_vectors)
+
+        # Handle cases where lattices match but are oriented in opposite directions (e.g., 180° rotation).
+        # This keeps the right-handed system for the strain calculation.
+        # The strain calculation uses vector magnitudes, so we need consistent orientation to avoid artificial strain
+        if (film_det > 0) != (substrate_det > 0):
+            film_sl_supercell_vectors = film_sl_supercell_vectors.copy()
+            film_sl_supercell_vectors[1] = -film_sl_supercell_vectors[1]
+
+        real_strain_matrix = np.linalg.solve(film_sl_supercell_vectors, substrate_sl_supercell_vectors)
+        real_strain_matrix = convert_2x2_to_3x3(real_strain_matrix.tolist())
+        strain_percentage = self.calculate_total_strain_percentage(real_strain_matrix)
+        return real_strain_matrix, strain_percentage
+
     def get_strained_configuration_by_match_id(self, match_id: int) -> MatchedSubstrateFilmConfigurationHolder:
         match_holders = self.zsl_match_holders
         if not match_holders:

package/src/py/mat3ra/made/tools/analyze/lattice.py

@@ -1,7 +1,9 @@
 from ..build_components.metadata import MaterialWithBuildMetadata
 from ..convert import from_pymatgen, to_pymatgen
+from ..operations.core.unary import rotate
 from ..third_party import PymatgenSpacegroupAnalyzer
 from . import BaseMaterialAnalyzer
+from .basis import BasisMaterialAnalyzer
 
 
 class LatticeMaterialAnalyzer(BaseMaterialAnalyzer):
@@ -18,6 +20,14 @@ class LatticeMaterialAnalyzer(BaseMaterialAnalyzer):
             from_pymatgen(self.spacegroup_analyzer.get_primitive_standard_structure())
         )
 
+    @property
+    def material_with_primitive_lattice_standard(self) -> MaterialWithBuildMetadata:
+        """
+        Get material with primitive lattice and standard orientation correction.
+        Uses default parameters: return_original_if_not_reduced=False, keep_orientation=True
+        """
+        return self.get_material_with_primitive_lattice_standard()
+
     @property
     def material_with_conventional_lattice(self: MaterialWithBuildMetadata) -> MaterialWithBuildMetadata:
         """
@@ -27,6 +37,38 @@ class LatticeMaterialAnalyzer(BaseMaterialAnalyzer):
             from_pymatgen(self.spacegroup_analyzer.get_conventional_standard_structure())
         )
 
+    def get_material_with_primitive_lattice_standard(
+        self, return_original_if_not_reduced: bool = False, keep_orientation: bool = True, layer_thickness: float = 1.0
+    ) -> MaterialWithBuildMetadata:
+        """
+        Get material with primitive lattice and optional orientation correction to be standardized.
+
+        Args:
+            return_original_if_not_reduced: If True, return original material when no reduction occurs
+            keep_orientation: If True, correct orientation after primitive conversion
+            layer_thickness: Thickness of layers for orientation detection
+
+        Returns:
+            MaterialWithBuildMetadata: Material with primitive lattice
+        """
+        material_with_primitive_lattice = self.material_with_primitive_lattice
+        original_number_of_atoms = self.material.basis.number_of_atoms
+        primitive_structure_number_of_atoms = material_with_primitive_lattice.basis.number_of_atoms
+
+        if original_number_of_atoms == primitive_structure_number_of_atoms:
+            if return_original_if_not_reduced:
+                return self.material
+
+        if keep_orientation:
+            basis_analyzer = BasisMaterialAnalyzer(material=material_with_primitive_lattice)
+            if basis_analyzer.is_orientation_flipped(self.material, layer_thickness):
+                material_with_primitive_lattice = rotate(
+                    material_with_primitive_lattice, axis=[1, 0, 0], angle=180, rotate_cell=False
+                )
+                print("Orientation corrected after primitive conversion.")
+
+        return material_with_primitive_lattice
+
 
 def get_material_with_conventional_lattice(material: MaterialWithBuildMetadata) -> MaterialWithBuildMetadata:
     analyzer = LatticeMaterialAnalyzer(material=material)
@@ -34,15 +76,7 @@ def get_material_with_conventional_lattice(material: MaterialWithBuildMetadata)
 
 
 def get_material_with_primitive_lattice(
-    material: MaterialWithBuildMetadata, return_original_if_not_reduced=False
+    material: MaterialWithBuildMetadata, return_original_if_not_reduced=False, keep_orientation=True
 ) -> MaterialWithBuildMetadata:
     analyzer = LatticeMaterialAnalyzer(material=material)
-    material_with_primitive_lattice = analyzer.material_with_primitive_lattice
-    original_number_of_atoms = material.basis.number_of_atoms
-    primitive_structure_number_of_atoms = material_with_primitive_lattice.basis.number_of_atoms
-    if original_number_of_atoms == primitive_structure_number_of_atoms:
-        # Not reduced, return original material if requested, to avoid unnecessary editions
-        if return_original_if_not_reduced:
-            return material
-    # Reduced, return the primitive structure
-    return material_with_primitive_lattice
+    return analyzer.get_material_with_primitive_lattice_standard(return_original_if_not_reduced, keep_orientation)

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/base/builder.py

@@ -82,8 +82,9 @@ class InterfaceBuilder(StackNComponentsBuilder):
     ) -> MaterialWithBuildMetadata:
         build_params = cast(InterfaceBuilderParameters, self.build_parameters)
         if build_params.make_primitive:
-            # TODO: check that this doesn't warp material or flip it -- otherwise raise and skip
-            primitive_material = get_material_with_primitive_lattice(material, return_original_if_not_reduced=True)
+            primitive_material = get_material_with_primitive_lattice(
+                material, return_original_if_not_reduced=True, keep_orientation=True
+            )
 
             if primitive_material != material:
                 if configuration is None:

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/commensurate/helpers.py

@@ -5,6 +5,7 @@ from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
 
 from mat3ra.made.material import Material
 from .. import InterfaceBuilder, InterfaceConfiguration
+from ......build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
 from .....pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
     SlabStrainedSupercellConfiguration,
 )
@@ -142,8 +143,9 @@ def create_interface_commensurate(
         use_conventional_cell=use_conventional_cell,
     )
 
+    vacuum_config = VacuumConfiguration(size=vacuum, crystal=None, direction=direction)
     interface_config = InterfaceConfiguration(
-        stack_components=strained_configs,
+        stack_components=strained_configs + [vacuum_config],
         gaps=ArrayWithIds.from_values([gap, gap]),
         direction=direction,
     )

package/tests/py/unit/fixtures/grain_boundary.py

@@ -1,5 +1,317 @@
 GRAIN_BOUNDARY_SI_001_011 = {
     "name": "Si(011)-Si(001), Grain Boundary",
+    "basis": {
+        "elements": [
+            {"id": 0, "value": "Si"},
+            {"id": 1, "value": "Si"},
+            {"id": 2, "value": "Si"},
+            {"id": 3, "value": "Si"},
+            {"id": 4, "value": "Si"},
+            {"id": 5, "value": "Si"},
+            {"id": 6, "value": "Si"},
+            {"id": 7, "value": "Si"},
+            {"id": 8, "value": "Si"},
+            {"id": 9, "value": "Si"},
+            {"id": 10, "value": "Si"},
+            {"id": 11, "value": "Si"},
+            {"id": 12, "value": "Si"},
+            {"id": 13, "value": "Si"},
+            {"id": 14, "value": "Si"},
+            {"id": 15, "value": "Si"},
+            {"id": 16, "value": "Si"},
+            {"id": 17, "value": "Si"},
+            {"id": 18, "value": "Si"},
+            {"id": 19, "value": "Si"},
+            {"id": 20, "value": "Si"},
+            {"id": 21, "value": "Si"},
+            {"id": 22, "value": "Si"},
+            {"id": 23, "value": "Si"},
+            {"id": 24, "value": "Si"},
+            {"id": 25, "value": "Si"},
+            {"id": 26, "value": "Si"},
+            {"id": 27, "value": "Si"},
+            {"id": 28, "value": "Si"},
+            {"id": 29, "value": "Si"},
+            {"id": 30, "value": "Si"},
+            {"id": 31, "value": "Si"},
+            {"id": 32, "value": "Si"},
+            {"id": 33, "value": "Si"},
+            {"id": 34, "value": "Si"},
+            {"id": 35, "value": "Si"},
+            {"id": 36, "value": "Si"},
+            {"id": 37, "value": "Si"},
+            {"id": 38, "value": "Si"},
+            {"id": 39, "value": "Si"},
+            {"id": 40, "value": "Si"},
+            {"id": 41, "value": "Si"},
+            {"id": 42, "value": "Si"},
+            {"id": 43, "value": "Si"},
+            {"id": 44, "value": "Si"},
+            {"id": 45, "value": "Si"},
+            {"id": 46, "value": "Si"},
+            {"id": 47, "value": "Si"},
+            {"id": 48, "value": "Si"},
+            {"id": 49, "value": "Si"},
+            {"id": 50, "value": "Si"},
+            {"id": 51, "value": "Si"},
+            {"id": 52, "value": "Si"},
+            {"id": 53, "value": "Si"},
+            {"id": 54, "value": "Si"},
+            {"id": 55, "value": "Si"},
+            {"id": 56, "value": "Si"},
+            {"id": 57, "value": "Si"},
+            {"id": 58, "value": "Si"},
+            {"id": 59, "value": "Si"},
+            {"id": 60, "value": "Si"},
+            {"id": 61, "value": "Si"},
+            {"id": 62, "value": "Si"},
+            {"id": 63, "value": "Si"},
+            {"id": 64, "value": "Si"},
+            {"id": 65, "value": "Si"},
+            {"id": 66, "value": "Si"},
+            {"id": 67, "value": "Si"},
+            {"id": 68, "value": "Si"},
+            {"id": 69, "value": "Si"},
+            {"id": 70, "value": "Si"},
+            {"id": 71, "value": "Si"},
+            {"id": 72, "value": "Si"},
+            {"id": 73, "value": "Si"},
+            {"id": 74, "value": "Si"},
+            {"id": 75, "value": "Si"},
+            {"id": 76, "value": "Si"},
+            {"id": 77, "value": "Si"},
+            {"id": 78, "value": "Si"},
+            {"id": 79, "value": "Si"},
+            {"id": 80, "value": "Si"},
+            {"id": 81, "value": "Si"},
+            {"id": 82, "value": "Si"},
+            {"id": 83, "value": "Si"},
+            {"id": 84, "value": "Si"},
+            {"id": 85, "value": "Si"},
+            {"id": 86, "value": "Si"},
+            {"id": 87, "value": "Si"},
+            {"id": 88, "value": "Si"},
+            {"id": 89, "value": "Si"},
+            {"id": 90, "value": "Si"},
+            {"id": 91, "value": "Si"},
+            {"id": 92, "value": "Si"},
+            {"id": 93, "value": "Si"},
+            {"id": 94, "value": "Si"},
+            {"id": 95, "value": "Si"},
+        ],
+        "coordinates": [
+            {"id": 0, "value": [0.408723941, 0.857142857, 0.5]},
+            {"id": 1, "value": [0.272482809, 0.821428571, 0.25]},
+            {"id": 2, "value": [0.136241677, 0.785714286, 0.5]},
+            {"id": 3, "value": [5.45e-7, 0.75, 0.25]},
+            {"id": 4, "value": [0.136241677, 0.857142857, 0]},
+            {"id": 5, "value": [5.45e-7, 0.821428571, 0.75]},
+            {"id": 6, "value": [0.408723941, 0.785714286, 0]},
+            {"id": 7, "value": [0.272482809, 0.75, 0.75]},
+            {"id": 8, "value": [0.408723941, 0.714285714, 0.5]},
+            {"id": 9, "value": [0.272482809, 0.678571429, 0.25]},
+            {"id": 10, "value": [0.136241677, 0.642857143, 0.5]},
+            {"id": 11, "value": [5.45e-7, 0.607142857, 0.25]},
+            {"id": 12, "value": [0.136241677, 0.714285714, 0]},
+            {"id": 13, "value": [5.45e-7, 0.678571429, 0.75]},
+            {"id": 14, "value": [0.408723941, 0.642857143, 0]},
+            {"id": 15, "value": [0.272482809, 0.607142857, 0.75]},
+            {"id": 16, "value": [0.408723941, 0.571428571, 0.5]},
+            {"id": 17, "value": [0.272482809, 0.535714286, 0.25]},
+            {"id": 18, "value": [0.136241677, 0.5, 0.5]},
+            {"id": 19, "value": [5.45e-7, 0.464285714, 0.25]},
+            {"id": 20, "value": [0.136241677, 0.571428571, 0]},
+            {"id": 21, "value": [5.45e-7, 0.535714286, 0.75]},
+            {"id": 22, "value": [0.408723941, 0.5, 0]},
+            {"id": 23, "value": [0.272482809, 0.464285714, 0.75]},
+            {"id": 24, "value": [0.408723941, 0.428571429, 0.5]},
+            {"id": 25, "value": [0.272482809, 0.392857143, 0.25]},
+            {"id": 26, "value": [0.136241677, 0.357142857, 0.5]},
+            {"id": 27, "value": [5.45e-7, 0.321428571, 0.25]},
+            {"id": 28, "value": [0.136241677, 0.428571429, 0]},
+            {"id": 29, "value": [5.45e-7, 0.392857143, 0.75]},
+            {"id": 30, "value": [0.408723941, 0.357142857, 0]},
+            {"id": 31, "value": [0.272482809, 0.321428571, 0.75]},
+            {"id": 32, "value": [0.408723941, 0.285714286, 0.5]},
+            {"id": 33, "value": [0.272482809, 0.25, 0.25]},
+            {"id": 34, "value": [0.136241677, 0.214285714, 0.5]},
+            {"id": 35, "value": [5.45e-7, 0.178571429, 0.25]},
+            {"id": 36, "value": [0.136241677, 0.285714286, 0]},
+            {"id": 37, "value": [5.45e-7, 0.25, 0.75]},
+            {"id": 38, "value": [0.408723941, 0.214285714, 0]},
+            {"id": 39, "value": [0.272482809, 0.178571429, 0.75]},
+            {"id": 40, "value": [0.408723941, 0.142857143, 0.5]},
+            {"id": 41, "value": [0.272482809, 0.107142857, 0.25]},
+            {"id": 42, "value": [0.136241677, 0.071428571, 0.5]},
+            {"id": 43, "value": [5.45e-7, 0.035714286, 0.25]},
+            {"id": 44, "value": [0.136241677, 0.142857143, 0]},
+            {"id": 45, "value": [5.45e-7, 0.107142857, 0.75]},
+            {"id": 46, "value": [0.408723941, 0.071428571, 0]},
+            {"id": 47, "value": [0.272482809, 0.035714286, 0.75]},
+            {"id": 48, "value": [0.408723941, 0, 0.5]},
+            {"id": 49, "value": [0.272482809, 0.964285714, 0.25]},
+            {"id": 50, "value": [0.136241677, 0.928571429, 0.5]},
+            {"id": 51, "value": [5.45e-7, 0.892857143, 0.25]},
+            {"id": 52, "value": [0.136241677, 0, 0]},
+            {"id": 53, "value": [5.45e-7, 0.964285714, 0.75]},
+            {"id": 54, "value": [0.408723941, 0.928571429, 0]},
+            {"id": 55, "value": [0.272482809, 0.892857143, 0.75]},
+            {"id": 56, "value": [0.800699192, 0.676122483, 0.86571336]},
+            {"id": 57, "value": [0.800699192, 0.626122483, 0.11571336]},
+            {"id": 58, "value": [0.800699192, 0.776122483, 0.86571336]},
+            {"id": 59, "value": [0.800699192, 0.726122483, 0.11571336]},
+            {"id": 60, "value": [0.608025135, 0.726122483, 0.36571336]},
+            {"id": 61, "value": [0.608025135, 0.676122483, 0.61571336]},
+            {"id": 62, "value": [0.608025135, 0.626122483, 0.36571336]},
+            {"id": 63, "value": [0.608025135, 0.776122483, 0.61571336]},
+            {"id": 64, "value": [0.800699192, 0.476122483, 0.86571336]},
+            {"id": 65, "value": [0.800699192, 0.426122483, 0.11571336]},
+            {"id": 66, "value": [0.800699192, 0.576122483, 0.86571336]},
+            {"id": 67, "value": [0.800699192, 0.526122483, 0.11571336]},
+            {"id": 68, "value": [0.608025135, 0.526122483, 0.36571336]},
+            {"id": 69, "value": [0.608025135, 0.476122483, 0.61571336]},
+            {"id": 70, "value": [0.608025135, 0.426122483, 0.36571336]},
+            {"id": 71, "value": [0.608025135, 0.576122483, 0.61571336]},
+            {"id": 72, "value": [0.800699192, 0.276122483, 0.86571336]},
+            {"id": 73, "value": [0.800699192, 0.226122483, 0.11571336]},
+            {"id": 74, "value": [0.800699192, 0.376122483, 0.86571336]},
+            {"id": 75, "value": [0.800699192, 0.326122483, 0.11571336]},
+            {"id": 76, "value": [0.608025135, 0.326122483, 0.36571336]},
+            {"id": 77, "value": [0.608025135, 0.276122483, 0.61571336]},
+            {"id": 78, "value": [0.608025135, 0.226122483, 0.36571336]},
+            {"id": 79, "value": [0.608025135, 0.376122483, 0.61571336]},
+            {"id": 80, "value": [0.800699192, 0.076122483, 0.86571336]},
+            {"id": 81, "value": [0.800699192, 0.026122483, 0.11571336]},
+            {"id": 82, "value": [0.800699192, 0.176122483, 0.86571336]},
+            {"id": 83, "value": [0.800699192, 0.126122483, 0.11571336]},
+            {"id": 84, "value": [0.608025135, 0.126122483, 0.36571336]},
+            {"id": 85, "value": [0.608025135, 0.076122483, 0.61571336]},
+            {"id": 86, "value": [0.608025135, 0.026122483, 0.36571336]},
+            {"id": 87, "value": [0.608025135, 0.176122483, 0.61571336]},
+            {"id": 88, "value": [0.800699192, 0.876122483, 0.86571336]},
+            {"id": 89, "value": [0.800699192, 0.826122483, 0.11571336]},
+            {"id": 90, "value": [0.800699192, 0.976122483, 0.86571336]},
+            {"id": 91, "value": [0.800699192, 0.926122483, 0.11571336]},
+            {"id": 92, "value": [0.608025135, 0.926122483, 0.36571336]},
+            {"id": 93, "value": [0.608025135, 0.876122483, 0.61571336]},
+            {"id": 94, "value": [0.608025135, 0.826122483, 0.36571336]},
+            {"id": 95, "value": [0.608025135, 0.976122483, 0.61571336]},
+        ],
+        "units": "crystal",
+        "labels": [
+            {"id": 0, "value": 0},
+            {"id": 1, "value": 0},
+            {"id": 2, "value": 0},
+            {"id": 3, "value": 0},
+            {"id": 4, "value": 0},
+            {"id": 5, "value": 0},
+            {"id": 6, "value": 0},
+            {"id": 7, "value": 0},
+            {"id": 8, "value": 0},
+            {"id": 9, "value": 0},
+            {"id": 10, "value": 0},
+            {"id": 11, "value": 0},
+            {"id": 12, "value": 0},
+            {"id": 13, "value": 0},
+            {"id": 14, "value": 0},
+            {"id": 15, "value": 0},
+            {"id": 16, "value": 0},
+            {"id": 17, "value": 0},
+            {"id": 18, "value": 0},
+            {"id": 19, "value": 0},
+            {"id": 20, "value": 0},
+            {"id": 21, "value": 0},
+            {"id": 22, "value": 0},
+            {"id": 23, "value": 0},
+            {"id": 24, "value": 0},
+            {"id": 25, "value": 0},
+            {"id": 26, "value": 0},
+            {"id": 27, "value": 0},
+            {"id": 28, "value": 0},
+            {"id": 29, "value": 0},
+            {"id": 30, "value": 0},
+            {"id": 31, "value": 0},
+            {"id": 32, "value": 0},
+            {"id": 33, "value": 0},
+            {"id": 34, "value": 0},
+            {"id": 35, "value": 0},
+            {"id": 36, "value": 0},
+            {"id": 37, "value": 0},
+            {"id": 38, "value": 0},
+            {"id": 39, "value": 0},
+            {"id": 40, "value": 0},
+            {"id": 41, "value": 0},
+            {"id": 42, "value": 0},
+            {"id": 43, "value": 0},
+            {"id": 44, "value": 0},
+            {"id": 45, "value": 0},
+            {"id": 46, "value": 0},
+            {"id": 47, "value": 0},
+            {"id": 48, "value": 0},
+            {"id": 49, "value": 0},
+            {"id": 50, "value": 0},
+            {"id": 51, "value": 0},
+            {"id": 52, "value": 0},
+            {"id": 53, "value": 0},
+            {"id": 54, "value": 0},
+            {"id": 55, "value": 0},
+            {"id": 56, "value": 1},
+            {"id": 57, "value": 1},
+            {"id": 58, "value": 1},
+            {"id": 59, "value": 1},
+            {"id": 60, "value": 1},
+            {"id": 61, "value": 1},
+            {"id": 62, "value": 1},
+            {"id": 63, "value": 1},
+            {"id": 64, "value": 1},
+            {"id": 65, "value": 1},
+            {"id": 66, "value": 1},
+            {"id": 67, "value": 1},
+            {"id": 68, "value": 1},
+            {"id": 69, "value": 1},
+            {"id": 70, "value": 1},
+            {"id": 71, "value": 1},
+            {"id": 72, "value": 1},
+            {"id": 73, "value": 1},
+            {"id": 74, "value": 1},
+            {"id": 75, "value": 1},
+            {"id": 76, "value": 1},
+            {"id": 77, "value": 1},
+            {"id": 78, "value": 1},
+            {"id": 79, "value": 1},
+            {"id": 80, "value": 1},
+            {"id": 81, "value": 1},
+            {"id": 82, "value": 1},
+            {"id": 83, "value": 1},
+            {"id": 84, "value": 1},
+            {"id": 85, "value": 1},
+            {"id": 86, "value": 1},
+            {"id": 87, "value": 1},
+            {"id": 88, "value": 1},
+            {"id": 89, "value": 1},
+            {"id": 90, "value": 1},
+            {"id": 91, "value": 1},
+            {"id": 92, "value": 1},
+            {"id": 93, "value": 1},
+            {"id": 94, "value": 1},
+            {"id": 95, "value": 1},
+        ],
+        "constraints": [],
+    },
+    "lattice": {
+        "a": 10.03508222,
+        "b": 38.281346922,
+        "c": 5.468763846,
+        "alpha": 90,
+        "beta": 90,
+        "gamma": 90,
+        "units": {"length": "angstrom", "angle": "degree"},
+        "type": "TRI",
+    },
+}
+
+GRAIN_BOUNDARY_SI_001_011_GH = {
+    "name": "Si(011)-Si(001), Grain Boundary",
     "basis": {
         "elements": [
             {"id": 0, "value": "Si"},

package/tests/py/unit/fixtures/interface/zsl.py

@@ -538,3 +538,219 @@ GRAPHENE_NICKEL_INTERFACE = {
         "type": "TRI",
     },
 }
+
+DIAMOND_GaAs_INTERFACE = {
+    "name": "AsGa(001)-C(001), Interface, Strain 7.114pct",
+    "basis": {
+        "elements": [
+            {"id": 0, "value": "Ga"},
+            {"id": 1, "value": "Ga"},
+            {"id": 2, "value": "Ga"},
+            {"id": 3, "value": "Ga"},
+            {"id": 4, "value": "As"},
+            {"id": 5, "value": "As"},
+            {"id": 6, "value": "As"},
+            {"id": 7, "value": "As"},
+            {"id": 8, "value": "C"},
+            {"id": 9, "value": "C"},
+            {"id": 10, "value": "C"},
+            {"id": 11, "value": "C"},
+            {"id": 12, "value": "C"},
+            {"id": 13, "value": "C"},
+            {"id": 14, "value": "C"},
+            {"id": 15, "value": "C"},
+            {"id": 16, "value": "C"},
+            {"id": 17, "value": "C"},
+            {"id": 18, "value": "C"},
+            {"id": 19, "value": "C"},
+            {"id": 20, "value": "C"},
+            {"id": 21, "value": "C"},
+            {"id": 22, "value": "C"},
+            {"id": 23, "value": "C"},
+            {"id": 24, "value": "C"},
+            {"id": 25, "value": "C"},
+            {"id": 26, "value": "C"},
+            {"id": 27, "value": "C"},
+        ],
+        "coordinates": [
+            {"id": 0, "value": [0, 0, 0.208703663]},
+            {"id": 1, "value": [0.5, 0, 0.352579044]},
+            {"id": 2, "value": [0, 0.5, 0.352579044]},
+            {"id": 3, "value": [0.5, 0.5, 0.208703663]},
+            {"id": 4, "value": [0.75, 0.75, 0.280641354]},
+            {"id": 5, "value": [0.25, 0.75, 0.424516735]},
+            {"id": 6, "value": [0.75, 0.25, 0.424516735]},
+            {"id": 7, "value": [0.25, 0.25, 0.280641354]},
+            {"id": 8, "value": [0.1, 0.7, 0.133640341]},
+            {"id": 9, "value": [0.2, 0.9, 0.08909362]},
+            {"id": 10, "value": [0, 0, 0.044546899]},
+            {"id": 11, "value": [0.1, 0.2, 1.78e-7]},
+            {"id": 12, "value": [0.4, 0.8, 0.044546899]},
+            {"id": 13, "value": [0.9, 0.8, 1.78e-7]},
+            {"id": 14, "value": [0.3, 0.1, 0.133640341]},
+            {"id": 15, "value": [0.8, 0.1, 0.08909362]},
+            {"id": 16, "value": [0.9, 0.3, 0.133640341]},
+            {"id": 17, "value": [0, 0.5, 0.08909362]},
+            {"id": 18, "value": [0.8, 0.6, 0.044546899]},
+            {"id": 19, "value": [0.2, 0.4, 0.044546899]},
+            {"id": 20, "value": [0.7, 0.4, 1.78e-7]},
+            {"id": 21, "value": [0.6, 0.7, 0.08909362]},
+            {"id": 22, "value": [0.7, 0.9, 0.133640341]},
+            {"id": 23, "value": [0.6, 0.2, 0.044546899]},
+            {"id": 24, "value": [0.5, 0, 1.78e-7]},
+            {"id": 25, "value": [0.4, 0.3, 0.08909362]},
+            {"id": 26, "value": [0.5, 0.5, 0.133640341]},
+            {"id": 27, "value": [0.3, 0.6, 1.78e-7]},
+        ],
+        "units": "crystal",
+        "labels": [
+            {"id": 0, "value": 1},
+            {"id": 1, "value": 1},
+            {"id": 2, "value": 1},
+            {"id": 3, "value": 1},
+            {"id": 4, "value": 1},
+            {"id": 5, "value": 1},
+            {"id": 6, "value": 1},
+            {"id": 7, "value": 1},
+            {"id": 8, "value": 0},
+            {"id": 9, "value": 0},
+            {"id": 10, "value": 0},
+            {"id": 11, "value": 0},
+            {"id": 12, "value": 0},
+            {"id": 13, "value": 0},
+            {"id": 14, "value": 0},
+            {"id": 15, "value": 0},
+            {"id": 16, "value": 0},
+            {"id": 17, "value": 0},
+            {"id": 18, "value": 0},
+            {"id": 19, "value": 0},
+            {"id": 20, "value": 0},
+            {"id": 21, "value": 0},
+            {"id": 22, "value": 0},
+            {"id": 23, "value": 0},
+            {"id": 24, "value": 0},
+            {"id": 25, "value": 0},
+            {"id": 26, "value": 0},
+            {"id": 27, "value": 0},
+        ],
+        "constraints": [],
+    },
+    "lattice": {
+        "a": 5.630032184,
+        "b": 5.630032184,
+        "c": 19.983204895,
+        "alpha": 90,
+        "beta": 90,
+        "gamma": 90,
+        "units": {"length": "angstrom", "angle": "degree"},
+        "type": "TRI",
+    },
+}
+
+DIAMOND_GaAs_INTERFACE_GH = {
+    "name": "AsGa(001)-C(001), Interface, Strain 69.038pct",
+    "basis": {
+        "elements": [
+            {"id": 0, "value": "Ga"},
+            {"id": 1, "value": "Ga"},
+            {"id": 2, "value": "Ga"},
+            {"id": 3, "value": "Ga"},
+            {"id": 4, "value": "As"},
+            {"id": 5, "value": "As"},
+            {"id": 6, "value": "As"},
+            {"id": 7, "value": "As"},
+            {"id": 8, "value": "C"},
+            {"id": 9, "value": "C"},
+            {"id": 10, "value": "C"},
+            {"id": 11, "value": "C"},
+            {"id": 12, "value": "C"},
+            {"id": 13, "value": "C"},
+            {"id": 14, "value": "C"},
+            {"id": 15, "value": "C"},
+            {"id": 16, "value": "C"},
+            {"id": 17, "value": "C"},
+            {"id": 18, "value": "C"},
+            {"id": 19, "value": "C"},
+            {"id": 20, "value": "C"},
+            {"id": 21, "value": "C"},
+            {"id": 22, "value": "C"},
+            {"id": 23, "value": "C"},
+            {"id": 24, "value": "C"},
+            {"id": 25, "value": "C"},
+            {"id": 26, "value": "C"},
+            {"id": 27, "value": "C"},
+        ],
+        "coordinates": [
+            {"id": 0, "value": [0.0, 0.0, 0.208703663]},
+            {"id": 1, "value": [0.5, 0.0, 0.352579044]},
+            {"id": 2, "value": [0.0, 0.5, 0.352579044]},
+            {"id": 3, "value": [0.5, 0.5, 0.208703663]},
+            {"id": 4, "value": [0.75, 0.25, 0.280641354]},
+            {"id": 5, "value": [0.25, 0.25, 0.424516735]},
+            {"id": 6, "value": [0.75, 0.75, 0.424516735]},
+            {"id": 7, "value": [0.25, 0.75, 0.280641354]},
+            {"id": 8, "value": [0.7, 0.9, 0.133640341]},
+            {"id": 9, "value": [0.8, 0.1, 0.08909362]},
+            {"id": 10, "value": [0.6, 0.2, 0.044546899]},
+            {"id": 11, "value": [0.7, 0.4, 1.78e-07]},
+            {"id": 12, "value": [0.0, 0.0, 0.044546899]},
+            {"id": 13, "value": [0.5, 0.0, 1.78e-07]},
+            {"id": 14, "value": [0.9, 0.3, 0.133640341]},
+            {"id": 15, "value": [0.4, 0.3, 0.08909362]},
+            {"id": 16, "value": [0.1, 0.7, 0.133640341]},
+            {"id": 17, "value": [0.2, 0.9, 0.08909362]},
+            {"id": 18, "value": [0.1, 0.2, 1.78e-07]},
+            {"id": 19, "value": [0.4, 0.8, 0.044546899]},
+            {"id": 20, "value": [0.9, 0.8, 1.78e-07]},
+            {"id": 21, "value": [0.3, 0.1, 0.133640341]},
+            {"id": 22, "value": [0.0, 0.5, 0.08909362]},
+            {"id": 23, "value": [0.8, 0.6, 0.044546899]},
+            {"id": 24, "value": [0.2, 0.4, 0.044546899]},
+            {"id": 25, "value": [0.6, 0.7, 0.08909362]},
+            {"id": 26, "value": [0.5, 0.5, 0.133640341]},
+            {"id": 27, "value": [0.3, 0.6, 1.78e-07]},
+        ],
+        "units": "crystal",
+        "labels": [
+            {"id": 0, "value": 1},
+            {"id": 1, "value": 1},
+            {"id": 2, "value": 1},
+            {"id": 3, "value": 1},
+            {"id": 4, "value": 1},
+            {"id": 5, "value": 1},
+            {"id": 6, "value": 1},
+            {"id": 7, "value": 1},
+            {"id": 8, "value": 0},
+            {"id": 9, "value": 0},
+            {"id": 10, "value": 0},
+            {"id": 11, "value": 0},
+            {"id": 12, "value": 0},
+            {"id": 13, "value": 0},
+            {"id": 14, "value": 0},
+            {"id": 15, "value": 0},
+            {"id": 16, "value": 0},
+            {"id": 17, "value": 0},
+            {"id": 18, "value": 0},
+            {"id": 19, "value": 0},
+            {"id": 20, "value": 0},
+            {"id": 21, "value": 0},
+            {"id": 22, "value": 0},
+            {"id": 23, "value": 0},
+            {"id": 24, "value": 0},
+            {"id": 25, "value": 0},
+            {"id": 26, "value": 0},
+            {"id": 27, "value": 0},
+        ],
+        "constraints": [],
+    },
+    "lattice": {
+        "a": 5.630032184,
+        "b": 5.630032184,
+        "c": 19.983204895,
+        "alpha": 90.0,
+        "beta": 90.0,
+        "gamma": 90.0,
+        "units": {"length": "angstrom", "angle": "degree"},
+        "type": "TRI",
+    },
+}

package/tests/py/unit/test_material.py

@@ -1,8 +1,10 @@
 import numpy as np
+import pytest
 from mat3ra.made.basis import Basis, Coordinates
 from mat3ra.made.lattice import Lattice
 from mat3ra.made.material import Material
 from mat3ra.utils import assertion as assertion_utils
+from unit.fixtures.bulk import BULK_Si_PRIMITIVE
 from unit.fixtures.slab import BULK_Si_CONVENTIONAL
 from unit.utils import assert_two_entities_deep_almost_equal
 
@@ -91,3 +93,28 @@ def test_basis_cell_lattice_sync():
     assertion_utils.assert_deep_almost_equal(new_vectors, material.basis.cell.vector_arrays)
     assertion_utils.assert_deep_almost_equal(new_vectors, material.lattice.vector_arrays)
     # Verify basis coordinates are still correct
+
+
+@pytest.mark.parametrize(
+    "initial_labels, reset_labels, expected_final",
+    [
+        # Test resetting with empty list
+        ([1, 2], [], []),
+        # Test resetting with None
+        ([1, 2], None, []),
+        # Test normal behavior with non-empty lists
+        ([], [1, 2], [1, 2]),
+    ],
+)
+def test_set_labels_from_list(initial_labels, reset_labels, expected_final):
+    material = Material.create(BULK_Si_PRIMITIVE)
+
+    if initial_labels:
+        material.basis.set_labels_from_list(initial_labels)
+        assert len(material.basis.labels.values) == len(initial_labels)
+        assert material.basis.labels.values == initial_labels
+
+    material.basis.set_labels_from_list(reset_labels)
+
+    assert len(material.basis.labels.values) == len(expected_final)
+    assert material.basis.labels.values == expected_final

package/tests/py/unit/test_tools_analyze.py

@@ -97,6 +97,7 @@ def test_lattice_material_analyzer(
 ):
     primitive_cell = Material.create(primitive_material_config)
     lattice_material_analyzer = LatticeMaterialAnalyzer(material=primitive_cell)
+
     conventional_cell = lattice_material_analyzer.material_with_conventional_lattice
     assert_two_entities_deep_almost_equal(conventional_cell, expected_conventional_material_config)
 

package/tests/py/unit/test_tools_analyze_basis.py

@@ -0,0 +1,74 @@
+"""
+Tests for basis material analysis functionality.
+"""
+
+import pytest
+from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
+from mat3ra.made.material import Material
+from mat3ra.made.tools.analyze.basis import BasisMaterialAnalyzer, LayeredFingerprintAlongAxis
+
+from .fixtures.bulk import BULK_Si_CONVENTIONAL
+from .fixtures.slab import SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO
+
+
+@pytest.mark.parametrize(
+    "original_material_config, another_material_config, is_flipped",
+    [
+        (SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_O2, False),
+        (SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO, True),
+    ],
+)
+def test_basis_analyzer_fingerprint(original_material_config, another_material_config, is_flipped):
+    original_material = Material.create(original_material_config)
+    another_material = Material.create(another_material_config)
+    analyzer = BasisMaterialAnalyzer(material=original_material)
+
+    fingerprint = analyzer.get_layer_fingerprint(layer_thickness=1.0)
+    assert isinstance(fingerprint, LayeredFingerprintAlongAxis)
+    assert len(fingerprint.layers) > 0
+    assert fingerprint.axis == AxisEnum.z
+    assert fingerprint.layer_thickness == 1.0
+
+    for layer in fingerprint.layers:
+        assert hasattr(layer, "min_coord")
+        assert hasattr(layer, "max_coord")
+        assert hasattr(layer, "elements")
+        assert isinstance(layer.min_coord, float)
+        assert isinstance(layer.max_coord, float)
+        assert layer.max_coord > layer.min_coord
+        assert isinstance(layer.elements, list)
+        assert all(isinstance(elem, str) for elem in layer.elements)
+
+    non_empty_layers = fingerprint.get_non_empty_layers()
+    assert isinstance(non_empty_layers, list)
+    assert all(isinstance(layer, type(fingerprint.layers[0])) for layer in non_empty_layers)
+
+    element_sequence = fingerprint.get_element_sequence()
+    assert isinstance(element_sequence, list)
+    assert all(isinstance(elements, list) for elements in element_sequence)
+
+    is_flipped = analyzer.is_orientation_flipped(another_material)
+    assert is_flipped == is_flipped, "Orientation flipped status does not match expected value."
+
+
+def test_fingerprint_similarity_score():
+    """Test the get_similarity_score method specifically."""
+    material = Material.create(BULK_Si_CONVENTIONAL)
+    analyzer = BasisMaterialAnalyzer(material=material)
+
+    fingerprint = analyzer.get_layer_fingerprint(layer_thickness=1.0)
+
+    # Test self-similarity (should be 1.0)
+    self_score = fingerprint.get_similarity_score(fingerprint)
+    assert self_score == 1.0, "Self-similarity should be perfect"
+
+    # Test with different layer thickness (should be different)
+    different_fp = analyzer.get_layer_fingerprint(layer_thickness=2.0)
+    different_score = fingerprint.get_similarity_score(different_fp)
+    assert isinstance(different_score, float)
+    assert 0.0 <= different_score <= 1.0
+
+    # Test with empty fingerprint
+    empty_fp = LayeredFingerprintAlongAxis(layers=[], axis=AxisEnum.z, layer_thickness=1.0)
+    empty_score = fingerprint.get_similarity_score(empty_fp)
+    assert empty_score == 0.0, "Similarity with empty fingerprint should be 0"

package/tests/py/unit/test_tools_analyze_interface_zsl.py

@@ -110,9 +110,6 @@ def test_zsl_interface_analyzer(substrate, film, zsl_params, expected_matches_mi
 
     assert np.allclose(film_sl_vectors[0:2], substrate_sl_vectors[0:2], atol=1e-4)
 
-    assert np.allclose(substrate_material.lattice.vector_arrays[0:2], substrate_sl_vectors[0:2], atol=1e-4)
-    assert np.allclose(film_material.lattice.vector_arrays[0:2], film_sl_vectors[0:2], atol=1e-4)
-
     assert np.isclose(substrate_material.lattice.a, film_material.lattice.a, atol=1e-4)
     assert np.isclose(substrate_material.lattice.b, film_material.lattice.b, atol=1e-4)
 
@@ -134,7 +131,7 @@ def test_zsl_interface_analyzer(substrate, film, zsl_params, expected_matches_mi
                 vacuum=0.0,
             ),
             {"max_area": 90.0, "max_area_ratio_tol": 0.1, "max_length_tol": 0.1, "max_angle_tol": 0.1},
-            {OSPlatform.DARWIN: 32, OSPlatform.OTHER: 33},
+            {OSPlatform.DARWIN: 29, OSPlatform.OTHER: 29},
             {
                 OSPlatform.DARWIN: {"strain_percentage": 0.474, "match_id": 0},
                 OSPlatform.OTHER: {"strain_percentage": 25.122, "match_id": 0},

package/tests/py/unit/test_tools_build_grain_boundary.py

@@ -15,9 +15,9 @@ from mat3ra.made.tools.build.defective_structures.two_dimensional.grain_boundary
 )
 
 from .fixtures.bulk import BULK_Si_CONVENTIONAL
-from .fixtures.grain_boundary import GRAIN_BOUNDARY_LINEAR_SI, GRAIN_BOUNDARY_SI_001_011
+from .fixtures.grain_boundary import GRAIN_BOUNDARY_LINEAR_SI, GRAIN_BOUNDARY_SI_001_011, GRAIN_BOUNDARY_SI_001_011_GH
 from .fixtures.monolayer import GRAPHENE
-from .utils import assert_two_entities_deep_almost_equal
+from .utils import OSPlatform, assert_two_entities_deep_almost_equal, get_platform_specific_value
 
 
 @pytest.mark.parametrize(
@@ -29,8 +29,11 @@ from .utils import assert_two_entities_deep_almost_equal
             (0, 1, 1),
             2.0,
             [2.0, 1.0],
-            250,
-            GRAIN_BOUNDARY_SI_001_011,
+            220,
+            {
+                OSPlatform.DARWIN: GRAIN_BOUNDARY_SI_001_011,
+                OSPlatform.OTHER: GRAIN_BOUNDARY_SI_001_011_GH,
+            },
         ),
     ],
 )
@@ -50,6 +53,7 @@ def test_create_grain_boundary_planar(
         max_area=max_area,
     )
 
+    expected_material_config = get_platform_specific_value(expected_material_config)
     assert_two_entities_deep_almost_equal(grain_boundary, expected_material_config)
 
 
@@ -62,8 +66,11 @@ def test_create_grain_boundary_planar(
             (0, 1, 1),
             2.0,
             [2.0, 1.0],
-            250,
-            GRAIN_BOUNDARY_SI_001_011,
+            220,
+            {
+                OSPlatform.DARWIN: GRAIN_BOUNDARY_SI_001_011,
+                OSPlatform.OTHER: GRAIN_BOUNDARY_SI_001_011_GH,
+            },
         ),
     ],
 )
@@ -95,6 +102,7 @@ def test_grain_boundary_builder(
     builder = GrainBoundaryPlanarBuilder()
     grain_boundary = builder.get_material(config)
 
+    expected_material_config = get_platform_specific_value(expected_material_config)
     assert_two_entities_deep_almost_equal(grain_boundary, expected_material_config)
 
 

package/tests/py/unit/test_tools_build_interface_zsl.py

@@ -1,6 +1,7 @@
 from types import SimpleNamespace
 
 import pytest
+from mat3ra.made.material import Material
 from mat3ra.made.tools.analyze.interface.zsl import ZSLInterfaceAnalyzer
 from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.base.builder import InterfaceBuilder
 from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.base.configuration import (
@@ -12,12 +13,14 @@ from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interf
 )
 from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab import SlabBuilder, SlabConfiguration
 from mat3ra.made.tools.build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
+from mat3ra.standata.materials import Materials
 
 from .fixtures.bulk import BULK_Ni_PRIMITIVE
 from .fixtures.interface.gr_ni_111_top_hcp import (
     GRAPHENE_NICKEL_INTERFACE_TOP_HCP,
     GRAPHENE_NICKEL_INTERFACE_TOP_HCP_GH_WF,
 )
+from .fixtures.interface.zsl import DIAMOND_GaAs_INTERFACE, DIAMOND_GaAs_INTERFACE_GH
 from .fixtures.monolayer import GRAPHENE
 from .utils import OSPlatform, assert_two_entities_deep_almost_equal, get_platform_specific_value
 
@@ -43,6 +46,32 @@ GRAPHENE_NICKEL_TEST_CASE = (
     },
 )
 
+BULK_DIAMOND = Materials.get_by_name_first_match("Diamond")
+BULK_GaAs = Materials.get_by_name_first_match("GaAs")
+
+DIAMOND_GAAS_CSL_TEST_CASE = (
+    SimpleNamespace(
+        bulk_config=BULK_DIAMOND,
+        miller_indices=(0, 0, 1),
+        number_of_layers=1,
+        vacuum=0.0,
+    ),
+    SimpleNamespace(
+        bulk_config=BULK_GaAs,
+        miller_indices=(0, 0, 1),
+        number_of_layers=1,
+        vacuum=0.0,
+    ),
+    1.5,  # gap between diamond and gaas
+    10.0,  # vacuum
+    70.0,  # max area
+    {
+        OSPlatform.DARWIN: DIAMOND_GaAs_INTERFACE,
+        OSPlatform.OTHER: DIAMOND_GaAs_INTERFACE_GH,
+    },
+)
+
+
 MAX_AREA_RATIO_TOL = 0.09
 MAX_LENGTH_TOL = 0.05
 MAX_ANGLE_TOL = 0.02
@@ -50,7 +79,7 @@ MAX_ANGLE_TOL = 0.02
 
 @pytest.mark.parametrize(
     "substrate, film,gap, vacuum, max_area, expected_interface",
-    [GRAPHENE_NICKEL_TEST_CASE],
+    [GRAPHENE_NICKEL_TEST_CASE, DIAMOND_GAAS_CSL_TEST_CASE],
 )
 def test_zsl_interface_builder(substrate, film, gap, vacuum, max_area, expected_interface):
     """Test creating Si/Ge interface using ZSL approach."""
@@ -90,8 +119,10 @@ def test_zsl_interface_builder(substrate, film, gap, vacuum, max_area, expected_
 
     # remove metadata
     interface.metadata.build = []
-    expected_interface = get_platform_specific_value(expected_interface)
-    print(interface.to_dict())
+    expected_interface = Material.create(get_platform_specific_value(expected_interface))
+
+    assert interface.basis.number_of_atoms == expected_interface.basis.number_of_atoms
+
     assert_two_entities_deep_almost_equal(interface, expected_interface)
 
 
@@ -122,7 +153,10 @@ def test_create_zsl_interface(substrate, film, gap, vacuum, max_area, expected_i
     assert_two_entities_deep_almost_equal(interface, expected_interface)
 
 
-@pytest.mark.parametrize("substrate, film, gap, vacuum, max_area, expected_interface", [GRAPHENE_NICKEL_TEST_CASE])
+@pytest.mark.parametrize(
+    "substrate, film, gap, vacuum, max_area, expected_interface",
+    [GRAPHENE_NICKEL_TEST_CASE, DIAMOND_GAAS_CSL_TEST_CASE],
+)
 def test_create_zsl_interface_between_slabs(substrate, film, gap, vacuum, max_area, expected_interface):
     substrate_slab_config = SlabConfiguration.from_parameters(
         material_or_dict=substrate.bulk_config,