@mat3ra/made 2026.8.7-0 → 2026.8.18-0

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

@@ -1,171 +0,0 @@
-import random
-from typing import List, Optional, Union
-
-import numpy as np
-from mat3ra.made.material import Material
-
-from ..analyze import BaseMaterialAnalyzer
-from ..analyze.utils import minimum_image_distances
-from ..build.defective_structures.three_dimensional.solid_solution.enums import SiteSelectionMethodEnum
-from ..build_components import MaterialWithBuildMetadata
-from ..build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-
-
-def _most_isotropic_dimensions(total_cells: int) -> List[int]:
-    """
-    Find [a, b, c] repeat factors whose product equals total_cells with minimum aspect ratio.
-
-    Enumerates factor triples with a <= b <= c and returns the triple with the
-    smallest spread (c - a).
-
-    Args:
-        total_cells (int): Target number of unit cells in the supercell.
-
-    Returns:
-        List[int]: Repeat factors [a, b, c] along the three lattice directions.
-    """
-    best_dimensions = [1, 1, total_cells]
-    best_spread = total_cells - 1
-    for a in range(1, total_cells + 1):
-        if total_cells % a:
-            continue
-        for b in range(a, total_cells // a + 1):
-            if (total_cells // a) % b:
-                continue
-            c = total_cells // (a * b)
-            if c < b:
-                continue
-            spread = c - a
-            if spread < best_spread:
-                best_dimensions = [a, b, c]
-                best_spread = spread
-    return best_dimensions
-
-
-def _select_sites_uniform(
-    material: Union[Material, MaterialWithBuildMetadata],
-    source_indices: List[int],
-    number_to_select: int,
-    seed: int = None,
-) -> List[int]:
-    """
-    Select number_to_select sites from source_indices using Farthest Point Sampling.
-
-    Iteratively picks the site whose minimum distance to all already-selected
-    sites is largest, producing a maximally dispersed subset under PBC.
-
-    Args:
-        material (Union[Material, MaterialWithBuildMetadata]): Material with lattice and coordinates.
-        source_indices (List[int]): Indices of candidate sites in the material basis.
-        number_to_select (int): Number of sites to select.
-        seed (int, optional): Random seed for the initial site choice.
-
-    Returns:
-        List[int]: Sorted list of selected site indices.
-    """
-    if number_to_select <= 0:
-        return []
-    if number_to_select >= len(source_indices):
-        return sorted(source_indices)
-
-    material.to_crystal()
-    fractional_coordinates = np.array(material.basis.coordinates.values)
-    lattice_vectors = np.array(material.lattice.vector_arrays)
-    pairwise_distances = minimum_image_distances(fractional_coordinates[source_indices], lattice_vectors)
-
-    random_generator = random.Random(seed)
-    first_pick = random_generator.randrange(len(source_indices))
-    selected = [first_pick]
-    distance_to_selected = pairwise_distances[first_pick].copy()
-    is_candidate = np.ones(len(source_indices), dtype=bool)
-    is_candidate[first_pick] = False
-
-    for _ in range(number_to_select - 1):
-        farthest_distance = np.max(distance_to_selected[is_candidate])
-        tied_candidates = np.where(is_candidate & np.isclose(distance_to_selected, farthest_distance))[0]
-        next_pick = int(random_generator.choice(tied_candidates))
-        selected.append(next_pick)
-        is_candidate[next_pick] = False
-        np.minimum(distance_to_selected, pairwise_distances[next_pick], out=distance_to_selected)
-
-    return sorted(source_indices[i] for i in selected)
-
-
-class SolidSolutionAnalyzer(BaseMaterialAnalyzer):
-    """
-    Analyzes a unit cell to plan supercell dimensions and select substitution sites.
-
-    Given a unit cell material and a desired substitution ratio, finds the
-    most isotropic supercell matching the target concentration within tolerance,
-    then selects specific sites for substitution.
-    """
-
-    source_element: str
-    target_element: str
-    target_concentration: float
-    tolerance: float = 0.01
-    max_supercell_cells: int = 128
-    seed: Optional[int] = None
-    site_selection_method: SiteSelectionMethodEnum = SiteSelectionMethodEnum.UNIFORM
-
-    @property
-    def source_element_count_per_cell(self) -> int:
-        return sum(1 for element in self.material.basis.elements.values if element == self.source_element)
-
-    @property
-    def optimal_supercell_dimensions(self) -> List[int]:
-        source_count_per_cell = self.source_element_count_per_cell
-        if source_count_per_cell == 0:
-            raise ValueError(f"No {self.source_element} atoms found in the unit cell.")
-
-        best_dimensions = None
-        best_shape_spread = self.max_supercell_cells
-        for cell_count in range(1, self.max_supercell_cells + 1):
-            source_atoms = source_count_per_cell * cell_count
-            replacement_atoms = min(max(round(self.target_concentration * source_atoms), 0), source_atoms)
-            achieved_concentration = replacement_atoms / source_atoms
-            if abs(achieved_concentration - self.target_concentration) > self.tolerance:
-                continue
-
-            dimensions = _most_isotropic_dimensions(cell_count)
-            shape_spread = dimensions[2] - dimensions[0]
-            if shape_spread < best_shape_spread:
-                best_dimensions = dimensions
-                best_shape_spread = shape_spread
-            if shape_spread == 0:
-                break
-
-        if best_dimensions is None:
-            raise ValueError(
-                f"Cannot achieve concentration {self.target_concentration} "
-                f"within tolerance {self.tolerance} for up to {self.max_supercell_cells} cells."
-            )
-        return best_dimensions
-
-    @property
-    def actual_concentration(self) -> float:
-        a, b, c = self.optimal_supercell_dimensions
-        source_atoms = self.source_element_count_per_cell * a * b * c
-        replacement_atoms = min(max(round(self.target_concentration * source_atoms), 0), source_atoms)
-        return replacement_atoms / source_atoms
-
-    @property
-    def selected_site_indices(self) -> List[int]:
-        supercell = create_supercell(material=self.material, scaling_factor=self.optimal_supercell_dimensions)
-        supercell_material = MaterialWithBuildMetadata.create(supercell.to_dict())
-        elements = supercell_material.basis.elements.values
-        source_indices = [index for index, element in enumerate(elements) if element == self.source_element]
-        replacement_atoms = min(
-            max(round(self.actual_concentration * len(source_indices)), 0),
-            len(source_indices),
-        )
-
-        if self.site_selection_method == SiteSelectionMethodEnum.UNIFORM:
-            keep_atoms = len(source_indices) - replacement_atoms
-            if keep_atoms < replacement_atoms:
-                kept_indices = _select_sites_uniform(supercell_material, source_indices, keep_atoms, self.seed)
-                return sorted(set(source_indices) - set(kept_indices))
-            return _select_sites_uniform(supercell_material, source_indices, replacement_atoms, self.seed)
-
-        random_generator = random.Random(self.seed)
-        return sorted(random_generator.sample(source_indices, replacement_atoms))

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

@@ -1,105 +0,0 @@
-from typing import List
-
-import numpy as np
-
-from .slab import SlabMaterialAnalyzer
-
-
-class TerraceMaterialAnalyzer(SlabMaterialAnalyzer):
-    """
-    Used to calculate the adjustment values to make a stepped-surface (terrace) slab
-    periodic.
-
-    Build sequence
-    --------------
-    1. **Add extra layers** on top of the parent slab.
-    2. **Cut** those layers with the crystallographic plane given by
-       ``cut_direction`` → isolates the terrace step.
-    3. **Stack** the step onto the original slab → creates a terrace.
-    4. **Stretch lattice** in-plane (``new_lattice_vectors``) so the rotation can be performed inside the unit cell.
-    5. **Rotate** the whole slab by ``angle`` around ``rotation_axis`` so the
-       crystal structure is matched with the repetition in the PBC.
-
-    Key outputs
-    -----------
-    cut_direction_vector : unit Cartesian vector normal to the cut plane
-    rotation_axis        : axis to rotate the slab around
-    angle                : rotation angle in degrees
-    new_lattice_vectors  : stretched lattice vectors used before rotation
-    """
-
-    cut_direction: List[int] = [0, 0, 1]
-    number_of_added_layers: float = 1.0
-
-    @property
-    def _lattice_matrix(self) -> np.ndarray:
-        return np.array(self.material.lattice.vector_arrays)
-
-    @property
-    def _height_cartesian(self) -> float:
-        return self.layer_thickness * self.number_of_added_layers
-
-    @property
-    def _cut_direction_xy_proj_cart(self) -> float:
-        return np.linalg.norm(np.dot(self._lattice_matrix, self.cut_direction_vector))
-
-    @property
-    def _length_increment(self) -> float:
-        return (
-            np.linalg.norm([self._height_cartesian, self._cut_direction_xy_proj_cart])
-            - self._cut_direction_xy_proj_cart
-        )
-
-    @property
-    def cut_direction_vector(self) -> np.ndarray:
-        """
-        Get the normalized Cartesian vector normal to the terrace cut plane.
-
-        The terrace is constructed by cutting the material with a crystallographic
-        plane defined by `cut_direction`
-        """
-        direction = np.dot(self._lattice_matrix, np.array(self.cut_direction))
-        return direction / np.linalg.norm(direction)
-
-    @property
-    def rotation_axis(self) -> List[int]:
-        """
-        Calculate the axis of rotation to align the terrace with its repetition in the PBC.
-        """
-        axis = np.cross(np.array(self.cut_direction), [0, 0, 1])
-        return np.round(axis / np.linalg.norm(axis)).astype(int).tolist()
-
-    @property
-    def angle(self) -> float:
-        """
-        Calculate the angle of the tilt needed to align the terrace with its repetition in the PBC.
-        """
-        return np.degrees(np.arctan(self._height_cartesian / self._cut_direction_xy_proj_cart))
-
-    @property
-    def new_lattice_vectors(self) -> List[List[float]]:
-        """
-        Compute updated lattice vectors to accommodate terrace tilt before rotation.
-
-        The terrace step introduces an additional height, so to match it across PBC,
-        the in-plane lattice vectors must be stretched. This method calculates the
-        additional in-plane length needed and applies directional scaling to both
-        a and b vectors, in proportion to their projection along the terrace normal.
-        """
-        direction_vector = self.cut_direction_vector
-        length_increment = self._length_increment
-
-        vector_a = self.material.lattice.vectors.a
-        vector_b = self.material.lattice.vectors.b
-
-        norm_a, norm_b = vector_a.norm, vector_b.norm
-        delta_a_cart = np.dot(vector_a.value, direction_vector) * length_increment / norm_a
-        delta_b_cart = np.dot(vector_b.value, direction_vector) * length_increment / norm_b
-
-        scaling_matrix = np.eye(3)
-        scaling_matrix[0, 0] += delta_a_cart / norm_a
-        scaling_matrix[1, 1] += delta_b_cart / norm_b
-
-        new_material = self.material.clone()
-        new_lattice = new_material.lattice.get_scaled_by_matrix(scaling_matrix.tolist())
-        return new_lattice.vector_arrays

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

@@ -1,162 +0,0 @@
-from functools import wraps
-from typing import TYPE_CHECKING, Union
-
-import numpy as np
-from mat3ra.code.array_with_ids import ArrayWithIds, RoundedArrayWithIds
-from mat3ra.made.material import Material
-
-if TYPE_CHECKING:
-    from .material import MaterialWithCrystalSites
-
-
-def decorator_handle_periodic_boundary_conditions(cutoff):
-    """
-    Decorator to handle periodic boundary conditions.
-
-    Copies atoms near boundaries within the cutoff distance beyond the opposite side of the cell
-    creating the effect of periodic boundary conditions for edge atoms.
-
-    Results of the function are filtered to remove atoms or coordinates outside the original cell.
-
-    Args:
-        cutoff (float): The cutoff distance for a border slice in crystal coordinates.
-
-    Returns:
-        Callable: The decorated function.
-    """
-
-    def decorator(func):
-        @wraps(func)
-        def wrapper(material, *args, **kwargs):
-            augmented_material, last_id = augment_material_with_periodic_images(material, cutoff)
-
-            result = func(augmented_material, *args, **kwargs)
-
-            original_ids = material.basis.coordinates.ids
-            if isinstance(result, (ArrayWithIds, RoundedArrayWithIds)):
-                result.filter_by_ids(original_ids)
-            if isinstance(result, list):
-                if all(isinstance(x, int) for x in result):
-                    result = [id for id in result if id <= last_id]
-                elif all(isinstance(x, list) and len(x) == 3 for x in result):
-                    result = [coord for coord in result if all(0 <= c < 1 for c in coord)]
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-def augment_material_with_periodic_images(material: Union[Material, "MaterialWithCrystalSites"], cutoff: float = 0.25):
-    """
-    Augment the material's dataset by adding atoms from periodic images within a cutoff distance
-    from the boundaries by copying them to the opposite side of the cell.
-
-    Args:
-        material (Material): The material to augment.
-        cutoff (float): The cutoff value for filtering atoms near boundaries, in crystal coordinates.
-
-    Returns:
-        Tuple[Material, int]: The augmented material and the last id of the original material for filtering.
-    """
-    augmented_material = material.clone()
-
-    last_id = material.basis.coordinates.ids[-1]
-    original_basis_is_in_cartesian = material.basis.is_in_cartesian_units
-
-    augmented_material.to_crystal()
-    coordinates = np.array(augmented_material.basis.coordinates.values)
-    elements = np.array(augmented_material.basis.elements.values)
-
-    for axis in range(3):
-        for direction in [-1, 1]:
-            mask = (coordinates[:, axis] < cutoff) if direction == 1 else (coordinates[:, axis] > (1 - cutoff))
-            filtered_coordinates = coordinates[mask]
-            filtered_elements = elements[mask]
-            translation_vector = np.zeros(3)
-            translation_vector[axis] = direction
-            translated_coordinates = filtered_coordinates + translation_vector
-            for coord, elem in zip(translated_coordinates, filtered_elements):
-                augmented_material.add_atom(elem, coord)
-
-    if original_basis_is_in_cartesian:
-        augmented_material.to_cartesian()
-
-    return augmented_material, last_id
-
-
-def decorator_perform_operation_in_cartesian_coordinates(func):
-    """
-    Decorator to perform operations in Cartesian coordinates.
-
-    Converts the material to Cartesian coordinates before executing the function
-    and converts it back to crystal coordinates after execution.
-
-    Args:
-        func (Callable): The function to decorate.
-
-    Returns:
-        Callable: The decorated function.
-    """
-
-    @wraps(func)
-    def wrapper(material, *args, **kwargs):
-        original_basis_is_in_cartesian = material.material.basis.is_in_cartesian_units
-        if not original_basis_is_in_cartesian:
-            material.material.to_cartesian()
-
-        result = func(material, *args, **kwargs)
-
-        if not original_basis_is_in_cartesian:
-            material.material.to_crystal()
-
-        return result
-
-    return wrapper
-
-
-def calculate_von_mises_strain(strain_matrix: np.ndarray) -> float:
-    """
-    Calculate von Mises strain (%) from a 2D strain transformation matrix (top-left 2x2 of 3x3).
-
-    Args:
-        strain_matrix (np.ndarray): A 2D numpy array representing the strain transformation matrix.
-    Returns:
-        float: The von Mises strain in percentage.
-    """
-    # allow passing a Python list
-    strain_matrix_2x2 = np.array(strain_matrix, dtype=float)[:2, :2]
-    E = 0.5 * (strain_matrix_2x2.T @ strain_matrix_2x2 - np.eye(2))
-
-    exx = E[0, 0]
-    eyy = E[1, 1]
-    exy = 0.5 * (E[0, 1] + E[1, 0])
-
-    e_von_mises = np.sqrt(exx**2 - exx * eyy + eyy**2 + 3 * exy**2)
-
-    return abs(e_von_mises) * 100.0
-
-
-def minimum_image_distances(frac_coords: np.ndarray, lattice_vectors: np.ndarray) -> np.ndarray:
-    """
-    Compute pairwise distances between fractional coordinates under periodic boundary conditions.
-
-    Applies the minimum image convention: for each pair, the shortest distance
-    across all periodic images is returned.
-
-    Args:
-        frac_coords (np.ndarray): Fractional coordinates, shape (N, 3).
-        lattice_vectors (np.ndarray): Lattice vectors, shape (3, 3), rows are vectors.
-
-    Returns:
-        np.ndarray: Symmetric distance matrix, shape (N, N), in the same units as lattice_vectors.
-    """
-    n = len(frac_coords)
-    distances = np.zeros((n, n))
-    for i in range(n):
-        delta = frac_coords[i] - frac_coords[i + 1 :]
-        delta -= np.round(delta)
-        dists = np.linalg.norm(delta @ lattice_vectors, axis=1)
-        distances[i, i + 1 :] = dists
-        distances[i + 1 :, i] = dists
-    return distances

package/src/py/mat3ra/made/tools/bond_directions/bond_directions.py

@@ -1,150 +0,0 @@
-from typing import List
-
-import numpy as np
-
-
-class BondDirections(np.ndarray):
-    def __new__(cls, input_array, *args, **kwargs):
-        """
-        Create a new instance of BondDirections from an input array.
-
-        Args:
-            input_array (array-like): Input data to initialize the array.
-
-        Returns:
-            BondDirections: A new BondDirections instance.
-        """
-        obj = np.asarray(input_array).view(cls)
-        return obj
-
-    def __eq__(self, other):
-        if not isinstance(other, BondDirections):
-            return False
-        if self.shape != other.shape:
-            return False  # Prevents shape mismatches
-        return self.are_bond_directions_similar(self, other)
-
-    @staticmethod
-    def are_bond_directions_similar(directions1: np.ndarray, directions2: np.ndarray, tolerance: float = 0.1) -> bool:
-        """
-        Check if two bond direction templates are similar.
-
-        Args:
-            directions1 (np.ndarray): First template of bond vectors.
-            directions2 (np.ndarray): Second template of bond vectors.
-            tolerance (float): Angle tolerance for comparison.
-
-        Returns:
-            bool: True if the templates are similar, False otherwise.
-        """
-        if len(directions1) != len(directions2):
-            return False
-
-        dot_matrix = np.dot(directions1, directions2.T)
-        norms1 = np.linalg.norm(directions1, axis=1)
-        norms2 = np.linalg.norm(directions2, axis=1)
-        cosine_matrix = dot_matrix / np.outer(norms1, norms2)
-        angles_matrix = np.arccos(np.clip(cosine_matrix, -1.0, 1.0))
-
-        unmatched = list(range(len(directions2)))
-        for angle_row in angles_matrix:
-            matches = np.where(angle_row < tolerance)[0]
-            if len(matches) == 0:
-                return False
-            unmatched.remove(matches.tolist()[0])
-
-        return True
-
-    def find_missing_directions(
-        self,
-        bond_templates: List[np.ndarray],
-        angle_tolerance: float = 0.1,
-        max_bonds_to_add: int = 1,
-    ) -> "BondDirections":
-        """
-        Reconstruct missing bonds for the atom based on the bond template that matches most of the existing bonds.
-
-        Args:
-            bond_templates (List[np.ndarray]): List of bond templates to match against.
-            angle_tolerance (float): Tolerance for comparing angles between bond vectors.
-            max_bonds_to_add (int): Maximum number of bonds to add.
-
-        Returns:
-            BondDirections: List of reconstructed bond vectors.
-        """
-        max_coordination_number = max(len(template) for template in bond_templates)
-
-        if len(self) >= max_coordination_number:
-            return BondDirections([])
-
-        best_missing_directions = None
-        highest_match_count = -1
-
-        bond_templates = self._flatten_bond_templates(bond_templates)
-
-        for bond_template in bond_templates:
-            # Check which existing bonds match the template bonds
-            is_matched = [
-                any(self._are_vectors_similar(existing_bond, candidate_bond, angle_tolerance) for existing_bond in self)
-                for candidate_bond in bond_template
-            ]
-
-            current_match_count = sum(is_matched)
-            missing_directions = [
-                candidate_bond for candidate_bond, matched in zip(bond_template, is_matched) if not matched
-            ]
-
-            # Select the template with the highest match count
-            if current_match_count > highest_match_count:
-                highest_match_count = current_match_count
-                best_missing_directions = missing_directions
-
-        if best_missing_directions is not None:
-            num_bonds_to_add = min(
-                len(best_missing_directions),
-                max_bonds_to_add,
-                max_coordination_number - len(self),
-            )
-            return BondDirections(best_missing_directions[:num_bonds_to_add])
-
-        return BondDirections([])
-
-    @staticmethod
-    def _are_vectors_similar(vector1: np.ndarray, vector2: np.ndarray, tolerance: float = 0.1) -> bool:
-        """
-        Check if two bond vectors are similar.
-
-        Args:
-            vector1 (np.ndarray): First bond vector.
-            vector2 (np.ndarray): Second bond vector.
-            tolerance (float): Angle tolerance for comparison.
-
-        Returns:
-            bool: True if the bond vectors are similar, False otherwise.
-        """
-        dot_product = np.dot(vector1, vector2)
-        norms = np.linalg.norm(vector1) * np.linalg.norm(vector2)
-        cosine_angle = dot_product / norms if norms != 0 else 0.0
-        angle = np.arccos(np.clip(cosine_angle, -1.0, 1.0))
-        return angle < tolerance
-
-    @staticmethod
-    def _flatten_bond_templates(bond_templates: List[np.ndarray]) -> List[np.ndarray]:
-        """
-        Ensure that bond_templates is a list of np.ndarray with no extra nesting.
-
-        Args:
-            bond_templates (list): List of bond templates to preprocess.
-
-        Returns:
-            list: Flattened list of bond templates (np.ndarray).
-        """
-        flattened_templates = []
-        for template in bond_templates:
-            if isinstance(template, list) and all(isinstance(sub_template, np.ndarray) for sub_template in template):
-                # If the template is a list of np.ndarray, extend the flattened list
-                flattened_templates.extend(template)
-            else:
-                # Otherwise, add the template directly
-                flattened_templates.append(template)
-        return flattened_templates

package/src/py/mat3ra/made/tools/bond_directions/bond_directions_for_element_list.py

@@ -1,7 +0,0 @@
-from typing import List
-
-from ...bond_directions.bond_directions_templates_for_element import BondDirectionsTemplatesForElement
-
-
-class BondDirectionsForElementList(List[BondDirectionsTemplatesForElement]):
-    pass

package/src/py/mat3ra/made/tools/bond_directions/bond_directions_templates_enum.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class BondDirectionsTemplatesEnum(list, Enum):
-    OCTAHEDRAL = [[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]]
-    TETRAHEDRAL = [[1, 1, 1], [-1, -1, 1], [1, -1, -1], [-1, 1, -1]]
-    PLANAR = [[1, 0, 0], [-1, 2, 0], [-1, -2, 0]]
-    LINEAR = [[1, 0, 0], [-1, 0, 0]]

package/src/py/mat3ra/made/tools/bond_directions/bond_directions_templates_for_element.py

@@ -1,16 +0,0 @@
-from typing import List
-
-import numpy as np
-from pydantic import BaseModel, ConfigDict
-
-from .bond_directions import BondDirections
-
-
-class BondDirectionsTemplatesForElement(BaseModel):
-    bond_directions_templates: List[BondDirections]
-    element: str
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_ndarray(self):
-        return [np.array(template) for template in self.bond_directions_templates]

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

@@ -1,25 +0,0 @@
-from ..build_components.metadata import (
-    BuildMetadata,
-    MaterialBuildMetadata,
-    MaterialWithBuildMetadata,
-)
-from ..build_components import (
-    BaseConfigurationPydantic,
-    BaseBuilderParameters,
-    BaseSingleBuilder,
-    TypeConfiguration,
-    TypeBuildParameters,
-    BaseConfigurationPydanticChild,
-)
-
-__all__ = [
-    "BuildMetadata",
-    "MaterialBuildMetadata",
-    "MaterialWithBuildMetadata",
-    "BaseConfigurationPydantic",
-    "BaseBuilderParameters",
-    "BaseSingleBuilder",
-    "TypeConfiguration",
-    "TypeBuildParameters",
-    "BaseConfigurationPydanticChild",
-]

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

@@ -1,7 +0,0 @@
-from .helpers import create_heterostructure
-from .types import StackComponentDict
-
-__all__ = [
-    "create_heterostructure",
-    "StackComponentDict",
-]