@mat3ra/made 2026.8.13-0 → 2026.8.26-0

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

@@ -1,192 +0,0 @@
-from functools import cached_property
-from typing import List, Tuple, Union
-
-from mat3ra.code.vector import Vector3D
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-
-from ..build_components.metadata import MaterialWithBuildMetadata
-from ..convert import from_pymatgen, to_pymatgen
-from ..entities import MillerIndices, Termination, TerminationHolder
-from ..third_party import PymatgenSlab, PymatgenSlabGenerator, label_pymatgen_slab_termination
-from .lattice import LatticeMaterialAnalyzer
-
-
-def select_slab_with_termination_by_formula(slabs: List[PymatgenSlab], termination: Termination) -> PymatgenSlab:
-    for slab in slabs:
-        if Termination.from_string(label_pymatgen_slab_termination(slab)).formula == termination.formula:
-            return slab
-    raise ValueError(f"No slab found with termination: {termination}")
-
-
-class CrystalLatticePlanesMaterialAnalyzer(LatticeMaterialAnalyzer):
-    # Values used to generate slabs with terminations, these values are set to allow for all terminations to be found.
-    # Heuristic showed that these values are sufficient for all slabs configurations.
-    DEFAULT_THICKNESS_FOR_TERMINATIONS: int = 3
-    DEFAULT_VACUUM_SIZE_FOR_TERMINATIONS: int = 1
-    # Values used to generate slabs for later use. A single layer thickness and no vacuum.
-    DEFAULT_THICKNESS_FOR_GENERATION: int = 1
-    DEFAULT_VACUUM_SIZE_FOR_GENERATION: int = 0
-    DEFAULT_SYMMETRIZE: bool = False
-    miller_indices: Union[List[int], Tuple[int, int, int]]
-
-    def get_pymatgen_slab_generator(
-        self,
-        min_slab_size: float = DEFAULT_VACUUM_SIZE_FOR_GENERATION,
-        min_vacuum_size: float = DEFAULT_VACUUM_SIZE_FOR_GENERATION,
-        in_unit_planes: bool = True,
-        make_primitive: bool = False,
-    ):
-        return PymatgenSlabGenerator(
-            initial_structure=to_pymatgen(self.material_with_conventional_lattice),
-            miller_index=MillerIndices(root=self.miller_indices).to_tuple(),
-            min_slab_size=min_slab_size,
-            min_vacuum_size=min_vacuum_size,
-            in_unit_planes=in_unit_planes,
-            primitive=make_primitive,
-        )
-
-    @cached_property
-    def pymatgen_slab_generator_with_vacuum(self) -> PymatgenSlabGenerator:
-        # This generator is used to create slabs with vacuum and thick enough to allow for all terminations to be found.
-        return self.get_pymatgen_slab_generator(
-            min_slab_size=self.DEFAULT_THICKNESS_FOR_TERMINATIONS,
-            min_vacuum_size=self.DEFAULT_VACUUM_SIZE_FOR_TERMINATIONS,
-        )
-
-    @cached_property
-    def pymatgen_slab_generator_without_vacuum(self) -> PymatgenSlabGenerator:
-        # This generator is used to create slabs without vacuum and with a single layer thickness.
-        return self.get_pymatgen_slab_generator(
-            min_slab_size=self.DEFAULT_THICKNESS_FOR_GENERATION, min_vacuum_size=self.DEFAULT_VACUUM_SIZE_FOR_GENERATION
-        )
-
-    @cached_property
-    def all_planes_as_pymatgen_slabs_with_vacuum(self) -> List[PymatgenSlab]:
-        return [
-            *self.pymatgen_slab_generator_with_vacuum.get_slabs(symmetrize=True),
-            # Leaving option to create a non-symmetrized slabs too for additional terminations.
-            # As of now, looks like symmetrize=True gives all the unique terminations needed.
-            # *self.pymatgen_slab_generator_with_vacuum.get_slabs(symmetrize=False),
-        ]
-
-    @cached_property
-    def all_planes_as_pymatgen_slabs_without_vacuum(self) -> List[PymatgenSlab]:
-        return [
-            *self.pymatgen_slab_generator_without_vacuum.get_slabs(symmetrize=self.DEFAULT_SYMMETRIZE),
-            # Leaving option to create symmetrized slabs for layers generation.
-            # *self.pymatgen_slab_generator_without_vacuum.get_slabs(symmetrize=not self.DEFAULT_SYMMETRIZE),
-        ]
-
-    def _create_fallback_termination_for_failed_slab_generation(self) -> TerminationHolder:
-        """
-        Creates a fallback termination when pymatgen's SlabGenerator fails to generate slabs.
-
-        This happens for certain materials where SlabGenerator removes "too many sites"
-        and returns empty slab lists (e.g., some nanoribbons, thin 2D materials).
-
-        Returns:
-             TerminationHolder: A basic termination using the material's chemical formula
-        """
-        formula = self.formula
-        fallback_termination = Termination(chemical_elements=formula, space_group_symmetry_label="")
-
-        return TerminationHolder(
-            termination_with_vacuum=fallback_termination,
-            termination_without_vacuum=fallback_termination,
-            shift_with_vacuum=0.0,
-            shift_without_vacuum=0.0,
-        )
-
-    @cached_property
-    def termination_holders(self):
-        termination_holders = []
-        slabs_with_vacuum = self.all_planes_as_pymatgen_slabs_with_vacuum
-        slabs_without_vacuum = self.all_planes_as_pymatgen_slabs_without_vacuum
-
-        # Handle case where pymatgen fails to generate slabs for certain materials
-        # (e.g., some nanoribbons where "Too many sites removed" by SlabGenerator)
-        if not slabs_with_vacuum:
-            fallback_holder = self._create_fallback_termination_for_failed_slab_generation()
-            termination_holders.append(fallback_holder)
-
-        for slab_with_vacuum in slabs_with_vacuum:
-            termination_with_vacuum_string = label_pymatgen_slab_termination(slab_with_vacuum)
-            termination_with_vacuum = Termination.from_string(termination_with_vacuum_string)
-
-            try:
-                matching_slab_without_vacuum = select_slab_with_termination_by_formula(
-                    slabs_without_vacuum, termination_with_vacuum
-                )
-                termination_without_vacuum_string = label_pymatgen_slab_termination(matching_slab_without_vacuum)
-                termination_without_vacuum = Termination.from_string(termination_without_vacuum_string)
-                shift_without_vacuum = matching_slab_without_vacuum.shift
-            except ValueError:
-                termination_without_vacuum = None
-                shift_without_vacuum = 0.0
-            shift_with_vacuum = slab_with_vacuum.shift
-
-            termination_holders.append(
-                TerminationHolder(
-                    termination_with_vacuum=termination_with_vacuum,
-                    termination_without_vacuum=termination_without_vacuum,
-                    shift_with_vacuum=shift_with_vacuum,
-                    shift_without_vacuum=shift_without_vacuum,
-                )
-            )
-
-        return termination_holders
-
-    @cached_property
-    def terminations_with_vacuum(self) -> List[Termination]:
-        return [holder.termination_with_vacuum for holder in self.termination_holders]
-
-    @cached_property
-    def terminations_without_vacuum(self) -> List[Termination]:
-        return [holder.termination_without_vacuum for holder in self.termination_holders]
-
-    @cached_property
-    def terminations(self):
-        return self.terminations_with_vacuum
-
-    @property
-    def default_termination(self) -> Termination:
-        return self.terminations[0]
-
-    @property
-    def miller_supercell_matrix(self) -> Matrix3x3Schema:
-        return self.pymatgen_slab_generator_without_vacuum.slab_scale_factor.tolist()
-
-    def get_material_name_for_termination(self, termination: Termination) -> str:
-        # for example: "Si(001), termination Si_P4/mmm_1, Slab"
-        return f"{self.material.formula}({self.miller_indices}), termination {termination}, Slab"
-
-    def get_material_with_termination_without_vacuum(self, termination: Termination) -> Material:
-        # Note: termination is passed with vacuum, but we return the material without vacuum
-        holder = next((h for h in self.termination_holders if h.termination_with_vacuum == termination), None)
-        if holder is None:
-            raise ValueError(f"Termination {termination} not found.")
-
-        slabs_without_vacuum = self.all_planes_as_pymatgen_slabs_without_vacuum
-        slab = select_slab_with_termination_by_formula(slabs_without_vacuum, termination)
-        material = MaterialWithBuildMetadata.create(from_pymatgen(slab))
-        material.name = self.get_material_name_for_termination(termination)
-        return material
-
-    def get_translation_vector_for_termination_without_vacuum(self, termination: Termination) -> Vector3D:
-        holder = next((h for h in self.termination_holders if h.termination_with_vacuum == termination), None)
-        if holder is None:
-            raise ValueError(f"Termination {termination} not found.")
-
-        # NOTE: pymatgen shift values are in fractional crystal coordinates and need to be negated
-        # Convert from crystal to cartesian coordinates using the conventional lattice
-        crystal_shift = [0.0, 0.0, -holder.shift_without_vacuum]
-        cartesian_shift = self.material_with_conventional_lattice.basis.cell.convert_point_to_cartesian(crystal_shift)
-        return cartesian_shift
-
-    def get_materials_for_all_terminations_without_vacuum(self) -> List[Material]:
-        return [
-            self.get_material_with_termination_without_vacuum(holder.termination_with_vacuum)
-            for holder in self.termination_holders
-            if holder.termination_without_vacuum is not None
-        ]

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

@@ -1,105 +0,0 @@
-from typing import Union
-
-import numpy as np
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-from pydantic import BaseModel, Field
-
-from ..build_components.metadata.material_with_build_metadata import MaterialWithBuildMetadata
-from ..operations.reusable.unary import transform_material_by_matrix
-from .basis import BasisMaterialAnalyzer
-from .enums import POSSIBLE_TRANSFORMATION_MATRICES
-
-
-class LatticeSwapDetectionResult(BaseModel):
-    model_config = {"arbitrary_types_allowed": True}
-    is_swapped: bool = Field(..., description="Whether a lattice swap was detected")
-    permutation: Matrix3x3Schema = Field(..., description="Transformation matrix representing the swap")
-    confidence: float = Field(..., description="Confidence score (0.0 to 1.0)")
-
-
-class MaterialLatticeSwapAnalyzer(BaseModel):
-    """
-    Analyzer to detect lattice vector swaps/permutations between materials.
-
-    This detects when lattice vectors have been reoriented (e.g., a->a, b->c, c->-b)
-    rather than the basis being rotated within the lattice.
-    """
-
-    material: Union[Material, MaterialWithBuildMetadata]
-    tolerance: float = 0.01
-
-    def _compute_transformation_score(self, matrix: np.ndarray, target_fingerprint) -> float:
-        transformed_material = transform_material_by_matrix(self.material, matrix)
-        new_analyzer = BasisMaterialAnalyzer(material=transformed_material)
-        new_fingerprint = new_analyzer.get_layer_fingerprint(target_fingerprint.layer_thickness)
-        return target_fingerprint.get_similarity_score(new_fingerprint)
-
-    def _create_detection_result(self, matrix: np.ndarray, score: float) -> LatticeSwapDetectionResult:
-        is_identity = np.allclose(matrix, np.eye(3), atol=self.tolerance)
-        return LatticeSwapDetectionResult(
-            is_swapped=not is_identity,
-            permutation=Matrix3x3Schema(root=matrix.tolist()),
-            confidence=score,
-        )
-
-    def detect_swap_from_original(
-        self, original_material: MaterialWithBuildMetadata, layer_thickness: float = 1.0, threshold: float = 0.1
-    ) -> LatticeSwapDetectionResult:
-        """
-        Detect lattice swap from the original material.
-
-        We apply every transformation matrix to lattice and basis, compute the fingerprint along z, then compare
-        to the original material's fingerprint. The best matching transformation (if above threshold) is considered
-        a detected swap.
-
-
-        Args:
-            original_material: The original material before transformation
-            layer_thickness: Thickness of layers for fingerprint comparison
-            threshold: Minimum improvement threshold to consider a swap detected
-
-        Returns:
-            LatticeSwapDetectionResult: Swap detection results with permutation and new lattice
-        """
-        target_analyzer = BasisMaterialAnalyzer(material=original_material)
-        target_fingerprint = target_analyzer.get_layer_fingerprint(layer_thickness)
-        possible_matrices = list(map(np.array, POSSIBLE_TRANSFORMATION_MATRICES))
-
-        best_match = None
-        max_score = 0
-
-        for matrix in possible_matrices:
-            score = self._compute_transformation_score(matrix, target_fingerprint)
-            if score > max_score:
-                best_match = self._create_detection_result(matrix, score)
-                max_score = score
-
-        if best_match and best_match.is_swapped and best_match.confidence >= threshold:
-            return best_match
-        # If no swap detected, return identity result
-        return self._create_detection_result(np.eye(3), 1.0)
-
-    def get_corrected_material(
-        self,
-        target: MaterialWithBuildMetadata,
-        layer_thickness: float = 1.0,
-        threshold: float = 0.1,
-    ) -> MaterialWithBuildMetadata:
-        """
-        Correct the material's lattice to match the target material's orientation if a swap is detected.
-
-        Args:
-            target: The target material to match
-            layer_thickness: Thickness of layers for fingerprint comparison
-            threshold: Minimum improvement threshold to consider a swap detected
-
-        Returns:
-            MaterialWithBuildMetadata: Corrected material with lattice matching the target orientation
-        """
-        swap_info = self.detect_swap_from_original(target, layer_thickness, threshold)
-        if swap_info.is_swapped:
-            matrix_list = [list(row.root) if hasattr(row, "root") else row for row in swap_info.permutation.root]
-            matrix_array = np.array(matrix_list)
-            return transform_material_by_matrix(self.material, matrix_array)
-        return self.material

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

@@ -1,276 +0,0 @@
-from typing import List, Optional, Tuple
-
-import numpy as np
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.made.material import Material
-from scipy.spatial._ckdtree import cKDTree
-
-from ..bond_directions.bond_directions import BondDirections
-from ..bond_directions.bond_directions_templates_for_element import BondDirectionsTemplatesForElement
-from ..build_components.entities.auxiliary.zero_dimensional.crystal_site import CrystalSite, CrystalSiteList
-from .rdf import RadialDistributionFunction
-from .utils import decorator_handle_periodic_boundary_conditions
-
-
-class MaterialWithCrystalSites(Material):
-    crystal_sites: CrystalSiteList = CrystalSiteList.from_values([])
-    nearest_neighbor_vectors: ArrayWithIds = ArrayWithIds.from_values([])
-
-    @classmethod
-    def from_material(cls, material: Material):
-        new_material = material.clone()
-        new_material.to_cartesian()
-        return cls(name=material.name, basis=new_material.basis, lattice=new_material.lattice)
-
-    def analyze(self):
-        """
-        Analyze the material in place and generate the crystal sites with properties.
-
-        Generated properties:
-            - nearest_neighbor_vectors: The nearest neighbor vectors for all sites.
-        """
-        self.nearest_neighbor_vectors = self.get_neighbors_vectors_for_all_sites(cutoff=3.0)
-        self.crystal_sites = CrystalSiteList(
-            values=[CrystalSite(nearest_neighbor_vectors=item) for item in self.nearest_neighbor_vectors.values],
-            ids=self.nearest_neighbor_vectors.ids,
-        )
-
-    @property
-    def coordinates_as_kdtree(self):
-        return cKDTree(self.basis.coordinates.values)
-
-    def get_neighbors_vectors_for_site(
-        self, site_index: int, cutoff: float = 3.0, max_number_of_neighbors: Optional[int] = None
-    ) -> List[np.ndarray]:
-        """
-        Get the nearest neighbor vectors for a specific site.
-
-        Args:
-            site_index (int): The index of the site to
-            cutoff (float): The maximum cutoff radius for identifying neighbors.
-            max_number_of_neighbors (int): The max number of neighbors possible.
-
-        Returns:
-            List[np.ndarray]: List of vectors to the nearest neighbors.
-        """
-        coordinates = self.basis.coordinates.values
-        neighbors, distances = self.get_neighbors_for_site(site_index, cutoff, max_number_of_neighbors)
-        vectors = [np.array(coordinates[neighbor]) - np.array(coordinates[site_index]) for neighbor in neighbors]
-        return vectors
-
-    @decorator_handle_periodic_boundary_conditions(cutoff=0.25)
-    def get_neighbors_vectors_for_all_sites(
-        self, cutoff: float = 3.0, max_number_of_neighbors: Optional[int] = None
-    ) -> ArrayWithIds:
-        """
-        Get the nearest neighbor vectors for all sites.
-
-        Args:
-            cutoff (float): The maximum cutoff radius for identifying neighbors.
-            max_number_of_neighbors (int): The max number of neighbors possible.
-
-        Returns:
-            ArrayWithIds: Array with the nearest neighbor vectors for all sites.
-        """
-        nearest_neighbors = ArrayWithIds(values=[], ids=[])
-        for site_index in range(len(self.basis.coordinates.values)):
-            vectors = self.get_neighbors_vectors_for_site(site_index, cutoff, max_number_of_neighbors)
-            nearest_neighbors.add_item(vectors, site_index)
-        return nearest_neighbors
-
-    def get_neighbors_for_site(
-        self,
-        site_index: int,
-        cutoff: float = 3.0,
-        max_number_of_neighbors: Optional[int] = None,
-        nearest_only: bool = True,
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Get the nearest neighbors for a specific site.
-
-        Args:
-            site_index (int): The index of the site to
-            cutoff (float): The maximum cutoff radius for identifying neighbors.
-            max_number_of_neighbors (int): The max number of neighbors possible.
-            nearest_only (bool): If True, only consider the first shell of neighbors.
-
-        Returns:
-            Tuple[np.ndarray, np.ndarray]: Tuple of neighbors and distances.
-        """
-        coordinates = self.basis.coordinates
-        max_number_of_neighbors = (
-            len(coordinates.values) if max_number_of_neighbors is None else max_number_of_neighbors
-        )
-        coordinate = coordinates.get_element_value_by_index(site_index)
-        distances, neighbors = self.coordinates_as_kdtree.query(
-            coordinate, k=max_number_of_neighbors, distance_upper_bound=cutoff
-        )
-        valid_indices = (distances != np.inf) & (distances != 0)
-        distances = distances[valid_indices]
-        neighbors = neighbors[valid_indices]
-
-        if nearest_only:
-            rdf = RadialDistributionFunction.from_material(self)
-            valid_indices = np.where([rdf.is_within_first_peak(distance) for distance in distances])
-            distances = distances[valid_indices]
-            neighbors = neighbors[valid_indices]
-        return neighbors, distances
-
-    def get_nearest_neighbors_for_all_sites(
-        self, cutoff: float = 3.0, max_number_of_neighbors: Optional[int] = None
-    ) -> ArrayWithIds:
-        """
-        Get the nearest neighbors for all sites.
-
-        Args:
-            cutoff (float): The maximum cutoff radius for identifying neighbors.
-            max_number_of_neighbors (int): The max number of neighbors possible.
-
-        Returns:
-            ArrayWithIds: Array with the nearest neighbors for all sites.
-        """
-        nearest_neighbors = ArrayWithIds(values=[], ids=[])
-        for site_index in self.basis.coordinates.ids:
-            neighbors, distances = self.get_neighbors_for_site(site_index, cutoff, max_number_of_neighbors)
-            nearest_neighbors.add_item(neighbors, site_index)
-        return nearest_neighbors
-
-    @decorator_handle_periodic_boundary_conditions(cutoff=0.25)
-    def get_coordination_numbers(self, cutoff: float = 3.0) -> ArrayWithIds:
-        """
-        Calculate the coordination numbers for all atoms in the material.
-
-        Args:
-            cutoff (float): The cutoff radius for identifying neighbors.
-
-        Returns:
-            ArrayWithIds: Array with the coordination numbers for all sites.
-        """
-        nearest_neighbors = self.get_nearest_neighbors_for_all_sites(cutoff)
-        coordination_numbers = [len(neighbors) for neighbors in nearest_neighbors.values]
-        return ArrayWithIds(values=coordination_numbers, ids=nearest_neighbors.ids)
-
-    def get_undercoordinated_atom_indices(self, cutoff: float, coordination_threshold: int) -> List[int]:
-        """
-        Identify undercoordinated atoms based on the coordination threshold (inclusive).
-
-        Args:
-            cutoff (float): The cutoff radius for identifying neighbors.
-            coordination_threshold (int): The coordination number threshold for an atom
-                to be considered undercoordinated, inclusive.
-
-        Returns:
-            List[int]: List of indices of undercoordinated atoms.
-        """
-        coordination_numbers = self.get_coordination_numbers(cutoff)
-        return [
-            item.id
-            for item in coordination_numbers.to_array_of_values_with_ids()
-            if item.value <= coordination_threshold
-        ]
-
-    def get_unique_coordination_numbers(self, cutoff: float) -> List[int]:
-        """
-        Get the unique coordination numbers for all atoms in the material.
-
-        Args:
-            self (MaterialWithCrystalSites): The material object with crystal sites.
-            cutoff (float): The cutoff radius for identifying neighbors.
-
-        Returns:
-            List[int]: A list of unique coordination numbers present in the material.
-        """
-        coordination_numbers = self.get_coordination_numbers(cutoff)
-        return sorted(list(set(coordination_numbers.values)))
-
-    @decorator_handle_periodic_boundary_conditions(cutoff=0.25)
-    def find_missing_bonds_for_all_sites(
-        self,
-        bond_templates_list: List[BondDirectionsTemplatesForElement],
-        max_bonds_to_add: int = 1,
-        angle_tolerance: float = 0.1,
-    ) -> List[BondDirections]:
-        """
-        Find missing bonds for all sites in the material.
-
-        Args:
-            self (MaterialWithCrystalSites): The material object with crystal sites.
-            bond_templates_list (List[BondDirectionsTemplatesForElement]): List of bond templates for each element.
-
-        Returns:
-            List[BondDirections]: List of missing bonds for each site.
-        """
-        missing_bonds: List[BondDirections] = []
-        for coordinate in self.basis.coordinates.to_array_of_values_with_ids():
-            existing_bond_directions = BondDirections(self.get_neighbors_vectors_for_site(coordinate.id, cutoff=3.0))
-            element = self.basis.elements.get_element_value_by_index(coordinate.id)
-            bond_templates = [
-                bond_templates_for_element.to_ndarray()
-                for bond_templates_for_element in bond_templates_list
-                if bond_templates_for_element.element == element
-            ]
-            if bond_templates is None:
-                continue
-            missing_bonds_for_site = existing_bond_directions.find_missing_directions(
-                bond_templates=bond_templates,
-                angle_tolerance=angle_tolerance,
-                max_bonds_to_add=max_bonds_to_add,
-            )
-            missing_bonds.append(BondDirections(missing_bonds_for_site))
-
-        return missing_bonds
-
-    def find_unique_bond_directions(self) -> List[BondDirectionsTemplatesForElement]:
-        """
-        Find unique bond templates for each element type.
-
-        Args:
-            self (Material): The material object.
-
-        Returns:
-            List[BondDirectionsTemplatesForElement]: List of unique bond templates for each element.
-
-        Example schematic structure for Graphene with 2 unique bond directions:
-            {"C": [[0, 1, 0], [-2, -1, 0], [2, -1, 0]], [[0,-1,0], [-2, 1, 0], [2, 1, 0]]}
-        """
-        element_templates: List[BondDirectionsTemplatesForElement] = []
-
-        for element in set(self.basis.elements.values):
-            element_templates.append(self.find_bond_directions_for_element(element))
-
-        return element_templates
-
-    def find_bond_directions_for_element(self, element: str) -> BondDirectionsTemplatesForElement:
-        """
-        Find bond directions templates for each element.
-
-        Args:
-            self (MaterialWithCrystalSites): The material object with crystal sites.
-            element (str): Chemical element to find templates for.
-
-        Returns:
-            List[BondDirectionsTemplatesForElement]: List of unique bond templates for the element.
-        """
-        atom_vectors = self.nearest_neighbor_vectors
-        atom_elements = self.basis.elements.values
-
-        element_indices = [i for i, e in enumerate(atom_elements) if e == element]
-        element_vector_lists = [np.array(atom_vectors.get_element_value_by_index(i)) for i in element_indices]
-
-        if not element_vector_lists:
-            return BondDirectionsTemplatesForElement(bond_directions_templates=[], element=element)
-
-        max_coordination_number = max(len(vectors) for vectors in element_vector_lists)
-        max_coordination_number_vectors = [v for v in element_vector_lists if len(v) == max_coordination_number]
-
-        unique_templates: BondDirectionsTemplatesForElement = BondDirectionsTemplatesForElement(
-            bond_directions_templates=[], element=element
-        )
-        for template in max_coordination_number_vectors:
-            bond_direction = BondDirections(template)
-            if not any(
-                np.array_equal(bond_direction, existing) for existing in unique_templates.bond_directions_templates
-            ):
-                unique_templates.bond_directions_templates.append(bond_direction)
-
-        return unique_templates