@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/entities/coordinate/box_coordinate_condition.py

@@ -1,15 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.core.reusable.coordinate_conditions.box import BoxCoordinateConditionSchema
-from pydantic import Field
-
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import is_coordinate_in_box
-
-
-class BoxCoordinateCondition(BoxCoordinateConditionSchema, CoordinateCondition):
-    min_coordinate: List[float] = Field(default_factory=lambda: [0, 0, 0])
-    max_coordinate: List[float] = Field(default_factory=lambda: [1, 1, 1])
-
-    def condition(self, coordinate: List[float]) -> bool:
-        return is_coordinate_in_box(coordinate, self.min_coordinate, self.max_coordinate)

package/src/py/mat3ra/made/tools/entities/coordinate/coordinate_condition.py

@@ -1,16 +0,0 @@
-from typing import Dict, List
-
-from pydantic import BaseModel
-
-
-class CoordinateCondition(BaseModel):
-    class Config:
-        arbitrary_types_allowed = True
-
-    def condition(self, coordinate: List[float]) -> bool:
-        raise NotImplementedError
-
-    def get_json(self) -> Dict:
-        json = {"type": self.__class__.__name__}
-        json.update(self.model_dump())
-        return json

package/src/py/mat3ra/made/tools/entities/coordinate/coordinate_functions.py

@@ -1,158 +0,0 @@
-# Place all functions acting on coordinates
-from typing import List
-
-import numpy as np
-
-
-def is_coordinate_in_cylinder(
-    coordinate: List[float], center_position: List[float], radius: float = 0.25, min_z: float = 0, max_z: float = 1
-) -> bool:
-    """
-    Check if a coordinate is inside a cylinder.
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        center_position (List[float]): The coordinates of the center position.
-        min_z (float): Lower limit of z-coordinate.
-        max_z (float): Upper limit of z-coordinate.
-        radius (float): The radius of the cylinder.
-
-    Returns:
-        bool: True if the coordinate is inside the cylinder, False otherwise.
-    """
-    np_coordinate = np.array(coordinate)
-    np_center_position = np.array(center_position)
-    distance_squared = np.sum((np_coordinate[:2] - np_center_position[:2]) ** 2)
-    return distance_squared <= radius**2 and min_z <= np_coordinate[2] <= max_z
-
-
-def is_coordinate_in_sphere(coordinate: List[float], center_position: List[float], radius: float = 0.25) -> bool:
-    """
-    Check if a coordinate is inside a sphere.
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        center_position (List[float]): The coordinates of the center position.
-        radius (float): The radius of the sphere.
-
-    Returns:
-        bool: True if the coordinate is inside the sphere, False otherwise.
-    """
-    np_coordinate = np.array(coordinate)
-    np_center_position = np.array(center_position)
-    distance_squared = np.sum((np_coordinate - np_center_position) ** 2)
-    return distance_squared <= radius**2
-
-
-def is_coordinate_in_box(coordinate: List[float], min_coordinate=None, max_coordinate=None) -> bool:
-    """
-    Check if a coordinate is inside a box.
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        min_coordinate (List[float]): The minimum coordinate of the box.
-        max_coordinate (List[float]): The maximum coordinate of the box.
-    Returns:
-        bool: True if the coordinate is inside the box, False otherwise.
-    """
-    if max_coordinate is None:
-        max_coordinate = [1, 1, 1]
-    if min_coordinate is None:
-        min_coordinate = [0, 0, 0]
-    np_coordinate = np.array(coordinate)
-    np_min_coordinate = np.array(min_coordinate)
-    np_max_coordinate = np.array(max_coordinate)
-    return bool(np.all(np_min_coordinate <= np_coordinate) and np.all(np_coordinate <= np_max_coordinate))
-
-
-def is_coordinate_within_layer(
-    coordinate: List[float], center_position: List[float], direction_vector: List[float], layer_thickness: float
-) -> bool:
-    """
-    Checks if a coordinate's projection along a specified direction vector
-    is within a certain layer thickness centered around a given position.
-
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        center_position (List[float]): The coordinates of the center position.
-        direction_vector (List[float]): The direction vector along which the layer thickness is defined.
-        layer_thickness (float): The thickness of the layer along the direction vector.
-
-    Returns:
-        bool: True if the coordinate is within the layer thickness, False otherwise.
-    """
-    direction_norm = np.array(direction_vector) / np.linalg.norm(direction_vector)
-    central_projection = np.dot(center_position, direction_norm)
-    layer_thickness_frac = layer_thickness / np.linalg.norm(direction_vector)
-
-    lower_bound = central_projection - layer_thickness_frac / 2
-    upper_bound = central_projection + layer_thickness_frac / 2
-
-    return lower_bound <= np.dot(coordinate, direction_norm) <= upper_bound
-
-
-def is_coordinate_in_triangular_prism(
-    coordinate: List[float],
-    coordinate_1: List[float],
-    coordinate_2: List[float],
-    coordinate_3: List[float],
-    min_z: float = 0,
-    max_z: float = 1,
-) -> bool:
-    """
-    Check if a coordinate is inside a triangular prism.
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        coordinate_1 (List[float]): The first coordinate of the triangle.
-        coordinate_2 (List[float]): The second coordinate of the triangle.
-        coordinate_3 (List[float]): The third coordinate of the triangle.
-        min_z (float): Lower limit of z-coordinate.
-        max_z (float): Upper limit of z-coordinate.
-
-    Returns:
-        bool: True if the coordinate is inside the triangular prism, False otherwise.
-    """
-    # convert to 3D coordinates at the origin XY plane
-    coordinate_1.extend([0] * (3 - len(coordinate_1)))
-    coordinate_2.extend([0] * (3 - len(coordinate_2)))
-    coordinate_3.extend([0] * (3 - len(coordinate_3)))
-
-    np_coordinate = np.array(coordinate)
-    v1 = np.array(coordinate_1)
-    v2 = np.array(coordinate_2)
-    v3 = np.array(coordinate_3)
-
-    v2_v1 = v2 - v1
-    v3_v1 = v3 - v1
-    coordinate_v1 = np_coordinate - v1
-
-    # Compute dot products for the barycentric coordinates
-    d00 = np.dot(v2_v1, v2_v1)
-    d01 = np.dot(v2_v1, v3_v1)
-    d11 = np.dot(v3_v1, v3_v1)
-    d20 = np.dot(coordinate_v1, v2_v1)
-    d21 = np.dot(coordinate_v1, v3_v1)
-
-    # Calculate barycentric coordinates
-    denom = d00 * d11 - d01 * d01
-    v = (d11 * d20 - d01 * d21) / denom
-    w = (d00 * d21 - d01 * d20) / denom
-    u = 1.0 - v - w
-
-    return (u >= 0) and (v >= 0) and (w >= 0) and (u + v + w <= 1) and (min_z <= np_coordinate[2] <= max_z)
-
-
-def is_coordinate_behind_plane(
-    coordinate: List[float], plane_normal: List[float], plane_point_coordinate: List[float]
-) -> bool:
-    """
-    Check if a coordinate is behind a plane.
-    Args:
-        coordinate (List[float]): The coordinate to check.
-        plane_normal (List[float]): The normal vector of the plane.
-        plane_point_coordinate (List[float]): The coordinate of a point on the plane.
-
-    Returns:
-        bool: True if the coordinate is behind the plane, False otherwise.
-    """
-    np_coordinate = np.array(coordinate)
-    np_plane_normal = np.array(plane_normal)
-    np_plane_point = np.array(plane_point_coordinate)
-    return np.dot(np_plane_normal, np_coordinate - np_plane_point) < 0

package/src/py/mat3ra/made/tools/entities/coordinate/cylinder_coordinate_condition.py

@@ -1,17 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.core.reusable.coordinate_conditions.cylinder import CylinderCoordinateConditionSchema
-from pydantic import Field
-
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import is_coordinate_in_cylinder
-
-
-class CylinderCoordinateCondition(CylinderCoordinateConditionSchema, CoordinateCondition):
-    center_position: List[float] = Field(default_factory=lambda: [0.5, 0.5])
-    radius: float = 0.25
-    min_z: float = 0
-    max_z: float = 1
-
-    def condition(self, coordinate: List[float]) -> bool:
-        return is_coordinate_in_cylinder(coordinate, self.center_position, self.radius, self.min_z, self.max_z)

package/src/py/mat3ra/made/tools/entities/coordinate/plane_coordinate_condition.py

@@ -1,14 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.core.reusable.coordinate_conditions.plane import PlaneCoordinateConditionSchema
-
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import is_coordinate_behind_plane
-
-
-class PlaneCoordinateCondition(PlaneCoordinateConditionSchema, CoordinateCondition):
-    plane_normal: List[float]
-    plane_point_coordinate: List[float]
-
-    def condition(self, coordinate: List[float]) -> bool:
-        return is_coordinate_behind_plane(coordinate, self.plane_normal, self.plane_point_coordinate)

package/src/py/mat3ra/made/tools/entities/coordinate/sphere_coordinate_condition.py

@@ -1,15 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.core.reusable.coordinate_conditions.sphere import SphereCoordinateConditionSchema
-from pydantic import Field
-
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import is_coordinate_in_sphere
-
-
-class SphereCoordinateCondition(SphereCoordinateConditionSchema, CoordinateCondition):
-    center_coordinate: List[float] = Field(default_factory=lambda: [0.5, 0.5, 0.5])
-    radius: float = 0.25
-
-    def condition(self, coordinate: List[float]) -> bool:
-        return is_coordinate_in_sphere(coordinate, self.center_coordinate, self.radius)

package/src/py/mat3ra/made/tools/entities/coordinate/triangular_prism_coordinate_condition.py

@@ -1,26 +0,0 @@
-from typing import List
-
-from mat3ra.esse.models.core.reusable.coordinate_conditions.triangular_prism import (
-    TriangularPrismCoordinateConditionSchema,
-)
-
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import is_coordinate_in_triangular_prism
-
-
-class TriangularPrismCoordinateCondition(TriangularPrismCoordinateConditionSchema, CoordinateCondition):
-    position_on_surface_1: List[float] = [0, 0]
-    position_on_surface_2: List[float] = [1, 0]
-    position_on_surface_3: List[float] = [0, 1]
-    min_z: float = 0
-    max_z: float = 1
-
-    def condition(self, coordinate: List[float]) -> bool:
-        return is_coordinate_in_triangular_prism(
-            coordinate,
-            self.position_on_surface_1,
-            self.position_on_surface_2,
-            self.position_on_surface_3,
-            self.min_z,
-            self.max_z,
-        )

package/src/py/mat3ra/made/tools/entities/termination_holder.py

@@ -1,12 +0,0 @@
-from typing import Optional
-
-from mat3ra.code.entity import InMemoryEntityPydantic
-
-from ..build_components.entities.auxiliary.two_dimensional.termination import Termination
-
-
-class TerminationHolder(InMemoryEntityPydantic):
-    termination_with_vacuum: Termination
-    termination_without_vacuum: Optional[Termination]
-    shift_with_vacuum: float
-    shift_without_vacuum: Optional[float]

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

@@ -1,168 +0,0 @@
-# Analyzers
-from .analyze.lattice import get_material_with_conventional_lattice, get_material_with_primitive_lattice
-
-# Defective Structures
-from .build.compound_pristine_structures.two_dimensional.heterostructure import create_heterostructure
-from .build.compound_pristine_structures.two_dimensional.heterostructure.types import StackComponentDict
-
-# Compound Pristine Structures
-from .build.compound_pristine_structures.two_dimensional.interface.base.helpers import (
-    create_interface_simple,
-    create_interface_simple_between_slabs,
-)
-from .build.compound_pristine_structures.two_dimensional.interface.commensurate.helpers import (
-    create_interface_commensurate,
-    get_commensurate_strained_configurations,
-)
-from .build.compound_pristine_structures.two_dimensional.interface.twisted.helpers import create_interface_twisted
-from .build.compound_pristine_structures.two_dimensional.interface.utils import get_optimal_film_displacement
-from .build.compound_pristine_structures.two_dimensional.interface.zsl.helpers import (
-    create_interface_zsl,
-    create_interface_zsl_between_slabs,
-)
-
-# Defective Structures
-from .build.defective_structures.one_dimensional.grain_boundary_linear.helpers import create_grain_boundary_linear
-from .build.defective_structures.two_dimensional.adatom.helpers import (
-    create_defect_adatom,
-    create_multiple_adatom_defects,
-    get_adatom_defect_analyzer_cls,
-)
-from .build.defective_structures.two_dimensional.adatom.types import AdatomDefectDict
-from .build.defective_structures.two_dimensional.grain_boundary_planar.helpers import create_grain_boundary_planar
-from .build.defective_structures.two_dimensional.island.helpers import create_defect_island, get_coordinate_condition
-from .build.defective_structures.two_dimensional.terrace.helpers import create_defect_terrace
-from .build.defective_structures.zero_dimensional.pair_defect.helpers import create_defect_pair
-from .build.defective_structures.zero_dimensional.point_defect.helpers import create_multiple_defects
-from .build.defective_structures.zero_dimensional.point_defect.interstitial.helpers import (
-    create_defect_point_interstitial,
-)
-from .build.defective_structures.zero_dimensional.point_defect.substitutional.helpers import (
-    create_defect_point_substitution,
-)
-from .build.defective_structures.zero_dimensional.point_defect.types import PointDefectDict
-from .build.defective_structures.zero_dimensional.point_defect.vacancy.helpers import create_defect_point_vacancy
-from .build.defective_structures.three_dimensional.solid_solution.helpers import create_solid_solution
-
-# Pristine Structures
-from .build.pristine_structures.three_dimensional.ideal_crystal.helpers import create_monolayer
-from .build.pristine_structures.two_dimensional.nanoribbon.helpers import create_nanoribbon
-from .build.pristine_structures.two_dimensional.nanotape.helpers import create_nanotape
-from .build.pristine_structures.two_dimensional.slab.helpers import (
-    create_slab,
-    create_slab_if_not,
-    get_slab_material_in_standard_representation,
-    get_slab_terminations,
-)
-from .build.pristine_structures.two_dimensional.slab.termination_utils import select_slab_termination
-from .build.pristine_structures.zero_dimensional.nanoparticle.helpers import (
-    create_nanoparticle_by_shape,
-    create_nanoparticle_by_shape_from_element,
-    create_nanoparticle_from_material,
-)
-
-# Enums
-from .build.processed_structures.two_dimensional.passivation.enums import SurfaceTypesEnum
-
-# Processed Structures
-from .build.processed_structures.two_dimensional.passivation.helpers import (
-    get_coordination_numbers_distribution,
-    get_unique_coordination_numbers,
-    passivate_dangling_bonds,
-    passivate_surface,
-)
-from .build_components.entities.reusable.one_dimensional.crystal_lattice_lines.edge_types import EdgeTypesEnum
-from .build_components.entities.reusable.one_dimensional.crystal_lattice_lines.helpers import (
-    create_lattice_lines_config_and_material,
-)
-
-# Build Components (for operations and utilities)
-from .build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-from .build_components.entities.reusable.two_dimensional.atomic_layers_unique_repeated.helpers import (
-    create_atomic_layers,
-)
-from .build_components.entities.reusable.two_dimensional.slab_stack.helpers import (
-    create_slab_stack,
-    recreate_slab_with_fractional_layers,
-)
-from .build_components.operations.core.modifications.perturb.helpers import create_perturbation
-
-# Entities
-from .entities.coordinate import CoordinateCondition
-
-__all__ = [
-    # Crystal and related analyzer functions
-    "get_material_with_primitive_lattice",
-    "get_material_with_conventional_lattice",
-    # Slab and related Functions
-    "create_slab",
-    "create_slab_if_not",
-    "get_slab_material_in_standard_representation",
-    "create_atomic_layers",
-    "get_slab_terminations",
-    "select_slab_termination",
-    "create_supercell",
-    "create_monolayer",
-    "create_perturbation",
-    # heterostructure Functions
-    "create_heterostructure",
-    "create_lattice_lines_config_and_material",
-    # Nanostructure Functions
-    "create_nanoparticle_from_material",
-    "create_nanoparticle_by_shape",
-    "create_nanoparticle_by_shape_from_element",
-    "create_nanoribbon",
-    "create_nanotape",
-    # Point Defect Functions
-    "create_defect_point_vacancy",
-    "create_defect_point_substitution",
-    "create_defect_point_interstitial",
-    "create_multiple_defects",
-    "create_solid_solution",
-    # Surface Defect Functions
-    "create_defect_adatom",
-    "create_multiple_adatom_defects",
-    "get_adatom_defect_analyzer_cls",
-    "create_defect_island",
-    "get_coordinate_condition",
-    "create_defect_terrace",
-    # Complex Defect Functions
-    "create_defect_pair",
-    "create_slab_stack",
-    "recreate_slab_with_fractional_layers",
-    # Interface Functions
-    "create_interface_simple",
-    "create_interface_simple_between_slabs",
-    "create_interface_zsl",
-    "create_interface_zsl_between_slabs",
-    "create_interface_commensurate",
-    "get_commensurate_strained_configurations",
-    "create_interface_twisted",
-    # Grain Boundary Functions
-    "create_grain_boundary_planar",
-    "create_grain_boundary_linear",
-    # Passivation Functions
-    "passivate_surface",
-    "passivate_dangling_bonds",
-    "get_unique_coordination_numbers",
-    "get_coordination_numbers_distribution",
-    # Utility Functions
-    "get_optimal_film_displacement",
-    # Type Definitions
-    "AdatomDefectDict",
-    "PointDefectDict",
-    "StackComponentDict",
-    # Entities
-    "CoordinateCondition",
-    # Enums
-    "EdgeTypesEnum",
-    "SurfaceTypesEnum",
-]
-
-# Aliases
-create_vacancy = create_defect_point_vacancy
-create_substitution = create_defect_point_substitution
-create_interstitial = create_defect_point_interstitial
-create_adatom = create_defect_adatom
-create_island = create_defect_island
-create_terrace = create_defect_terrace