@mat3ra/made 2024.3.22-0

package/dist/lattice/lattice.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lattice = exports.nonPeriodicLatticeScalingFactor = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const underscore_1 = __importDefault(require("underscore"));
+const cell_1 = require("../cell/cell");
+const primitive_cell_1 = require("../cell/primitive_cell");
+const constants_1 = require("../constants");
+const math_1 = __importDefault(require("../math"));
+const lattice_bravais_1 = require("./lattice_bravais");
+const lattice_vectors_1 = require("./lattice_vectors");
+const types_1 = require("./types");
+const unit_cell_1 = require("./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.
+ */
+exports.nonPeriodicLatticeScalingFactor = 2.0;
+/*
+ * Container class for crystal lattice and associated methods.
+ * Follows Bravais convention for lattice types and contains lattice vectors within.
+ * Units for lattice vector coordinates are "angstroms", and "degrees" for the corresponding angles.
+ */
+class Lattice extends lattice_bravais_1.LatticeBravais {
+    /**
+     * Create a Lattice class from a config object.
+     * @param {Object} config - Config object. See LatticeVectors.fromBravais.
+     */
+    constructor(config = {}) {
+        super(config);
+        this.vectors = lattice_vectors_1.LatticeVectors.fromBravais(config);
+    }
+    /**
+     * Create a Lattice class from a list of vectors.
+     * @param {Object} config - Config object. See LatticeBravais.fromVectors.
+     */
+    static fromVectors(config) {
+        return new Lattice(lattice_bravais_1.LatticeBravais.fromVectors(config).toJSON());
+    }
+    /**
+     * 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 = false) {
+        const round = skipRounding ? (x) => x : Lattice._roundValue; // round values by default
+        return {
+            a: round(this.a),
+            b: round(this.b),
+            c: round(this.c),
+            alpha: round(this.alpha),
+            beta: round(this.beta),
+            gamma: round(this.gamma),
+            units: {
+                length: this.units.length,
+                angle: this.units.angle,
+            },
+            type: this.type,
+            vectors: this.vectors.toJSON(),
+        };
+    }
+    clone(extraContext) {
+        return new this.constructor({ ...this.toJSON(), ...extraContext });
+    }
+    /**
+     * Get lattice vectors as a nested array
+     */
+    get vectorArrays() {
+        return this.vectors.vectorArrays;
+    }
+    get Cell() {
+        return new cell_1.Cell(this.vectorArrays);
+    }
+    /**
+     * Get a short label for the type of the lattice, eg. "MCLC".
+     */
+    get typeLabel() {
+        return lodash_1.default.get(types_1.LATTICE_TYPE_CONFIGS.find((c) => c.code === this.type), "label", "Unknown");
+    }
+    /**
+     * Get a short label for the extended type of the lattice, eg. "MCLC-5".
+     */
+    get typeExtended() {
+        const { a, b, c, alpha, beta, gamma, type } = this;
+        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        switch (type) {
+            case "BCT":
+                return c < a ? "BCT-1" : "BCT-2";
+            case "ORCF":
+                if (1 / (a * a) >= 1 / (b * b) + 1 / (c * c)) {
+                    return "ORCF-1";
+                }
+                return "ORCF-2";
+            case "RHL":
+                return cosAlpha > 0 ? "RHL-1" : "RHL-2";
+            case "MCLC":
+                if (gamma >= 90) {
+                    // MCLC-1,2
+                    return "MCLC-1";
+                }
+                if ((b / c) * cosAlpha + ((b * b) / (a * a)) * (1 - cosAlpha * cosAlpha) <= 1) {
+                    // MCLC-3,4
+                    return "MCLC-3";
+                }
+                return "MCLC-5";
+            case "TRI":
+                if (alpha > 90 && beta > 90 && gamma >= 90) {
+                    // TRI-1a,2a
+                    return "TRI_1a";
+                }
+                return "TRI_1b";
+            default:
+                return type;
+        }
+    }
+    /**
+     * Calculate the volume of the lattice cell.
+     */
+    get volume() {
+        return math_1.default.abs(math_1.default.det(this.vectorArrays));
+    }
+    /*
+     * Returns a "default" primitive lattice by type, with lattice parameters scaled by the length of "a",
+     * @param latticeConfig {Object} LatticeBravais config (see constructor)
+     */
+    static getDefaultPrimitiveLatticeConfigByType(latticeConfig) {
+        const f_ = Lattice._roundValue;
+        // construct new primitive cell using lattice parameters and skip rounding the vectors
+        const pCell = (0, primitive_cell_1.primitiveCell)(latticeConfig, true);
+        // create new lattice from primitive cell
+        const newLattice = { ...Lattice.fromVectorArrays(pCell, latticeConfig.type) };
+        // preserve the new type and scale back the lattice parameters
+        const k = latticeConfig.a / newLattice.a;
+        return Object.assign(newLattice, {
+            a: f_(newLattice.a * k),
+            b: f_(newLattice.b * k),
+            c: f_(newLattice.c * k),
+            alpha: f_(newLattice.alpha),
+            beta: f_(newLattice.beta),
+            gamma: f_(newLattice.gamma),
+        });
+    }
+    // TODO: remove
+    get unitCell() {
+        const vectors = [...underscore_1.default.flatten(this.vectorArrays), this.units.length];
+        return new unit_cell_1.UnitCell(vectors);
+    }
+    /**
+     * 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 = false) {
+        // lattice vectors must be measured in angstroms
+        const scaleK = isScaled ? this.a : 1;
+        const scaledLattice = {
+            ...this,
+            a: this.a / scaleK,
+            b: this.b / scaleK,
+            c: this.c / scaleK,
+        };
+        // form lattice string
+        return `${[
+            scaledLattice.a,
+            scaledLattice.b,
+            scaledLattice.c,
+            scaledLattice.alpha,
+            scaledLattice.beta,
+            scaledLattice.gamma,
+        ]
+            .map((x) => math_1.default.round(x, constants_1.HASH_TOLERANCE))
+            .join(";")};`;
+    }
+}
+exports.Lattice = Lattice;

package/dist/lattice/lattice_bravais.d.ts

@@ -0,0 +1,59 @@
+import { LatticeImplicitSchema, LatticeTypeSchema } from "@mat3ra/esse/lib/js/types";
+import { Vector, VectorsAsArray } from "./types";
+export type Units = Required<LatticeImplicitSchema>["units"];
+export interface FromVectorsProps {
+    a: Vector;
+    b: Vector;
+    c: Vector;
+    alat?: number;
+    units?: Units["length"];
+    type?: LatticeTypeSchema;
+    skipRounding?: boolean;
+}
+export declare class LatticeBravais implements LatticeImplicitSchema {
+    a: number;
+    b: number;
+    c: number;
+    alpha: number;
+    beta: number;
+    gamma: number;
+    units: Units;
+    type: LatticeImplicitSchema["type"];
+    /**
+     * Create a Bravais lattice.
+     */
+    constructor(config: Partial<LatticeImplicitSchema>);
+    static _roundValue(x: number): number;
+    /**
+     * Create a Bravais lattice from vectors.
+     */
+    static fromVectors({ a, b, c, alat, units, type, skipRounding, }: FromVectorsProps): LatticeBravais;
+    /**
+     * See fromVectors above.
+     */
+    static fromVectorArrays(array: VectorsAsArray, type: LatticeTypeSchema, skipRounding?: boolean): LatticeBravais;
+    /**
+     * Get the list of editable keys (eg. 'a', 'alpha') for the current lattice.
+     * @return {Object}
+     * @example {a: true, b: false, c: false, alpha: true, beta: false, gamma: false}
+     */
+    get editables(): {};
+    /**
+     * 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"
+         }
+     */
+    toJSON(): LatticeImplicitSchema;
+}

package/dist/lattice/lattice_bravais.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LatticeBravais = void 0;
+const constants_1 = __importDefault(require("../constants"));
+const math_1 = __importDefault(require("../math"));
+const types_1 = require("./types");
+/*
+ * @summary: class that holds parameters of a Bravais Lattice: a, b, c, alpha, beta, gamma + corresponding units.
+ * When stored as class variables units for lengths are always "angstrom"s, angle - "degree"s
+ */
+class LatticeBravais {
+    /**
+     * Create a Bravais lattice.
+     */
+    constructor(config) {
+        const { a = 1, // default lattice is cubic with unity in edge sizes
+        b = a, c = a, alpha = 90, beta = alpha, gamma = alpha, 
+        // if we do not know what lattice type this is => set to TRI
+        type = "TRI", units = {
+            length: "angstrom",
+            angle: "degree",
+        }, } = config;
+        const k = constants_1.default.units.bohr === units.length ? constants_1.default.coefficients.BOHR_TO_ANGSTROM : 1;
+        this.a = a * k;
+        this.b = b * k;
+        this.c = c * k;
+        this.alpha = alpha;
+        this.beta = beta;
+        this.gamma = gamma;
+        this.type = type;
+        this.units = units;
+    }
+    static _roundValue(x) {
+        return math_1.default.precise(math_1.default.roundToZero(x));
+    }
+    /**
+     * Create a Bravais lattice from vectors.
+     */
+    static fromVectors({ a, b, c, alat = 1, units = "angstrom", type = "TRI", skipRounding = false, }) {
+        const roundValue = skipRounding ? (x) => x : this._roundValue;
+        return new this.prototype.constructor({
+            // @ts-ignore
+            a: roundValue(math_1.default.vlen(a) * alat),
+            // @ts-ignore
+            b: roundValue(math_1.default.vlen(b) * alat),
+            // @ts-ignore
+            c: roundValue(math_1.default.vlen(c) * alat),
+            alpha: roundValue(math_1.default.angle(b, c, "deg")),
+            beta: roundValue(math_1.default.angle(a, c, "deg")),
+            gamma: roundValue(math_1.default.angle(a, b, "deg")),
+            // initially we do not know what lattice type this is => set to TRI
+            type,
+            units: {
+                length: units,
+                angle: "degree",
+            },
+        });
+    }
+    /**
+     * See fromVectors above.
+     */
+    static fromVectorArrays(array, type, skipRounding = true) {
+        return this.fromVectors({
+            a: array[0],
+            b: array[1],
+            c: array[2],
+            type,
+            skipRounding, // do not round the values to avoid loosing precision by default
+        });
+    }
+    /**
+     * Get the list of editable keys (eg. 'a', 'alpha') for the current lattice.
+     * @return {Object}
+     * @example {a: true, b: false, c: false, alpha: true, beta: false, gamma: false}
+     */
+    get editables() {
+        var _a;
+        const object = {};
+        const editablesList = (_a = types_1.LATTICE_TYPE_CONFIGS.find((entry) => entry.code === this.type)) === null || _a === void 0 ? void 0 : _a.editables;
+        // ["a", "gamma"] => {a: true, gamma: true}
+        if (editablesList) {
+            editablesList.forEach((element) => {
+                Object.assign(object, {
+                    [element]: true,
+                });
+            });
+        }
+        return object;
+    }
+    /**
+     * 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"
+         }
+     */
+    toJSON() {
+        return {
+            ...this,
+            units: {
+                length: this.units.length,
+                angle: this.units.angle,
+            },
+        };
+    }
+}
+exports.LatticeBravais = LatticeBravais;

package/dist/lattice/lattice_vectors.d.ts

@@ -0,0 +1,46 @@
+import { LatticeExplicitUnit, LatticeImplicitSchema } from "@mat3ra/esse/lib/js/types";
+import { Vector } from "./types";
+type RequiredLatticeExplicitUnit = Required<LatticeExplicitUnit>;
+export interface BravaisConfigProps extends Partial<LatticeImplicitSchema> {
+    isConventional?: boolean;
+}
+export declare class LatticeVectors implements RequiredLatticeExplicitUnit {
+    a: RequiredLatticeExplicitUnit["a"];
+    b: RequiredLatticeExplicitUnit["b"];
+    c: RequiredLatticeExplicitUnit["c"];
+    alat: RequiredLatticeExplicitUnit["alat"];
+    units: RequiredLatticeExplicitUnit["units"];
+    /**
+     * Create a Bravais lattice.
+     */
+    constructor(config: LatticeExplicitUnit);
+    static _roundValue(arr: number[]): number[];
+    static fromBravais({ a, // default lattice is cubic with unity in edge sizes
+    b, c, alpha, beta, gamma, units, type, isConventional, }: BravaisConfigProps): LatticeVectors;
+    get vectorArrays(): [Vector, Vector, Vector];
+    /**
+     * Serialize class instance to JSON.
+     * @example As below:
+     {
+            "a" : [
+                3.34892,
+                0,
+                1.9335
+            ],
+            "b" : [
+                1.116307,
+                3.157392,
+                1.9335
+            ],
+            "c" : [
+                0,
+                0,
+                3.867
+            ],
+            "alat" : 1,
+            "units" : "angstrom"
+        }
+     */
+    toJSON(): RequiredLatticeExplicitUnit;
+}
+export {};

package/dist/lattice/lattice_vectors.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LatticeVectors = void 0;
+const primitive_cell_1 = require("../cell/primitive_cell");
+const constants_1 = __importDefault(require("../constants"));
+const math_1 = __importDefault(require("../math"));
+/*
+ * @summary: class that holds parameters of a Bravais Lattice: a, b, c, alpha, beta, gamma + corresponding units.
+ * When stored as class variables units for lengths are always "angstrom"s, angle - "degree"s
+ */
+class LatticeVectors {
+    /**
+     * Create a Bravais lattice.
+     */
+    constructor(config) {
+        const { a, b, c, alat = 1, units = "angstrom" } = config;
+        const k = constants_1.default.units.bohr === units ? constants_1.default.coefficients.BOHR_TO_ANGSTROM : 1;
+        this.a = a.map((x) => x * k);
+        this.b = b.map((x) => x * k);
+        this.c = c.map((x) => x * k);
+        this.alat = alat;
+        this.units = "angstrom";
+    }
+    static _roundValue(arr) {
+        return arr.map((el) => math_1.default.precise(math_1.default.roundToZero(el)));
+    }
+    /*
+     * Constructs a Bravais lattice from lattice vectors
+     * Supports conventional lattice as parameters and primitive too.
+     * Algorithm from http://pymatgen.org/_modules/pymatgen/core/lattice.html (from_params)
+     * For parameters see `LatticeBravais.constructor`.
+     */
+    static fromBravais({ a = 1, // default lattice is cubic with unity in edge sizes
+    b = a, c = a, alpha = 90, beta = 90, gamma = 90, units = {
+        length: "angstrom",
+        angle: "degree",
+    }, type = "TRI", isConventional = false, }) {
+        // use "direct" lattice constructor for primitive lattice
+        // eslint-disable-next-line no-param-reassign
+        if (!isConventional)
+            type = "TRI";
+        // set precision and remove JS floating point artifacts
+        const [vectorA, vectorB, vectorC] = (0, primitive_cell_1.primitiveCell)({
+            a,
+            b,
+            c,
+            alpha,
+            beta,
+            gamma,
+            units,
+            type,
+        });
+        return new LatticeVectors({
+            a: vectorA,
+            b: vectorB,
+            c: vectorC,
+            alat: 1,
+        });
+    }
+    get vectorArrays() {
+        return [this.a, this.b, this.c];
+    }
+    /**
+     * Serialize class instance to JSON.
+     * @example As below:
+     {
+            "a" : [
+                3.34892,
+                0,
+                1.9335
+            ],
+            "b" : [
+                1.116307,
+                3.157392,
+                1.9335
+            ],
+            "c" : [
+                0,
+                0,
+                3.867
+            ],
+            "alat" : 1,
+            "units" : "angstrom"
+        }
+     */
+    toJSON() {
+        return {
+            ...this,
+            a: LatticeVectors._roundValue(this.a),
+            b: LatticeVectors._roundValue(this.b),
+            c: LatticeVectors._roundValue(this.c),
+        };
+    }
+}
+exports.LatticeVectors = LatticeVectors;

package/dist/lattice/reciprocal/lattice_reciprocal.d.ts

@@ -0,0 +1,75 @@
+export class ReciprocalLattice extends Lattice {
+    /**
+     * Get reciprocal vectors for the current Lattice in cartesian (2pi / a) units
+     * @return {Array[]}
+     */
+    get reciprocalVectors(): any[][];
+    /**
+     * Norms of reciprocal vectors.
+     * @return {number[]}
+     */
+    get reciprocalVectorNorms(): number[];
+    /**
+     * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
+     * @return {number[]}
+     */
+    get reciprocalVectorRatios(): number[];
+    /**
+     * Get point (in crystal coordinates) in cartesian coordinates.
+     * @param {Array} point - point in 3D space
+     * @return {Array}
+     */
+    getCartesianCoordinates(point: any[]): any[];
+    /**
+     * Get the list of high-symmetry points for the current lattice.
+     * @return {Object[]}
+     */
+    get symmetryPoints(): Object[];
+    /**
+     * Get the default path in reciprocal space for the current lattice.
+     * @return {Array[]}
+     */
+    get defaultKpointPath(): any[][];
+    /**
+     * Find/mark the high symmetry points on a list with raw data and return the edited list.
+     * @param {Array} dataPoints - list of point coordinates
+     * @return {Object[]}
+     */
+    extractKpointPath(dataPoints?: any[]): Object[];
+    /**
+     * Calculate grid dimension based on reciprocal lattice vectors.
+     * @param {number} nPoints - Total number of points
+     * @param {number} index - Index of reciprocal vector
+     * @return {number} - Grid dimension in direction of reciprocal vector
+     * @todo This could be moved to a separate KGrid class.
+     */
+    calculateDimension(nPoints: number, index: number): number;
+    /**
+     * Calculate grid dimensions from total number of k-points.
+     * @param {number} nKpoints - Total number of k-points.
+     * @return {number[]} - Grid dimensions
+     */
+    getDimensionsFromPointsCount(nKpoints: number): number[];
+    get conversionTable(): {
+        [x: string]: {
+            [x: string]: number;
+        };
+    };
+    /**
+     * Calculate grid dimensions from k-point spacing, i.e.
+     * the maximum distance between adjacent points along a reciprocal axis.
+     * Note: just as the lattice vectors spacing is in cartesian (2pi / a) units by default
+     * @param {number} spacing - maximum Spacing between k-points
+     * @param {string} units - units of spacing parameter (default: 2pi / a)
+     * @return {number[]}
+     */
+    getDimensionsFromSpacing(spacing: number, units?: string): number[];
+    /**
+     * Calculate grid spacing as average of spacing along individual reciprocal axes.
+     * @param {number[]} dimensions - Array of dimensions
+     * @param {string} units - units of spacing parameter (default: 2pi / a)
+     * @return {number} - average grid spacing
+     */
+    getSpacingFromDimensions(dimensions: number[], units?: string): number;
+}
+import { Lattice } from "../lattice";