@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/analyze/build_metadata_analyzer_factory.py

@@ -1,31 +0,0 @@
-from typing import Dict, Type
-
-from ..build_components.metadata import MaterialWithBuildMetadata
-from .build_metadata_analyzer import BuildMetadataAnalyzer
-from .interface_material import (
-    InterfaceMaterialAnalyzer,
-)
-from .slab import SlabMaterialAnalyzer
-
-BUILD_METADATA_ANALYZER_REGISTRY: Dict[str, Type[BuildMetadataAnalyzer]] = {
-    "SlabConfiguration": SlabMaterialAnalyzer,
-    "InterfaceConfiguration": InterfaceMaterialAnalyzer,
-}
-
-
-def create_build_metadata_analyzer(
-    material: MaterialWithBuildMetadata,
-    **analyzer_kwargs,
-) -> BuildMetadataAnalyzer:
-    build_metadata = material.metadata.get_latest_build_metadata()
-    configuration_type = build_metadata.configuration.get("type")
-    if not configuration_type:
-        raise ValueError("Latest build step has no configuration type.")
-    analyzer_cls = BUILD_METADATA_ANALYZER_REGISTRY.get(configuration_type)
-    if analyzer_cls is None:
-        registered_types = ", ".join(sorted(BUILD_METADATA_ANALYZER_REGISTRY))
-        raise ValueError(
-            f"No build metadata analyzer registered for '{configuration_type}'. "
-            f"Registered types: {registered_types}."
-        )
-    return analyzer_cls(material=material, **analyzer_kwargs)

package/src/py/mat3ra/made/tools/analyze/coordination.py

@@ -1,56 +0,0 @@
-from typing import List, Optional
-
-from mat3ra.made.material import Material
-
-from ..convert import to_pymatgen
-from ..third_party import PymatgenVoronoiNN
-
-
-def get_voronoi_nearest_neighbors_atom_indices(
-    material: Material,
-    coordinate: Optional[List[float]] = None,
-    tolerance: float = 0.1,
-    cutoff: float = 13.0,
-) -> Optional[List[int]]:
-    """
-    Returns the indices of direct neighboring atoms to a specified position in the material using Voronoi tessellation.
-
-    Args:
-        material (Material): The material object to find neighbors in.
-        coordinate (List[float]): The position to find neighbors for.
-        tolerance (float): tolerance parameter for near-neighbor finding. Faces that are smaller than tol fraction
-            of the largest face are not included in the tessellation. (default: 0.1).
-            as per: https://pymatgen.org/pymatgen.analysis.html#pymatgen.analysis.local_env.VoronoiNN
-        cutoff (float): The cutoff radius for identifying neighbors, in angstroms.
-
-    Returns:
-        List[int]: A list of indices of neighboring atoms, or an empty list if no neighbors are found.
-    """
-    if coordinate is None:
-        coordinate = [0, 0, 0]
-    structure = to_pymatgen(material)
-    voronoi_nn = PymatgenVoronoiNN(
-        tol=tolerance,
-        cutoff=cutoff,
-        weight="solid_angle",
-        extra_nn_info=False,
-        compute_adj_neighbors=True,
-    )
-    coordinates = material.basis.coordinates
-    site_index = coordinates.get_element_id_by_value(coordinate)
-    remove_dummy_atom = False
-    if site_index is None:
-        structure.append("X", coordinate, validate_proximity=False)
-        site_index = len(structure.sites) - 1
-        remove_dummy_atom = True
-    try:
-        neighbors = voronoi_nn.get_nn_info(structure, site_index)
-    except ValueError:
-        return None
-    neighboring_atoms_pymatgen_ids = [n["site_index"] for n in neighbors]
-    if remove_dummy_atom:
-        structure.remove_sites([-1])
-
-    all_coordinates = material.basis.coordinates
-    all_coordinates.filter_by_indices(neighboring_atoms_pymatgen_ids)
-    return all_coordinates.ids

package/src/py/mat3ra/made/tools/analyze/crystal_site/adatom_crystal_site_material_analyzer.py

@@ -1,35 +0,0 @@
-from typing import List
-
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.builder import SlabBuilder
-
-from ...build_components.entities.reusable.two_dimensional.slab_stack.helpers import (
-    recreate_slab_with_fractional_layers,
-)
-from ...build_components.metadata import MaterialWithBuildMetadata
-from .adatom_material_analyzer import AdatomMaterialAnalyzer
-from .crystal_site_analyzer import CrystalSiteAnalyzer
-
-
-class AdatomCrystalSiteMaterialAnalyzer(AdatomMaterialAnalyzer):
-    DEFAULT_NUMBER_OF_LAYERS: float = 1
-
-    @property
-    def added_component_prototype(self) -> Material:
-        # Recreate the slab with a single layer to ensure the adatom is placed correctly
-        return recreate_slab_with_fractional_layers(self.material, self.DEFAULT_NUMBER_OF_LAYERS)
-
-    @property
-    def coordinate_in_added_component(self) -> List[float]:
-        approximate_coordinate_3d = super().coordinate_in_added_component
-        crystal_site_analyzer = CrystalSiteAnalyzer(
-            material=self.added_component_prototype,
-            coordinate=approximate_coordinate_3d,
-        )
-        return crystal_site_analyzer.closest_site_coordinate
-
-    @property
-    def slab_material_or_configuration_for_stacking(self) -> MaterialWithBuildMetadata:
-        config = self.slab_configuration_with_no_vacuum
-        params = self.build_parameters
-        return SlabBuilder(build_parameters=params).get_material(config)

package/src/py/mat3ra/made/tools/analyze/crystal_site/adatom_material_analyzer.py

@@ -1,49 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.materials_category_components.entities.core.zero_dimensional.atom import AtomSchema
-
-from ...build_components.entities.core.two_dimensional.vacuum.builder import VacuumBuilder
-from ...build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from ...build_components.entities.core.zero_dimensional.atom.builder import AtomAtCoordinateBuilder
-from ...build_components.entities.core.zero_dimensional.atom.configuration import AtomAtCoordinateConfiguration
-from ...build_components.metadata import MaterialWithBuildMetadata
-from ..slab import SlabMaterialAnalyzer
-
-
-class AdatomMaterialAnalyzer(SlabMaterialAnalyzer):
-    distance_z: float
-    coordinate_2d: List[float]  # Add coordinate property
-    element: str
-
-    @property
-    def added_component_height(self) -> float:
-        return self.layer_thickness
-
-    @property
-    def added_component_prototype(self) -> MaterialWithBuildMetadata:
-        vacuum_configuration = VacuumConfiguration(crystal=self.material, size=self.added_component_height)
-        vacuum_material = VacuumBuilder().get_material(vacuum_configuration)
-        return vacuum_material
-
-    @property
-    def coordinate_in_added_component(self) -> List[float]:
-        coordinate_3d = self.coordinate_2d + [0]
-        coordinate_3d_cartesian = self.material.basis.cell.convert_point_to_cartesian(coordinate_3d)
-        coordinate_3d_cartesian[2] = self.distance_z
-        coordinate_3d_crystal = self.added_component_prototype.basis.cell.convert_point_to_crystal(
-            coordinate_3d_cartesian
-        )
-        return coordinate_3d_crystal
-
-    @property
-    def added_component(self) -> MaterialWithBuildMetadata:
-        atom_configuration = AtomAtCoordinateConfiguration(
-            crystal=self.added_component_prototype,
-            element=AtomSchema(chemical_element=self.element),
-            coordinate=self.coordinate_in_added_component,
-        )
-        return AtomAtCoordinateBuilder().get_material(atom_configuration)
-
-    @property
-    def slab_material_or_configuration_for_stacking(self) -> MaterialWithBuildMetadata:
-        return self._slab_with_no_gap

package/src/py/mat3ra/made/tools/analyze/crystal_site/crystal_site_analyzer.py

@@ -1,65 +0,0 @@
-from typing import List
-
-from ....utils import get_center_of_coordinates
-from ...build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-from ...modify import filter_by_condition_on_coordinates
-from ...utils import transform_coordinate_to_supercell
-from .. import BaseMaterialAnalyzer
-from ..coordination import get_voronoi_nearest_neighbors_atom_indices
-from ..other import get_closest_site_id_from_coordinate
-
-
-class CrystalSiteAnalyzer(BaseMaterialAnalyzer):
-    coordinate: List[float] = [0.0, 0.0, 0.0]
-
-    @property
-    def exact_coordinate(self) -> List[float]:
-        return self.coordinate
-
-    @property
-    def closest_site_coordinate(self) -> List[float]:
-        site_id = get_closest_site_id_from_coordinate(self.material, self.coordinate)
-        return self.material.coordinates_array[site_id]
-
-    def get_equidistant_coordinate(self, coordinate=None) -> List[float]:
-        """
-        Compute a coordinate that is equidistant from the nearest atoms to the target coordinate. Useful for adatom.
-
-        This method works by:
-        1. Creating a 3x3x1 supercell of the original material to include atoms in PBC.
-        2. Transforming the target coordinate into the supercell's coordinate system.
-        3. Using Voronoi tessellation to find the indices of the nearest atoms in the supercell.
-        4. Taking the geometric center (average) of these neighboring atoms' coordinates as the equidistant point.
-        5. Setting the z-coordinate to the original value (useful for 2D/slab systems).
-        6. Transforming the equidistant coordinate back to the original cell's coordinate system.
-
-        The [3, 3, 1] supercell ensures robust neighbor search in x and y, but not in z (for 2D/slab systems).
-        """
-        if coordinate is None:
-            coordinate = self.coordinate
-        scaling_factor = [3, 3, 1]
-        translation_vector = [1 / 3, 1 / 3, 0]
-        supercell_material = create_supercell(self.material, scaling_factor=scaling_factor)
-
-        coordinate_in_supercell = transform_coordinate_to_supercell(
-            coordinate=coordinate, scaling_factor=scaling_factor, translation_vector=translation_vector
-        )
-
-        neighboring_atoms_ids_in_supercell = get_voronoi_nearest_neighbors_atom_indices(
-            material=supercell_material, coordinate=coordinate_in_supercell
-        )
-
-        if neighboring_atoms_ids_in_supercell is None:
-            raise ValueError("No neighboring atoms found for equidistant calculation.")
-
-        # Filter out atoms that are too close to the z boundaries of the supercell
-        supercell_material = filter_by_condition_on_coordinates(supercell_material, lambda c: 1e-2 < c[2] < 1 - 1e-2)
-        isolated_neighboring_atoms_basis = supercell_material.basis.model_copy()
-        isolated_neighboring_atoms_basis.coordinates.filter_by_ids(neighboring_atoms_ids_in_supercell)
-        equidistant_coordinate_in_supercell = get_center_of_coordinates(
-            isolated_neighboring_atoms_basis.coordinates.values
-        )
-
-        return transform_coordinate_to_supercell(
-            equidistant_coordinate_in_supercell, scaling_factor, translation_vector, reverse=True
-        )

package/src/py/mat3ra/made/tools/analyze/crystal_site/voronoi_crystal_site_analyzer.py

@@ -1,47 +0,0 @@
-from typing import List
-
-from ...convert import to_pymatgen
-from ...third_party import PymatgenVoronoiInterstitialGenerator
-from ...utils import get_distance_between_coordinates
-from .crystal_site_analyzer import CrystalSiteAnalyzer
-
-
-class VoronoiCrystalSiteAnalyzer(CrystalSiteAnalyzer):
-    """
-    Attributes:
-       clustering_tol: Tolerance for clustering the Voronoi nodes.
-       min_dist: Minimum distance between an interstitial and the nearest atom.
-       ltol: Tolerance for lattice matching.
-       stol: Tolerance for structure matching.
-       angle_tol: Angle tolerance for structure matching.
-    """
-
-    clustering_tol: float = 0.5
-    min_dist: float = 0.9
-    ltol: float = 0.2
-    stol: float = 0.3
-    angle_tol: float = 5
-
-    @property
-    def voronoi_site_coordinate(self) -> List[float]:
-        pymatgen_structure = to_pymatgen(self.material)
-
-        voronoi_gen = PymatgenVoronoiInterstitialGenerator(
-            clustering_tol=self.clustering_tol,
-            min_dist=self.min_dist,
-            ltol=self.ltol,
-            stol=self.stol,
-            angle_tol=self.angle_tol,
-        )
-
-        interstitials = list(voronoi_gen.generate(structure=pymatgen_structure, insert_species=["Si"]))
-
-        if not interstitials:
-            raise ValueError("No Voronoi interstitial sites found.")
-
-        closest_interstitial = min(
-            interstitials,
-            key=lambda interstitial: get_distance_between_coordinates(interstitial.site.frac_coords, self.coordinate),
-        )
-
-        return closest_interstitial.site.frac_coords.tolist()

package/src/py/mat3ra/made/tools/analyze/enums.py

@@ -1,33 +0,0 @@
-POSSIBLE_TRANSFORMATION_MATRICES = [
-    [[1, 0, 0], [0, 1, 0], [0, 0, 1]],  # Identity - no transformation
-    # Direct swaps: new[i] = old[j]
-    [[0, 1, 0], [1, 0, 0], [0, 0, 1]],
-    [[0, 0, 1], [0, 1, 0], [1, 0, 0]],
-    [[1, 0, 0], [0, 0, 1], [0, 1, 0]],
-    # Swaps with sign flips
-    [[0, 0, 1], [1, 0, 0], [0, -1, 0]],
-    [[0, 0, -1], [1, 0, 0], [0, 1, 0]],
-    [[0, 1, 0], [0, 0, 1], [-1, 0, 0]],
-    [[0, -1, 0], [0, 0, 1], [1, 0, 0]],
-    # Inverted swaps
-    [[0, -1, 0], [-1, 0, 0], [0, 0, 1]],
-    [[0, 0, -1], [0, 1, 0], [-1, 0, 0]],
-    [[1, 0, 0], [0, 0, -1], [0, -1, 0]],
-    # Rotations around x-axis: -90 and +90 degrees
-    [[1, 0, 0], [0, 0, 1], [0, -1, 0]],  # -90° around x
-    [[1, 0, 0], [0, 0, -1], [0, 1, 0]],  # +90° around x
-    # Rotations around y-axis: -90 and +90 degrees
-    [[0, 0, -1], [0, 1, 0], [1, 0, 0]],  # -90° around y
-    [[0, 0, 1], [0, 1, 0], [-1, 0, 0]],  # +90° around y
-    # Rotations around z-axis: -90 and +90 degrees
-    [[0, 1, 0], [-1, 0, 0], [0, 0, 1]],  # -90° around z
-    [[0, -1, 0], [1, 0, 0], [0, 0, 1]],  # +90° around z
-    # 180° rotations around axes
-    [[1, 0, 0], [0, -1, 0], [0, 0, -1]],  # 180° around x
-    [[-1, 0, 0], [0, 1, 0], [0, 0, -1]],  # 180° around y
-    [[-1, 0, 0], [0, -1, 0], [0, 0, 1]],  # 180° around z
-    # Mirrors (reflections)
-    [[1, 0, 0], [0, 1, 0], [0, 0, -1]],  # Mirror along z
-    [[1, 0, 0], [0, -1, 0], [0, 0, 1]],  # Mirror along y
-    [[-1, 0, 0], [0, 1, 0], [0, 0, 1]],  # Mirror along x
-]

package/src/py/mat3ra/made/tools/analyze/fingerprint/__init__.py

@@ -1,4 +0,0 @@
-from mat3ra.made.tools.analyze.fingerprint.layers.layered_fingerprint_along_axis import LayeredFingerprintAlongAxis
-from mat3ra.made.tools.analyze.fingerprint.layers.unique_element_string_per_layer import UniqueElementStringsPerLayer
-
-__all__ = ["UniqueElementStringsPerLayer", "LayeredFingerprintAlongAxis"]

package/src/py/mat3ra/made/tools/analyze/fingerprint/layers/layered_fingerprint_along_axis.py

@@ -1,83 +0,0 @@
-from itertools import cycle, islice
-from typing import List
-
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.made.tools.analyze.fingerprint.layers.unique_element_string_per_layer import UniqueElementStringsPerLayer
-from mat3ra.utils.array import jaccard_similarity_for_strings
-from pydantic import BaseModel, Field
-
-
-class LayeredFingerprintAlongAxis(BaseModel):
-    layers: List[UniqueElementStringsPerLayer] = Field(default_factory=list, description="List of layer fingerprints")
-    axis: AxisEnum = Field(default=AxisEnum.z, description="Axis along which the fingerprint is computed")
-    layer_thickness: float = Field(default=1.0, gt=0, description="Thickness of each layer in Angstroms")
-
-    @property
-    def non_empty_layers(self) -> List[UniqueElementStringsPerLayer]:
-        return [layer for layer in self.layers if layer.elements]
-
-    @property
-    def element_sequence(self) -> List[List[str]]:
-        return [layer.elements for layer in self.layers]
-
-    def get_similarity_score(self, other: "LayeredFingerprintAlongAxis") -> float:
-        """
-        Calculate Jaccard similarity score between this and another fingerprint.
-
-        The Jaccard similarity coefficient measures the similarity between two sets by comparing
-        the size of their intersection to the size of their union: J(A, B) = |A ∩ B| / |A ∪ B|.
-        In this implementation, we compare the sets of chemical elements in corresponding layers
-        between two fingerprints. For example, if layer 1 contains {Si, O} and the corresponding
-        layer contains {Si, Ge}, the Jaccard score is 1/3 (one common element divided by three
-        unique elements total). The final score is the average across all layers, providing a
-        measure of compositional similarity along the axis (0.0 = completely different,
-        1.0 = identical composition in all layers).
-
-        Args:
-            other: Another LayeredFingerprintAlongAxis to compare with
-
-        Returns:
-            float: Average Jaccard similarity score (0.0 to 1.0). Returns 0.0 if the number of layers doesn't match.
-        """
-        if not self.layers or not other.layers:
-            return 0.0
-        if len(self.layers) != len(other.layers):
-            return 0.0
-
-        seq1, seq2 = self.element_sequence, other.element_sequence
-        return sum(jaccard_similarity_for_strings(a, b) for a, b in zip(seq1, seq2)) / len(seq1)
-
-    def get_similarity_score_ignore_periodicity(self, other: "LayeredFingerprintAlongAxis") -> float:
-        """
-        Calculate Jaccard similarity score ignoring periodicity differences.
-
-        Handles cases where one fingerprint is a periodic repetition of another.
-        For example, if self has 6 layers and other has 2 layers, this method checks if
-        self.layers is a 3× repetition of other.layers (i.e., layers 0–1 match other,
-        layers 2–3 match other, etc.).
-
-        Args:
-            other: Another LayeredFingerprintAlongAxis to compare with
-
-        Returns:
-            float: Average Jaccard similarity score (0.0 to 1.0). Returns 0.0 if the number
-                   of layers is not a multiple relationship or if fingerprints don't match.
-        """
-        if not self.layers or not other.layers:
-            return 0.0
-
-        len_a, len_b = len(self.layers), len(other.layers)
-        if len_a == len_b:
-            return self.get_similarity_score(other)
-
-        # Identify shorter/longer and ensure multiplicity
-        if len_a < len_b:
-            short_seq, long_seq = self.element_sequence, other.element_sequence
-        else:
-            short_seq, long_seq = other.element_sequence, self.element_sequence
-
-        if len(long_seq) % len(short_seq) != 0:
-            return 0.0
-
-        cycled_short = islice(cycle(short_seq), len(long_seq))
-        return sum(jaccard_similarity_for_strings(a, b) for a, b in zip(cycled_short, long_seq)) / len(short_seq)

package/src/py/mat3ra/made/tools/analyze/fingerprint/layers/unique_element_string_per_layer.py

@@ -1,9 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel, Field
-
-
-class UniqueElementStringsPerLayer(BaseModel):
-    min_coord: float = Field(..., description="Minimum coordinate value for the layer")
-    max_coord: float = Field(..., description="Maximum coordinate value for the layer")
-    elements: List[str] = Field(default_factory=list, description="Sorted unique chemical elements in the layer")

package/src/py/mat3ra/made/tools/analyze/interface/__init__.py

@@ -1,20 +0,0 @@
-from .commensurate import CommensurateLatticeInterfaceAnalyzer, CommensurateLatticeMatchHolder
-from .grain_boundary import GrainBoundaryPlanarAnalyzer, GrainBoundaryPlanarMatchHolder
-from .simple import InterfaceAnalyzer
-from .twisted_nanoribbons import TwistedNanoribbonsInterfaceAnalyzer
-from .utils import calculate_interfacial_distance_from_rdf
-from .utils.holders import MatchedSubstrateFilmConfigurationHolder
-from .zsl import ZSLInterfaceAnalyzer, ZSLMatchHolder
-
-__all__ = [
-    "InterfaceAnalyzer",
-    "ZSLInterfaceAnalyzer",
-    "ZSLMatchHolder",
-    "CommensurateLatticeInterfaceAnalyzer",
-    "CommensurateLatticeMatchHolder",
-    "GrainBoundaryPlanarAnalyzer",
-    "GrainBoundaryPlanarMatchHolder",
-    "TwistedNanoribbonsInterfaceAnalyzer",
-    "MatchedSubstrateFilmConfigurationHolder",
-    "calculate_interfacial_distance_from_rdf",
-]

package/src/py/mat3ra/made/tools/analyze/interface/commensurate.py

@@ -1,156 +0,0 @@
-from functools import cached_property
-from typing import List, Optional
-
-import numpy as np
-from mat3ra.code.entity import InMemoryEntityPydantic
-from mat3ra.esse.models.materials_category_components.entities.auxiliary.two_dimensional.supercell_matrix_2d import (
-    SupercellMatrix2DSchema,
-)
-from mat3ra.made.lattice import Lattice
-from mat3ra.made.material import Material
-from pydantic import model_validator
-
-from ....utils import create_2d_supercell_matrices, get_angle_from_rotation_matrix_2d
-from .enums import angle_to_supercell_matrix_values_for_hex
-from .simple import InterfaceAnalyzer
-from .utils.holders import MatchedSubstrateFilmConfigurationHolder
-
-
-class CommensurateLatticeMatchHolder(InMemoryEntityPydantic):
-    match_id: int
-    angle: float
-    actual_angle: float
-    xy_supercell_matrix_film: List[List[int]]
-    xy_supercell_matrix_substrate: List[List[int]]
-
-
-class CommensurateLatticeInterfaceAnalyzer(InterfaceAnalyzer):
-    """
-    Interface analyzer using commensurate lattice matching for commensurate lattice interfaces.
-
-    For commensurate lattice bilayer materials where film and substrate are the same material,
-    this analyzer finds commensurate supercells at a target twist angle.
-
-    Attributes:
-        target_angle (float): The target twist angle, in degrees.
-        angle_tolerance (float): Tolerance for matching angles, in degrees.
-        max_supercell_matrix_int (Optional[int]): Maximum integer for supercell matrix elements.
-        limit_max_int (int): Limit for maximum integer to search for supercell matrices.
-        return_first_match (bool): If True, returns only the first match found (to speed up the process).
-
-    This class generates strained configurations for both substrate and film based on the commensurate matches found.
-
-    """
-
-    target_angle: float = 0.0
-    angle_tolerance: float = 0.1
-    max_supercell_matrix_int: Optional[int] = None
-    limit_max_int: int = 50
-    return_first_match: bool = True
-
-    @model_validator(mode="before")
-    def _handle_missing_substrate_or_film(cls, values):
-        substrate = values.get("substrate_slab_configuration")
-        film = values.get("film_slab_configuration")
-        if substrate and not film:
-            values["film_slab_configuration"] = substrate
-        elif film and not substrate:
-            values["substrate_slab_configuration"] = film
-        return values
-
-    @property
-    def material(self) -> Material:
-        return self.substrate_material
-
-    def _get_initial_guess_for_max_int(self, material: Material, target_angle: float) -> int:
-        if material.lattice.type == Lattice.__types__.HEX:
-            xy_supercell_matrix_for_closest_angle = min(
-                angle_to_supercell_matrix_values_for_hex, key=lambda x: abs(x["angle"] - target_angle)
-            )
-            return max(abs(x) for row in xy_supercell_matrix_for_closest_angle["xy_supercell"] for x in row)
-        return 1
-
-    def _generate_commensurate_lattices(
-        self,
-        material: Material,
-        target_angle: float,
-        max_supercell_matrix_element_int: int,
-    ) -> List[CommensurateLatticeMatchHolder]:
-        a = material.lattice.vector_arrays[0][:2]
-        b = material.lattice.vector_arrays[1][:2]
-
-        matrices = create_2d_supercell_matrices(max_supercell_matrix_element_int)
-        matrix_ab = np.array([a, b])
-        matrix_ab_inverse = np.linalg.inv(matrix_ab)
-
-        solutions: List[CommensurateLatticeMatchHolder] = []
-        match_id = 0
-
-        for index1, matrix1 in enumerate(matrices):
-            for index2, matrix2 in enumerate(matrices[0 : index1 + 1]):
-                matrix2_inverse = np.linalg.inv(matrix2)
-                intermediate_product = matrix2_inverse @ matrix1
-                product = matrix_ab_inverse @ intermediate_product @ matrix_ab
-                angle = get_angle_from_rotation_matrix_2d(product)
-
-                if angle is not None and np.abs(angle - target_angle) < self.angle_tolerance:
-                    solutions.append(
-                        CommensurateLatticeMatchHolder(
-                            match_id=match_id,
-                            angle=angle,
-                            actual_angle=angle,
-                            xy_supercell_matrix_substrate=matrix1.tolist(),
-                            xy_supercell_matrix_film=matrix2.tolist(),
-                        )
-                    )
-                    match_id += 1
-
-                    if self.return_first_match:
-                        return solutions
-
-        return solutions
-
-    @cached_property
-    def commensurate_lattice_match_holders(self) -> List[CommensurateLatticeMatchHolder]:
-        max_int = self.max_supercell_matrix_int or self._get_initial_guess_for_max_int(self.material, self.target_angle)
-
-        commensurate_lattice_matches: List[CommensurateLatticeMatchHolder] = []
-
-        while not commensurate_lattice_matches and max_int < self.limit_max_int:
-            commensurate_lattice_matches = self._generate_commensurate_lattices(
-                self.material, self.target_angle, max_int
-            )
-            max_int += 1
-
-        return commensurate_lattice_matches
-
-    def get_strained_configuration_by_match_id(self, match_id: int) -> MatchedSubstrateFilmConfigurationHolder:
-        match_holders = self.commensurate_lattice_match_holders
-        if match_id < 0 or match_id >= len(match_holders):
-            raise ValueError(f"Match ID {match_id} out of range. Available IDs: 0-{len(match_holders)-1}")
-
-        match_holder = match_holders[match_id]
-        return self._create_strained_configs_from_match(match_holder)
-
-    def _create_strained_configs_from_match(
-        self, match_holder: CommensurateLatticeMatchHolder
-    ) -> MatchedSubstrateFilmConfigurationHolder:
-        substrate_matrix_schema = SupercellMatrix2DSchema(root=match_holder.xy_supercell_matrix_substrate)
-        film_matrix_schema = SupercellMatrix2DSchema(root=match_holder.xy_supercell_matrix_film)
-
-        return self.create_matched_configuration_holder(
-            self.substrate_slab_configuration,
-            self.film_slab_configuration,
-            match_id=match_holder.match_id,
-            substrate_xy_supercell_matrix=substrate_matrix_schema,
-            film_xy_supercell_matrix=film_matrix_schema,
-        )
-
-    def get_strained_configurations(self) -> List[MatchedSubstrateFilmConfigurationHolder]:
-        strained_configs = []
-
-        for match_holder in self.commensurate_lattice_match_holders:
-            config_holder = self._create_strained_configs_from_match(match_holder)
-            strained_configs.append(config_holder)
-
-        return strained_configs

package/src/py/mat3ra/made/tools/analyze/interface/enums.py

@@ -1,60 +0,0 @@
-from enum import Enum
-from typing import List, TypedDict
-
-
-class SupercellTypes(str, Enum):
-    hexagonal = "hexagonal"
-    orthogonal = "orthogonal"
-
-
-class SupercellMatrix(TypedDict):
-    angle: float
-    xy_supercell: List[List[int]]
-
-
-# Tabulation from https://github.com/qtm-iisc/Twister/blob/474156a2a59f2b9d59350b32de56864a9496f848/examples/Homobilayer_hex/hex.table
-# Maps twist angle to supercell matrix values for homo-material hexagonal supercells bilayer
-angle_to_supercell_matrix_values_for_hex: List[SupercellMatrix] = [
-    {"angle": 60.0, "xy_supercell": [[0, 1], [-1, 1]]},
-    {"angle": 21.7867892983, "xy_supercell": [[1, 2], [-2, 3]]},
-    {"angle": 13.1735511073, "xy_supercell": [[2, 3], [-3, 5]]},
-    {"angle": 9.4300079079, "xy_supercell": [[3, 4], [-4, 7]]},
-    {"angle": 7.34099301663, "xy_supercell": [[4, 5], [-5, 9]]},
-    {"angle": 6.00898319777, "xy_supercell": [[5, 6], [-6, 11]]},
-    {"angle": 5.08584780812, "xy_supercell": [[6, 7], [-7, 13]]},
-    {"angle": 4.40845500794, "xy_supercell": [[7, 8], [-8, 15]]},
-    {"angle": 3.89023816901, "xy_supercell": [[8, 9], [-9, 17]]},
-    {"angle": 3.48100608947, "xy_supercell": [[9, 10], [-10, 19]]},
-    {"angle": 3.14965742639, "xy_supercell": [[10, 11], [-11, 21]]},
-    {"angle": 2.87589463363, "xy_supercell": [[11, 12], [-12, 23]]},
-    {"angle": 2.64590838119, "xy_supercell": [[12, 13], [-13, 25]]},
-    {"angle": 2.44997727662, "xy_supercell": [[13, 14], [-14, 27]]},
-    {"angle": 2.28105960973, "xy_supercell": [[14, 15], [-15, 29]]},
-    {"angle": 2.1339296666, "xy_supercell": [[15, 16], [-16, 31]]},
-    {"angle": 2.00462783069, "xy_supercell": [[16, 17], [-17, 33]]},
-    {"angle": 1.89009907347, "xy_supercell": [[17, 18], [-18, 35]]},
-    {"angle": 1.78794861038, "xy_supercell": [[18, 19], [-19, 37]]},
-    {"angle": 1.69627269352, "xy_supercell": [[19, 20], [-20, 39]]},
-    {"angle": 1.61353890116, "xy_supercell": [[20, 21], [-21, 41]]},
-    {"angle": 1.53849981837, "xy_supercell": [[21, 22], [-22, 43]]},
-    {"angle": 1.47012972578, "xy_supercell": [[22, 23], [-23, 45]]},
-    {"angle": 1.40757744635, "xy_supercell": [[23, 24], [-24, 47]]},
-    {"angle": 1.35013073557, "xy_supercell": [[24, 25], [-25, 49]]},
-    {"angle": 1.29718904759, "xy_supercell": [[25, 26], [-26, 51]]},
-    {"angle": 1.24824246553, "xy_supercell": [[26, 27], [-27, 53]]},
-    {"angle": 1.20285522748, "xy_supercell": [[27, 28], [-28, 55]]},
-    {"angle": 1.16065271985, "xy_supercell": [[28, 29], [-29, 57]]},
-    {"angle": 1.12131111538, "xy_supercell": [[29, 30], [-30, 59]]},
-    {"angle": 1.08454904916, "xy_supercell": [[30, 31], [-31, 61]]},
-    {"angle": 1.05012087979, "xy_supercell": [[31, 32], [-32, 63]]},
-    {"angle": 1.01781119445, "xy_supercell": [[32, 33], [-33, 65]]},
-    {"angle": 0.987430297814, "xy_supercell": [[33, 34], [-34, 67]]},
-    {"angle": 0.958810485525, "xy_supercell": [[34, 35], [-35, 69]]},
-    {"angle": 0.931802947264, "xy_supercell": [[35, 36], [-36, 71]]},
-    {"angle": 0.906275178895, "xy_supercell": [[36, 37], [-37, 73]]},
-    {"angle": 0.882108808579, "xy_supercell": [[37, 38], [-38, 75]]},
-    {"angle": 0.859197761631, "xy_supercell": [[38, 39], [-39, 77]]},
-    {"angle": 0.8374467041, "xy_supercell": [[39, 40], [-40, 79]]},
-    {"angle": 0.816769716893, "xy_supercell": [[40, 41], [-41, 81]]},
-    {"angle": 0.0, "xy_supercell": [[1, 0], [0, 1]]},
-]