@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/tests/py/unit/test_symmetry_points.py

@@ -1,151 +0,0 @@
-"""Tests for Brillouin zone symmetry points."""
-
-import pytest
-from mat3ra.made.lattice import Lattice
-from mat3ra.made.reciprocal.symmetry_points import get_symmetry_points
-from mat3ra.utils import assertion as assertion_utils
-
-
-def test_symmetry_points_gamma_always_first():
-    """Gamma point should always be the first symmetry point."""
-    lattice = Lattice(a=1.0, b=1.0, c=1.0, type="CUB")
-    points = get_symmetry_points(lattice)
-    assert points[0]["point"] == "Γ"
-    assert points[0]["coordinates"] == [0.0, 0.0, 0.0]
-
-
-def test_symmetry_points_cub():
-    lattice = Lattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert labels == ["Γ", "R", "X", "M"]
-    # Verify specific coordinates
-    r_point = next(p for p in points if p["point"] == "R")
-    assertion_utils.assert_deep_almost_equal(r_point["coordinates"], [0.5, 0.5, 0.5])
-    x_point = next(p for p in points if p["point"] == "X")
-    assertion_utils.assert_deep_almost_equal(x_point["coordinates"], [0.0, 0.5, 0.0])
-    m_point = next(p for p in points if p["point"] == "M")
-    assertion_utils.assert_deep_almost_equal(m_point["coordinates"], [0.5, 0.5, 0.0])
-
-
-def test_symmetry_points_fcc():
-    lattice = Lattice(a=5.43, b=5.43, c=5.43, type="FCC")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert "K" in labels
-    assert "L" in labels
-    assert "U" in labels
-    assert "W" in labels
-    assert "X" in labels
-    k_point = next(p for p in points if p["point"] == "K")
-    assertion_utils.assert_deep_almost_equal(k_point["coordinates"], [3 / 8, 3 / 8, 3 / 4])
-
-
-def test_symmetry_points_bcc():
-    lattice = Lattice(a=3.0, b=3.0, c=3.0, type="BCC")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert labels == ["Γ", "H", "P", "N"]
-    h_point = next(p for p in points if p["point"] == "H")
-    assertion_utils.assert_deep_almost_equal(h_point["coordinates"], [0.5, -0.5, 0.5])
-
-
-def test_symmetry_points_hex():
-    lattice = Lattice(a=2.46, b=2.46, c=6.71, type="HEX")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert set(labels) == {"Γ", "A", "H", "K", "L", "M"}
-    k_point = next(p for p in points if p["point"] == "K")
-    assertion_utils.assert_deep_almost_equal(k_point["coordinates"], [1 / 3, 1 / 3, 0.0])
-
-
-def test_symmetry_points_bct1():
-    """BCT with c < a should give BCT-1 points."""
-    lattice = Lattice(a=4.0, b=4.0, c=2.0, type="BCT")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert "Z" in labels
-    assert "Z1" in labels
-    # BCT-1: n = (1 + c²/a²) / 4 = (1 + 4/16) / 4 = 1.25/4 = 0.3125
-    z_point = next(p for p in points if p["point"] == "Z")
-    n = (1 + 4.0 / 16.0) / 4
-    assertion_utils.assert_deep_almost_equal(z_point["coordinates"], [n, n, -n])
-
-
-def test_symmetry_points_bct2():
-    """BCT with c >= a should give BCT-2 points."""
-    lattice = Lattice(a=2.0, b=2.0, c=4.0, type="BCT")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert "∑" in labels
-    assert "Y" in labels
-    assert "Z" not in [p["point"] for p in points if p["point"] == "Z1"]
-
-
-def test_symmetry_points_tet():
-    lattice = Lattice(a=3.0, b=3.0, c=5.0, type="TET")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert set(labels) == {"Γ", "A", "M", "R", "X", "Z"}
-
-
-def test_symmetry_points_orc():
-    lattice = Lattice(a=2.0, b=3.0, c=4.0, type="ORC")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert set(labels) == {"Γ", "R", "S", "T", "U", "X", "Y", "Z"}
-
-
-def test_symmetry_points_rhl1():
-    """RHL with cos(alpha) > 0 should give RHL-1 points."""
-    lattice = Lattice(a=3.0, b=3.0, c=3.0, alpha=60.0, beta=60.0, gamma=60.0, type="RHL")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert "B" in labels
-    assert "B1" in labels
-    assert "F" in labels
-
-
-def test_symmetry_points_rhl2():
-    """RHL with cos(alpha) < 0 should give RHL-2 points."""
-    lattice = Lattice(a=3.0, b=3.0, c=3.0, alpha=120.0, beta=120.0, gamma=120.0, type="RHL")
-    points = get_symmetry_points(lattice)
-    labels = [p["point"] for p in points]
-    assert "Q" in labels
-    assert "Q1" in labels
-    # RHL-2 should NOT have B, B1 points
-    assert "B" not in labels
-
-
-def test_symmetry_points_tri_1a():
-    """TRI with alpha, beta > 90 and gamma >= 90."""
-    lattice = Lattice(a=1.0, b=2.0, c=3.0, alpha=95.0, beta=100.0, gamma=110.0, type="TRI")
-    points = get_symmetry_points(lattice)
-    # TRI-1a,2a: L at [1/2, 1/2, 0]
-    l_point = next(p for p in points if p["point"] == "L")
-    assertion_utils.assert_deep_almost_equal(l_point["coordinates"], [0.5, 0.5, 0.0])
-
-
-def test_symmetry_points_tri_1b():
-    """TRI without all angles > 90."""
-    lattice = Lattice(a=1.0, b=2.0, c=3.0, alpha=80.0, beta=85.0, gamma=75.0, type="TRI")
-    points = get_symmetry_points(lattice)
-    # TRI-1b,2b: L at [1/2, -1/2, 0]
-    l_point = next(p for p in points if p["point"] == "L")
-    assertion_utils.assert_deep_almost_equal(l_point["coordinates"], [0.5, -0.5, 0.0])
-
-
-@pytest.mark.parametrize(
-    "lattice_type",
-    ["CUB", "FCC", "BCC", "TET", "BCT", "ORC", "ORCF", "ORCI", "ORCC", "HEX", "RHL", "MCL", "MCLC", "TRI"],
-)
-def test_symmetry_points_all_lattice_types(lattice_type):
-    """Every supported lattice type should return at least the Gamma point."""
-    lattice = Lattice(a=3.0, b=4.0, c=5.0, alpha=80.0, beta=85.0, gamma=75.0, type=lattice_type)
-    points = get_symmetry_points(lattice)
-    assert len(points) >= 1
-    assert points[0]["point"] == "Γ"
-    # All coordinates should be lists of 3 floats
-    for p in points:
-        assert len(p["coordinates"]) == 3
-        assert all(isinstance(c, (int, float)) for c in p["coordinates"])

package/tests/py/unit/test_tools_analyze.py

@@ -1,219 +0,0 @@
-import numpy as np
-import pytest
-from mat3ra.made.material import Material, defaultMaterialConfig
-from mat3ra.made.tools.analyze.crystal_site.adatom_crystal_site_material_analyzer import (
-    AdatomCrystalSiteMaterialAnalyzer,
-)
-from mat3ra.made.tools.analyze.crystal_site.adatom_material_analyzer import AdatomMaterialAnalyzer
-from mat3ra.made.tools.analyze.crystal_site.crystal_site_analyzer import CrystalSiteAnalyzer
-from mat3ra.made.tools.analyze.crystal_site.voronoi_crystal_site_analyzer import VoronoiCrystalSiteAnalyzer
-from mat3ra.made.tools.analyze.other import (
-    SurfaceTypesEnum,
-    get_average_interlayer_distance,
-    get_surface_area,
-    get_surface_atom_indices,
-)
-from mat3ra.made.tools.analyze.rdf import RadialDistributionFunction
-from mat3ra.made.tools.analyze.utils import calculate_von_mises_strain
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.defective_structures.zero_dimensional.point_defect.atom_placement_method_enum import (
-    AtomPlacementMethodEnum,
-)
-from mat3ra.made.tools.build_components.operations.core.combinations.enums import AdatomPlacementMethodEnum
-from unit.fixtures.nanoribbon.nanoribbon import GRAPHENE_ZIGZAG_NANORIBBON
-from unit.utils import OSPlatform, get_platform_specific_value
-
-from .fixtures.bulk import BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVE
-from .fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
-from .fixtures.slab import SI_CONVENTIONAL_SLAB_001
-
-COMPARISON_PRECISION = 1e-4
-
-
-@pytest.mark.parametrize(
-    "material_config, layer_indices, expected_distance",
-    [
-        (GRAPHENE_NICKEL_INTERFACE, [0, 1], 3.0),
-    ],
-)
-def test_calculate_average_interlayer_distance(material_config, layer_indices, expected_distance):
-    material = Material.create(material_config)
-    distance = get_average_interlayer_distance(material, *layer_indices)
-    assert np.isclose(distance, expected_distance)
-
-
-@pytest.mark.parametrize(
-    "material_config, expected_area",
-    [
-        (defaultMaterialConfig, 12.950),
-    ],
-)
-def test_calculate_surface_area(material_config, expected_area):
-    material = Material.create(material_config)
-    area = get_surface_area(material)
-    assert np.isclose(area, expected_area, atol=1e-3)
-
-
-@pytest.mark.parametrize(
-    "material_config, rdf_params, expected_first_peak_distance",
-    [
-        (GRAPHENE_ZIGZAG_NANORIBBON, {"cutoff": 10.0, "bin_size": 0.1}, 1.42),
-        (BULK_Si_CONVENTIONAL, {"cutoff": 10.0, "bin_size": 0.1}, 2.35),
-    ],
-)
-def test_radial_distribution_function(material_config, rdf_params, expected_first_peak_distance):
-    material = Material.create(material_config)
-
-    rdf = RadialDistributionFunction.from_material(material, **rdf_params)
-
-    # Test that RDF is non-negative
-    assert np.all(rdf.rdf >= 0), "RDF contains negative values."
-
-    # Test the first peak properties
-    assert rdf.first_peak_index > 0, "First peak index should be greater than 0."
-    assert rdf.first_peak_value > 0, "First peak value should be greater than 0."
-    assert rdf.first_peak_width > 0, "First peak width should be greater than 0."
-    assert rdf.first_peak_distance > 0, "First peak distance should be greater than 0."
-
-    # Test that `is_within_first_peak` works as expected
-    assert rdf.is_within_first_peak(rdf.first_peak_distance), "First peak distance should be within the first peak."
-    assert not rdf.is_within_first_peak(0), "Zero distance should not be within the first peak."
-    assert not rdf.is_within_first_peak(rdf_params["cutoff"]), "Cutoff distance should not be within the first peak."
-
-    # Test that RDF drops to zero near the cutoff
-    assert np.isclose(rdf.rdf[-1], 0, atol=1e-2), "RDF should approach zero near the cutoff."
-
-    # Specific material related tests
-    assert np.isclose(rdf.first_peak_distance, expected_first_peak_distance, atol=0.1)
-
-
-VORONOI_SITE_EXPECTED = {OSPlatform.DARWIN: [0.625, 0.625, 0.125], OSPlatform.OTHER: [0.5, 0.5, 0.5]}
-
-
-@pytest.mark.parametrize(
-    "placement_method, coordinate, expected_coordinate",
-    [
-        (AtomPlacementMethodEnum.EXACT_COORDINATE, [0.25, 0.25, 0.5], [0.25, 0.25, 0.5]),
-        (AtomPlacementMethodEnum.CLOSEST_SITE, [0.25, 0.25, 0.5], [0.25, 0.25, 0.25]),
-        (AtomPlacementMethodEnum.EQUIDISTANT, [0.5432, 0.5123, 0.5], [0.58333, 0.58333, 0.25]),
-        (AtomPlacementMethodEnum.VORONOI_SITE, [0.25, 0.25, 0.5], VORONOI_SITE_EXPECTED),
-    ],
-)
-def test_crystal_site_analyzer(placement_method, coordinate, expected_coordinate):
-    crystal = Material.create(BULK_Si_PRIMITIVE)
-
-    if placement_method == AtomPlacementMethodEnum.VORONOI_SITE:
-        analyzer = VoronoiCrystalSiteAnalyzer(material=crystal, coordinate=coordinate)
-        final_coordinate = analyzer.voronoi_site_coordinate
-        expected_coordinate = get_platform_specific_value(expected_coordinate)
-    else:
-        analyzer = CrystalSiteAnalyzer(material=crystal, coordinate=coordinate)
-        if placement_method == AtomPlacementMethodEnum.EXACT_COORDINATE:
-            final_coordinate = analyzer.exact_coordinate
-        elif placement_method == AtomPlacementMethodEnum.CLOSEST_SITE:
-            final_coordinate = analyzer.closest_site_coordinate
-        elif placement_method == AtomPlacementMethodEnum.EQUIDISTANT:
-            final_coordinate = analyzer.get_equidistant_coordinate()
-        else:
-            raise ValueError(f"Unknown method: {placement_method}")
-
-    if placement_method == AtomPlacementMethodEnum.VORONOI_SITE:
-        allowed_coords = [[0.625, 0.625, 0.125], [0.625, 0.625, 0.625], [0.5, 0.5, 0.5]]
-        assert any(
-            np.allclose(final_coordinate, allowed, atol=COMPARISON_PRECISION) for allowed in allowed_coords
-        ), f"Voronoi coordinate {final_coordinate} not in allowed list"
-    else:
-        assert np.allclose(final_coordinate, expected_coordinate, atol=COMPARISON_PRECISION)
-
-
-@pytest.mark.parametrize(
-    "material_config, coordinate, placement_method, distance_z, element, expected_coordinate",
-    [
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            [0.25, 0.25],
-            AdatomPlacementMethodEnum.EXACT_COORDINATE,
-            1.0,
-            "Si",
-            [0.25, 0.25, 0.1828],
-        ),
-    ],
-)
-def test_adatom_material_analyzer(
-    material_config, coordinate, placement_method, distance_z, element, expected_coordinate
-):
-    crystal = MaterialWithBuildMetadata.create(material_config)
-
-    analyzer = AdatomMaterialAnalyzer(
-        material=crystal, coordinate_2d=coordinate, distance_z=distance_z, element=element
-    )
-    resolved_coord = analyzer.coordinate_in_added_component
-
-    assert np.allclose(resolved_coord, expected_coordinate, atol=COMPARISON_PRECISION)
-
-
-@pytest.mark.parametrize(
-    "material_config, coordinate, placement_method, distance_z, element,expected_coordinate",
-    [
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            [0.25, 0.25],
-            AdatomPlacementMethodEnum.NEW_CRYSTAL_SITE,
-            1.0,
-            "Si",
-            [0.25, 0.25, 0.5],
-        ),
-    ],
-)
-def test_adatom_crystal_site_material_analyzer(
-    material_config, coordinate, placement_method, distance_z, element, expected_coordinate
-):
-    crystal = MaterialWithBuildMetadata.create(material_config)
-
-    # Test NEW_CRYSTAL_SITE method
-    analyzer = AdatomCrystalSiteMaterialAnalyzer(
-        material=crystal,
-        coordinate_2d=coordinate,
-        distance_z=distance_z,
-        element=element,
-    )
-    resolved_coord = analyzer.coordinate_in_added_component
-
-    assert np.allclose(resolved_coord, expected_coordinate, atol=COMPARISON_PRECISION)
-
-
-@pytest.mark.parametrize(
-    "material_config, expected_indices_top, expected_indices_bottom",
-    [
-        (
-            SI_CONVENTIONAL_SLAB_001,
-            [8, 14],
-            [3, 4, 5],
-        ),
-    ],
-)
-def test_get_surface_atom_indices_top_and_bottom(material_config, expected_indices_top, expected_indices_bottom):
-    material = Material.create(material_config)
-    top_indices = get_surface_atom_indices(material, SurfaceTypesEnum.TOP)
-    bottom_indices = get_surface_atom_indices(material, SurfaceTypesEnum.BOTTOM)
-    assert set(top_indices) == set(expected_indices_top)
-    assert set(bottom_indices) == set(expected_indices_bottom)
-
-
-@pytest.mark.parametrize(
-    "strain_matrix, expected_strain",
-    [
-        # Identity matrix - no strain
-        ([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 0.0),
-        # Uniaxial compression (5% x only)
-        ([[0.95, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 4.875),
-        # Biaxial compression (5% x and y)
-        ([[0.95, 0.0, 0.0], [0.0, 0.95, 0.0], [0.0, 0.0, 1.0]], 4.875),
-        # Shear strain
-        ([[1.0, 0.1, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 8.675),
-    ],
-)
-def test_calculate_von_mises_strain(strain_matrix, expected_strain):
-    """Test von Mises strain calculation used in ZSL interface analysis."""
-    strain_percentage = calculate_von_mises_strain(np.array(strain_matrix))
-    assert np.isclose(strain_percentage, expected_strain, atol=0.01)

package/tests/py/unit/test_tools_analyze_basis.py

@@ -1,105 +0,0 @@
-import pytest
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.basis import BasisMaterialAnalyzer
-from mat3ra.made.tools.analyze.fingerprint import LayeredFingerprintAlongAxis
-from mat3ra.made.tools.operations.core.unary import supercell
-
-from .fixtures.bulk import BULK_Si_CONVENTIONAL
-from .fixtures.slab import SI_CONVENTIONAL_SLAB_001, SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO
-
-
-@pytest.mark.parametrize(
-    "material_config",
-    [SLAB_SrTiO3_011_TERMINATION_O2, SLAB_SrTiO3_011_TERMINATION_SrTiO, SI_CONVENTIONAL_SLAB_001],
-)
-def test_basis_analyzer_fingerprint(material_config):
-    material = Material.create(material_config)
-    analyzer = BasisMaterialAnalyzer(material=material)
-
-    fingerprint = analyzer.get_layer_fingerprint(layer_thickness=1.0)
-    assert isinstance(fingerprint, LayeredFingerprintAlongAxis)
-    assert len(fingerprint.layers) > 0
-    assert fingerprint.axis == AxisEnum.z
-    assert fingerprint.layer_thickness == 1.0
-
-    for layer in fingerprint.layers:
-        assert hasattr(layer, "min_coord")
-        assert hasattr(layer, "max_coord")
-        assert hasattr(layer, "elements")
-        assert isinstance(layer.min_coord, float)
-        assert isinstance(layer.max_coord, float)
-        assert layer.max_coord > layer.min_coord
-        assert isinstance(layer.elements, list)
-        assert all(isinstance(elem, str) for elem in layer.elements)
-
-    non_empty_layers = fingerprint.non_empty_layers
-    assert isinstance(non_empty_layers, list)
-    assert all(isinstance(layer, type(fingerprint.layers[0])) for layer in non_empty_layers)
-
-    element_sequence = fingerprint.element_sequence
-    assert isinstance(element_sequence, list)
-    assert all(isinstance(elements, list) for elements in element_sequence)
-
-
-@pytest.mark.parametrize(
-    "material_config, layer_thickness",
-    [
-        (BULK_Si_CONVENTIONAL, 1.0),
-        (SI_CONVENTIONAL_SLAB_001, 1.0),
-        (SLAB_SrTiO3_011_TERMINATION_O2, 0.5),
-    ],
-)
-def test_get_layer_fingerprint(material_config, layer_thickness):
-    material = Material.create(material_config)
-    analyzer = BasisMaterialAnalyzer(material=material)
-
-    fingerprint = analyzer.get_layer_fingerprint(layer_thickness=layer_thickness)
-    assert isinstance(fingerprint, LayeredFingerprintAlongAxis)
-    assert len(fingerprint.layers) > 0
-    assert fingerprint.axis == AxisEnum.z
-    assert fingerprint.layer_thickness == layer_thickness
-
-    for axis in [AxisEnum.x, AxisEnum.y, AxisEnum.z]:
-        fingerprint = analyzer.get_layer_fingerprint(layer_thickness=layer_thickness, axis=axis)
-        assert isinstance(fingerprint, LayeredFingerprintAlongAxis)
-        assert fingerprint.axis == axis
-        assert fingerprint.layer_thickness == layer_thickness
-        assert len(fingerprint.layers) > 0
-
-
-@pytest.mark.parametrize(
-    "material_config, supercell_matrix, repetition_axis",
-    [
-        (SLAB_SrTiO3_011_TERMINATION_O2, [[2, 0, 0], [0, 2, 0], [0, 0, 1]], AxisEnum.y),
-        (SLAB_SrTiO3_011_TERMINATION_SrTiO, [[2, 0, 0], [0, 2, 0], [0, 0, 1]], AxisEnum.y),
-        (SI_CONVENTIONAL_SLAB_001, [[2, 0, 0], [0, 2, 0], [0, 0, 1]], AxisEnum.x),
-    ],
-)
-def test_fingerprint_similarity_scores(material_config, supercell_matrix, repetition_axis):
-    slab = Material.create(material_config)
-    supercell_material = supercell(slab, supercell_matrix)
-
-    analyzer_slab = BasisMaterialAnalyzer(material=slab)
-    analyzer_supercell = BasisMaterialAnalyzer(material=supercell_material)
-
-    layer_thickness = 1.0
-
-    fingerprint_slab = analyzer_slab.get_layer_fingerprint(layer_thickness=layer_thickness, axis=repetition_axis)
-    fingerprint_supercell = analyzer_supercell.get_layer_fingerprint(
-        layer_thickness=layer_thickness, axis=repetition_axis
-    )
-
-    assert fingerprint_slab.get_similarity_score(fingerprint_supercell) == 0.0
-
-    score_periodic = fingerprint_slab.get_similarity_score_ignore_periodicity(fingerprint_supercell)
-    assert score_periodic > 0.0
-    assert len(fingerprint_supercell.layers) % len(fingerprint_slab.layers) == 0
-
-    assert fingerprint_supercell.get_similarity_score_ignore_periodicity(fingerprint_slab) > 0.0
-
-    fingerprint_slab_z = analyzer_slab.get_layer_fingerprint(layer_thickness=layer_thickness, axis=AxisEnum.z)
-    fingerprint_supercell_z = analyzer_supercell.get_layer_fingerprint(layer_thickness=layer_thickness, axis=AxisEnum.z)
-
-    assert len(fingerprint_slab_z.layers) == len(fingerprint_supercell_z.layers)
-    assert fingerprint_slab_z.get_similarity_score(fingerprint_supercell_z) == 1.0