@mat3ra/made 2026.8.7-0 → 2026.8.18-0

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

@@ -1,59 +0,0 @@
-from typing import List
-
-from .types import StackComponentDict
-from .utils import (
-    apply_gaps_and_stack,
-    create_initial_slabs,
-    create_strained_films,
-    create_strained_substrate,
-    find_common_supercell_matrix,
-    validate_heterostructure_inputs,
-)
-from .....analyze import BaseMaterialAnalyzer
-from .....build_components import MaterialWithBuildMetadata
-
-
-def create_heterostructure(
-    stack_component_dicts: List[StackComponentDict],
-    gaps: List[float],
-    vacuum: float = 10.0,
-    use_conventional_cell: bool = True,
-    optimize_layer_supercells: bool = True,
-) -> MaterialWithBuildMetadata:
-    """
-    Create a heterostructure by stacking multiple slabs, while applying strain to each slab relative to the first slab.
-    Args:
-        stack_component_dicts: List of stack component configurations
-        gaps: List of gaps between adjacent slabs (in Angstroms)
-        vacuum: Size of vacuum layer over the last slab (in Angstroms)
-        use_conventional_cell: Whether to use conventional cell
-        optimize_layer_supercells: Whether to find optimal supercells for strained layers
-    Returns:
-        Heterostructure material with stacked strained slabs
-    """
-    validate_heterostructure_inputs(stack_component_dicts, gaps)
-
-    slabs = create_initial_slabs(stack_component_dicts, vacuum, use_conventional_cell)
-    common_supercell_matrix = find_common_supercell_matrix(slabs, optimize_layer_supercells)
-
-    strained_substrate = create_strained_substrate(slabs[0], common_supercell_matrix)
-    strained_films = create_strained_films(slabs, common_supercell_matrix, optimize_layer_supercells)
-
-    strained_slabs = [strained_substrate] + strained_films
-    heterostructure = apply_gaps_and_stack(strained_slabs, gaps)
-    heterostructure.name = generate_heterostructure_name(stack_component_dicts)
-
-    return heterostructure
-
-
-def generate_heterostructure_name(stack_component_dicts: List[StackComponentDict]):
-    """Generate a descriptive name for the heterostructure."""
-
-    components = []
-    for component in stack_component_dicts:
-        analyzer = BaseMaterialAnalyzer(material=component.crystal)
-        formula = analyzer.formula
-        miller_str = "".join(map(str, component.miller_indices))
-        components.append(f"{formula}({miller_str})")
-
-    return f"Heterostructure [{'-'.join(components)}]"

package/src/py/mat3ra/made/tools/build/compound_pristine_structures/two_dimensional/heterostructure/types.py

@@ -1,26 +0,0 @@
-from typing import List, Optional, Tuple, Union
-
-from mat3ra.code.entity import InMemoryEntityPydantic
-from pydantic import Field
-
-from mat3ra.made.material import Material
-from .....build_components import MaterialWithBuildMetadata
-
-
-class StackComponentDict(InMemoryEntityPydantic):
-    """
-    Pydantic model for heterostructure stack component configurations.
-
-    Required fields:
-        crystal: The crystal material to create a slab from
-        miller_indices: Miller indices for the slab surface as (h, k, l)
-        thickness: Number of layers in the slab
-
-    Optional fields:
-        xy_supercell_matrix: Optional supercell matrix for the xy plane
-    """
-
-    crystal: Union[Material, MaterialWithBuildMetadata] = Field(..., description="Crystal material for the slab")
-    miller_indices: Tuple[int, int, int] = Field(..., description="Miller indices for the slab surface")
-    thickness: int = Field(..., gt=0, description="Number of layers in the slab")
-    xy_supercell_matrix: Optional[List[List[int]]] = Field(None, description="Optional xy supercell matrix")

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

@@ -1,139 +0,0 @@
-from typing import List
-
-import numpy as np
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.esse.models.materials_category_components.entities.auxiliary.two_dimensional.supercell_matrix_2d import (
-    SupercellMatrix2DSchema,
-)
-
-from .types import StackComponentDict
-from mat3ra.made.utils import adjust_material_cell_to_set_gap_along_direction
-from ....pristine_structures.two_dimensional.slab.helpers import create_slab
-from ....pristine_structures.two_dimensional.slab_strained_supercell.builder import SlabStrainedSupercellBuilder
-from ....pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
-    SlabStrainedSupercellConfiguration,
-)
-from .....analyze.interface import InterfaceAnalyzer
-from .....analyze.slab import SlabMaterialAnalyzer
-from .....build_components import MaterialWithBuildMetadata
-from .....operations.core.binary import stack
-
-
-def validate_heterostructure_inputs(stack_component_dicts: List[StackComponentDict], gaps: List[float]) -> None:
-    """Validate inputs for heterostructure creation."""
-    if len(stack_component_dicts) < 2:
-        raise ValueError("At least 2 stack components are required for a heterostructure")
-    if len(gaps) != len(stack_component_dicts) - 1:
-        raise ValueError("Number of gaps must be one less than number of stack components")
-
-
-def create_initial_slabs(
-    stack_component_dicts: List[StackComponentDict], vacuum: float, use_conventional_cell: bool
-) -> List[MaterialWithBuildMetadata]:
-    """Create initial slabs from stack components."""
-    slabs = []
-    for i, component in enumerate(stack_component_dicts):
-        slab = create_slab(
-            crystal=component.crystal,
-            miller_indices=component.miller_indices,
-            number_of_layers=component.thickness,
-            vacuum=0.0 if i < len(stack_component_dicts) - 1 else vacuum,
-            use_conventional_cell=use_conventional_cell,
-            xy_supercell_matrix=component.xy_supercell_matrix or [[1, 0], [0, 1]],
-        )
-        slabs.append(slab)
-    return slabs
-
-
-def find_common_supercell_matrix(
-    slabs: List[MaterialWithBuildMetadata], optimize_layer_supercells: bool
-) -> SupercellMatrix2DSchema:
-    """Find common supercell matrix for all materials."""
-    reference_substrate = slabs[0]
-
-    for i in range(1, len(slabs)):
-        film_slab = slabs[i]
-
-        substrate_analyzer = SlabMaterialAnalyzer(material=reference_substrate)
-        film_analyzer = SlabMaterialAnalyzer(material=film_slab)
-
-        analyzer = InterfaceAnalyzer(
-            substrate_slab_configuration=substrate_analyzer.build_configuration,
-            film_slab_configuration=film_analyzer.build_configuration,
-            substrate_build_parameters=substrate_analyzer.build_parameters,
-            film_build_parameters=film_analyzer.build_parameters,
-            optimize_film_supercell=optimize_layer_supercells,
-        )
-        analyzer.__dict__["substrate_material"] = reference_substrate
-        analyzer.__dict__["film_material"] = film_slab
-
-        return analyzer.film_strained_configuration.xy_supercell_matrix
-
-
-def create_strained_substrate(
-    reference_substrate: MaterialWithBuildMetadata, common_supercell_matrix: SupercellMatrix2DSchema
-) -> MaterialWithBuildMetadata:
-    """Create strained substrate with common supercell."""
-    substrate_analyzer = SlabMaterialAnalyzer(material=reference_substrate)
-
-    substrate_config = SlabStrainedSupercellConfiguration(
-        **substrate_analyzer.build_configuration.model_dump(),
-        strain_matrix=Matrix3x3Schema(root=np.eye(3).tolist()),
-        xy_supercell_matrix=common_supercell_matrix,
-    )
-
-    builder = SlabStrainedSupercellBuilder()
-    return builder.get_material(substrate_config)
-
-
-def create_strained_films(
-    slabs: List[MaterialWithBuildMetadata],
-    common_supercell_matrix: SupercellMatrix2DSchema,
-    optimize_layer_supercells: bool,
-) -> List[MaterialWithBuildMetadata]:
-    """Create strained films with common supercell."""
-    reference_substrate = slabs[0]
-    strained_films = []
-    builder = SlabStrainedSupercellBuilder()
-
-    for i in range(1, len(slabs)):
-        film_slab = slabs[i]
-
-        substrate_analyzer = SlabMaterialAnalyzer(material=reference_substrate)
-        film_analyzer = SlabMaterialAnalyzer(material=film_slab)
-
-        analyzer = InterfaceAnalyzer(
-            substrate_slab_configuration=substrate_analyzer.build_configuration,
-            film_slab_configuration=film_analyzer.build_configuration,
-            substrate_build_parameters=substrate_analyzer.build_parameters,
-            film_build_parameters=film_analyzer.build_parameters,
-            optimize_film_supercell=optimize_layer_supercells,
-        )
-        analyzer.__dict__["substrate_material"] = reference_substrate
-        analyzer.__dict__["film_material"] = film_slab
-
-        film_config = analyzer.film_strained_configuration
-        film_config_dict = film_config.model_dump()
-        film_config_dict["xy_supercell_matrix"] = common_supercell_matrix
-        film_config_common = SlabStrainedSupercellConfiguration(**film_config_dict)
-
-        strained_film = builder.get_material(film_config_common)
-        strained_films.append(strained_film)
-
-    return strained_films
-
-
-def apply_gaps_and_stack(
-    strained_slabs: List[MaterialWithBuildMetadata], gaps: List[float]
-) -> MaterialWithBuildMetadata:
-    """Apply gaps and stack materials."""
-    stacked_materials = []
-    for i, slab in enumerate(strained_slabs):
-        if i < len(gaps):
-            slab_with_gap = adjust_material_cell_to_set_gap_along_direction(slab, gaps[i], AxisEnum.z)
-            stacked_materials.append(slab_with_gap)
-        else:
-            stacked_materials.append(slab)
-
-    return stack(stacked_materials, AxisEnum.z)

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

@@ -1,47 +0,0 @@
-from .base import (
-    InterfaceConfiguration,
-    InterfaceBuilder,
-    InterfaceBuilderParameters,
-    create_interface_simple_between_slabs,
-)
-from .commensurate import (
-    create_interface_commensurate,
-    get_commensurate_strained_configurations,
-)
-from .enums import StrainModes
-from .twisted import (
-    TwistedNanoribbonsInterfaceConfiguration,
-    create_interface_twisted,
-)
-from .utils import (
-    get_optimal_film_displacement,
-    get_slab,
-    remove_duplicate_interfaces,
-)
-from .zsl import (
-    create_interface_zsl,
-    create_interface_zsl_between_slabs,
-)
-
-__all__ = [
-    # Base interface classes
-    "InterfaceConfiguration",
-    "InterfaceBuilder",
-    "InterfaceBuilderParameters",
-    # Simple interface
-    "create_interface_simple_between_slabs",
-    # ZSL interface
-    "create_interface_zsl",
-    "create_interface_zsl_between_slabs",
-    # Commensurate interface
-    "create_interface_commensurate",
-    "get_commensurate_strained_configurations",
-    # Twisted interface
-    "TwistedNanoribbonsInterfaceConfiguration",
-    "create_interface_twisted",
-    # Utilities
-    "get_optimal_film_displacement",
-    "get_slab",
-    "remove_duplicate_interfaces",
-    "StrainModes",
-]

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

@@ -1,11 +0,0 @@
-from .configuration import InterfaceConfiguration
-from .builder import InterfaceBuilder
-from .build_parameters import InterfaceBuilderParameters
-from .helpers import create_interface_simple_between_slabs
-
-__all__ = [
-    "InterfaceConfiguration",
-    "InterfaceBuilder",
-    "InterfaceBuilderParameters",
-    "create_interface_simple_between_slabs",
-]

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

@@ -1,5 +0,0 @@
-from mat3ra.code.entity import InMemoryEntityPydantic
-
-
-class InterfaceBuilderParameters(InMemoryEntityPydantic):
-    make_primitive: bool = True

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

@@ -1,164 +0,0 @@
-from typing import Optional, Any, Type, Union, cast
-
-import numpy as np
-
-from mat3ra.made.material import Material
-from mat3ra.made.utils import AXIS_TO_INDEX_MAP
-from .build_parameters import InterfaceBuilderParameters
-from .configuration import InterfaceConfiguration
-from .....pristine_structures.two_dimensional.slab_strained_supercell.builder import SlabStrainedSupercellBuilder
-from .....pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
-    SlabStrainedSupercellConfiguration,
-)
-from ......analyze import BaseMaterialAnalyzer
-from ......analyze.lattice import get_material_with_primitive_lattice
-from ......build_components import MaterialWithBuildMetadata
-from ......build_components.operations.core.combinations.stack.builder import StackNComponentsBuilder
-from ......build_components.operations.core.combinations.stack.configuration import StackConfiguration
-from ......convert.interface_parts_enum import InterfacePartsEnum
-from ......modify import translate_by_vector, translate_to_center, wrap_to_unit_cell
-from ......operations.core.unary import supercell
-from ......operations.core.utils import should_skip_stacking
-
-
-class InterfaceBuilder(StackNComponentsBuilder):
-    """
-    Creates an interface by straining the film to match the substrate.
-    """
-
-    _ConfigurationType: Type[InterfaceConfiguration] = InterfaceConfiguration
-    _BuildParametersType: Type[InterfaceBuilderParameters] = InterfaceBuilderParameters
-    _DefaultBuildParameters: InterfaceBuilderParameters = InterfaceBuilderParameters()
-    _GeneratedItemType: Type[Material] = Material
-
-    @property
-    def stack_component_types_conversion_map(self):
-        return {
-            **super().stack_component_types_conversion_map,
-            SlabStrainedSupercellConfiguration: SlabStrainedSupercellBuilder,
-        }
-
-    def _generate(self, configuration: InterfaceConfiguration) -> MaterialWithBuildMetadata:
-        film_material = self._stack_component_to_material(configuration.film_configuration, configuration)
-        substrate_material = self._stack_component_to_material(configuration.substrate_configuration, configuration)
-
-        if film_material:
-            film_material.set_labels_from_value(InterfacePartsEnum.FILM.value)
-        if substrate_material:
-            substrate_material.set_labels_from_value(InterfacePartsEnum.SUBSTRATE.value)
-
-        # Apply xy shift to the film material
-        stacking_axis = AXIS_TO_INDEX_MAP[configuration.direction.value]
-        other_axes = [i for i in range(3) if i != stacking_axis]
-        translation_vector = [0.0, 0.0, 0.0]
-        translation_vector[other_axes[0]] = configuration.xy_shift[0]
-        translation_vector[other_axes[1]] = configuration.xy_shift[1]
-        film_material = translate_by_vector(film_material, translation_vector, use_cartesian_coordinates=True)
-
-        try:
-            should_skip_stacking(substrate_material, film_material, stacking_axis)
-        except ValueError:
-            film_material = supercell(film_material, [[0, 1, 0], [1, 0, 0], [0, 0, 1]])
-            print(
-                "Switched in-plane lattice vectors of the film material to match substrate"
-                + "Direct stacking was not possible."
-            )
-            should_skip_stacking(substrate_material, film_material, stacking_axis)
-
-        stack_configuration = StackConfiguration(
-            stack_components=[substrate_material, film_material, configuration.vacuum_configuration],
-            gaps=configuration.gaps,
-            direction=configuration.direction,
-        )
-        interface = super()._generate(stack_configuration)
-        wrapped_interface = wrap_to_unit_cell(interface)
-        return wrapped_interface
-
-    def _post_process(
-        self,
-        material: MaterialWithBuildMetadata,
-        post_process_parameters: Optional[Any],
-        configuration: Optional[InterfaceConfiguration] = None,
-    ) -> MaterialWithBuildMetadata:
-        build_params = cast(InterfaceBuilderParameters, self.build_parameters)
-        if build_params.make_primitive:
-            primitive_material = get_material_with_primitive_lattice(
-                material, return_original_if_not_reduced=True, keep_orientation=True
-            )
-
-            if primitive_material != material:
-                if configuration is None:
-                    raise ValueError(
-                        "Configuration cannot be None when make_primitive is True and material is changed."
-                    )
-                primitive_material = self._preserve_interface_labels_after_primitive_conversion(
-                    original_material=material,
-                    primitive_material=primitive_material,
-                    axis=configuration.direction.value,
-                )
-
-            material = primitive_material
-
-        return super()._post_process(material, post_process_parameters=None, configuration=configuration)
-
-    def get_base_name_from_configuration(self, first_configuration, second_configuration) -> str:
-        first_component_formula = BaseMaterialAnalyzer(material=first_configuration.atomic_layers.crystal).formula
-        second_component_formula = BaseMaterialAnalyzer(material=second_configuration.atomic_layers.crystal).formula
-        first_component_miller = first_configuration.atomic_layers.miller_indices_as_string
-        second_component_miller = second_configuration.atomic_layers.miller_indices_as_string
-        return f"{first_component_formula}{first_component_miller}-{second_component_formula}{second_component_miller}"
-
-    def get_name_suffix(self, configuration: InterfaceConfiguration) -> str:
-        strain = configuration.von_mises_strain_percentage
-        if strain == 0:
-            return "Interface"
-        return f"Interface, Strain {strain:.3f}pct"
-
-    def _update_material_name(
-        self, material: Union[Material, MaterialWithBuildMetadata], configuration: InterfaceConfiguration
-    ) -> MaterialWithBuildMetadata:
-        base_name = self.get_base_name_from_configuration(
-            configuration.film_configuration, configuration.substrate_configuration
-        )
-        name_suffix = self.get_name_suffix(configuration) or self.name_suffix
-        name = f"{base_name}, {name_suffix}"
-        material.name = name
-        return material
-
-    def _preserve_interface_labels_after_primitive_conversion(
-        self, original_material: MaterialWithBuildMetadata, primitive_material: MaterialWithBuildMetadata, axis: str
-    ) -> MaterialWithBuildMetadata:
-        if not original_material.basis.labels.values:
-            return primitive_material
-
-        labeled_primitive = primitive_material.clone()
-        interface_gap_coordinate = self._find_interface_coordinate_level(original_material, axis)
-        primitive_labels = self._assign_labels_by_coordinate_level(labeled_primitive, interface_gap_coordinate, axis)
-        labeled_primitive.set_labels_from_list(primitive_labels)
-        return labeled_primitive
-
-    def _find_interface_coordinate_level(self, material: MaterialWithBuildMetadata, axis) -> float:
-        normalized_material = translate_to_center(material, axes=[axis])
-        normalized_material.to_cartesian()
-        direction_coords = np.array(normalized_material.coordinates_array)[:, AXIS_TO_INDEX_MAP[axis]]
-        labels = material.basis.labels.values
-
-        substrate_gap_coordinate = direction_coords[np.array(labels) == int(InterfacePartsEnum.SUBSTRATE.value)]
-        film_gap_coordinate = direction_coords[np.array(labels) == int(InterfacePartsEnum.FILM.value)]
-
-        if len(substrate_gap_coordinate) == 0 or len(film_gap_coordinate) == 0:
-            return (np.min(direction_coords) + np.max(direction_coords)) / 2
-
-        max_substrate_gap_coordinate = np.max(substrate_gap_coordinate)
-        min_film_gap_coordinate = np.min(film_gap_coordinate)
-        return (max_substrate_gap_coordinate + min_film_gap_coordinate) / 2
-
-    def _assign_labels_by_coordinate_level(
-        self, material: MaterialWithBuildMetadata, interface_gap_coordinate: float, axis
-    ) -> list:
-        normalized_material = translate_to_center(material, axes=[axis])
-        normalized_material.to_cartesian()
-        direction_coords = np.array(normalized_material.coordinates_array)[:, AXIS_TO_INDEX_MAP[axis]]
-        substrate_label = int(InterfacePartsEnum.SUBSTRATE.value)
-        film_label = int(InterfacePartsEnum.FILM.value)
-        return [substrate_label if z < interface_gap_coordinate else film_label for z in direction_coords]

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

@@ -1,48 +0,0 @@
-from typing import Union, List, Optional
-
-import numpy as np
-from mat3ra.esse.models.materials_category.compound_pristine_structures.two_dimensional.interface.configuration import (  # noqa: E501
-    InterfaceConfigurationSchema,
-)
-
-from .....pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
-    SlabStrainedSupercellConfiguration,
-)
-from ......analyze.utils import calculate_von_mises_strain
-from ......build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from ......build_components.operations.core.combinations.stack.configuration import StackConfiguration
-from ......utils import unwrap
-
-
-class InterfaceConfiguration(StackConfiguration, InterfaceConfigurationSchema):
-    # components and their modifiers added in the order they are stacked, from bottom to top
-    stack_components: List[
-        Union[
-            SlabStrainedSupercellConfiguration,
-            VacuumConfiguration,
-        ]
-    ]
-    xy_shift: List[float] = InterfaceConfigurationSchema.model_fields["xy_shift"].default  # in Angstroms
-
-    type: str = "InterfaceConfiguration"
-
-    @property
-    def substrate_configuration(self) -> SlabStrainedSupercellConfiguration:
-        return self.stack_components[0]
-
-    @property
-    def film_configuration(self) -> SlabStrainedSupercellConfiguration:
-        return self.stack_components[1]
-
-    @property
-    def vacuum_configuration(self) -> Optional[VacuumConfiguration]:
-        if len(self.stack_components) > 2:
-            return self.stack_components[2]
-        return None
-
-    @property
-    def von_mises_strain_percentage(self) -> float:
-        """Von Mises strain (%) from the film's strain_matrix (2D part)."""
-        raw = self.film_configuration.strain_matrix.root
-        strain_matrix = np.array(unwrap(raw))
-        return calculate_von_mises_strain(strain_matrix)

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

@@ -1,134 +0,0 @@
-from typing import List, Optional, Tuple, Union
-
-from mat3ra.code.array_with_ids import ArrayWithIds
-
-from mat3ra.made.material import Material
-from .build_parameters import InterfaceBuilderParameters
-from .builder import InterfaceBuilder
-from .configuration import InterfaceConfiguration
-from ......analyze.interface import InterfaceAnalyzer
-from ......analyze.slab import SlabMaterialAnalyzer
-from ......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_simple_between_slabs(
-    substrate_slab: MaterialWithBuildMetadata,
-    film_slab: MaterialWithBuildMetadata,
-    gap: Optional[float] = None,
-    vacuum: float = 10.0,
-    xy_shift: List[float] = [0, 0],
-    reduce_result_cell_to_primitive: bool = False,
-) -> Material:
-    """
-    Create an interface between two slab materials with specified parameters.
-    No strain matching is performed, the interface is created as a simple stack of two slabs.
-
-    Args:
-        substrate_slab (MaterialWithBuildMetadata): Substrate slab material.
-        film_slab (MaterialWithBuildMetadata): Film slab material.
-        gap (Optional[float]): Gap between the two materials, in Angstroms.
-            Distance between top most atom of the substrate and bottom most atom of the film.
-        vacuum (float): Size of the vacuum layer in Angstroms.
-        xy_shift (List[float]): Shift in x and y directions, in Angstroms.
-
-    Returns:
-        Material: The interface material.
-    """
-    substrate_analyzer = SlabMaterialAnalyzer(material=substrate_slab)
-    film_analyzer = SlabMaterialAnalyzer(material=film_slab)
-
-    analyzer = InterfaceAnalyzer(
-        substrate_slab_configuration=substrate_analyzer.build_configuration,
-        film_slab_configuration=film_analyzer.build_configuration,
-        substrate_build_parameters=substrate_analyzer.build_parameters,
-        film_build_parameters=film_analyzer.build_parameters,
-    )
-
-    film_configuration = analyzer.film_strained_configuration
-    substrate_configuration = analyzer.substrate_strained_configuration
-    vacuum_configuration = VacuumConfiguration(
-        size=vacuum,
-    )
-
-    config = InterfaceConfiguration(
-        stack_components=[substrate_configuration, film_configuration, vacuum_configuration],
-        xy_shift=xy_shift,
-        gaps=ArrayWithIds.from_values([gap]),
-    )
-    builder = InterfaceBuilder(
-        build_parameters=InterfaceBuilderParameters(make_primitive=reduce_result_cell_to_primitive)
-    )
-    interface = builder.get_material(config)
-    return interface
-
-
-def create_interface_simple(
-    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,
-    substrate_xy_supercell_matrix: List[List[int]] = [[1, 0], [0, 1]],
-    film_xy_supercell_matrix: List[List[int]] = [[1, 0], [0, 1]],
-    gap: Optional[float] = None,
-    vacuum: float = 10.0,
-    xy_shift: List[float] = [0, 0],
-    use_conventional_cell: bool = True,
-    reduce_result_cell_to_primitive: bool = False,
-) -> Material:
-    """
-    Create an interface between two crystal materials by first creating slabs and then stacking them.
-    No strain matching is performed, the interface is created as a simple stack of two slabs.
-
-    Args:
-        substrate_crystal (Union[Material, MaterialWithBuildMetadata]): Substrate crystal material.
-        film_crystal (Union[Material, MaterialWithBuildMetadata]): Film crystal material.
-        substrate_miller_indices (Tuple[int, int, int]): Miller indices for the substrate slab surface.
-        film_miller_indices (Tuple[int, int, int]): Miller indices for the film slab surface.
-        substrate_number_of_layers (int): Number of atomic layers in the substrate slab.
-        film_number_of_layers (int): Number of atomic layers in the film slab.
-        substrate_termination_formula (Optional[str]): Formula of the termination for substrate slab.
-        film_termination_formula (Optional[str]): Formula of the termination for film slab.
-        substrate_xy_supercell_matrix (List[List[int]]): Supercell matrix for substrate slab xy plane.
-        film_xy_supercell_matrix (List[List[int]]): Supercell matrix for film slab xy plane.
-        gap (Optional[float]): Gap between the two materials, in Angstroms.
-        vacuum (float): Size of the vacuum layer in Angstroms.
-        xy_shift (List[float]): Shift in x and y directions, in Angstroms.
-        use_conventional_cell (bool): Whether to use conventional cell for crystals.
-        reduce_result_cell_to_primitive (bool): Whether to reduce result cell to primitive.
-
-    Returns:
-        Material: The interface material.
-    """
-    substrate_slab = create_slab(
-        crystal=substrate_crystal,
-        miller_indices=substrate_miller_indices,
-        number_of_layers=substrate_number_of_layers,
-        vacuum=0,
-        termination_top_formula=substrate_termination_formula,
-        xy_supercell_matrix=substrate_xy_supercell_matrix,
-        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,
-        xy_supercell_matrix=film_xy_supercell_matrix,
-        use_conventional_cell=use_conventional_cell,
-    )
-
-    return create_interface_simple_between_slabs(
-        substrate_slab=substrate_slab,
-        film_slab=film_slab,
-        gap=gap,
-        vacuum=vacuum,
-        xy_shift=xy_shift,
-        reduce_result_cell_to_primitive=reduce_result_cell_to_primitive,
-    )

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

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