@mat3ra/made 2024.3.22-0

package/dist/cell/cell.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cell = void 0;
+const math_1 = require("@exabyte-io/code.js/dist/math");
+const constants_1 = __importDefault(require("../constants"));
+const MATRIX = math_1.math.matrix;
+const MULT = math_1.math.multiply;
+const INV = math_1.math.inv;
+// @ts-ignore
+const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
+/*
+ * Cell represents a unit cell in geometrical form: 3x3 matrix where rows are cell vectors.
+ * Example: [[1, 0, 0], [0, 1, 0], [0, 0, 1]].
+ */
+class Cell {
+    /**
+     * Create a cell.
+     * @param nestedArray {Number[][]} is an array of cell vectors in cartesian Angstrom units.
+     */
+    constructor(nestedArray) {
+        this.tolerance = 1;
+        [this.vector1, this.vector2, this.vector3] = nestedArray;
+    }
+    /**
+     * Get cell vectors as (a nested) array.
+     * @example [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+     */
+    get vectorsAsArray() {
+        return [
+            this.vector1,
+            this.vector2,
+            this.vector3,
+            // assert that no near-zero artifacts are present (ie. 1.6 x 10^-16) before attempting inversion
+            // @param tolerance {Number} Maximum tolerance to small numbers, used to avoid artifacts on matrix inversion
+        ].map((v) => v.map((c) => (math_1.math.abs(c) < constants_1.default.tolerance.lengthAngstrom ? 0 : c)));
+    }
+    clone() {
+        return new this.constructor(this.vectorsAsArray);
+    }
+    cloneAndScaleByMatrix(matrix) {
+        const newCell = this.clone();
+        newCell.scaleByMatrix(matrix);
+        return newCell;
+    }
+    /**
+     * Convert a point (in crystal coordinates) to cartesian.
+     */
+    convertPointToCartesian(point) {
+        return MULT(point, this.vectorsAsArray);
+    }
+    /**
+     * Convert a point (in cartesian coordinates) to crystal (fractional).
+     */
+    convertPointToFractional(point) {
+        return MULT(point, INV(this.vectorsAsArray));
+    }
+    /**
+     * Check whether a point is inside the cell.
+     * @param point - the point to conduct the check for.
+     * @param tolerance - numerical tolerance.
+     */
+    isPointInsideCell(point, tolerance = constants_1.default.tolerance.length) {
+        return (this.convertPointToFractional(point)
+            .map((c) => math_1.math.isBetweenZeroInclusiveAndOne(c, tolerance))
+            // @ts-ignore
+            .reduce((a, b) => a && b));
+    }
+    /**
+     * Returns the index of the cell vector, most collinear with the testVector.
+     * @param testVector
+     */
+    getMostCollinearVectorIndex(testVector) {
+        // @ts-ignore
+        const angles = this.vectorsAsArray.map((v) => math_1.math.angleUpTo90(v, testVector));
+        return angles.findIndex((el) => el === math_1.math.min(angles));
+    }
+    /**
+     * Scale this cell by right-multiplying it to a matrix (nested array)
+     */
+    scaleByMatrix(matrix) {
+        // @ts-ignore
+        [this.vector1, this.vector2, this.vector3] = MATRIX_MULT(matrix, this.vectorsAsArray);
+    }
+}
+exports.Cell = Cell;

package/dist/cell/conventional_cell.d.ts

@@ -0,0 +1,22 @@
+import { LatticeTypeSchema } from "@mat3ra/esse/lib/js/types";
+export declare const PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS: {
+    CUB: number[][];
+    FCC: number[][];
+    BCC: number[][];
+    TET: number[][];
+    BCT: number[][];
+    ORC: number[][];
+    ORCF: number[][];
+    ORCI: number[][];
+    ORCC: number[][];
+    HEX: number[][];
+    RHL: number[][];
+    MCL: number[][];
+    MCLC: number[][];
+    TRI: number[][];
+    TRIalt: number[][];
+};
+export declare const PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES: {
+    [key in LatticeTypeSchema | "TRIalt"]: LatticeTypeSchema;
+};
+export declare function isConventionalCellSameAsPrimitiveForLatticeType(latticeType: LatticeTypeSchema): boolean;

package/dist/cell/conventional_cell.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConventionalCellSameAsPrimitiveForLatticeType = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS = void 0;
+/**
+ * Routines for calculating conventional cell vectors from primitive cell Bravais parameters.
+ * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
+ */
+const unitMatrix = [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+];
+// (Conventional cellVectors) = (Primitive cellVectors) * (PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIER matrix)
+exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS = {
+    // PRIMITIVE    =>  CONVENTIONAL
+    CUB: unitMatrix,
+    FCC: [
+        [-1, 1, 1],
+        [1, -1, 1],
+        [1, 1, -1],
+    ],
+    BCC: [
+        [0, 1, 1],
+        [1, 0, 1],
+        [1, 1, 0],
+    ],
+    TET: unitMatrix,
+    BCT: [
+        [0, 1, 1],
+        [1, 0, 1],
+        [1, 1, 0],
+    ],
+    ORC: unitMatrix,
+    ORCF: [
+        [-1, 1, 1],
+        [1, -1, 1],
+        [1, 1, -1],
+    ],
+    ORCI: [
+        [0, 1, 1],
+        [1, 0, 1],
+        [1, 1, 0],
+    ],
+    ORCC: [
+        [1, -1, 0],
+        [1, 1, 0],
+        [0, 0, 1],
+    ],
+    HEX: unitMatrix,
+    RHL: unitMatrix,
+    MCL: unitMatrix,
+    MCLC: [
+        [1, -1, 0],
+        [1, 1, 0],
+        [0, 0, 1],
+    ],
+    TRI: unitMatrix,
+    TRIalt: unitMatrix,
+};
+exports.PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES = {
+    // PRIMITIVE    =>  CONVENTIONAL
+    CUB: "CUB",
+    FCC: "CUB",
+    BCC: "CUB",
+    TET: "TET",
+    BCT: "TET",
+    ORC: "ORC",
+    ORCF: "ORC",
+    ORCI: "ORC",
+    ORCC: "ORC",
+    HEX: "HEX",
+    RHL: "RHL",
+    MCL: "MCL",
+    MCLC: "MCL",
+    TRI: "TRI",
+    // TODO: Legacy `TRI_alt` type, assert not used and remove
+    TRIalt: "TRI",
+};
+function isConventionalCellSameAsPrimitiveForLatticeType(latticeType) {
+    const multiplier = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS[latticeType || "TRI"];
+    return multiplier === unitMatrix;
+}
+exports.isConventionalCellSameAsPrimitiveForLatticeType = isConventionalCellSameAsPrimitiveForLatticeType;

package/dist/cell/primitive_cell.d.ts

@@ -0,0 +1,9 @@
+import { LatticeImplicitSchema } from "@mat3ra/esse/lib/js/types";
+import { VectorsAsArray } from "../lattice/types";
+/**
+ * Returns lattice vectors for a primitive cell for a lattice.
+ * @param lattice - Lattice instance.
+ * @param  skipRounding - whether to skip rounding the lattice vectors.
+ * @return Cell.vectorsAsArray
+ */
+export declare function primitiveCell(lattice: LatticeImplicitSchema, skipRounding?: boolean): VectorsAsArray;

package/dist/cell/primitive_cell.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitiveCell = void 0;
+const math_1 = __importDefault(require("../math"));
+/**
+ * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
+ * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
+ */
+const PRIMITIVE_CELLS = {
+    CUB: ({ a }) => {
+        return [
+            [a, 0, 0],
+            [0, a, 0],
+            [0, 0, a],
+        ];
+    },
+    FCC: ({ a }) => {
+        return [
+            [0.0, a / 2, a / 2],
+            [a / 2, 0.0, a / 2],
+            [a / 2, a / 2, 0.0],
+        ];
+    },
+    BCC: ({ a }) => {
+        return [
+            [-a / 2, a / 2, a / 2],
+            [a / 2, -a / 2, a / 2],
+            [a / 2, a / 2, -a / 2],
+        ];
+    },
+    TET: ({ a, c }) => {
+        return [
+            [a, 0, 0],
+            [0, a, 0],
+            [0, 0, c],
+        ];
+    },
+    BCT: ({ a, c }) => {
+        return [
+            [-a / 2, a / 2, c / 2],
+            [a / 2, -a / 2, c / 2],
+            [a / 2, a / 2, -c / 2],
+        ];
+    },
+    ORC: ({ a, b, c }) => {
+        return [
+            [a, 0, 0],
+            [0, b, 0],
+            [0, 0, c],
+        ];
+    },
+    ORCF: ({ a, b, c }) => {
+        return [
+            [0, b / 2, c / 2],
+            [a / 2, 0, c / 2],
+            [a / 2, b / 2, 0],
+        ];
+    },
+    ORCI: ({ a, b, c }) => {
+        return [
+            [-a / 2, b / 2, c / 2],
+            [a / 2, -b / 2, c / 2],
+            [a / 2, b / 2, -c / 2],
+        ];
+    },
+    ORCC: ({ a, b, c }) => {
+        return [
+            [a / 2, b / 2, 0],
+            [-a / 2, b / 2, 0],
+            [0, 0, c],
+        ];
+    },
+    HEX: ({ a, c }) => {
+        return [
+            [a / 2, (-a * math_1.default.sqrt(3)) / 2, 0],
+            [a / 2, (a * math_1.default.sqrt(3)) / 2, 0],
+            [0, 0, c],
+        ];
+    },
+    RHL: ({ a, alpha }) => {
+        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        const cosHalfAlpha = math_1.default.sqrt((1 / 2) * (1 + cosAlpha));
+        const sinHalfAlpha = math_1.default.sqrt((1 / 2) * (1 - cosAlpha));
+        return [
+            [a * cosHalfAlpha, -a * sinHalfAlpha, 0.0],
+            [a * cosHalfAlpha, a * sinHalfAlpha, 0.0],
+            [
+                (a * cosAlpha) / cosHalfAlpha,
+                0.0,
+                a * math_1.default.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+            ],
+        ];
+    },
+    MCL: ({ a, b, c, alpha }) => {
+        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        return [
+            [a, 0, 0],
+            [0, b, 0],
+            [0, c * cosAlpha, c * math_1.default.sqrt(1 - cosAlpha * cosAlpha)],
+        ];
+    },
+    MCLC: ({ a, b, c, alpha }) => {
+        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        return [
+            [a / 2, b / 2, 0],
+            [-a / 2, b / 2, 0],
+            [0, c * cosAlpha, c * math_1.default.sqrt(1 - cosAlpha * cosAlpha)],
+        ];
+    },
+    // Algorithm from http://pymatgen.org/_modules/pymatgen/core/lattice.html (from_params)
+    TRI: ({ a, b, c, alpha, beta, gamma }) => {
+        // convert angles to Radians
+        // eslint-disable-next-line no-param-reassign
+        [alpha, beta, gamma] = [alpha, beta, gamma].map(
+        // @ts-ignore
+        (x) => math_1.default.unit(x, "degree").to("rad").value);
+        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math_1.default.cos(x));
+        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math_1.default.sin(x));
+        const gammaStar = math_1.default.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
+        const cosGammaStar = math_1.default.cos(gammaStar);
+        const sinGammaStar = math_1.default.sin(gammaStar);
+        return [
+            [a * sinBeta, 0.0, a * cosBeta],
+            [-b * sinAlpha * cosGammaStar, b * sinAlpha * sinGammaStar, b * cosAlpha],
+            [0.0, 0.0, c],
+        ];
+    },
+    // alternative implementation
+    TRIalt: ({ a, b, c, alpha, beta, gamma }) => {
+        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        const cosBeta = math_1.default.cos((beta / 180) * math_1.default.PI);
+        const cosGamma = math_1.default.cos((gamma / 180) * math_1.default.PI);
+        const sinGamma = math_1.default.sqrt(1 - cosGamma * cosGamma);
+        return [
+            [a, 0.0, 0.0],
+            [b * cosGamma, b * sinGamma, 0.0],
+            [
+                c * cosBeta,
+                (c / sinGamma) * (cosAlpha - cosBeta * cosGamma),
+                (c / sinGamma) *
+                    math_1.default.sqrt(sinGamma * sinGamma -
+                        cosAlpha * cosAlpha -
+                        cosBeta * cosBeta +
+                        2 * cosAlpha * cosBeta * cosGamma),
+            ],
+        ];
+    },
+};
+/**
+ * Returns lattice vectors for a primitive cell for a lattice.
+ * @param lattice - Lattice instance.
+ * @param  skipRounding - whether to skip rounding the lattice vectors.
+ * @return Cell.vectorsAsArray
+ */
+function primitiveCell(lattice, skipRounding = false) {
+    const [vectorA, vectorB, vectorC] = PRIMITIVE_CELLS[lattice.type || "TRI"](lattice);
+    // set precision and remove JS floating point artifacts
+    if (!skipRounding) {
+        [vectorA, vectorB, vectorC].map((vec) => vec.map((c) => math_1.default.precise(c)).map(math_1.default.roundToZero));
+    }
+    return [vectorA, vectorB, vectorC];
+}
+exports.primitiveCell = primitiveCell;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export * from "@exabyte-io/code.js/dist/constants";
+export { default } from "@exabyte-io/code.js/dist/constants";

package/dist/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+// TODO: adjust the imports and remove the need for re-exporting
+__exportStar(require("@exabyte-io/code.js/dist/constants"), exports);
+// eslint-disable-next-line no-restricted-exports
+var constants_1 = require("@exabyte-io/code.js/dist/constants");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(constants_1).default; } });

package/dist/constraints/constraints.d.ts

@@ -0,0 +1,45 @@
+import { ArrayWithIds } from "../abstract/array_with_ids";
+import { ObjectWithIdAndValue } from "../abstract/scalar_with_id";
+export interface ConstraintValue extends Array<boolean> {
+    0: boolean;
+    1: boolean;
+    2: boolean;
+}
+export type Constraint = ObjectWithIdAndValue<ConstraintValue>;
+export declare class AtomicConstraints {
+    name: string;
+    values: ArrayWithIds<ConstraintValue>;
+    static fromArray(array: ConstraintValue[]): AtomicConstraints;
+    /**
+     * Create atomic constraints.
+     * @param {Object} config
+     * @param {ArrayWithIds|Array} config.values
+     */
+    constructor({ values }: {
+        values?: ConstraintValue[];
+    });
+    /**
+     * @example As below:
+        [
+            {
+                "id" : 0,
+                "value" : [
+                    1,
+                    1,
+                    1
+                ]
+            }
+        ]
+     */
+    toJSON(): {
+        name: string;
+        values: ObjectWithIdAndValue<ConstraintValue>[];
+    };
+    getByIndex(idx: number): ConstraintValue;
+    /**
+     * Get constraints for an atom with index as string.
+     * @param idx - atom index.
+     * @param mapFn (OPTIONAL) - a function to be applied to each constraint. By default 0 or 1 is returned.
+     */
+    getAsStringByIndex(idx: number, mapFn?: (val: boolean) => string): string;
+}

package/dist/constraints/constraints.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicConstraints = void 0;
+const array_with_ids_1 = require("../abstract/array_with_ids");
+class AtomicConstraints {
+    static fromArray(array) {
+        return new AtomicConstraints({ values: array });
+    }
+    /**
+     * Create atomic constraints.
+     * @param {Object} config
+     * @param {ArrayWithIds|Array} config.values
+     */
+    constructor({ values }) {
+        this.name = "atomic_constraints";
+        this.values = new array_with_ids_1.ArrayWithIds(values || []);
+    }
+    /**
+     * @example As below:
+        [
+            {
+                "id" : 0,
+                "value" : [
+                    1,
+                    1,
+                    1
+                ]
+            }
+        ]
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            values: this.values.toJSON(),
+        };
+    }
+    getByIndex(idx) {
+        return this.values.getArrayElementByIndex(idx) || [];
+    }
+    /**
+     * Get constraints for an atom with index as string.
+     * @param idx - atom index.
+     * @param mapFn (OPTIONAL) - a function to be applied to each constraint. By default 0 or 1 is returned.
+     */
+    getAsStringByIndex(idx, mapFn = (val) => (val ? "1" : "0")) {
+        return this.getByIndex(idx).map(mapFn).join(" ");
+    }
+}
+exports.AtomicConstraints = AtomicConstraints;

package/dist/lattice/lattice.d.ts

@@ -0,0 +1,104 @@
+import { LatticeImplicitSchema, LatticeSchema, LatticeTypeExtendedSchema } from "@mat3ra/esse/lib/js/types";
+import { Cell } from "../cell/cell";
+import { FromVectorsProps, LatticeBravais } from "./lattice_bravais";
+import { BravaisConfigProps, LatticeVectors } from "./lattice_vectors";
+import { UnitCell } from "./unit_cell";
+/**
+ * Scaling factor used to calculate the new lattice size for non-periodic systems.
+ * The scaling factor ensures that a non-periodic structure will have have a lattice greater than the structures size.
+ */
+export declare const nonPeriodicLatticeScalingFactor = 2;
+export declare class Lattice extends LatticeBravais implements LatticeSchema {
+    vectors: LatticeVectors;
+    /**
+     * Create a Lattice class from a config object.
+     * @param {Object} config - Config object. See LatticeVectors.fromBravais.
+     */
+    constructor(config?: Partial<LatticeImplicitSchema>);
+    /**
+     * Create a Lattice class from a list of vectors.
+     * @param {Object} config - Config object. See LatticeBravais.fromVectors.
+     */
+    static fromVectors(config: FromVectorsProps): Lattice;
+    /**
+     * Serialize class instance to JSON.
+     * @example As below:
+         {
+            "a" : 3.867,
+            "b" : 3.867,
+            "c" : 3.867,
+            "alpha" : 60,
+            "beta" : 60,
+            "gamma" : 60,
+            "units" : {
+                "length" : "angstrom",
+                "angle" : "degree"
+            },
+            "type" : "FCC",
+            "vectors" : {
+                "a" : [
+                    3.34892,
+                    0,
+                    1.9335
+                ],
+                "b" : [
+                    1.116307,
+                    3.157392,
+                    1.9335
+                ],
+                "c" : [
+                    0,
+                    0,
+                    3.867
+                ],
+                "alat" : 1,
+                "units" : "angstrom"
+            }
+        }
+     */
+    toJSON(skipRounding?: boolean): LatticeSchema;
+    clone(extraContext: BravaisConfigProps): Lattice;
+    /**
+     * Get lattice vectors as a nested array
+     */
+    get vectorArrays(): [import("@mat3ra/esse/lib/js/types").ArrayOf3NumberElementsSchema, import("@mat3ra/esse/lib/js/types").ArrayOf3NumberElementsSchema, import("@mat3ra/esse/lib/js/types").ArrayOf3NumberElementsSchema];
+    get Cell(): Cell;
+    /**
+     * Get a short label for the type of the lattice, eg. "MCLC".
+     */
+    get typeLabel(): string;
+    /**
+     * Get a short label for the extended type of the lattice, eg. "MCLC-5".
+     */
+    get typeExtended(): LatticeTypeExtendedSchema;
+    /**
+     * Calculate the volume of the lattice cell.
+     */
+    get volume(): number;
+    static getDefaultPrimitiveLatticeConfigByType(latticeConfig: LatticeImplicitSchema): {
+        a: number;
+        b: number;
+        c: number;
+        alpha: number;
+        beta: number;
+        gamma: number;
+        units: {
+            length?: "bohr" | "angstrom" | undefined;
+            angle?: "degree" | "radian" | undefined;
+        };
+        type: "CUB" | "BCC" | "FCC" | "TET" | "MCL" | "ORC" | "ORCC" | "ORCF" | "ORCI" | "HEX" | "BCT" | "TRI" | "MCLC" | "RHL";
+    } & {
+        a: number;
+        b: number;
+        c: number;
+        alpha: number;
+        beta: number;
+        gamma: number;
+    };
+    get unitCell(): UnitCell;
+    /**
+     * Returns a string further used for the calculation of an unique hash.
+     * @param isScaled - Whether to scale the vectors by the length of the first vector initially.
+     */
+    getHashString(isScaled?: boolean): string;
+}