@mat3ra/made 2026.8.7-0 → 2026.8.13-0

package/src/js/tools/supercell.ts

@@ -5,10 +5,10 @@ import { Basis } from "../basis/basis";
 import { ConstrainedBasis } from "../basis/constrained_basis";
 import { Cell } from "../cell/cell";
 import { Lattice } from "../lattice/lattice";
-import type { Material } from "../material";
+import type { MaterialSchemaMap } from "../Material";
+import type Material from "../Material";
 import cellTools from "./cell";
 
-
 const ADD = Utils.math.add;
 
 /**
@@ -53,18 +53,19 @@ function generateNewBasisWithinSupercell(
 
 /**
  * @summary Generates supercell config for the specified material.
- * @param material
- * @param supercellMatrix {Number[][]}
  */
-function generateConfig(material: Material, supercellMatrix: Matrix3X3Schema) {
+function generateConfig<Schemas extends MaterialSchemaMap = MaterialSchemaMap>(
+    material: Material<Schemas>,
+    supercellMatrix: Matrix3X3Schema,
+) {
     const det = Utils.math.det(supercellMatrix);
     if (det === 0) {
         throw new Error("Scaling matrix is degenerate.");
     }
-    const cell = material.Lattice.vectors;
+    const cell = material.getLattice().vectors;
     const supercell = cell.cloneAndScaleByMatrix(supercellMatrix);
     const newBasis = generateNewBasisWithinSupercell(
-        material.Basis,
+        material.getBasis(),
         cell,
         supercell,
         supercellMatrix,

package/src/js/tools/surface.ts

@@ -1,14 +1,9 @@
-import {
-    Coordinate3DSchema,
-    MaterialSchema,
-    Matrix3X3Schema,
-    Vector3DSchema,
-} from "@mat3ra/esse/dist/js/types";
+import { Coordinate3DSchema, Matrix3X3Schema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
 import { Utils } from "@mat3ra/utils";
 
 import { Cell } from "../cell/cell";
 import { Lattice } from "../lattice/lattice";
-import { Material } from "../material";
+import Material, { type MaterialConfig, type MaterialSchemaMap } from "../Material";
 import SupercellTools from "./supercell";
 
 const MULT = Utils.math.multiply;
@@ -36,10 +31,6 @@ function extGCD(a: number, b: number): [number, number] {
 /**
  * Generates a slab scaling matrix for the specified cell based on miller indices.
  * Inspired by from https://gitlab.com/ase/ase/blob/master/ase/build/general_surface.py.
- * @param cell {Cell}
- * @param millerIndices {Number[]}
- * @param tol {Number} Zero-value tolerance
- * @return {Number[][]}
  */
 function getMillerScalingMatrix(
     cell: Cell,
@@ -132,7 +123,6 @@ function getMillerScalingMatrix(
  * @param thickness {Number} Surface (Slab) thickness in layers (Positive Integer).
  * @param vx {Number} Size of lateral supercell along the direction of the first (x) cell vector (Positive Integer).
  * @param vy {Number} Size of lateral supercell along the direction of the second (y) cell vector (Positive Integer).
- * @return {Number[][]}
  */
 function getDimensionsScalingMatrix(
     outOfPlaneAxisIndex: number,
@@ -158,7 +148,7 @@ function getDimensionsScalingMatrix(
     return transformationMatrix as Matrix3X3Schema;
 }
 
-export type SlabConfigSchema = MaterialSchema & {
+export type SlabConfigSchema = MaterialConfig & {
     outOfPlaneAxisIndex: number;
 };
 
@@ -171,8 +161,8 @@ export type SlabConfigSchema = MaterialSchema & {
  * @param vy {Number} Size of lateral supercell along the direction of the second (y) cell vector (Positive Integer).
  * @return {Object}
  */
-function generateConfig(
-    material: Material,
+function generateConfig<Schemas extends MaterialSchemaMap = MaterialSchemaMap>(
+    material: Material<Schemas>,
     millerIndices: Coordinate3DSchema,
     numberOfLayers = 1,
     vx = 1,
@@ -181,7 +171,7 @@ function generateConfig(
     if (numberOfLayers < 1)
         throw new Error("Made.tools.surface.generateConfig: number of layers < 1.");
 
-    const cell = material.Lattice.vectors;
+    const cell = material.getLattice().vectors;
     const millerScalingMatrix = getMillerScalingMatrix(cell, millerIndices);
     const millerSupercell = cell.cloneAndScaleByMatrix(millerScalingMatrix);
     const millerPlanePseudoNormal = cell.convertPointToCartesian(millerIndices);
@@ -195,7 +185,7 @@ function generateConfig(
     );
     const supercellMatrix = MULT(dimensionsScalingMatrix, millerScalingMatrix);
     const supercell = millerSupercell.cloneAndScaleByMatrix(dimensionsScalingMatrix);
-    const tempBasis = material.Basis.clone();
+    const tempBasis = material.getBasis().clone();
     const newBasis = SupercellTools.generateNewBasisWithinSupercell(
         tempBasis,
         cell,

package/src/py/mat3ra/made/material.py

@@ -4,7 +4,7 @@ from typing import Any, List, Optional, Union
 from mat3ra.code.constants import AtomicCoordinateUnits, Units
 from mat3ra.code.entity import HasDescriptionHasMetadataNamedDefaultableInMemoryEntityPydantic
 from mat3ra.esse.models.material import MaterialSchema
-from pydantic import ConfigDict, SkipValidation, computed_field, field_serializer
+from pydantic import ConfigDict, SkipValidation, computed_field
 
 from .basis import Basis
 from .lattice import Lattice
@@ -125,10 +125,11 @@ class Material(MaterialSchema, HasDescriptionHasMetadataNamedDefaultableInMemory
     def hash(self) -> str:
         return self.calculate_hash()
 
-    @field_serializer("scaledHash")
-    def serialize_scaled_hash(self, _scaled_hash: Optional[str]) -> str:
-        return self.scaled_hash
-
     @property
     def scaled_hash(self) -> str:
         return self.calculate_hash(is_scaled=True)
+
+    @computed_field
+    @property
+    def scaledHash(self) -> str:
+        return self.scaled_hash

package/tests/fixtures/si-standata.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:62175309558d4a75da4fd723ccb47dc558cdbb89fa224e61921c4ee2d5b48094
-size 1133
+oid sha256:d81edc05f74463da35845fd348716de48459b8b3b5acfa5076fb621a8e23a74e
+size 1454

package/tests/js/basis/basis.ts

@@ -5,7 +5,7 @@ import { Utils } from "@mat3ra/utils";
 import { expect } from "chai";
 
 import { Basis } from "../../../src/js/basis/basis";
-import { Material } from "../../../src/js/material";
+import Material from "../../../src/js/Material";
 import {
     AsGeBasis,
     C2H4,
@@ -29,20 +29,20 @@ describe("Basis", () => {
     });
 
     it("should return true when basis is compared to its clone", () => {
-        const basis1 = new Material(Na4Cl4).Basis;
+        const basis1 = new Material(Na4Cl4).getBasis();
         const basis2 = basis1.clone();
         expect(basis1.isEqualTo(basis2)).to.be.equal(true);
         expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
     });
 
     it("should return jsonified basis", () => {
-        const basis = new Material(Na4Cl4).Basis;
+        const basis = new Material(Na4Cl4).getBasis();
         expect(basis.toJSON()).to.be.deep.almost.equal(Na4Cl4.basis);
     });
 
     it("should return true if cells are equal", () => {
-        const basis1 = new Material(Na4Cl4).Basis;
-        const basis2 = new Material(Na4Cl4Cartesian).Basis;
+        const basis1 = new Material(Na4Cl4).getBasis();
+        const basis2 = new Material(Na4Cl4Cartesian).getBasis();
         expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
     });
 
@@ -120,7 +120,7 @@ describe("Basis", () => {
     });
 
     it("should convert crystal to cartesian", () => {
-        const basis = new Material(Na4Cl4).Basis;
+        const basis = new Material(Na4Cl4).getBasis();
         basis.toCartesian();
         expect(basis.isInCartesianUnits).to.be.equal(true);
         expect(basis.coordinates).to.be.deep.almost.equal(Na4Cl4Cartesian.basis.coordinates);
@@ -195,8 +195,8 @@ describe("Basis", () => {
      */
 
     it("should return standard representation", () => {
-        const basis = new Material(Na4Cl4Cartesian).Basis;
-        expect(basis.standardRepresentation).to.be.deep.almost.equal(Na4Cl4.basis);
+        const basis = new Material(Na4Cl4Cartesian).getBasis();
+        assertDeepAlmostEqual(basis.standardRepresentation, Na4Cl4.basis, ["constraints"]);
     });
 
     /**

package/tests/js/fixtures.ts

@@ -1,4 +1,9 @@
-import { AtomicConstraintsSchema, BasisSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
+import {
+    AtomicConstraintsSchema,
+    BasisSchema,
+    MaterialHashedSchema,
+    MaterialSchema,
+} from "@mat3ra/esse/dist/js/types";
 import { MaterialStandata } from "@mat3ra/standata";
 import fs from "fs";
 import path from "path";
@@ -9,7 +14,6 @@ import C2H4_JSON from "../fixtures/C2H4.json";
 import C2H4Translated_JSON from "../fixtures/C2H4-translated.json";
 import FeLiSiBasis_JSON from "../fixtures/FeLiSi-basis.json";
 import FeO_JSON from "../fixtures/FeO.json";
-
 import Ge2Basis_JSON from "../fixtures/Ge2-basis.json";
 import Graphene_JSON from "../fixtures/Graphene.json";
 import H2HFinal_JSON from "../fixtures/H2+H-final.json";
@@ -28,24 +32,23 @@ import SiSlab111Gamma120_JSON from "../fixtures/si-slab-111-0.5-vacuum-gamma-120
 import SiSlab111_JSON from "../fixtures/si-slab-111-0.5-vacuum-ratio.json";
 import SiSlab111NoVacuum_JSON from "../fixtures/si-slab-111-0-vacuum.json";
 import Silicon_JSON from "../fixtures/si-standata.json";
-
 import SiSupercell_JSON from "../fixtures/Si-supercell.json";
 import Si2Basis_JSON from "../fixtures/Si2-basis.json";
 import Si2BasisRepeated_JSON from "../fixtures/Si2-basis-repeated.json";
 import Zr1H23Zr1H1_JSON from "../fixtures/Zr1H23Zr1H1.json";
 
 // Material
-const Silicon = Silicon_JSON as unknown as MaterialSchema;
-const SiSupercell = SiSupercell_JSON as unknown as MaterialSchema;
+const Silicon = Silicon_JSON as unknown as MaterialHashedSchema;
+const SiSupercell = SiSupercell_JSON as unknown as MaterialHashedSchema;
 const SiSlab = SiSlab_JSON as unknown as MaterialSchema;
 const SiSlab100 = SiSlab100_JSON as unknown as MaterialSchema;
 const SiSlab111 = SiSlab111_JSON as unknown as MaterialSchema;
 const SiSlab111Gamma120 = SiSlab111Gamma120_JSON as unknown as MaterialSchema;
 const SiSlab111NoVacuum = SiSlab111NoVacuum_JSON as unknown as MaterialSchema;
 const FeO = FeO_JSON as unknown as MaterialSchema;
-const FeOStandata = MaterialStandata.getRuntimeDataConfigs().find(
-    (m: any) => m.name?.includes("FeO"),
-) as MaterialSchema;
+const FeOStandata = MaterialStandata.getRuntimeDataConfigs().find((m: any) =>
+    m.name?.includes("FeO"),
+) as MaterialHashedSchema;
 const Na4Cl4 = Na4Cl4_JSON as unknown as MaterialSchema;
 const Na4Cl4Cartesian = Na4Cl4Cartesian_JSON as unknown as MaterialSchema;
 const C2H4 = C2H4_JSON as unknown as MaterialSchema;
@@ -55,7 +58,7 @@ const H2HInitial = H2HInitial_JSON as unknown as MaterialSchema;
 const H2HFinal = H2HFinal_JSON as unknown as MaterialSchema;
 const H2HImage = H2HImage_JSON as unknown as MaterialSchema;
 const Zr1H23Zr1H1 = Zr1H23Zr1H1_JSON as unknown as MaterialSchema;
-const Graphene = Graphene_JSON as unknown as MaterialSchema;
+const Graphene = Graphene_JSON as unknown as MaterialHashedSchema;
 const NiHex = NiHex_JSON as unknown as MaterialSchema;
 
 // Basis

package/tests/js/material/material.ts

@@ -0,0 +1,161 @@
+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.getBasis().units);
+        expect(clonedMaterial.getBasis().elements).to.have.lengthOf(2);
+    });
+
+    it("defaults missing metadata to empty object", () => {
+        const material = new Material({
+            name: Silicon.name,
+            basis: Silicon.basis,
+            lattice: Silicon.lattice,
+        });
+        expect(material.metadata).to.deep.equal({});
+        expect(material.toJSON().metadata).to.deep.equal({});
+    });
+
+    describe("toJSON variants", () => {
+        const material = new Material(Silicon);
+
+        it("toJSONPure omits hash and basis.constraints", () => {
+            const json = material.toJSONPure();
+            expect(json).to.not.have.property("hash");
+            expect(json).to.not.have.property("scaledHash");
+            expect(json.basis).to.not.have.property("constraints");
+            expect(json.name).to.equal(Silicon.name);
+        });
+
+        it("toJSONEnhanced includes basis.constraints and omits hash", () => {
+            const json = material.toJSONEnhanced();
+            expect(json).to.not.have.property("hash");
+            expect(json).to.not.have.property("scaledHash");
+            expect(json.basis).to.have.property("constraints").that.is.an("array");
+        });
+
+        it("toJSONHashed includes hash and omits basis.constraints", () => {
+            const json = material.toJSONHashed();
+            expect(json.hash).to.be.a("string");
+            expect(json.hash.length).to.be.greaterThan(0);
+            expect(json.basis).to.not.have.property("constraints");
+        });
+
+        it("toJSONEnhancedHashed includes hash and basis.constraints", () => {
+            const json = material.toJSONEnhancedHashed();
+            expect(json.hash).to.be.a("string");
+            expect(json.hash.length).to.be.greaterThan(0);
+            expect(json.basis.constraints).to.be.an("array");
+        });
+
+        it("toJSON equals toJSONEnhancedHashed", () => {
+            expect(material.toJSON()).to.deep.equal(material.toJSONEnhancedHashed());
+        });
+    });
+
+    it("getBasisAsXyz includes atomic constraints via toJSONEnhanced", () => {
+        const material = new Material({
+            name: "Li-with-constraints",
+            basis: {
+                elements: [
+                    { id: 0, value: "Li" },
+                    { id: 1, value: "Li" },
+                ],
+                coordinates: [
+                    { id: 0, value: [0, 0, 0] },
+                    { id: 1, value: [0.25, 0.25, 0.25] },
+                ],
+                units: "crystal",
+                constraints: [
+                    { id: 0, value: [true, true, false] },
+                    { id: 1, value: [true, true, true] },
+                ],
+            },
+            lattice: Silicon.lattice,
+        });
+
+        const xyz = material.getBasisAsXyz();
+        expect(xyz).to.match(/Li\s+0\.000000\s+0\.000000\s+0\.000000\s+1\s+1\s+0/);
+        expect(xyz).to.match(/Li\s+0\.250000\s+0\.250000\s+0\.250000\s+1\s+1\s+1/);
+        // Regression: toJSONPure strips constraints — must not be used for XYZ display.
+        expect(material.toJSONPure().basis).to.not.have.property("constraints");
+    });
+
+    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.hash);
+                expect(material.scaledHash).to.equal(fixture.scaledHash);
+            });
+        });
+
+        it("should match expected hash for FeO (standata)", () => {
+            // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+            const expectedHashes = require("../../fixtures/hashes.json");
+            const material = new Material(FeOStandata);
+            expect(material.calculateHash()).to.equal(expectedHashes.FeO.hash);
+            // scaledHash is stored on schema; standata config may omit it — match main's computed getter.
+            expect(material.calculateHash("", true)).to.equal(expectedHashes.FeO.scaledHash);
+        });
+
+        it("stores InChI hash for non-periodic materials when InChI is present", () => {
+            // MD5 of the InChI string — same contract as web-app MolView upload.
+            const inchi =
+                "1S/C8H18N4O2/c1-10-4-9-6-5(10)7(13)12(3)8(14)11(6)2/h5-9,13-14H,4H2,1-3H3";
+            const expectedInchiHash = "b3680772bb4f0cba602788d519531914";
+
+            const material = new Material({
+                name: "non-periodic-inchi",
+                isNonPeriodic: true,
+                basis: Silicon.basis,
+                lattice: Silicon.lattice,
+                derivedProperties: [{ name: "inchi", value: inchi }],
+            });
+
+            expect(material.isNonPeriodic).to.equal(true);
+            expect(material.getInchiStringForHash()).to.equal(inchi);
+            expect(material.calculateHash()).to.equal(expectedInchiHash);
+            expect(material.hash).to.equal(expectedInchiHash);
+
+            const geometricHashWithBypass = material.calculateHash("", false, true);
+            material.lattice = { ...material.lattice };
+            expect(material.hash).to.equal(expectedInchiHash);
+            expect(material.hash).to.not.equal(geometricHashWithBypass);
+        });
+
+        it("uses geometric hash when non-periodic but InChI is not derived yet", () => {
+            // Designer toggle sets isNonPeriodic then scales lattice before butler adds InChI.
+            const material = new Material({
+                name: "non-periodic-no-inchi",
+                isNonPeriodic: true,
+                basis: Silicon.basis,
+                lattice: Silicon.lattice,
+            });
+
+            const expectedGeometricHash = material.calculateHash("", false, true);
+            expect(material.hash).to.equal(expectedGeometricHash);
+            expect(() => material.calculateHash()).to.throw(/Missing InChI/);
+
+            material.lattice = { ...material.lattice };
+            expect(material.hash).to.equal(material.calculateHash("", false, true));
+        });
+    });
+});

package/tests/js/parsers/espresso.ts

@@ -1,15 +1,12 @@
-import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
 import { expect } from "chai";
 
-import { Material } from "../../../src/js/material";
+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,
-        );
+        expect(parsers.espresso.toEspressoFormat(material.toJSON())).to.be.equal(SiPWSCFInput);
     });
 });

package/tests/js/parsers/poscar.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 
 import { AtomicConstraints } from "../../../src/js/constraints/constraints";
-import { Material } from "../../../src/js/material";
+import Material from "../../../src/js/Material";
 import parsers from "../../../src/js/parsers/parsers";
 import { atomsCount } from "../../../src/js/parsers/poscar";
 import {
@@ -81,7 +81,7 @@ direct
 
         const material = new Material(Silicon);
         const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.Basis.units);
+        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.getBasis().units);
 
         const poscar = clonedMaterial.getAsPOSCAR(true);
         expect(poscar).to.be.equal(poscarConstraints);

package/tests/js/register-esse-schemas.cjs

@@ -0,0 +1,10 @@
+/**
+ * Registers ESSE schemas for made unit tests.
+ * Kept as CommonJS so mocha `--require` can load it without ESM JSON import issues.
+ * Library / web-app code must not import `@mat3ra/esse/dist/js/schemas.json` — the host
+ * (web-app) registers the (possibly extended) schema set once at startup.
+ */
+const JSONSchemasInterface = require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface").default;
+const allSchemas = require("@mat3ra/esse/dist/js/schemas.json");
+
+JSONSchemasInterface.setSchemas(allSchemas);

package/tests/js/tools/supercell.ts

@@ -4,7 +4,7 @@ import { expect } from "chai";
 
 import { Basis } from "../../../src/js/basis/basis";
 import { Made } from "../../../src/js/made";
-import { Material } from "../../../src/js/material";
+import Material from "../../../src/js/Material";
 import { Silicon, SiSupercell } from "../fixtures";
 
 const { assertDeepAlmostEqual } = Utils.assertion;
@@ -44,7 +44,7 @@ direct
    0.625000000    0.250000000    0.250000000  Ge`;
         const material = new Material(Silicon);
         const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.Basis.units);
+        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.getBasis().units);
         const supercellConfig = Made.tools.supercell.generateConfig(clonedMaterial, [
             [2, 0, 0],
             [0, 1, 0],

package/tests/js/tools/surface.ts

@@ -1,7 +1,7 @@
 import type { MaterialSchema } from "@mat3ra/esse/dist/js/types";
 import { Utils } from "@mat3ra/utils";
 
-import { Material } from "../../../src/js/material";
+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";
@@ -39,6 +39,7 @@ describe("Tools:Surface", () => {
         const adjustedSilicon: MaterialSchema = {
             ...Silicon,
             basis: {
+                ...Silicon.basis,
                 elements: [
                     {
                         id: 10,
@@ -72,9 +73,8 @@ describe("Tools:Surface", () => {
         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);
+        // Structural comparison: omit hash (now included in Material.toJSON).
+        assertDeepAlmostEqual(expectedSlabMaterial.toJSONEnhanced(), slabMaterial.toJSONEnhanced());
     });
 
     it("should return slab (111) with vacuum for gamma = 59.999", () => {
@@ -90,9 +90,7 @@ describe("Tools:Surface", () => {
         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);
+        assertDeepAlmostEqual(expectedSlabMaterial.toJSONEnhanced(), slabMaterial.toJSONEnhanced());
     });
 
     it("should return slab (111) with vacuum for gamma = 60.001", () => {
@@ -108,8 +106,6 @@ describe("Tools:Surface", () => {
         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);
+        assertDeepAlmostEqual(expectedSlabMaterial.toJSONEnhanced(), slabMaterial.toJSONEnhanced());
     });
 });