@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/perturb/functions/perturbation_function_holder.py

@@ -1,45 +0,0 @@
-from typing import List
-
-import numpy as np
-from mat3ra.made.utils import AXIS_TO_INDEX_MAP
-from scipy.integrate import quad
-from scipy.optimize import root_scalar
-
-from .function_holder import FunctionHolder
-
-EQUATION_RANGE_COEFFICIENT = 5
-
-
-class PerturbationFunctionHolder(FunctionHolder):
-    def _integrand(self, t: float, coordinate: List[float], axis: str) -> float:
-        temp_coordinate = coordinate[:]
-        temp_coordinate[AXIS_TO_INDEX_MAP[axis]] = t
-        return np.sqrt(1 + self.calculate_derivative(temp_coordinate, axis) ** 2)
-
-    def get_arc_length_equation(self, w_prime: float, coordinate: List[float], axis: str) -> float:
-        """
-        Calculate arc length considering a change along one specific axis.
-        """
-        a, b = 0, w_prime
-        arc_length = quad(self._integrand, a, b, args=(coordinate, axis), limit=1000)[0]
-        return arc_length - coordinate[AXIS_TO_INDEX_MAP[axis]]
-
-    def normalize_coordinates(self, coordinate: List[float]) -> List[float]:
-        """
-        Transform coordinates to preserve the distance between points on a sine wave when perturbation is applied.
-        Achieved by calculating the integral of the length between [0,0,0] and given coordinate.
-
-        Returns:
-            Callable[[List[float]], List[float]]: The coordinates transformation function.
-        """
-        for i, var in enumerate(self.variables):
-            index = AXIS_TO_INDEX_MAP[var]
-            w = coordinate[index]
-            result = root_scalar(
-                self.get_arc_length_equation,
-                args=(coordinate, var),
-                bracket=[0, EQUATION_RANGE_COEFFICIENT * w],
-                method="brentq",
-            )
-            coordinate[index] = result.root
-        return coordinate

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/perturb/functions/sine_wave_perturbation_function_holder.py

@@ -1,29 +0,0 @@
-from typing import Any
-
-import sympy as sp
-
-from .perturbation_function_holder import PerturbationFunctionHolder
-
-
-class SineWavePerturbationFunctionHolder(PerturbationFunctionHolder):
-    amplitude: float = 0.05
-    wavelength: float = 1
-    phase: float = 0
-    axis: str = "x"
-
-    def __init__(
-        self,
-        amplitude: float = 0.05,
-        wavelength: float = 1,
-        phase: float = 0,
-        axis: str = "x",
-        **data: Any,
-    ):
-        w = sp.Symbol(axis)
-        function = amplitude * sp.sin(2 * sp.pi * w / wavelength + phase)
-        variables = [axis]
-        super().__init__(function=function, variables=variables, **data)
-        self.amplitude = amplitude
-        self.wavelength = wavelength
-        self.phase = phase
-        self.axis = axis

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/perturb/helpers.py

@@ -1,83 +0,0 @@
-from typing import Optional, Union
-
-import sympy as sp
-from mat3ra.made.material import Material
-
-from ..... import MaterialWithBuildMetadata
-from .builders.base import PerturbationBuilder
-from .builders.isometric import IsometricPerturbationBuilder
-from .configuration import PerturbationConfiguration
-from .functions import PerturbationFunctionHolder
-from .functions.maxwell_boltzmann import MaxwellBoltzmannDisplacementHolder
-
-
-def create_perturbation(
-    material: Union[Material, MaterialWithBuildMetadata],
-    perturbation_function: Union[sp.Expr, str],
-    use_cartesian_coordinates: bool = True,
-    is_isometric: bool = False,
-):
-    """
-    Create a perturbation for a material.
-    With a function of delta for coordinate [∆x, ∆y, ∆z] = f(x, y, z) applied to each atom in the material.
-
-    Args:
-        material (Material): The material to be perturbed.
-        perturbation_function (PerturbationFunctionHolder): The perturbation function to apply.
-        is_isometric (bool): If True, the lattice will be adjusted to preserve distances between atoms.
-
-    Returns:
-        Material: The perturbed material.
-    """
-
-    configuration = PerturbationConfiguration(
-        material=material,
-        perturbation_function_holder=PerturbationFunctionHolder(function=perturbation_function),
-        use_cartesian_coordinates=use_cartesian_coordinates,
-    )
-    if is_isometric:
-        builder = IsometricPerturbationBuilder()
-    else:
-        builder = PerturbationBuilder()
-    return builder.get_material(configuration)
-
-
-def create_maxwell_displacement(
-    material: Union[Material, MaterialWithBuildMetadata],
-    disorder_parameter: float,
-    random_seed: Optional[int] = None,
-    is_mass_used: bool = True,
-) -> Material:
-    """
-    Apply Maxwell-Boltzmann random displacements to a material.
-
-    Generates random 3D displacement vectors where each component follows a normal
-    distribution with variance proportional to disorder_parameter/m (if is_mass_used=True)
-    or disorder_parameter (if is_mass_used=False), where m is atomic mass.
-
-    Args:
-        material: The material to be perturbed.
-        disorder_parameter: Disorder parameter controlling displacement magnitude,
-                            can be viewed as effective temperature in eV.
-        random_seed: Optional random seed for reproducibility for the same material and parameters.
-        is_mass_used: If True, displacement variance is disorder_parameter/m (mass-dependent).
-                     If False, displacement variance is disorder_parameter (mass-independent).
-
-    Returns:
-        Material with applied Maxwell-Boltzmann displacements.
-    """
-    displacement_holder = MaxwellBoltzmannDisplacementHolder(
-        disorder_parameter=disorder_parameter,
-        random_seed=random_seed,
-        is_mass_used=is_mass_used,
-    )
-
-    configuration = PerturbationConfiguration(
-        material=material,
-        perturbation_function_holder=displacement_holder,
-        use_cartesian_coordinates=True,
-    )
-
-    builder = PerturbationBuilder()
-
-    return builder.get_material(configuration)

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/strain/__init__.py

@@ -1,5 +0,0 @@
-from .builder import StrainBuilder
-from .configuration import StrainConfiguration
-from .helpers import create_strain, get_isotropic_strain_matrix
-
-__all__ = ["StrainBuilder", "StrainConfiguration", "create_strain", "get_isotropic_strain_matrix"]

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/strain/builder.py

@@ -1,25 +0,0 @@
-from typing import Type
-
-from mat3ra.made.tools.build_components.entities.reusable.base_builder import BaseBuilderParameters, BaseSingleBuilder
-
-from ......operations.core.unary import strain
-from ..... import MaterialWithBuildMetadata
-from .configuration import StrainConfiguration
-
-
-class StrainBuilder(BaseSingleBuilder):
-    _ConfigurationType: Type[StrainConfiguration] = StrainConfiguration
-    _BuildParametersType: Type[BaseBuilderParameters] = BaseBuilderParameters
-    _DefaultBuildParameters: BaseBuilderParameters = BaseBuilderParameters()
-
-    def _generate(self, configuration: StrainConfiguration) -> MaterialWithBuildMetadata:
-        strained_material = strain(configuration.material, configuration.strain_matrix)
-        return MaterialWithBuildMetadata.create(strained_material.to_dict())
-
-    def _update_material_name(
-        self, material: MaterialWithBuildMetadata, configuration: StrainConfiguration
-    ) -> MaterialWithBuildMetadata:
-        if configuration.scale_factor is not None:
-            base_name = configuration.material.name
-            material.name = f"{base_name} (scale={configuration.scale_factor:.4f})"
-        return material

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/strain/configuration.py

@@ -1,23 +0,0 @@
-from typing import Optional, Union
-
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components.entities.reusable.base_builder import BaseConfigurationPydantic
-
-from ..... import MaterialWithBuildMetadata
-
-
-class StrainConfiguration(BaseConfigurationPydantic):
-    """
-    Configuration for a strain operation on a Material.
-
-    Args:
-        material (Material): The Material object to be strained.
-        strain_matrix (Matrix3x3Schema): The 3x3 strain matrix defining the deformation.
-        scale_factor (Optional[float]): An optional scale factor for isotropic scaling instead of a full strain matrix.
-    """
-
-    type: str = "StrainConfiguration"
-    material: Union[Material, MaterialWithBuildMetadata]
-    strain_matrix: Matrix3x3Schema
-    scale_factor: Optional[float] = None

package/src/py/mat3ra/made/tools/build_components/operations/core/modifications/strain/helpers.py

@@ -1,49 +0,0 @@
-from typing import Optional, Union
-
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-
-from ..... import MaterialWithBuildMetadata
-from .builder import StrainBuilder
-from .configuration import StrainConfiguration
-
-
-def get_isotropic_strain_matrix(scale_factor: float) -> Matrix3x3Schema:
-    """
-    Returns a 3x3 isotropic strain matrix for uniform lattice scaling.
-    """
-    return Matrix3x3Schema(
-        root=[
-            [scale_factor, 0.0, 0.0],
-            [0.0, scale_factor, 0.0],
-            [0.0, 0.0, scale_factor],
-        ]
-    )
-
-
-def create_strain(
-    material: Union[Material, MaterialWithBuildMetadata],
-    strain_matrix: Optional[Matrix3x3Schema] = None,
-    scale_factor: Optional[float] = None,
-) -> MaterialWithBuildMetadata:
-    """
-    Creates a strained Material based on the provided strain matrix or scale factor.
-
-    Args:
-        material (Union[Material, MaterialWithBuildMetadata]): The material to be strained.
-        strain_matrix (Optional[Matrix3x3Schema]): The 3x3 strain matrix defining the deformation.
-        scale_factor (Optional[float]): An optional scale factor for isotropic scaling instead of a full strain matrix.
-
-    Returns:
-        MaterialWithBuildMetadata: The strained material with build metadata.
-    """
-    if scale_factor is not None:
-        if scale_factor <= 0:
-            raise ValueError("scale_factor must be positive.")
-        strain_matrix = get_isotropic_strain_matrix(scale_factor)
-    if strain_matrix is None:
-        raise ValueError("Either strain_matrix or scale_factor must be provided.")
-
-    configuration = StrainConfiguration(material=material, strain_matrix=strain_matrix, scale_factor=scale_factor)
-    builder = StrainBuilder()
-    return builder.get_material(configuration)

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

@@ -1,44 +0,0 @@
-from typing import List, Union
-
-from mat3ra.made.material import Material
-
-from ..modify import filter_by_box
-from . import MaterialWithBuildMetadata
-from .entities.reusable.three_dimensional.supercell.helpers import create_supercell
-
-
-def double_and_filter_material(
-    material: Union[Material, MaterialWithBuildMetadata], start: List[float], end: List[float]
-) -> Material:
-    """
-    Double the material and filter it by a box defined by the start and end coordinates.
-    Args:
-        material (Material): The material to double and filter.
-        start (List[float]): The start coordinates of the box.
-        end (List[float]): The end coordinates of the box.
-    Returns:
-        Material: The filtered material.
-    """
-    material_doubled = create_supercell(material, scaling_factor=[2, 1, 1])
-    return filter_by_box(material_doubled, start, end)
-
-
-def expand_lattice_vectors(
-    material: Union[Material, MaterialWithBuildMetadata], gap: float, direction: int = 0
-) -> Material:
-    """
-    Expand the lattice vectors of the material in the specified direction by the given gap.
-
-    Args:
-        material (Material): The material whose lattice vectors are to be expanded.
-        gap (float): The gap by which to expand the lattice vector.
-        direction (int): The index of the lattice vector to expand (0, 1, or 2).
-    """
-    new_lattice_vectors = material.lattice.vector_arrays
-    new_lattice_vectors[direction][direction] += gap
-    material.set_lattice_vectors(
-        lattice_vector1=new_lattice_vectors[0],
-        lattice_vector2=new_lattice_vectors[1],
-        lattice_vector3=new_lattice_vectors[2],
-    )
-    return material

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

@@ -1,149 +0,0 @@
-from typing import Optional, Tuple
-
-from ...material import Material
-from ..analyze.other import get_surface_area
-from ..analyze.interface_material import get_interface_bulk_crystal
-from ..build.compound_pristine_structures.two_dimensional.interface import get_slab
-from ..build_components.metadata import MaterialWithBuildMetadata
-from ..convert import decorator_convert_material_args_kwargs_to_atoms
-from ..third_party import ASEAtoms, ASECalculator, ASECalculatorEMT
-from .calculators import InterfaceMaterialCalculatorParameters
-from .interaction_functions import sum_of_inverse_distances_squared
-
-
-@decorator_convert_material_args_kwargs_to_atoms
-def calculate_total_energy(atoms: ASEAtoms, calculator: ASECalculator):
-    """
-    Set calculator for ASE Atoms and calculate the total energy.
-
-    Args:
-        atoms (ASEAtoms): The Atoms object to calculate the energy of.
-        calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation.
-
-    Returns:
-        float: The total energy of the atoms.
-    """
-    atoms.calc = calculator
-    return atoms.get_total_energy()
-
-
-@decorator_convert_material_args_kwargs_to_atoms
-def calculate_total_energy_per_atom(atoms: ASEAtoms, calculator: ASECalculator):
-    """
-    Set calculator for ASE Atoms and calculate the total energy per atom.
-
-    Args:
-            atoms (ASEAtoms): The Atoms object to calculate the energy of.
-            calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation.
-
-    Returns:
-            float: The energy per atom of the atoms.
-    """
-    return calculate_total_energy(atoms, calculator) / atoms.get_global_number_of_atoms()
-
-
-@decorator_convert_material_args_kwargs_to_atoms
-def calculate_surface_energy(slab: ASEAtoms, bulk: ASEAtoms, calculator: ASECalculator):
-    """
-    Calculate the surface energy by subtracting the weighted bulk energy from the slab energy.
-
-    Args:
-        slab (ASEAtoms): The slab Atoms object to calculate the surface energy of.
-        bulk (ASEAtoms): The bulk Atoms object to calculate the surface energy of.
-        calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation.
-
-    Returns:
-        float: The surface energy of the slab.
-    """
-    number_of_atoms = slab.get_global_number_of_atoms()
-    area = get_surface_area(slab)
-    return (
-        calculate_total_energy(slab, calculator) - calculate_total_energy_per_atom(bulk, calculator) * number_of_atoms
-    ) / (2 * area)
-
-
-@decorator_convert_material_args_kwargs_to_atoms
-def calculate_adhesion_energy(
-    interface: ASEAtoms, substrate_slab: ASEAtoms, film_slab: ASEAtoms, calculator: ASECalculator
-):
-    """
-    Calculate the adhesion energy.
-    The adhesion energy is the difference between the energy of the interface and
-    the sum of the energies of the substrate and film.
-    According to: 10.1088/0953-8984/27/30/305004
-
-    Args:
-        interface (ASEAtoms): The interface ASEAtoms object to calculate the adhesion energy of.
-        substrate_slab (ASEAtoms): The substrate slab ASEAtoms object to calculate the adhesion energy of.
-        film_slab (ASEAtoms): The film slab ASEAtoms object to calculate the adhesion energy of.
-        calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation.
-
-    Returns:
-        float: The adhesion energy of the interface.
-    """
-    energy_substrate_slab = calculate_total_energy(substrate_slab, calculator)
-    energy_film_slab = calculate_total_energy(film_slab, calculator)
-    energy_interface = calculate_total_energy(interface, calculator)
-    area = get_surface_area(interface)
-    return (energy_substrate_slab + energy_film_slab - energy_interface) / area
-
-
-def _get_interface_with_build_metadata(interface: Material) -> MaterialWithBuildMetadata:
-    if isinstance(interface, MaterialWithBuildMetadata):
-        return interface
-    return MaterialWithBuildMetadata.create(interface.to_dict())
-
-
-def _resolve_interface_bulk_materials(
-    interface: Material,
-    substrate_bulk: Optional[Material],
-    film_bulk: Optional[Material],
-) -> Tuple[Optional[Material], Optional[Material]]:
-    """Resolve missing bulks from interface build metadata (handles BoundaryConditions metadata)."""
-    try:
-        interface_with_metadata = _get_interface_with_build_metadata(interface)
-        if substrate_bulk is None:
-            substrate_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="substrate"))
-        if film_bulk is None:
-            film_bulk = Material.create(get_interface_bulk_crystal(interface_with_metadata, part="film"))
-    except (ValueError, TypeError) as exc:
-        raise ValueError(
-            "The substrate and film bulk materials must be provided or defined in the interface metadata."
-        ) from exc
-    return substrate_bulk, film_bulk
-
-
-def calculate_interfacial_energy(
-    interface: Material,
-    substrate_slab: Optional[Material] = None,
-    substrate_bulk: Optional[Material] = None,
-    film_slab: Optional[Material] = None,
-    film_bulk: Optional[Material] = None,
-    calculator: ASECalculator = ASECalculatorEMT(),
-):
-    """
-    Calculate the interfacial energy.
-    The interfacial energy is the sum of the surface energies of the substrate and film minus the adhesion energy.
-    According to Dupré's formula
-
-    Args:
-        interface (Material): The interface Material object to calculate the interfacial energy of.
-        substrate_slab (Material): The substrate slab Material object to calculate the interfacial energy of.
-        substrate_bulk (Material): The substrate bulk Material object to calculate the interfacial energy of.
-        film_slab (Material): The film slab Material object to calculate the interfacial energy of.
-        film_bulk (Material): The film bulk Material object to calculate the interfacial energy of.
-        calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation
-
-    Returns:
-        float: The interfacial energy of the interface.
-    """
-    substrate_slab = get_slab(interface, part="substrate") if substrate_slab is None else substrate_slab
-    film_slab = get_slab(interface, part="film") if film_slab is None else film_slab
-
-    if substrate_bulk is None or film_bulk is None:
-        substrate_bulk, film_bulk = _resolve_interface_bulk_materials(interface, substrate_bulk, film_bulk)
-
-    surface_energy_substrate = calculate_surface_energy(substrate_slab, substrate_bulk, calculator)
-    surface_energy_film = calculate_surface_energy(film_slab, film_bulk, calculator)
-    adhesion_energy = calculate_adhesion_energy(interface, substrate_slab, film_slab, calculator)
-    return surface_energy_film + surface_energy_substrate - adhesion_energy

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

@@ -1,133 +0,0 @@
-from typing import List, Optional, Union
-
-import numpy as np
-from mat3ra.made.material import Material
-
-from ...convert import from_ase
-from ...convert.interface_parts_enum import INTERFACE_LABELS_MAP, InterfacePartsEnum
-from ...third_party import ASEAtoms, ASECalculator, ASEFixAtoms, ASEFixedPlane, ase_all_changes
-from ..calculators import InterfaceMaterialCalculator, MaterialCalculator
-from .constraints import RigidFilmXYInterfaceConstraint
-
-
-def get_interface_part_indices(atoms: ASEAtoms, part: InterfacePartsEnum) -> List[int]:
-    """
-    Get the indices of the atoms in the interface part.
-
-    Args:
-        atoms (ASEAtoms): The ASE Atoms object.
-        part (str): The interface part to get the indices of.
-
-    Returns:
-        List[int]: The indices of the atoms in the interface part.
-    """
-    return [i for i, tag in enumerate(atoms.get_tags()) if tag == INTERFACE_LABELS_MAP[part.name.lower()]]
-
-
-class FilmSubstrateDistanceASECalculator(ASECalculator):
-    """
-    ASE calculator that calculates the interaction energy between a film and substrate in an interface material.
-
-    Args:
-        shadowing_radius (float): The radius for atom to shadow underlying from being considered surface, in Angstroms.
-        force_constant (float): The force constant for the finite difference approximation of the forces.
-        is_substrate_fixed (bool): Whether to fix the substrate atoms.
-        is_z_axis_fixed (bool): Whether to fix atoms movement in the z direction.
-        symprec (float): The symmetry precision for the ASE calculator. This parameter determines the tolerance
-                         for symmetry operations, affecting the identification of equivalent atoms and the overall
-                         symmetry of the system. For more details, refer to the ASE documentation:
-                         https://wiki.fysik.dtu.dk/ase/ase/constraints.html#ase.constraints.FixSymmetry
-
-    Example usage:
-    ```python
-    from ase.optimize import BFGS
-    atoms = to_ase(material)
-    calc = SurfaceDistanceCalculator(shadowing_radius=2.5)
-
-    atoms.calc = calc
-    opt = BFGS(atoms)
-    opt.run(fmax=0.05)
-    ```
-    Args:
-        shadowing_radius (float): Radius for atoms shadowing underlying from being treated as a surface, in Angstroms.
-        force_constant (float): The force constant for the finite difference approximation of the
-    Note:
-        Built following https://wiki.fysik.dtu.dk/ase/development/calculators.html
-
-        The calculate method is responsible for computing the energy and forces (if requested).
-        Forces are estimated using a finite difference method, which is a simple approximation
-        and might not be the most accurate or efficient for all cases.
-    """
-
-    implemented_properties = ["energy", "forces"]
-
-    def __init__(
-        self,
-        shadowing_radius: float = 2.5,
-        is_substrate_fixed: bool = True,
-        is_z_axis_fixed: bool = True,
-        symprec: float = 0.01,
-        material_calculator: Union[MaterialCalculator, InterfaceMaterialCalculator] = InterfaceMaterialCalculator(),
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.shadowing_radius = shadowing_radius
-        self.fix_substrate = is_substrate_fixed
-        self.fix_z = is_z_axis_fixed
-        self.symprec = symprec
-        self.material_calculator = material_calculator
-
-    def _add_constraints(self, atoms: ASEAtoms) -> ASEAtoms:
-        constraints: List[Union[ASEFixAtoms, ASEFixedPlane, RigidFilmXYInterfaceConstraint]] = []
-        if self.fix_substrate:
-            substrate_indices = get_interface_part_indices(atoms, InterfacePartsEnum.SUBSTRATE)
-            constraints.append(ASEFixAtoms(indices=substrate_indices))
-        if self.fix_z:
-            all_indices = list(range(len(atoms)))
-            constraints.append(ASEFixedPlane(indices=all_indices, direction=[0, 0, 1]))
-
-        film_indices = get_interface_part_indices(atoms, InterfacePartsEnum.FILM)
-        if film_indices:
-            constraints.append(RigidFilmXYInterfaceConstraint(film_indices=film_indices))
-
-        atoms.set_constraint(constraints)
-        return atoms
-
-    def _calculate_forces(self, atoms: ASEAtoms, energy: float) -> np.ndarray:
-        forces = np.zeros((len(atoms), 3))
-        dx = 0.01
-        for i in range(len(atoms)):
-            for j in range(3):
-                atoms_plus = atoms.copy()
-                atoms_plus.positions[i, j] += dx
-                material_plus = Material.create(from_ase(atoms_plus))
-                energy_plus = self.material_calculator.get_energy(material_plus)
-
-                forces[i, j] = -(energy_plus - energy) / dx
-
-        return forces
-
-    def calculate(self, atoms: Optional[ASEAtoms] = None, properties=["energy"], system_changes=ase_all_changes):
-        if atoms is None:
-            atoms = self.atoms.copy()
-
-        atoms = self._add_constraints(atoms)
-        constraints = atoms.constraints
-
-        super().calculate(atoms, properties, system_changes)
-        material = Material.create(from_ase(atoms))
-        energy = self.material_calculator.get_energy(material)
-
-        self.results = {"energy": energy}
-
-        if "forces" in properties:
-            forces = self._calculate_forces(atoms, energy)
-            for constraint in constraints:
-                constraint.adjust_forces(atoms, forces)
-            self.results["forces"] = forces
-
-    def get_potential_energy(self, atoms=None, force_consistent=False):
-        return self.get_property("energy", atoms)
-
-    def get_forces(self, atoms=None):
-        return self.get_property("forces", atoms)