@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/calculate/ase/constraints.py

@@ -1,91 +0,0 @@
-from typing import List, Optional
-
-import numpy as np
-from pydantic import BaseModel
-
-from ...third_party import ASEAtoms
-
-
-class InterfaceConstraint(BaseModel):
-    """
-    Based on  https://wiki.fysik.dtu.dk/ase/ase/constraints.html#making-your-own-constraint-class
-    """
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    def adjust_positions(self, atoms: ASEAtoms, new_positions: np.ndarray) -> None:
-        """
-        Adjust the positions of the atoms in the system.
-
-        Args:
-            atoms (ASEAtoms): The ASE Atoms object.
-            new_positions (numpy.ndarray): The new positions to adjust in place.
-        """
-        raise NotImplementedError
-
-    def adjust_forces(self, forces: np.ndarray) -> None:
-        """
-        Adjust the forces on the atoms in the system.
-
-        Args:
-            forces (numpy.ndarray): The forces array to adjust in place.
-        """
-        raise NotImplementedError
-
-
-class RigidFilmXYInterfaceConstraint(InterfaceConstraint):
-    """
-    Custom constraint to allow only rigid translation in x and y for film atoms.
-    """
-
-    film_indices: List[int] = []
-    initial_positions: Optional[np.ndarray] = None
-    reference_center: Optional[np.ndarray] = None
-
-    def adjust_positions(self, atoms: ASEAtoms, new_positions: np.ndarray) -> None:
-        """
-        Adjust the positions of film atoms to maintain rigidity in x and y.
-
-        Args:
-            atoms (ase.Atoms): The ASE Atoms object.
-            new_positions (numpy.ndarray): The new positions to adjust in place.
-        """
-        if self.initial_positions is None:
-            self.initial_positions = atoms.positions[self.film_indices].copy()
-            self.reference_center = self.initial_positions.mean(axis=0)
-
-        current_center = new_positions[self.film_indices].mean(axis=0)
-        desired_translation = current_center - self.reference_center
-        desired_translation[2] = 0.0
-
-        # Update positions to maintain rigid body translation in x and y
-        for i, idx in enumerate(self.film_indices):
-            new_positions[idx, 0] = self.initial_positions[i, 0] + desired_translation[0]
-            new_positions[idx, 1] = self.initial_positions[i, 1] + desired_translation[1]
-
-    def adjust_forces(self, forces: np.ndarray) -> None:
-        """
-        Adjust the forces on film atoms to ensure rigidity.
-
-        Args:
-            forces (numpy.ndarray): The forces array to adjust in place.
-        """
-        if self.initial_positions is None:
-            return  # No adjustment needed if initial positions are not set
-
-        # Project forces onto x and y for collective translation
-        net_force_x = np.sum(forces[self.film_indices, 0])
-        net_force_y = np.sum(forces[self.film_indices, 1])
-
-        # Distribute the net force equally to all film atoms to maintain rigidity
-        num_film_atoms = len(self.film_indices)
-        if num_film_atoms == 0:
-            return  # Avoid division by zero
-
-        distributed_force_x = net_force_x / num_film_atoms
-        distributed_force_y = net_force_y / num_film_atoms
-
-        for idx in self.film_indices:
-            forces[idx, 0] = distributed_force_x
-            forces[idx, 1] = distributed_force_y

package/src/py/mat3ra/made/tools/calculate/calculators/__init__.py

@@ -1,4 +0,0 @@
-from .interface_material_calculator import InterfaceMaterialCalculator
-from .interface_material_calculator_parameters import InterfaceMaterialCalculatorParameters
-from .material_calculator import MaterialCalculator
-from .material_calculator_parameters import MaterialCalculatorParameters

package/src/py/mat3ra/made/tools/calculate/calculators/interface_material_calculator.py

@@ -1,70 +0,0 @@
-from typing import Callable
-
-import numpy as np
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.processed_structures.two_dimensional.passivation.enums import SurfaceTypesEnum
-
-from ...analyze.other import get_surface_atom_indices
-from ...convert.interface_parts_enum import InterfacePartsEnum
-from ...modify import interface_get_part
-from ..interaction_functions import sum_of_inverse_distances_squared
-from .interface_material_calculator_parameters import InterfaceMaterialCalculatorParameters
-from .material_calculator import MaterialCalculator
-
-
-class InterfaceMaterialCalculator(MaterialCalculator):
-    """
-    A specialized calculator for computing the interaction energy between a film and a substrate
-    in an interface material.
-
-    This class extends MaterialCalculator and uses additional parameters specific to interface materials,
-    such as the shadowing radius to detect surface atoms.
-
-    Args:
-        calculator_parameters (InterfaceMaterialCalculatorParameters): Parameters that include the
-        shadowing radius and interaction function.
-    """
-
-    calculator_parameters: InterfaceMaterialCalculatorParameters = InterfaceMaterialCalculatorParameters()
-
-    def get_energy(
-        self,
-        material: Material,
-        shadowing_radius: float = 2.5,
-        interaction_function: Callable = sum_of_inverse_distances_squared,
-    ) -> float:
-        """
-        Calculate the interaction energy between the film and substrate in an interface material.
-
-        This method uses the shadowing radius to detect surface atoms and applies the given
-        interaction function to calculate the interaction between the film and substrate.
-
-        Args:
-            material (Material): The interface Material object consisting of both the film and substrate.
-            shadowing_radius (float): The radius used to detect surface atoms for the interaction
-                                      calculation. Defaults to 2.5 Å.
-            interaction_function (Callable): A function to compute the interaction between the film and
-                                             substrate. Defaults to sum_of_inverse_distances_squared.
-
-        Returns:
-            float: The calculated interaction energy between the film and substrate.
-        """
-        film_material = interface_get_part(material, part=InterfacePartsEnum.FILM)
-        substrate_material = interface_get_part(material, part=InterfacePartsEnum.SUBSTRATE)
-
-        film_surface_atom_indices = get_surface_atom_indices(
-            film_material, SurfaceTypesEnum.BOTTOM, shadowing_radius=shadowing_radius
-        )
-        substrate_surface_atom_indices = get_surface_atom_indices(
-            substrate_material, SurfaceTypesEnum.TOP, shadowing_radius=shadowing_radius
-        )
-
-        film_surface_atom_coordinates = film_material.basis.coordinates
-        film_surface_atom_coordinates.filter_by_ids(film_surface_atom_indices)
-        substrate_surface_atom_coordinates = substrate_material.basis.coordinates
-        substrate_surface_atom_coordinates.filter_by_ids(substrate_surface_atom_indices)
-
-        film_coordinates_values = np.array(film_surface_atom_coordinates.values)
-        substrate_coordinates_values = np.array(substrate_surface_atom_coordinates.values)
-
-        return interaction_function(film_coordinates_values, substrate_coordinates_values)

package/src/py/mat3ra/made/tools/calculate/calculators/interface_material_calculator_parameters.py

@@ -1,14 +0,0 @@
-from .material_calculator_parameters import MaterialCalculatorParameters
-
-
-class InterfaceMaterialCalculatorParameters(MaterialCalculatorParameters):
-    """
-    Parameters specific to the calculation of interaction energies between
-    an interface material's film and substrate.
-
-    Args:
-        shadowing_radius (float): Radius used to determine the surface atoms of the film or substrate
-                                  for interaction calculations. Default is 2.5 Å.
-    """
-
-    shadowing_radius: float = 2.5

package/src/py/mat3ra/made/tools/calculate/calculators/material_calculator.py

@@ -1,32 +0,0 @@
-from mat3ra.made.material import Material
-from pydantic import BaseModel
-
-from .material_calculator_parameters import MaterialCalculatorParameters
-
-
-class MaterialCalculator(BaseModel):
-    """
-    A base class for performing calculations on materials.
-
-    This class uses the parameters defined in MaterialCalculatorParameters to calculate
-    interaction metrics between atoms or sets of coordinates within the material.
-
-    Args:
-        calculator_parameters (MaterialCalculatorParameters): Parameters controlling the calculator,
-        including the interaction function.
-    """
-
-    calculator_parameters: MaterialCalculatorParameters = MaterialCalculatorParameters()
-
-    def get_energy(self, material: Material):
-        """
-        Calculate the energy (or other metric) for a material.
-
-        Args:
-            material (Material): The material to calculate the interaction energy for.
-
-        Returns:
-            float: The interaction energy between the coordinates of the material,
-            calculated using the specified interaction function.
-        """
-        return self.calculator_parameters.interaction_function(material.coordinates, material.coordinates)

package/src/py/mat3ra/made/tools/calculate/calculators/material_calculator_parameters.py

@@ -1,17 +0,0 @@
-from typing import Callable
-
-from pydantic import BaseModel
-
-from ..interaction_functions import sum_of_inverse_distances_squared
-
-
-class MaterialCalculatorParameters(BaseModel):
-    """
-    Defines the parameters for a material calculator.
-
-    Args:
-        interaction_function (Callable): A function used to calculate the interaction metric between
-        sets of coordinates. The default function is sum_of_inverse_distances_squared.
-    """
-
-    interaction_function: Callable = sum_of_inverse_distances_squared

package/src/py/mat3ra/made/tools/calculate/interaction_functions.py

@@ -1,23 +0,0 @@
-import numpy as np
-
-
-def sum_of_inverse_distances_squared(
-    coordinates_1: np.ndarray, coordinates_2: np.ndarray, epsilon: float = 1e-12
-) -> float:
-    """
-    Calculate the sum of inverse squares of distances between two sets of coordinates.
-
-    Args:
-        coordinates_1 (np.ndarray): The first set of coordinates, shape (N1, 3).
-        coordinates_2 (np.ndarray): The second set of coordinates, shape (N2, 3).
-        epsilon (float): Small value to prevent division by zero.
-
-    Returns:
-        float: The calculated sum.
-    """
-    differences = coordinates_1[:, np.newaxis, :] - coordinates_2[np.newaxis, :, :]  # Shape: (N1, N2, 3)
-    distances_squared = np.sum(differences**2, axis=2)  # Shape: (N1, N2)
-    distances_squared = np.where(distances_squared == 0, epsilon, distances_squared)
-    inv_distances_squared = -1 / distances_squared
-    total = np.sum(inv_distances_squared)
-    return float(total)

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

@@ -1,286 +0,0 @@
-import inspect
-from functools import wraps
-from typing import Any, Callable, Dict, Union
-
-from mat3ra.made.material import Material
-from mat3ra.made.utils import map_array_to_array_with_id_value, map_array_with_id_value_to_array
-from mat3ra.utils import remove_comments_from_source_code
-from mat3ra.utils.mixins import RoundNumericValuesMixin
-
-from ..third_party import (
-    ASEAtoms,
-    PymatgenAseAtomsAdaptor,
-    PymatgenInterface,
-    PymatgenLattice,
-    PymatgenPoscar,
-    PymatgenStructure,
-)
-from .utils import (
-    calculate_padded_cell_simple_cubic,
-    extract_labels_from_pymatgen_structure,
-    extract_metadata_from_pymatgen_structure,
-    extract_tags_from_ase_atoms,
-)
-
-
-def to_pymatgen(material_or_material_data: Union[Material, Dict[str, Any]]) -> PymatgenStructure:
-    """
-    Converts material object in ESSE format to a pymatgen Structure object.
-
-    Args:
-        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
-
-    Returns:
-        Structure: A pymatgen Structure object.
-    """
-    material_data = material_or_material_data
-
-    if isinstance(material_or_material_data, Material):
-        material_data = material_or_material_data.to_dict()
-
-    lattice_params = material_data["lattice"]
-    lattice = PymatgenLattice.from_parameters(
-        a=lattice_params["a"],
-        b=lattice_params["b"],
-        c=lattice_params["c"],
-        alpha=lattice_params["alpha"],
-        beta=lattice_params["beta"],
-        gamma=lattice_params["gamma"],
-    )
-
-    basis = material_data["basis"]
-    elements = [element["value"] for element in basis["elements"]]
-    coordinates = [coord["value"] for coord in basis["coordinates"]]
-    labels_data = basis.get("labels", []) or []
-    labels = [label["value"] for label in labels_data]
-    # Assuming that the basis units are fractional since it's a crystal basis
-    coords_are_cartesian = "units" in basis and basis["units"] == "angstrom"
-
-    if "labels" in inspect.signature(PymatgenStructure.__init__).parameters:
-        structure = PymatgenStructure(
-            lattice, elements, coordinates, coords_are_cartesian=coords_are_cartesian, labels=labels
-        )
-    else:
-        # Passing labels does not work for pymatgen `2023.6.23` supporting py3.8
-        print(f"labels: {labels}. Not passing labels to pymatgen.")
-        structure = PymatgenStructure(lattice, elements, coordinates, coords_are_cartesian=coords_are_cartesian)
-
-    return structure
-
-
-def from_pymatgen(structure: Union[PymatgenStructure, PymatgenInterface]) -> Dict[str, Any]:
-    """
-    Converts a pymatgen Structure object to a material object in ESSE format.
-
-    Args:
-        structure (Structure): A pymatgen Structure object.
-
-    Returns:
-        dict: A dictionary containing the material information in ESSE format.
-    """
-    __round__ = RoundNumericValuesMixin.round_array_or_number
-    basis = {
-        "elements": [{"id": i, "value": str(site.specie)} for i, site in enumerate(structure.sites)],
-        "coordinates": [
-            {"id": i, "value": __round__(list(site.frac_coords))} for i, site in enumerate(structure.sites)
-        ],
-        "units": "crystal",
-        # `cell` is assigned by the `lattice` object during Material initialization
-        # "cell": __round__(structure.lattice.matrix.tolist()),
-        "constraints": [],
-    }
-
-    lattice = {
-        "a": __round__(structure.lattice.a),
-        "b": __round__(structure.lattice.b),
-        "c": __round__(structure.lattice.c),
-        "alpha": __round__(structure.lattice.alpha),
-        "beta": __round__(structure.lattice.beta),
-        "gamma": __round__(structure.lattice.gamma),
-        "units": {"length": "angstrom", "angle": "degree"},
-        "type": "TRI",
-        "vectors": {
-            "a": __round__(structure.lattice.matrix[0].tolist()),
-            "b": __round__(structure.lattice.matrix[1].tolist()),
-            "c": __round__(structure.lattice.matrix[2].tolist()),
-            "alat": 1,
-            "units": "angstrom",
-        },
-    }
-
-    metadata = {
-        **extract_metadata_from_pymatgen_structure(structure),
-        "boundaryConditions": {"type": "pbc", "offset": 0},
-    }
-
-    basis["labels"] = map_array_to_array_with_id_value(
-        extract_labels_from_pymatgen_structure(structure), remove_none=True
-    )
-
-    material_data = {
-        "name": structure.formula,
-        "basis": basis,
-        "lattice": lattice,
-        "isNonPeriodic": not structure.is_ordered,
-        "_id": "",
-        "metadata": metadata,
-        "isUpdated": True,
-    }
-
-    return material_data
-
-
-def to_poscar(material_or_material_data: Union[Material, Dict[str, Any]]) -> str:
-    """
-    Converts material object in ESSE format to a POSCAR string.
-
-    Args:
-        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
-
-    Returns:
-        str: A POSCAR string.
-    """
-    structure = to_pymatgen(material_or_material_data)
-    poscar = PymatgenPoscar(structure)
-    # For pymatgen `2023.6.23` supporting py3.8 the method name is "get_string"
-    # TODO: cleanup the if statement when dropping support for py3.8
-    if hasattr(poscar, "get_string"):
-        return poscar.get_string()
-    return poscar.get_str()
-
-
-def clean_qe_input(poscar):
-    return remove_comments_from_source_code(remove_comments_from_source_code(poscar, "fortran"), "python")
-
-
-def from_poscar(poscar: str) -> Dict[str, Any]:
-    """
-    Converts a POSCAR string to a material object in ESSE format.
-
-    Args:
-        poscar (str): A POSCAR string.
-
-    Returns:
-        dict: A dictionary containing the material information in ESSE format.
-    """
-    poscar_clean = clean_qe_input(poscar)
-    structure = PymatgenStructure.from_str(poscar_clean, "poscar")
-    return from_pymatgen(structure)
-
-
-def from_poscar_molecule(poscar: str) -> Dict[str, Any]:
-    """
-    Converts a molecule POSCAR string to a non-periodic ESSE material.
-    """
-    poscar_clean = clean_qe_input(poscar)
-    structure = PymatgenStructure.from_str(poscar_clean, "poscar")
-    ase_atoms = PymatgenAseAtomsAdaptor.get_atoms(structure)
-    ase_atoms.set_pbc(False)
-    return from_ase(ase_atoms)
-
-
-def to_ase(material_or_material_data: Union[Material, Dict[str, Any]]) -> ASEAtoms:
-    """
-    Converts material object in ESSE format to an ASE Atoms object.
-
-    Args:
-        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
-
-    Returns:
-        Any: An ASE Atoms object.
-    """
-    if isinstance(material_or_material_data, Material):
-        material_config = material_or_material_data.to_dict()
-    else:
-        material_config = material_or_material_data
-    structure = to_pymatgen(material_config)
-    atoms = PymatgenAseAtomsAdaptor.get_atoms(structure)
-
-    atomic_labels = material_config["basis"].get("labels", [])
-    if atomic_labels:
-        atoms.set_tags(map_array_with_id_value_to_array(atomic_labels))
-    if "metadata" in material_config:
-        atoms.info.update({"metadata": material_config["metadata"]})
-
-    atoms.info.update({"name": material_config["name"]})
-    return atoms
-
-
-def from_ase(ase_atoms: ASEAtoms) -> Dict[str, Any]:
-    """
-    Converts an ASE Atoms object to a material object in ESSE format.
-
-    Args:
-        ase_atoms (Atoms): An ASE Atoms object.
-
-    Returns:
-        dict: A dictionary containing the material information in ESSE format.
-    """
-    is_molecule = not any(ase_atoms.pbc)
-
-    if is_molecule:
-        lattice_vectors = calculate_padded_cell_simple_cubic(ase_atoms.get_positions())
-        ase_atoms.set_cell(lattice_vectors)
-        ase_atoms.center()
-
-    # TODO: check that atomic labels/tags are properly handled
-    structure = PymatgenAseAtomsAdaptor.get_structure(ase_atoms)
-
-    material = from_pymatgen(structure)
-    material["isNonPeriodic"] = is_molecule
-    if is_molecule:
-        material["lattice"]["type"] = "CUB"
-
-    ase_tags = extract_tags_from_ase_atoms(ase_atoms)
-    material["basis"]["labels"] = ase_tags
-    ase_metadata = ase_atoms.info.get("metadata", {})
-    if ase_metadata:
-        material["metadata"].update(ase_metadata)
-    material["name"] = ase_atoms.info.get("name", ase_atoms.get_chemical_formula())
-    return material
-
-
-def decorator_convert_material_args_kwargs_to_atoms(func: Callable) -> Callable:
-    """
-    Decorator that converts ESSE Material objects to ASE Atoms objects.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        # Convert args if they are of type ESSE Material
-        new_args = [to_ase(arg) if isinstance(arg, Material) else arg for arg in args]
-
-        # Convert kwargs if they are of type ESSE Material
-        new_kwargs = {k: to_ase(v) if isinstance(v, Material) else v for k, v in kwargs.items()}
-
-        # Call the original function with the converted arguments
-        return func(*new_args, **new_kwargs)
-
-    return wrapper
-
-
-def decorator_convert_material_args_kwargs_to_structure(func: Callable) -> Callable:
-    """
-    Decorator that converts ESSE Material objects to pymatgen Structure objects.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        # Convert args if they are of type ESSE Material
-        new_args = [to_pymatgen(arg) if isinstance(arg, Material) else arg for arg in args]
-
-        # Convert kwargs if they are of type ESSE Material
-        new_kwargs = {k: to_pymatgen(v) if isinstance(v, Material) else v for k, v in kwargs.items()}
-
-        # Call the original function with the converted arguments
-        return func(*new_args, **new_kwargs)
-
-    return wrapper
-
-
-def convert_atoms_or_structure_to_material(item):
-    if isinstance(item, PymatgenStructure):
-        return from_pymatgen(item)
-    elif isinstance(item, ASEAtoms):
-        return from_ase(item)
-    return item

package/src/py/mat3ra/made/tools/convert/interface_parts_enum.py

@@ -1,9 +0,0 @@
-from enum import Enum
-
-
-class InterfacePartsEnum(int, Enum):
-    SUBSTRATE = 0
-    FILM = 1
-
-
-INTERFACE_LABELS_MAP = {"substrate": InterfacePartsEnum.SUBSTRATE.value, "film": InterfacePartsEnum.FILM.value}

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

@@ -1,96 +0,0 @@
-import json
-from typing import Any, Dict, List, Union
-
-import numpy as np
-from mat3ra.made.data_helper import DATA_DIR
-from mat3ra.made.utils import get_center_of_coordinates, map_array_to_array_with_id_value
-from mat3ra.utils.object import NumpyNDArrayRoundEncoder
-from scipy.spatial.distance import pdist
-
-from ..third_party import ASEAtoms, PymatgenInterface, PymatgenStructure
-from .interface_parts_enum import INTERFACE_LABELS_MAP
-
-_CONSTANTS_FILE = DATA_DIR / "constants.json"
-with open(_CONSTANTS_FILE) as _f:
-    _CONSTANTS = json.load(_f)
-
-DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE = _CONSTANTS["molecule"]["nonPeriodicMinimumLatticeSize"]
-DIATOMIC_LATTICE_PADDING_FACTOR = _CONSTANTS["molecule"]["diatomicLatticePaddingFactor"]
-MOLECULAR_LATTICE_PADDING_FACTOR = _CONSTANTS["molecule"]["molecularLatticePaddingFactor"]
-
-
-def _get_non_periodic_lattice_padding_factor(max_distance: float, min_distance: float) -> float:
-    if max_distance <= 0:
-        return MOLECULAR_LATTICE_PADDING_FACTOR
-    width_ratio = min_distance / max_distance
-    if np.isclose(width_ratio, 1.0):
-        return DIATOMIC_LATTICE_PADDING_FACTOR
-    return MOLECULAR_LATTICE_PADDING_FACTOR
-
-
-def _get_non_periodic_lattice_size(
-    shifted_positions: np.ndarray,
-    default_min_size: float = DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE,
-) -> float:
-    if len(shifted_positions) < 2:
-        return max(default_min_size, 10.0)
-    distances = pdist(shifted_positions)
-    max_distance = float(np.max(distances))
-    min_distance = float(np.min(distances))
-    padding_factor = _get_non_periodic_lattice_padding_factor(max_distance, min_distance)
-    return max(default_min_size, max_distance * padding_factor)
-
-
-def extract_labels_from_pymatgen_structure(structure: PymatgenStructure) -> List[int]:
-    labels = []
-    if isinstance(structure, PymatgenInterface):
-        labels = list(map(lambda s: INTERFACE_LABELS_MAP[s.properties["interface_label"]], structure.sites))
-    return labels
-
-
-def extract_metadata_from_pymatgen_structure(structure: PymatgenStructure) -> Dict[str, Any]:
-    metadata = {}
-    # TODO: consider using Interface JSONSchema from ESSE when such created and adapt interface_properties accordingly.
-    # Add interface properties to metadata according to pymatgen Interface as a JSON object
-    if hasattr(structure, "interface_properties"):
-        interface_props = structure.interface_properties
-        # TODO: figure out how to round the values and stringify terminations tuple
-        #  in the interface properties with Encoder
-        for key, value in interface_props.items():
-            if isinstance(value, tuple):
-                interface_props[key] = str(value)
-        metadata["interface_properties"] = json.loads(json.dumps(interface_props, cls=NumpyNDArrayRoundEncoder))
-
-    return metadata
-
-
-def extract_tags_from_ase_atoms(atoms: ASEAtoms) -> List[Union[str, int]]:
-    result = []
-    if "tags" in atoms.arrays:
-        int_tags = [int(tag) for tag in atoms.arrays["tags"] if tag is not None]
-        result = map_array_to_array_with_id_value(int_tags, remove_none=True)
-    return result
-
-
-def calculate_padded_cell_simple_cubic(
-    coordinates: List[List[float]],
-    default_min_size: float = DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE,
-) -> List[List[float]]:
-    """
-    Calculate values for a padded cell for a molecule based on its coordinates.
-    Args:
-        coordinates (Array[Array[float]]): A list of atomic coordinates.
-        default_min_size (float): Minimum cubic lattice parameter in angstroms.
-    Returns:
-        Array[float]: A list containing the final cell latice vectors with padding applied.
-    """
-    positions = np.array(coordinates)
-    center = get_center_of_coordinates(positions)
-    shifted_positions = positions - center
-    padding_value = _get_non_periodic_lattice_size(shifted_positions, default_min_size)
-
-    return [
-        [padding_value, 0.0, 0.0],
-        [0.0, padding_value, 0.0],
-        [0.0, 0.0, padding_value],
-    ]

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

@@ -1,5 +0,0 @@
-from ..build_components.entities.auxiliary.two_dimensional.miller_indices import MillerIndices
-from ..build_components.entities.auxiliary.two_dimensional.termination import Termination
-from .termination_holder import TerminationHolder
-
-__all__ = ["Termination", "TerminationHolder", "MillerIndices"]

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

@@ -1,14 +0,0 @@
-from .box_coordinate_condition import BoxCoordinateCondition
-from .coordinate_condition import CoordinateCondition
-from .coordinate_functions import (
-    is_coordinate_behind_plane,
-    is_coordinate_in_box,
-    is_coordinate_in_cylinder,
-    is_coordinate_in_sphere,
-    is_coordinate_in_triangular_prism,
-    is_coordinate_within_layer,
-)
-from .cylinder_coordinate_condition import CylinderCoordinateCondition
-from .plane_coordinate_condition import PlaneCoordinateCondition
-from .sphere_coordinate_condition import SphereCoordinateCondition
-from .triangular_prism_coordinate_condition import TriangularPrismCoordinateCondition