@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/py/unit/test_tools_build.py

@@ -1,158 +0,0 @@
-import pytest
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components import BaseConfigurationPydantic, MaterialWithBuildMetadata
-from mat3ra.made.tools.build_components.operations.core.combinations.merge.build_parameters import (
-    MergeBuilderParameters,
-)
-from mat3ra.made.tools.build_components.operations.core.combinations.merge.builder import MergeBuilder
-from mat3ra.made.tools.build_components.operations.core.combinations.merge.configuration import MergeConfiguration
-from mat3ra.made.tools.operations.core.binary import merge
-from mat3ra.utils import assertion as assertion_utils
-from unit.fixtures.bulk import BULK_Ge_CONVENTIONAL, BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVE
-from unit.fixtures.cuts import (
-    CAVITY_MATERIAL_BASIS,
-    FULL_MATERIAL,
-    MERGED_CAVITY_SECTION_BASIS,
-    MERGED_SECTION_CAVITY_BASIS,
-    SECTION_MATERIAL_BASIS,
-    SECTION_MATERIAL_BASIS_EXTRA_ATOM,
-)
-from unit.fixtures.merge import MERGED_BULK_Si_Ge
-from unit.fixtures.point_defects import (
-    INTERSTITIAL_DEFECT_BULK_PRIMITIVE_Si,
-    SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-    VACANCY_DEFECT_BULK_PRIMITIVE_Si,
-)
-from unit.utils import assert_two_entities_deep_almost_equal
-
-section = Material.create({**FULL_MATERIAL, **SECTION_MATERIAL_BASIS})
-cavity = Material.create({**FULL_MATERIAL, **CAVITY_MATERIAL_BASIS})
-section_with_extra_atom = Material.create({**FULL_MATERIAL, **SECTION_MATERIAL_BASIS_EXTRA_ATOM})
-
-
-@pytest.mark.parametrize(
-    "materials_to_merge, expected_basis, expected_basis_reverse",
-    [
-        (
-            [section, cavity],
-            MERGED_CAVITY_SECTION_BASIS,
-            MERGED_SECTION_CAVITY_BASIS,
-        ),
-        (
-            [section_with_extra_atom, cavity],
-            MERGED_CAVITY_SECTION_BASIS,
-            MERGED_SECTION_CAVITY_BASIS,
-        ),
-    ],
-)
-def test_merge_materials(materials_to_merge, expected_basis, expected_basis_reverse):
-    merged_material = merge(materials_to_merge)
-    merged_material_reverse = merge(materials_to_merge[::-1])
-    assertion_utils.assert_deep_almost_equal(merged_material.basis, expected_basis)
-    assertion_utils.assert_deep_almost_equal(merged_material_reverse.basis, expected_basis_reverse)
-
-
-def test_configuration():
-    class MockConfiguration(BaseConfigurationPydantic):
-        value_1: str = "test"
-        value_2: int = 0
-
-    class CompositeMockConfiguration(BaseConfigurationPydantic):
-        component: MockConfiguration = MockConfiguration(value_1="component_value")
-
-    mock_config = MockConfiguration(value_1="component_value", value_2=42)
-    configuration = CompositeMockConfiguration(component=mock_config)
-    assert isinstance(configuration.component, MockConfiguration)
-    assert configuration.component.value_1 == "component_value"
-    assert configuration.component.value_2 == 42
-
-    config_dict = configuration.to_dict()
-    assert config_dict["component"]["value_1"] == "component_value"
-    assert config_dict["component"]["value_2"] == 42
-
-    configuration_from_dict = CompositeMockConfiguration(**config_dict)
-    assert isinstance(configuration_from_dict.component, MockConfiguration)
-    assert configuration_from_dict.component.value_1 == "component_value"
-    assert configuration_from_dict.component.value_2 == 42
-
-
-MERGE_TEST_PARAMS = [
-    (
-        BULK_Si_CONVENTIONAL,
-        BULK_Ge_CONVENTIONAL,
-        MergeMethodsEnum.REPLACE,
-        {"material_name": "Si-Ge Merged", "distance_tolerance": 0.1, "merge_dangerously": True},
-        MERGED_BULK_Si_Ge,
-    ),
-]
-
-
-@pytest.mark.parametrize(
-    "material1_config, material2_config, merge_method, builder_params, expected_material_config", MERGE_TEST_PARAMS
-)
-def test_merge_builder(material1_config, material2_config, merge_method, builder_params, expected_material_config):
-    material1 = MaterialWithBuildMetadata.create(material1_config)
-    material2 = MaterialWithBuildMetadata.create(material2_config)
-
-    merge_config = MergeConfiguration(merge_components=[material1, material2], merge_method=merge_method)
-
-    builder_parameters = MergeBuilderParameters(**builder_params)
-    builder = MergeBuilder(build_parameters=builder_parameters)
-
-    merged_material = builder.get_material(merge_config)
-
-    assert_two_entities_deep_almost_equal(merged_material, expected_material_config)
-
-
-@pytest.mark.parametrize(
-    "material1_config, material2_config, merge_method, expected_material_config",
-    [
-        (
-            VACANCY_DEFECT_BULK_PRIMITIVE_Si,
-            INTERSTITIAL_DEFECT_BULK_PRIMITIVE_Si,
-            MergeMethodsEnum.ADD,
-            INTERSTITIAL_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-        (
-            VACANCY_DEFECT_BULK_PRIMITIVE_Si,
-            SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-            MergeMethodsEnum.REPLACE,
-            SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-        (
-            SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-            BULK_Si_PRIMITIVE,
-            MergeMethodsEnum.YIELD,
-            SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-    ],
-)
-def test_merge_methods(material1_config, material2_config, merge_method, expected_material_config):
-    material1 = MaterialWithBuildMetadata.create(material1_config)
-    material2 = MaterialWithBuildMetadata.create(material2_config)
-    merge_config = MergeConfiguration(merge_components=[material1, material2], merge_method=merge_method)
-    builder = MergeBuilder(build_parameters=MergeBuilderParameters(merge_dangerously=True))
-    merged_material = builder.get_material(merge_config)
-
-    # Custom comparison that ignores atom IDs, metadata, and name
-    def compare_materials_ignoring_ids(actual, expected):
-        actual_dict = actual.to_dict()
-        expected_dict = expected.to_dict()
-
-        # Remove IDs from coordinates and elements
-        for material_dict in [actual_dict, expected_dict]:
-            for coord in material_dict["basis"]["coordinates"]:
-                coord.pop("id", None)
-            for elem in material_dict["basis"]["elements"]:
-                elem.pop("id", None)
-            # Remove metadata and name differences
-            material_dict.pop("metadata", None)
-            material_dict.pop("name", None)
-            material_dict["lattice"].pop("type", None)
-
-        # Compare only essential structure
-        assert_two_entities_deep_almost_equal(actual_dict, expected_dict)
-
-    expected_material = Material.create(expected_material_config)
-    compare_materials_ignoring_ids(merged_material, expected_material)

package/tests/py/unit/test_tools_build_defect/test_adatom.py

@@ -1,84 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.defective_structures.two_dimensional.adatom.helpers import (
-    create_defect_adatom,
-    create_multiple_adatom_defects,
-)
-from mat3ra.made.tools.build.defective_structures.two_dimensional.adatom.types import AdatomDefectDict
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.helpers import create_slab
-from mat3ra.made.tools.build_components.operations.core.combinations.enums import AdatomPlacementMethodEnum
-from mat3ra.utils import assertion as assertion_utils
-from unit.fixtures.adatom import SLAB_Si_3_ADATOMS
-from unit.fixtures.bulk import BULK_Si_CONVENTIONAL
-from unit.fixtures.slab import SI_CONVENTIONAL_SLAB_001
-from unit.utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "crystal_config, position_on_surface, distance_z, chemical_element, adatom_placement_method, expected_last_coord",
-    [
-        (
-            BULK_Si_CONVENTIONAL,
-            [0.5, 0.5],
-            2.0,
-            "Si",
-            AdatomPlacementMethodEnum.NEW_CRYSTAL_SITE.value,
-            [0.5, 0.5, 0.4659],
-        ),
-        (
-            BULK_Si_CONVENTIONAL,
-            [0.55, 0.51],
-            2.0,
-            "Si",
-            AdatomPlacementMethodEnum.EXACT_COORDINATE.value,
-            [0.55, 0.51, 0.4621],
-        ),
-    ],
-)
-def test_create_adatom(
-    crystal_config,
-    position_on_surface,
-    distance_z,
-    chemical_element,
-    adatom_placement_method,
-    expected_last_coord,
-):
-    slab = create_slab(
-        crystal=Material.create(crystal_config),
-        number_of_layers=2,
-        xy_supercell_matrix=[[2, 0], [0, 2]],
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-    defect = create_defect_adatom(slab, position_on_surface, distance_z, adatom_placement_method, chemical_element)
-
-    assertion_utils.assert_deep_almost_equal(expected_last_coord, defect.basis.coordinates.values[-1], atol=1e-4)
-
-
-@pytest.mark.parametrize(
-    "crystal_config, adatom_dicts, placement_method, expected_material_config",
-    [
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            [
-                {"element": "Si", "coordinate_2d": [0.5, 0.5], "distance_z": 2.0},
-                {"element": "C", "coordinate_2d": [0.25, 0.25], "distance_z": 1.5},
-                {"element": "N", "coordinate_2d": [0.75, 0.75], "distance_z": 1.0},
-            ],
-            AdatomPlacementMethodEnum.EXACT_COORDINATE.value,
-            SLAB_Si_3_ADATOMS,
-        ),
-    ],
-)
-def test_create_multiple_adatom_defects(crystal_config, adatom_dicts, placement_method, expected_material_config):
-    slab = MaterialWithBuildMetadata.create(crystal_config)
-
-    defect_models = []
-    for adatom_data in adatom_dicts:
-        defect_dict = AdatomDefectDict(**adatom_data)
-        defect_models.append(defect_dict)
-
-    defects = create_multiple_adatom_defects(slab, defect_models, placement_method)
-    defects.metadata.build = []
-    assert_two_entities_deep_almost_equal(defects, expected_material_config)

package/tests/py/unit/test_tools_build_defect/test_island.py

@@ -1,45 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.defective_structures.two_dimensional.island.helpers import create_defect_island
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.helpers import create_slab
-from mat3ra.made.tools.entities import coordinate as CoordinateCondition
-from unit.fixtures.bulk import BULK_Si_CONVENTIONAL
-from unit.fixtures.island import ISLAND_SLAB_Si_001_CYLINDER_CONDITION_1_LAYER
-from unit.utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "slab_parameters, condition_class, condition_params, num_added_layers, expected_config",
-    [
-        (
-            {"crystal": BULK_Si_CONVENTIONAL, "number_of_layers": 2, "xy_supercell_matrix": [[3, 0], [0, 3]]},
-            CoordinateCondition.CylinderCoordinateCondition,
-            {"center_position": [0.5, 0.5], "radius": 0.25, "min_z": 0, "max_z": 1},
-            1,
-            ISLAND_SLAB_Si_001_CYLINDER_CONDITION_1_LAYER,
-        )
-    ],
-)
-def test_create_island_defect(slab_parameters, condition_class, condition_params, num_added_layers, expected_config):
-    slab = create_slab(
-        Material.create(slab_parameters["crystal"]),
-        number_of_layers=slab_parameters["number_of_layers"],
-        xy_supercell_matrix=slab_parameters["xy_supercell_matrix"],
-        termination_top_formula=None,
-        termination_bottom_formula=None,
-    )
-    condition = condition_class(
-        center_position=condition_params["center_position"],
-        radius=condition_params["radius"],
-        min_z=condition_params["min_z"],
-        max_z=condition_params["max_z"],
-    )
-
-    defect = create_defect_island(
-        slab=slab,
-        condition=condition,
-        use_cartesian_coordinates=False,
-        number_of_added_layers=num_added_layers,
-    )
-    defect.metadata.build = []
-    assert_two_entities_deep_almost_equal(defect, expected_config)

package/tests/py/unit/test_tools_build_defect/test_pair_defect.py

@@ -1,84 +0,0 @@
-from types import SimpleNamespace
-
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.pair_defect.builder import PairDefectBuilder
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.pair_defect.configuration import (
-    PairDefectConfiguration,
-)
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.point_defect import (
-    SubstitutionPlacementMethodEnum,
-    create_defect_configuration,
-)
-from unit.fixtures.bulk import BULK_Si_PRIMITIVE
-from unit.fixtures.pair_defects import (
-    PAIR_DEFECT_SUBSTITUTION_VACANCY_BULK_PRIMITIVE_Si,
-    PAIR_DEFECT_VACANCY_INTERSTITIAL_BULK_PRIMITIVE_Si,
-)
-from unit.utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "material_config, pair_defect_params, expected_material_config",
-    [
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                primary_defect_type="vacancy",
-                primary_coordinate=[0.0, 0.0, 0.0],
-                secondary_defect_type="interstitial",
-                secondary_coordinate=[0.5, 0.5, 0.5],
-                secondary_element="Ge",
-            ),
-            PAIR_DEFECT_VACANCY_INTERSTITIAL_BULK_PRIMITIVE_Si,
-        ),
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                primary_defect_type="substitution",
-                primary_coordinate=[0.123, 0.123, 0.123],
-                primary_element="Ge",
-                primary_placement_method=SubstitutionPlacementMethodEnum.CLOSEST_SITE,
-                secondary_defect_type="vacancy",
-                secondary_coordinate=[0.25, 0.25, 0.25],
-            ),
-            PAIR_DEFECT_SUBSTITUTION_VACANCY_BULK_PRIMITIVE_Si,
-        ),
-    ],
-)
-def test_pair_defect_builder(material_config, pair_defect_params, expected_material_config):
-    crystal = Material.create(material_config)
-
-    primary_config = create_defect_configuration(
-        material=crystal,
-        defect_type=pair_defect_params.primary_defect_type,
-        coordinate=pair_defect_params.primary_coordinate,
-        element=pair_defect_params.primary_element if hasattr(pair_defect_params, "primary_element") else None,
-        placement_method=(
-            pair_defect_params.primary_placement_method
-            if hasattr(pair_defect_params, "primary_placement_method")
-            else None
-        ),
-    )
-    secondary_config = create_defect_configuration(
-        material=crystal,
-        defect_type=pair_defect_params.secondary_defect_type,
-        coordinate=pair_defect_params.secondary_coordinate,
-        element=pair_defect_params.secondary_element if hasattr(pair_defect_params, "secondary_element") else None,
-        placement_method=(
-            pair_defect_params.secondary_placement_method
-            if hasattr(pair_defect_params, "secondary_placement_method")
-            else None
-        ),
-    )
-
-    config = PairDefectConfiguration.from_parameters(
-        crystal=crystal,
-        primary_defect_configuration=primary_config,
-        secondary_defect_configuration=secondary_config,
-    )
-
-    builder = PairDefectBuilder()
-    defect = builder.get_material(config)
-
-    assert_two_entities_deep_almost_equal(defect, expected_material_config)

package/tests/py/unit/test_tools_build_defect/test_point_defect.py

@@ -1,196 +0,0 @@
-from types import SimpleNamespace
-
-import numpy as np
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.point_defect import (
-    InterstitialPlacementMethodEnum,
-    SubstitutionPlacementMethodEnum,
-    VacancyPlacementMethodEnum,
-)
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.point_defect.helpers import (
-    create_defect_point_interstitial,
-    create_defect_point_substitution,
-    create_defect_point_vacancy,
-    create_multiple_defects,
-)
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.point_defect.types import PointDefectDict
-from unit.fixtures.bulk import BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVE
-from unit.fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
-from unit.fixtures.point_defects import (
-    INTERSTITIAL_DEFECT_BULK_PRIMITIVE_Si,
-    INTERSTITIAL_VORONOI_DEFECT_BULK_PRIMITIVE_Si,
-    MULTIPLE_POINT_DEFECTS_BULK_Si_CONVENTIONAL,
-    SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-    VACANCY_DEFECT_BULK_PRIMITIVE_Si,
-)
-from unit.utils import assert_two_entities_deep_almost_equal, get_platform_specific_value
-
-# The default comparison tolerance (atol=1e-9) in assert_two_entities_deep_almost_equal
-# is too strict for the interstitial Voronoi placement method. Because Qhull/SciPy calculates
-# different symmetrically equivalent vertices on different platforms/compilers, we define a
-# custom coordinate tolerance (atol=1e-4) to verify that the generated coordinate is
-# within a reasonable tolerance of any of the valid symmetrical Voronoi sites.
-UPDATED_COORDINATE_TOLERANCE = 1e-4
-
-FILM_LABEL = 1
-SUBSTRATE_LABEL = 0
-SUBSTITUTION_ELEMENT = "Ge"
-INTERFACE_SUBSTITUTION_PLACEMENT_METHOD = SubstitutionPlacementMethodEnum.CLOSEST_SITE.value
-
-
-def _film_atom_coordinate(material: Material) -> list:
-    labels_by_id = {entry["id"]: entry["value"] for entry in material.basis.labels.to_dict()}
-    for coordinate_entry in material.basis.coordinates.to_dict():
-        if labels_by_id.get(coordinate_entry["id"]) == FILM_LABEL:
-            return coordinate_entry["value"]
-    raise ValueError("No film atom found in fixture material")
-
-
-@pytest.mark.parametrize(
-    "material_config, defect_params, expected_material_config",
-    [
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                type="vacancy",
-                coordinate=[0.0, 0.0, 0.0],
-                placement_method=VacancyPlacementMethodEnum.CLOSEST_SITE.value,
-            ),
-            VACANCY_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                type="substitution",
-                coordinate=[0.0, 0.0, 0.0],
-                element="Ge",
-                placement_method=SubstitutionPlacementMethodEnum.CLOSEST_SITE.value,
-            ),
-            SUBSTITUTION_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                type="interstitial",
-                coordinate=[0.5, 0.5, 0.5],
-                element="C",
-                placement_method=InterstitialPlacementMethodEnum.EXACT_COORDINATE.value,
-            ),
-            INTERSTITIAL_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-        (
-            BULK_Si_PRIMITIVE,
-            SimpleNamespace(
-                type="interstitial",
-                coordinate=[0.25, 0.25, 0.5],
-                element="Ge",
-                placement_method=InterstitialPlacementMethodEnum.VORONOI_SITE.value,
-            ),
-            INTERSTITIAL_VORONOI_DEFECT_BULK_PRIMITIVE_Si,
-        ),
-    ],
-)
-def test_point_defect_helpers(material_config, defect_params, expected_material_config):
-    crystal = Material.create(material_config)
-
-    if defect_params.type == "vacancy":
-        defect = create_defect_point_vacancy(crystal, defect_params.coordinate, defect_params.placement_method)
-    elif defect_params.type == "substitution":
-        defect = create_defect_point_substitution(
-            crystal, defect_params.coordinate, defect_params.element, defect_params.placement_method
-        )
-    elif defect_params.type == "interstitial":
-        defect = create_defect_point_interstitial(
-            crystal, defect_params.coordinate, defect_params.element, defect_params.placement_method
-        )
-    else:
-        raise ValueError(f"Unknown defect_type: {defect_params.type}")
-
-    expected_material_config = get_platform_specific_value(expected_material_config)
-
-    if (
-        defect_params.type == "interstitial"
-        and defect_params.placement_method == InterstitialPlacementMethodEnum.VORONOI_SITE.value
-    ):
-        # The interstitial atom is the 3rd atom (index 2)
-        actual_coord = defect.basis.coordinates.values[2]
-        allowed_coords = [[0.625, 0.625, 0.125], [0.625, 0.625, 0.625], [0.5, 0.5, 0.5]]
-        assert any(
-            np.allclose(actual_coord, allowed, atol=UPDATED_COORDINATE_TOLERANCE) for allowed in allowed_coords
-        ), f"Voronoi coordinate {actual_coord} not in allowed list"
-        if isinstance(expected_material_config, dict):
-            expected_material_config["basis"]["coordinates"][2]["value"] = actual_coord
-        else:
-            expected_material_config.basis.coordinates.values[2] = actual_coord
-
-    assert_two_entities_deep_almost_equal(defect, expected_material_config)
-
-
-@pytest.mark.parametrize(
-    "expected_label_count, expected_unique_labels",
-    [(5, {SUBSTRATE_LABEL, FILM_LABEL})],
-)
-def test_create_defect_point_substitution_preserves_interface_labels(expected_label_count, expected_unique_labels):
-    material = Material.create(GRAPHENE_NICKEL_INTERFACE)
-    coordinate = _film_atom_coordinate(material)
-
-    defect_material = create_defect_point_substitution(
-        material, coordinate, SUBSTITUTION_ELEMENT, INTERFACE_SUBSTITUTION_PLACEMENT_METHOD
-    )
-
-    assert len(defect_material.basis.elements.values) == expected_label_count
-    assert len(defect_material.basis.labels.values) == expected_label_count
-    assert set(defect_material.basis.labels.values) == expected_unique_labels
-
-
-@pytest.mark.parametrize(
-    "material_config, defect_params_list, expected_material_config",
-    [
-        (
-            BULK_Si_CONVENTIONAL,
-            [
-                SimpleNamespace(
-                    defect_type="vacancy",
-                    coordinate=[0.75, 0.70, 0.70],
-                    placement_method=VacancyPlacementMethodEnum.CLOSEST_SITE.value,
-                ),
-                SimpleNamespace(
-                    defect_type="interstitial",
-                    coordinate=[0.25, 0.25, 0.2],
-                    element="N",
-                    placement_method=InterstitialPlacementMethodEnum.VORONOI_SITE.value,
-                ),
-                SimpleNamespace(
-                    defect_type="substitution",
-                    coordinate=[0.543, 0.543, 0.5],
-                    element="Ge",
-                    placement_method="closest_site",
-                ),
-            ],
-            MULTIPLE_POINT_DEFECTS_BULK_Si_CONVENTIONAL,
-        ),
-    ],
-)
-def test_create_multiple_defects(material_config, defect_params_list, expected_material_config):
-    material = MaterialWithBuildMetadata.create(material_config)
-
-    defect_dicts = []
-    for defect_params in defect_params_list:
-        defect_data = {
-            "type": defect_params.defect_type,
-            "coordinate": defect_params.coordinate,
-            "placement_method": defect_params.placement_method if hasattr(defect_params, "placement_method") else None,
-            "element": defect_params.element if hasattr(defect_params, "element") else None,
-        }
-
-        defect_dict = PointDefectDict(**defect_data)
-
-        defect_dicts.append(defect_dict)
-
-    defects = create_multiple_defects(
-        material=material,
-        defect_dicts=defect_dicts,
-    )
-    assert_two_entities_deep_almost_equal(defects, expected_material_config)

package/tests/py/unit/test_tools_build_defect/test_slab_stack.py

@@ -1,30 +0,0 @@
-import pytest
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build_components.entities.reusable.two_dimensional.slab_stack.helpers import (
-    create_slab_stack,
-    recreate_slab_with_fractional_layers,
-)
-from unit.fixtures.slab import SI_CONVENTIONAL_SLAB_001, SI_SLAB_001_ADDED_FRACTIONAL_LAYER, SI_SLAB_001_ADDED_LAYER
-from unit.utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "original_slab_config, number_of_layers, expected_slab_config",
-    [
-        (SI_CONVENTIONAL_SLAB_001, 1, SI_SLAB_001_ADDED_LAYER),
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            1.5,
-            SI_SLAB_001_ADDED_FRACTIONAL_LAYER,
-        ),
-    ],
-)
-def test_create_slab_stack(original_slab_config, number_of_layers, expected_slab_config):
-    original_slab = MaterialWithBuildMetadata.create(original_slab_config)
-
-    slab_component = recreate_slab_with_fractional_layers(original_slab, number_of_layers)
-    # Here we can create isolated defect out of slab_component
-
-    slab_stack = create_slab_stack(original_slab, slab_component)
-
-    assert_two_entities_deep_almost_equal(slab_stack, expected_slab_config, atol=1e-6)