@mat3ra/made 2024.3.22-0

package/dist/lattice/reciprocal/lattice_reciprocal.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReciprocalLattice = void 0;
+const constants_1 = require("@exabyte-io/code.js/dist/constants");
+const array_almost_equal_1 = __importDefault(require("array-almost-equal"));
+const lodash_1 = __importDefault(require("lodash"));
+const math_1 = __importDefault(require("../../math"));
+const lattice_1 = require("../lattice");
+const paths_1 = require("./paths");
+const symmetry_points_1 = require("./symmetry_points");
+class ReciprocalLattice extends lattice_1.Lattice {
+    /**
+     * Get reciprocal vectors for the current Lattice in cartesian (2pi / a) units
+     * @return {Array[]}
+     */
+    get reciprocalVectors() {
+        const vectors_ = this.vectors.vectorArrays;
+        const a = math_1.default.vlen(vectors_[0]);
+        const divider = math_1.default.multiply(vectors_[0], math_1.default.cross(vectors_[1], vectors_[2])) / a;
+        return [
+            math_1.default.multiply(math_1.default.cross(vectors_[1], vectors_[2]), 1 / divider),
+            math_1.default.multiply(math_1.default.cross(vectors_[2], vectors_[0]), 1 / divider),
+            math_1.default.multiply(math_1.default.cross(vectors_[0], vectors_[1]), 1 / divider),
+        ];
+    }
+    /**
+     * Norms of reciprocal vectors.
+     * @return {number[]}
+     */
+    get reciprocalVectorNorms() {
+        return this.reciprocalVectors.map((vec) => math_1.default.norm(vec));
+    }
+    /**
+     * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
+     * @return {number[]}
+     */
+    get reciprocalVectorRatios() {
+        const norms = this.reciprocalVectorNorms;
+        const maxNorm = math_1.default.max(...norms);
+        return norms.map((n) => n / maxNorm);
+    }
+    /**
+     * Get point (in crystal coordinates) in cartesian coordinates.
+     * @param {Array} point - point in 3D space
+     * @return {Array}
+     */
+    getCartesianCoordinates(point) {
+        return math_1.default.multiply(point, this.reciprocalVectors);
+    }
+    /**
+     * Get the list of high-symmetry points for the current lattice.
+     * @return {Object[]}
+     */
+    get symmetryPoints() {
+        return (0, symmetry_points_1.symmetryPoints)(this);
+    }
+    /**
+     * Get the default path in reciprocal space for the current lattice.
+     * @return {Array[]}
+     */
+    get defaultKpointPath() {
+        return paths_1.paths[this.typeExtended] || paths_1.paths[this.type];
+    }
+    /**
+     * 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 = []) {
+        const kpointPath = [];
+        const symmPoints = this.symmetryPoints;
+        dataPoints.forEach((point, index) => {
+            const symmPoint = symmPoints.find((x) => {
+                return (0, array_almost_equal_1.default)(x.coordinates, point, 1e-4);
+            });
+            if (symmPoint) {
+                kpointPath.push({
+                    point: symmPoint.point,
+                    steps: index,
+                    coordinates: symmPoint.coordinates,
+                });
+            }
+        });
+        return kpointPath;
+    }
+    /**
+     * 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, index) {
+        const norms = this.reciprocalVectorNorms;
+        const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
+        const N = math_1.default.cbrt((nPoints * norms[index] ** 2) / (norms[j] * norms[k]));
+        return math_1.default.max(1, math_1.default.ceil(N));
+    }
+    /**
+     * Calculate grid dimensions from total number of k-points.
+     * @param {number} nKpoints - Total number of k-points.
+     * @return {number[]} - Grid dimensions
+     */
+    getDimensionsFromPointsCount(nKpoints) {
+        const indices = [0, 1, 2];
+        return indices.map((i) => this.calculateDimension(nKpoints, i));
+    }
+    get conversionTable() {
+        const { a } = this;
+        return {
+            [constants_1.ATOMIC_COORD_UNITS.cartesian]: {
+                [constants_1.units.angstrom]: (2 * math_1.default.PI) / a,
+            },
+            [constants_1.units.angstrom]: {
+                [constants_1.ATOMIC_COORD_UNITS.cartesian]: a / (2 * math_1.default.PI),
+            },
+        };
+    }
+    /**
+     * 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, units = constants_1.ATOMIC_COORD_UNITS.cartesian) {
+        const factor = this.conversionTable[units][constants_1.ATOMIC_COORD_UNITS.cartesian] || 1;
+        return this.reciprocalVectorNorms.map((norm) => {
+            return math_1.default.max(1, math_1.default.ceil(lodash_1.default.round(norm / (spacing * factor), 4)));
+        });
+    }
+    /**
+     * 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, units = constants_1.ATOMIC_COORD_UNITS.cartesian) {
+        const factor = this.conversionTable[constants_1.ATOMIC_COORD_UNITS.cartesian][units] || 1;
+        const norms = this.reciprocalVectorNorms;
+        return factor * math_1.default.mean(dimensions.map((dim, i) => norms[i] / math_1.default.max(1, dim)));
+    }
+}
+exports.ReciprocalLattice = ReciprocalLattice;

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

@@ -0,0 +1,24 @@
+export const paths: {
+    CUB: string[][];
+    BCC: string[][];
+    FCC: string[][];
+    TET: string[][];
+    "BCT-1": string[][];
+    "BCT-2": string[][];
+    ORC: string[][];
+    "ORCF-1": string[][];
+    "ORCF-2": string[][];
+    "ORCF-3": string[][];
+    ORCI: string[][];
+    ORCC: string[][];
+    HEX: string[][];
+    "RHL-1": string[][];
+    "RHL-2": string[][];
+    MCL: string[][];
+    "MCLC-1": string[][];
+    "MCLC-2": string[][];
+    "MCLC-3": string[][];
+    "MCLC-4": string[][];
+    "MCLC-5": string[][];
+    TRI: string[][];
+};

package/dist/lattice/reciprocal/paths.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paths = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+/**
+ * Default kpoing paths according to:
+ *  [AFLOW](https://arxiv.org/abs/1004.2974) methodology.
+ *  Paths are split in parts for clarity.
+ */
+const points = {
+    CUB: [
+        ["Г", "X", "M", "Г", "R", "X"],
+        ["M", "R"],
+    ],
+    BCC: [
+        ["Г", "H", "N", "Г", "P", "H"],
+        ["P", "N"],
+    ],
+    FCC: [
+        ["Г", "X", "W", "K", "Г", "L", "U", "W", "L"],
+        ["U", "X"],
+    ],
+    TET: [
+        ["Г", "X", "M", "Г", "Z", "R", "A", "Z"],
+        ["X", "R"],
+        ["M", "A"],
+    ],
+    "BCT-1": [
+        ["Г", "X", "M", "Г", "Z", "P", "N", "Z1", "M"],
+        ["X", "P"],
+    ],
+    "BCT-2": [
+        ["Г", "X", "Y", "∑", "Г", "Z", "∑1", "N", "P", "Y1", "Z"],
+        ["X", "P"],
+    ],
+    ORC: [
+        ["Г", "X", "S", "Y", "Г", "Z", "U", "R", "T", "Z"],
+        ["Y", "T"],
+        ["U", "X"],
+        ["S", "R"],
+    ],
+    "ORCF-1": [
+        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["T", "X1"],
+        ["X", "A", "Z"],
+        ["L", "Г"],
+    ],
+    "ORCF-2": [
+        ["Г", "Y", "C", "D", "X", "Г", "Z", "D1", "H", "C"],
+        ["C1", "Z"],
+        ["X", "H1"],
+        ["H", "Y"],
+        ["L", "Г"],
+    ],
+    "ORCF-3": [
+        ["Г", "Y", "T", "Z", "Г", "X", "A1", "Y"],
+        ["X", "A", "Z"],
+        ["L", "Г"],
+    ],
+    ORCI: [
+        ["Г", "X", "L", "T", "W", "R", "X1", "Z", "Г", "Y", "S", "W"],
+        ["L1", "Y"],
+        ["Y1", "Z"],
+    ],
+    ORCC: [
+        ["Г", "X", "S", "R", "A", "Z", "Г", "Y", "X1", "A1", "T", "Y"],
+        ["Z", "T"],
+    ],
+    HEX: [
+        ["Г", "M", "K", "Г", "A", "L", "H", "A"],
+        ["L", "M"],
+        ["K", "H"],
+    ],
+    "RHL-1": [
+        ["Г", "L", "B1"],
+        ["B", "Z", "Г", "X"],
+        ["Q", "F", "P1", "Z"],
+        ["L", "P"],
+    ],
+    "RHL-2": [["Г", "P", "Z", "Q", "Г", "F", "P1", "Q1", "L", "Z"]],
+    MCL: [
+        ["Г", "Y", "H", "C", "E", "M1", "A", "X", "H1"],
+        ["M", "D", "Z"],
+        ["Y", "D"],
+    ],
+    "MCLC-1": [
+        ["Г", "Y", "Г", "L", "I"],
+        ["I1", "Z", "F1"],
+        ["Y", "X1"],
+        ["X", "Г", "N"],
+        ["M", "Г"],
+    ],
+    "MCLC-2": [
+        ["Г", "Y", "F", "L", "I"],
+        ["I1", "Z", "F1"],
+        ["N", "Г", "M"],
+    ],
+    "MCLC-3": [
+        ["Г", "Y", "F", "H", "Z", "I", "F1"],
+        ["H1", "Y1", "X", "Г", "N"],
+        ["M", "Г"],
+    ],
+    "MCLC-4": [
+        ["Г", "Y", "F", "H", "Z", "I"],
+        ["H1", "Y1", "X", "Г", "N"],
+        ["M", "Г"],
+    ],
+    "MCLC-5": [
+        ["Г", "Y", "F", "L", "I"],
+        ["I1", "Z", "H", "F1"],
+        ["H1", "Y1", "X", "Г", "N"],
+        ["M", "Г"],
+    ],
+    TRI: [
+        ["X", "Г", "Y"],
+        ["L", "Г", "Z"],
+        ["N", "Г", "M"],
+        ["R", "Г"],
+    ],
+};
+exports.paths = underscore_1.default.each(points, (val, key, obj) => {
+    // merge sub-arrays
+    // eslint-disable-next-line no-param-reassign
+    val = val.reduce((a, b) => a.concat(b));
+    underscore_1.default.each(val, (el, idx, list) => {
+        list[idx] = {
+            point: el,
+            // TODO: calculate number of steps based on distance in k-space
+            steps: 10,
+        };
+    });
+    obj[key] = val;
+});

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

@@ -0,0 +1,8 @@
+import { Lattice } from "../lattice";
+/**
+ * Returns a list of symmetry points for the specified lattice.
+ */
+export declare function symmetryPoints(lattice: Lattice): {
+    point: string;
+    coordinates: number[];
+}[];