@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/builder.py

@@ -1,37 +0,0 @@
-from typing import Dict, Type, Union
-
-from mat3ra.made.material import Material
-
-from .....analyze.other import get_chemical_formula_empirical
-from .....build_components import MaterialWithBuildMetadata, TypeConfiguration
-from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.builder import PointDefectSiteBuilder
-from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.configuration import (
-    PointDefectSiteConfiguration,
-)
-from .....build_components.operations.core.combinations.merge.builder import MergeBuilder
-from .configuration import SolidSolutionConfiguration
-
-
-class SolidSolutionBuilder(MergeBuilder):
-    """Builds a solid solution by merging substitution sites into a supercell."""
-
-    _ConfigurationType: Type[SolidSolutionConfiguration] = SolidSolutionConfiguration
-
-    @property
-    def merge_component_types_conversion_map(self) -> Dict[Type, Type]:
-        return {
-            PointDefectSiteConfiguration: PointDefectSiteBuilder,
-        }
-
-    def _update_material_name(
-        self, material: Union[Material, MaterialWithBuildMetadata], configuration: TypeConfiguration
-    ) -> MaterialWithBuildMetadata:
-        formula = get_chemical_formula_empirical(material)
-        concentration_percentage = configuration.actual_concentration * 100
-        source_element = configuration.source_element
-        target_element = configuration.target_element
-        material.name = (
-            f"{formula} - Solid Solution ({source_element}->{target_element} "
-            f"{concentration_percentage:.4g}%)"
-        )
-        return material

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/configuration.py

@@ -1,30 +0,0 @@
-from typing import List, Union
-
-from mat3ra.esse.models.materials_category.defective_structures.three_dimensional.solid_solution.configuration import (
-    SolidSolutionConfigurationSchema,
-)
-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.auxiliary.zero_dimensional.point_defect_site.configuration import (
-    PointDefectSiteConfiguration,
-)
-from .....build_components.operations.core.combinations.merge.configuration import MergeConfiguration
-
-
-class SolidSolutionConfiguration(MergeConfiguration, SolidSolutionConfigurationSchema):
-    """Configuration for building a solid solution by merging substitution sites.
-
-    Physical specification: crystal, source_element, target_element, concentrations.
-    The merge_components hold the resolved substitution sites.
-    """
-
-    type: str = "SolidSolutionConfiguration"
-    crystal: Union[Material, MaterialWithBuildMetadata]
-    source_element: str
-    target_element: str
-    target_concentration: float
-    actual_concentration: float
-    merge_components: List[Union[Material, MaterialWithBuildMetadata, PointDefectSiteConfiguration]]
-    merge_method: MergeMethodsEnum = MergeMethodsEnum.REPLACE

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/enums.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class SiteSelectionMethodEnum(str, Enum):
-    # Selects sites purely at random (seeded for reproducibility).
-    RANDOM = "random"
-    # Selects sites using Farthest Point Sampling for maximal dispersion under PBC.
-    UNIFORM = "uniform"

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/helpers.py

@@ -1,76 +0,0 @@
-from typing import Optional, Union
-
-from mat3ra.esse.models.materials_category_components.entities.core.zero_dimensional.atom import AtomSchema
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-from mat3ra.made.material import Material
-
-from .....analyze.solid_solution_analyzer import SolidSolutionAnalyzer
-from .....build_components import MaterialWithBuildMetadata
-from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.configuration import (
-    PointDefectSiteConfiguration,
-)
-from .....build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-from .builder import SolidSolutionBuilder
-from .configuration import SolidSolutionConfiguration
-from .enums import SiteSelectionMethodEnum
-
-
-def create_solid_solution(
-    material: Union[Material, MaterialWithBuildMetadata],
-    source_element: str,
-    target_element: str,
-    concentration: float,
-    seed: Optional[int] = None,
-    tolerance: float = 0.01,
-    max_supercell_cells: int = 128,
-    site_selection_method: SiteSelectionMethodEnum = SiteSelectionMethodEnum.UNIFORM,
-) -> MaterialWithBuildMetadata:
-    """
-    Create a solid solution by partially substituting one element for another.
-
-    Automatically determines the optimal supercell size to achieve the target
-    concentration, builds the supercell, and performs substitution.
-
-    Args:
-        material (Union[Material, MaterialWithBuildMetadata]): Unit cell crystal.
-        source_element (str): Element to partially replace (e.g. "Hf").
-        target_element (str): Replacement element (e.g. "Zr").
-        concentration (float): Fraction of source_element to replace (0.0-1.0).
-        seed (Optional[int]): Random seed for reproducible site selection.
-        tolerance (float): Acceptable deviation from target concentration.
-        max_supercell_cells (int): Maximum supercell size to search.
-        site_selection_method (SiteSelectionMethodEnum): RANDOM or UNIFORM (Farthest Point Sampling).
-
-    Returns:
-        MaterialWithBuildMetadata: Solid solution with full build metadata.
-    """
-    analyzer = SolidSolutionAnalyzer(
-        material=material,
-        source_element=source_element,
-        target_element=target_element,
-        target_concentration=concentration,
-        tolerance=tolerance,
-        max_supercell_cells=max_supercell_cells,
-        seed=seed,
-        site_selection_method=site_selection_method,
-    )
-    supercell = create_supercell(material, scaling_factor=analyzer.optimal_supercell_dimensions)
-    coordinates = supercell.basis.coordinates.values
-    site_configurations = [
-        PointDefectSiteConfiguration(
-            crystal=supercell,
-            coordinate=coordinates[site_index],
-            element=AtomSchema(chemical_element=target_element),
-        )
-        for site_index in analyzer.selected_site_indices
-    ]
-    configuration = SolidSolutionConfiguration(
-        crystal=material,
-        source_element=source_element,
-        target_element=target_element,
-        target_concentration=concentration,
-        actual_concentration=analyzer.actual_concentration,
-        merge_components=[supercell] + site_configurations,
-        merge_method=MergeMethodsEnum.REPLACE,
-    )
-    return SolidSolutionBuilder().get_material(configuration)

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/adatom/builder.py

@@ -1,11 +0,0 @@
-from .configuration import AdatomDefectConfiguration
-from .....build_components.entities.reusable.two_dimensional.slab_stack.builder import SlabStackBuilder
-
-
-class AdatomDefectBuilder(SlabStackBuilder):
-    _ConfigurationType = AdatomDefectConfiguration
-
-    def get_name_suffix(self, configuration: AdatomDefectConfiguration) -> str:
-        elements = set(configuration.added_component.basis.elements.values)
-        elements_str = ", ".join(sorted(elements))
-        return f"{elements_str} Adatom"

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/adatom/configuration.py

@@ -1,18 +0,0 @@
-from mat3ra.esse.models.materials_category.defective_structures.two_dimensional.adatom.configuration import (
-    AdatomDefectConfigurationSchema,
-    AxisEnum,
-)
-
-from .....build_components.entities.reusable.two_dimensional.slab_stack.configuration import SlabStackConfiguration
-
-
-class AdatomDefectConfiguration(SlabStackConfiguration, AdatomDefectConfigurationSchema):
-    """
-    Configuration for creating an adatom defect on a slab surface.
-
-    Args:
-        stack_components: List containing [slab, isolated_defect, vacuum].
-    """
-
-    type: str = "AdatomDefectConfiguration"
-    direction: AxisEnum = AxisEnum.z

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/adatom/helpers.py

@@ -1,137 +0,0 @@
-from typing import List, Optional
-
-from mat3ra.made.material import Material
-from .builder import AdatomDefectBuilder
-from .configuration import (
-    AdatomDefectConfiguration,
-)
-from .types import AdatomDefectDict
-from .....analyze.crystal_site.adatom_crystal_site_material_analyzer import (
-    AdatomCrystalSiteMaterialAnalyzer,
-)
-from .....analyze.crystal_site.adatom_material_analyzer import AdatomMaterialAnalyzer
-from .....build_components import MaterialWithBuildMetadata
-from .....build_components.operations.core.combinations.enums import AdatomPlacementMethodEnum
-from .....operations.core.binary import merge
-
-
-def get_adatom_defect_analyzer_cls(
-    placement_method: str = AdatomPlacementMethodEnum.EXACT_COORDINATE.value,
-):
-    if placement_method == AdatomPlacementMethodEnum.EXACT_COORDINATE.value:
-        return AdatomMaterialAnalyzer
-    elif placement_method == AdatomPlacementMethodEnum.NEW_CRYSTAL_SITE.value:
-        return AdatomCrystalSiteMaterialAnalyzer
-    else:
-        raise ValueError(f"Unsupported placement method: {placement_method}")
-
-
-def create_defect_adatom(
-    slab: MaterialWithBuildMetadata,
-    position_on_surface: List[float],
-    distance_z: float = 1.0,
-    placement_method: str = AdatomPlacementMethodEnum.EXACT_COORDINATE.value,
-    element: Optional[str] = None,
-    use_cartesian_coordinates: bool = False,
-) -> Material:
-    """
-    Create an adatom defect based on the specified placement method.
-
-    Args:
-        slab: The slab material.
-        position_on_surface: Position on the surface [x, y].
-        distance_z: Distance above the surface in Angstroms.
-        placement_method: Method to place the adatom.
-        element: Chemical element for the adatom.
-        use_cartesian_coordinates: Whether the position_on_surface is in Cartesian units.
-
-    Returns:
-        Material: The slab with adatom defect.
-    """
-    # Reuse the create_multiple_adatom_defects function below
-    slab_with_adatom = create_multiple_adatom_defects(
-        slab,
-        defect_dicts=[
-            AdatomDefectDict(
-                **{
-                    "element": element or "Si",  # Default to Silicon if no element provided
-                    "coordinate_2d": position_on_surface,
-                    "distance_z": distance_z,
-                    "use_cartesian_coordinates": use_cartesian_coordinates,
-                }
-            )
-        ],
-        placement_method=placement_method,
-    )
-    return slab_with_adatom
-
-
-def create_multiple_adatom_defects(
-    slab: MaterialWithBuildMetadata, defect_dicts: List[AdatomDefectDict], placement_method: str
-) -> Material:
-    """
-    Create multiple adatom defects from a list of AdatomDefectDict.
-
-    Args:
-        slab: The slab material.
-        defect_dicts: List of adatom dictionaries with keys:
-            - element: str (chemical element for the adatom)
-            - coordinate: List[float] (position on surface [x, y])
-            - distance_z: float (distance above surface in Angstroms)
-            - use_cartesian_coordinates: bool (optional, defaults to False)
-                Whether the coordinate is in Cartesian units.
-        placement_method: Method to place all adatoms (common for all defects).
-            Valid values from AtomPlacementMethodEnum:
-                - "exact_coordinate" (default): Places atom at exact coordinate
-                - "new_crystal_site": Places atom at nearest crystal site
-                - "equidistant": Places atom equidistant from nearest atoms
-
-    Returns:
-        Material: The slab with all adatom defects applied.
-    """
-    if placement_method not in [e.value for e in AdatomPlacementMethodEnum]:
-        raise ValueError(f"Unsupported placement method: {placement_method}")
-
-    if not defect_dicts:
-        return slab
-
-    all_adatom_configs = []
-    analyzer_cls = get_adatom_defect_analyzer_cls(placement_method)
-
-    last_analyzer = None
-
-    for defect_dict in defect_dicts:
-        coordinate_2d = defect_dict.coordinate_2d
-        use_cartesian = defect_dict.use_cartesian_coordinates
-
-        if use_cartesian:
-            coordinate_3d = coordinate_2d + [0.0]
-            coordinate_3d_crystal = slab.basis.cell.convert_point_to_crystal(coordinate_3d)
-            coordinate_2d = coordinate_3d_crystal[:2]
-
-        analyzer = analyzer_cls(
-            material=slab,
-            coordinate_2d=coordinate_2d,
-            distance_z=defect_dict.distance_z,
-            placement_method=placement_method,
-            element=defect_dict.element,
-        )
-        last_analyzer = analyzer
-        all_adatom_configs.append(analyzer.added_component)
-
-    if not last_analyzer:
-        return slab
-
-    vacuum_configuration = last_analyzer.get_slab_vacuum_configuration()
-
-    merged_adatoms_component = merge(all_adatom_configs)
-
-    stack_components = [
-        last_analyzer.slab_material_or_configuration_for_stacking,
-        merged_adatoms_component,
-        vacuum_configuration,
-    ]
-    configuration = AdatomDefectConfiguration(stack_components=stack_components)
-
-    builder = AdatomDefectBuilder()
-    return builder.get_material(configuration)

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/adatom/types.py

@@ -1,22 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel, Field
-
-
-class AdatomDefectDict(BaseModel):
-    """
-    Pydantic model for adatom defect configurations used with create_multiple_adatom_defects.
-
-    Required fields:
-        element: Chemical element for the adatom
-        coordinate: Position on surface as [x, y] list
-        distance_z: Distance above surface in Angstroms
-
-    Optional fields:
-        use_cartesian_coordinates: Whether coordinates are in Cartesian units
-    """
-
-    element: str = Field(..., description="Chemical element for the adatom")
-    coordinate_2d: List[float] = Field(..., min_items=2, max_items=2, description="Position on surface as [x, y]")
-    distance_z: float = Field(..., gt=0, description="Distance above surface in Angstroms")
-    use_cartesian_coordinates: bool = False

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/grain_boundary_planar/builder.py

@@ -1,28 +0,0 @@
-from typing import Type
-
-from mat3ra.made.material import Material
-from .configuration import GrainBoundaryPlanarConfiguration
-from ....compound_pristine_structures.two_dimensional.interface import InterfaceBuilder, InterfaceBuilderParameters
-from .....modify import wrap_to_unit_cell
-from .....operations.core.unary import supercell
-
-
-class GrainBoundaryPlanarBuilder(InterfaceBuilder):
-    """
-    Builder for creating grain boundaries.
-
-    Uses InterfaceBuilder to create a Z-stacked interface, then transforms the supercell
-    to flip the Z direction to X direction for grain boundary orientation.
-    """
-
-    _BuildParametersType: Type[InterfaceBuilderParameters] = InterfaceBuilderParameters
-    _DefaultBuildParameters = InterfaceBuilderParameters()
-
-    def _generate(self, configuration: GrainBoundaryPlanarConfiguration) -> Material:
-        interface = super()._generate(configuration)
-        rotated_interface = supercell(interface, [[0, 0, 1], [0, 1, 0], [1, 0, 0]])
-        wrapped_interface = wrap_to_unit_cell(rotated_interface)
-        return wrapped_interface
-
-    def get_name_suffix(self, configuration: GrainBoundaryPlanarConfiguration) -> str:
-        return "Grain Boundary"

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/grain_boundary_planar/configuration.py

@@ -1,55 +0,0 @@
-from typing import List, Optional
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-# fmt: off
-from mat3ra.esse.models.materials_category.defective_structures.two_dimensional. \
-    grain_boundary_planar.configuration import (
-    GrainBoundaryPlanarConfigurationSchema,
-)
-
-from ....compound_pristine_structures.two_dimensional.interface import InterfaceConfiguration
-from ....pristine_structures.two_dimensional.slab_strained_supercell.configuration import \
-    SlabStrainedSupercellConfiguration
-from .....build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import \
-    SlabConfiguration
-
-
-class GrainBoundaryPlanarConfiguration(InterfaceConfiguration, GrainBoundaryPlanarConfigurationSchema):
-    direction: AxisEnum = AxisEnum.z
-
-    @property
-    def phase_1_configuration(self) -> SlabConfiguration:
-        return self.stack_components[0]
-
-    @property
-    def phase_2_configuration(self) -> SlabConfiguration:
-        return self.stack_components[1]
-
-    @property
-    def vacuum_configuration(self) -> VacuumConfiguration:
-        if len(self.stack_components) > 2:
-            return self.stack_components[2]
-        return VacuumConfiguration(
-            size=0.0, crystal=self.film_configuration.atomic_layers.crystal, direction=self.direction
-        )
-
-    @classmethod
-    def from_parameters(
-        cls,
-        phase_1_configuration: SlabStrainedSupercellConfiguration,
-        phase_2_configuration: SlabStrainedSupercellConfiguration,
-        xy_shift: Optional[List[float]] = None,
-        gaps: Optional[List[float]] = None,
-    ) -> "GrainBoundaryPlanarConfiguration":
-        if xy_shift is None:
-            xy_shift = [0.0, 0.0]
-
-        stack_components = [phase_1_configuration, phase_2_configuration]
-        return cls(
-            stack_components=stack_components,
-            direction=AxisEnum.z,
-            xy_shift=xy_shift,
-            gaps=ArrayWithIds.from_values(gaps),
-        )

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/grain_boundary_planar/helpers.py

@@ -1,75 +0,0 @@
-from typing import Optional, List, Tuple, Union
-
-from mat3ra.made.material import Material
-from .builder import GrainBoundaryPlanarBuilder
-from .configuration import GrainBoundaryPlanarConfiguration
-from .....analyze.interface import GrainBoundaryPlanarAnalyzer
-from .....analyze.lattice import get_material_with_conventional_lattice
-from .....build_components import MaterialWithBuildMetadata
-
-
-def create_grain_boundary_planar(
-    phase_1_material: Union[Material, MaterialWithBuildMetadata],
-    phase_2_material: Optional[Material] = None,
-    phase_1_miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    phase_2_miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    phase_1_thickness: int = 1,
-    phase_2_thickness: int = 1,
-    translation_vector: List[float] = [0.0, 0.0],
-    gap: float = 3.0,
-    max_area: float = 50.0,
-    match_id: int = 0,
-    max_area_ratio_tol: float = 0.09,
-    max_length_tol: float = 0.03,
-    max_angle_tol: float = 0.01,
-    use_conventional_cell: bool = True,
-) -> Material:
-    """
-    Create a planar grain boundary between two materials with different orientations.
-
-    Args:
-        phase_1_material: The material to use for each phase of the grain boundary
-        phase_1_miller_indices: Miller indices for phase 1
-        phase_2_miller_indices: Miller indices for phase 2
-        phase_1_thickness: Number of layers for phase 1
-        phase_2_thickness: Number of layers for phase 2
-        translation_vector: Relative shift between phases [x, y, z]
-        gap: Gap between phases in Angstroms
-        match_id: ZSL match ID to use (0 for first match)
-        max_area: Maximum area for ZSL matching
-        max_area_ratio_tol: Area ratio tolerance for ZSL matching
-        max_length_tol: Length tolerance for ZSL matching
-        max_angle_tol: Angle tolerance for ZSL matching
-
-    Returns:
-        Material: The grain boundary material
-    """
-    phase_2_material = phase_2_material or phase_1_material
-    if use_conventional_cell:
-        phase_1_material = get_material_with_conventional_lattice(phase_1_material)
-        phase_2_material = get_material_with_conventional_lattice(phase_2_material)
-
-    analyzer = GrainBoundaryPlanarAnalyzer(
-        phase_1_material=phase_1_material,
-        phase_2_material=phase_2_material,
-        phase_1_miller_indices=phase_1_miller_indices,
-        phase_2_miller_indices=phase_2_miller_indices,
-        phase_1_thickness=phase_1_thickness,
-        phase_2_thickness=phase_2_thickness,
-        max_area=max_area,
-        max_area_ratio_tol=max_area_ratio_tol,
-        max_length_tol=max_length_tol,
-        max_angle_tol=max_angle_tol,
-    )
-
-    strained_config = analyzer.get_grain_boundary_configuration_by_match_id(match_id)
-
-    gb_config = GrainBoundaryPlanarConfiguration.from_parameters(
-        phase_1_configuration=strained_config.substrate_configuration,
-        phase_2_configuration=strained_config.film_configuration,
-        xy_shift=translation_vector,
-        gaps=[gap, gap],
-    )
-
-    builder = GrainBoundaryPlanarBuilder()
-    return builder.get_material(gb_config)

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/island/builder.py

@@ -1,15 +0,0 @@
-from .configuration import IslandDefectConfiguration
-from .....build_components.entities.reusable.two_dimensional.slab_stack.builder import SlabStackBuilder
-
-
-class IslandDefectBuilder(SlabStackBuilder):
-    """
-    Builder for creating island defects by merging a slab with a void site.
-    The void site defines which atoms to remove from the slab.
-    """
-
-    _ConfigurationType = IslandDefectConfiguration
-
-    @property
-    def name_suffix(self) -> str:
-        return "Island"

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/island/configuration.py

@@ -1,16 +0,0 @@
-from mat3ra.esse.models.materials_category.defective_structures.two_dimensional.island.configuration import (
-    IslandDefectConfigurationSchema,
-)
-
-from .....build_components.entities.reusable.two_dimensional.slab_stack.configuration import SlabStackConfiguration
-
-
-class IslandDefectConfiguration(SlabStackConfiguration, IslandDefectConfigurationSchema):
-    """
-    Configuration for creating an island defect on a slab surface.
-
-    Args:
-        stack_components: List containing [slab, isolated_island, vacuum].
-    """
-
-    type: str = "IslandDefectConfiguration"

package/src/py/mat3ra/made/tools/build/defective_structures/two_dimensional/island/helpers.py

@@ -1,116 +0,0 @@
-from typing import Union, TypeVar
-
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-
-from .builder import IslandDefectBuilder
-from .configuration import IslandDefectConfiguration
-from .....analyze.slab import SlabMaterialAnalyzer
-from .....build_components import MaterialWithBuildMetadata
-from .....build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-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.entities.reusable.zero_dimensional.coordinates_shape_enum import CoordinatesShapeEnum
-from .....entities.coordinate import (
-    CoordinateCondition,
-    CylinderCoordinateCondition,
-    SphereCoordinateCondition,
-    BoxCoordinateCondition,
-    TriangularPrismCoordinateCondition,
-    PlaneCoordinateCondition,
-)
-from .....modify import filter_by_condition_on_coordinates
-
-CoordinateConditionType = TypeVar("CoordinateConditionType", bound=CoordinateCondition)
-
-
-def create_defect_island(
-    slab: MaterialWithBuildMetadata,
-    condition: Union[
-        CylinderCoordinateCondition,
-        SphereCoordinateCondition,
-        BoxCoordinateCondition,
-        TriangularPrismCoordinateCondition,
-        PlaneCoordinateCondition,
-        CoordinateConditionType,
-    ] = CylinderCoordinateCondition(),
-    use_cartesian_coordinates: bool = True,
-    number_of_added_layers: Union[int, float] = 1,
-) -> MaterialWithBuildMetadata:
-    """
-    Create an island defect using the new IslandDefectConfiguration and IslandDefectBuilder.
-
-    Args:
-        slab: The slab material.
-        condition: The coordinate condition that defines the island shape.
-        number_of_added_layers: Number of additional layers to add to the slab, from which the island will be created.
-
-    Returns:
-        Material: The slab with island defect.
-    """
-
-    material_with_additional_layers = recreate_slab_with_fractional_layers(slab, number_of_added_layers)
-
-    isolated_island = filter_by_condition_on_coordinates(
-        material=material_with_additional_layers,
-        condition=condition.condition,
-        use_cartesian_coordinates=use_cartesian_coordinates,
-    )
-
-    # Create the island defect using IslandDefectBuilder
-    analyzer = SlabMaterialAnalyzer(material=slab)
-    slab_without_vacuum_configuration = analyzer.slab_configuration_with_no_vacuum
-    slab_build_parameters = analyzer.build_parameters
-
-    new_slab = SlabBuilder(build_parameters=slab_build_parameters).get_material(slab_without_vacuum_configuration)
-
-    original_vacuum_config = analyzer.get_slab_vacuum_configuration()
-    vacuum_config = VacuumConfiguration(
-        size=original_vacuum_config.size, crystal=new_slab, direction=original_vacuum_config.direction
-    )
-
-    island_config = IslandDefectConfiguration(
-        stack_components=[new_slab, isolated_island, vacuum_config], direction=AxisEnum.z
-    )
-
-    island_builder = IslandDefectBuilder()
-    return island_builder.get_material(island_config)
-
-
-def get_coordinate_condition(shape: CoordinatesShapeEnum, dict_params: dict):
-    """
-    Returns the appropriate coordinate condition based on the shape provided.
-
-    Args:
-        shape (CoordinatesShapeEnum): Shape of the island (e.g., cylinder, box, etc.).
-        dict_params (dict): Parameters for the shape condition.
-
-    Returns:
-        CoordinateCondition: The appropriate condition object.
-    """
-    if shape == "cylinder":
-        return CylinderCoordinateCondition(
-            center_position=dict_params.get("center_position", [0.5, 0.5]),
-            radius=dict_params["radius"],
-            min_z=dict_params["min_z"],
-            max_z=dict_params["max_z"],
-        )
-    elif shape == "sphere":
-        return SphereCoordinateCondition(
-            center_coordinate=dict_params.get("center_coordinate", [0.5, 0.5, 0.5]), radius=dict_params["radius"]
-        )
-    elif shape == "box":
-        return BoxCoordinateCondition(
-            min_coordinate=dict_params["min_coordinate"], max_coordinate=dict_params["max_coordinate"]
-        )
-    elif shape == "triangular_prism":
-        return TriangularPrismCoordinateCondition(
-            position_on_surface_1=dict_params["position_on_surface_1"],
-            position_on_surface_2=dict_params["position_on_surface_2"],
-            position_on_surface_3=dict_params["position_on_surface_3"],
-            min_z=dict_params["min_z"],
-            max_z=dict_params["max_z"],
-        )
-    else:
-        raise ValueError(f"Unsupported island shape: {shape}")