@mat3ra/made 2026.4.2-0 → 2026.5.7-0

package/package.json

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

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

@@ -128,6 +128,20 @@ class Lattice(RoundNumericValuesMixin, LatticeSchemaVectorless, InMemoryEntityPy
     def cell_volume_rounded(self) -> float:
         return self.vectors.volume_rounded
 
+    @property
+    def reciprocal_vectors(self):
+        return np.linalg.inv(np.array(self.vector_arrays, dtype=float)).T.tolist()
+
+    @property
+    def reciprocal_vector_norms(self) -> List[float]:
+        return [float(np.linalg.norm(vector)) for vector in self.reciprocal_vectors]
+
+    @property
+    def reciprocal_vector_ratios(self) -> List[float]:
+        norms = self.reciprocal_vector_norms
+        max_norm = max(norms)
+        return [round(float(value / max_norm), 3) for value in norms]
+
     def get_hash_string(self, is_scaled: bool = False) -> str:
         """Mirrors JS Lattice.getHashString(isScaled). Rounds to HASH_TOLERANCE decimal places."""
         scale = self.a if is_scaled else 1

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

@@ -4,7 +4,7 @@ from typing import Any, List, Optional, Union
 from mat3ra.code.constants import AtomicCoordinateUnits, Units
 from mat3ra.code.entity import HasDescriptionHasMetadataNamedDefaultableInMemoryEntityPydantic
 from mat3ra.esse.models.material import MaterialSchema
-from pydantic import ConfigDict, SkipValidation
+from pydantic import ConfigDict, SkipValidation, computed_field, field_serializer
 
 from .basis import Basis
 from .lattice import Lattice
@@ -120,10 +120,15 @@ class Material(MaterialSchema, HasDescriptionHasMetadataNamedDefaultableInMemory
         message = f"{self.basis.hash_string}#{self.lattice.get_hash_string(is_scaled)}#{salt}"
         return hashlib.md5(message.encode()).hexdigest()
 
+    @computed_field
     @property
     def hash(self) -> str:
         return self.calculate_hash()
 
+    @field_serializer("scaledHash")
+    def serialize_scaled_hash(self, _scaled_hash: Optional[str]) -> str:
+        return self.scaled_hash
+
     @property
     def scaled_hash(self) -> str:
         return self.calculate_hash(is_scaled=True)

package/src/py/mat3ra/made/tools/build/pristine_structures/two_dimensional/slab/helpers.py

@@ -40,14 +40,6 @@ def create_slab(
     Returns:
         Material: The generated slab material.
     """
-    material_to_use = crystal
-
-    if use_conventional_cell:
-        crystal_lattice_planes_analyzer = CrystalLatticePlanesMaterialAnalyzer(
-            material=crystal, miller_indices=miller_indices
-        )
-        material_to_use = crystal_lattice_planes_analyzer.material_with_conventional_lattice
-
     if termination_top is not None:
         termination_top_formula = termination_top.formula
     if termination_bottom is not None:
@@ -58,7 +50,7 @@ def create_slab(
         use_orthogonal_c=use_orthogonal_c,
     )
     slab_configuration = SlabConfiguration.from_parameters(
-        material_or_dict=material_to_use,
+        material_or_dict=crystal,
         miller_indices=miller_indices,
         number_of_layers=number_of_layers,
         termination_top_formula=termination_top_formula,

package/tests/py/unit/test_lattice.py

@@ -1,3 +1,5 @@
+import pytest
+
 from mat3ra.code.vector import RoundedVector3D
 from mat3ra.made.lattice import Lattice
 from mat3ra.utils import assertion as assertion_utils
@@ -75,5 +77,28 @@ def test_lattice_get_scaled_by_matrix():
     assertion_utils.assert_deep_almost_equal(lattice.vector_arrays, expected_vector_values)
 
 
+def test_reciprocal_vectors():
+    lattice = Lattice(a=2.0, b=3.0, c=4.0)
+    expected_vectors = [[0.5, 0.0, 0.0], [0.0, 1 / 3, 0.0], [0.0, 0.0, 0.25]]
+    assertion_utils.assert_deep_almost_equal(lattice.reciprocal_vectors, expected_vectors)
+
+
+def test_reciprocal_vector_norms():
+    lattice = Lattice(a=2.0, b=3.0, c=4.0)
+    expected_norms = [0.5, 1 / 3, 0.25]
+    assertion_utils.assert_deep_almost_equal(lattice.reciprocal_vector_norms, expected_norms)
+
+
+@pytest.mark.parametrize(
+    "lattice, expected",
+    [
+        (Lattice(a=2.0, b=3.0, c=4.0), [1.0, 0.667, 0.5]),
+        (Lattice(a=5.43, b=5.43, c=5.43), [1.0, 1.0, 1.0]),
+    ],
+)
+def test_reciprocal_vector_ratios(lattice, expected):
+    assert lattice.reciprocal_vector_ratios == expected
+
+
 # to test: create, calculate_vectors, from_vectors, get_lattice_type, clone
 # from_vectors, to_dict, cell, cell_volume, scale_by_matrix, update_from_lattice,

package/tests/py/unit/test_material.py

@@ -12,6 +12,8 @@ from unit.fixtures.slab import BULK_Si_CONVENTIONAL
 from unit.utils import assert_two_entities_deep_almost_equal
 
 FIXTURES_DIR = Path(__file__).parents[2] / "fixtures"
+HASH_KEY = "hash"
+SCALED_HASH_KEY = "scaledHash"
 
 
 def load_fixture(name: str) -> dict:
@@ -136,3 +138,11 @@ def test_calculate_hash(fixture_file):
     material = Material.create(fixture)
     assert material.hash == fixture["hash"]
     assert material.scaled_hash == fixture["scaledHash"]
+
+
+def test_model_dump_includes_hashes():
+    material = Material.create_default()
+    serialized_material = material.model_dump()
+
+    assert serialized_material[HASH_KEY] == material.hash
+    assert serialized_material[SCALED_HASH_KEY] == material.scaled_hash

package/tests/py/unit/test_tools_build_interface.py

@@ -5,6 +5,7 @@ import pytest
 from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
 from mat3ra.made.material import Material
 from mat3ra.made.tools.analyze.interface.simple import InterfaceAnalyzer
+from mat3ra.made.tools.analyze.lattice_planes import CrystalLatticePlanesMaterialAnalyzer
 from mat3ra.made.tools.build import MaterialWithBuildMetadata
 from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.base.build_parameters import (
     InterfaceBuilderParameters,
@@ -39,6 +40,9 @@ from .fixtures.interface.twisted_nanoribbons import TWISTED_INTERFACE_GRAPHENE_G
 from .fixtures.monolayer import GRAPHENE
 from .utils import OSPlatform, assert_two_entities_deep_almost_equal
 
+HASH_KEY = "hash"
+SCALED_HASH_KEY = "scaledHash"
+
 Si_Ge_SIMPLE_INTERFACE_TEST_CASE = (
     SimpleNamespace(
         bulk_config=BULK_Si_CONVENTIONAL,
@@ -253,6 +257,29 @@ def test_commensurate_interface_creation(material_config, analyzer_params, direc
     assert_two_entities_deep_almost_equal(interface, expected_interface, atol=PRECISION)
 
 
+def test_create_slab_with_conventional_cell_stores_crystal_hashes_in_metadata():
+    miller_indices = (0, 0, 1)
+    material = Material.create(BULK_Ni_PRIMITIVE)
+    expected_crystal = CrystalLatticePlanesMaterialAnalyzer(
+        material=material, miller_indices=miller_indices
+    ).material_with_conventional_lattice
+
+    slab = create_slab(
+        crystal=material,
+        miller_indices=miller_indices,
+        use_conventional_cell=True,
+        use_orthogonal_c=True,
+        number_of_layers=1,
+        vacuum=0.0,
+    )
+    serialized_slab = slab.model_dump()
+    crystal = serialized_slab["metadata"]["build"][-1]["configuration"]["stack_components"][0]["crystal"]
+
+    assert crystal[HASH_KEY] == expected_crystal.hash
+    assert crystal[SCALED_HASH_KEY] == expected_crystal.scaled_hash
+    assert "bulkId" not in serialized_slab["metadata"]
+
+
 @pytest.mark.parametrize(
     "interface_config, expected_coordinate_level",
     [(GRAPHENE_NICKEL_INTERFACE_TOP_HCP, 12.048)],