@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/js/lattice/lattice_reciprocal.ts

@@ -1,104 +0,0 @@
-import "../setup";
-
-import { LatticeSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { ReciprocalLattice } from "../../../src/js/lattice/reciprocal/lattice_reciprocal";
-import { Na4Cl4, Silicon, SiSlab } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Lattice Reciprocal", () => {
-    it("should extract kpoint path", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const expectedPath = [
-            {
-                point: "Γ",
-                steps: 0,
-                coordinates: [0, 0, 0],
-            },
-            {
-                point: "R",
-                steps: 1,
-                coordinates: [0.5, 0.5, 0.5],
-            },
-        ];
-        const actualPath = lattice.extractKpointPath([
-            [0, 0, 0],
-            [0.5, 0.5, 0.5],
-        ]);
-        assertDeepAlmostEqual(expectedPath, actualPath);
-    });
-
-    it("should return cartesian coordinates of a point", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const expectedCoordinates = [0.5, 0.5, 0.5];
-        const actualCoordinates = lattice.getCartesianCoordinates([0.5, 0.5, 0.5]);
-        assertDeepAlmostEqual(actualCoordinates, expectedCoordinates);
-    });
-
-    it("should return reciprocal vectors", () => {
-        const lattice = new ReciprocalLattice(Silicon.lattice as LatticeSchema);
-        const actualVectors = lattice.reciprocalVectors;
-        const expectedVectors = [
-            [1.1547005383792517, -0.40824829046386313, 0],
-            [0, 1.2247448713915892, 0],
-            [-0.5773502691896261, -0.40824829046386313, 1],
-        ];
-        assertDeepAlmostEqual(actualVectors, expectedVectors);
-    });
-
-    it("should extract symmetry points", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const actualPoints = lattice.symmetryPoints;
-        const expectedPoints = [
-            {
-                point: "Γ",
-                coordinates: [0, 0, 0],
-            },
-            {
-                point: "R",
-                coordinates: [0.5, 0.5, 0.5],
-            },
-            {
-                point: "X",
-                coordinates: [0, 0.5, 0],
-            },
-            {
-                point: "M",
-                coordinates: [0.5, 0.5, 0],
-            },
-        ];
-        assertDeepAlmostEqual(actualPoints, expectedPoints);
-    });
-
-    it("should calculate k-grid dimensions based on number of points", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromPointsCount(500);
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate k-grid dimensions based on spacing in cartesian units", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromSpacing(0.09);
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate k-grid dimensions based on spacing in 1/angstrom", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromSpacing(0.11, "angstrom");
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate average spacing in 1/angstrom based on k-grid dimensions", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = [12, 12, 4];
-        const expectedSpacing = 0.1047;
-        const spacing = lattice.getSpacingFromDimensions(dimensions, "angstrom");
-        expect(spacing).to.be.almost(expectedSpacing, 1e-4);
-    });
-});

package/tests/js/material.test.ts

@@ -1,42 +0,0 @@
-import { expect } from "chai";
-
-import { Material } from "../../src/js/material";
-import { FeOStandata, Graphene, Na4Cl4, Silicon } from "./fixtures";
-
-const newBasisXYZ = `Si     0.000000    0.000000    0.000000
-Ge     0.250000    0.250000    0.250000
-`;
-
-describe("Material", () => {
-    it("should return unique elements", () => {
-        const material = new Material(Na4Cl4);
-        expect(material.uniqueElements).to.have.same.members(["Na", "Cl"]);
-    });
-
-    it("should return cloned material", () => {
-        const material = new Material(Silicon);
-        const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.Basis.units);
-        expect(clonedMaterial.Basis.elements).to.have.lengthOf(2);
-    });
-
-    describe("calculateHash", () => {
-        [
-            { name: "Silicon", fixture: Silicon },
-            { name: "Graphene", fixture: Graphene },
-        ].forEach(({ name, fixture }) => {
-            it(`should match expected hash for ${name}`, () => {
-                const material = new Material(fixture);
-                expect(material.calculateHash()).to.equal((fixture as any).hash);
-                expect(material.scaledHash).to.equal((fixture as any).scaledHash);
-            });
-        });
-
-        it("should match expected hash for FeO (standata)", () => {
-            const expectedHashes = require("../../fixtures/hashes.json");
-            const material = new Material(FeOStandata);
-            expect(material.calculateHash()).to.equal(expectedHashes.FeO.hash);
-            expect(material.scaledHash).to.equal(expectedHashes.FeO.scaledHash);
-        });
-    });
-});

package/tests/js/parsers/espresso.ts

@@ -1,15 +0,0 @@
-import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
-import { expect } from "chai";
-
-import { Material } from "../../../src/js/material";
-import parsers from "../../../src/js/parsers/parsers";
-import { Silicon, SiPWSCFInput } from "../fixtures";
-
-describe("Parsers:Espresso", () => {
-    it("should return textual representation of a material according to QE pw.x input format", () => {
-        const material = new Material(Silicon);
-        expect(parsers.espresso.toEspressoFormat(material as MaterialSchema)).to.be.equal(
-            SiPWSCFInput,
-        );
-    });
-});

package/tests/js/parsers/native_formats.ts

@@ -1,35 +0,0 @@
-import "../setup";
-
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import nativeFormatParsers from "../../../src/js/parsers/native_format_parsers";
-import { Graphene, GraphenePoscar, NiHex, NiHexPoscar } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Parsers.NativeFormat", () => {
-    it("should return a material config for graphene from a json", () => {
-        const json = JSON.stringify(Graphene);
-        expect(nativeFormatParsers.convertFromNativeFormat(json)).to.deep.equal(Graphene);
-    });
-
-    it("should return a material config for graphene from a poscar", () => {
-        const poscar = GraphenePoscar;
-        const config = nativeFormatParsers.convertFromNativeFormat(poscar);
-        assertDeepAlmostEqual(config, Graphene, ["basis.labels", "lattice"]);
-        assertDeepAlmostEqual(config.lattice, Graphene.lattice, ["type"]);
-    });
-
-    it("should return a material config for Ni hex from a poscar", () => {
-        const poscar = NiHexPoscar;
-        const config = nativeFormatParsers.convertFromNativeFormat(poscar);
-        assertDeepAlmostEqual(config, NiHex, ["lattice", "basis.labels"]);
-        assertDeepAlmostEqual(config.lattice, NiHex.lattice, ["type"]); // to omit "lattice.type" property
-    });
-
-    it("should throw an error for unknown format", () => {
-        const text = "A\n snippet from an unknown format";
-        expect(() => nativeFormatParsers.convertFromNativeFormat(text)).to.throw("Unknown format");
-    });
-});

package/tests/js/parsers/poscar.ts

@@ -1,89 +0,0 @@
-import { expect } from "chai";
-
-import { AtomicConstraints } from "../../../src/js/constraints/constraints";
-import { Material } from "../../../src/js/material";
-import parsers from "../../../src/js/parsers/parsers";
-import { atomsCount } from "../../../src/js/parsers/poscar";
-import {
-    atomicConstraints,
-    H2OPoscar,
-    Na4Cl4,
-    Na4Cl4Poscar,
-    Silicon,
-    Zr1H23Zr1H1,
-    Zr1H23Zr1H1Poscar,
-} from "../fixtures";
-
-const O2_POSCAR_WITH_COMMENTS = `O2 molecule in a box
-1.0 ! universal scaling parameters
-12.0 0.0 0.0 ! lattice vector a(1)
-0.0 12.0 0.0 ! lattice vector a(2)
-0.0 0.0 12.0 ! lattice vector a(3)
-O
-2 ! number of atoms
-cart ! positions in cartesian coordinates
-0 0 0 O
-0 0 1.21 O
-`;
-
-describe("Parsers.POSCAR", () => {
-    it("should return a valid poscar", () => {
-        const material = new Material(Na4Cl4);
-        expect(`${material.getAsPOSCAR()}\n`).to.be.equal(Na4Cl4Poscar);
-    });
-
-    it("should return poscar elements line according to id in basis, duplicate entries separate", () => {
-        const material = new Material(Zr1H23Zr1H1);
-        expect(`${material.getAsPOSCAR()}\n`).to.be.equal(Zr1H23Zr1H1Poscar);
-    });
-
-    it("should return the number of atoms for a molecule in a poscar file", () => {
-        expect(atomsCount(H2OPoscar)).to.be.equal(3);
-    });
-
-    it("should detect POSCAR with VASP-style comments", () => {
-        expect(parsers.poscar.isPoscar(O2_POSCAR_WITH_COMMENTS)).to.be.equal(true);
-        expect(parsers.nativeFormatParsers.detectFormat(O2_POSCAR_WITH_COMMENTS)).to.be.equal(
-            "poscar",
-        );
-    });
-
-    it("should parse POSCAR with VASP-style comments", () => {
-        const materialConfig = parsers.poscar.fromPoscar(O2_POSCAR_WITH_COMMENTS);
-        expect(materialConfig).to.have.property("basis");
-        expect((materialConfig as { basis: { elements: object[] } }).basis.elements).to.have.length(
-            2,
-        );
-    });
-
-    it("should return constraints as string with given map function", () => {
-        const constraints = AtomicConstraints.fromObjects(atomicConstraints);
-        expect(
-            constraints.getAsStringByIndex(0, parsers.poscar.atomicConstraintsCharFromBool),
-        ).to.be.equal("T T F");
-    });
-
-    it("should generate POSCAR with constraints if they were present", () => {
-        const newBasisXYZ = `Si     0.000000    0.000000    0.000000 0 0 0
-Ge     0.250000    0.250000    0.250000 1 1 1
-`;
-        const poscarConstraints = `Silicon FCC
-1.0
-   3.348920000\t   0.000000000\t   1.933500000
-   1.116307000\t   3.157392000\t   1.933500000
-   0.000000000\t   0.000000000\t   3.867000000
-Si Ge
-1 1
-Selective dynamics
-direct
-   0.000000000    0.000000000    0.000000000 F F F Si
-   0.250000000    0.250000000    0.250000000 T T T Ge`;
-
-        const material = new Material(Silicon);
-        const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.Basis.units);
-
-        const poscar = clonedMaterial.getAsPOSCAR(true);
-        expect(poscar).to.be.equal(poscarConstraints);
-    });
-});

package/tests/js/parsers/xyz.ts

@@ -1,33 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-
-import parsers from "../../../src/js/parsers/parsers";
-import { FeO, Silicon } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Parsers:XYZ", () => {
-    it("should extract basis from XYZ text", () => {
-        const text = "Si 0 0 0 \n Si 0.25 0.25 0.25";
-        assertDeepAlmostEqual(parsers.xyz.toBasisConfig(text), Silicon.basis, [
-            "constraints",
-            "cell",
-            "units",
-        ]);
-    });
-
-    it("should extract basis from XYZ text with atomic labels", () => {
-        const text =
-            "Fe1  0.00  0.00  0.00  1 1 1\n" +
-            "Fe2  0.50  0.50  0.50  1 1 1\n" +
-            "O    0.25  0.25  0.25  1 1 1\n" +
-            "O    0.75  0.75  0.75  1 1 1";
-        assertDeepAlmostEqual(parsers.xyz.toBasisConfig(text), FeO.basis, ["cell", "units"]);
-    });
-
-    it("should return [true, true, true] as constraints for the line without any constraints", () => {
-        const text = "Si 0 0 0 0 1 1\n Si 0.25 0.25 0.25";
-        const basis = parsers.xyz.toBasisConfig(text);
-        assertDeepAlmostEqual(basis.constraints[0].value, [false, true, true]);
-        assertDeepAlmostEqual(basis.constraints[1].value, [true, true, true]);
-    });
-});

package/tests/js/parsers/xyz_combinatorial_basis.ts

@@ -1,156 +0,0 @@
-import { expect } from "chai";
-
-import { Basis } from "../../../src/js/basis/basis";
-import { CombinatorialBasis } from "../../../src/js/parsers/xyz_combinatorial_basis";
-import { AsGeBasis, FeLiSiBasis, Ge2Basis, OSiBasis, Si2Basis } from "../fixtures";
-
-describe("Parsers:CombinatorialBasis", () => {
-    it("toBasisConfig", () => {
-        // eslint-disable-next-line new-cap
-        const basisConfig2 = CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-            {
-                element: "Si",
-                coordinate: [0, 0, 0],
-            },
-            {
-                element: "Li",
-                coordinate: [0.3, 0.3, 0.3],
-            },
-            {
-                element: "Fe",
-                coordinate: [0.5, 0.5, 0.5],
-            },
-        ]);
-        const [basis1, basis2] = [
-            new Basis(FeLiSiBasis),
-            Basis.fromElementsAndCoordinates(basisConfig2),
-        ];
-
-        expect(basis1.isEqualTo(basis2)).to.equal(true);
-    });
-
-    it("Regular XYZ", () => {
-        const xyz = `
-            Si 0.0 0.0 0.0
-            O 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(xyz);
-        expect(basis.uniqueElements).deep.equal(["O", "Si"]);
-        const basis1 = Basis.fromElementsAndCoordinates(basis.allBasisConfigs[0]);
-        const basis2 = new Basis(OSiBasis);
-        expect(basis1.isEqualTo(basis2)).to.equal(true);
-    });
-
-    it("Permutation XYZ", () => {
-        const permutation = `
-            Si/Ge/As 0.0 0.0 0.0
-            Si/Ge 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(permutation);
-        expect(basis.uniqueElements).deep.equal(["As", "Ge", "Si"]);
-        const basisList1 = basis.allBasisConfigs.map((c) => Basis.fromElementsAndCoordinates(c));
-        const basisList2 = [Si2Basis, Ge2Basis, AsGeBasis].map((c) => new Basis(c));
-
-        basisList1.forEach((basis1) => {
-            const condition = basisList2
-                .map((basis2) => basis2.isEqualTo(basis1))
-                .reduce((a, b) => a || b);
-            expect(condition).to.equal(true);
-        });
-    });
-
-    it("Combination XYZ", () => {
-        const combination = `
-            Si,Ge,As 0.0 0.0 0.0
-            Si,Ge 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(combination);
-        expect(basis.uniqueElements).deep.equal(["As", "Ge", "Si"]);
-
-        const basisList1 = basis.allBasisConfigs.map((c) => Basis.fromElementsAndCoordinates(c));
-        expect(basisList1.length).to.equal(6);
-
-        const basisList2 = [
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Si",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Si",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Ge",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Ge",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "As",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "As",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-        ].map((c) => Basis.fromElementsAndCoordinates(c));
-
-        basisList1.forEach((basis1) => {
-            const condition = basisList2
-                .map((basis2) => basis2.isEqualTo(basis1))
-                .reduce((a, b) => a || b);
-            expect(condition).to.equal(true);
-        });
-    });
-
-    it("Mixing combination and permutation should fail", () => {
-        const mixedInMultipleLines = `
-            Si/Ge/As 0.0 0.0 0.0\n
-            Si,Ge 0.5 0.5 0.5
-        `;
-        const mixedInOneLine = `
-            Si/Ge,As 0.0 0.0 0.0
-        `;
-        // Wrapping into function as recommended in: http://chaijs.com/api/bdd/
-        expect(() => new CombinatorialBasis(mixedInMultipleLines)).to.throw();
-        expect(() => new CombinatorialBasis(mixedInOneLine)).to.throw();
-    });
-});

package/tests/js/setup.ts

@@ -1,6 +0,0 @@
-import chai from "chai";
-import chaiAlmost from "chai-almost";
-
-const TOLERANCE = 1e-3;
-
-chai.use(chaiAlmost(TOLERANCE));

package/tests/js/tools/basis.ts

@@ -1,22 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-
-import { Basis } from "../../../src/js/basis/basis";
-import tools from "../../../src/js/tools";
-import { H2HFinal, H2HImage, H2HInitial, Si2Basis, Si2BasisRepeated } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Tools:Basis", () => {
-    it("should return a repeated basis", () => {
-        const basis = new Basis(Si2Basis);
-        const repeatedBasis = tools.basis.repeat(basis, [2, 1, 1]);
-        assertDeepAlmostEqual(Si2BasisRepeated, repeatedBasis.toJSON());
-    });
-
-    it("should return interpolated basises", () => {
-        const finalBasis = new Basis(H2HFinal.basis);
-        const initialBasis = new Basis(H2HInitial.basis);
-        const images = tools.basis.interpolate(initialBasis, finalBasis, 1);
-        assertDeepAlmostEqual(H2HImage.basis, images[0].toJSON());
-    });
-});

package/tests/js/tools/supercell.ts

@@ -1,58 +0,0 @@
-import { Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { Basis } from "../../../src/js/basis/basis";
-import { Made } from "../../../src/js/made";
-import { Material } from "../../../src/js/material";
-import { Silicon, SiSupercell } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Tools:Supercell", () => {
-    it("should generate supercell", () => {
-        const material = new Material(Silicon);
-        const supercell = Made.tools.supercell.generateConfig(material, [
-            [2, 0, 0],
-            [0, 2, 0],
-            [0, 0, 2],
-        ] as Matrix3X3Schema);
-        // expect(supercell.lattice).deep.equal(SiSupercell.lattice, "lattices are not equal");
-        assertDeepAlmostEqual(supercell.lattice, SiSupercell.lattice, ["vectors"]);
-
-        const basis1 = new Basis(SiSupercell.basis);
-        const basis2 = new Basis(supercell.basis);
-
-        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
-    });
-
-    it("should generate supercell with removed constraints", () => {
-        const newBasisXYZ = `Si     0.000000    0.000000    0.000000
-Ge     0.250000    0.250000    0.250000
-`;
-        const poscarNoConstraints = `Silicon FCC - supercell [[2,0,0],[0,1,0],[0,0,1]]
-1.0
-   6.697840000\t   0.000000000\t   3.867000000
-   1.116307000\t   3.157392000\t   1.933500000
-   0.000000000\t   0.000000000\t   3.867000000
-Si Ge
-2 2
-direct
-   0.000000000    0.000000000    0.000000000  Si
-   0.500000000    0.000000000    0.000000000  Si
-   0.125000000    0.250000000    0.250000000  Ge
-   0.625000000    0.250000000    0.250000000  Ge`;
-        const material = new Material(Silicon);
-        const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.Basis.units);
-        const supercellConfig = Made.tools.supercell.generateConfig(clonedMaterial, [
-            [2, 0, 0],
-            [0, 1, 0],
-            [0, 0, 1],
-        ] as Matrix3X3Schema);
-
-        const newMaterial = new Material(supercellConfig);
-        const poscar = newMaterial.getAsPOSCAR(true);
-        expect(poscar).to.be.equal(poscarNoConstraints);
-    });
-});

package/tests/js/tools/surface.ts

@@ -1,115 +0,0 @@
-import type { MaterialSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-
-import { Material } from "../../../src/js/material";
-import tools from "../../../src/js/tools";
-import { SlabConfigSchema } from "../../../src/js/tools/surface";
-import { Silicon, SiSlab100, SiSlab111, SiSlab111NoVacuum } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-const generateSlabWithVacuum = (slabConfig: SlabConfigSchema, vacuumRatio: number) => {
-    const slabMaterial = new Material(slabConfig);
-    const { outOfPlaneAxisIndex } = slabConfig;
-    const AXES = ["a", "b", "c"] as const;
-
-    tools.material.scaleOneLatticeVector(
-        slabMaterial,
-        AXES[outOfPlaneAxisIndex],
-        1 / (1 - vacuumRatio),
-    );
-
-    return slabMaterial;
-};
-
-describe("Tools:Surface", () => {
-    it("should return slab (100)", () => {
-        const material = new Material(Silicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 0, 0], 3, 1, 1);
-        assertDeepAlmostEqual(SiSlab100, slabConfig);
-    });
-
-    it("should return slab (111)", () => {
-        const material = new Material(Silicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 1, 1], 3, 1, 1);
-        assertDeepAlmostEqual(SiSlab111NoVacuum, slabConfig);
-    });
-
-    it("should return slab (111) even if ids shifted", () => {
-        const adjustedSilicon: MaterialSchema = {
-            ...Silicon,
-            basis: {
-                elements: [
-                    {
-                        id: 10,
-                        value: "Si",
-                    },
-                    {
-                        id: 14,
-                        value: "Si",
-                    },
-                ],
-                coordinates: [
-                    {
-                        id: 10,
-                        value: [0.0, 0.0, 0.0],
-                    },
-                    {
-                        id: 14,
-                        value: [0.25, 0.25, 0.25],
-                    },
-                ],
-            },
-        };
-        const material = new Material(adjustedSilicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 1, 1], 3, 1, 1);
-        assertDeepAlmostEqual(SiSlab111NoVacuum, slabConfig);
-    });
-
-    it("should return slab (111) with vacuum", () => {
-        const material = new Material(Silicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 1, 1], 3, 1, 1);
-        const vacuumRatio = 0.5;
-        const slabMaterial = generateSlabWithVacuum(slabConfig, vacuumRatio);
-        const expectedSlabMaterial = new Material(SiSlab111);
-        const expectedMaterialJSON = expectedSlabMaterial.toJSON();
-        const slabMaterialJSON = slabMaterial.toJSON();
-        assertDeepAlmostEqual(expectedMaterialJSON, slabMaterialJSON);
-    });
-
-    it("should return slab (111) with vacuum for gamma = 59.999", () => {
-        const adjustedSilicon = {
-            ...Silicon,
-            lattice: {
-                ...Silicon.lattice,
-                gamma: 59.999,
-            },
-        };
-        const material = new Material(adjustedSilicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 1, 1], 3, 1, 1);
-        const vacuumRatio = 0.5;
-        const slabMaterial = generateSlabWithVacuum(slabConfig, vacuumRatio);
-        const expectedSlabMaterial = new Material(SiSlab111);
-        const expectedMaterialJSON = expectedSlabMaterial.toJSON();
-        const slabMaterialJSON = slabMaterial.toJSON();
-        assertDeepAlmostEqual(expectedMaterialJSON, slabMaterialJSON);
-    });
-
-    it("should return slab (111) with vacuum for gamma = 60.001", () => {
-        const adjustedSilicon = {
-            ...Silicon,
-            lattice: {
-                ...Silicon.lattice,
-                gamma: 60.001,
-            },
-        };
-        const material = new Material(adjustedSilicon);
-        const slabConfig = tools.surface.generateConfig(material, [1, 1, 1], 3, 1, 1);
-        const vacuumRatio = 0.5;
-        const slabMaterial = generateSlabWithVacuum(slabConfig, vacuumRatio);
-        const expectedSlabMaterial = new Material(SiSlab111);
-        const expectedMaterialJSON = expectedSlabMaterial.toJSON();
-        const slabMaterialJSON = slabMaterial.toJSON();
-        assertDeepAlmostEqual(expectedMaterialJSON, slabMaterialJSON);
-    });
-});