@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/py/unit/test_tools_build_interface_zsl.py

@@ -1,263 +0,0 @@
-import copy
-from types import SimpleNamespace
-
-import numpy as np
-import pytest
-from mat3ra.made.basis import Basis
-from mat3ra.made.lattice import COORDINATE_TOLERANCE
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.interface.zsl import ZSLInterfaceAnalyzer
-from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.base.builder import InterfaceBuilder
-from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.base.configuration import (
-    InterfaceConfiguration,
-)
-from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface.zsl.helpers import (
-    create_interface_zsl,
-    create_interface_zsl_between_slabs,
-)
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab import SlabBuilder, SlabConfiguration
-from mat3ra.made.tools.build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from mat3ra.standata.materials import Materials
-
-from .fixtures.bulk import BULK_Ni_PRIMITIVE
-from .fixtures.interface.gr_ni_111_top_hcp import (
-    GRAPHENE_NICKEL_INTERFACE_TOP_HCP,
-    GRAPHENE_NICKEL_INTERFACE_TOP_HCP_GH_WF,
-)
-from .fixtures.interface.zsl import DIAMOND_GaAs_INTERFACE, DIAMOND_GaAs_INTERFACE_GH
-from .fixtures.monolayer import GRAPHENE
-from .utils import OSPlatform, assert_interfaces_almost_equal, get_platform_specific_value
-
-GRAPHENE_NICKEL_TEST_CASE = (
-    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,
-    ),
-    3.0,  # gap between graphene and nickel
-    10.0,  # vacuum
-    90,  # max area
-    {
-        OSPlatform.DARWIN: GRAPHENE_NICKEL_INTERFACE_TOP_HCP,
-        OSPlatform.OTHER: GRAPHENE_NICKEL_INTERFACE_TOP_HCP_GH_WF,
-    },
-)
-
-BULK_DIAMOND = Materials.get_by_name_first_match("Diamond")
-BULK_GaAs = Materials.get_by_name_first_match("GaAs")
-
-DIAMOND_GAAS_CSL_TEST_CASE = (
-    SimpleNamespace(
-        bulk_config=BULK_DIAMOND,
-        miller_indices=(0, 0, 1),
-        number_of_layers=1,
-        vacuum=0.0,
-    ),
-    SimpleNamespace(
-        bulk_config=BULK_GaAs,
-        miller_indices=(0, 0, 1),
-        number_of_layers=1,
-        vacuum=0.0,
-    ),
-    1.5,  # gap between diamond and gaas
-    10.0,  # vacuum
-    70.0,  # max area
-    {
-        OSPlatform.DARWIN: DIAMOND_GaAs_INTERFACE,
-        OSPlatform.OTHER: DIAMOND_GaAs_INTERFACE_GH,
-    },
-)
-
-
-MAX_AREA_RATIO_TOL = 0.09
-MAX_LENGTH_TOL = 0.05
-MAX_ANGLE_TOL = 0.02
-
-
-# The default comparison tolerance (atol=1e-9) in assert_two_entities_deep_almost_equal
-# is too strict for cross-platform floating-point variations in ZSL interface coordinate
-# calculations, which can differ on the order of 10**-8 to 10**-7 across different systems
-# and compilers. We instead use the coordinate tolerance defined in mat3ra.made.lattice,
-# which is 10**-COORDINATE_TOLERANCE (10**-6 = 1e-6).
-UPDATED_COORDINATE_TOLERANCE = 10**-COORDINATE_TOLERANCE
-
-
-def to_basis_obj(b_dict: dict) -> Basis:
-    """
-    Ensure a basis dictionary has sequential IDs and convert it to a Basis object.
-
-    Args:
-        b_dict (dict): The dictionary representation of a basis.
-
-    Returns:
-        Basis: The instantiated Basis object.
-    """
-    b_dict = copy.deepcopy(b_dict)
-    for key in ["elements", "coordinates"]:
-        if key in b_dict and isinstance(b_dict[key], list):
-            for idx, item in enumerate(b_dict[key]):
-                if isinstance(item, dict) and "id" not in item:
-                    item["id"] = idx
-    return Basis(**b_dict)
-
-
-def are_bases_almost_equal(b1: Basis, b2: Basis, atol: float) -> bool:
-    """
-    Compare two Basis objects for equality with permuted ordering and coordinate tolerance.
-
-    Args:
-        b1 (Basis): The first Basis object.
-        b2 (Basis): The second Basis object.
-        atol (float): Absolute tolerance for coordinate comparison.
-
-    Returns:
-        bool: True if the bases are physically equivalent within tolerance, False otherwise.
-    """
-    if b1.number_of_atoms != b2.number_of_atoms:
-        return False
-    n = b1.number_of_atoms
-    self_elements, other_elements = b1.elements.values, b2.elements.values
-    self_coords, other_coords = b1.coordinates.values, b2.coordinates.values
-    self_labels = b1.labels.values if (b1.labels and len(b1.labels.values) == n) else [None] * n
-    other_labels = b2.labels.values if (b2.labels and len(b2.labels.values) == n) else [None] * n
-    self_constraints = b1.constraints.values if (b1.constraints and len(b1.constraints.values) == n) else [None] * n
-    other_constraints = b2.constraints.values if (b2.constraints and len(b2.constraints.values) == n) else [None] * n
-
-    other_indices_left = set(range(n))
-    for i in range(n):
-        found = False
-        elem, coord, lbl, const = self_elements[i], self_coords[i], self_labels[i], self_constraints[i]
-        for j in list(other_indices_left):
-            if other_elements[j] == elem and other_labels[j] == lbl and other_constraints[j] == const:
-                if np.allclose(other_coords[j], coord, atol=atol):
-                    other_indices_left.remove(j)
-                    found = True
-                    break
-        if not found:
-            return False
-    return True
-
-
-@pytest.mark.parametrize(
-    "substrate, film,gap, vacuum, max_area, expected_interface",
-    [GRAPHENE_NICKEL_TEST_CASE, DIAMOND_GAAS_CSL_TEST_CASE],
-)
-def test_zsl_interface_builder(substrate, film, gap, vacuum, max_area, expected_interface):
-    """Test creating Si/Ge interface using ZSL approach."""
-    substrate_slab_config = SlabConfiguration.from_parameters(
-        substrate.bulk_config, substrate.miller_indices, substrate.number_of_layers, vacuum=substrate.vacuum
-    )
-    film_slab_config = SlabConfiguration.from_parameters(
-        film.bulk_config, film.miller_indices, film.number_of_layers, vacuum=film.vacuum
-    )
-
-    # Use ZSLInterfaceAnalyzer to get strained slab configurations
-    analyzer = ZSLInterfaceAnalyzer(
-        substrate_slab_configuration=substrate_slab_config,
-        film_slab_configuration=film_slab_config,
-        max_area=max_area,
-        max_area_ratio_tol=MAX_AREA_RATIO_TOL,
-        max_length_tol=MAX_LENGTH_TOL,
-        max_angle_tol=MAX_ANGLE_TOL,
-        reduce_result_cell=False,
-    )
-
-    interface_configurations = analyzer.get_strained_configurations()
-
-    selected_config = interface_configurations[0]
-    vacuum_configuration = VacuumConfiguration(size=vacuum)
-    interface_config = InterfaceConfiguration(
-        stack_components=[
-            selected_config.substrate_configuration,
-            selected_config.film_configuration,
-            vacuum_configuration,
-        ],
-        gaps=[gap, gap],
-    )
-
-    builder = InterfaceBuilder()
-    interface = builder.get_material(interface_config)
-
-    # remove metadata
-    interface.metadata.build = []
-    expected_interface = Material.create(get_platform_specific_value(expected_interface))
-
-    assert interface.basis.number_of_atoms == expected_interface.basis.number_of_atoms
-
-    assert_interfaces_almost_equal(interface, expected_interface)
-
-
-@pytest.mark.parametrize("substrate, film,gap, vacuum, max_area,  expected_interface", [GRAPHENE_NICKEL_TEST_CASE])
-def test_create_zsl_interface(substrate, film, gap, vacuum, max_area, expected_interface):
-    interface = create_interface_zsl(
-        substrate_crystal=substrate.bulk_config,
-        film_crystal=film.bulk_config,
-        substrate_miller_indices=substrate.miller_indices,
-        film_miller_indices=film.miller_indices,
-        substrate_number_of_layers=substrate.number_of_layers,
-        film_number_of_layers=film.number_of_layers,
-        substrate_termination_formula=None,
-        film_termination_formula=None,
-        gap=gap,
-        vacuum=vacuum,
-        xy_shift=[0, 0],
-        max_area=max_area,
-        max_area_ratio_tol=MAX_AREA_RATIO_TOL,
-        max_length_tol=MAX_LENGTH_TOL,
-        max_angle_tol=MAX_ANGLE_TOL,
-        use_conventional_cell=True,
-        reduce_result_cell=False,
-        reduce_result_cell_to_primitive=True,
-    )
-    interface.metadata.build = []
-    expected_interface = get_platform_specific_value(expected_interface)
-    assert_interfaces_almost_equal(interface, expected_interface)
-
-
-@pytest.mark.parametrize(
-    "substrate, film, gap, vacuum, max_area, expected_interface",
-    [GRAPHENE_NICKEL_TEST_CASE, DIAMOND_GAAS_CSL_TEST_CASE],
-)
-def test_create_zsl_interface_between_slabs(substrate, film, gap, vacuum, max_area, expected_interface):
-    substrate_slab_config = SlabConfiguration.from_parameters(
-        material_or_dict=substrate.bulk_config,
-        miller_indices=substrate.miller_indices,
-        number_of_layers=substrate.number_of_layers,
-        vacuum=0.0,
-        termination_top_formula=None,
-        use_conventional_cell=True,
-    )
-    film_slab_config = SlabConfiguration.from_parameters(
-        material_or_dict=film.bulk_config,
-        miller_indices=film.miller_indices,
-        number_of_layers=film.number_of_layers,
-        vacuum=0.0,
-        termination_bottom_formula=None,
-        use_conventional_cell=True,
-    )
-
-    substrate_slab = SlabBuilder().get_material(substrate_slab_config)
-    film_slab = SlabBuilder().get_material(film_slab_config)
-
-    interface = create_interface_zsl_between_slabs(
-        substrate_slab=substrate_slab,
-        film_slab=film_slab,
-        gap=gap,
-        vacuum=vacuum,
-        xy_shift=[0, 0],
-        max_area=max_area,
-        max_area_ratio_tol=MAX_AREA_RATIO_TOL,
-        max_length_tol=MAX_LENGTH_TOL,
-        max_angle_tol=MAX_ANGLE_TOL,
-        reduce_result_cell=False,
-        reduce_result_cell_to_primitive=True,
-    )
-    expected_interface = get_platform_specific_value(expected_interface)
-    assert_interfaces_almost_equal(interface, expected_interface)

package/tests/py/unit/test_tools_build_maxwell_disorder.py

@@ -1,123 +0,0 @@
-import numpy as np
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb.functions.maxwell_boltzmann import (
-    MaxwellBoltzmannDisplacementHolder,
-)
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb.helpers import create_maxwell_displacement
-from mat3ra.made.tools.helpers import create_supercell
-from mat3ra.periodic_table.helpers import get_atomic_mass_from_element
-
-from .fixtures.bulk import BULK_Si_PRIMITIVE
-from .fixtures.slab import SI_CONVENTIONAL_SLAB_001
-
-DISORDER_PARAMETER = 1.0  # Temperature-like
-RANDOM_SEED = 42
-NUM_SAMPLES_FOR_MSD = 1000
-
-
-@pytest.mark.parametrize("random_seed", [None, 42, 123])
-def test_maxwell_displacement_deterministic(random_seed):
-    material = Material.create(BULK_Si_PRIMITIVE)
-    displacement_func1 = MaxwellBoltzmannDisplacementHolder(
-        disorder_parameter=DISORDER_PARAMETER, random_seed=random_seed
-    )
-    displacement_func2 = MaxwellBoltzmannDisplacementHolder(
-        disorder_parameter=DISORDER_PARAMETER, random_seed=random_seed
-    )
-
-    coord = [0.0, 0.0, 0.0]
-
-    if random_seed is not None:
-        disp1 = displacement_func1.apply_function(coord, material=material)
-        disp2 = displacement_func2.apply_function(coord, material=material)
-        assert np.allclose(disp1, disp2)
-
-        # Different seed should give different results
-        displacement_func3 = MaxwellBoltzmannDisplacementHolder(
-            disorder_parameter=DISORDER_PARAMETER, random_seed=random_seed + 1
-        )
-        disp3 = displacement_func3.apply_function(coord, material=material)
-        assert not np.allclose(disp1, disp3) or np.allclose(disp1, [0, 0, 0], atol=1e-10)
-    else:
-        # No seed: different instances should give different results (non-deterministic)
-        disp1 = displacement_func1.apply_function(coord, material=material)
-        disp2 = displacement_func2.apply_function(coord, material=material)
-        assert not np.allclose(disp1, disp2) or np.allclose(disp1, [0, 0, 0], atol=1e-10)
-
-
-def test_maxwell_displacement_perturb_integration():
-    material = Material.create(BULK_Si_PRIMITIVE)
-    original_coords = [coord[:] for coord in material.basis.coordinates.values]
-
-    perturbed_material = create_maxwell_displacement(
-        material, disorder_parameter=DISORDER_PARAMETER, random_seed=RANDOM_SEED
-    )
-
-    assert len(perturbed_material.basis.coordinates.values) == len(original_coords)
-    for i, (orig, pert) in enumerate(zip(original_coords, perturbed_material.basis.coordinates.values)):
-        delta = np.array(pert) - np.array(orig)
-        assert np.linalg.norm(delta) > 0 or np.allclose(delta, 0, atol=1e-10)
-
-
-def test_maxwell_displacement_msd_expectation():
-    material = Material.create(BULK_Si_PRIMITIVE)
-    si_mass = get_atomic_mass_from_element("Si")
-    disorder_parameter = DISORDER_PARAMETER
-    expected_variance = disorder_parameter / si_mass
-    expected_msd = 3 * expected_variance
-
-    displacements = []
-    coord = [0.0, 0.0, 0.0]
-    for _ in range(NUM_SAMPLES_FOR_MSD):
-        displacement_func = MaxwellBoltzmannDisplacementHolder(disorder_parameter=disorder_parameter, random_seed=None)
-        disp = displacement_func.apply_function(coord, material=material)
-        displacements.append(disp)
-
-    displacements_array = np.array(displacements)
-    msd = np.mean(np.sum(displacements_array**2, axis=1))
-
-    assert abs(msd - expected_msd) / expected_msd < 0.3
-
-
-@pytest.mark.parametrize(
-    "slab_config, temperature_k, random_seed",
-    [
-        (SI_CONVENTIONAL_SLAB_001, 1300.0, 42),
-        (SI_CONVENTIONAL_SLAB_001, 1300.0, 42),
-    ],
-)
-def test_maxwell_boltzmann_on_slab(slab_config, temperature_k, random_seed):
-    material = Material.create(slab_config)
-    material = create_supercell(material, scaling_factor=[4, 4, 1])
-    original_coords = [coord[:] for coord in material.basis.coordinates.values]
-    original_lattice = material.lattice.vector_arrays.copy()
-
-    perturbed_material = create_maxwell_displacement(
-        material, disorder_parameter=temperature_k, random_seed=random_seed
-    )
-
-    assert len(perturbed_material.basis.coordinates.values) == len(original_coords)
-    assert len(perturbed_material.basis.elements.values) == len(material.basis.elements.values)
-
-    coordinate_changes = []
-    for i, (orig, pert) in enumerate(zip(original_coords, perturbed_material.basis.coordinates.values)):
-        delta = np.array(pert) - np.array(orig)
-        displacement_magnitude = np.linalg.norm(delta)
-        coordinate_changes.append(displacement_magnitude)
-
-    max_displacement = max(coordinate_changes)
-    mean_displacement = np.mean(coordinate_changes)
-
-    assert max_displacement > 0
-    assert mean_displacement > 0
-
-    si_mass = get_atomic_mass_from_element("Si")
-    expected_std = np.sqrt(temperature_k / si_mass)
-
-    assert mean_displacement < 5 * expected_std
-
-    assert np.allclose(perturbed_material.lattice.vector_arrays, original_lattice, atol=1e-10)
-
-    for i, element in enumerate(material.basis.elements.values):
-        assert perturbed_material.basis.elements.values[i] == element

package/tests/py/unit/test_tools_build_metadata.py

@@ -1,79 +0,0 @@
-import pytest
-from mat3ra.code.entity import InMemoryEntityPydantic
-from mat3ra.made.tools.build_components.metadata import BuildMetadata, MaterialBuildMetadata
-
-
-class ConfigWithToDict(InMemoryEntityPydantic):
-    value: str = "test_dict"
-
-
-class ConfigWithToJsonReturnsStr(InMemoryEntityPydantic):
-    value: str = "test_json_str"
-
-
-class MockParameters(InMemoryEntityPydantic):
-    param: str = "param_value"
-
-
-def test_metadata_initialization_with_data():
-    initial_data = {"existing_key": "existing_value", "build": [{"configuration": {"initial": "config"}}]}
-    metadata = MaterialBuildMetadata(**initial_data)
-
-    assert metadata.existing_key == "existing_value"
-    assert metadata.build[-1].configuration["initial"] == "config"
-
-
-def test_metadata_empty_initialization():
-    metadata = MaterialBuildMetadata()
-    assert metadata.model_dump(exclude_none=True) == {"build": []}
-
-
-def test_get_latest_build_metadata():
-    metadata = MaterialBuildMetadata(build=[BuildMetadata(configuration={"type": "SlabConfiguration"})])
-    assert metadata.get_latest_build_metadata().configuration["type"] == "SlabConfiguration"
-
-
-def test_get_latest_build_metadata_raises_when_empty():
-    with pytest.raises(ValueError, match="No metadata.build"):
-        MaterialBuildMetadata().get_latest_build_metadata()
-
-
-@pytest.mark.parametrize(
-    "config_object, expected_dict",
-    [
-        (ConfigWithToDict(), {"value": "test_dict"}),
-        (ConfigWithToJsonReturnsStr(), {"value": "test_json_str"}),
-    ],
-)
-def test_build_metadata_update(config_object, expected_dict):
-    build_metadata = BuildMetadata()
-
-    build_metadata.update(configuration=config_object)
-    assert build_metadata.configuration == expected_dict
-
-    build_metadata.configuration = {}
-    build_metadata.update(build_parameters=config_object)
-    assert build_metadata.build_parameters == expected_dict
-
-
-def test_full_lifecycle_and_serialization():
-    # Initialize with some existing data
-    metadata = MaterialBuildMetadata(existing_key="previous_material_metadata_value")
-
-    # Update with a 'to_dict' config
-    config = ConfigWithToDict(value="config_value")
-    params = MockParameters(param="param_value")
-    metadata.build.append(BuildMetadata(configuration=config, build_parameters=params))
-
-    # Check the final state before serialization
-    assert metadata.existing_key == "previous_material_metadata_value"
-    assert metadata.build[-1].configuration["value"] == "config_value"
-    assert metadata.build[-1].build_parameters["param"] == "param_value"
-
-    # Check the final serialized dict
-    final_dict = metadata.model_dump()
-    expected_dict = {
-        "existing_key": "previous_material_metadata_value",
-        "build": [{"configuration": {"value": "config_value"}, "build_parameters": {"param": "param_value"}}],
-    }
-    assert final_dict == expected_dict

package/tests/py/unit/test_tools_build_monolayer.py

@@ -1,33 +0,0 @@
-import sys
-
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.pristine_structures.three_dimensional.ideal_crystal.helpers import create_monolayer
-
-from .fixtures.bulk import BULK_GRAPHITE, BULK_Si_PRIMITIVE
-from .fixtures.monolayer import GRAPHENE, SILICENE
-from .utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "material_config, vacuum, expected_material_config, skip_on_gh",
-    [
-        (BULK_Si_PRIMITIVE, 10.0, SILICENE, True),
-        (BULK_GRAPHITE, 12.197, GRAPHENE, False),
-    ],
-)
-def test_create_monolayer(material_config, vacuum, expected_material_config, skip_on_gh):
-    if sys.platform != "darwin" and skip_on_gh:
-        pytest.skip("Skipping test on non-Darwin platform due to different slab generation.")
-    crystal = Material.create(material_config)
-    monolayer = create_monolayer(crystal, vacuum=vacuum)
-
-    assert isinstance(monolayer, Material)
-    assert "Monolayer" in monolayer.name
-
-    # reset the name and lattice.type to ignore them in the comparison
-    monolayer.name = expected_material_config["name"]
-    monolayer.lattice.type = expected_material_config["lattice"]["type"]
-    monolayer.metadata.build = []
-
-    assert_two_entities_deep_almost_equal(monolayer, expected_material_config, atol=1e-6)

package/tests/py/unit/test_tools_build_nanoparticle.py

@@ -1,42 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.pristine_structures.zero_dimensional.nanoparticle import (
-    NanoparticleShapesEnum,
-    create_nanoparticle_by_shape,
-    create_nanoparticle_from_material,
-)
-from mat3ra.made.tools.entities.coordinate import SphereCoordinateCondition
-from unit.fixtures.bulk import BULK_Si_PRIMITIVE
-from unit.fixtures.nanoparticle import SI_NANOPARTICLE_SPHERE
-from unit.utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "material_config, condition, expected_material_config",
-    [
-        (
-            BULK_Si_PRIMITIVE,
-            SphereCoordinateCondition(radius=6.0),
-            SI_NANOPARTICLE_SPHERE,
-        ),
-    ],
-)
-def test_create_nanoparticle_by_condition(material_config, condition, expected_material_config):
-    material = Material.create(material_config)
-    nanoparticle = create_nanoparticle_from_material(
-        material, condition=condition, center_around_atom=True, use_cartesian_coordinates=True
-    )
-
-    assert_two_entities_deep_almost_equal(nanoparticle, expected_material_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, shape, parameters",
-    [
-        (BULK_Si_PRIMITIVE, NanoparticleShapesEnum.ICOSAHEDRON, {"noshells": 3}),
-    ],
-)
-def test_create_nanoparticle_by_shape(material_config, shape, parameters):
-    material = Material.create(material_config)
-    nanoparticle = create_nanoparticle_by_shape(material, shape, parameters)
-    assert isinstance(nanoparticle, Material)

package/tests/py/unit/test_tools_build_nanoribbon.py

@@ -1,45 +0,0 @@
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.nanoribbon import create_nanoribbon
-from mat3ra.made.tools.build_components.entities.reusable.one_dimensional.crystal_lattice_lines import (
-    CrystalLatticeLinesBuilder,
-    CrystalLatticeLinesConfiguration,
-)
-
-from .fixtures.monolayer import GRAPHENE
-from .fixtures.nanoribbon.armchair import GRAPHENE_NANORIBBON_ARMCHAIR
-from .fixtures.nanoribbon.zigzag import GRAPHENE_NANORIBBON_ZIGZAG
-from .utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "material_config, width, length, vacuum_width, vacuum_length, miller_indices_2d, edge_type, expected_nanoribbon",
-    [
-        (GRAPHENE, 5, 4, 5.0, 5.0, (1, 1), "armchair", GRAPHENE_NANORIBBON_ARMCHAIR),
-        (GRAPHENE, 2, 4, 5.0, 5.0, (0, 1), "zigzag", GRAPHENE_NANORIBBON_ZIGZAG),
-    ],
-)
-def test_build_nanoribbon(
-    material_config, width, length, vacuum_width, vacuum_length, miller_indices_2d, edge_type, expected_nanoribbon
-):
-    material = Material.create(material_config)
-
-    nanoribbon = create_nanoribbon(
-        material=material,
-        miller_indices_2d=miller_indices_2d,
-        width=width,
-        length=length,
-        vacuum_width=vacuum_width,
-        vacuum_length=vacuum_length,
-    )
-
-    assert_two_entities_deep_almost_equal(nanoribbon, expected_nanoribbon)
-
-
-def test_crystal_lattice_lines():
-    builder = CrystalLatticeLinesBuilder()
-    config = CrystalLatticeLinesConfiguration(crystal=Material.create(GRAPHENE), miller_indices_2d=(1, 0))
-
-    material = builder.get_material(config)
-    material.name = f"{material.name} {config.miller_indices_2d}"
-    assert isinstance(material, Material)

package/tests/py/unit/test_tools_build_passivation.py

@@ -1,85 +0,0 @@
-import pytest
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.processed_structures.two_dimensional.passivation.helpers import (
-    get_coordination_numbers_distribution,
-    get_unique_coordination_numbers,
-    passivate_dangling_bonds,
-    passivate_surface,
-)
-
-from .fixtures.nanoribbon.nanoribbon import GRAPHENE_ZIGZAG_NANORIBBON
-from .fixtures.passivated.nanoribbon import GRAPHENE_ZIGZAG_NANORIBBON_PASSIVATED
-from .fixtures.passivated.slab import PASSIVATED_SI_CONVENTIONAL_SLAB_001
-from .fixtures.slab import SI_CONVENTIONAL_SLAB_001
-from .utils import assert_two_entities_deep_almost_equal
-
-
-@pytest.mark.parametrize(
-    "slab_config, passivant, bond_length, surface, passivation_parameters, expected_material_config",
-    [
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            "H",
-            1.48,
-            "both",
-            {"shadowing_radius": 2.5, "depth": 2.0},
-            PASSIVATED_SI_CONVENTIONAL_SLAB_001,
-        ),
-    ],
-)
-def test_passivate_surface(
-    slab_config, passivant, bond_length, surface, passivation_parameters, expected_material_config
-):
-    slab = MaterialWithBuildMetadata.create(slab_config)
-    passivated_material = passivate_surface(slab, passivant, bond_length, **passivation_parameters)
-    assert_two_entities_deep_almost_equal(passivated_material, expected_material_config)
-
-
-#
-@pytest.mark.parametrize(
-    "slab_config, passivant, bond_length, surface, cutoff, expected_numbers",
-    [(GRAPHENE_ZIGZAG_NANORIBBON, "H", 1.48, "both", 3.0, [2, 3])],
-)
-def test_get_unique_coordination_numbers(slab_config, passivant, bond_length, surface, cutoff, expected_numbers):
-    """Test getting unique coordination numbers for passivation analysis"""
-    material = MaterialWithBuildMetadata.create(slab_config)
-    unique_coordination_numbers = get_unique_coordination_numbers(material=material, cutoff=cutoff)
-    assert unique_coordination_numbers == expected_numbers
-
-
-@pytest.mark.parametrize(
-    "slab_config, passivant, bond_length, surface, cutoff, expected_distribution",
-    [(GRAPHENE_ZIGZAG_NANORIBBON, "H", 1.48, "both", 3.0, {2: 8, 3: 8})],
-)
-def test_get_coordination_numbers_distribution(
-    slab_config, passivant, bond_length, surface, cutoff, expected_distribution
-):
-    """Test getting coordination numbers distribution for passivation analysis"""
-    material = MaterialWithBuildMetadata.create(slab_config)
-    distribution = get_coordination_numbers_distribution(material=material, cutoff=cutoff)
-    # Should return a dictionary with coordination numbers as keys and counts as values
-    assert distribution == expected_distribution
-
-
-@pytest.mark.parametrize(
-    "slab_config, passivant, bond_length, builder_params_dict, expected_material_config",
-    [
-        (
-            GRAPHENE_ZIGZAG_NANORIBBON,
-            "H",
-            1.48,
-            {"shadowing_radius": 2.5, "coordination_threshold": 2, "number_of_bonds_to_passivate": 1},
-            GRAPHENE_ZIGZAG_NANORIBBON_PASSIVATED,
-        ),
-    ],
-)
-def test_passivate_coordination_based(
-    slab_config, passivant, bond_length, builder_params_dict, expected_material_config
-):
-    passivated_material = passivate_dangling_bonds(
-        MaterialWithBuildMetadata.create(slab_config),
-        passivant=passivant,
-        bond_length=bond_length,
-        **builder_params_dict,
-    )
-    assert_two_entities_deep_almost_equal(passivated_material, expected_material_config)