@mat3ra/made 2026.7.18-0 → 2026.7.29-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.18-0",
+    "version": "2026.7.29-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/build/defective_structures/three_dimensional/solid_solution/builder.py

@@ -31,7 +31,7 @@ class SolidSolutionBuilder(MergeBuilder):
         source_element = configuration.source_element
         target_element = configuration.target_element
         material.name = (
-            f"{formula} - Solid Solution ({source_element}\u2192{target_element} "
+            f"{formula} - Solid Solution ({source_element}->{target_element} "
             f"{concentration_percentage:.4g}%)"
         )
         return material

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

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Tuple
 
 from ...material import Material
 from ..analyze.other import get_surface_area
@@ -88,6 +88,31 @@ def calculate_adhesion_energy(
     return (energy_substrate_slab + energy_film_slab - energy_interface) / area
 
 
+def _get_interface_with_build_metadata(interface: Material) -> MaterialWithBuildMetadata:
+    if isinstance(interface, MaterialWithBuildMetadata):
+        return interface
+    return MaterialWithBuildMetadata.create(interface.to_dict())
+
+
+def _resolve_interface_bulk_materials(
+    interface: Material,
+    substrate_bulk: Optional[Material],
+    film_bulk: Optional[Material],
+) -> Tuple[Optional[Material], Optional[Material]]:
+    """Resolve missing bulks from interface build metadata (handles BoundaryConditions metadata)."""
+    try:
+        interface_with_metadata = _get_interface_with_build_metadata(interface)
+        if substrate_bulk is None:
+            substrate_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="substrate"))
+        if film_bulk is None:
+            film_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="film"))
+    except (ValueError, TypeError) as exc:
+        raise ValueError(
+            "The substrate and film bulk materials must be provided or defined in the interface metadata."
+        ) from exc
+    return substrate_bulk, film_bulk
+
+
 def calculate_interfacial_energy(
     interface: Material,
     substrate_slab: Optional[Material] = None,
@@ -115,14 +140,9 @@ 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
 
-    try:
-        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
+    if substrate_bulk is None or film_bulk is None:
+        substrate_bulk, film_bulk = _resolve_interface_bulk_materials(interface, substrate_bulk, film_bulk)
+
     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/src/py/mat3ra/made/tools/operations/core/unary.py

@@ -22,9 +22,12 @@ def supercell(material: MaterialWithBuildMetadata, supercell_matrix) -> Material
     atoms = to_ase(material)
 
     supercell_atoms = ase_make_supercell(atoms, supercell_matrix)
-    new_material = MaterialWithBuildMetadata.create(from_ase(supercell_atoms))
-    # if material.metadata:
-    #     new_material.metadata.update(**material.metadata.to_dict())
+    material_config = from_ase(supercell_atoms)
+    # ASE make_supercell drops atoms.info; merge prior build/boundaryConditions when present.
+    source_metadata = material.to_dict().get("metadata") or {}
+    if source_metadata:
+        material_config["metadata"] = {**material_config.get("metadata", {}), **source_metadata}
+    new_material = MaterialWithBuildMetadata.create(material_config)
     new_material.name = material.name
     return new_material
 

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/fixtures/bulk.py

@@ -5,7 +5,7 @@ from mat3ra.standata.materials import Materials
 BULK_SrTiO3 = Materials.get_by_name_first_match("SrTiO3")
 BULK_GRAPHITE = Materials.get_by_name_first_match("Graphite")
 BULK_SiO2 = Materials.get_by_name_first_match("SiO2")
-BULK_Hf2O_MCL = Materials.get_by_name_first_match("Hafnium.*MCL")
+BULK_Hf2O_MCL = Materials.get_by_name_first_match("Hafnium IV Oxide, MCL")
 BULK_TiN = Materials.get_by_name_first_match("TiN")
 BULK_Ni_PRIMITIVE = Materials.get_by_name_first_match("Nickel")
 BULK_GRAPHENE = Materials.get_by_name_first_match("Graphene")

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_build_supercell.py

@@ -2,18 +2,22 @@ import numpy as np
 import pytest
 from mat3ra.made.material import Material
 from mat3ra.made.tools.build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
+from mat3ra.made.tools.build_components.metadata import MaterialWithBuildMetadata
+from unit.fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
 from unit.fixtures.supercell import SI_SUPERCELL_2X2X1
 
 from .fixtures.bulk import BULK_Si_PRIMITIVE
 from .utils import assert_two_entities_deep_almost_equal
 
+SUPERCELL_MATRIX_2X2X1 = [[2, 0, 0], [0, 2, 0], [0, 0, 1]]
+
 
 @pytest.mark.parametrize(
     "material_config, supercell_matrix, expected_material_config",
     [
         (
             BULK_Si_PRIMITIVE,
-            [[2, 0, 0], [0, 2, 0], [0, 0, 1]],
+            SUPERCELL_MATRIX_2X2X1,
             SI_SUPERCELL_2X2X1,
         ),
     ],
@@ -27,3 +31,17 @@ def test_create_supercell(material_config, supercell_matrix, expected_material_c
     expected_vectors = np.array(supercell_matrix) @ np.array(material.lattice.vector_arrays)
     actual_vectors = np.array(supercell_material.lattice.vector_arrays)
     assert np.allclose(actual_vectors, expected_vectors, atol=1e-6), "Supercell vectors do not match expected values."
+
+
+def test_create_supercell_preserves_prior_build_metadata():
+    material = MaterialWithBuildMetadata.create(GRAPHENE_NICKEL_INTERFACE)
+    prior_build_types = [step.configuration.get("type") for step in material.metadata.build]
+
+    supercell_material = create_supercell(material, SUPERCELL_MATRIX_2X2X1)
+
+    result_build_types = [step.configuration.get("type") for step in supercell_material.metadata.build]
+    assert result_build_types[:-1] == prior_build_types
+    assert result_build_types[-1] == "SupercellConfiguration"
+    assert supercell_material.metadata.to_dict().get("boundaryConditions") == material.metadata.to_dict().get(
+        "boundaryConditions"
+    )

package/tests/py/unit/test_tools_calculate.py

@@ -1,5 +1,4 @@
 import numpy as np
-import pytest
 from ase.build import add_adsorbate, bulk, fcc111, graphene, surface
 from ase.calculators import emt
 from mat3ra.made.material import Material
@@ -20,16 +19,15 @@ graphene_layer.cell = nickel_slab.cell
 interface = nickel_slab.copy()
 add_adsorbate(interface, graphene_layer, height=2, position="ontop")
 
-# Material objects setup
+# Material.create yields MaterialMetadataBoundaryConditions; bulks are resolved from nested build.
 interface_material = Material.create(GRAPHENE_NICKEL_INTERFACE)
 nickel_slab_material = Material.create(from_ase(nickel_slab))
-nickel_bulk_material = Material.create(from_ase(bulk("Ni", "fcc", a=3.52)))
-graphene_layer_material = Material.create(from_ase(graphene_layer))
-graphene_bulk_material = graphene_layer
 
 # Calculator setup
 calculator = emt.EMT()
 
+EXPECTED_INTERFACIAL_ENERGY = -0.78488
+
 
 def test_calculate_total_energy():
     atoms = bulk("C", cubic=True)
@@ -59,17 +57,11 @@ def test_calculate_adhesion_energy():
     assert np.isclose(adhesion_energy, 0.07345)
 
 
-@pytest.mark.skip(reason="This test is not working as expected")
 def test_calculate_interfacial_energy():
     interfacial_energy = calculate_interfacial_energy(
         interface_material,
-        nickel_slab_material,
-        nickel_bulk_material,
-        graphene_layer,
-        graphene_bulk_material,
-        calculator,
-    )
-    assert np.isclose(
-        interfacial_energy,
-        -0.78488,
+        substrate_slab=nickel_slab_material,
+        film_slab=graphene_layer,
+        calculator=calculator,
     )
+    assert np.isclose(interfacial_energy, EXPECTED_INTERFACIAL_ENERGY)