@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/tests/py/unit/test_tools_build_perturbation.py

@@ -1,103 +0,0 @@
-import pytest
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb import SineWavePerturbationFunctionHolder
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb.builders.base import PerturbationBuilder
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb.configuration import (
-    PerturbationConfiguration,
-)
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb.helpers import create_perturbation
-from mat3ra.utils import assertion as assertion_utils
-
-from .fixtures.monolayer import GRAPHENE
-from .fixtures.nanoribbon.armchair import GRAPHENE_NANORIBBON_ARMCHAIR
-
-
-@pytest.mark.parametrize(
-    "material_config, supercell_matrix, perturbation_function, use_cartesian, coordinates_to_check",
-    [
-        (
-            GRAPHENE,
-            [[10, 0, 0], [0, 10, 0], [0, 0, 1]],
-            SineWavePerturbationFunctionHolder(amplitude=0.05, wavelength=1),
-            False,
-            {0: [0.0, 0.0, 0.5], 42: [0.2, 0.1, 0.5475]},
-        ),
-        (
-            GRAPHENE_NANORIBBON_ARMCHAIR,
-            [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
-            SineWavePerturbationFunctionHolder(amplitude=3.0, wavelength=18.0),
-            True,
-            {0: [0.1454, 0.279, 0.635], 12: [0.242, 0.3895, 0.6434]},
-        ),
-    ],
-)
-def test_perturbation_builder(
-    material_config, supercell_matrix, perturbation_function, use_cartesian, coordinates_to_check
-):
-    material = MaterialWithBuildMetadata.create(material_config)
-    slab = create_supercell(material, supercell_matrix)
-
-    perturbation_config = PerturbationConfiguration(
-        material=slab,
-        perturbation_function_holder=perturbation_function,
-        use_cartesian_coordinates=use_cartesian,
-    )
-    builder = PerturbationBuilder()
-    perturbed_slab = builder.get_material(perturbation_config)
-    # Check selected atoms to avoid using 100+ atoms fixture
-    for index, expected_coord in coordinates_to_check.items():
-        assertion_utils.assert_deep_almost_equal(
-            expected_coord, perturbed_slab.basis.coordinates.values[index], atol=1e-4
-        )
-
-
-@pytest.mark.parametrize(
-    "material_config, supercell_matrix, perturbation_function, use_cartesian, is_isometric,"
-    + " coordinates_to_check, expected_cell",
-    [
-        (
-            GRAPHENE,
-            [[10, 0, 0], [0, 10, 0], [0, 0, 1]],
-            "0.25*sin(x) + 0.25*cos(y)",
-            False,
-            True,
-            {0: [0.0, 0.0, 0.75], 42: [0.19707, 0.10156, 0.7969]},
-            [[24.30514, 0.0, 0.0], [-12.15434, 21.03520, 0.0], [0.0, 0.0, 20.0]],
-        ),
-        (
-            GRAPHENE_NANORIBBON_ARMCHAIR,
-            [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
-            "0.3*sin(x*pi)",
-            False,
-            True,
-            {0: [0.1275, 0.2791, 0.5987], 12: [0.2156, 0.3895, 0.6612]},
-            [[18.4967, 0.0, 0.0], [0.0, 11.1682, 0.0], [0.0, 0.0, 20.0]],
-        ),
-    ],
-)
-def test_create_perturbation(
-    material_config,
-    supercell_matrix,
-    perturbation_function,
-    use_cartesian,
-    is_isometric,
-    coordinates_to_check,
-    expected_cell,
-):
-    material = MaterialWithBuildMetadata.create(material_config)
-    slab = create_supercell(material, supercell_matrix)
-
-    perturbed_slab = create_perturbation(
-        material=slab,
-        perturbation_function=perturbation_function,
-        use_cartesian_coordinates=use_cartesian,
-        is_isometric=is_isometric,
-    )
-    # Check selected atoms to avoid using 100+ atoms fixture
-    for index, expected_coord in coordinates_to_check.items():
-        assertion_utils.assert_deep_almost_equal(
-            expected_coord, perturbed_slab.basis.coordinates.values[index], atol=1e-4
-        )
-    # Value taken from visually inspected notebook
-    assertion_utils.assert_deep_almost_equal(expected_cell, perturbed_slab.lattice.vector_arrays, atol=1e-4)

package/tests/py/unit/test_tools_build_slab.py

@@ -1,382 +0,0 @@
-import copy
-from typing import Final, Tuple
-
-import numpy as np
-import pytest
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.esse.models.materials_category_components.entities.auxiliary.two_dimensional.supercell_matrix_2d import (
-    SupercellMatrix2DSchema,
-)
-from mat3ra.made.material import Material
-from mat3ra.made.tools.analyze.interface.utils.vector import align_first_vector_to_x_2d_right_handed
-from mat3ra.made.tools.analyze.lattice_planes import CrystalLatticePlanesMaterialAnalyzer
-from mat3ra.made.tools.build import MaterialWithBuildMetadata
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab import (
-    SlabBuilder,
-    SlabBuilderParameters,
-    SlabConfiguration,
-)
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.helpers import create_slab
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab.termination_utils import select_slab_termination
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab_strained_supercell.builder import (
-    SlabStrainedSupercellBuilder,
-)
-from mat3ra.made.tools.build.pristine_structures.two_dimensional.slab_strained_supercell.configuration import (
-    SlabStrainedSupercellConfiguration,
-)
-from mat3ra.made.tools.build_components.entities.core.two_dimensional.vacuum.configuration import VacuumConfiguration
-from mat3ra.made.tools.build_components.entities.reusable.two_dimensional import (
-    AtomicLayersUniqueRepeatedBuilder,
-    AtomicLayersUniqueRepeatedConfiguration,
-)
-from mat3ra.made.utils import AXIS_TO_INDEX_MAP, adjust_material_cell_to_set_gap_along_direction
-from mat3ra.utils import assertion
-from mat3ra.utils.matrix import convert_2x2_to_3x3
-from unit.fixtures.bulk import BULK_Si_CONVENTIONAL, BULK_Si_PRIMITIVE, BULK_SrTiO3
-from unit.fixtures.slab import (
-    SI_CONVENTIONAL_SLAB_001,
-    SI_PRIMITIVE_SLAB_001,
-    SLAB_SI_CONVENTIONAL_001_NO_VACUUM,
-    SLAB_SrTiO3_011_TERMINATION_O2,
-    SLAB_SrTiO3_011_TERMINATION_O2_BOTTOM,
-    SLAB_SrTiO3_011_TERMINATION_SrTiO,
-)
-
-from .fixtures.monolayer import GRAPHENE
-from .utils import assert_two_entities_deep_almost_equal
-
-SI_CONVENTIONAL_SLAB_001_NO_BUILD_METADATA = copy.deepcopy(SI_CONVENTIONAL_SLAB_001)
-SI_CONVENTIONAL_SLAB_001_NO_BUILD_METADATA["metadata"].pop("build", None)
-
-PARAMS_SI_PRIMITIVE_SLAB_001: Final = (
-    BULK_Si_PRIMITIVE,
-    (0, 0, 1),
-    "Si",
-    2,
-    5.0,
-    [[1, 0], [0, 1]],
-)
-
-PARAMS_BUILD_SLAB_CONVENTIONAL: Final = (
-    BULK_Si_PRIMITIVE,
-    (0, 0, 1),
-    "Si",
-    2,
-    5.0,
-    [[1, 0], [0, 1]],
-)
-
-PARAMS_BUILD_SLAB_CONVENTIONAL_NO_VACUUM: Final = (
-    BULK_Si_PRIMITIVE,
-    (0, 0, 1),
-    "Si",
-    2,
-    0.0,
-    [[1, 0], [0, 1]],
-)
-
-PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_SrTiO: Final = (
-    BULK_SrTiO3,
-    (0, 1, 1),
-    "SrTiO",
-    None,
-    2,
-    5.0,
-    [[1, 0], [0, 1]],
-)
-
-PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_O2: Final = (
-    BULK_SrTiO3,
-    (0, 1, 1),
-    "O2",
-    None,
-    2,
-    5.0,
-    [[1, 0], [0, 1]],
-)
-
-
-PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_O2_BOTTOM: Final = (
-    BULK_SrTiO3,
-    (0, 1, 1),
-    None,
-    "O2",
-    2,
-    5.0,
-    [[1, 0], [0, 1]],
-)
-
-PARAMS_CREATE_SLAB: Final = (
-    BULK_Si_CONVENTIONAL,
-    (0, 0, 1),
-    "Si",
-    None,
-    2,
-    5,
-    [[1, 0], [0, 1]],
-    True,
-)
-
-
-def get_slab_with_builder(
-    material: Material,
-    miller_indices: Tuple[int, int, int],
-    termination_top_formula: str,
-    termination_bottom_formula: str,
-    number_of_layers: int,
-    vacuum: float,
-    xy_supercell_matrix: list,
-) -> Material:
-    crystal_lattice_planes_analyzer = CrystalLatticePlanesMaterialAnalyzer(
-        material=material, miller_indices=miller_indices
-    )
-    terminations = crystal_lattice_planes_analyzer.terminations
-    termination_top = (
-        select_slab_termination(terminations, termination_top_formula) if termination_top_formula is not None else None
-    )
-    termination_bottom = (
-        select_slab_termination(terminations, termination_bottom_formula)
-        if termination_bottom_formula is not None
-        else None
-    )
-
-    atomic_layers_repeated_configuration = AtomicLayersUniqueRepeatedConfiguration(
-        crystal=material,
-        miller_indices=miller_indices,
-        termination_top=termination_top,
-        termination_bottom=termination_bottom,
-        number_of_repetitions=number_of_layers,
-    )
-    atomic_layers_repeated_orthogonal_c = AtomicLayersUniqueRepeatedBuilder().get_material(
-        atomic_layers_repeated_configuration
-    )
-    vacuum_configuration = VacuumConfiguration(
-        size=vacuum, crystal=atomic_layers_repeated_orthogonal_c, direction=AxisEnum.z
-    )
-    build_params = SlabBuilderParameters(use_orthogonal_c=True, xy_supercell_matrix=xy_supercell_matrix)
-    slab_configuration = SlabConfiguration(
-        stack_components=[atomic_layers_repeated_configuration, vacuum_configuration],
-        direction=AxisEnum.z,
-    )
-    builder = SlabBuilder(build_parameters=build_params)
-    slab = builder.get_material(slab_configuration)
-
-    return slab
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, termination_formula, number_of_layers,"
-    + " vacuum, xy_supercell_matrix, expected_slab_config",
-    [
-        (*PARAMS_SI_PRIMITIVE_SLAB_001, SI_PRIMITIVE_SLAB_001),
-    ],
-)
-def test_build_slab_primitive(
-    material_config,
-    miller_indices,
-    termination_formula,
-    number_of_layers,
-    vacuum,
-    xy_supercell_matrix,
-    expected_slab_config,
-):
-    material = MaterialWithBuildMetadata.create(material_config)
-    slab = get_slab_with_builder(
-        material, miller_indices, termination_formula, None, number_of_layers, vacuum, xy_supercell_matrix
-    )
-    slab.metadata.build = []  # Remove build metadata for comparison
-    expected_slab_config.get("metadata", {}).pop("build", None)  # Remove build metadata for comparison
-    assert_two_entities_deep_almost_equal(slab, expected_slab_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, termination_formula, number_of_layers,"
-    + " vacuum, xy_supercell_matrix, expected_slab_config",
-    [
-        (
-            *PARAMS_BUILD_SLAB_CONVENTIONAL,
-            SI_CONVENTIONAL_SLAB_001_NO_BUILD_METADATA,
-        ),
-        (
-            *PARAMS_BUILD_SLAB_CONVENTIONAL_NO_VACUUM,
-            SLAB_SI_CONVENTIONAL_001_NO_VACUUM,
-        ),
-    ],
-)
-def test_build_slab_conventional(
-    material_config,
-    miller_indices,
-    termination_formula,
-    number_of_layers,
-    vacuum,
-    xy_supercell_matrix,
-    expected_slab_config,
-):
-    material = Material.create(material_config)
-    crystal_lattice_planes_analyzer = CrystalLatticePlanesMaterialAnalyzer(
-        material=material, miller_indices=miller_indices
-    )
-    conventional_material = crystal_lattice_planes_analyzer.material_with_conventional_lattice
-    slab = get_slab_with_builder(
-        conventional_material,
-        miller_indices,
-        termination_formula,
-        None,
-        number_of_layers,
-        vacuum,
-        xy_supercell_matrix,
-    )
-    slab.metadata.build = []
-    assert_two_entities_deep_almost_equal(slab, expected_slab_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, termination_top_formula,termination_bottom_formula, number_of_layers,"
-    + " vacuum, xy_supercell_matrix, expected_slab_config",
-    [
-        (
-            *PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_SrTiO,
-            SLAB_SrTiO3_011_TERMINATION_SrTiO,
-        ),
-        (
-            *PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_O2,
-            SLAB_SrTiO3_011_TERMINATION_O2,
-        ),
-        (
-            *PARAMS_BUILD_SLAB_CONVENTIONAL_SrTiO_O2_BOTTOM,
-            SLAB_SrTiO3_011_TERMINATION_O2_BOTTOM,
-        ),
-    ],
-)
-def test_build_slab_conventional_with_multiple_terminations(
-    material_config,
-    miller_indices,
-    termination_top_formula,
-    termination_bottom_formula,
-    number_of_layers,
-    vacuum,
-    xy_supercell_matrix,
-    expected_slab_config,
-):
-    crystal_lattice_planes_analyzer = CrystalLatticePlanesMaterialAnalyzer(
-        material=material_config, miller_indices=miller_indices
-    )
-    conventional_material = crystal_lattice_planes_analyzer.material_with_conventional_lattice
-    slab = get_slab_with_builder(
-        conventional_material,
-        miller_indices,
-        termination_top_formula,
-        termination_bottom_formula,
-        number_of_layers,
-        vacuum,
-        xy_supercell_matrix,
-    )
-
-    slab.metadata.build = []  # Remove build metadata for comparison
-    expected_slab_config.get("metadata", {}).pop("build", None)
-    assert_two_entities_deep_almost_equal(slab, expected_slab_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, miller_indices, termination_top_formula, termination_bottom_formula, number_of_layers,"
-    + " vacuum, xy_supercell, use_conventional_cell, expected_slab_config",
-    [
-        (
-            *PARAMS_CREATE_SLAB,
-            SI_CONVENTIONAL_SLAB_001_NO_BUILD_METADATA,
-        ),
-    ],
-)
-def test_create_slab(
-    material_config,
-    miller_indices,
-    termination_top_formula,
-    termination_bottom_formula,
-    number_of_layers,
-    vacuum,
-    xy_supercell,
-    use_conventional_cell,
-    expected_slab_config,
-):
-    crystal = Material.create(material_config)
-    slab = create_slab(
-        crystal=crystal,
-        miller_indices=miller_indices,
-        use_conventional_cell=use_conventional_cell,
-        termination_top_formula=termination_top_formula,
-        termination_bottom_formula=termination_bottom_formula,
-        number_of_layers=number_of_layers,
-        vacuum=vacuum,
-        xy_supercell_matrix=xy_supercell,
-    )
-    slab.metadata.build = []  # Remove build metadata for comparison
-    assert_two_entities_deep_almost_equal(slab, expected_slab_config)
-
-
-@pytest.mark.parametrize(
-    "material_config, direction, gap, expected_length",
-    [
-        (SLAB_SI_CONVENTIONAL_001_NO_VACUUM, AxisEnum.z, 5.0, 14.5703),  # Adjusted length for z direction
-        (GRAPHENE, AxisEnum.y, 5.0, 6.6448),  # Adjusted length for y direction (lattice vector b)
-    ],
-)
-def test_adjust_lattice_for_gap(material_config, direction, gap, expected_length):
-    material = Material.create(material_config)
-    adjusted_material = adjust_material_cell_to_set_gap_along_direction(material, gap, direction)
-
-    axis_index = AXIS_TO_INDEX_MAP[direction.value]
-    actual_length = np.linalg.norm(adjusted_material.lattice.vector_arrays[axis_index])
-    assertion.assert_almost_equal_numbers(actual_length.tolist(), expected_length)
-
-
-@pytest.mark.parametrize(
-    "crystal_config, miller_indices, termination_formula, number_of_layers, vacuum, xy_supercell_matrix, strain_matrix",
-    [
-        (
-            BULK_Si_PRIMITIVE,
-            (0, 0, 1),
-            "Si",
-            2,
-            5.0,
-            [[2, 0], [-1, 1]],
-            [[0.8, -0.2, 0.0], [0.05, 1.2, 0.0], [0.0, 0.0, 1.0]],
-        ),
-    ],
-)
-def test_build_slab_strained(
-    crystal_config,
-    miller_indices,
-    termination_formula,
-    number_of_layers,
-    vacuum,
-    xy_supercell_matrix,
-    strain_matrix,
-):
-    material = MaterialWithBuildMetadata.create(crystal_config)
-    config = SlabStrainedSupercellConfiguration.from_parameters(
-        material_or_dict=material,
-        miller_indices=miller_indices,
-        termination_top_formula=termination_formula,
-        number_of_layers=number_of_layers,
-        vacuum=vacuum,
-    )
-
-    normal_slab = SlabBuilder().get_material(config)
-
-    config.strain_matrix = Matrix3x3Schema(root=strain_matrix)
-    config.xy_supercell_matrix = SupercellMatrix2DSchema(root=xy_supercell_matrix)
-
-    strained_slab = SlabStrainedSupercellBuilder().get_material(config)
-
-    actual_lattice_vectors = np.array(strained_slab.lattice.vector_arrays)
-    expected_lattice_vectors = (
-        np.array(convert_2x2_to_3x3(xy_supercell_matrix)) @ np.array(normal_slab.lattice.vector_arrays)
-    ) @ np.array(strain_matrix)
-
-    # Align the first vector to x-axis and ensure right-handedness
-    actual_lattice_vectors = align_first_vector_to_x_2d_right_handed(actual_lattice_vectors[:2, :2])
-    expected_lattice_vectors = align_first_vector_to_x_2d_right_handed(expected_lattice_vectors[:2, :2])
-    assert np.allclose(
-        actual_lattice_vectors, expected_lattice_vectors, atol=1e-6
-    ), "Strained supercell lattice vectors do not match expected values."

package/tests/py/unit/test_tools_build_strain.py

@@ -1,36 +0,0 @@
-import pytest
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components.operations.core.modifications.strain.helpers import create_strain
-from unit.fixtures.strain import BULK_Si_CONVENTIONAL_STRAINED
-from unit.utils import assert_two_entities_deep_almost_equal
-
-from .fixtures.bulk import BULK_Si_CONVENTIONAL
-
-
-@pytest.mark.parametrize(
-    "material_config, strain_matrix, expected_material_config",
-    [
-        (BULK_Si_CONVENTIONAL, [[1.1, 0, 0], [0, 1.1, 0], [0, 0, 1.0]], BULK_Si_CONVENTIONAL_STRAINED),
-    ],
-)
-def test_create_strain(material_config, strain_matrix, expected_material_config):
-    material = Material.create(material_config)
-    strained_material = create_strain(material, Matrix3x3Schema(root=strain_matrix))
-
-    assert_two_entities_deep_almost_equal(strained_material, expected_material_config)
-
-    build_step = strained_material.metadata.build[-1]
-    assert build_step.configuration["type"] == "StrainConfiguration"
-    assert build_step.configuration["strain_matrix"] == strain_matrix
-    assert build_step.build_parameters == {}
-
-
-def test_create_strain_with_scale_factor():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    strained_material = create_strain(material, scale_factor=1.1)
-
-    assert strained_material.name == f"{material.name} (scale=1.1000)"
-    build_step = strained_material.metadata.build[-1]
-    assert build_step.configuration["scale_factor"] == 1.1
-    assert build_step.configuration["strain_matrix"] == [[1.1, 0.0, 0.0], [0.0, 1.1, 0.0], [0.0, 0.0, 1.1]]

package/tests/py/unit/test_tools_build_supercell.py

@@ -1,47 +0,0 @@
-import numpy as np
-import pytest
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
-from mat3ra.made.tools.build_components.metadata import MaterialWithBuildMetadata
-from unit.fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
-from unit.fixtures.supercell import SI_SUPERCELL_2X2X1
-
-from .fixtures.bulk import BULK_Si_PRIMITIVE
-from .utils import assert_two_entities_deep_almost_equal
-
-SUPERCELL_MATRIX_2X2X1 = [[2, 0, 0], [0, 2, 0], [0, 0, 1]]
-
-
-@pytest.mark.parametrize(
-    "material_config, supercell_matrix, expected_material_config",
-    [
-        (
-            BULK_Si_PRIMITIVE,
-            SUPERCELL_MATRIX_2X2X1,
-            SI_SUPERCELL_2X2X1,
-        ),
-    ],
-)
-def test_create_supercell(material_config, supercell_matrix, expected_material_config):
-    material = Material.create(material_config)
-    supercell_material = create_supercell(material, supercell_matrix)
-
-    assert_two_entities_deep_almost_equal(supercell_material, expected_material_config)
-
-    expected_vectors = np.array(supercell_matrix) @ np.array(material.lattice.vector_arrays)
-    actual_vectors = np.array(supercell_material.lattice.vector_arrays)
-    assert np.allclose(actual_vectors, expected_vectors, atol=1e-6), "Supercell vectors do not match expected values."
-
-
-def test_create_supercell_preserves_prior_build_metadata():
-    material = MaterialWithBuildMetadata.create(GRAPHENE_NICKEL_INTERFACE)
-    prior_build_types = [step.configuration.get("type") for step in material.metadata.build]
-
-    supercell_material = create_supercell(material, SUPERCELL_MATRIX_2X2X1)
-
-    result_build_types = [step.configuration.get("type") for step in supercell_material.metadata.build]
-    assert result_build_types[:-1] == prior_build_types
-    assert result_build_types[-1] == "SupercellConfiguration"
-    assert supercell_material.metadata.to_dict().get("boundaryConditions") == material.metadata.to_dict().get(
-        "boundaryConditions"
-    )

package/tests/py/unit/test_tools_calculate.py

@@ -1,67 +0,0 @@
-import numpy as np
-from ase.build import add_adsorbate, bulk, fcc111, graphene, surface
-from ase.calculators import emt
-from mat3ra.made.material import Material
-from mat3ra.made.tools.calculate import (
-    calculate_adhesion_energy,
-    calculate_interfacial_energy,
-    calculate_surface_energy,
-    calculate_total_energy,
-    calculate_total_energy_per_atom,
-)
-from mat3ra.made.tools.convert import from_ase
-from unit.fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
-
-# Interface and its constituents structures setup
-nickel_slab = fcc111("Ni", size=(2, 2, 3), vacuum=10, a=3.52)
-graphene_layer = graphene(size=(1, 1, 1), vacuum=10)
-graphene_layer.cell = nickel_slab.cell
-interface = nickel_slab.copy()
-add_adsorbate(interface, graphene_layer, height=2, position="ontop")
-
-# Material.create yields MaterialMetadataBoundaryConditions; bulks are resolved from nested build.
-interface_material = Material.create(GRAPHENE_NICKEL_INTERFACE)
-nickel_slab_material = Material.create(from_ase(nickel_slab))
-
-# Calculator setup
-calculator = emt.EMT()
-
-EXPECTED_INTERFACIAL_ENERGY = -0.78488
-
-
-def test_calculate_total_energy():
-    atoms = bulk("C", cubic=True)
-    calculator = emt.EMT()
-    energy = calculate_total_energy(atoms, calculator)
-    assert np.isclose(energy, 1.3612647524769237)
-
-
-def test_calculate_total_energy_per_atom():
-    atoms = bulk("C", cubic=True)
-    calculator = emt.EMT()
-    print(atoms.get_global_number_of_atoms())
-    energy_per_atom = calculate_total_energy_per_atom(atoms, calculator)
-    assert np.isclose(energy_per_atom, 0.1701580940596)
-
-
-def test_calculate_surface_energy():
-    atoms_slab = surface("C", (1, 1, 1), 3, vacuum=10)
-    atoms_bulk = bulk("C", cubic=True)
-    calculator = emt.EMT()
-    surface_energy = calculate_surface_energy(atoms_slab, atoms_bulk, calculator)
-    assert np.isclose(surface_energy, 0.148845)
-
-
-def test_calculate_adhesion_energy():
-    adhesion_energy = calculate_adhesion_energy(interface, nickel_slab, graphene_layer, calculator)
-    assert np.isclose(adhesion_energy, 0.07345)
-
-
-def test_calculate_interfacial_energy():
-    interfacial_energy = calculate_interfacial_energy(
-        interface_material,
-        substrate_slab=nickel_slab_material,
-        film_slab=graphene_layer,
-        calculator=calculator,
-    )
-    assert np.isclose(interfacial_energy, EXPECTED_INTERFACIAL_ENERGY)