@mat3ra/made 2024.5.15-0 → 2024.6.3-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2024.5.15-0",
+    "version": "2024.6.3-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",

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

@@ -55,3 +55,17 @@ def get_surface_area(atoms: Atoms):
     matrix = atoms.cell
     cross_product = np.cross(matrix[0], matrix[1])
     return np.linalg.norm(cross_product)
+
+
+@decorator_convert_material_args_kwargs_to_atoms
+def get_chemical_formula(atoms: Atoms):
+    """
+    Calculate the formula of the atoms structure.
+
+    Args:
+        atoms (ase.Atoms): The Atoms object to calculate the formula of.
+
+    Returns:
+        str: The formula of the atoms.
+    """
+    return atoms.get_chemical_formula()

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

@@ -1,80 +1,101 @@
+from typing import List, Optional, Any
+
+from pydantic import BaseModel
+
 from ...material import Material
-from .interface import InterfaceDataHolder, CoherentInterfaceBuilder, TerminationType
-from .interface import InterfaceSettings as Settings
-from .interface import interface_init_zsl_builder, interface_patch_with_mean_abs_strain
-from ..convert import decorator_convert_material_args_kwargs_to_structure
-from ..modify import translate_to_bottom, wrap_to_unit_cell
-from typing import Optional
-
-
-@decorator_convert_material_args_kwargs_to_structure
-def create_interfaces(
-    substrate: Optional[Material] = None,
-    layer: Optional[Material] = None,
-    settings: Settings = Settings(),
-    sort_by_strain_and_size: bool = True,
-    remove_duplicates: bool = True,
-    is_logging_enabled: bool = True,
-    interface_builder: Optional[CoherentInterfaceBuilder] = None,
-    termination: Optional[TerminationType] = None,
-) -> InterfaceDataHolder:
+
+
+class BaseBuilder(BaseModel):
     """
-    Create all interfaces between the substrate and layer structures using ZSL algorithm provided by pymatgen.
-
-    Args:
-        substrate (Material): The substrate structure.
-        layer (Material): The layer structure.
-        settings: The settings for the interface generation.
-        sort_by_strain_and_size (bool): Whether to sort the interfaces by strain and size.
-        remove_duplicates (bool): Whether to remove duplicate interfaces.
-        is_logging_enabled (bool): Whether to enable debug print.
-    Returns:
-        InterfaceDataHolder.
+    Base class for material builders.
+    This class provides an interface for generating materials and getter functions.
+    The builder is meant as a description of the process, while its functions require a
+    "Configuration" class instance to perform the generation.
+
+    The class is designed to be subclassed and the subclass should implement the following methods:
+
+    - `_generate`: Generate the material items, possibly using third-party tools/implementation for items.
+    - `_sort`: Sort the items.
+    - `_select`: Select a subset of the items.
+    - `_post_process`: Post-process the items to convert them to materials (Material class).
+    - `_finalize`: Finalize the materials.
+
+    The subclass should also define the following attributes:
+
+    - `_BuildParametersType`: The data structure model for the build parameters.
+    - `_DefaultBuildParameters`: The default build parameters.
+    - `_ConfigurationType`: The data structure model for the Configuration used during the build.
+    - `_GeneratedItemType`: The type of the generated item.
+    - `_SelectorParametersType`: The data structure model for the selector parameters.
+    - `_PostProcessParametersType`: The data structure model for the post-process parameters.
     """
-    if is_logging_enabled:
-        print("Creating interfaces...")
-
-    builder = interface_builder or init_interface_builder(substrate, layer, settings)
-    interfaces_data = InterfaceDataHolder()
-
-    if termination is not None:
-        builder.terminations = [termination]
-
-    for termination in builder.terminations:
-        all_interfaces_for_termination = builder.get_interfaces(
-            termination,
-            gap=settings.distance_z,
-            film_thickness=settings.LayerParameters.thickness,
-            substrate_thickness=settings.SubstrateParameters.thickness,
-            in_layers=True,
-        )
-
-        all_interfaces_for_termination_patched_wrapped = list(
-            map(
-                lambda i: wrap_to_unit_cell(interface_patch_with_mean_abs_strain(i)),
-                all_interfaces_for_termination,
-            )
-        )
-
-        interfaces_data.add_data_entries(
-            all_interfaces_for_termination_patched_wrapped,
-            sort_interfaces_by_strain_and_size=sort_by_strain_and_size,
-            remove_duplicates=remove_duplicates,
-        )
-
-    if is_logging_enabled:
-        unique_str = "unique" if remove_duplicates else ""
-        print(f"Found {len(interfaces_data.get_interfaces_for_termination(0))} {unique_str} interfaces.")
-
-    return interfaces_data
-
-
-@decorator_convert_material_args_kwargs_to_structure
-def init_interface_builder(
-    substrate: Material,
-    layer: Material,
-    settings: Settings,
-) -> CoherentInterfaceBuilder:
-    substrate = translate_to_bottom(substrate, settings.use_conventional_cell)
-    layer = translate_to_bottom(layer, settings.use_conventional_cell)
-    return interface_init_zsl_builder(substrate, layer, settings)
+
+    build_parameters: Any = None
+    _BuildParametersType: Any = None
+    _DefaultBuildParameters: Any = None
+
+    _ConfigurationType: Any = Any
+    _GeneratedItemType: Any = Any
+    _SelectorParametersType: Any = None
+    _PostProcessParametersType: Any = None
+
+    def __init__(self, build_parameters: _BuildParametersType = None):
+        super().__init__(build_parameters=build_parameters)
+        self.build_parameters = build_parameters or self._DefaultBuildParameters
+        self.__generated_items: List[List[BaseBuilder._GeneratedItemType]] = []
+        self.__configurations: List[BaseBuilder._ConfigurationType] = []
+
+    def _generate(self, configuration: _ConfigurationType) -> List[_GeneratedItemType]:
+        return []
+
+    def _generate_or_get_from_cache(self, configuration: _ConfigurationType) -> List[_GeneratedItemType]:
+        if configuration not in self.__configurations:
+            self.__configurations.append(configuration)
+            self.__generated_items.append(self._generate(configuration))
+        return self.__generated_items[self.__configurations.index(configuration)]
+
+    def _sort(self, items: List[_GeneratedItemType]) -> List[_GeneratedItemType]:
+        return items
+
+    def _select(
+        self, items: List[_GeneratedItemType], selector_parameters: Optional[_SelectorParametersType]
+    ) -> List[_GeneratedItemType]:
+        return items
+
+    def _post_process(
+        self, items: List[_GeneratedItemType], post_process_parameters: Optional[_PostProcessParametersType]
+    ) -> List[Material]:
+        return [Material(self._convert_generated_item(item)) for item in items]
+
+    @staticmethod
+    def _convert_generated_item(item: _GeneratedItemType):
+        material_config = item
+        return material_config
+
+    def _finalize(self, materials: List[Material], configuration: _ConfigurationType) -> List[Material]:
+        return [self._update_material_name(material, configuration) for material in materials]
+
+    def get_materials(
+        self,
+        configuration: _ConfigurationType,
+        selector_parameters: Optional[_SelectorParametersType] = None,
+        post_process_parameters: Optional[_PostProcessParametersType] = None,
+    ) -> List[Material]:
+        generated_items = self._generate_or_get_from_cache(configuration)
+        sorted_items = self._sort(generated_items)
+        selected_items = self._select(sorted_items, selector_parameters)
+        materials = self._post_process(selected_items, post_process_parameters)
+        finalized_materials = self._finalize(materials, configuration)
+        return finalized_materials
+
+    def get_material(
+        self,
+        configuration: _ConfigurationType,
+        selector_parameters: Optional[_SelectorParametersType] = None,
+        post_process_parameters: Optional[_PostProcessParametersType] = None,
+    ) -> Material:
+        return self.get_materials(configuration, selector_parameters, post_process_parameters)[0]
+
+    def _update_material_name(self, material, configuration):
+        # Do nothing by default
+        return material

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

@@ -0,0 +1,26 @@
+from typing import Union, List, Optional
+
+from mat3ra.made.material import Material
+from .builders import (
+    SimpleInterfaceBuilder,
+    SimpleInterfaceBuilderParameters,
+    ZSLStrainMatchingParameters,
+    ZSLStrainMatchingInterfaceBuilder,
+    ZSLStrainMatchingInterfaceBuilderParameters,
+)
+from .configuration import InterfaceConfiguration
+
+
+def create_interfaces(
+    builder: Union[SimpleInterfaceBuilder, ZSLStrainMatchingInterfaceBuilder], configuration: InterfaceConfiguration
+) -> List[Material]:
+    return builder.get_materials(configuration)
+
+
+def create_interface(
+    configuration: InterfaceConfiguration,
+    builder: Optional[Union[SimpleInterfaceBuilder, ZSLStrainMatchingInterfaceBuilder]] = None,
+) -> Material:
+    if builder is None:
+        builder = SimpleInterfaceBuilder(build_parameters=SimpleInterfaceBuilderParameters())
+    return builder.get_material(configuration)

package/src/py/mat3ra/made/tools/build/interface/builders.py

@@ -0,0 +1,185 @@
+from typing import Any, List, Optional
+
+import numpy as np
+from pydantic import BaseModel
+from ase.build.tools import niggli_reduce
+from pymatgen.analysis.interfaces.coherent_interfaces import (
+    CoherentInterfaceBuilder,
+    ZSLGenerator,
+)
+
+from mat3ra.made.material import Material
+from .enums import StrainModes
+from .configuration import InterfaceConfiguration
+from .termination_pair import TerminationPair, safely_select_termination_pair
+from .utils import interface_patch_with_mean_abs_strain, remove_duplicate_interfaces
+from ..mixins import (
+    ConvertGeneratedItemsASEAtomsMixin,
+    ConvertGeneratedItemsPymatgenStructureMixin,
+)
+from ..slab import create_slab, Termination
+from ..slab.configuration import SlabConfiguration
+from ...analyze import get_chemical_formula
+from ...convert import to_ase, from_ase, to_pymatgen, PymatgenInterface, ASEAtoms
+from ...build import BaseBuilder
+
+
+class InterfaceBuilderParameters(BaseModel):
+    pass
+
+
+class InterfaceBuilder(BaseBuilder):
+    _BuildParametersType = InterfaceBuilderParameters
+    _ConfigurationType: type(InterfaceConfiguration) = InterfaceConfiguration  # type: ignore
+
+    def _update_material_name(self, material: Material, configuration: InterfaceConfiguration) -> Material:
+        film_formula = get_chemical_formula(configuration.film_configuration.bulk)
+        substrate_formula = get_chemical_formula(configuration.substrate_configuration.bulk)
+        film_miller_indices = "".join([str(i) for i in configuration.film_configuration.miller_indices])
+        substrate_miller_indices = "".join([str(i) for i in configuration.substrate_configuration.miller_indices])
+        new_name = f"{film_formula}({film_miller_indices})-{substrate_formula}({substrate_miller_indices}), Interface"
+        material.name = new_name
+        return material
+
+
+########################################################################################
+#                           Simple Interface Builder                                   #
+########################################################################################
+class SimpleInterfaceBuilderParameters(InterfaceBuilderParameters):
+    scale_film: bool = True
+
+
+class SimpleInterfaceBuilder(ConvertGeneratedItemsASEAtomsMixin, InterfaceBuilder):
+    """
+    Creates matching interface between substrate and film by straining the film to match the substrate.
+    """
+
+    _BuildParametersType = Optional[SimpleInterfaceBuilderParameters]
+    _DefaultBuildParameters = SimpleInterfaceBuilderParameters(scale_film=True)
+    _GeneratedItemType: type(ASEAtoms) = ASEAtoms  # type: ignore
+
+    @staticmethod
+    def __preprocess_slab_configuration(configuration: SlabConfiguration, termination: Termination):
+        slab = create_slab(configuration, termination)
+        ase_slab = to_ase(slab)
+        niggli_reduce(ase_slab)
+        return ase_slab
+
+    @staticmethod
+    def __combine_two_slabs_ase(substrate_slab_ase: ASEAtoms, film_slab_ase: ASEAtoms, distance_z: float) -> ASEAtoms:
+        max_z_substrate = max(substrate_slab_ase.positions[:, 2])
+        min_z_film = min(film_slab_ase.positions[:, 2])
+        shift_z = max_z_substrate - min_z_film + distance_z
+
+        film_slab_ase.translate([0, 0, shift_z])
+
+        return substrate_slab_ase + film_slab_ase
+
+    @staticmethod
+    def __add_vacuum_along_c_ase(interface_ase: ASEAtoms, vacuum: float) -> ASEAtoms:
+        cell_c_with_vacuum = max(interface_ase.positions[:, 2]) + vacuum
+        interface_ase.cell[2, 2] = cell_c_with_vacuum
+        return interface_ase
+
+    def _generate(self, configuration: InterfaceBuilder._ConfigurationType) -> List[_GeneratedItemType]:  # type: ignore
+        film_slab_ase = self.__preprocess_slab_configuration(
+            configuration.film_configuration, configuration.film_termination
+        )
+        substrate_slab_ase = self.__preprocess_slab_configuration(
+            configuration.substrate_configuration, configuration.substrate_termination
+        )
+
+        if self.build_parameters.scale_film:
+            film_slab_ase.set_cell(substrate_slab_ase.cell, scale_atoms=True)
+            film_slab_ase.wrap()
+
+        interface_ase = self.__combine_two_slabs_ase(substrate_slab_ase, film_slab_ase, configuration.distance_z)
+        interface_ase_with_vacuum = self.__add_vacuum_along_c_ase(interface_ase, configuration.vacuum)
+
+        return [interface_ase_with_vacuum]
+
+    def _post_process(self, items: List[_GeneratedItemType], post_process_parameters=None) -> List[Material]:
+        return [Material(from_ase(slab)) for slab in items]
+
+
+########################################################################################
+#                       Strain Matching Interface Builders                             #
+########################################################################################
+class StrainMatchingInterfaceBuilderParameters(BaseModel):
+    strain_matching_parameters: Optional[Any] = None
+
+
+class StrainMatchingInterfaceBuilder(InterfaceBuilder):
+    _BuildParametersType = StrainMatchingInterfaceBuilderParameters  # type: ignore
+
+    def _update_material_name(self, material: Material, configuration: InterfaceConfiguration) -> Material:
+        updated_material = super()._update_material_name(material, configuration)
+        if StrainModes.mean_abs_strain in material.metadata:
+            strain = material.metadata[StrainModes.mean_abs_strain]
+            new_name = f"{updated_material.name}, Strain {strain*100:.3f}%"
+            updated_material.name = new_name
+        return material
+
+
+class ZSLStrainMatchingParameters(BaseModel):
+    max_area: float = 50.0
+    max_area_ratio_tol: float = 0.09
+    max_length_tol: float = 0.03
+    max_angle_tol: float = 0.01
+
+
+class ZSLStrainMatchingInterfaceBuilderParameters(StrainMatchingInterfaceBuilderParameters):
+    strain_matching_parameters: ZSLStrainMatchingParameters
+
+
+class ZSLStrainMatchingInterfaceBuilder(ConvertGeneratedItemsPymatgenStructureMixin, StrainMatchingInterfaceBuilder):
+    """
+    Creates matching interface between substrate and film using the ZSL algorithm.
+    """
+
+    _BuildParametersType: type(  # type: ignore
+        ZSLStrainMatchingInterfaceBuilderParameters
+    ) = ZSLStrainMatchingInterfaceBuilderParameters  # type: ignore
+    _GeneratedItemType: PymatgenInterface = PymatgenInterface  # type: ignore
+
+    def _generate(self, configuration: InterfaceConfiguration) -> List[PymatgenInterface]:
+        generator = ZSLGenerator(**self.build_parameters.strain_matching_parameters.dict())
+        builder = CoherentInterfaceBuilder(
+            substrate_structure=to_pymatgen(configuration.substrate_configuration.bulk),
+            film_structure=to_pymatgen(configuration.film_configuration.bulk),
+            substrate_miller=configuration.substrate_configuration.miller_indices,
+            film_miller=configuration.film_configuration.miller_indices,
+            zslgen=generator,
+        )
+
+        generated_termination_pairs = [
+            TerminationPair.from_pymatgen(pymatgen_termination) for pymatgen_termination in builder.terminations
+        ]
+        termination_pair = safely_select_termination_pair(configuration.termination_pair, generated_termination_pairs)
+        interfaces = builder.get_interfaces(
+            termination=termination_pair.to_pymatgen(),
+            gap=configuration.distance_z,
+            film_thickness=configuration.film_configuration.thickness,
+            substrate_thickness=configuration.substrate_configuration.thickness,
+            in_layers=True,
+        )
+
+        return list([interface_patch_with_mean_abs_strain(interface) for interface in interfaces])
+
+    def _sort(self, items: List[_GeneratedItemType]):
+        sorted_by_num_sites = sorted(items, key=lambda x: x.num_sites)
+        sorted_by_num_sites_and_strain = sorted(
+            sorted_by_num_sites, key=lambda x: np.mean(x.interface_properties[StrainModes.mean_abs_strain])
+        )
+        unique_sorted_interfaces = remove_duplicate_interfaces(
+            sorted_by_num_sites_and_strain, strain_mode=StrainModes.mean_abs_strain
+        )
+        return unique_sorted_interfaces
+
+    def _post_process(self, items: List[_GeneratedItemType], post_process_parameters=None) -> List[Material]:
+        materials = super()._post_process(items, post_process_parameters)
+        strains = [interface.interface_properties[StrainModes.mean_abs_strain] for interface in items]
+
+        for material, strain in zip(materials, strains):
+            material.metadata["mean_abs_strain"] = strain
+        return materials

package/src/py/mat3ra/made/tools/build/interface/configuration.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+
+from .termination_pair import TerminationPair
+from ..slab import Termination
+from ..slab.configuration import SlabConfiguration
+
+
+class InterfaceConfiguration(BaseModel):
+    film_configuration: SlabConfiguration
+    substrate_configuration: SlabConfiguration
+    film_termination: Termination
+    substrate_termination: Termination
+    distance_z: float = 3.0
+    vacuum: float = 5.0
+
+    @property
+    def termination_pair(self):
+        return TerminationPair(self.film_termination, self.substrate_termination)

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

@@ -0,0 +1,7 @@
+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/interface/termination_pair.py

@@ -0,0 +1,59 @@
+from typing import Tuple, List
+from pydantic import BaseModel
+
+from ..slab.termination import Termination
+
+
+class TerminationPair(BaseModel):
+    film_termination: Termination
+    substrate_termination: Termination
+
+    def __str__(self):
+        # return str(self.to_tuple_of_str())
+        return f"({self.film_termination}, {self.substrate_termination})"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __init__(self, film_termination: Termination, substrate_termination: Termination):
+        super().__init__(film_termination=film_termination, substrate_termination=substrate_termination)
+
+    @classmethod
+    def from_tuple_of_str(cls, termination_pair: Tuple[str, str]):
+        film_termination = Termination.from_string(termination_pair[0])
+        substrate_termination = Termination.from_string(termination_pair[1])
+        return cls(film_termination=film_termination, substrate_termination=substrate_termination)
+
+    def to_tuple_of_str(self) -> Tuple[str, str]:
+        return str(self.film_termination), str(self.substrate_termination)
+
+    @classmethod
+    def from_pymatgen(cls, termination_pair: Tuple[str, str]):
+        return cls.from_tuple_of_str(termination_pair)
+
+    def to_pymatgen(self) -> Tuple[str, str]:
+        return self.to_tuple_of_str()
+
+
+def safely_select_termination_pair(
+    provided_termination_pair: TerminationPair, generated_termination_pairs: List[TerminationPair]
+) -> TerminationPair:
+    """
+    Attempt finding provided in generated terminations to find a complete match,
+    if match isn't found, get terminations with equivalent chemical elements.
+    """
+    provided_film_termination = provided_termination_pair.film_termination
+    provided_substrate_termination = provided_termination_pair.substrate_termination
+    hotfix_termination_pair = provided_termination_pair
+    if provided_termination_pair not in generated_termination_pairs:
+        for termination_pair in generated_termination_pairs:
+            generated_film_termination = termination_pair.film_termination
+            generated_substrate_termination = termination_pair.substrate_termination
+            if (
+                generated_film_termination.chemical_elements == provided_film_termination.chemical_elements
+                and generated_substrate_termination.chemical_elements
+                == provided_substrate_termination.chemical_elements
+            ):
+                hotfix_termination_pair = termination_pair
+                print("Interface will be built with terminations: ", hotfix_termination_pair)
+    return hotfix_termination_pair

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

@@ -0,0 +1,36 @@
+import types
+from typing import List
+import numpy as np
+from .enums import StrainModes
+from ...convert import PymatgenInterface
+
+
+def interface_patch_with_mean_abs_strain(target: PymatgenInterface, tolerance: float = 10e-6):
+    def get_mean_abs_strain(target):
+        return target.interface_properties[StrainModes.mean_abs_strain]
+
+    target.get_mean_abs_strain = types.MethodType(get_mean_abs_strain, target)
+    target.interface_properties[StrainModes.mean_abs_strain] = (
+        round(np.mean(np.abs(target.interface_properties["strain"])) / tolerance) * tolerance
+    )
+    return target
+
+
+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

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

@@ -0,0 +1,13 @@
+from ..convert import from_ase, from_pymatgen, ASEAtoms, PymatgenStructure
+
+
+class ConvertGeneratedItemsASEAtomsMixin:
+    @staticmethod
+    def _convert_generated_item(item: ASEAtoms):
+        return from_ase(item)
+
+
+class ConvertGeneratedItemsPymatgenStructureMixin:
+    @staticmethod
+    def _convert_generated_item(item: PymatgenStructure):
+        return from_pymatgen(item)

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

@@ -0,0 +1,15 @@
+from typing import List
+
+from mat3ra.made.material import Material
+from .builders import SlabBuilder, SlabSelectorParameters
+from .configuration import SlabConfiguration
+from .termination import Termination
+
+
+def get_terminations(configuration: SlabConfiguration) -> List[Termination]:
+    return SlabBuilder().get_terminations(configuration)
+
+
+def create_slab(configuration: SlabConfiguration, termination: Termination) -> Material:
+    builder = SlabBuilder()
+    return builder.get_material(configuration, selector_parameters=SlabSelectorParameters(termination=termination))

package/src/py/mat3ra/made/tools/build/slab/builders.py

@@ -0,0 +1,75 @@
+from pymatgen.core.surface import SlabGenerator as PymatgenSlabGenerator
+from ...convert import label_pymatgen_slab_termination
+from typing import List
+from pydantic import BaseModel
+
+
+from mat3ra.made.material import Material
+
+from .termination import Termination
+from ...analyze import get_chemical_formula
+from ...convert import to_pymatgen, PymatgenSlab
+from ...build import BaseBuilder
+from ...build.mixins import ConvertGeneratedItemsPymatgenStructureMixin
+from ..supercell import create_supercell
+from .configuration import SlabConfiguration
+
+
+class SlabSelectorParameters(BaseModel):
+    termination: Termination
+
+
+class SlabBuilder(ConvertGeneratedItemsPymatgenStructureMixin, BaseBuilder):
+    _ConfigurationType: type(SlabConfiguration) = SlabConfiguration  # type: ignore
+    _GeneratedItemType: PymatgenSlab = PymatgenSlab  # type: ignore
+    _SelectorParametersType: type(SlabSelectorParameters) = SlabSelectorParameters  # type: ignore
+    __configuration: SlabConfiguration
+
+    def _generate(self, configuration: _ConfigurationType) -> List[_GeneratedItemType]:  # type: ignore
+        generator = PymatgenSlabGenerator(
+            initial_structure=to_pymatgen(configuration.bulk),
+            miller_index=configuration.miller_indices,
+            min_slab_size=configuration.thickness,
+            min_vacuum_size=configuration.vacuum,
+            in_unit_planes=True,
+            reorient_lattice=True,
+        )
+        raw_slabs = generator.get_slabs()
+        self.__configuration = configuration
+
+        return [self.__conditionally_convert_slab_to_orthogonal_pymatgen(slab) for slab in raw_slabs]
+
+    def _select(
+        self, items: List[_GeneratedItemType], selector_parameters: _SelectorParametersType
+    ) -> List[_GeneratedItemType]:
+        termination = selector_parameters.termination
+        return [slab for slab in items if self.__create_termination_from_slab_pymatgen(slab) == termination]
+
+    def _post_process(self, items: List[_GeneratedItemType], post_process_parameters=None) -> List[Material]:
+        materials = super()._post_process(items, post_process_parameters)
+        materials = [create_supercell(material, self.__configuration.xy_supercell_matrix) for material in materials]
+        for idx, material in enumerate(materials):
+            material.metadata["termination"] = label_pymatgen_slab_termination(items[idx])
+
+        return materials
+
+    def get_terminations(self, configuration: _ConfigurationType) -> List[Termination]:
+        return [
+            self.__create_termination_from_slab_pymatgen(slab)
+            for slab in self._generate_or_get_from_cache(configuration)
+        ]
+
+    def __conditionally_convert_slab_to_orthogonal_pymatgen(self, slab: PymatgenSlab) -> PymatgenSlab:
+        return slab.get_orthogonal_c_slab() if self.__configuration.use_orthogonal_z else slab
+
+    def __create_termination_from_slab_pymatgen(self, slab: PymatgenSlab) -> Termination:
+        return Termination.from_string(label_pymatgen_slab_termination(slab))
+
+    def _update_material_name(self, material: Material, configuration: SlabConfiguration) -> Material:
+        formula = get_chemical_formula(configuration.bulk)
+        miller_indices = "".join([str(i) for i in configuration.miller_indices])
+        termination = material.metadata["termination"]
+        # for example: "Si8(001), termination Si_P4/mmm_1, Slab"
+        new_name = f"{formula}({miller_indices}), termination {termination}, Slab"
+        material.name = new_name
+        return material