@mat3ra/made 2026.7.13-0 → 2026.7.21-0

package/data/reciprocal_paths.json

@@ -1,111 +1,111 @@
 {
     "CUB": [
-        ["Г", "X", "M", "Г", "R", "X"],
+        ["Γ", "X", "M", "Γ", "R", "X"],
         ["M", "R"]
     ],
     "BCC": [
-        ["Г", "H", "N", "Г", "P", "H"],
+        ["Γ", "H", "N", "Γ", "P", "H"],
         ["P", "N"]
     ],
     "FCC": [
-        ["Г", "X", "W", "K", "Г", "L", "U", "W", "L"],
+        ["Γ", "X", "W", "K", "Γ", "L", "U", "W", "L"],
         ["U", "X"]
     ],
     "TET": [
-        ["Г", "X", "M", "Г", "Z", "R", "A", "Z"],
+        ["Γ", "X", "M", "Γ", "Z", "R", "A", "Z"],
         ["X", "R"],
         ["M", "A"]
     ],
     "BCT-1": [
-        ["Г", "X", "M", "Г", "Z", "P", "N", "Z1", "M"],
+        ["Γ", "X", "M", "Γ", "Z", "P", "N", "Z1", "M"],
         ["X", "P"]
     ],
     "BCT-2": [
-        ["Г", "X", "Y", "∑", "Г", "Z", "∑1", "N", "P", "Y1", "Z"],
+        ["Γ", "X", "Y", "∑", "Γ", "Z", "∑1", "N", "P", "Y1", "Z"],
         ["X", "P"]
     ],
     "ORC": [
-        ["Г", "X", "S", "Y", "Г", "Z", "U", "R", "T", "Z"],
+        ["Γ", "X", "S", "Y", "Γ", "Z", "U", "R", "T", "Z"],
         ["Y", "T"],
         ["U", "X"],
         ["S", "R"]
     ],
     "ORCF-1": [
-        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["Γ", "Y", "T", "Z", "Γ", "X", "A1", "Y"],
         ["T", "X1"],
         ["X", "A", "Z"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCF-2": [
-        ["Г", "Y", "C", "D", "X", "Г", "Z", "D1", "H", "C"],
+        ["Γ", "Y", "C", "D", "X", "Γ", "Z", "D1", "H", "C"],
         ["C1", "Z"],
         ["X", "H1"],
         ["H", "Y"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCF-3": [
-        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["Γ", "Y", "T", "Z", "Γ", "X", "A1", "Y"],
         ["X", "A", "Z"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCI": [
-        ["Г", "X", "L", "T", "W", "R", "X1", "Z", "Г", "Y", "S", "W"],
+        ["Γ", "X", "L", "T", "W", "R", "X1", "Z", "Γ", "Y", "S", "W"],
         ["L1", "Y"],
         ["Y1", "Z"]
     ],
     "ORCC": [
-        ["Г", "X", "S", "R", "A", "Z", "Г", "Y", "X1", "A1", "T", "Y"],
+        ["Γ", "X", "S", "R", "A", "Z", "Γ", "Y", "X1", "A1", "T", "Y"],
         ["Z", "T"]
     ],
     "HEX": [
-        ["Г", "M", "K", "Г", "A", "L", "H", "A"],
+        ["Γ", "M", "K", "Γ", "A", "L", "H", "A"],
         ["L", "M"],
         ["K", "H"]
     ],
     "RHL-1": [
-        ["Г", "L", "B1"],
-        ["B", "Z", "Г", "X"],
+        ["Γ", "L", "B1"],
+        ["B", "Z", "Γ", "X"],
         ["Q", "F", "P1", "Z"],
         ["L", "P"]
     ],
-    "RHL-2": [["Г", "P", "Z", "Q", "Г", "F", "P1", "Q1", "L", "Z"]],
+    "RHL-2": [["Γ", "P", "Z", "Q", "Γ", "F", "P1", "Q1", "L", "Z"]],
     "MCL": [
-        ["Г", "Y", "H", "C", "E", "M1", "A", "X", "H1"],
+        ["Γ", "Y", "H", "C", "E", "M1", "A", "X", "H1"],
         ["M", "D", "Z"],
         ["Y", "D"]
     ],
     "MCLC-1": [
-        ["Г", "Y", "Г", "L", "I"],
+        ["Γ", "Y", "Γ", "L", "I"],
         ["I1", "Z", "F1"],
         ["Y", "X1"],
-        ["X", "Г", "N"],
-        ["M", "Г"]
+        ["X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-2": [
-        ["Г", "Y", "F", "L", "I"],
+        ["Γ", "Y", "F", "L", "I"],
         ["I1", "Z", "F1"],
-        ["N", "Г", "M"]
+        ["N", "Γ", "M"]
     ],
     "MCLC-3": [
-        ["Г", "Y", "F", "H", "Z", "I", "F1"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["Γ", "Y", "F", "H", "Z", "I", "F1"],
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-4": [
-        ["Г", "Y", "F", "H", "Z", "I"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["Γ", "Y", "F", "H", "Z", "I"],
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-5": [
-        ["Г", "Y", "F", "L", "I"],
+        ["Γ", "Y", "F", "L", "I"],
         ["I1", "Z", "H", "F1"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "TRI": [
-        ["X", "Г", "Y"],
-        ["L", "Г", "Z"],
-        ["N", "Г", "M"],
-        ["R", "Г"]
+        ["X", "Γ", "Y"],
+        ["L", "Γ", "Z"],
+        ["N", "Γ", "M"],
+        ["R", "Γ"]
     ]
 }

package/dist/js/data/reciprocal_paths.json

@@ -1,111 +1,111 @@
 {
     "CUB": [
-        ["Г", "X", "M", "Г", "R", "X"],
+        ["Γ", "X", "M", "Γ", "R", "X"],
         ["M", "R"]
     ],
     "BCC": [
-        ["Г", "H", "N", "Г", "P", "H"],
+        ["Γ", "H", "N", "Γ", "P", "H"],
         ["P", "N"]
     ],
     "FCC": [
-        ["Г", "X", "W", "K", "Г", "L", "U", "W", "L"],
+        ["Γ", "X", "W", "K", "Γ", "L", "U", "W", "L"],
         ["U", "X"]
     ],
     "TET": [
-        ["Г", "X", "M", "Г", "Z", "R", "A", "Z"],
+        ["Γ", "X", "M", "Γ", "Z", "R", "A", "Z"],
         ["X", "R"],
         ["M", "A"]
     ],
     "BCT-1": [
-        ["Г", "X", "M", "Г", "Z", "P", "N", "Z1", "M"],
+        ["Γ", "X", "M", "Γ", "Z", "P", "N", "Z1", "M"],
         ["X", "P"]
     ],
     "BCT-2": [
-        ["Г", "X", "Y", "∑", "Г", "Z", "∑1", "N", "P", "Y1", "Z"],
+        ["Γ", "X", "Y", "∑", "Γ", "Z", "∑1", "N", "P", "Y1", "Z"],
         ["X", "P"]
     ],
     "ORC": [
-        ["Г", "X", "S", "Y", "Г", "Z", "U", "R", "T", "Z"],
+        ["Γ", "X", "S", "Y", "Γ", "Z", "U", "R", "T", "Z"],
         ["Y", "T"],
         ["U", "X"],
         ["S", "R"]
     ],
     "ORCF-1": [
-        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["Γ", "Y", "T", "Z", "Γ", "X", "A1", "Y"],
         ["T", "X1"],
         ["X", "A", "Z"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCF-2": [
-        ["Г", "Y", "C", "D", "X", "Г", "Z", "D1", "H", "C"],
+        ["Γ", "Y", "C", "D", "X", "Γ", "Z", "D1", "H", "C"],
         ["C1", "Z"],
         ["X", "H1"],
         ["H", "Y"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCF-3": [
-        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["Γ", "Y", "T", "Z", "Γ", "X", "A1", "Y"],
         ["X", "A", "Z"],
-        ["L", "Г"]
+        ["L", "Γ"]
     ],
     "ORCI": [
-        ["Г", "X", "L", "T", "W", "R", "X1", "Z", "Г", "Y", "S", "W"],
+        ["Γ", "X", "L", "T", "W", "R", "X1", "Z", "Γ", "Y", "S", "W"],
         ["L1", "Y"],
         ["Y1", "Z"]
     ],
     "ORCC": [
-        ["Г", "X", "S", "R", "A", "Z", "Г", "Y", "X1", "A1", "T", "Y"],
+        ["Γ", "X", "S", "R", "A", "Z", "Γ", "Y", "X1", "A1", "T", "Y"],
         ["Z", "T"]
     ],
     "HEX": [
-        ["Г", "M", "K", "Г", "A", "L", "H", "A"],
+        ["Γ", "M", "K", "Γ", "A", "L", "H", "A"],
         ["L", "M"],
         ["K", "H"]
     ],
     "RHL-1": [
-        ["Г", "L", "B1"],
-        ["B", "Z", "Г", "X"],
+        ["Γ", "L", "B1"],
+        ["B", "Z", "Γ", "X"],
         ["Q", "F", "P1", "Z"],
         ["L", "P"]
     ],
-    "RHL-2": [["Г", "P", "Z", "Q", "Г", "F", "P1", "Q1", "L", "Z"]],
+    "RHL-2": [["Γ", "P", "Z", "Q", "Γ", "F", "P1", "Q1", "L", "Z"]],
     "MCL": [
-        ["Г", "Y", "H", "C", "E", "M1", "A", "X", "H1"],
+        ["Γ", "Y", "H", "C", "E", "M1", "A", "X", "H1"],
         ["M", "D", "Z"],
         ["Y", "D"]
     ],
     "MCLC-1": [
-        ["Г", "Y", "Г", "L", "I"],
+        ["Γ", "Y", "Γ", "L", "I"],
         ["I1", "Z", "F1"],
         ["Y", "X1"],
-        ["X", "Г", "N"],
-        ["M", "Г"]
+        ["X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-2": [
-        ["Г", "Y", "F", "L", "I"],
+        ["Γ", "Y", "F", "L", "I"],
         ["I1", "Z", "F1"],
-        ["N", "Г", "M"]
+        ["N", "Γ", "M"]
     ],
     "MCLC-3": [
-        ["Г", "Y", "F", "H", "Z", "I", "F1"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["Γ", "Y", "F", "H", "Z", "I", "F1"],
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-4": [
-        ["Г", "Y", "F", "H", "Z", "I"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["Γ", "Y", "F", "H", "Z", "I"],
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "MCLC-5": [
-        ["Г", "Y", "F", "L", "I"],
+        ["Γ", "Y", "F", "L", "I"],
         ["I1", "Z", "H", "F1"],
-        ["H1", "Y1", "X", "Г", "N"],
-        ["M", "Г"]
+        ["H1", "Y1", "X", "Γ", "N"],
+        ["M", "Γ"]
     ],
     "TRI": [
-        ["X", "Г", "Y"],
-        ["L", "Г", "Z"],
-        ["N", "Г", "M"],
-        ["R", "Г"]
+        ["X", "Γ", "Y"],
+        ["L", "Γ", "Z"],
+        ["N", "Γ", "M"],
+        ["R", "Γ"]
     ]
 }

package/dist/js/lattice/reciprocal/symmetry_points.js

@@ -858,7 +858,7 @@ const POINTS = {
 function symmetryPoints(lattice) {
     return [
         {
-            point: "Г",
+            point: "Γ",
             coordinates: [0.0, 0.0, 0.0],
         },
     ].concat(POINTS[lattice.type](lattice) || []);

package/package.json

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

package/src/js/lattice/reciprocal/symmetry_points.ts

@@ -879,7 +879,7 @@ const POINTS = {
 export function symmetryPoints(lattice: Lattice) {
     return [
         {
-            point: "Г",
+            point: "Γ",
             coordinates: [0.0, 0.0, 0.0],
         },
     ].concat(POINTS[lattice.type](lattice) || []);

package/src/py/mat3ra/made/reciprocal/symmetry_points.py

@@ -367,7 +367,7 @@ def get_symmetry_points(lattice: Any) -> List[dict]:
     """
     lattice_type = lattice.type.value if hasattr(lattice.type, "value") else str(lattice.type)
 
-    gamma_point = [{"point": "Г", "coordinates": [0.0, 0.0, 0.0]}]
+    gamma_point = [{"point": "Γ", "coordinates": [0.0, 0.0, 0.0]}]
 
     points_fn = POINTS.get(lattice_type)
     if points_fn is None:

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

@@ -16,6 +16,8 @@ class BuildMetadataAnalyzer(BaseMaterialAnalyzer, Generic[TypeConfiguration, Typ
 
     @property
     def build_metadata(self) -> BuildMetadata:
+        if not self.material.metadata.build:
+            raise ValueError("No metadata.build on the material.")
         metadata = self.material.metadata.get_build_metadata_of_type(self.configuration_cls.__name__)
         if not metadata:
             raise ValueError(f"Build metadata for {self.configuration_cls.__name__} not found.")

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

@@ -0,0 +1,31 @@
+from typing import Dict, Type
+
+from ..build_components.metadata import MaterialWithBuildMetadata
+from .build_metadata_analyzer import BuildMetadataAnalyzer
+from .interface_material import (
+    InterfaceMaterialAnalyzer,
+)
+from .slab import SlabMaterialAnalyzer
+
+BUILD_METADATA_ANALYZER_REGISTRY: Dict[str, Type[BuildMetadataAnalyzer]] = {
+    "SlabConfiguration": SlabMaterialAnalyzer,
+    "InterfaceConfiguration": InterfaceMaterialAnalyzer,
+}
+
+
+def create_build_metadata_analyzer(
+    material: MaterialWithBuildMetadata,
+    **analyzer_kwargs,
+) -> BuildMetadataAnalyzer:
+    build_metadata = material.metadata.get_latest_build_metadata()
+    configuration_type = build_metadata.configuration.get("type")
+    if not configuration_type:
+        raise ValueError("Latest build step has no configuration type.")
+    analyzer_cls = BUILD_METADATA_ANALYZER_REGISTRY.get(configuration_type)
+    if analyzer_cls is None:
+        registered_types = ", ".join(sorted(BUILD_METADATA_ANALYZER_REGISTRY))
+        raise ValueError(
+            f"No build metadata analyzer registered for '{configuration_type}'. "
+            f"Registered types: {registered_types}."
+        )
+    return analyzer_cls(material=material, **analyzer_kwargs)

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

@@ -0,0 +1,45 @@
+from typing import Type, Union
+
+from ..build.compound_pristine_structures.two_dimensional.interface.base.build_parameters import (
+    InterfaceBuilderParameters,
+)
+from ..build.compound_pristine_structures.two_dimensional.interface.base.configuration import InterfaceConfiguration
+from ..build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
+from ..build.pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
+    SlabStrainedSupercellConfiguration,
+)
+from ..build_components.metadata import MaterialWithBuildMetadata
+from ..convert.interface_parts_enum import INTERFACE_LABELS_MAP
+from .build_metadata_analyzer import BuildMetadataAnalyzer
+
+
+class InterfaceMaterialAnalyzer(
+    BuildMetadataAnalyzer[InterfaceConfiguration, InterfaceBuilderParameters],
+):
+    configuration_cls: Type[InterfaceConfiguration] = InterfaceConfiguration
+    build_parameters_cls: Type[InterfaceBuilderParameters] = InterfaceBuilderParameters
+
+    @property
+    def substrate_slab_configuration(self) -> Union[SlabStrainedSupercellConfiguration, SlabConfiguration]:
+        return self.build_configuration.substrate_configuration
+
+    @property
+    def film_slab_configuration(self) -> Union[SlabStrainedSupercellConfiguration, SlabConfiguration]:
+        return self.build_configuration.film_configuration
+
+    def get_bulk_crystal(self, part: str = "substrate") -> dict:
+        if part not in INTERFACE_LABELS_MAP:
+            raise ValueError(f"Unknown interface part '{part}'. Use 'substrate' or 'film'.")
+        slab_configuration = self.substrate_slab_configuration if part == "substrate" else self.film_slab_configuration
+        crystal = slab_configuration.atomic_layers.crystal
+        if crystal is None:
+            raise ValueError(f"No bulk crystal for {part} in interface build metadata.")
+        return crystal if isinstance(crystal, dict) else crystal.to_dict()
+
+
+def get_interface_configuration(interface: MaterialWithBuildMetadata) -> InterfaceConfiguration:
+    return InterfaceMaterialAnalyzer(material=interface).build_configuration
+
+
+def get_interface_bulk_crystal(interface: MaterialWithBuildMetadata, part: str = "substrate") -> dict:
+    return InterfaceMaterialAnalyzer(material=interface).get_bulk_crystal(part=part)

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

@@ -13,7 +13,11 @@ from .twisted import (
     TwistedNanoribbonsInterfaceConfiguration,
     create_interface_twisted,
 )
-from .utils import get_optimal_film_displacement, get_slab, remove_duplicate_interfaces
+from .utils import (
+    get_optimal_film_displacement,
+    get_slab,
+    remove_duplicate_interfaces,
+)
 from .zsl import (
     create_interface_zsl,
     create_interface_zsl_between_slabs,

package/src/py/mat3ra/made/tools/build_components/metadata/material_build_metadata.py

@@ -10,6 +10,11 @@ class MaterialBuildMetadata(BaseMetadata):
     # Other metadata fields can be added as needed
     build: List[BuildMetadata] = Field([])
 
+    def get_latest_build_metadata(self) -> BuildMetadata:
+        if not self.build:
+            raise ValueError("No metadata.build on the material.")
+        return self.build[-1]
+
     def get_build_metadata_of_type(self, configuration_type: str) -> Optional[BuildMetadata]:
         """
         Returns the first build configuration of the specified type.

package/src/py/mat3ra/made/tools/calculate/__init__.py

@@ -2,8 +2,9 @@ from typing import Optional
 
 from ...material import Material
 from ..analyze.other import get_surface_area
-from ..build.compound_pristine_structures.two_dimensional.interface import InterfaceConfiguration, get_slab
-from ..build_components import MaterialBuildMetadata, MaterialWithBuildMetadata
+from ..analyze.interface_material import get_interface_bulk_crystal
+from ..build.compound_pristine_structures.two_dimensional.interface import get_slab
+from ..build_components.metadata import MaterialWithBuildMetadata
 from ..convert import decorator_convert_material_args_kwargs_to_atoms
 from ..third_party import ASEAtoms, ASECalculator, ASECalculatorEMT
 from .calculators import InterfaceMaterialCalculatorParameters
@@ -114,19 +115,14 @@ def calculate_interfacial_energy(
     substrate_slab = get_slab(interface, part="substrate") if substrate_slab is None else substrate_slab
     film_slab = get_slab(interface, part="film") if film_slab is None else film_slab
 
-    metadata = (
-        interface.metadata
-        if isinstance(interface, MaterialWithBuildMetadata)
-        else MaterialBuildMetadata(**interface.metadata)
-    )
-    build_configuration = metadata.build[-1].configuration if metadata.build else {}
-    config = InterfaceConfiguration(**build_configuration)
-
     try:
-        substrate_bulk = config.substrate_configuration.atomic_layers.crystal
-        film_bulk = config.film_configuration.atomic_layers.crystal
-    except KeyError:
-        raise ValueError("The substrate and film bulk materials must be provided or defined in the interface metadata.")
+        interface_with_metadata = MaterialWithBuildMetadata.create(interface.to_dict())
+        substrate_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="substrate"))
+        film_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="film"))
+    except ValueError as exc:
+        raise ValueError(
+            "The substrate and film bulk materials must be provided or defined in the interface metadata."
+        ) from exc
     surface_energy_substrate = calculate_surface_energy(substrate_slab, substrate_bulk, calculator)
     surface_energy_film = calculate_surface_energy(film_slab, film_bulk, calculator)
     adhesion_energy = calculate_adhesion_energy(interface, substrate_slab, film_slab, calculator)

package/tests/js/lattice/lattice_reciprocal.ts

@@ -14,7 +14,7 @@ describe("Lattice Reciprocal", () => {
         const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
         const expectedPath = [
             {
-                point: "Г",
+                point: "Γ",
                 steps: 0,
                 coordinates: [0, 0, 0],
             },
@@ -54,7 +54,7 @@ describe("Lattice Reciprocal", () => {
         const actualPoints = lattice.symmetryPoints;
         const expectedPoints = [
             {
-                point: "Г",
+                point: "Γ",
                 coordinates: [0, 0, 0],
             },
             {

package/tests/py/unit/test_primitive_cell.py

@@ -3,7 +3,7 @@ import pytest
 
 from mat3ra.made.cell.primitive_cell import get_primitive_lattice_vectors_from_config
 from mat3ra.made.lattice import Lattice, LatticeTypeEnum
-from tests.py.unit.utils import assert_two_entities_deep_almost_equal
+from unit.utils import assert_two_entities_deep_almost_equal
 
 EXPECTED_PRIMITIVE_CELL_NA4CL4 = [
     [5.691694, 0.0, 0.0],

package/tests/py/unit/test_reciprocal_lattice.py

@@ -5,18 +5,18 @@ from mat3ra.utils import assertion as assertion_utils
 
 
 def test_reciprocal_lattice_symmetry_points_cub():
-    """CUB lattice should have Г, R, X, M symmetry points."""
+    """CUB lattice should have Γ, R, X, M symmetry points."""
     lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
     points = lattice.symmetry_points
     labels = [p["point"] for p in points]
-    assert labels == ["Г", "R", "X", "M"]
+    assert labels == ["Γ", "R", "X", "M"]
 
 
 def test_reciprocal_lattice_default_kpoint_path_cub():
     lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
     path = lattice.default_kpoint_path
     labels = [p["point"] for p in path]
-    assert labels == ["Г", "X", "M", "Г", "R", "X", "M", "R"]
+    assert labels == ["Γ", "X", "M", "Γ", "R", "X", "M", "R"]
 
 
 def test_reciprocal_lattice_default_kpoint_path_bct():
@@ -32,7 +32,7 @@ def test_reciprocal_lattice_extract_kpoint_path():
     data_points = [[0, 0, 0], [0.5, 0.5, 0.5]]
     result = lattice.extract_kpoint_path(data_points)
     assert len(result) == 2
-    assert result[0]["point"] == "Г"
+    assert result[0]["point"] == "Γ"
     assert result[0]["steps"] == 0
     assert result[1]["point"] == "R"
     assert result[1]["steps"] == 1

package/tests/py/unit/test_reciprocal_paths.py

@@ -49,16 +49,16 @@ def test_reciprocal_paths_entry_structure():
 def test_reciprocal_paths_cub():
     path = RECIPROCAL_PATHS["CUB"]
     labels = [p["point"] for p in path]
-    assert labels == ["Г", "X", "M", "Г", "R", "X", "M", "R"]
+    assert labels == ["Γ", "X", "M", "Γ", "R", "X", "M", "R"]
 
 
 def test_reciprocal_paths_fcc():
     path = RECIPROCAL_PATHS["FCC"]
     labels = [p["point"] for p in path]
-    assert labels == ["Г", "X", "W", "K", "Г", "L", "U", "W", "L", "U", "X"]
+    assert labels == ["Γ", "X", "W", "K", "Γ", "L", "U", "W", "L", "U", "X"]
 
 
 def test_reciprocal_paths_hex():
     path = RECIPROCAL_PATHS["HEX"]
     labels = [p["point"] for p in path]
-    assert labels == ["Г", "M", "K", "Г", "A", "L", "H", "A", "L", "M", "K", "H"]
+    assert labels == ["Γ", "M", "K", "Γ", "A", "L", "H", "A", "L", "M", "K", "H"]

package/tests/py/unit/test_symmetry_points.py

@@ -10,7 +10,7 @@ def test_symmetry_points_gamma_always_first():
     """Gamma point should always be the first symmetry point."""
     lattice = Lattice(a=1.0, b=1.0, c=1.0, type="CUB")
     points = get_symmetry_points(lattice)
-    assert points[0]["point"] == "Г"
+    assert points[0]["point"] == "Γ"
     assert points[0]["coordinates"] == [0.0, 0.0, 0.0]
 
 
@@ -18,7 +18,7 @@ def test_symmetry_points_cub():
     lattice = Lattice(a=5.64, b=5.64, c=5.64, type="CUB")
     points = get_symmetry_points(lattice)
     labels = [p["point"] for p in points]
-    assert labels == ["Г", "R", "X", "M"]
+    assert labels == ["Γ", "R", "X", "M"]
     # Verify specific coordinates
     r_point = next(p for p in points if p["point"] == "R")
     assertion_utils.assert_deep_almost_equal(r_point["coordinates"], [0.5, 0.5, 0.5])
@@ -45,7 +45,7 @@ def test_symmetry_points_bcc():
     lattice = Lattice(a=3.0, b=3.0, c=3.0, type="BCC")
     points = get_symmetry_points(lattice)
     labels = [p["point"] for p in points]
-    assert labels == ["Г", "H", "P", "N"]
+    assert labels == ["Γ", "H", "P", "N"]
     h_point = next(p for p in points if p["point"] == "H")
     assertion_utils.assert_deep_almost_equal(h_point["coordinates"], [0.5, -0.5, 0.5])
 
@@ -54,7 +54,7 @@ def test_symmetry_points_hex():
     lattice = Lattice(a=2.46, b=2.46, c=6.71, type="HEX")
     points = get_symmetry_points(lattice)
     labels = [p["point"] for p in points]
-    assert set(labels) == {"Г", "A", "H", "K", "L", "M"}
+    assert set(labels) == {"Γ", "A", "H", "K", "L", "M"}
     k_point = next(p for p in points if p["point"] == "K")
     assertion_utils.assert_deep_almost_equal(k_point["coordinates"], [1 / 3, 1 / 3, 0.0])
 
@@ -86,14 +86,14 @@ def test_symmetry_points_tet():
     lattice = Lattice(a=3.0, b=3.0, c=5.0, type="TET")
     points = get_symmetry_points(lattice)
     labels = [p["point"] for p in points]
-    assert set(labels) == {"Г", "A", "M", "R", "X", "Z"}
+    assert set(labels) == {"Γ", "A", "M", "R", "X", "Z"}
 
 
 def test_symmetry_points_orc():
     lattice = Lattice(a=2.0, b=3.0, c=4.0, type="ORC")
     points = get_symmetry_points(lattice)
     labels = [p["point"] for p in points]
-    assert set(labels) == {"Г", "R", "S", "T", "U", "X", "Y", "Z"}
+    assert set(labels) == {"Γ", "R", "S", "T", "U", "X", "Y", "Z"}
 
 
 def test_symmetry_points_rhl1():
@@ -144,7 +144,7 @@ def test_symmetry_points_all_lattice_types(lattice_type):
     lattice = Lattice(a=3.0, b=4.0, c=5.0, alpha=80.0, beta=85.0, gamma=75.0, type=lattice_type)
     points = get_symmetry_points(lattice)
     assert len(points) >= 1
-    assert points[0]["point"] == "Г"
+    assert points[0]["point"] == "Γ"
     # All coordinates should be lists of 3 floats
     for p in points:
         assert len(p["coordinates"]) == 3

package/tests/py/unit/test_tools_analyze_interface_material.py

@@ -0,0 +1,63 @@
+from typing import Final, Type
+
+import pytest
+from mat3ra.made.tools.analyze.build_metadata_analyzer import BuildMetadataAnalyzer
+from mat3ra.made.tools.analyze.build_metadata_analyzer_factory import create_build_metadata_analyzer
+from mat3ra.made.tools.analyze.interface_material import (
+    InterfaceMaterialAnalyzer,
+    get_interface_bulk_crystal,
+    get_interface_configuration,
+)
+from mat3ra.made.tools.analyze.slab import SlabMaterialAnalyzer
+from mat3ra.made.tools.build import MaterialWithBuildMetadata
+from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface import InterfaceConfiguration
+from unit.fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
+from unit.fixtures.slab import SI_CONVENTIONAL_SLAB_001
+
+INTERFACE_MATERIAL: Final = MaterialWithBuildMetadata.create(GRAPHENE_NICKEL_INTERFACE)
+SLAB_MATERIAL: Final = MaterialWithBuildMetadata.create(SI_CONVENTIONAL_SLAB_001)
+SUBSTRATE_CRYSTAL_NAME: Final = "Ni, Nickel, FCC (Fm-3m) 3D (Bulk), mp-23"
+FILM_CRYSTAL_NAME: Final = "Graphene"
+
+GET_BULK_CRYSTAL_CASES = [
+    ("substrate", SUBSTRATE_CRYSTAL_NAME),
+    ("film", FILM_CRYSTAL_NAME),
+]
+
+CREATE_BUILD_METADATA_ANALYZER_CASES = [
+    (INTERFACE_MATERIAL, InterfaceMaterialAnalyzer),
+    (SLAB_MATERIAL, SlabMaterialAnalyzer),
+]
+
+
+def test_build_configuration():
+    configuration = InterfaceMaterialAnalyzer(material=INTERFACE_MATERIAL).build_configuration
+    assert isinstance(configuration, InterfaceConfiguration)
+    assert configuration.type == "InterfaceConfiguration"
+
+
+@pytest.mark.parametrize("part,expected_name", GET_BULK_CRYSTAL_CASES)
+def test_get_bulk_crystal(part, expected_name):
+    crystal = InterfaceMaterialAnalyzer(material=INTERFACE_MATERIAL).get_bulk_crystal(part=part)
+    assert crystal["name"] == expected_name
+
+
+def test_get_interface_configuration():
+    configuration = get_interface_configuration(INTERFACE_MATERIAL)
+    assert isinstance(configuration, InterfaceConfiguration)
+    assert configuration.type == "InterfaceConfiguration"
+
+
+@pytest.mark.parametrize("part,expected_name", GET_BULK_CRYSTAL_CASES)
+def test_get_interface_bulk_crystal(part, expected_name):
+    crystal = get_interface_bulk_crystal(INTERFACE_MATERIAL, part=part)
+    assert crystal["name"] == expected_name
+
+
+@pytest.mark.parametrize("material,expected_analyzer_cls", CREATE_BUILD_METADATA_ANALYZER_CASES)
+def test_create_build_metadata_analyzer(
+    material: MaterialWithBuildMetadata,
+    expected_analyzer_cls: Type[BuildMetadataAnalyzer],
+):
+    analyzer = create_build_metadata_analyzer(material)
+    assert isinstance(analyzer, expected_analyzer_cls)

package/tests/py/unit/test_tools_build_metadata.py

@@ -28,6 +28,16 @@ def test_metadata_empty_initialization():
     assert metadata.model_dump(exclude_none=True) == {"build": []}
 
 
+def test_get_latest_build_metadata():
+    metadata = MaterialBuildMetadata(build=[BuildMetadata(configuration={"type": "SlabConfiguration"})])
+    assert metadata.get_latest_build_metadata().configuration["type"] == "SlabConfiguration"
+
+
+def test_get_latest_build_metadata_raises_when_empty():
+    with pytest.raises(ValueError, match="No metadata.build"):
+        MaterialBuildMetadata().get_latest_build_metadata()
+
+
 @pytest.mark.parametrize(
     "config_object, expected_dict",
     [