@mat3ra/made 2024.3.22-0

package/tests/js/enums.js

@@ -0,0 +1,40 @@
+import path from "path";
+
+import { readFile, readJSONFile } from "./utils";
+
+export const TOLERANCE = 1e-3;
+
+export const FIXTURES_DIR = path.resolve(__dirname, "../fixtures");
+export const Si = readJSONFile(path.join(FIXTURES_DIR, "Si.json"));
+export const FeO = readJSONFile(path.join(FIXTURES_DIR, "FeO.json"));
+export const Na4Cl4 = readJSONFile(path.join(FIXTURES_DIR, "Na4Cl4.json"));
+export const Na4Cl4Cartesian = readJSONFile(path.join(FIXTURES_DIR, "Na4Cl4-cartesian.json"));
+export const Na4Cl4Poscar = readFile(path.join(FIXTURES_DIR, "Na4Cl4.poscar"));
+export const SiSupercell = readJSONFile(path.join(FIXTURES_DIR, "Si-supercell.json"));
+export const C2H4 = readJSONFile(path.join(FIXTURES_DIR, "C2H4.json"));
+export const C2H4Translated = readJSONFile(path.join(FIXTURES_DIR, "C2H4-translated.json"));
+export const Na = readJSONFile(path.join(FIXTURES_DIR, "Na.json"));
+
+export const OSiBasis = readJSONFile(path.join(FIXTURES_DIR, "OSi-basis.json"));
+export const Si2Basis = readJSONFile(path.join(FIXTURES_DIR, "Si2-basis.json"));
+export const Ge2Basis = readJSONFile(path.join(FIXTURES_DIR, "Ge2-basis.json"));
+export const AsGeBasis = readJSONFile(path.join(FIXTURES_DIR, "AsGe-basis.json"));
+export const FeLiSiBasis = readJSONFile(path.join(FIXTURES_DIR, "FeLiSi-basis.json"));
+export const LiFeSiBasis = readJSONFile(path.join(FIXTURES_DIR, "LiFeSi-basis.json"));
+export const atomicConstraints = readJSONFile(path.join(FIXTURES_DIR, "atomic-constraints.json"));
+export const Si2BasisRepeated = readJSONFile(path.join(FIXTURES_DIR, "Si2-basis-repeated.json"));
+export const H2HInitial = readJSONFile(path.join(FIXTURES_DIR, "H2+H-initial.json"));
+export const H2HFinal = readJSONFile(path.join(FIXTURES_DIR, "H2+H-final.json"));
+export const H2HImage = readJSONFile(path.join(FIXTURES_DIR, "H2+H-image.json"));
+export const SiSlab = readJSONFile(path.join(FIXTURES_DIR, "Si-slab.json"));
+export const SiPWSCFInput = readFile(path.join(FIXTURES_DIR, "Si-pwscf.in"));
+
+export const Zr1H23Zr1H1 = readJSONFile(path.join(FIXTURES_DIR, "Zr1H23Zr1H1.json"));
+export const Zr1H23Zr1H1Poscar = readFile(path.join(FIXTURES_DIR, "Zr1H23Zr1H1.poscar"));
+export const H2O = readFile(path.join(FIXTURES_DIR, "H2O.poscar"));
+
+export const Graphene = readJSONFile(path.join(FIXTURES_DIR, "Graphene.json"));
+export const GraphenePoscar = readFile(path.join(FIXTURES_DIR, "Graphene.poscar"));
+export const NiHex = readJSONFile(path.join(FIXTURES_DIR, "Ni-hex.json"));
+export const NiHexPoscar = readFile(path.join(FIXTURES_DIR, "Ni-hex.poscar"));
+export const SiHex = readJSONFile(path.join(FIXTURES_DIR, "Si-hex.json"));

package/tests/js/lattice/lattice.js

@@ -0,0 +1,31 @@
+import { expect } from "chai";
+
+import { Lattice } from "../../../src/js/lattice/lattice";
+import { Na4Cl4, Si } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Lattice", () => {
+    it("should return lattice cell volume", () => {
+        const lattice = new Lattice(Si.lattice);
+        expect(lattice.volume).to.be.almost.equal(125);
+    });
+
+    it("should return lattice from vectors", () => {
+        const lattice = Lattice.fromVectors(Na4Cl4.lattice.vectors);
+        assertDeepAlmostEqual(lattice.toJSON(), Na4Cl4.lattice, ["type"]);
+    });
+
+    it("should return lattice type", () => {
+        const lattice = new Lattice(Si.lattice);
+        expect(lattice.typeExtended).to.be.equal("TRI_1b");
+    });
+
+    /**
+     * hash
+     */
+
+    it("should return lattice hash string", () => {
+        const lattice = new Lattice(Na4Cl4.lattice);
+        expect(lattice.getHashString()).to.be.equal("5.692;5.692;5.692;90;90;90;");
+    });
+});

package/tests/js/lattice/lattice_bravais.js

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+
+import { LatticeBravais } from "../../../src/js/lattice/lattice_bravais";
+import { Na4Cl4 } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Lattice Bravais", () => {
+    it("should return lattice bravais from vectors", () => {
+        const lattice = LatticeBravais.fromVectors(Na4Cl4.lattice.vectors);
+        assertDeepAlmostEqual(lattice.toJSON(), Na4Cl4.lattice, ["type", "vectors"]);
+    });
+
+    it("should return a list of editable keys", () => {
+        const lattice = new LatticeBravais(Na4Cl4.lattice);
+        expect(lattice.editables).to.be.deep.equal({ a: true });
+    });
+});

package/tests/js/lattice/lattice_reciprocal.js

@@ -0,0 +1,99 @@
+import { expect } from "chai";
+
+import { ReciprocalLattice } from "../../../src/js/lattice/reciprocal/lattice_reciprocal";
+import { Na4Cl4, Si, SiSlab } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Lattice Reciprocal", () => {
+    it("should extract kpoint path", () => {
+        const lattice = new ReciprocalLattice(Na4Cl4.lattice);
+        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);
+        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(Si.lattice);
+        const actualVectors = lattice.reciprocalVectors;
+        const expectedVectors = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1],
+        ];
+        assertDeepAlmostEqual(actualVectors, expectedVectors);
+    });
+
+    it("should extract symmetry points", () => {
+        const lattice = new ReciprocalLattice(Na4Cl4.lattice);
+        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);
+        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);
+        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);
+        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);
+        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/lattice/lattice_vectors.js

@@ -0,0 +1,10 @@
+import { LatticeVectors } from "../../../src/js/lattice/lattice_vectors";
+import { Na4Cl4 } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Lattice Vectors", () => {
+    it("should return lattice from bravais", () => {
+        const lattice = LatticeVectors.fromBravais(Na4Cl4.lattice);
+        assertDeepAlmostEqual(lattice.toJSON(), Na4Cl4.lattice.vectors, ["type", "vectors"]);
+    });
+});

package/tests/js/material.test.js

@@ -0,0 +1,11 @@
+import { expect } from "chai";
+
+import { Material } from "../../src/js/material";
+import { Na4Cl4 } from "./enums";
+
+describe("Material", () => {
+    it("should return unique elements", () => {
+        const material = new Material(Na4Cl4);
+        expect(material.uniqueElements).to.have.same.members(["Na", "Cl"]);
+    });
+});

package/tests/js/parsers/espresso.js

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

package/tests/js/parsers/native_formats.js

@@ -0,0 +1,30 @@
+import { expect } from "chai";
+
+import nativeFormatParsers from "../../../src/js/parsers/native_format_parsers";
+import { Graphene, GraphenePoscar, NiHex, NiHexPoscar } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+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);
+        expect(config).to.be.deep.almost.equal(Graphene);
+    });
+
+    it("should return a material config for Ni hex from a poscar", () => {
+        const poscar = NiHexPoscar;
+        const config = nativeFormatParsers.convertFromNativeFormat(poscar);
+        assertDeepAlmostEqual(config, NiHex, ["lattice"]);
+        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.js

@@ -0,0 +1,21 @@
+import { expect } from "chai";
+
+import { Material } from "../../../src/js/material";
+import { atomsCount } from "../../../src/js/parsers/poscar";
+import { H2O, Na4Cl4, Na4Cl4Poscar, Zr1H23Zr1H1, Zr1H23Zr1H1Poscar } from "../enums";
+
+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(H2O)).to.be.equal(3);
+    });
+});

package/tests/js/parsers/xyz.js

@@ -0,0 +1,25 @@
+import parsers from "../../../src/js/parsers/parsers";
+import { FeO, Si } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+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), Si.basis, [
+            "constraints",
+            "cell",
+            "units",
+        ]);
+    });
+});
+
+describe("Parsers:XYZ", () => {
+    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"]);
+    });
+});

package/tests/js/parsers/xyz_combinatorial_basis.js

@@ -0,0 +1,153 @@
+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 "../enums";
+
+describe("Parsers:CombinatorialBasis", () => {
+    it("toBasisConfig", () => {
+        // eslint-disable-next-line new-cap
+        const basisConfig2 = CombinatorialBasis.toBasisConfig([
+            {
+                element: "Si",
+                coordinates: [0, 0, 0],
+            },
+            {
+                element: "Li",
+                coordinates: [0.3, 0.3, 0.3],
+            },
+            {
+                element: "Fe",
+                coordinates: [0.5, 0.5, 0.5],
+            },
+        ]);
+        const [basis1, basis2] = [new Basis(FeLiSiBasis), new Basis(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 = new Basis(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) => new Basis(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) => new Basis(c));
+        expect(basisList1.length).to.equal(6);
+
+        const basisList2 = [
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "Si",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Si",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "Si",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Ge",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "Ge",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Si",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "Ge",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Ge",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "As",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Si",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+            CombinatorialBasis.toBasisConfig([
+                {
+                    element: "As",
+                    coordinates: [0, 0, 0],
+                },
+                {
+                    element: "Ge",
+                    coordinates: [0.5, 0.5, 0.5],
+                },
+            ]),
+        ].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("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.js

@@ -0,0 +1,6 @@
+import chai from "chai";
+import chaiAlmost from "chai-almost";
+
+import { TOLERANCE } from "./enums";
+
+chai.use(chaiAlmost(TOLERANCE));

package/tests/js/tools/basis.js

@@ -0,0 +1,18 @@
+import { Basis } from "../../../src/js/basis/basis";
+import tools from "../../../src/js/tools";
+import { H2HFinal, H2HImage, H2HInitial, Si2Basis, Si2BasisRepeated } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Tools:Basis", () => {
+    it("should return a repeated basis", () => {
+        const b = new Basis(Si2Basis);
+        assertDeepAlmostEqual(Si2BasisRepeated, tools.basis.repeat(b, [2, 1, 1]).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.js

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+
+import { Basis } from "../../../src/js/basis/basis";
+import { Made } from "../../../src/js/made";
+import { Material } from "../../../src/js/material";
+import { Si, SiSupercell } from "../enums";
+
+describe("Tools:Supercell", () => {
+    it("should generate supercell", () => {
+        const material = new Material(Si);
+        const supercell = Made.tools.supercell.generateConfig(material, [
+            [2, 0, 0],
+            [0, 2, 0],
+            [0, 0, 2],
+        ]);
+        expect(supercell.lattice).deep.equal(SiSupercell.lattice, "lattices are not equal");
+
+        const basis1 = new Basis(SiSupercell.basis);
+        const basis2 = new Basis(supercell.basis);
+
+        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
+    });
+});

package/tests/js/tools/surface.js

@@ -0,0 +1,12 @@
+import { Material } from "../../../src/js/material";
+import tools from "../../../src/js/tools";
+import { Si, SiSlab } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Tools:Surface", () => {
+    it("should return slab", () => {
+        const material = new Material(Si);
+        const slab = tools.surface.generateConfig(material, [1, 0, 0], 3, 1, 1);
+        assertDeepAlmostEqual(SiSlab, slab);
+    });
+});

package/tests/js/utils.js

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+import fs from "fs";
+import _ from "underscore";
+
+export function readFile(filePath, coding = "utf8") {
+    return fs.readFileSync(filePath, coding);
+}
+
+export function readJSONFile(filePath) {
+    return JSON.parse(readFile(filePath));
+}
+
+export function assertDeepAlmostEqual(leftHandOperand, rightHandOperand, excludedKeys = []) {
+    expect(_.omit(leftHandOperand, excludedKeys)).to.be.deep.almost.equal(
+        _.omit(rightHandOperand, excludedKeys),
+    );
+}

package/tests/py/unit/test_sample.py

@@ -0,0 +1,10 @@
+import unittest
+
+import numpy as np
+from mat3ra.made import get_length
+
+
+class TestSample(unittest.TestCase):
+    def test_type(self):
+        a = get_length(np.array([1, 2]))
+        self.assertTrue(type(a) == np.float_)

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "@mat3ra/tsconfig/tsconfig.json"
+}