@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/commensurate/helpers.py

@@ -1,157 +0,0 @@
-from typing import List, Optional, Tuple, Union
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-
-from mat3ra.made.material import Material
-from .. import InterfaceBuilder, InterfaceConfiguration
-from ......build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from .....pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
-    SlabStrainedSupercellConfiguration,
-)
-from ......analyze.interface import CommensurateLatticeInterfaceAnalyzer
-from ......analyze.lattice import get_material_with_conventional_lattice
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
-from ......build_components.metadata import MaterialWithBuildMetadata
-
-
-def get_commensurate_strained_configurations(
-    material: Union[Material, MaterialWithBuildMetadata],
-    target_angle: float,
-    angle_tolerance: float,
-    max_repetition_int: Optional[int],
-    limit_max_int: int,
-    return_first_match: bool,
-    miller_indices: Tuple[int, int, int],
-    number_of_layers: int,
-    vacuum: float,
-    match_id: int = 0,
-    use_conventional_cell: bool = True,
-) -> Tuple[List[SlabStrainedSupercellConfiguration], float]:
-    """
-    Get strained configurations for commensurate lattice matching.
-
-    This function creates strained configurations for both substrate and film phases
-    based on commensurate lattice matching at a specified twist angle.
-
-    Args:
-        material (Material): The material to create configurations from.
-        target_angle (float): The target twist angle in degrees.
-        angle_tolerance (float): Tolerance for matching angles in degrees.
-        max_repetition_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): Whether to return the first match or all matches.
-        miller_indices (Tuple[int, int, int]): Miller indices for the slab surface.
-        number_of_layers (int): Number of atomic layers in the slab.
-        vacuum (float): Size of the vacuum layer in Angstroms.
-        match_id (int): ID of the match to use (0 for first match).
-
-    Returns:
-        Tuple[List[SlabStrainedSupercellConfiguration], float]:
-            List of strained configurations [substrate, film] and the actual angle.
-
-    Raises:
-        ValueError: If no commensurate lattice matches are found.
-    """
-    if use_conventional_cell:
-        material = get_material_with_conventional_lattice(material)
-
-    slab_config = SlabConfiguration.from_parameters(
-        material_or_dict=material,
-        miller_indices=miller_indices,
-        number_of_layers=number_of_layers,
-        vacuum=vacuum,
-    )
-
-    analyzer = CommensurateLatticeInterfaceAnalyzer(
-        substrate_slab_configuration=slab_config,
-        target_angle=target_angle,
-        angle_tolerance=angle_tolerance,
-        max_supercell_matrix_int=max_repetition_int,
-        limit_max_int=limit_max_int,
-        return_first_match=return_first_match,
-    )
-
-    match_holders = analyzer.commensurate_lattice_match_holders
-    if not match_holders:
-        raise ValueError(f"No commensurate lattice matches found for angle {target_angle}°")
-
-    selected_config = analyzer.get_strained_configuration_by_match_id(match_id)
-    actual_angle = match_holders[match_id].actual_angle
-    return [selected_config.substrate_configuration, selected_config.film_configuration], actual_angle
-
-
-def create_interface_commensurate(
-    material: Union[Material, MaterialWithBuildMetadata],
-    target_angle: float = 0.0,
-    angle_tolerance: float = 0.1,
-    max_repetition_int: Optional[int] = None,
-    limit_max_int: int = 20,
-    return_first_match: bool = True,
-    direction: AxisEnum = AxisEnum.z,
-    gap: float = 3.0,
-    miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    number_of_layers: int = 1,
-    vacuum: float = 0.0,
-    match_id: int = 0,
-    use_conventional_cell: bool = True,
-    remove_overlapping_atoms: bool = True,
-    tolerance_for_overlap: float = 1.0,
-) -> MaterialWithBuildMetadata:
-    """
-    Create a commensurate lattice interface (twisted interface) from a material with specified twist angle.
-
-    This function creates a commensurate interface by:
-    1. Creating a slab configuration from the material
-    2. Finding commensurate lattice matches at the target angle using CommensurateLatticeInterfaceAnalyzer
-    3. Creating strained configurations with directional gaps for both phases
-    4. Stacking them along the specified direction
-
-    Args:
-        material (Material): The material to create the interface from.
-        target_angle (float): The target twist angle in degrees.
-        angle_tolerance (float): Tolerance for matching angles in degrees.
-        max_repetition_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): Whether to return the first match or all matches.
-        direction (AxisEnum): Direction along which to stack components (x, y, or z).
-        gap (float): The gap between the two phases in Angstroms.
-        miller_indices (Tuple[int, int, int]): Miller indices for the slab surface.
-        number_of_layers (int): Number of atomic layers in the slab.
-        vacuum (float): Size of the vacuum layer in Angstroms.
-        match_id (int): ID of the match to use (0 for first match).
-        use_conventional_cell (bool): Whether to use the conventional cell for the material.
-        remove_overlapping_atoms (bool): Whether to resolve overlapping atoms in the interface after creation.
-        tolerance_for_overlap (float): Tolerance for resolving overlapping atoms, in Angstroms.
-    Returns:
-        Material: The commensurate interface material.
-
-    Raises:
-        ValueError: If no commensurate lattice matches are found.
-    """
-    strained_configs, _ = get_commensurate_strained_configurations(
-        material=material,
-        target_angle=target_angle,
-        angle_tolerance=angle_tolerance,
-        max_repetition_int=max_repetition_int,
-        limit_max_int=limit_max_int,
-        return_first_match=return_first_match,
-        miller_indices=miller_indices,
-        number_of_layers=number_of_layers,
-        vacuum=vacuum,
-        match_id=match_id,
-        use_conventional_cell=use_conventional_cell,
-    )
-
-    vacuum_config = VacuumConfiguration(size=vacuum, crystal=None, direction=direction)
-    interface_config = InterfaceConfiguration(
-        stack_components=strained_configs + [vacuum_config],
-        gaps=ArrayWithIds.from_values([gap, gap]),
-        direction=direction,
-    )
-
-    builder = InterfaceBuilder()
-    interface = builder.get_material(interface_config)
-    if remove_overlapping_atoms:
-        interface.basis.resolve_colliding_coordinates(tolerance=tolerance_for_overlap)
-    return interface

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/enums.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class StrainModes(str, Enum):
-    strain = "strain"
-    von_mises_strain = "von_mises_strain"
-    mean_abs_strain = "mean_abs_strain"

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/twisted/__init__.py

@@ -1,7 +0,0 @@
-from .configuration import TwistedNanoribbonsInterfaceConfiguration
-from .helpers import create_interface_twisted
-
-__all__ = [
-    "TwistedNanoribbonsInterfaceConfiguration",
-    "create_interface_twisted",
-]

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/twisted/configuration.py

@@ -1,13 +0,0 @@
-from ..base.configuration import InterfaceConfiguration
-
-
-class TwistedNanoribbonsInterfaceConfiguration(InterfaceConfiguration):
-    """
-    Configuration for creating a twisted interface between two nanoribbons with specified twist angle.
-
-    Args:
-        stack_components (List[SlabConfiguration]): List of two nanoribbons as slab configurations.
-        angle (float): Twist angle in degrees for provenance.
-    """
-
-    angle: float = 0.0

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/twisted/helpers.py

@@ -1,70 +0,0 @@
-from typing import Union
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-
-from mat3ra.made.material import Material
-from .. import InterfaceBuilder, InterfaceConfiguration
-from ......analyze.interface import TwistedNanoribbonsInterfaceAnalyzer
-from ......analyze.lattice import get_material_with_conventional_lattice
-from ......build_components import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
-
-
-def create_interface_twisted(
-    material1: Union[Material, MaterialWithBuildMetadata],
-    material2: Union[Material, MaterialWithBuildMetadata],
-    angle: float = 0.0,
-    vacuum_x: float = 5.0,
-    vacuum_y: float = 5.0,
-    gap: float = 3.0,
-    use_conventional_cell: bool = False,
-) -> MaterialWithBuildMetadata:
-    """
-    Create a twisted interface between two nanoribbons.
-
-    Args:
-        material1 (Material): First nanoribbon material.
-        material2 (Material): Second nanoribbon material.
-        angle (float): Twist angle in degrees.
-        vacuum_x (float): Vacuum along x on both sides, in Angstroms.
-        vacuum_y (float): Vacuum along y on both sides, in Angstroms.
-        gap (float): Gap between the nanoribbons in Angstroms.
-
-    Returns:
-        Material: The twisted interface material.
-    """
-    if use_conventional_cell:
-        material1 = get_material_with_conventional_lattice(material1)
-        material2 = get_material_with_conventional_lattice(material2)
-    slab1 = SlabConfiguration.from_parameters(
-        material_or_dict=material1,
-        miller_indices=(0, 0, 1),
-        number_of_layers=1,
-        vacuum=0.0,
-        use_conventional_cell=use_conventional_cell,
-    )
-    slab2 = SlabConfiguration.from_parameters(
-        material_or_dict=material2,
-        miller_indices=(0, 0, 1),
-        number_of_layers=1,
-        vacuum=0.0,
-        use_conventional_cell=use_conventional_cell,
-    )
-    analyzer = TwistedNanoribbonsInterfaceAnalyzer(
-        substrate_slab_configuration=slab1,
-        film_slab_configuration=slab2,
-        angle=angle,
-        vacuum_x=vacuum_x,
-        vacuum_y=vacuum_y,
-    )
-    processed_slab1 = analyzer.substrate_nanoribbon_configuration
-    processed_slab2 = analyzer.film_nanoribbon_configuration
-
-    configuration = InterfaceConfiguration(
-        stack_components=[processed_slab1, processed_slab2],
-        gaps=ArrayWithIds.from_values([gap, gap]),
-        direction=AxisEnum.z,
-    )
-    builder = InterfaceBuilder()
-    return builder.get_material(configuration)

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/utils.py

@@ -1,87 +0,0 @@
-from typing import List, Tuple, Union
-
-import numpy as np
-
-from mat3ra.made.material import Material
-from .enums import StrainModes
-from .....build_components import MaterialWithBuildMetadata
-from .....convert.interface_parts_enum import INTERFACE_LABELS_MAP
-from .....modify import interface_displace_part, filter_by_label
-from .....optimize import evaluate_calculator_on_xy_grid
-from .....third_party import PymatgenInterface
-
-
-def remove_duplicate_interfaces(
-    interfaces: List[PymatgenInterface], strain_mode: StrainModes = StrainModes.mean_abs_strain
-):
-    def are_interfaces_duplicate(interface1: PymatgenInterface, interface2: PymatgenInterface):
-        are_sizes_equivalent = interface1.num_sites == interface2.num_sites and np.allclose(
-            interface1.interface_properties[strain_mode], interface2.interface_properties[strain_mode]
-        )
-        are_strains_equivalent = np.allclose(
-            interface1.interface_properties[strain_mode], interface2.interface_properties[strain_mode]
-        )
-        return are_sizes_equivalent and are_strains_equivalent
-
-    filtered_interfaces = [interfaces[0]] if interfaces else []
-
-    for interface in interfaces[1:]:
-        if not any(are_interfaces_duplicate(interface, unique_interface) for unique_interface in filtered_interfaces):
-            filtered_interfaces.append(interface)
-    return filtered_interfaces
-
-
-def get_slab(interface: Material, part: str = "film"):
-    try:
-        return filter_by_label(interface, INTERFACE_LABELS_MAP[part])
-    except ValueError:
-        raise ValueError(f"Material does not contain label for {part}.")
-
-
-def get_optimal_film_displacement(
-    material: Union[Material, MaterialWithBuildMetadata],
-    calculator,
-    grid_size_xy: Tuple[int, int] = (10, 10),
-    grid_offset_position: List[float] = [0, 0],
-    grid_range_x=(-0.5, 0.5),
-    grid_range_y=(-0.5, 0.5),
-    use_cartesian_coordinates=False,
-):
-    """
-    Calculate the optimal displacement in of the film to minimize the interaction energy
-        between the film and the substrate. The displacement is calculated on a grid.
-
-    This function evaluates the interaction energy between the film and substrate
-    over a specified grid of (x,y) displacements. It returns the displacement vector that
-    results in the minimum interaction energy.
-
-    Args:
-        material (Material): The interface Material object.
-        grid_size_xy (Tuple[int, int]): The size of the grid to search for the optimal displacement.
-        grid_offset_position (List[float]): The offset position of the grid.
-        grid_range_x (Tuple[float, float]): The range of the grid in x.
-        grid_range_y (Tuple[float, float]): The range of the grid in y.
-        use_cartesian_coordinates (bool): Whether to use Cartesian coordinates.
-        calculator: The calculator to use for the calculation of the interaction energy.
-
-    Returns:
-        List[float]: The optimal displacement vector.
-
-    """
-    xy_matrix, results_matrix = evaluate_calculator_on_xy_grid(
-        material=material,
-        calculator_function=calculator.get_energy,
-        modifier=interface_displace_part,
-        modifier_parameters={},
-        grid_size_xy=grid_size_xy,
-        grid_offset_position=grid_offset_position,
-        grid_range_x=grid_range_x,
-        grid_range_y=grid_range_y,
-        use_cartesian_coordinates=use_cartesian_coordinates,
-    )
-    min_index = np.unravel_index(np.argmin(results_matrix), results_matrix.shape)
-
-    optimal_x = xy_matrix[0][min_index[0]]
-    optimal_y = xy_matrix[1][min_index[1]]
-
-    return [optimal_x, optimal_y, 0]

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/zsl/__init__.py

@@ -1,6 +0,0 @@
-from .helpers import create_interface_zsl, create_interface_zsl_between_slabs
-
-__all__ = [
-    "create_interface_zsl",
-    "create_interface_zsl_between_slabs",
-]

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/interface/zsl/helpers.py

@@ -1,129 +0,0 @@
-from typing import List, Optional, Tuple, Union
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-
-from mat3ra.made.material import Material
-from ......analyze.interface import ZSLInterfaceAnalyzer
-from ......analyze.lattice import get_material_with_conventional_lattice
-from ......analyze.slab import SlabMaterialAnalyzer
-from ......build.compound_pristine_structures.two_dimensional.interface import (
-    InterfaceBuilderParameters,
-    InterfaceBuilder,
-    InterfaceConfiguration,
-)
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.helpers import create_slab
-from ......build_components import MaterialWithBuildMetadata
-from ......build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-
-
-def create_interface_zsl(
-    substrate_crystal: Union[Material, MaterialWithBuildMetadata],
-    film_crystal: Union[Material, MaterialWithBuildMetadata],
-    substrate_miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    film_miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    substrate_number_of_layers: int = 1,
-    film_number_of_layers: int = 1,
-    substrate_termination_formula: Optional[str] = None,
-    film_termination_formula: Optional[str] = None,
-    gap: Optional[float] = None,
-    vacuum: float = 10.0,
-    xy_shift: List[float] = [0, 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,
-    reduce_result_cell: bool = True,
-    reduce_result_cell_to_primitive: bool = False,
-) -> MaterialWithBuildMetadata:
-    if use_conventional_cell:
-        substrate_crystal = get_material_with_conventional_lattice(substrate_crystal)
-        film_crystal = get_material_with_conventional_lattice(film_crystal)
-
-    substrate_slab = create_slab(
-        crystal=substrate_crystal,
-        miller_indices=substrate_miller_indices,
-        number_of_layers=substrate_number_of_layers,
-        vacuum=0,
-        termination_bottom_formula=substrate_termination_formula,
-        use_conventional_cell=use_conventional_cell,
-    )
-    film_slab = create_slab(
-        crystal=film_crystal,
-        miller_indices=film_miller_indices,
-        number_of_layers=film_number_of_layers,
-        vacuum=0,
-        termination_top_formula=film_termination_formula,
-        use_conventional_cell=use_conventional_cell,
-    )
-
-    return create_interface_zsl_between_slabs(
-        substrate_slab=substrate_slab,
-        film_slab=film_slab,
-        gap=gap,
-        vacuum=vacuum,
-        xy_shift=xy_shift,
-        max_area=max_area,
-        max_area_ratio_tol=max_area_ratio_tol,
-        max_length_tol=max_length_tol,
-        max_angle_tol=max_angle_tol,
-        match_id=match_id,
-        reduce_result_cell=reduce_result_cell,
-        reduce_result_cell_to_primitive=reduce_result_cell_to_primitive,
-    )
-
-
-def create_interface_zsl_between_slabs(
-    substrate_slab: MaterialWithBuildMetadata,
-    film_slab: MaterialWithBuildMetadata,
-    gap: Optional[float] = None,
-    vacuum: float = 10.0,
-    xy_shift: Optional[List[float]] = None,
-    max_area: float = 200.0,
-    max_area_ratio_tol: float = 0.1,
-    max_length_tol: float = 0.03,
-    max_angle_tol: float = 0.01,
-    match_id: int = 0,
-    reduce_result_cell: bool = True,
-    reduce_result_cell_to_primitive: bool = False,
-) -> MaterialWithBuildMetadata:
-    if xy_shift is None:
-        xy_shift = [0, 0]
-
-    substrate_slab_config = SlabMaterialAnalyzer(material=substrate_slab).build_configuration
-    film_slab_config = SlabMaterialAnalyzer(material=film_slab).build_configuration
-
-    analyzer = ZSLInterfaceAnalyzer(
-        substrate_slab_configuration=substrate_slab_config,
-        film_slab_configuration=film_slab_config,
-        max_area=max_area,
-        max_area_ratio_tol=max_area_ratio_tol,
-        max_length_tol=max_length_tol,
-        max_angle_tol=max_angle_tol,
-        reduce_result_cell=reduce_result_cell,
-    )
-
-    interface_configurations = analyzer.get_strained_configurations()
-    if not interface_configurations:
-        raise ValueError("No ZSL match found for the given parameters.")
-
-    if match_id >= len(interface_configurations):
-        raise IndexError(f"match_id {match_id} is out of bounds for {len(interface_configurations)} matches found.")
-
-    selected_config = interface_configurations[match_id]
-
-    vacuum_configuration = VacuumConfiguration(size=vacuum)
-    stack_components = [
-        selected_config.substrate_configuration,
-        selected_config.film_configuration,
-        vacuum_configuration,
-    ]
-
-    interface_config = InterfaceConfiguration(
-        stack_components=stack_components, gaps=ArrayWithIds.from_values([gap, gap]), xy_shift=xy_shift
-    )
-    builder = InterfaceBuilder(
-        build_parameters=InterfaceBuilderParameters(make_primitive=reduce_result_cell_to_primitive)
-    )
-    return builder.get_material(interface_config)

package/src/py/mat3ra/made/tools/build/defective_structures/one_dimensional/grain_boundary_linear/build_parameters.py

@@ -1,12 +0,0 @@
-from typing import Optional
-
-from ....compound_pristine_structures.two_dimensional.interface import InterfaceBuilderParameters
-
-
-class GrainBoundaryLinearBuilderParameters(InterfaceBuilderParameters):
-    max_supercell_matrix_int: Optional[int] = None
-    limit_max_int: Optional[int] = 30
-    angle_tolerance: float = 0.1
-    return_first_match: bool = False
-    edge_inclusion_tolerance: float = 1.0
-    distance_tolerance: float = 1.0

package/src/py/mat3ra/made/tools/build/defective_structures/one_dimensional/grain_boundary_linear/builder.py

@@ -1,17 +0,0 @@
-from .build_parameters import GrainBoundaryLinearBuilderParameters
-from .configuration import GrainBoundaryLinearConfiguration
-from ....compound_pristine_structures.two_dimensional.interface import InterfaceBuilder
-
-
-class GrainBoundaryLinearBuilder(InterfaceBuilder):
-    """
-    Creates a linear grain boundary by stacking two materials along x or y direction.
-    """
-
-    _ConfigurationType = GrainBoundaryLinearConfiguration
-    _BuildParametersType = GrainBoundaryLinearBuilderParameters
-    _DefaultBuildParameters = GrainBoundaryLinearBuilderParameters()
-
-    def get_name_suffix(self, configuration: GrainBoundaryLinearConfiguration) -> str:
-        angle_str = f"{configuration.actual_angle:.2f} degrees" if configuration.actual_angle is not None else ""
-        return f"Linear Grain Boundary, {angle_str}"

package/src/py/mat3ra/made/tools/build/defective_structures/one_dimensional/grain_boundary_linear/configuration.py

@@ -1,40 +0,0 @@
-from typing import Optional
-
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-# fmt: off
-from mat3ra.esse.models.materials_category.defective_structures.one_dimensional. \
-    grain_boundary_linear.configuration import GrainBoundaryLinearConfigurationSchema
-
-# fmt: on
-from ....compound_pristine_structures.two_dimensional.interface import InterfaceConfiguration
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.configuration import SlabConfiguration
-
-
-class GrainBoundaryLinearConfiguration(InterfaceConfiguration, GrainBoundaryLinearConfigurationSchema):
-    """
-    Configuration for creating a linear grain boundary.
-
-    Args:
-        stack_components (: of configuration objects for grain boundary components.
-        direction (AxisEnum): Direction along which to stack components (x or y).
-    """
-
-    type: str = "GrainBoundaryLinearConfiguration"
-    direction: AxisEnum = AxisEnum.x
-    actual_angle: Optional[float] = None
-
-    @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 substrate_configuration(self) -> SlabConfiguration:
-        return self.phase_1_configuration
-
-    @property
-    def film_configuration(self) -> SlabConfiguration:
-        return self.phase_2_configuration

package/src/py/mat3ra/made/tools/build/defective_structures/one_dimensional/grain_boundary_linear/helpers.py

@@ -1,82 +0,0 @@
-from typing import Optional, Tuple, Union
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-
-from mat3ra.made.material import Material
-from .builder import GrainBoundaryLinearBuilder
-from .configuration import GrainBoundaryLinearConfiguration
-from ....compound_pristine_structures.two_dimensional.interface import get_commensurate_strained_configurations
-from .....analyze.lattice import get_material_with_conventional_lattice
-from .....build_components import MaterialWithBuildMetadata
-
-
-def create_grain_boundary_linear(
-    material: Union[Material, MaterialWithBuildMetadata],
-    target_angle: float = 0.0,
-    angle_tolerance: float = 0.1,
-    max_repetition_int: Optional[int] = None,
-    limit_max_int: int = 20,
-    return_first_match: bool = True,
-    direction: AxisEnum = AxisEnum.x,
-    gap: float = 3.0,
-    miller_indices: Tuple[int, int, int] = (0, 0, 1),
-    number_of_layers: int = 1,
-    vacuum: float = 0.0,
-    use_conventional_cell: bool = True,
-) -> Material:
-    """
-    Create a linear grain boundary from a material with specified twist angle.
-
-    This function creates a grain boundary by:
-    1. Creating a slab configuration from the material
-    2. Finding commensurate lattice matches at the target angle using CommensurateLatticeInterfaceAnalyzer
-    3. Creating strained configurations with directional gaps for both phases
-    4. Stacking them along the specified direction
-
-    Args:
-        material (Material): The material to create the grain boundary from.
-        target_angle (float): The target twist angle in degrees.
-        angle_tolerance (float): Tolerance for matching angles in degrees.
-        max_repetition_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): Whether to return the first match or all matches.
-        direction (AxisEnum): Direction along which to stack components (x or y).
-        gap (float): The gap between the two phases in Angstroms.
-        miller_indices (Tuple[int, int, int]): Miller indices for the slab surface.
-        number_of_layers (int): Number of atomic layers in the slab.
-        vacuum (float): Size of the vacuum layer in Angstroms.
-
-    Returns:
-        Material: The grain boundary material.
-
-    Raises:
-        ValueError: If no commensurate lattice matches are found.
-    """
-    if use_conventional_cell:
-        material = get_material_with_conventional_lattice(material)
-
-    strained_configs, actual_angle = get_commensurate_strained_configurations(
-        material=material,
-        target_angle=target_angle,
-        angle_tolerance=angle_tolerance,
-        max_repetition_int=max_repetition_int,
-        limit_max_int=limit_max_int,
-        return_first_match=return_first_match,
-        miller_indices=miller_indices,
-        number_of_layers=number_of_layers,
-        vacuum=vacuum,
-        use_conventional_cell=use_conventional_cell,
-    )
-
-    grain_boundary_config = GrainBoundaryLinearConfiguration(
-        stack_components=strained_configs,
-        direction=direction,
-        gaps=ArrayWithIds.from_values([gap, gap]),
-        actual_angle=actual_angle,
-    )
-
-    builder = GrainBoundaryLinearBuilder()
-    grain_boundary = builder.get_material(grain_boundary_config)
-
-    return grain_boundary

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/__init__.py

@@ -1 +0,0 @@
-

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

@@ -1,9 +0,0 @@
-from .builder import SolidSolutionBuilder
-from .configuration import SolidSolutionConfiguration
-from .enums import SiteSelectionMethodEnum
-
-__all__ = [
-    "SiteSelectionMethodEnum",
-    "SolidSolutionBuilder",
-    "SolidSolutionConfiguration",
-]