@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/py/unit/fixtures/supercell.py

@@ -1,64 +0,0 @@
-from typing import Any, Dict
-
-SI_SUPERCELL_FLIPPED_Z: Dict[str, Any] = {
-    "name": "Silicon FCC",
-    "basis": {
-        "constraints": [],
-        "coordinates": [{"id": 0, "value": [0.0, 0.0, 0.0]}, {"id": 1, "value": [0.25, 0.25, 0.25]}],
-        "elements": [{"id": 0, "value": "Si"}, {"id": 1, "value": "Si"}],
-        "labels": [],
-        "units": "crystal",
-    },
-    "lattice": {
-        "a": 3.867,
-        "alpha": 60.0,
-        "b": 3.867,
-        "beta": 60.0,
-        "c": 3.867,
-        "gamma": 60.0,
-        "type": "TRI",
-        "units": {"angle": "degree", "length": "angstrom"},
-    },
-    "isNonPeriodic": False,
-}
-
-SI_SUPERCELL_2X2X1: Dict[str, Any] = {
-    "name": "Silicon FCC",
-    "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"},
-        ],
-        "coordinates": [
-            {"id": 0, "value": [0.0, 0.0, 0.0]},
-            {"id": 1, "value": [0.125, 0.125, 0.25]},
-            {"id": 2, "value": [0.0, 0.5, 0.0]},
-            {"id": 3, "value": [0.125, 0.625, 0.25]},
-            {"id": 4, "value": [0.5, 0.0, 0.0]},
-            {"id": 5, "value": [0.625, 0.125, 0.25]},
-            {"id": 6, "value": [0.5, 0.5, 0.0]},
-            {"id": 7, "value": [0.625, 0.625, 0.25]},
-        ],
-        "units": "crystal",
-        "constraints": [],
-        "labels": [],
-    },
-    "lattice": {
-        "a": 7.734,
-        "b": 7.734,
-        "c": 3.867,
-        "alpha": 60.0,
-        "beta": 60.0,
-        "gamma": 60.0,
-        "units": {"length": "angstrom", "angle": "degree"},
-        "type": "TRI",
-    },
-    "isNonPeriodic": False,
-    "metadata": {"boundaryConditions": {"type": "pbc", "offset": 0}},
-}

package/tests/py/unit/fixtures/terrace.py

@@ -1,70 +0,0 @@
-TERRACE_SLAB_Si_001_3x3 = {
-    "name": "Si(001), termination Si_P4/mmm_2, Slab, Terrace [0, 1, 0]",
-    "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"},
-        ],
-        "coordinates": [
-            {"id": 0, "value": [0.5, 0.977786405, 0.44181159]},
-            {"id": 1, "value": [0.25, 0.127786404, 0.402285072]},
-            {"id": 2, "value": [0.5, 0.277786404, 0.362758554]},
-            {"id": 3, "value": [0.25, 0.427786405, 0.323232035]},
-            {"id": 4, "value": [0, 0.077786404, 0.283705516]},
-            {"id": 5, "value": [0.75, 0.227786404, 0.244178997]},
-            {"id": 6, "value": [0, 0.177786405, 0.520864628]},
-            {"id": 7, "value": [0.75, 0.327786405, 0.48133811]},
-            {"id": 8, "value": [0.5, 0.377786404, 0.599917665]},
-            {"id": 9, "value": [0.25, 0.527786404, 0.560391147]},
-            {"id": 10, "value": [0.5, 0.677786404, 0.520864629]},
-            {"id": 11, "value": [0.25, 0.827786404, 0.48133811]},
-            {"id": 12, "value": [0, 0.477786403, 0.441811592]},
-            {"id": 13, "value": [0.75, 0.627786404, 0.402285072]},
-            {"id": 14, "value": [0, 0.577786405, 0.678970703]},
-            {"id": 15, "value": [0.75, 0.727786404, 0.639444185]},
-            {"id": 16, "value": [0.5, 0.777786404, 0.758023741]},
-            {"id": 17, "value": [0.25, 0.927786404, 0.718497223]},
-            {"id": 18, "value": [0.5, 0.077786405, 0.678970704]},
-            {"id": 19, "value": [0.25, 0.227786404, 0.639444186]},
-            {"id": 20, "value": [0, 0.877786404, 0.599917666]},
-            {"id": 21, "value": [0.75, 0.027786404, 0.560391148]},
-            {"id": 22, "value": [0, 0.977786405, 0.837076779]},
-            {"id": 23, "value": [0.75, 0.127786405, 0.79755026]},
-        ],
-        "units": "crystal",
-        "labels": [],
-        "constraints": [],
-    },
-    "lattice": {
-        "a": 5.468763846,
-        "b": 12.228527713,
-        "c": 15.468763846,
-        "alpha": 90,
-        "beta": 90,
-        "gamma": 90,
-        "units": {"length": "angstrom", "angle": "degree"},
-        "type": "TRI",
-    },
-}

package/tests/py/unit/fixtures/thrid_party/ase_atoms.py

@@ -1,13 +0,0 @@
-from ase.build import bulk, molecule
-
-BULK_SI_LATTICE_A = 3.8395
-BULK_SI_LATTICE_ALPHA = 60
-BULK_SI_LABELS = [{"id": 0, "value": 0}, {"id": 1, "value": 1}]
-
-atoms = bulk("Si")
-atoms.set_tags([0, 1])
-ASE_BULK_Si = atoms
-
-atoms = molecule("H2O")
-atoms.set_pbc(False)
-ASE_MOLECULE_H2O = atoms

package/tests/py/unit/test_analyze_lattice_planes.py

@@ -1,131 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.lattice_planes import CrystalLatticePlanesMaterialAnalyzer
-from mat3ra.utils import assertion as assertion_utils
-from unit.fixtures.bulk import BULK_SrTiO3
-
-SLAB_SrTiO3_EXPECTED_TERMINATIONS_WITH_VACUUM = [
-    [
-        (1, 1, 0),
-        ["SrTiO_Pmmm_3", "O2_Pmmm_2"],
-    ]
-]
-
-SLAB_SrTiO3_EXPECTED_TERMINATIONS_WITHOUT_VACUUM = [
-    [
-        (1, 1, 0),
-        [
-            "None",
-            "SrTiO_P4/mmm_3",
-        ],
-    ]
-]
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, number_of_slabs",
-    [
-        (
-            BULK_SrTiO3,
-            (1, 1, 0),
-            2,
-        ),
-    ],
-)
-def test_all_planes_as_pymatgen_slabs_with_vacuum(material_config, miller_indices, number_of_slabs):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    slabs_with_vacuum = analyzer.all_planes_as_pymatgen_slabs_with_vacuum
-    assert len(slabs_with_vacuum) == number_of_slabs
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, number_of_slabs",
-    [
-        (BULK_SrTiO3, (1, 1, 0), 1),
-    ],
-)
-def test_all_planes_as_pymatgen_slabs_without_vacuum(material_config, miller_indices, number_of_slabs):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    slabs_without_vacuum = analyzer.all_planes_as_pymatgen_slabs_without_vacuum
-    assert len(slabs_without_vacuum) == number_of_slabs
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, expected_shifts_with_vacuum",
-    [
-        (BULK_SrTiO3, (1, 1, 0), [0.25, 0.25]),
-    ],
-)
-def test_termination_holders_shifts_with_vacuum(material_config, miller_indices, expected_shifts_with_vacuum):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    shifts_with_vacuum = [h.shift_with_vacuum for h in analyzer.termination_holders]
-    assertion_utils.assert_deep_almost_equal(shifts_with_vacuum, expected_shifts_with_vacuum)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, expected_shifts_without_vacuum",
-    [
-        (BULK_SrTiO3, (1, 1, 0), [0.0, 0.25]),
-    ],
-)
-def test_termination_holders_shifts_without_vacuum(material_config, miller_indices, expected_shifts_without_vacuum):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    shifts_without_vacuum = [
-        h.shift_without_vacuum for h in analyzer.termination_holders if h.shift_without_vacuum is not None
-    ]
-    assertion_utils.assert_deep_almost_equal(shifts_without_vacuum, expected_shifts_without_vacuum)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, expected_terminations_with_vacuum_str",
-    [
-        (
-            BULK_SrTiO3,
-            (1, 1, 0),
-            SLAB_SrTiO3_EXPECTED_TERMINATIONS_WITH_VACUUM[0][1],
-        )
-    ],
-)
-def test_terminations_with_vacuum(material_config, miller_indices, expected_terminations_with_vacuum_str):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    terminations_with_vacuum = analyzer.terminations_with_vacuum
-    terminations_with_vacuum_str_list = [str(t) for t in terminations_with_vacuum]
-    assert sorted(terminations_with_vacuum_str_list) == sorted(expected_terminations_with_vacuum_str)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, expected_terminations_without_vacuum_str",
-    [
-        (
-            BULK_SrTiO3,
-            (1, 1, 0),
-            SLAB_SrTiO3_EXPECTED_TERMINATIONS_WITHOUT_VACUUM[0][1],
-        ),
-    ],
-)
-def test_terminations_without_vacuum(material_config, miller_indices, expected_terminations_without_vacuum_str):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    terminations_without_vacuum = analyzer.terminations_without_vacuum
-    terminations_without_vacuum_str_list = [str(t) for t in terminations_without_vacuum]
-    all_materials = analyzer.get_materials_for_all_terminations_without_vacuum()
-    assert sorted(terminations_without_vacuum_str_list) == sorted(expected_terminations_without_vacuum_str)
-    assert all_materials
-    assert len(all_materials) == len([t for t in analyzer.terminations_without_vacuum if t is not None])
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, expected_formulas",
-    [(BULK_SrTiO3, (1, 1, 0), ["SrTiO", "O2"])],
-)
-def test_terminations(material_config, miller_indices, expected_formulas):
-    material = Material.create(material_config)
-    analyzer = CrystalLatticePlanesMaterialAnalyzer(material=material, miller_indices=miller_indices)
-    terminations = analyzer.terminations
-    actual_formulas = sorted([t.formula for t in terminations])
-    assert sorted(actual_formulas) == sorted(expected_formulas)

package/tests/py/unit/test_cell.py

@@ -1,104 +0,0 @@
-from mat3ra.code.vector import RoundedVector3D
-from mat3ra.made.cell import Cell
-
-VECTORS = [
-    [1.0, 0.0, 0.0],
-    [0.0, 2.0, 0.0],
-    [0.0, 0.0, 3.0],
-]
-
-VECTORS_VOLUME = 6.0
-
-VECTORS_EQUAL_UP_TO_PRECISION_4 = [
-    [1.00001, 0.0, 0.0],
-    [0.0, 2.00001, 0.0],
-    [0.0, 0.0, 3.00001],
-]
-
-VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME = 6.000110000600002
-VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4 = 6.0001
-VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5 = 6.00011
-
-
-def test_cell_creation():
-    cell = Cell(a=RoundedVector3D(VECTORS[0]), b=RoundedVector3D(VECTORS[1]), c=RoundedVector3D(VECTORS[2]))
-    assert cell.a.value == VECTORS[0]
-    assert cell.b.value == VECTORS[1]
-    assert cell.c.value == VECTORS[2]
-    assert cell.volume == 6.0
-    assert cell.vector_arrays == VECTORS
-
-
-def test_cell_creation_default():
-    cell = Cell()
-    assert cell.a.value == Cell.__default_vectors__[0]
-    assert cell.b.value == Cell.__default_vectors__[1]
-    assert cell.c.value == Cell.__default_vectors__[2]
-    assert cell.volume == 1.0
-    assert cell.vector_arrays == Cell.__default_vectors__
-
-
-def test_from_vectors_array():
-    cell = Cell.from_vectors_array(vectors=VECTORS)
-    assert cell.a.value == VECTORS[0]
-    assert cell.b.value == VECTORS[1]
-    assert cell.c.value == VECTORS[2]
-    assert cell.volume == VECTORS_VOLUME
-    assert cell.vector_arrays == VECTORS
-
-
-def test_get_vector_arrays():
-    cell = Cell.from_vectors_array(vectors=VECTORS)
-    assert cell.get_vector_arrays() == VECTORS
-    assert cell.get_vector_arrays(skip_rounding=True) == VECTORS
-    assert cell.get_vector_arrays(skip_rounding=False) == VECTORS
-
-
-def test_vector_arrays_including_rounded():
-    class_reference = Cell
-    class_reference.__rounded_vector3d__ = RoundedVector3D
-
-    class_reference.__rounded_vector3d__.__round_precision__ = 4
-    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
-    assert cell.vector_arrays == VECTORS_EQUAL_UP_TO_PRECISION_4
-    assert cell.vector_arrays_rounded == VECTORS
-
-    class_reference.__rounded_vector3d__.__round_precision__ = 5
-    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
-    assert cell.vector_arrays == VECTORS_EQUAL_UP_TO_PRECISION_4
-    assert cell.vector_arrays_rounded != VECTORS
-
-
-def test_convert_point_to_cartesian():
-    cell = Cell.from_vectors_array(vectors=VECTORS)
-    coordinate_in_crystal = [0.5, 0.5, 0.5]
-    coordinate_in_cartesian = cell.convert_point_to_cartesian(coordinate_in_crystal)
-    expected_coordinate_in_cartesian = [0.5, 1.0, 1.5]
-    assert coordinate_in_cartesian == expected_coordinate_in_cartesian
-
-
-def test_convert_point_to_crystal():
-    cell = Cell.from_vectors_array(vectors=VECTORS)
-    coordinate_in_cartesian = [0.5, 1.0, 1.5]
-    coordinate_in_crystal = cell.convert_point_to_crystal(coordinate_in_cartesian)
-    expected_coordinate_in_crystal = [0.5, 0.5, 0.5]
-    assert coordinate_in_crystal == expected_coordinate_in_crystal
-
-
-def test_volume():
-    cell = Cell.from_vectors_array(vectors=VECTORS)
-    assert cell.volume == VECTORS_VOLUME
-
-
-def test_volume_rounded():
-    class_reference = Cell
-    class_reference.__round_precision__ = 4
-    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
-    assert cell.volume == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME
-    assert cell.volume_rounded == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4
-
-    class_reference.__round_precision__ = 5
-    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
-    assert cell.volume == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME
-    assert cell.volume_rounded != VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4
-    assert cell.volume_rounded == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5

package/tests/py/unit/test_data_files.py

@@ -1,68 +0,0 @@
-"""Tests that shared data files in data/ are accessible after package installation.
-
-These tests verify that the JSON files can be found and loaded via the
-path resolution logic used in production code. If they fail, the data
-files are likely missing from the installed package distribution.
-"""
-
-import json
-from pathlib import Path
-
-
-def _get_data_dir():
-    """Resolve data/ directory the same way production code does.
-
-    Production code uses Path(__file__).parents[N] to reach the repo root.
-    This test uses the same approach from its own location to verify the
-    path resolution works in the installed environment.
-    """
-    # tests/py/unit/test_data_files.py -> parents[3] -> repo root
-    return Path(__file__).parents[3] / "data"
-
-
-def test_data_dir_exists():
-    data_dir = _get_data_dir()
-    assert data_dir.exists(), f"data/ directory not found at {data_dir}"
-    assert data_dir.is_dir(), f"{data_dir} is not a directory"
-
-
-def test_data_constants_json_loadable():
-    path = _get_data_dir() / "constants.json"
-    assert path.exists(), f"constants.json not found at {path}"
-    with open(path) as f:
-        data = json.load(f)
-    assert "molecule" in data, "constants.json missing 'molecule' key"
-    assert "precision" in data, "constants.json missing 'precision' key"
-    assert data["molecule"]["nonPeriodicMinimumLatticeSize"] == 3.0
-
-
-def test_data_reciprocal_paths_json_loadable():
-    path = _get_data_dir() / "reciprocal_paths.json"
-    assert path.exists(), f"reciprocal_paths.json not found at {path}"
-    with open(path) as f:
-        data = json.load(f)
-    assert len(data) == 22, f"Expected 22 path keys, got {len(data)}"
-    assert "CUB" in data
-    assert "FCC" in data
-    assert "TRI" in data
-
-
-def test_data_constants_importable_from_production_code():
-    """Verify the actual production import path works."""
-    from mat3ra.made.tools.convert.utils import (
-        DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE,
-        DIATOMIC_LATTICE_PADDING_FACTOR,
-        MOLECULAR_LATTICE_PADDING_FACTOR,
-    )
-
-    assert DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE == 3.0
-    assert DIATOMIC_LATTICE_PADDING_FACTOR == 3.0
-    assert MOLECULAR_LATTICE_PADDING_FACTOR == 2.0
-
-
-def test_data_reciprocal_paths_importable_from_production_code():
-    """Verify the actual production import path works."""
-    from mat3ra.made.reciprocal import RECIPROCAL_PATHS
-
-    assert len(RECIPROCAL_PATHS) == 22
-    assert "CUB" in RECIPROCAL_PATHS

package/tests/py/unit/test_lattice.py

@@ -1,103 +0,0 @@
-import pytest
-from mat3ra.code.vector import RoundedVector3D
-from mat3ra.made.lattice import Lattice
-from mat3ra.utils import assertion as assertion_utils
-
-DEFAULT_UNITS = Lattice.__units_default__
-DEFAULT_TYPE = Lattice.__type_default__
-
-
-def test_lattice_creation():
-    lattice = Lattice(a=2.0, b=3.0, c=4.0)
-    assert lattice.a == 2.0
-    assert lattice.b == 3.0
-    assert lattice.c == 4.0
-    assert lattice.alpha == 90.0
-    assert lattice.beta == 90.0
-    assert lattice.gamma == 90.0
-    assert lattice.units == DEFAULT_UNITS
-    assert lattice.type == DEFAULT_TYPE
-
-
-def test_lattice_get_vectors():
-    lattice = Lattice(a=2.0, b=3.0, c=4.0)
-    expected_vectors = [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]
-    assert expected_vectors == lattice.vector_arrays_rounded
-
-
-def test_lattice_vectors_access():
-    lattice = Lattice(a=2.0, b=3.0, c=4.0)
-
-    # Test individual vector access
-    assert isinstance(lattice.vectors.a, RoundedVector3D)
-    assert isinstance(lattice.vectors.b, RoundedVector3D)
-    assert isinstance(lattice.vectors.c, RoundedVector3D)
-
-    # Test vector arrays access
-    arrays = lattice.vector_arrays
-    assert len(arrays) == 3
-    assert arrays[0] == lattice.vectors.a
-    assert arrays[1] == lattice.vectors.b
-    assert arrays[2] == lattice.vectors.c
-
-    # Test get value of vectors, without rounding
-    assertion_utils.assert_deep_almost_equal(lattice.vectors.a.root, [2.0, 0.0, 0.0])
-
-
-def test_lattice_from_vectors():
-    lattice = Lattice.from_vectors_array(vectors=[[2.0, 0, 0], [0, 3.0, 0], [0, 0, 4.0]])
-    assert lattice.a == 2.0
-    assert lattice.b == 3.0
-    assert lattice.c == 4.0
-    assert lattice.alpha == 90.0
-    assert lattice.beta == 90.0
-    assert lattice.gamma == 90.0
-    assert lattice.units == DEFAULT_UNITS
-    assert lattice.type.value == DEFAULT_TYPE
-    # Avoid floating point comparison issue
-    assertion_utils.assert_deep_almost_equal(lattice.cell_volume, 24.0)
-    assert lattice.cell_volume_rounded == 24.0
-    assert lattice.vector_arrays_rounded == [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]
-
-
-def test_lattice_get_scaled_by_matrix():
-    original_lattice = Lattice(a=2.0, b=3.0, c=4.0)
-    matrix = [[1.5, 0, 0], [0, 1.5, 0], [0, 0, 0.5]]
-    expected_vector_values = [[3.0, 0.0, 0.0], [0.0, 4.5, 0.0], [0.0, 0.0, 2.0]]
-    lattice = original_lattice.get_scaled_by_matrix(matrix)
-    assert lattice.a == 3.0
-    assert lattice.b == 4.5
-    assert lattice.c == 2.0
-    assert lattice.alpha == pytest.approx(90.0)
-    assert lattice.beta == pytest.approx(90.0)
-    assert lattice.gamma == pytest.approx(90.0)
-    assert lattice.units == DEFAULT_UNITS
-    assert lattice.type.value == DEFAULT_TYPE
-    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_lattice_type_extended.py

@@ -1,53 +0,0 @@
-"""Tests for Lattice.type_extended property."""
-
-import pytest
-from mat3ra.made.lattice import Lattice
-
-
-@pytest.mark.parametrize(
-    "lattice_params, expected_type",
-    [
-        # Simple types return base type
-        ({"a": 1.0, "b": 1.0, "c": 1.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "CUB"}, "CUB"),
-        ({"a": 1.0, "b": 1.0, "c": 1.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "FCC"}, "FCC"),
-        ({"a": 1.0, "b": 1.0, "c": 1.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "BCC"}, "BCC"),
-        ({"a": 1.0, "b": 1.0, "c": 2.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "TET"}, "TET"),
-        ({"a": 2.0, "b": 3.0, "c": 4.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "ORC"}, "ORC"),
-        ({"a": 1.0, "b": 1.0, "c": 2.0, "alpha": 90, "beta": 90, "gamma": 120, "type": "HEX"}, "HEX"),
-        # BCT subtypes
-        ({"a": 2.0, "b": 2.0, "c": 1.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "BCT"}, "BCT-1"),  # c < a
-        ({"a": 1.0, "b": 1.0, "c": 2.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "BCT"}, "BCT-2"),  # c >= a
-        # ORCF subtypes
-        (
-            {"a": 3.0, "b": 4.0, "c": 5.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "ORCF"},
-            "ORCF-1",
-        ),  # 1/a^2 >= 1/b^2 + 1/c^2 for a=3,b=4,c=5: 1/9≈0.111 vs 1/16+1/25≈0.1025
-        (
-            {"a": 4.0, "b": 2.0, "c": 3.0, "alpha": 90, "beta": 90, "gamma": 90, "type": "ORCF"},
-            "ORCF-2",
-        ),  # 1/a^2 < 1/b^2 + 1/c^2: 1/16=0.0625 < 1/4+1/9=0.361
-        # RHL subtypes
-        ({"a": 1.0, "b": 1.0, "c": 1.0, "alpha": 60, "beta": 60, "gamma": 60, "type": "RHL"}, "RHL-1"),  # cos(60)>0
-        (
-            {"a": 1.0, "b": 1.0, "c": 1.0, "alpha": 120, "beta": 120, "gamma": 120, "type": "RHL"},
-            "RHL-2",
-        ),  # cos(120)<0
-        # MCLC subtypes
-        (
-            {"a": 1.0, "b": 2.0, "c": 3.0, "alpha": 80, "beta": 90, "gamma": 95, "type": "MCLC"},
-            "MCLC-1",
-        ),  # gamma >= 90
-        # TRI subtypes
-        (
-            {"a": 1.0, "b": 2.0, "c": 3.0, "alpha": 95, "beta": 100, "gamma": 110, "type": "TRI"},
-            "TRI_1a",
-        ),  # all > 90
-        (
-            {"a": 1.0, "b": 2.0, "c": 3.0, "alpha": 80, "beta": 85, "gamma": 75, "type": "TRI"},
-            "TRI_1b",
-        ),  # not all > 90
-    ],
-)
-def test_type_extended(lattice_params, expected_type):
-    lattice = Lattice(**lattice_params)
-    assert lattice.type_extended == expected_type