@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/py/unit/test_tools_analyze_interface.py

@@ -1,223 +0,0 @@
-from types import SimpleNamespace
-from typing import Final
-
-import numpy as np
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.interface import InterfaceAnalyzer
-from mat3ra.made.tools.analyze.interface.commensurate import CommensurateLatticeInterfaceAnalyzer
-from mat3ra.made.tools.analyze.interface.utils import calculate_interfacial_distance_from_rdf
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab import SlabConfiguration
-from unit.fixtures.bulk import BULK_GRAPHENE, BULK_Ge_CONVENTIONAL, BULK_Si_CONVENTIONAL
-
-from .fixtures.monolayer import GRAPHENE
-from .utils import assert_two_entities_deep_almost_equal
-
-SUBSTRATE_SI_001: Final = SimpleNamespace(
-    bulk_config=BULK_Si_CONVENTIONAL,
-    miller_indices=(0, 0, 1),
-    number_of_layers=2,
-    vacuum=0.0,
-)
-
-FILM_GE_001: Final = SimpleNamespace(
-    bulk_config=BULK_Ge_CONVENTIONAL,
-    miller_indices=(0, 0, 1),
-    number_of_layers=2,
-    vacuum=0.0,
-)
-
-EXPECTED_PROPERTIES_SI_GE_001: Final = SimpleNamespace(
-    substrate_strain_matrix=np.identity(3).tolist(),
-    substrate_supercell_matrix=[[1.0, 0.0], [0.0, 1.0]],
-    film_strain_matrix=[[0.9643, 0.0, 0.0], [0.0, 0.9643, 0.0], [0.0, 0.0, 1.0]],
-    film_supercell_matrix=[[1.0, 0.0], [0.0, 1.0]],
-)
-
-TEST_CASES = [(SUBSTRATE_SI_001, FILM_GE_001, EXPECTED_PROPERTIES_SI_GE_001)]
-
-
-SUBSTRATE_SI_111: Final = SimpleNamespace(
-    bulk_config=BULK_Si_CONVENTIONAL,
-    miller_indices=(1, 1, 1),
-    number_of_layers=2,
-    vacuum=0.0,
-)
-
-FILM_GRAPHENE_001: Final = SimpleNamespace(
-    bulk_config=BULK_GRAPHENE,
-    miller_indices=(0, 0, 1),
-    number_of_layers=1,
-    vacuum=0.0,
-)
-
-OPTIMAL_SUPERCELL_TEST_CASES = [
-    (SUBSTRATE_SI_111, FILM_GRAPHENE_001, 4, 4),  # n, m
-]
-
-
-@pytest.mark.parametrize("substrate, film, expected", TEST_CASES)
-def test_interface_analyzer(substrate, film, expected):
-    substrate_slab_config = SlabConfiguration.from_parameters(
-        substrate.bulk_config,
-        substrate.miller_indices,
-        substrate.number_of_layers,
-        vacuum=substrate.vacuum,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-    film_slab_config = SlabConfiguration.from_parameters(
-        film.bulk_config,
-        film.miller_indices,
-        film.number_of_layers,
-        vacuum=film.vacuum,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-
-    interface_analyzer = InterfaceAnalyzer(
-        substrate_slab_configuration=substrate_slab_config,
-        film_slab_configuration=film_slab_config,
-    )
-
-    assert_two_entities_deep_almost_equal(
-        interface_analyzer.get_substrate_strain_matrix().root, expected.substrate_strain_matrix
-    )
-    assert_two_entities_deep_almost_equal(
-        interface_analyzer.film_strained_configuration.strain_matrix.root, expected.film_strain_matrix, atol=1e-4
-    )
-
-    # Test strain matrix calculation using vectors from substrate and film
-    substrate_vectors = np.array(interface_analyzer.substrate_material.lattice.vector_arrays)
-    film_vectors = np.array(interface_analyzer.film_material.lattice.vector_arrays)
-
-    strain_matrix_3d = interface_analyzer.get_film_strain_matrix(substrate_vectors, film_vectors)
-
-    matrix = [row.root for row in strain_matrix_3d.root]
-    strain_matrix_2d = np.array(matrix)[:2, :2]
-
-    # Verify that strain applied to film vectors yields substrate vectors
-    film_2d = film_vectors[:2, :2]
-    substrate_2d = substrate_vectors[:2, :2]
-    film_strained = film_2d @ strain_matrix_2d
-
-    assert np.allclose(film_strained, substrate_2d, atol=1e-10)
-
-
-@pytest.mark.parametrize(
-    "material_config, analyzer_params, expected_matches_len, expected_angle_range",
-    [
-        (
-            GRAPHENE,
-            {"target_angle": 13.0, "angle_tolerance": 0.5, "max_supercell_matrix_int": 5, "return_first_match": True},
-            1,
-            (12.5, 13.5),
-        )
-    ],
-)
-def test_commensurate_analyzer_functionality(
-    material_config, analyzer_params, expected_matches_len, expected_angle_range
-):
-    slab_config = SlabConfiguration.from_parameters(
-        material_config,
-        miller_indices=(0, 0, 1),
-        number_of_layers=1,
-        vacuum=0.0,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-
-    analyzer = CommensurateLatticeInterfaceAnalyzer(substrate_slab_configuration=slab_config, **analyzer_params)
-
-    assert analyzer.substrate_material == analyzer.film_material == analyzer.material
-
-    match_holders = analyzer.commensurate_lattice_match_holders
-    assert len(match_holders) >= expected_matches_len
-
-    for match in match_holders:
-        assert expected_angle_range[0] <= match.angle <= expected_angle_range[1]
-        assert expected_angle_range[0] <= match.actual_angle <= expected_angle_range[1]
-        assert match.angle == match.actual_angle
-        assert isinstance(match.xy_supercell_matrix_film, list)
-        assert isinstance(match.xy_supercell_matrix_substrate, list)
-        assert len(match.xy_supercell_matrix_film) == 2
-        assert len(match.xy_supercell_matrix_substrate) == 2
-        assert isinstance(match.match_id, int)
-        assert match.match_id >= 0
-
-    interface_configurations = analyzer.get_strained_configurations()
-    assert len(interface_configurations) == len(match_holders)
-
-    if len(match_holders) > 0:
-        selected_config = analyzer.get_strained_configuration_by_match_id(0)
-        assert selected_config.match_id == 0
-        assert hasattr(selected_config, "substrate_configuration")
-        assert hasattr(selected_config, "film_configuration")
-
-        assert selected_config.substrate_configuration.stack_components == slab_config.stack_components
-        assert selected_config.film_configuration.stack_components == slab_config.stack_components
-
-        # Test invalid match ID
-        with pytest.raises(ValueError, match="Match ID .* out of range"):
-            analyzer.get_strained_configuration_by_match_id(999)
-
-        # Test negative match ID
-        with pytest.raises(ValueError, match="Match ID .* out of range"):
-            analyzer.get_strained_configuration_by_match_id(-1)
-
-
-@pytest.mark.parametrize("substrate, film, expected_n, expected_m", OPTIMAL_SUPERCELL_TEST_CASES)
-def test_optimal_supercell_functions(substrate, film, expected_n, expected_m):
-    """Test the optimal supercell functions with Si/Ge fixtures."""
-    substrate_slab_config = SlabConfiguration.from_parameters(
-        substrate.bulk_config,
-        substrate.miller_indices,
-        substrate.number_of_layers,
-        vacuum=substrate.vacuum,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-    film_slab_config = SlabConfiguration.from_parameters(
-        film.bulk_config,
-        film.miller_indices,
-        film.number_of_layers,
-        vacuum=film.vacuum,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-
-    analyzer = InterfaceAnalyzer(
-        substrate_slab_configuration=substrate_slab_config,
-        film_slab_configuration=film_slab_config,
-        optimize_film_supercell=True,
-    )
-
-    # Test find_optimal_film_supercell
-    optimal_n, optimal_m = analyzer.find_optimal_film_supercell()
-
-    assert optimal_n == expected_n
-    assert optimal_m == expected_m
-
-
-@pytest.mark.parametrize(
-    "substrate_config, film_config, expected_distance_range",
-    [
-        (BULK_Si_CONVENTIONAL, BULK_Si_CONVENTIONAL, (3.8, 3.9)),
-        (BULK_Si_CONVENTIONAL, BULK_Ge_CONVENTIONAL, (3.1, 3.2)),
-    ],
-)
-def test_calculate_interfacial_distance_from_rdf(substrate_config, film_config, expected_distance_range):
-    """Test RDF-based interfacial distance calculation with different material types."""
-    substrate_material = Material.create(substrate_config)
-    film_material = Material.create(film_config)
-
-    distance = calculate_interfacial_distance_from_rdf(
-        substrate_material=substrate_material,
-        film_material=film_material,
-        rdf_cutoff=10.0,
-        rdf_bin_size=0.1,
-        supercell_size=(3, 3, 3),
-    )
-
-    assert isinstance(distance, float)
-    assert expected_distance_range[0] <= distance <= expected_distance_range[1]

package/tests/py/unit/test_tools_analyze_interface_material.py

@@ -1,63 +0,0 @@
-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_analyze_interface_zsl.py

@@ -1,187 +0,0 @@
-from types import SimpleNamespace
-from typing import Final
-
-import numpy as np
-import pytest
-from mat3ra.made.tools.analyze.interface.zsl import ZSLInterfaceAnalyzer
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab import SlabConfiguration
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab_strained_supercell.builder import (
-    SlabStrainedSupercellBuilder,
-)
-from mat3ra.made.tools.utils import supercell_matrix_2d_schema_to_list, unwrap
-from mat3ra.utils.matrix import convert_2x2_to_3x3
-from unit.fixtures.bulk import BULK_Ge_CONVENTIONAL, BULK_Ni_PRIMITIVE, BULK_Si_CONVENTIONAL
-
-from .fixtures.monolayer import GRAPHENE
-from .utils import OSPlatform, get_platform_specific_value
-
-SUBSTRATE_SI_001: Final = SimpleNamespace(
-    bulk_config=BULK_Si_CONVENTIONAL,
-    miller_indices=(0, 0, 1),
-    number_of_layers=2,
-    vacuum=0.0,
-)
-
-FILM_GE_001: Final = SimpleNamespace(
-    bulk_config=BULK_Ge_CONVENTIONAL,
-    miller_indices=(0, 0, 1),
-    number_of_layers=2,
-    vacuum=0.0,
-)
-
-EXPECTED_PROPERTIES_SI_GE_001: Final = SimpleNamespace(
-    substrate_strain_matrix=np.identity(3).tolist(),
-    substrate_supercell_matrix=[[1.0, 0.0], [0.0, 1.0]],
-    film_strain_matrix=[[0.9643, 0.0, 0.0], [0.0, 0.9643, 0.0], [0.0, 0.0, 1.0]],
-    film_supercell_matrix=[[1.0, 0.0], [0.0, 1.0]],
-)
-
-
-@pytest.mark.parametrize(
-    "substrate, film, zsl_params, expected_matches_min",
-    [
-        (
-            SUBSTRATE_SI_001,
-            FILM_GE_001,
-            {"max_area": 350.0, "max_area_ratio_tol": 0.09, "max_length_tol": 0.03, "max_angle_tol": 0.01},
-            1,
-        ),
-        (
-            SimpleNamespace(
-                bulk_config=BULK_Ni_PRIMITIVE,
-                miller_indices=(0, 0, 1),
-                number_of_layers=2,
-                vacuum=0.0,
-            ),
-            SimpleNamespace(
-                bulk_config=GRAPHENE,
-                miller_indices=(0, 0, 1),
-                number_of_layers=1,
-                vacuum=0.0,
-            ),
-            {"max_area": 120.0, "max_area_ratio_tol": 0.09, "max_length_tol": 0.03, "max_angle_tol": 0.01},
-            1,
-        ),
-    ],
-)
-def test_zsl_interface_analyzer(substrate, film, zsl_params, expected_matches_min):
-    substrate_slab_config = SlabConfiguration.from_parameters(
-        substrate.bulk_config,
-        substrate.miller_indices,
-        substrate.number_of_layers,
-        vacuum=0.0,
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-    film_slab_config = SlabConfiguration.from_parameters(
-        film.bulk_config, film.miller_indices, film.number_of_layers, vacuum=0.0
-    )
-
-    analyzer = ZSLInterfaceAnalyzer(
-        substrate_slab_configuration=substrate_slab_config,
-        film_slab_configuration=film_slab_config,
-        **zsl_params,
-    )
-
-    # Test ZSL match generation
-    match_holders = analyzer.zsl_match_holders
-    assert len(match_holders) >= expected_matches_min
-
-    match = analyzer.get_strained_configuration_by_match_id(0)
-
-    sub_config = match.substrate_configuration
-    film_config = match.film_configuration
-
-    film_vectors = np.array(analyzer.film_slab.lattice.vector_arrays)
-    substrate_vectors = np.array(analyzer.substrate_slab.lattice.vector_arrays)
-
-    film_sl_vectors = (
-        np.array(unwrap(film_config.strain_matrix.root))
-        @ np.array(convert_2x2_to_3x3(supercell_matrix_2d_schema_to_list(film_config.xy_supercell_matrix)))
-        @ film_vectors
-    )
-    substrate_sl_vectors = (
-        np.array(convert_2x2_to_3x3(supercell_matrix_2d_schema_to_list(sub_config.xy_supercell_matrix)))
-        @ substrate_vectors
-    )
-
-    substrate_material = SlabStrainedSupercellBuilder().get_material(sub_config)
-    film_material = SlabStrainedSupercellBuilder().get_material(film_config)
-
-    # Check that the lattice vectors have the same magnitudes (allowing for orientation differences)
-    film_a = np.linalg.norm(film_sl_vectors[0])
-    film_b = np.linalg.norm(film_sl_vectors[1])
-    substrate_a = np.linalg.norm(substrate_sl_vectors[0])
-    substrate_b = np.linalg.norm(substrate_sl_vectors[1])
-
-    assert np.isclose(film_a, substrate_a, atol=0.1)
-    assert np.isclose(film_b, substrate_b, atol=0.1)
-
-    # Check that the unit cell areas match
-    film_area = abs(np.cross(film_sl_vectors[0][:2], film_sl_vectors[1][:2]))
-    substrate_area = abs(np.cross(substrate_sl_vectors[0][:2], substrate_sl_vectors[1][:2]))
-    assert np.isclose(film_area, substrate_area, 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)
-
-
-@pytest.mark.parametrize(
-    "substrate, film, zsl_parameters, expected_number_of_matches, expected_properties",
-    [
-        (
-            SimpleNamespace(
-                bulk_config=BULK_Ni_PRIMITIVE,
-                miller_indices=(1, 1, 1),
-                number_of_layers=3,
-                vacuum=0.0,
-            ),
-            SimpleNamespace(
-                bulk_config=GRAPHENE,
-                miller_indices=(0, 0, 1),
-                number_of_layers=1,
-                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: 26, OSPlatform.OTHER: 29},
-            {
-                OSPlatform.DARWIN: {"strain_percentage": 0.474, "match_id": 0},
-                OSPlatform.OTHER: {"strain_percentage": 25.629, "match_id": 0},
-            },
-            # NOTE: the following values are expected for the DARWIN platform.
-            # {"max_area": 90.0, "max_area_ratio_tol": 0.09, "max_length_tol": 0.03, "max_angle_tol": 0.01},
-            # 31,
-            # {"strain_percentage": 25.122, "match_id": 0},
-        ),
-    ],
-)
-def test_zsl_interface_analyzer_sort_by_strain_then_area(
-    substrate, film, zsl_parameters, expected_number_of_matches, expected_properties
-):
-    expected_number_of_matches = get_platform_specific_value(expected_number_of_matches)
-    expected_properties = get_platform_specific_value(expected_properties)
-
-    analyzer = ZSLInterfaceAnalyzer(
-        substrate_slab_configuration=SlabConfiguration.from_parameters(
-            substrate.bulk_config,
-            substrate.miller_indices,
-            substrate.number_of_layers,
-            vacuum=0.0,
-            termination_top_formula=None,
-            termination_bottom_formula=None,
-        ),
-        film_slab_configuration=SlabConfiguration.from_parameters(
-            film.bulk_config, film.miller_indices, film.number_of_layers, vacuum=0.0
-        ),
-        **zsl_parameters,
-    )
-
-    sorted_match_holders = analyzer.zsl_match_holders
-
-    assert len(sorted_match_holders) == expected_number_of_matches
-
-    index_to_check = expected_properties["match_id"]
-    match_to_check = sorted_match_holders[index_to_check]
-    expected_strain_percentage = expected_properties["strain_percentage"]
-
-    assert np.isclose(match_to_check.total_strain_percentage, expected_strain_percentage, atol=1e-3)

package/tests/py/unit/test_tools_analyze_lattice.py

@@ -1,74 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.lattice import LatticeMaterialAnalyzer, get_lattice_type
-
-from .fixtures.bulk import BULK_GRAPHITE, BULK_Hf2O_MCL, BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVE, BULK_Si_PRIMITIVIZED
-from .fixtures.interface.gaas_dia import (
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE,
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE,
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE_GH_WF,
-)
-from .fixtures.interface.gr_ni_111_top_hcp import GRAPHENE_NICKEL_INTERFACE_TOP_HCP
-from .utils import (
-    OSPlatform,
-    assert_interfaces_almost_equal,
-    assert_two_entities_deep_almost_equal,
-    get_platform_specific_value,
-)
-
-
-@pytest.mark.parametrize(
-    "material_config, expected_conventional_material_config, expected_primitive_material_config",
-    [
-        (BULK_Si_PRIMITIVE, BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVIZED),
-        (BULK_Si_CONVENTIONAL, BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVIZED),
-    ],
-)
-def test_get_primitive_lattice(
-    material_config, expected_conventional_material_config, expected_primitive_material_config
-):
-    material = Material.create(material_config)
-    lattice_material_analyzer = LatticeMaterialAnalyzer(material=material)
-    conventional_cell = lattice_material_analyzer.material_with_conventional_lattice
-    assert_two_entities_deep_almost_equal(conventional_cell, expected_conventional_material_config)
-
-    primitive_cell_generated = lattice_material_analyzer.material_with_primitive_lattice
-    assert_two_entities_deep_almost_equal(primitive_cell_generated, expected_primitive_material_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, keep_orientation, expected_primitive",
-    [
-        (
-            GALLIUM_ARSENIDE_DIAMOND_INTERFACE,
-            True,
-            {
-                OSPlatform.DARWIN: GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE,
-                OSPlatform.OTHER: GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE_GH_WF,
-            },
-        ),
-    ],
-)
-def test_get_primitive_lattice_standard(material_config, keep_orientation, expected_primitive):
-    original_material = Material.create(material_config)
-    analyzer = LatticeMaterialAnalyzer(material=original_material)
-    corrected_primitive_material = analyzer.get_material_with_primitive_lattice_standard(
-        keep_orientation=keep_orientation
-    )
-    expected_primitive_material = get_platform_specific_value(expected_primitive)
-    assert_interfaces_almost_equal(corrected_primitive_material, expected_primitive_material)
-
-
-@pytest.mark.parametrize(
-    "material, expected_lattice_type",
-    [
-        (BULK_Si_PRIMITIVE, "FCC"),
-        (BULK_Si_CONVENTIONAL, "FCC"),
-        (GRAPHENE_NICKEL_INTERFACE_TOP_HCP, "HEX"),
-        (BULK_Hf2O_MCL, "MCL"),
-        (BULK_GRAPHITE, "HEX"),
-    ],
-)
-def test_analyze_lattice_type(material, expected_lattice_type):
-    result = get_lattice_type(material)
-    assert result.value == expected_lattice_type

package/tests/py/unit/test_tools_analyze_swap.py

@@ -1,80 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.lattice import LatticeMaterialAnalyzer
-from mat3ra.made.tools.analyze.lattice_swap_analyzer import MaterialLatticeSwapAnalyzer
-
-from .fixtures.interface.gaas_dia import (
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE,
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE,
-    GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE_GH_WF,
-)
-from .fixtures.interface.gr_ni_111_top_hcp import GRAPHENE_NICKEL_INTERFACE_TOP_HCP_GH_WF
-from .fixtures.slab import SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO
-from .utils import (
-    OSPlatform,
-    assert_interfaces_almost_equal,
-    assert_two_entities_deep_almost_equal,
-    get_platform_specific_value,
-)
-
-
-@pytest.mark.parametrize(
-    "original_material_config, another_material_config, is_swapped",
-    [
-        (SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_O2, False),
-        (SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO, True),
-    ],
-)
-def test_flip_detection_between_materials(original_material_config, another_material_config, is_swapped):
-    original_material = Material.create(original_material_config)
-    another_material = Material.create(another_material_config)
-
-    rotation_analyzer = MaterialLatticeSwapAnalyzer(material=another_material)
-    swap_info = rotation_analyzer.detect_swap_from_original(original_material)
-
-    new_lattice = rotation_analyzer.get_corrected_material(another_material).lattice
-
-    assert swap_info.is_swapped == is_swapped
-    assert_two_entities_deep_almost_equal(new_lattice, another_material.lattice)
-
-
-@pytest.mark.parametrize(
-    "original_material_config, expected_swapped, expected_primitive, clear_labels",
-    [
-        (
-            GALLIUM_ARSENIDE_DIAMOND_INTERFACE,
-            {OSPlatform.DARWIN: True, OSPlatform.OTHER: True},
-            {
-                OSPlatform.DARWIN: GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE,
-                OSPlatform.OTHER: GALLIUM_ARSENIDE_DIAMOND_INTERFACE_PRIMITIVE_GH_WF,
-            },
-            False,
-        ),
-        (
-            GRAPHENE_NICKEL_INTERFACE_TOP_HCP_GH_WF,
-            {OSPlatform.DARWIN: True, OSPlatform.OTHER: False},
-            None,
-            True,
-        ),
-    ],
-)
-def test_swap_detection(original_material_config, expected_swapped, expected_primitive, clear_labels):
-    original_material = Material.create(original_material_config)
-    primitive_material = LatticeMaterialAnalyzer(material=original_material).material_with_primitive_lattice
-
-    analyzer = MaterialLatticeSwapAnalyzer(material=primitive_material)
-    swap_info = analyzer.detect_swap_from_original(original_material)
-
-    expected_is_swapped = get_platform_specific_value(expected_swapped)
-    assert swap_info.is_swapped is expected_is_swapped
-
-    if clear_labels:
-        original_material.basis.set_labels_from_list([])
-
-    corrected_primitive_material = analyzer.get_corrected_material(original_material)
-
-    if expected_primitive is not None:
-        expected_primitive_material = get_platform_specific_value(expected_primitive)
-        assert_interfaces_almost_equal(corrected_primitive_material, expected_primitive_material)
-    else:
-        assert_interfaces_almost_equal(corrected_primitive_material, original_material)