@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/src/py/mat3ra/made/tools/operations/core/binary.py

@@ -1,106 +0,0 @@
-from typing import List, Optional
-
-import numpy as np
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-from mat3ra.made.material import Material
-from mat3ra.made.utils import AXIS_TO_INDEX_MAP
-
-from ...build_components import MaterialWithBuildMetadata
-from ...modify import translate_by_vector
-from .utils import merge_two_materials, should_skip_stacking
-
-
-def merge(
-    materials: List[Material],
-    merge_method: Optional[MergeMethodsEnum] = MergeMethodsEnum.ADD,
-    material_name: Optional[str] = None,
-    distance_tolerance: float = 0.1,
-    merge_dangerously: bool = False,
-) -> MaterialWithBuildMetadata:
-    """
-    Merge multiple materials using a specific merge method.
-
-    Args:
-        materials (List[Material]): List of materials to merge.
-        merge_method (MergeMethodsEnum): The merge method to use.
-        material_name (Optional[str]): Name of the merged material.
-        distance_tolerance (float): The tolerance for resolving overlapping coordinates.
-        merge_dangerously (bool): If True, allows merging even if lattices are different.
-
-    Returns:
-        MaterialWithBuildMetadata: The merged material.
-    """
-    merged_material = materials[0]
-    for material in materials[1:]:
-        merged_material = merge_two_materials(
-            merged_material, material, merge_method, material_name, distance_tolerance, merge_dangerously
-        )
-    return merged_material
-
-
-def stack(materials: List[Material], direction: AxisEnum) -> MaterialWithBuildMetadata:
-    result = materials[0]
-    for material in materials[1:]:
-        result = stack_two_materials(material_1=result, material_2=material, direction=direction)
-    return result
-
-
-def stack_two_materials(
-    material_1: Material,
-    material_2: Material,
-    direction: AxisEnum = AxisEnum.z,
-) -> MaterialWithBuildMetadata:
-    """
-    Stack two materials along a specified direction by expanding lattices and merging.
-
-    First attempts to stack materials as-is. If that fails due to lattice mismatch,
-    adjusts the in-plane lattice vectors of material_2 to match material_1 and tries again.
-
-    Args:
-        material_1: First material to stack.
-        material_2: Second material to stack.
-        direction: Direction along which to stack (x, y, or z axis).
-
-    Returns:
-        MaterialWithBuildMetadata: Stacked material with combined lattice and atoms.
-    """
-    lattice_vector_index = AXIS_TO_INDEX_MAP[direction.value]
-
-    try:
-        if should_skip_stacking(material_1, material_2, lattice_vector_index):
-            return material_1.clone()
-
-        material_1_lattice_vectors = material_1.lattice.vector_arrays
-        material_2_lattice_vectors = material_2.lattice.vector_arrays
-
-        stacked_lattice_vectors_values = [vector.copy() for vector in material_1_lattice_vectors]
-        stacked_lattice_vectors_values[lattice_vector_index] = (
-            np.array(material_1_lattice_vectors[lattice_vector_index])
-            + np.array(material_2_lattice_vectors[lattice_vector_index])
-        ).tolist()
-
-        material_1_final_lattice_config = material_1.clone()
-        material_1_final_lattice_config.set_lattice_vectors_from_array(stacked_lattice_vectors_values)
-
-        # Translate material2 so its atoms are positioned correctly relative to material1
-        material_2_adjusted_c = material_2.clone()
-        material_2_adjusted_c.set_lattice_vectors_from_array(stacked_lattice_vectors_values)
-        # The translation amount is the original lattice vector of material1 in the stacking direction
-        translation_vec = material_1_lattice_vectors[lattice_vector_index]
-        material_2_translated = translate_by_vector(
-            material_2_adjusted_c, translation_vec, use_cartesian_coordinates=True
-        )
-
-        stacked_material = merge_two_materials(
-            material1=material_1_final_lattice_config,
-            material2=material_2_translated,
-            distance_tolerance=0,
-            merge_dangerously=False,
-            material_name=material_1.name,
-        )
-        return stacked_material
-    except ValueError as e:
-        raise ValueError(
-            f"Failed to stack materials {material_1.name} and {material_2.name} due to lattice mismatch: {str(e)}"
-        ) from e

package/src/py/mat3ra/made/tools/operations/core/unary.py

@@ -1,170 +0,0 @@
-from typing import List
-
-import numpy as np
-from mat3ra.code.vector import Vector3D
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-
-from ...build_components.metadata import MaterialWithBuildMetadata
-from ...build_components.operations.core.modifications.perturb import FunctionHolder
-from ...convert import from_ase, to_ase
-from ...modify import translate_by_vector, wrap_to_unit_cell
-from ...third_party import ase_make_supercell
-from ...utils import decorator_convert_supercell_matrix_2x2_to_3x3
-
-
-def translate(material: Material, vector: Vector3D) -> Material:
-    return translate_by_vector(material, vector, use_cartesian_coordinates=True)
-
-
-def translate_atoms(
-    material: Material,
-    atom_ids: List[int],
-    vector: Vector3D,
-    use_cartesian_coordinates: bool = True,
-) -> Material:
-    """
-    Translate the given atoms by a vector.
-
-    Basis order is preserved.
-
-    Args:
-        material (Material): The material to translate atoms in.
-        atom_ids (List[int]): Indices of the atoms to translate.
-        vector (Vector3D): The vector to translate the atoms by.
-        use_cartesian_coordinates (bool): Whether `vector` is in cartesian coordinates.
-
-    Returns:
-        Material: The material with the given atoms translated.
-
-    Raises:
-        IndexError: If any atom id is out of range for the basis.
-    """
-    new_material = material.clone()
-    if use_cartesian_coordinates:
-        new_material.to_cartesian()
-    coordinates: List[List[float]] = [list(coordinate) for coordinate in new_material.basis.coordinates.values]
-
-    out_of_range = [atom_id for atom_id in atom_ids if not -len(coordinates) <= atom_id < len(coordinates)]
-    if out_of_range:
-        raise IndexError(f"Atom ids {out_of_range} are out of range for a basis of {len(coordinates)} atoms.")
-
-    for atom_id in atom_ids:
-        coordinates[atom_id] = (np.array(coordinates[atom_id]) + np.array(vector)).tolist()
-
-    new_material.set_coordinates(coordinates)
-    if use_cartesian_coordinates:
-        new_material.to_crystal()
-    return new_material
-
-
-@decorator_convert_supercell_matrix_2x2_to_3x3
-def supercell(material: MaterialWithBuildMetadata, supercell_matrix) -> MaterialWithBuildMetadata:
-    atoms = to_ase(material)
-
-    supercell_atoms = ase_make_supercell(atoms, supercell_matrix)
-    material_config = from_ase(supercell_atoms)
-    # ASE make_supercell drops atoms.info; merge prior build/boundaryConditions when present.
-    source_metadata = material.to_dict().get("metadata") or {}
-    if source_metadata:
-        material_config["metadata"] = {**material_config.get("metadata", {}), **source_metadata}
-    new_material = MaterialWithBuildMetadata.create(material_config)
-    new_material.name = material.name
-    return new_material
-
-
-def edit_cell(material: Material, lattice_vectors=None) -> MaterialWithBuildMetadata:
-    if lattice_vectors is not None:
-        material.set_lattice_vectors(
-            lattice_vector1=lattice_vectors[0], lattice_vector2=lattice_vectors[1], lattice_vector3=lattice_vectors[2]
-        )
-    wrapped_material = wrap_to_unit_cell(material)
-    return wrapped_material
-
-
-def strain(material: Material, strain_matrix: Matrix3x3Schema) -> Material:
-    """
-    Applies a strain to the material by modifying its lattice vectors while keeping the basis in crystal coordinates.
-    """
-    if not isinstance(strain_matrix, Matrix3x3Schema):
-        raise ValueError("strain_matrix must be an instance of Matrix3x3Schema")
-
-    strain_matrix_np = np.array([row.root for row in strain_matrix.root])
-    lattice_vectors_np = np.array(material.lattice.vector_arrays)
-    new_lattice_vectors_np = lattice_vectors_np @ strain_matrix_np
-    new_lattice_vectors = new_lattice_vectors_np.tolist()
-
-    new_material = material.clone()
-
-    original_crystal_coords = new_material.basis.coordinates.values
-
-    new_material.set_lattice_vectors_from_array(new_lattice_vectors)
-    new_material.basis.coordinates.values = original_crystal_coords
-
-    return new_material
-
-
-def perturb(
-    material: Material, perturbation_function: FunctionHolder, use_cartesian_coordinates: bool = False
-) -> Material:
-    """
-    Applies a small delta perturbation to a each atom in the material. Lattice vectors are not modified.
-
-    Args:
-        material: The input Material instance containing coordinates.
-        perturbation_function: A PerturbationFunctionHolder that defines
-                     a function f(x,y,z) -> float (or vector) and
-                     optional transform_coordinates behavior.
-        use_cartesian_coordinates: If True, the perturbation is applied in Cartesian coordinates.
-                                   If False, the perturbation is applied in crystal coordinates.
-
-    Returns:
-        A new Material with perturbed coordinates.
-    """
-    new_material = material.clone()
-    if use_cartesian_coordinates:
-        new_material.to_cartesian()
-    original_coordinates = new_material.basis.coordinates.values
-    perturbed_coordinates: List[List[float]] = []
-
-    for coordinate in original_coordinates:
-        displacement = perturbation_function.apply_function(coordinate, material=new_material)
-
-        if isinstance(displacement, (list, tuple, np.ndarray)):
-            delta = np.array(displacement)
-        else:
-            delta = np.array([0.0, 0.0, displacement])
-
-        new_coordinate = np.array(coordinate) + delta
-        perturbed_coordinates.append(new_coordinate.tolist())
-
-    new_material.set_coordinates(perturbed_coordinates)
-    if use_cartesian_coordinates:
-        new_material.to_crystal()
-    return new_material
-
-
-def rotate(material: Material, axis: List[int], angle: float, wrap: bool = True) -> Material:
-    """
-    Rotate the basis of the material relative to the lattice.
-    This operation breaks symmetry and does not modify lattice vectors.
-
-    Args:
-        material (Material): The material to rotate.
-        axis (List[int]): The axis to rotate around, expressed as [x, y, z].
-        angle (float): The angle of rotation in degrees.
-        wrap (bool): Whether to wrap the material to the unit cell.
-    Returns:
-        Atoms: The rotated material.
-    """
-    new_material = material.clone()
-    original_is_in_cartesian_units = new_material.basis.is_in_cartesian_units
-    new_material.to_crystal()
-    atoms = to_ase(new_material)
-    atoms.rotate(v=axis, a=angle, center="COU", rotate_cell=False)
-    if wrap:
-        atoms.wrap()
-    new_material = MaterialWithBuildMetadata.create(from_ase(atoms))
-    if original_is_in_cartesian_units:
-        new_material.to_cartesian()
-    return new_material

package/src/py/mat3ra/made/tools/operations/core/utils.py

@@ -1,138 +0,0 @@
-from typing import Optional
-
-import numpy as np
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
-from mat3ra.made.basis import Basis, Coordinates
-from mat3ra.made.material import Material
-
-from ...build_components import MaterialWithBuildMetadata
-
-
-def merge_two_bases(basis1: Basis, basis2: Basis, distance_tolerance: float) -> Basis:
-    """
-    Merges two Basis objects into a new Basis object, resolving overlapping coordinates.
-    The function assumes that both Basis objects have the same lattice structure handled separately.
-
-    Args:
-        basis1 (Basis): The first Basis object to merge.
-        basis2 (Basis): The second Basis object to merge.
-        distance_tolerance (float): The tolerance for resolving overlapping coordinates.
-
-    Returns:
-        Basis: A new Basis object containing merged elements, coordinates, labels, and constraints.
-    """
-    basis1.to_crystal()
-    basis2.to_crystal()
-
-    merged_elements_values = basis1.elements.values + basis2.elements.values
-    merged_coordinates_values = basis1.coordinates.values + basis2.coordinates.values
-    merged_labels_values = basis1.labels.values + basis2.labels.values if basis1.labels and basis2.labels else []
-    merged_constraints_values = basis1.constraints.values + basis2.constraints.values
-
-    new_basis = basis1.clone()
-    new_basis.elements = ArrayWithIds.from_values(values=merged_elements_values)
-    new_basis.coordinates = Coordinates.from_values(values=merged_coordinates_values)
-    new_basis.labels = ArrayWithIds.from_values(values=merged_labels_values)
-    new_basis.constraints = ArrayWithIds.from_values(values=merged_constraints_values)
-    new_basis.resolve_colliding_coordinates(tolerance=distance_tolerance)
-
-    return new_basis
-
-
-def merge_two_materials(
-    material1: Material,
-    material2: Material,
-    merge_method: Optional[MergeMethodsEnum] = MergeMethodsEnum.ADD,
-    material_name: Optional[str] = None,
-    distance_tolerance: float = 0.1,
-    merge_dangerously: bool = False,
-) -> MaterialWithBuildMetadata:
-    """
-    Merge two materials using a specific merge method.
-
-    Args:
-        material1 (Material): The first material to merge.
-        material2 (Material): The second material to merge.
-        merge_method (MergeMethodsEnum): The merge method to use.
-        material_name (Optional[str]): Name of the merged material.
-        distance_tolerance (float): The tolerance for resolving overlapping coordinates.
-        merge_dangerously (bool): If True, allows merging even if lattices are different.
-
-    Returns:
-        MaterialWithBuildMetadata: The merged material.
-    """
-    if not np.allclose(material1.lattice.vector_arrays, material2.lattice.vector_arrays) and not merge_dangerously:
-        raise ValueError("Lattices of the two materials must be the same.")
-
-    if merge_method == MergeMethodsEnum.ADD:
-        merged_basis = merge_bases_add(material1.basis, material2.basis, distance_tolerance)
-    elif merge_method == MergeMethodsEnum.REPLACE:
-        merged_basis = merge_bases_replace(material1.basis, material2.basis, distance_tolerance)
-    elif merge_method == MergeMethodsEnum.YIELD:
-        merged_basis = merge_bases_yield(material1.basis, material2.basis, distance_tolerance)
-    else:
-        raise ValueError(f"Unknown merge method: {merge_method}")
-
-    name = material_name or "Merged Material"
-    new_material = MaterialWithBuildMetadata.create(
-        {"name": name, "lattice": material1.lattice.to_dict(), "basis": merged_basis.to_dict()}
-    )
-
-    return new_material
-
-
-def should_skip_stacking(
-    material_1: Material,
-    material_2: Material,
-    lattice_vector_index: int,
-) -> bool:
-    """
-    Determine if stacking should be skipped due to zero thickness in material_2.
-
-    Also validates that materials are compatible for stacking.
-
-    Args:
-        material_1: First material to stack.
-        material_2: Second material to stack.
-        lattice_vector_index: Index of the lattice vector in the stacking direction.
-
-    Returns:
-        bool: True if stacking should be skipped (material_2 has zero thickness).
-
-    Raises:
-        ValueError: If in-plane lattice vectors are not the same.
-    """
-    material_1_lattice_vectors = material_1.lattice.vector_arrays
-    material_2_lattice_vectors = material_2.lattice.vector_arrays
-
-    is_zero_thickness = np.allclose(material_2_lattice_vectors[lattice_vector_index], [0, 0, 0])
-    if is_zero_thickness:
-        return True
-
-    # Check that in-plane vectors are the same
-    all_indices = [0, 1, 2]
-    in_plane_indices = [i for i in all_indices if i != lattice_vector_index]
-
-    material_1_in_plane_vectors = np.array(material_1_lattice_vectors)[in_plane_indices]
-    material_2_in_plane_vectors = np.array(material_2_lattice_vectors)[in_plane_indices]
-
-    if not np.allclose(material_1_in_plane_vectors, material_2_in_plane_vectors):
-        difference = np.abs(material_1_in_plane_vectors - material_2_in_plane_vectors)
-        raise ValueError(f"In-plane lattice vectors of the two materials must be the same for stacking.\n{difference}")
-
-    return False
-
-
-def merge_bases_add(basis1: Basis, basis2: Basis, distance_tolerance: float) -> Basis:
-    return merge_two_bases(basis1, basis2, distance_tolerance)
-
-
-def merge_bases_replace(basis1: Basis, basis2: Basis, distance_tolerance: float) -> Basis:
-    base1 = basis1.clone()
-    return merge_two_bases(base1, basis2, distance_tolerance)
-
-
-def merge_bases_yield(basis1: Basis, basis2: Basis, distance_tolerance: float) -> Basis:
-    base2 = basis2.clone()
-    return merge_two_bases(base2, basis1, distance_tolerance)

package/src/py/mat3ra/made/tools/operations/reusable/unary.py

@@ -1,53 +0,0 @@
-import numpy as np
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-
-from ...modify import wrap_to_unit_cell
-from ..core.unary import strain
-
-
-def transform_material_by_matrix(material: Material, matrix: np.ndarray) -> Material:
-    """
-    Transforms a material by applying a transformation matrix to lattice vectors and coordinates.
-
-    Args:
-        material: The material to be transformed.
-        matrix: The 3x3 transformation matrix as a numpy array.
-
-    Returns:
-        A new material instance with transformed lattice and coordinates, wrapped to unit cell.
-    """
-    current_lattice_vectors = np.array(material.lattice.vector_arrays)
-    current_coordinates = material.basis.coordinates.values
-
-    new_lattice_vectors = (matrix @ current_lattice_vectors.T).tolist()
-    new_coordinates = (np.linalg.inv(matrix) @ np.array(current_coordinates).T).T.tolist()
-
-    transformed_material = material.clone()
-    transformed_material.set_lattice_vectors_from_array(new_lattice_vectors)
-    transformed_material.basis.coordinates.values = new_coordinates
-    return wrap_to_unit_cell(transformed_material)
-
-
-def strain_to_match_lattice(material_to_strain: Material, target_material: Material) -> Material:
-    """
-    Strains a material to match the lattice of a target material.
-
-    Args:
-        material_to_strain: The material to be strained.
-        target_material: The material with the target lattice.
-
-    Returns:
-        A new material instance with the strained lattice.
-    """
-    target_lattice_vectors = np.array(target_material.lattice.vector_arrays)
-    source_lattice_vectors = np.array(material_to_strain.lattice.vector_arrays)
-
-    # Prevent division by zero or singular matrix issues
-    if np.linalg.det(source_lattice_vectors) == 0:
-        raise ValueError("Lattice of material to strain is singular and cannot be inverted.")
-
-    strain_matrix_np = np.linalg.inv(source_lattice_vectors) @ target_lattice_vectors
-    strain_matrix = Matrix3x3Schema(root=strain_matrix_np.tolist())
-    strained_material = strain(material_to_strain, strain_matrix)
-    return strained_material

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

@@ -1,55 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-import numpy as np
-from mat3ra.made.material import Material
-
-
-def evaluate_calculator_on_xy_grid(
-    material: Material,
-    calculator_function: Callable[[Material], Any],
-    modifier: Optional[Callable] = None,
-    modifier_parameters: Dict[str, Any] = {},
-    grid_size_xy: Tuple[int, int] = (10, 10),
-    grid_offset_position: List[float] = [0, 0],
-    grid_range_x: Tuple[float, float] = (-0.5, 0.5),
-    grid_range_y: Tuple[float, float] = (-0.5, 0.5),
-    use_cartesian_coordinates: bool = False,
-) -> Tuple[List[np.ndarray], np.ndarray]:
-    """
-    Calculate a property on a grid of x-y positions.
-
-    Args:
-        material (Material): The material object.
-        modifier (Callable): The modifier function to apply to the material.
-        modifier_parameters (Dict[str, Any]): The parameters to pass to the modifier.
-        calculator_function (Callable): The calculator function to apply to the modified material.
-        grid_size_xy (Tuple[int, int]): The size of the grid in x and y directions.
-        grid_offset_position (List[float]): The offset position of the grid, in Angstroms or crystal coordinates.
-        grid_range_x (Tuple[float, float]): The range to search in x direction, in Angstroms or crystal coordinates.
-        grid_range_y (Tuple[float, float]): The range to search in y direction, in Angstroms or crystal coordinates.
-        use_cartesian_coordinates (bool): Whether to use Cartesian coordinates.
-
-    Returns:
-        Tuple[List[np.ndarray[float]], np.ndarray[float]]: The x-y positions and the calculated property values.
-    """
-    x_values = np.linspace(grid_range_x[0], grid_range_x[1], grid_size_xy[0]) + grid_offset_position[0]
-    y_values = np.linspace(grid_range_y[0], grid_range_y[1], grid_size_xy[1]) + grid_offset_position[1]
-
-    xy_matrix = [x_values, y_values]
-    results_matrix = np.zeros(grid_size_xy)
-
-    for i, x in enumerate(x_values):
-        for j, y in enumerate(y_values):
-            if modifier is None:
-                modified_material = material
-            else:
-                modified_material = modifier(
-                    material,
-                    displacement=[x, y, 0],
-                    use_cartesian_coordinates=use_cartesian_coordinates,
-                    **modifier_parameters,
-                )
-            result = calculator_function(modified_material)
-            results_matrix[i, j] = result
-
-    return xy_matrix, results_matrix

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

@@ -1,69 +0,0 @@
-from ase import Atoms as ASEAtoms
-from ase.build import add_vacuum as ase_add_vacuum
-from ase.build.supercells import make_supercell as ase_make_supercell
-from ase.calculators.calculator import Calculator as ASECalculator
-from ase.calculators.calculator import all_changes as ase_all_changes
-from ase.calculators.emt import EMT as ASECalculatorEMT
-from ase.cluster import BodyCenteredCubic as ASEBodyCenteredCubic
-from ase.cluster import Decahedron as ASEDecahedron
-from ase.cluster import FaceCenteredCubic as ASEFaceCenteredCubic
-from ase.cluster import HexagonalClosedPacked as ASEHexagonalClosedPacked
-from ase.cluster import Icosahedron as ASEIcosahedron
-from ase.cluster import Octahedron as ASEOctahedron
-from ase.cluster import SimpleCubic as ASESimpleCubic
-from ase.cluster.wulff import wulff_construction as ASEWulffConstruction
-from ase.constraints import FixAtoms as ASEFixAtoms
-from ase.constraints import FixedPlane as ASEFixedPlane
-from pymatgen.analysis.defects.core import Interstitial as PymatgenInterstitial
-from pymatgen.analysis.defects.core import Substitution as PymatgenSubstitution
-from pymatgen.analysis.defects.core import Vacancy as PymatgenVacancy
-from pymatgen.analysis.defects.generators import VoronoiInterstitialGenerator as PymatgenVoronoiInterstitialGenerator
-from pymatgen.analysis.local_env import VoronoiNN as PymatgenVoronoiNN
-from pymatgen.core import IStructure as PymatgenIStructure
-from pymatgen.core import PeriodicSite as PymatgenPeriodicSite
-from pymatgen.core.interface import Interface as PymatgenInterface
-from pymatgen.core.interface import label_termination as label_pymatgen_slab_termination
-from pymatgen.core.structure import Lattice as PymatgenLattice
-from pymatgen.core.structure import Structure as PymatgenStructure
-from pymatgen.core.surface import Slab as PymatgenSlab
-from pymatgen.core.surface import SlabGenerator as PymatgenSlabGenerator
-from pymatgen.io.ase import AseAtomsAdaptor as PymatgenAseAtomsAdaptor
-from pymatgen.io.vasp.inputs import Poscar as PymatgenPoscar
-from pymatgen.symmetry.analyzer import SpacegroupAnalyzer as PymatgenSpacegroupAnalyzer
-
-# Re-exported imports to allow for both use in type hints and instantiation
-
-__all__ = [
-    "ASEAtoms",
-    "ASECalculator",
-    "ASECalculatorEMT",
-    "ASEFixAtoms",
-    "ASEFixedPlane",
-    "ase_all_changes",
-    "PymatgenLattice",
-    "PymatgenStructure",
-    "PymatgenIStructure",
-    "PymatgenSlab",
-    "PymatgenSlabGenerator",
-    "PymatgenInterface",
-    "PymatgenPeriodicSite",
-    "PymatgenSpacegroupAnalyzer",
-    "PymatgenVacancy",
-    "PymatgenSubstitution",
-    "PymatgenInterstitial",
-    "PymatgenVoronoiInterstitialGenerator",
-    "label_pymatgen_slab_termination",
-    "ase_make_supercell",
-    "ase_add_vacuum",
-    "PymatgenAseAtomsAdaptor",
-    "PymatgenPoscar",
-    "PymatgenVoronoiNN",
-    "ASESimpleCubic",
-    "ASEBodyCenteredCubic",
-    "ASEFaceCenteredCubic",
-    "ASEIcosahedron",
-    "ASEOctahedron",
-    "ASEDecahedron",
-    "ASEHexagonalClosedPacked",
-    "ASEWulffConstruction",
-]