@mat3ra/made 2024.5.15-1 → 2024.6.4-0

package/dist/js/cell/cell.d.ts

@@ -1,6 +1,7 @@
+import CodeMath from "@mat3ra/code/dist/js/math";
 import { Coordinate } from "../basis/types";
 import { Vector, VectorsAsArray } from "../lattice/types";
-type Point = Coordinate | math.Matrix | math.MathType;
+type Point = Coordinate | CodeMath.Matrix | CodeMath.MathType;
 export declare class Cell {
     tolerance: number;
     vector1: Vector;
@@ -21,7 +22,7 @@ export declare class Cell {
     /**
      * Convert a point (in crystal coordinates) to cartesian.
      */
-    convertPointToCartesian(point: Point): import("mathjs").MathType;
+    convertPointToCartesian(point: Point): CodeMath.MathType;
     /**
      * Convert a point (in cartesian coordinates) to crystal (fractional).
      */

package/dist/js/lattice/lattice.d.ts

@@ -83,7 +83,7 @@ export declare class Lattice extends LatticeBravais implements LatticeSchema {
         beta: number;
         gamma: number;
         units: {
-            length?: "bohr" | "angstrom" | undefined;
+            length?: "angstrom" | "bohr" | undefined;
             angle?: "degree" | "radian" | undefined;
         };
         type: "CUB" | "BCC" | "FCC" | "TET" | "MCL" | "ORC" | "ORCC" | "ORCF" | "ORCI" | "HEX" | "BCT" | "TRI" | "MCLC" | "RHL";

package/dist/js/material.d.ts

@@ -1,5 +1,5 @@
 import { HasConsistencyChecksHasMetadataNamedDefaultableInMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { AnyObject } from "@mat3ra/code/dist/js/entity/in_memory";
+import { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import { ConsistencyCheck, DerivedPropertiesSchema, FileSourceSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
 import { ConstrainedBasis } from "./basis/constrained_basis";
 import { Constraint } from "./constraints/constraints";
@@ -483,9 +483,7 @@ export declare const Material: {
     setProps(json?: AnyObject | undefined): any;
     toJSON(exclude?: string[] | undefined): AnyObject;
     toJSONSafe(exclude?: string[] | undefined): AnyObject;
-    toJSONQuick(exclude?: string[] | undefined): AnyObject; /**
-     * Returns a copy of the material with conventional cell constructed instead of primitive.
-     */
+    toJSONQuick(exclude?: string[] | undefined): AnyObject;
     clone(extraContext?: object | undefined): any;
     validate(): void;
     clean(config: AnyObject): AnyObject;
@@ -511,10 +509,7 @@ export declare const Material: {
     toJSONQuick(exclude?: string[] | undefined): AnyObject;
     clone(extraContext?: object | undefined): any;
     validate(): void;
-    clean(config: AnyObject): AnyObject; /**
-     * @summary a series of checks for the material's basis and returns an array of results in ConsistencyChecks format.
-     * @returns Array of checks results
-     */
+    clean(config: AnyObject): AnyObject;
     isValid(): boolean;
     id: string;
     readonly cls: string;

package/dist/js/math.d.ts

@@ -35,7 +35,7 @@ declare const _default: {
     uninitialized: any;
     version: string;
     expression: import("mathjs").MathNode;
-    json: mathjs.MathJsJson;
+    json: import("mathjs").MathJsJson;
     config: (options: any) => void;
     lsolve(L: import("mathjs").Matrix | import("mathjs").MathArray, b: import("mathjs").Matrix | import("mathjs").MathArray): import("mathjs").Matrix | import("mathjs").MathArray;
     lup(A?: import("mathjs").Matrix | import("mathjs").MathArray | undefined): import("mathjs").MathArray;
@@ -184,7 +184,7 @@ declare const _default: {
     re(x: number | import("mathjs").Matrix | import("mathjs").BigNumber | import("mathjs").Complex | import("mathjs").MathArray): number | import("mathjs").Matrix | import("mathjs").BigNumber | import("mathjs").MathArray;
     bignumber(x?: string | number | boolean | import("mathjs").Matrix | import("mathjs").MathArray | undefined): import("mathjs").BigNumber;
     boolean(x: string | number | boolean | import("mathjs").Matrix | import("mathjs").MathArray): boolean | import("mathjs").Matrix | import("mathjs").MathArray;
-    chain(value?: any): any;
+    chain(value?: any): import("mathjs").MathJsChain;
     complex(arg?: string | import("mathjs").Complex | import("mathjs").MathArray | import("mathjs").PolarCoordinates | undefined): import("mathjs").Complex;
     complex(re: number, im: number): import("mathjs").Complex;
     fraction(numerator: string | number | import("mathjs").Matrix | import("mathjs").MathArray, denominator?: string | number | import("mathjs").Matrix | import("mathjs").MathArray | undefined): import("mathjs").Matrix | import("mathjs").Fraction | import("mathjs").MathArray;

package/dist/js/tools/material.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const mathjs_1 = __importDefault(require("mathjs"));
+const math_1 = require("@mat3ra/code/dist/js/math");
 const constants_1 = require("../constants");
 const lattice_1 = require("../lattice/lattice");
 /**
@@ -40,8 +37,8 @@ function getBasisConfigTranslatedToCenter(material) {
     material.toCartesian();
     const updatedBasis = material.Basis;
     const centerOfCoordinates = updatedBasis.centerOfCoordinatesPoint;
-    const centerOfLattice = mathjs_1.default.multiply(0.5, material.Lattice.vectorArrays.reduce((a, b) => mathjs_1.default.add(a, b)));
-    const translationVector = mathjs_1.default.subtract(centerOfLattice, centerOfCoordinates);
+    const centerOfLattice = math_1.math.multiply(0.5, material.Lattice.vectorArrays.reduce((a, b) => math_1.math.add(a, b)));
+    const translationVector = math_1.math.subtract(centerOfLattice, centerOfCoordinates);
     updatedBasis.translateByVector(translationVector);
     material.setBasis(updatedBasis.toJSON());
     if (originalUnits !== constants_1.ATOMIC_COORD_UNITS.cartesian)

package/dist/js/types.d.ts

@@ -1,3 +1,3 @@
-import { AnyObject } from "@mat3ra/code/dist/js/entity/in_memory";
+import { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
 export type MaterialJSON = MaterialSchema & AnyObject;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2024.5.15-1",
+    "version": "2024.6.4-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",
@@ -33,11 +33,10 @@
         "@babel/register": "^7.22.15",
         "@babel/runtime-corejs3": "^7.16.8",
         "@exabyte-io/eslint-config": "^2023.8.29-1",
-        "@mat3ra/code": "2024.3.25-3",
-        "@mat3ra/esse": "2024.3.25-6",
-        "@mat3ra/tsconfig": "^2024.3.25-5",
+        "@mat3ra/code": "2024.6.4-0",
+        "@mat3ra/esse": "2024.6.4-1",
+        "@mat3ra/tsconfig": "2024.6.3-0",
         "@types/crypto-js": "^4.2.2",
-        "@types/mathjs": "^3.21.1",
         "@typescript-eslint/eslint-plugin": "^5.9.1",
         "@typescript-eslint/parser": "^5.9.1",
         "chai": "^4.3.4",
@@ -72,7 +71,6 @@
         "array-almost-equal": "^1.0.0",
         "crypto-js": "4.2.0",
         "lodash": "^4.17.*",
-        "mathjs": "12.4.1",
         "ts-node": "^10.9.1",
         "typescript": "^4.5.5",
         "underscore": "^1.8.3",

package/src/js/cell/cell.ts

@@ -1,4 +1,4 @@
-import { math } from "@mat3ra/code/dist/js/math";
+import CodeMath, { math } from "@mat3ra/code/dist/js/math";
 
 import { Coordinate } from "../basis/types";
 import constants from "../constants";
@@ -10,7 +10,7 @@ const INV = math.inv;
 // @ts-ignore
 const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
 
-type Point = Coordinate | math.Matrix | math.MathType;
+type Point = Coordinate | CodeMath.Matrix | CodeMath.MathType;
 
 /*
  * Cell represents a unit cell in geometrical form: 3x3 matrix where rows are cell vectors.
@@ -64,7 +64,7 @@ export class Cell {
     /**
      * Convert a point (in crystal coordinates) to cartesian.
      */
-    convertPointToCartesian(point: Point) {
+    convertPointToCartesian(point: Point): CodeMath.MathType {
         return MULT(point, this.vectorsAsArray);
     }
 

package/src/js/material.ts

@@ -1,5 +1,5 @@
 import { HasConsistencyChecksHasMetadataNamedDefaultableInMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { AnyObject } from "@mat3ra/code/dist/js/entity/in_memory";
+import { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import {
     ConsistencyCheck,
     DerivedPropertiesSchema,

package/src/js/{math.js → math.ts}

@@ -1,6 +1,6 @@
 // TODO: adjust the imports and remove the need for re-exporting
-import { math as codeJSMath } from "@mat3ra/code/dist/js/math";
+import { math } from "@mat3ra/code/dist/js/math";
 
 export default {
-    ...codeJSMath,
+    ...math,
 };

package/src/js/tools/material.js

@@ -1,4 +1,4 @@
-import math from "mathjs";
+import { math } from "@mat3ra/code/dist/js/math";
 
 import { ATOMIC_COORD_UNITS } from "../constants";
 import { Lattice } from "../lattice/lattice";

package/src/js/types.ts

@@ -1,4 +1,4 @@
-import { AnyObject } from "@mat3ra/code/dist/js/entity/in_memory";
+import { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
 
 export type MaterialJSON = MaterialSchema & AnyObject;

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"