@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/__init__.py

@@ -1,19 +0,0 @@
-from .merge_based import NanoparticleConfiguration, NanoparticleBuilder
-from .ase_based import ASEBasedNanoparticleConfiguration, ASEBasedNanoparticleBuilder
-from .enums import NanoparticleShapesEnum
-from .helpers import (
-    create_nanoparticle_by_shape,
-    create_nanoparticle_from_material,
-    create_nanoparticle_by_shape_from_element,
-)
-
-__all__ = [
-    "NanoparticleConfiguration",
-    "NanoparticleBuilder",
-    "ASEBasedNanoparticleConfiguration",
-    "ASEBasedNanoparticleBuilder",
-    "NanoparticleShapesEnum",
-    "create_nanoparticle_by_shape",
-    "create_nanoparticle_from_material",
-    "create_nanoparticle_by_shape_from_element",
-]

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/analyzer.py

@@ -1,86 +0,0 @@
-from typing import List, Union
-
-import numpy as np
-
-from .....analyze import BaseMaterialAnalyzer
-from .....entities.coordinate import SphereCoordinateCondition, CoordinateCondition
-
-
-class NanoparticleMaterialAnalyzer(BaseMaterialAnalyzer):
-    orientation_z: List[int] = [0, 0, 1]
-    vacuum_padding: float = 10.0
-    coordinate_condition: Union[SphereCoordinateCondition, CoordinateCondition] = SphereCoordinateCondition()
-
-    def _calculate_max_dimension_from_condition(self) -> float:
-        if isinstance(self.coordinate_condition, SphereCoordinateCondition):
-            return 2.0 * self.coordinate_condition.radius
-
-        return self.vacuum_padding
-
-    def _get_cartesian_lattice_dimensions(self) -> List[float]:
-        """
-        Get the Cartesian dimensions of the unit cell lattice vectors.
-        """
-        lattice_vectors = self.material.lattice.vector_arrays
-        return [np.linalg.norm(vector) for vector in lattice_vectors]
-
-    @property
-    def supercell_to_fit_nanoparticle(self) -> List[List[int]]:
-        """
-        Calculate the supercell size needed to fit the nanoparticle.
-        This calculates how many unit cells are needed in each direction to contain
-        the nanoparticle defined by the coordinate condition.
-        """
-        max_dimension = self._calculate_max_dimension_from_condition()
-
-        lattice_dimensions = self._get_cartesian_lattice_dimensions()
-
-        nx = max(1, int(np.ceil(max_dimension / lattice_dimensions[0])))
-        ny = max(1, int(np.ceil(max_dimension / lattice_dimensions[1])))
-        nz = max(1, int(np.ceil(max_dimension / lattice_dimensions[2])))
-
-        return [[nx, 0, 0], [0, ny, 0], [0, 0, nz]]
-
-    @property
-    def supercell_for_vacuum(self) -> List[List[int]]:
-        """
-        Calculate the supercell size that includes vacuum padding on all sides.
-        This is used to create the final cell with appropriate vacuum space.
-        """
-        nanoparticle_supercell = self.supercell_to_fit_nanoparticle
-
-        # Get base dimensions from nanoparticle supercell
-        nx_base = nanoparticle_supercell[0][0]
-        ny_base = nanoparticle_supercell[1][1]
-        nz_base = nanoparticle_supercell[2][2]
-
-        # Get lattice dimensions
-        lattice_dimensions = self._get_cartesian_lattice_dimensions()
-
-        # Calculate additional cells needed for vacuum padding on each side
-        # We need padding on both sides, so total padding = 2 * vacuum_padding
-        vacuum_cells_x = max(1, int(np.ceil(2 * self.vacuum_padding / lattice_dimensions[0])))
-        vacuum_cells_y = max(1, int(np.ceil(2 * self.vacuum_padding / lattice_dimensions[1])))
-        vacuum_cells_z = max(1, int(np.ceil(2 * self.vacuum_padding / lattice_dimensions[2])))
-
-        # Total supercell size = nanoparticle size + vacuum padding
-        nx_total = nx_base + vacuum_cells_x
-        ny_total = ny_base + vacuum_cells_y
-        nz_total = nz_base + vacuum_cells_z
-
-        return [[nx_total, 0, 0], [0, ny_total, 0], [0, 0, nz_total]]
-
-    @property
-    def xy_supercell_matrix_to_fit_nanoparticle(self) -> List[List[int]]:
-        """
-        Get the 2D supercell matrix for the xy plane to fit the nanoparticle.
-        """
-        supercell_3d = self.supercell_to_fit_nanoparticle
-        return [[supercell_3d[0][0], 0], [0, supercell_3d[1][1]]]
-
-    @property
-    def number_of_layers_to_fit_nanoparticle(self) -> int:
-        """
-        Get the number of layers (z-direction repetitions) needed to fit the nanoparticle.
-        """
-        return self.supercell_to_fit_nanoparticle[2][2]

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/ase_based/__init__.py

@@ -1,7 +0,0 @@
-from .configuration import ASEBasedNanoparticleConfiguration
-from .builder import ASEBasedNanoparticleBuilder
-
-__all__ = [
-    "ASEBasedNanoparticleConfiguration",
-    "ASEBasedNanoparticleBuilder",
-]

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/ase_based/builder.py

@@ -1,54 +0,0 @@
-from typing import Callable, Dict
-
-from .configuration import ASEBasedNanoparticleConfiguration
-from ..enums import NanoparticleShapesEnum
-from ......analyze import get_chemical_formula_empirical
-from ......build_components import MaterialWithBuildMetadata, BaseSingleBuilder
-from ......build_components.mixins import ConvertGeneratedItemsASEAtomsMixin
-from ......third_party import ASEAtoms
-
-
-class ASEBasedNanoparticleBuilder(ConvertGeneratedItemsASEAtomsMixin, BaseSingleBuilder):
-    """
-    Generalized builder for creating nanoparticles based on ASE cluster tools.
-    Passes configuration parameters directly to the ASE constructors.
-    """
-
-    _ConfigurationType: type(ASEBasedNanoparticleConfiguration) = ASEBasedNanoparticleConfiguration  # type: ignore
-    _GeneratedItemType: type(ASEAtoms) = ASEAtoms  # type: ignore
-
-    @staticmethod
-    def _get_ase_nanoparticle_parameters(config: ASEBasedNanoparticleConfiguration) -> Dict:
-        parameters = config.parameters or {}
-        parameters["symbol"] = config.element
-        return parameters
-
-    @classmethod
-    def _get_ase_nanoparticle_constructor(cls, config: ASEBasedNanoparticleConfiguration) -> Callable[..., ASEAtoms]:
-        constructor = NanoparticleShapesEnum.get_ase_constructor(config.shape.value)
-        return constructor
-
-    @staticmethod
-    def _set_ase_cell(atoms: ASEAtoms, vacuum: float) -> ASEAtoms:
-        """
-        Set the cell of an ASE atoms object to a cubic box with vacuum padding around the nanoparticle.
-        """
-        max_dimension_along_x = abs(atoms.positions[:, 0]).max()
-        box_size = 2 * max_dimension_along_x + vacuum
-        atoms.set_cell([box_size, box_size, box_size], scale_atoms=False)
-        atoms.center()
-        return atoms
-
-    def _generate(self, configuration: ASEBasedNanoparticleConfiguration) -> MaterialWithBuildMetadata:
-        parameters = self._get_ase_nanoparticle_parameters(configuration)
-        constructor = self._get_ase_nanoparticle_constructor(configuration)
-        nanoparticle_without_cell = constructor(**parameters)
-        nanoparticle = self._set_ase_cell(nanoparticle_without_cell, configuration.vacuum_padding)
-
-        return MaterialWithBuildMetadata.create(self._convert_generated_item(nanoparticle))
-
-    def _update_material_name(
-        self, material: MaterialWithBuildMetadata, configuration: ASEBasedNanoparticleConfiguration
-    ) -> MaterialWithBuildMetadata:
-        material.name = f"{get_chemical_formula_empirical(material)} {configuration.shape.value.capitalize()}"
-        return material

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/ase_based/configuration.py

@@ -1,19 +0,0 @@
-from typing import Dict, Optional
-
-from ......build_components import BaseConfigurationPydantic
-from ..enums import NanoparticleShapesEnum
-
-
-class ASEBasedNanoparticleConfiguration(BaseConfigurationPydantic):
-    """
-    Configuration for building a nanoparticle with bottom-up approach from atoms.
-
-    Attributes:
-        shape (NanoparticleShapes): The desired shape of the nanoparticle.
-        parameters (dict): Dictionary of parameters to pass to the corresponding ASE constructor.
-    """
-
-    shape: NanoparticleShapesEnum
-    parameters: Optional[Dict] = None
-    element: str
-    vacuum_padding: float = 10.0

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/enums.py

@@ -1,42 +0,0 @@
-from enum import Enum
-from typing import Callable
-
-from .....third_party import (
-    ASEIcosahedron,
-    ASEOctahedron,
-    ASEDecahedron,
-    ASESimpleCubic,
-    ASEFaceCenteredCubic,
-    ASEBodyCenteredCubic,
-    ASEHexagonalClosedPacked,
-    ASEWulffConstruction,
-    ASEAtoms,
-)
-
-
-class NanoparticleShapesEnum(str, Enum):
-    """
-    Enum for supported nanoparticle shapes.
-    """
-
-    ICOSAHEDRON = "icosahedron"
-    OCTAHEDRON = "octahedron"
-    DECAHEDRON = "decahedron"
-    SIMPLE_CUBIC = "simple_cubic"
-    FACE_CENTERED_CUBIC = "face_centered_cubic"
-    BODY_CENTERED_CUBIC = "body_centered_cubic"
-    HEXAGONAL_CLOSED_PACKED = "hexagonal_closed_packed"
-    WULFF_CONSTRUCTION = "wulff_construction"
-
-    @staticmethod
-    def get_ase_constructor(shape: str) -> Callable[..., ASEAtoms]:
-        return {
-            "icosahedron": ASEIcosahedron,
-            "octahedron": ASEOctahedron,
-            "decahedron": ASEDecahedron,
-            "simple_cubic": ASESimpleCubic,
-            "face_centered_cubic": ASEFaceCenteredCubic,
-            "body_centered_cubic": ASEBodyCenteredCubic,
-            "hexagonal_closed_packed": ASEHexagonalClosedPacked,
-            "ase_wulff_construction": ASEWulffConstruction,
-        }[shape]

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/helpers.py

@@ -1,127 +0,0 @@
-from types import SimpleNamespace
-from typing import Union
-
-from mat3ra.made.material import Material
-from . import (
-    NanoparticleConfiguration,
-    NanoparticleBuilder,
-    NanoparticleShapesEnum,
-    ASEBasedNanoparticleConfiguration,
-    ASEBasedNanoparticleBuilder,
-)
-from .analyzer import NanoparticleMaterialAnalyzer
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.helpers import create_slab
-from ....defective_structures.two_dimensional.island.helpers import CoordinateConditionType
-from .....analyze.other import get_closest_site_id_from_coordinate
-from .....build_components import MaterialWithBuildMetadata
-from .....build_components.entities.auxiliary.zero_dimensional.void_region.configuration import VoidRegionConfiguration
-from .....entities.coordinate import SphereCoordinateCondition
-
-
-def create_nanoparticle_from_material(
-    material: Union[Material, MaterialWithBuildMetadata],
-    condition: Union[
-        SphereCoordinateCondition,
-        CoordinateConditionType,
-    ] = SphereCoordinateCondition(),
-    orientation_z=None,
-    center_around_atom: bool = True,
-    use_cartesian_coordinates: bool = True,
-    vacuum_padding: float = 10.0,
-) -> MaterialWithBuildMetadata:
-    """
-    Create a nanoparticle by applying a coordinate condition to a crystal.
-
-    Args:
-        material: The crystal material from which the nanoparticle is created.
-        condition: The coordinate condition that defines the nanoparticle shape.
-        orientation_z: The orientation of the crystallographic axis in the z-direction.
-        center_around_atom: Whether to center the condition around an atom close to the center in the material.
-        use_cartesian_coordinates: Whether the condition supplied is in Cartesian coordinates.
-        vacuum_padding: Padding for vacuum space around the nanoparticle.
-
-    Returns:
-        MaterialWithBuildMetadata: The nanoparticle material with build metadata.
-    """
-
-    if orientation_z is None:
-        orientation_z = [0, 0, 1]
-    analyzer = NanoparticleMaterialAnalyzer(
-        material=material,
-        orientation_z=orientation_z,
-        vacuum_padding=vacuum_padding,
-        coordinate_condition=condition,
-    )
-
-    repetitions_z = analyzer.number_of_layers_to_fit_nanoparticle
-    xy_supercell = analyzer.xy_supercell_matrix_to_fit_nanoparticle
-
-    if len(orientation_z) != 3:
-        raise ValueError("orientation_z must have exactly three elements.")
-    slab = create_slab(
-        material,
-        miller_indices=tuple(orientation_z),  # type: ignore
-        number_of_layers=repetitions_z,
-        xy_supercell_matrix=xy_supercell,
-        vacuum=0,
-    )
-
-    # Find an atom close to center, to apply the condition around it
-    if center_around_atom:
-        slab.to_cartesian()
-        center_coordinate = slab.basis.cell.convert_point_to_cartesian([0.5, 0.5, 0.5])
-        center_id_at_site = get_closest_site_id_from_coordinate(slab, center_coordinate, use_cartesian_coordinates=True)
-        center_coordinate = slab.basis.coordinates.get_element_value_by_index(center_id_at_site)
-        condition.center_coordinate = center_coordinate
-
-    void_region_config = VoidRegionConfiguration(
-        crystal=slab,
-        coordinate_condition=condition,
-        use_cartesian_coordinates=use_cartesian_coordinates,
-    )
-    config = NanoparticleConfiguration(merge_components=[slab, void_region_config])
-
-    nanoparticle = NanoparticleBuilder().get_material(config)
-    return nanoparticle
-
-
-def create_nanoparticle_by_shape(
-    crystal: Union[Material, MaterialWithBuildMetadata],
-    shape: NanoparticleShapesEnum,
-    parameters: Union[dict, SimpleNamespace],
-):
-    """
-    Create a nanoparticle from a crystal material by specifying its shape and parameters.
-
-    Provide the crystal which first element nad lattice constant will be used to create the nanoparticle.
-
-    """
-
-    # TODO: should done in analyzer
-    element = crystal.basis.elements.values[0]
-    lattice_constant = crystal.lattice.a
-
-    return create_nanoparticle_by_shape_from_element(
-        element=element, shape=shape, lattice_constant=lattice_constant, parameters=parameters
-    )
-
-
-def create_nanoparticle_by_shape_from_element(
-    element: str,
-    lattice_constant: float,
-    shape: NanoparticleShapesEnum,
-    parameters: Union[dict, SimpleNamespace],
-):
-    """
-    Create a nanoparticle from a specified element, lattice constant, shape, and parameters.
-    The shape is defined by the NanoparticleShapesEnum, and parameters are passed directly to the ASE constructor.
-    """
-    if not isinstance(parameters, SimpleNamespace):
-        parameters = SimpleNamespace(**parameters)
-    if not hasattr(parameters, "latticeconstant"):
-        parameters.latticeconstant = lattice_constant
-
-    config = ASEBasedNanoparticleConfiguration(shape=shape, parameters=parameters.__dict__, element=element)
-    builder = ASEBasedNanoparticleBuilder()
-    nanoparticles = builder.get_material(config)
-    return nanoparticles

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/merge_based/__init__.py

@@ -1,7 +0,0 @@
-from .configuration import NanoparticleConfiguration
-from .builder import NanoparticleBuilder
-
-__all__ = [
-    "NanoparticleConfiguration",
-    "NanoparticleBuilder",
-]

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/merge_based/builder.py

@@ -1,33 +0,0 @@
-from typing import Dict, Type, Union
-
-from mat3ra.made.material import Material
-from .configuration import NanoparticleConfiguration
-from .....defective_structures.zero_dimensional.point_defect.vacancy.builder import VacancyDefectBuilder
-from ......analyze import get_chemical_formula_empirical
-from ......build_components import MaterialWithBuildMetadata
-from ......build_components.entities.auxiliary.zero_dimensional.void_region.builder import VoidRegionBuilder
-from ......build_components.entities.auxiliary.zero_dimensional.void_region.configuration import VoidRegionConfiguration
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.builder import SlabBuilder
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
-from ......build_components.operations.core.combinations.merge import MergeBuilder
-
-
-class NanoparticleBuilder(VacancyDefectBuilder, MergeBuilder):
-    """
-    Builder class for creating a nanoparticle by merging a slab with a void region.
-    """
-
-    @property
-    def merge_component_types_conversion_map(self) -> Dict[Type, Type]:
-        return {
-            SlabConfiguration: SlabBuilder,
-            VoidRegionConfiguration: VoidRegionBuilder,
-        }
-
-    def _update_material_name(
-        self, material: Union[Material, MaterialWithBuildMetadata], configuration: NanoparticleConfiguration
-    ) -> Material:
-        formula = get_chemical_formula_empirical(material)
-
-        material.name = f"{formula} {configuration.void_region_configuration.condition_name} Nanoparticle"
-        return material

package/src/py/mat3ra/made/tools/build/pristine_structures/zero_dimensional/nanoparticle/merge_based/configuration.py

@@ -1,16 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-
-from ......build_components.entities.auxiliary.zero_dimensional.void_region.configuration import VoidRegionConfiguration
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
-from ......build_components.operations.core.combinations.merge.configuration import MergeConfiguration
-
-
-class NanoparticleConfiguration(MergeConfiguration):
-    merge_components: List = [SlabConfiguration, VoidRegionConfiguration]
-    merge_method: MergeMethodsEnum = MergeMethodsEnum.REPLACE
-
-    @property
-    def void_region_configuration(self) -> VoidRegionConfiguration:
-        return self.merge_components[1]

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/analyzers/__init__.py

@@ -1,9 +0,0 @@
-from .passivation_material_analyzer import PassivationMaterialAnalyzer
-from .surface_passivation_material_analyzer import SurfacePassivationMaterialAnalyzer
-from .coordination_based_passivation_material_analyzer import CoordinationBasedPassivationMaterialAnalyzer
-
-__all__ = [
-    "PassivationMaterialAnalyzer",
-    "SurfacePassivationMaterialAnalyzer",
-    "CoordinationBasedPassivationMaterialAnalyzer",
-]

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/analyzers/coordination_based_passivation_material_analyzer.py

@@ -1,112 +0,0 @@
-from typing import List
-
-import numpy as np
-
-from ......analyze.material import MaterialWithCrystalSites
-from ......bond_directions.bond_directions import BondDirections
-from ......bond_directions.bond_directions_templates_for_element import BondDirectionsTemplatesForElement
-
-from .surface_passivation_material_analyzer import SurfacePassivationMaterialAnalyzer
-
-
-class CoordinationBasedPassivationMaterialAnalyzer(SurfacePassivationMaterialAnalyzer):
-    """
-    Builder for passivating material surfaces based on coordination number analysis.
-
-        This builder analyzes atomic coordination environments and reconstructs missing bonds
-        using templates derived from fully coordinated atoms. It works by:
-
-        1. Finding undercoordinated atoms that need passivation
-        2. Creating bond vector templates for each element type by:
-            - Collecting vectors from atoms with the highest valid coordination
-            - Grouping similar vector arrangements into unique templates
-        3. Reconstructing missing bonds by:
-            - Matching existing bonds against templates
-            - Finding the best-matching template for each atom
-            - Adding missing bond vectors from the template
-        4. Placing passivant atoms (typically H) along the reconstructed bond vectors
-    """
-
-    coordination_threshold: int = 3  # The coordination number threshold for an atom to be considered undercoordinated.
-    number_of_bonds_to_passivate: int = 1  # The maximum number of bonds to passivate for each undercoordinated atom.
-    symmetry_tolerance: float = 0.1  # The tolerance for symmetry comparison of vectors for bonds.
-
-    @property
-    def material_with_crystal_sites(self) -> MaterialWithCrystalSites:
-        material_with_crystal_sites = MaterialWithCrystalSites.from_material(material=self.material)
-        material_with_crystal_sites.analyze()
-        return material_with_crystal_sites
-
-    @property
-    def undercoordinated_atoms_indices(self):
-        return self.material_with_crystal_sites.get_undercoordinated_atom_indices(
-            cutoff=self.shadowing_radius,
-            coordination_threshold=self.coordination_threshold,
-        )
-
-    @property
-    def bonds_templates(self) -> List[BondDirectionsTemplatesForElement]:
-        """
-        Find unique bond directions based on the material's crystal sites.
-
-        Returns:
-            List[BondDirectionsTemplatesForElement]: A list of unique bond direction templates.
-        """
-        # TODO: bonds_templates will be passed from the self in the "controlled" version of this class
-        return self.material_with_crystal_sites.find_unique_bond_directions()
-
-    @property
-    def reconstructed_bonds(self) -> List[BondDirections]:
-        """
-        Find missing bonds for all sites based on the bond templates.
-
-        Returns:
-            List[BondDirections]: A list of reconstructed bond directions for each atom.
-        """
-        return self.material_with_crystal_sites.find_missing_bonds_for_all_sites(
-            bond_templates_list=self.bonds_templates,
-            max_bonds_to_add=self.number_of_bonds_to_passivate,
-            angle_tolerance=self.symmetry_tolerance,
-        )
-
-    def _normalize_and_convert_bond_vector(self, bond_vector):
-        """
-        Normalize a bond vector and convert it to crystal coordinates.
-        Args:
-            bond_vector: The bond vector to normalize and convert.
-
-        Returns:
-            numpy.ndarray: The normalized bond vector in crystal coordinates, or None if the vector is zero.
-        """
-        bond_vector_np = np.array(bond_vector)
-        if np.linalg.norm(bond_vector_np) == 0:
-            return None
-        normalized_bond = bond_vector_np / np.linalg.norm(bond_vector_np) * self.bond_length
-        return self.material.basis.cell.convert_point_to_crystal(normalized_bond)
-
-    @property
-    def passivant_coordinates(
-        self,
-    ):
-        """
-        Calculate the coordinates for placing passivating atoms based on reconstructed bonds.
-
-        Args:
-            self (PassivationConfiguration): Configuration for passivation.
-
-        Returns:
-            list: Coordinates where passivants should be added.
-        """
-        passivant_coordinates = []
-
-        for idx in self.undercoordinated_atoms_indices:
-            for bond_vector in self.reconstructed_bonds[idx]:
-                normalized_bond_crystal = self._normalize_and_convert_bond_vector(bond_vector)
-                if normalized_bond_crystal is None:
-                    continue
-                passivant_coordinates.append(
-                    np.array(self.material.basis.coordinates.get_element_value_by_index(idx))
-                    + np.array(normalized_bond_crystal)
-                )
-
-        return passivant_coordinates

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/analyzers/passivation_material_analyzer.py

@@ -1,16 +0,0 @@
-from typing import List
-
-from ......analyze.slab import SlabMaterialAnalyzer
-from ..enums import SurfaceTypesEnum
-
-
-class PassivationMaterialAnalyzer(SlabMaterialAnalyzer):
-    passivant: str = "H"
-    bond_length: float = 1.0
-    surface: SurfaceTypesEnum = SurfaceTypesEnum.TOP
-
-    @property
-    def passivant_coordinates(self) -> List[List[float]]:
-        raise NotImplementedError(
-            "This method should be implemented in subclasses to return passivant coordinates based on the surface type."
-        )

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/analyzers/surface_passivation_material_analyzer.py

@@ -1,32 +0,0 @@
-import numpy as np
-
-from ......analyze.other import get_surface_atom_indices
-from ..enums import SurfaceTypesEnum
-
-from .passivation_material_analyzer import PassivationMaterialAnalyzer
-
-
-class SurfacePassivationMaterialAnalyzer(PassivationMaterialAnalyzer):
-    shadowing_radius: float = 2.5
-    depth: float = 5.0
-
-    @property
-    def passivant_coordinates(
-        self,
-    ):
-        """
-        Calculate the coordinates for placing passivants based on the specified surface type.
-
-        Args:
-            self (SurfacePassivationConfiguration): Configuration for passivation.
-
-        Returns:
-            list: Coordinates where passivants should be added.
-        """
-        surface_atoms_indices = get_surface_atom_indices(self.material, self.surface, self.shadowing_radius, self.depth)
-        surface_atoms_coordinates = [
-            self.material.basis.coordinates.get_element_value_by_index(i) for i in surface_atoms_indices
-        ]
-        bond_vector = [0, 0, self.bond_length] if self.surface == SurfaceTypesEnum.TOP else [0, 0, -self.bond_length]
-        passivant_bond_vector_crystal = self.material.basis.cell.convert_point_to_crystal(bond_vector)
-        return (np.array(surface_atoms_coordinates) + np.array(passivant_bond_vector_crystal)).tolist()

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/builder.py

@@ -1,23 +0,0 @@
-from typing import Dict, Type
-
-from .....build_components import MaterialWithBuildMetadata
-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.operations.core.combinations.merge import MergeBuilder
-
-from .configuration import PassivationConfiguration
-
-
-class PassivationBuilder(MergeBuilder):
-    @property
-    def merge_component_types_conversion_map(self) -> Dict[Type, Type]:
-        return {
-            AtomAtCoordinateConfiguration: AtomAtCoordinateBuilder,
-        }
-
-    def _update_material_name(
-        self, material: MaterialWithBuildMetadata, configuration: PassivationConfiguration
-    ) -> MaterialWithBuildMetadata:
-        material_name = configuration.material.name
-        material.name = f"{material_name}, {configuration.passivant}-passivated"
-        return material

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/configuration.py

@@ -1,31 +0,0 @@
-from typing import List, Union
-
-from mat3ra.esse.models.materials_category.processed_structures.two_dimensional.passivation.configuration import (
-    PassivationConfigurationSchema,
-)
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-
-from mat3ra.made.material import Material
-from .....build_components import MaterialWithBuildMetadata
-from .....build_components.entities.core.zero_dimensional.atom.configuration import AtomAtCoordinateConfiguration
-from .....build_components.operations.core.combinations.merge.configuration import MergeConfiguration
-
-
-class PassivationConfiguration(MergeConfiguration, PassivationConfigurationSchema):
-    """
-    Configuration for a passivation.
-
-    Args:
-        merge_components (List[Material, AtomAtCoordinateConfiguration]): The components to merge.
-        passivant (str): The passivating element.
-        bond_length (float): The bond length.
-    """
-
-    merge_components: List[Union[Material, MaterialWithBuildMetadata, AtomAtCoordinateConfiguration]]
-    merge_method: MergeMethodsEnum = MergeMethodsEnum.ADD
-    passivant: str = "H"
-    bond_length: float = 1.0
-
-    @property
-    def material(self) -> MaterialWithBuildMetadata:
-        return self.merge_components[0]

package/src/py/mat3ra/made/tools/build/processed_structures/two_dimensional/passivation/enums.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class SurfaceTypesEnum(str, Enum):
-    TOP = "top"
-    BOTTOM = "bottom"
-    BOTH = "both"