@mat3ra/made 2024.3.22-0

package/src/js/tools/surface.js

@@ -0,0 +1,176 @@
+import { LatticeBravais } from "../lattice/lattice_bravais";
+import math from "../math";
+import SupercellTools from "./supercell";
+
+const MULT = math.multiply;
+const ADD = math.add;
+const DOT = math.product;
+const getMatrixInLeftHandedRepresentation = (matrix) => {
+    return math.det(matrix) < 0 ? MULT(matrix, -1) : matrix;
+};
+
+/**
+ * Helper function for extended GCD.
+ * Inspired by https://gitlab.com/ase/ase/blob/master/ase/build/general_surface.py
+ * @param {Number} a
+ * @param {Number} b
+ * @return {Array}
+ */
+function extGCD(a, b) {
+    if (b === 0) return [1, 0];
+    if (math.mod(a, b) === 0) return [0, 1];
+
+    const [x, y] = extGCD(b, math.mod(a, b));
+    return [y, x - y * math.floor(a, b)];
+}
+
+/**
+ * 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, millerIndices, tol = 1e-8) {
+    if (!millerIndices.reduce((a, b) => math.abs(a) + math.abs(b)))
+        throw new Error("Miller indices are zeros.");
+
+    let scalingMatrix;
+
+    const [h, k, l] = millerIndices;
+    const [h0, k0, l0] = millerIndices.map((i) => i === 0);
+
+    if ((h0 && k0) || (h0 && l0) || (k0 && l0)) {
+        // if any two indices are zero
+
+        if (!h0) {
+            scalingMatrix = [
+                [0, 1, 0],
+                [0, 0, 1],
+                [1, 0, 0],
+            ];
+        }
+        if (!k0) {
+            scalingMatrix = [
+                [0, 0, 1],
+                [1, 0, 0],
+                [0, 1, 0],
+            ];
+        }
+        if (!l0) {
+            scalingMatrix = [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ];
+        }
+    } else {
+        const [a1, a2, a3] = cell.vectorsAsArray;
+        // z1 = (k * a1 - h * a2)
+        // z2 = (l * a1 - h * a3)
+        // z3 = l * a2 - k * a3)
+        const z1 = ADD(MULT(k, a1), MULT(-1, h, a2));
+        const z2 = ADD(MULT(l, a1), MULT(-1, h, a3));
+        const z3 = ADD(MULT(l, a2), MULT(-1, k, a3));
+
+        let [p, q] = extGCD(k, l);
+
+        const k1 = DOT(ADD(MULT(p, z1), MULT(q, z2)), z3);
+        const k2 = DOT(ADD(MULT(l, z1), MULT(-1, k, z2)), z3);
+
+        if (math.abs(k2) > tol) {
+            const i = -parseInt(math.round(k1 / k2), 10);
+            [p, q] = [p + i * l, q - i * k];
+        }
+
+        const [a, b] = extGCD(p * k + q * l, h);
+        const c1 = [p * k + q * l, -p * h, -q * h];
+        const c2 = [0, l, -k].map((c) => math.trunc(c / math.gcd(l, k))); // floor division
+        const c3 = [b, a * p, a * q];
+
+        scalingMatrix = [c1, c2, c3];
+    }
+
+    return getMatrixInLeftHandedRepresentation(scalingMatrix);
+}
+
+/**
+ * Scale the surface cell in out-of-plane direction according to thickness
+ *  and construct the lateral supercell from vx/vy parameters.
+ * @param bulkCell {Cell}
+ * @param surfaceCell {Cell}
+ * @param outOfPlaneAxisIndex {Number} Index of the cell vector most collinear with the out-of-surface-plane vector
+ * @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(bulkCell, surfaceCell, outOfPlaneAxisIndex, thickness, vx, vy) {
+    const transformationMatrix = math.eye(3).toArray();
+    const vxIndex = outOfPlaneAxisIndex === 2 ? 0 : outOfPlaneAxisIndex + 1;
+    const vyIndex = vxIndex === 2 ? 0 : vxIndex + 1;
+
+    transformationMatrix[outOfPlaneAxisIndex] = MULT(
+        thickness,
+        transformationMatrix[outOfPlaneAxisIndex],
+    );
+    transformationMatrix[vxIndex] = MULT(vx, transformationMatrix[vxIndex]);
+    transformationMatrix[vyIndex] = MULT(vy, transformationMatrix[vyIndex]);
+
+    return transformationMatrix;
+}
+
+/*
+ * Generate a config object for a surface based on a set of parameters.
+ * @param material {Material} The parent material (bulk) this surface is constructed from
+ * @param millerIndices {Number[]} Miller Indices that define the surface cleavage.
+ * @param numberOfLayers {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 {Object}
+ */
+function generateConfig(material, millerIndices, numberOfLayers = 1, vx = 1, vy = 1) {
+    if (numberOfLayers < 1)
+        throw new Error("Made.tools.surface.generateConfig: number of layers < 1.");
+
+    const cell = material.Lattice.Cell;
+    const millerScalingMatrix = getMillerScalingMatrix(cell, millerIndices);
+    const millerSupercell = cell.cloneAndScaleByMatrix(millerScalingMatrix);
+    const millerPlanePseudoNormal = cell.convertPointToCartesian(millerIndices);
+    const outOfPlaneAxisIndex =
+        millerSupercell.getMostCollinearVectorIndex(millerPlanePseudoNormal);
+    const dimensionsScalingMatrix = getDimensionsScalingMatrix(
+        cell,
+        millerSupercell,
+        outOfPlaneAxisIndex,
+        numberOfLayers,
+        vx,
+        vy,
+    );
+    const supercellMatrix = MULT(dimensionsScalingMatrix, millerScalingMatrix);
+    const supercell = millerSupercell.cloneAndScaleByMatrix(dimensionsScalingMatrix);
+    const newBasis = SupercellTools.generateNewBasisWithinSupercell(
+        material.Basis,
+        cell,
+        supercell,
+        supercellMatrix,
+    );
+    const newLattice = LatticeBravais.fromVectors({
+        a: supercell.vector1,
+        b: supercell.vector2,
+        c: supercell.vector3,
+    });
+
+    return {
+        name: `${material.name} - slab ${JSON.stringify(millerIndices)}`,
+        basis: newBasis.toJSON(),
+        lattice: newLattice.toJSON(),
+        // extra parameter for use in creating vacuum etc.
+        outOfPlaneAxisIndex,
+    };
+}
+
+export default {
+    generateConfig,
+};

package/src/js/types.ts

@@ -0,0 +1,4 @@
+import { AnyObject } from "@exabyte-io/code.js/dist/entity/in_memory";
+import { MaterialSchema } from "@mat3ra/esse/lib/js/types";
+
+export type MaterialJSON = MaterialSchema & AnyObject;

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

@@ -0,0 +1,5 @@
+import numpy as np
+
+
+def get_length(vec: np.ndarray) -> np.float_:
+    return np.linalg.norm(vec)

package/tests/.gitattributes

@@ -0,0 +1 @@
+fixtures/** filter=lfs diff=lfs merge=lfs -text

package/tests/fixtures/AsGe-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f79f4af766a9b118e63dd6619b46f903995f11548a4f68940a0c7d2108ec07ae
+size 342

package/tests/fixtures/C2H4-translated.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b4423a8f4e9d34e2592880517597bcf5ade475de17d8824070438fb24dabe18
+size 1827

package/tests/fixtures/C2H4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f0026c208aefc5fa46b5d3261969a617b95d9f7db27c3acda15f6e7d2c920d0
+size 1807

package/tests/fixtures/FeLiSi-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6279702702efc3aeb23de89d79702a5c56c78596b45f8dcb11b0d7e2676ace50
+size 489

package/tests/fixtures/FeO.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceaee5513c8093601a075bbb93bd8914e3dff76e24c2da0d67b35b785a27b8a2
+size 1254

package/tests/fixtures/Ge2-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b3c577612bdd8d42bea556297dfb411932158da4973a800b2bd3e31cfdec514
+size 342

package/tests/fixtures/Graphene.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eb6b302bffb3eb5ba9ca93a5fd11eb4e8b1200a192208ff4cc4efbd69803eca
+size 2106

package/tests/fixtures/Graphene.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ba18e37e9fd699364f378cd12e366e75cef9c52b345f1be11be88de16293f05
+size 284

package/tests/fixtures/H2+H-final.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:614755b60189a75999b7800b1ed47148836bee848cfb61d7f79ed28005716981
+size 1272

package/tests/fixtures/H2+H-image.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8739c66fc720bdeec7eeef2a67aa37d2fa54a47281fafcc011593cdebf5e6aee
+size 1274

package/tests/fixtures/H2+H-initial.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb4b3898d48cf7d1f0e8b73f8435f5fbf25eeb297c188a37dbf0446cb85cec3f
+size 1272

package/tests/fixtures/H2O.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41b30bc04f751d7df5d30cb9fdccb407b87bb067dcbb053f14527389198928ef
+size 301

package/tests/fixtures/LiFeSi-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9cf96b94f82d28492f7a0abaa8a5116eb37a33888f2d9da3b93e43c97fb74bc
+size 489

package/tests/fixtures/Na.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71c75d20acc30b2ffcbc6d38f23fdd5ed7fc3b8431274635cf6fa885bf864cd7
+size 514

package/tests/fixtures/Na4Cl4-cartesian.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:503af314a34a074b775ab512994a61a09d0b134ef3048dea3076285f1ef5f44f
+size 2295

package/tests/fixtures/Na4Cl4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5ecfe71533206ef52419bd1c9843ec668594fd9ea110dda8ac781f25af296d0
+size 2148

package/tests/fixtures/Na4Cl4.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5fa6e20480de4e6c01db8ff472d37a30e71964787f84fbb0aafee866d7bdf13
+size 553

package/tests/fixtures/Ni-hex.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:972098aa21b7f2a8d50bd968245fb69588d3c4f3152a90517c64bf13b2af4683
+size 2242

package/tests/fixtures/Ni-hex.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d6c299bd6ecda7026c4c29b99239ca305f7dfc7c46bfd5cb14f7beb65476bea
+size 354

package/tests/fixtures/OSi-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab3226dc3a8bfb9d985ef75ae9bd227be2a56ffb408f03d16cf54d335ad12395
+size 341

package/tests/fixtures/Si-hex.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6269540e98507c052a6a6e56328429c7d4cdd858ac4b6c59b838e0782a588fa
+size 2431

package/tests/fixtures/Si-hex.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e393e3cac1370d0e27feb59a03b10a6abc0c73323a350b79edd95ad2d146a185
+size 354

package/tests/fixtures/Si-pwscf.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd4c4fd85d270eee39c2ce8ef09f08204cfa3b8a3eaea121400096a9072d9401
+size 273

package/tests/fixtures/Si-slab.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6942398bc73bfdecf050070243cbe191a50887ea18b138d458e95c43121df22
+size 1745

package/tests/fixtures/Si-supercell.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b778eeec68581caa4cbf984be834ba49d3283b2da23be8477e8ff1fd105c31a
+size 3244

package/tests/fixtures/Si.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa80c58c1efbec6fe822f8747f6c4ef1927b04d70dd1e160fdb75d0f631cbf64
+size 696

package/tests/fixtures/Si2-basis-repeated.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24211f6b09a3190b7ad69669591cb1e3793eac573892d21bcfa562d128d3c919
+size 792

package/tests/fixtures/Si2-basis.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6361a98bbeb999a365730f1da21f9b72236b29d19084f59f86e4464f542d4ba8
+size 342

package/tests/fixtures/Zr1H23Zr1H1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:226ea6c374a2bfd103793a4134d353c41147032a289157e4f888cb996f5bc5aa
+size 11190

package/tests/fixtures/Zr1H23Zr1H1.poscar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c0a922079ffd436b809fc6f9b98807e853c001d1c395c56f9db0b7c7d1364cd
+size 1911

package/tests/fixtures/atomic-constraints.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf9542c5a395fbabb89171cec67711915e8e49c08afdf369f9b7f54a189dc338
+size 226

package/tests/js/basis/basis.js

@@ -0,0 +1,221 @@
+import { expect } from "chai";
+
+import { Basis } from "../../../src/js/basis/basis";
+import {
+    AsGeBasis,
+    C2H4,
+    C2H4Translated,
+    FeLiSiBasis,
+    LiFeSiBasis,
+    Na,
+    Na4Cl4,
+    Na4Cl4Cartesian,
+} from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Basis", () => {
+    it("should return true if basises are equal", () => {
+        const basis1 = new Basis(FeLiSiBasis);
+        const basis2 = new Basis(LiFeSiBasis);
+        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
+    });
+
+    it("should return true when basis is compared to its clone", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.isEqualTo(basis.clone())).to.be.equal(true);
+    });
+
+    it("should return jsonified basis", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.toJSON()).to.be.deep.almost.equal(Na4Cl4.basis);
+    });
+
+    it("should return true if cells are equal", () => {
+        const basis1 = new Basis(FeLiSiBasis);
+        const basis2 = new Basis(LiFeSiBasis);
+        expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
+    });
+
+    /**
+     * Elements
+     */
+
+    it("should return Na4Cl4 as unitCellFormula", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.unitCellFormula).to.be.equal("Na4Cl4");
+    });
+
+    it("should return NaCl as formula", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.formula).to.be.equal("NaCl");
+    });
+
+    it("should return elements", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.elements).to.be.deep.almost.equal(Na4Cl4.basis.elements);
+    });
+
+    it("should return unique elements", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.uniqueElements).to.be.deep.equal(["Na", "Cl"]);
+    });
+
+    it("should return elements count", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.elementCounts).to.be.deep.equal([
+            {
+                value: "Na",
+                count: 4,
+            },
+            {
+                value: "Cl",
+                count: 4,
+            },
+        ]);
+    });
+
+    it("should set elements", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        basis.elements = AsGeBasis.elements;
+        expect(basis.elements).to.be.deep.equal(AsGeBasis.elements);
+    });
+
+    /**
+     * Coordinates
+     */
+
+    it("should return coordinates", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.coordinates).to.be.deep.almost.equal(Na4Cl4.basis.coordinates);
+    });
+
+    it("should set coordinates", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        basis.coordinates = AsGeBasis.coordinates;
+        expect(basis.coordinates).to.be.deep.almost.equal(AsGeBasis.coordinates);
+    });
+
+    /**
+     * Units
+     */
+
+    it("should return true if basis is in crystal units", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.isInCrystalUnits).to.be.equal(true);
+    });
+
+    it("should convert crystal to cartesian", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        basis.toCartesian();
+        expect(basis.isInCartesianUnits).to.be.equal(true);
+        expect(basis.coordinates).to.be.deep.almost.equal(Na4Cl4Cartesian.basis.coordinates);
+    });
+
+    /**
+     * Atoms
+     */
+
+    it("should add a new atom", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        basis.addAtom({
+            element: "Ge",
+            coordinate: [0, 0.25, 0.25],
+        });
+        expect(basis.elements).to.be.deep.equal([
+            ...Na4Cl4.basis.elements,
+            {
+                id: 8,
+                value: "Ge",
+            },
+        ]);
+        expect(basis.coordinates).to.be.deep.almost.equal([
+            ...Na4Cl4.basis.coordinates,
+            {
+                id: 8,
+                value: [0, 0.25, 0.25],
+            },
+        ]);
+    });
+
+    it("should remove an atom", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        basis.removeAtom({
+            id: 3,
+            element: "Na",
+            coordinate: [0.5, 0.5, 0],
+        });
+        expect(basis.elements.length).to.be.equal(7);
+        expect(basis.coordinates.length).to.be.equal(7);
+    });
+
+    it("should return number of atoms", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        expect(basis.nAtoms).to.be.equal(8);
+    });
+
+    /**
+     * Hash
+     */
+
+    it("should return the string", () => {
+        const basis = new Basis(Na4Cl4.basis);
+        const string =
+            "Cl 0,0,0.5;Cl 0,0.5,0;Cl 0.5,0,0;Cl 0.5,0.5,0.5;Na 0,0,0;Na 0,0.5,0.5;Na 0.5,0,0.5;Na 0.5,0.5,0;";
+        expect(basis.getAsSortedString()).to.be.equal(string);
+    });
+
+    /**
+     * Representation
+     */
+
+    it("should return standard representation", () => {
+        const basis = new Basis(Na4Cl4Cartesian.basis);
+        expect(basis.standardRepresentation).to.be.deep.almost.equal(Na4Cl4.basis);
+    });
+
+    /**
+     * Minimum lattice size generated for a molecule with more than one atom.
+     * The minimumLatticeSize is the maximum pairwise distance between two atoms
+     * of the structure, C2H4 in this case.
+     */
+    it("should return minimum lattice size for a molecule", () => {
+        const basis = new Basis(C2H4.basis);
+        const minimumLatticeSize = 3.162;
+        const latticeSize = basis.getMinimumLatticeSize();
+        expect(latticeSize).to.be.equal(minimumLatticeSize);
+    });
+
+    /**
+     * Minimum lattice size generated for a structure made up of a single atom.
+     * The minimumLatticeSize is the atomic radii of the atom, Na in this case, in units of angstroms.
+     */
+    it("should return minimum lattice size for an atom", () => {
+        const basis = new Basis(Na.basis);
+        const minimumLatticeSize = 1.8;
+        const latticeSize = basis.getMinimumLatticeSize();
+        expect(latticeSize).to.be.equal(minimumLatticeSize);
+    });
+
+    //* * Pairwise Distance */
+    it("should return max distance", () => {
+        const basis = new Basis(C2H4.basis);
+        const maxDistance = 1.581;
+        expect(basis.maxPairwiseDistance).to.be.equal(maxDistance);
+    });
+
+    //* * Center of Coordinates */
+    it("should return center of coordinates", () => {
+        const basis = new Basis(C2H4.basis);
+        const centerOfCoordinatesArray = [0.3333, -0.0417, 0.0917];
+        const basisCenterOfCoordinatesPoint = basis.centerOfCoordinatesPoint;
+        assertDeepAlmostEqual(basisCenterOfCoordinatesPoint, centerOfCoordinatesArray);
+    });
+
+    //* * Translation by Vector */
+    it("should return the updated basis coordinates", () => {
+        const basis = new Basis(C2H4.basis);
+        const translationVector = [1.6917, 1.9667, 2];
+        basis.translateByVector(translationVector);
+        assertDeepAlmostEqual(basis.coordinates, C2H4Translated.basis.coordinates);
+    });
+});

package/tests/js/cell/cell.js

@@ -0,0 +1,21 @@
+import { Lattice } from "../../../src/js/lattice/lattice";
+import { Si } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Cell", () => {
+    it("should return scaled cell", () => {
+        const lattice = new Lattice(Si.lattice);
+        const expectedCell = {
+            tolerance: 1,
+            vector1: [10, 0, 0],
+            vector2: [0, 10, 0],
+            vector3: [0, 0, 10],
+        };
+        const actualCell = lattice.Cell.cloneAndScaleByMatrix([
+            [2, 0, 0],
+            [0, 2, 0],
+            [0, 0, 2],
+        ]);
+        assertDeepAlmostEqual(expectedCell, actualCell);
+    });
+});

package/tests/js/cell/primitive_cell.js

@@ -0,0 +1,17 @@
+import { primitiveCell } from "../../../src/js/cell/primitive_cell";
+import { Lattice } from "../../../src/js/lattice/lattice";
+import { Na4Cl4 } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("Primitive Cell", () => {
+    it("should return primitive lattice", () => {
+        const lattice = new Lattice(Na4Cl4.lattice);
+        const actualPrimitiveCell = primitiveCell(lattice);
+        const expectedPrimitiveCell = [
+            [5.691694, 0, 0],
+            [0, 5.691694, 0],
+            [0, 0, 5.691694],
+        ];
+        assertDeepAlmostEqual(expectedPrimitiveCell, actualPrimitiveCell);
+    });
+});

package/tests/js/constraints/constraints.js

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { AtomicConstraints } from "../../../src/js/constraints/constraints";
+import parsers from "../../../src/js/parsers/parsers";
+import { atomicConstraints } from "../enums";
+import { assertDeepAlmostEqual } from "../utils";
+
+describe("AtomicConstraints", () => {
+    it("should return constraints as string", () => {
+        const constraints = new AtomicConstraints(atomicConstraints);
+        expect(constraints.getAsStringByIndex(0)).to.be.equal("1 1 0");
+    });
+
+    it("should return constraints as string with given map function", () => {
+        const constraints = new AtomicConstraints(atomicConstraints);
+        expect(
+            constraints.getAsStringByIndex(0, parsers.poscar.atomicConstraintsCharFromBool),
+        ).to.be.equal("T T F");
+    });
+
+    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]);
+    });
+});