@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/src/js/constraints/constraints.ts

@@ -1,45 +0,0 @@
-import { ArrayWithIds, ValueWithId } from "@mat3ra/code";
-import { AtomicConstraintSchema } from "@mat3ra/esse/dist/js/types";
-
-export type AtomicConstraintValue = AtomicConstraintSchema["value"];
-
-export class Constraint extends ValueWithId<AtomicConstraintValue> {
-    value: AtomicConstraintValue;
-
-    constructor({ value, id }: AtomicConstraintSchema) {
-        super({ id, value });
-        this.value = value;
-    }
-
-    getValueAsString(): string {
-        return this.value.map((x) => (x ? 1 : 0)).join(" ");
-    }
-
-    prettyPrint(): string {
-        return this.value.map((x) => (x ? 1 : 0)).join(" ");
-    }
-
-    // By default, the constraint is unconstrained if all values are 1/true.
-    isUnconstrained(): boolean {
-        return this.value.every((val) => val);
-    }
-}
-
-export class AtomicConstraints extends ArrayWithIds<AtomicConstraintValue> {
-    /**
-     * 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 => (val ? "1" : "0")): string {
-        const constraints = this.getElementValueByIndex(idx);
-        return constraints ? constraints.map(mapFn).join(" ") : "";
-    }
-
-    get areUnconstrained(): boolean {
-        return this.values.every((constraint) => {
-            const _constraint = Constraint.fromValueAndId(constraint);
-            return _constraint.isUnconstrained();
-        });
-    }
-}

package/src/js/lattice/lattice.ts

@@ -1,306 +0,0 @@
-import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import {
-    Coordinate3DSchema,
-    LatticeSchema,
-    LatticeTypeEnum,
-    LatticeTypeExtendedEnum,
-    LatticeVectorsSchema,
-    Matrix3X3Schema,
-} from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import * as lodash from "lodash";
-
-import { Cell } from "../cell/cell";
-import { getPrimitiveLatticeVectorsFromConfig } from "../cell/primitive_cell";
-import { LATTICE_TYPE_CONFIGS } from "./lattice_types";
-import { UnitCell, UnitCellProps } from "./unit_cell";
-
-const { HASH_TOLERANCE } = Utils.constants;
-/**
- * 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 {
-    defaultNonPeriodicMinimumLatticeSize,
-    diatomicLatticePaddingFactor,
-    molecularLatticePaddingFactor,
-} from "../constants/molecule";
-
-export class LatticeVectors extends Cell implements LatticeVectorsSchema {}
-
-export type { LatticeVectorsSchema };
-
-export class Lattice extends InMemoryEntity implements LatticeSchema {
-    static defaultConfig: LatticeSchema = {
-        a: 1,
-        b: 1,
-        c: 1,
-        alpha: 90,
-        beta: 90,
-        gamma: 90,
-        units: { length: "angstrom", angle: "degree" },
-        type: "CUB",
-    };
-
-    a: LatticeSchema["a"];
-
-    b: LatticeSchema["b"];
-
-    c: LatticeSchema["c"];
-
-    alpha: LatticeSchema["alpha"];
-
-    beta: LatticeSchema["beta"];
-
-    gamma: LatticeSchema["gamma"];
-
-    type: LatticeTypeEnum = "TRI";
-
-    units: LatticeSchema["units"];
-
-    constructor(config: LatticeSchema = Lattice.defaultConfig) {
-        super(config);
-        const { a, b, c, alpha, beta, gamma, units, type } = config;
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.alpha = alpha;
-        this.beta = beta;
-        this.gamma = gamma;
-        this.units = units;
-        this.type = type || "TRI";
-    }
-
-    static fromConfig(config: object): Lattice {
-        const latticeConfig = config as LatticeSchema;
-        return new Lattice(latticeConfig);
-    }
-
-    static fromConfigPartial(config: LatticeSchema): Lattice {
-        const primitiveLatticeConfig = Lattice.getDefaultPrimitiveLatticeConfigByType(config);
-        return new Lattice(primitiveLatticeConfig);
-    }
-
-    calculateVectors(): Matrix3X3Schema {
-        const { a } = this;
-        const { b } = this;
-        const { c } = this;
-
-        const alphaRad = Utils.math.unit(this.alpha, "deg").toNumber("rad");
-        const betaRad = Utils.math.unit(this.beta, "deg").toNumber("rad");
-        const gammaRad = Utils.math.unit(this.gamma, "deg").toNumber("rad");
-
-        const cosAlpha = Utils.math.cos(alphaRad);
-        const cosBeta = Utils.math.cos(betaRad);
-        const cosGamma = Utils.math.cos(gammaRad);
-        const sinAlpha = Utils.math.sin(alphaRad);
-        const sinBeta = Utils.math.sin(betaRad);
-
-        const gammaStar = Utils.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
-        // @ts-ignore - mathjs v12 acos return type includes Complex, but inputs are always real
-        const cosGammaStar = Utils.math.cos(gammaStar);
-        // @ts-ignore
-        const sinGammaStar = Utils.math.sin(gammaStar);
-
-        const vectorA: Coordinate3DSchema = [a * sinBeta, 0.0, a * cosBeta];
-        const vectorB: Coordinate3DSchema = [
-            -b * sinAlpha * cosGammaStar,
-            b * sinAlpha * sinGammaStar,
-            b * cosAlpha,
-        ];
-        const vectorC: Coordinate3DSchema = [0.0, 0.0, c];
-
-        return [vectorA, vectorB, vectorC];
-    }
-
-    static fromVectors(config: LatticeVectorsSchema): Lattice {
-        return this.fromVectorsArray([config.a, config.b, config.c]);
-    }
-
-    static fromVectorsArray(
-        vectors: Matrix3X3Schema,
-        units: LatticeSchema["units"] = Lattice.defaultConfig.units,
-        type: LatticeTypeEnum = "TRI",
-    ): Lattice {
-        const [aVec, bVec, cVec] = vectors;
-        const a = Utils.math.vlen(aVec);
-        const b = Utils.math.vlen(bVec);
-        const c = Utils.math.vlen(cVec);
-        const alpha = Utils.math.angle(bVec, cVec, "deg");
-        const beta = Utils.math.angle(aVec, cVec, "deg");
-        const gamma = Utils.math.angle(aVec, bVec, "deg");
-
-        return new Lattice({
-            a,
-            b,
-            c,
-            alpha,
-            beta,
-            gamma,
-            units,
-            type,
-        });
-    }
-
-    // TODO: remove
-    get unitCell() {
-        const units = this.units?.length || "angstrom";
-        const vectors = [...lodash.flatten(this.vectorArrays), units] as UnitCellProps;
-        return new UnitCell(vectors);
-    }
-
-    get vectors(): LatticeVectors {
-        return LatticeVectors.fromVectorsArray(this.calculateVectors());
-    }
-
-    get vectorArrays(): Matrix3X3Schema {
-        return this.vectors.vectorArrays;
-    }
-
-    get vectorArraysRounded(): Matrix3X3Schema {
-        return this.vectors.vectorArraysRounded;
-    }
-
-    get cellVolume(): number {
-        return this.vectors.volume;
-    }
-
-    get cellVolumeRounded(): number {
-        return this.vectors.volumeRounded;
-    }
-
-    /**
-     * Get a short label for the type of the lattice, eg. "MCLC".
-     */
-    get typeLabel(): string {
-        return lodash.get(
-            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(): LatticeTypeExtendedEnum {
-        const { a, b, c, alpha, beta, gamma, type } = this;
-        const cosAlpha = Utils.math.cos((alpha / 180) * Utils.math.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(): number {
-        return Utils.math.abs(Utils.math.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: LatticeSchema) {
-        const f_ = Utils.math.roundArrayOrNumber;
-        // construct new primitive cell using lattice parameters and skip rounding the vectors
-        const vectors = getPrimitiveLatticeVectorsFromConfig(latticeConfig);
-        // create new lattice from primitive cell
-        const newLattice = Lattice.fromVectorsArray(vectors, undefined, latticeConfig.type);
-        // preserve the new type and scale back the lattice parameters
-        const k = latticeConfig.a / newLattice.a;
-
-        return Object.assign(newLattice.toJSON(), {
-            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),
-        });
-    }
-
-    /**
-     * 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): string {
-        // 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) => Utils.math.roundCustom(x, HASH_TOLERANCE))
-            .join(";")};`;
-    }
-
-    /**
-     * 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() {
-        const object = {};
-        const editablesList = LATTICE_TYPE_CONFIGS.find(
-            (entry: any) => entry.code === this.type,
-        )?.editables;
-        // ["a", "gamma"] => {a: true, gamma: true}
-        if (editablesList) {
-            editablesList.forEach((element: any) => {
-                Object.assign(object, {
-                    [element]: true,
-                });
-            });
-        }
-
-        return object;
-    }
-
-    // @ts-ignore
-    toJSON(exclude?: string[]): LatticeSchema {
-        return {
-            ...super.toJSON(exclude),
-            vectors: this.vectors.toJSON(),
-        } as LatticeSchema;
-    }
-}

package/src/js/lattice/lattice_types.ts

@@ -1,134 +0,0 @@
-import { LatticeTypeEnum } from "@mat3ra/esse/dist/js/types";
-
-export enum LatticeTypeExtended {
-    BCC = "BCC",
-    BCT_1 = "BCT-1",
-    BCT_2 = "BCT-2",
-    CUB = "CUB",
-    FCC = "FCC",
-    HEX = "HEX",
-    MCL = "MCL",
-    MCLC_1 = "MCLC-1",
-    MCLC_2 = "MCLC-2",
-    MCLC_3 = "MCLC-3",
-    MCLC_4 = "MCLC-4",
-    MCLC_5 = "MCLC-5",
-    ORC = "ORC",
-    ORCC = "ORCC",
-    ORCF_1 = "ORCF-1",
-    ORCF_2 = "ORCF-2",
-    ORCF_3 = "ORCF-3",
-    ORCI = "ORCI",
-    RHL_1 = "RHL-1",
-    RHL_2 = "RHL-2",
-    TET = "TET",
-    TRI_1a = "TRI_1a",
-    TRI_2a = "TRI_2a",
-    TRI_1b = "TRI_1b",
-}
-
-export interface LatticeTypeConfig {
-    label: string;
-    code: LatticeTypeEnum;
-    editables: string[];
-    editablesConventional: string[];
-}
-
-export const DEFAULT_LATTICE_UNITS = {
-    // by default lattice vectors shall be measured in angstrom, angles - in degrees
-    length: {
-        angstrom: "angstrom",
-    },
-    angle: {
-        degree: "degree",
-    },
-};
-
-export const LATTICE_TYPE_CONFIGS: LatticeTypeConfig[] = [
-    {
-        label: "Simple Cubic",
-        code: "CUB",
-        // editables for primitive cell => WARNING: not tested
-        editables: ["a"],
-        // editables for conventional cell, taken from the publication above
-        editablesConventional: ["a"],
-    },
-    {
-        label: "Face-centered Cubic",
-        code: "FCC",
-        editables: ["a"],
-        editablesConventional: ["a"],
-    },
-    {
-        label: "Body-centered Cubic",
-        code: "BCC",
-        editables: ["a"],
-        editablesConventional: ["a"],
-    },
-    {
-        label: "Tetragonal",
-        code: "TET",
-        editables: ["a", "c"],
-        editablesConventional: ["a", "c"],
-    },
-    {
-        label: "Body-centered Tetragonal",
-        code: "BCT",
-        editables: ["a"],
-        editablesConventional: ["a", "c"],
-    },
-    {
-        label: "Orthorombic",
-        code: "ORC",
-        editables: ["a", "b", "c"],
-        editablesConventional: ["a", "b", "c"],
-    },
-    {
-        label: "Orthorombic Face-centered",
-        code: "ORCF",
-        editables: ["a", "b", "c"],
-        editablesConventional: ["a", "b", "c"],
-    },
-    {
-        label: "Orthorombic Body-centered",
-        code: "ORCI",
-        editables: ["a", "alpha", "gamma"],
-        editablesConventional: ["a", "b", "c"],
-    },
-    {
-        label: "Orthorombic Base-centered",
-        code: "ORCC",
-        editables: ["a", "c", "alpha"],
-        editablesConventional: ["a", "b", "c"],
-    },
-    {
-        label: "Hexagonal",
-        code: "HEX",
-        editables: ["a", "c"],
-        editablesConventional: ["a", "c"],
-    },
-    {
-        label: "Rhombohedral",
-        code: "RHL",
-        editables: ["a", "alpha"],
-        editablesConventional: ["a", "alpha"],
-    },
-    {
-        label: "Monoclinic",
-        code: "MCL",
-        editables: ["a", "b", "c", "alpha"],
-        editablesConventional: ["a", "b", "c", "alpha"],
-    },
-    {
-        label: "Monoclinic Base-centered",
-        code: "MCLC",
-        editables: ["a", "c", "alpha", "gamma"],
-        editablesConventional: ["a", "b", "c", "alpha"],
-    },
-    {
-        label: "Triclinic",
-        code: "TRI",
-        editables: ["a", "b", "c", "alpha", "beta", "gamma"],
-        editablesConventional: ["a", "b", "c", "alpha", "beta", "gamma"],
-    },
-];

package/src/js/lattice/reciprocal/lattice_reciprocal.ts

@@ -1,193 +0,0 @@
-import { ATOMIC_COORD_UNITS, units as UNITS } from "@mat3ra/code/dist/js/constants";
-import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import lodash from "lodash";
-
-import { Lattice } from "../lattice";
-import { paths } from "./paths";
-import { symmetryPoints } from "./symmetry_points";
-
-
-export type KPointCoordinates = number[];
-export type KPointPath = Array<{
-    point: string;
-    steps: number;
-    coordinates: KPointCoordinates;
-}>;
-
-interface SymmetryPoint {
-    point: string;
-    coordinates: KPointCoordinates;
-}
-
-interface ConversionTable {
-    [key: string]: {
-        [key: string]: number;
-    };
-}
-
-interface PathsType {
-    [key: string]: Array<{
-        point: string;
-        steps: number;
-    }>;
-}
-
-export class ReciprocalLattice extends Lattice {
-    /**
-     * Get reciprocal vectors for the current Lattice in cartesian (2pi / a) units
-     * @return {Vector3DSchema[]}
-     */
-    get reciprocalVectors(): Vector3DSchema[] {
-        const vectors_: Vector3DSchema[] = this.vectors.vectorArrays as Vector3DSchema[];
-        const a: number = Utils.math.vlen(vectors_[0]);
-        const divider: number =
-            (Utils.math.multiply(
-                vectors_[0],
-                Utils.math.cross(vectors_[1], vectors_[2]),
-            ) as unknown as number) / a;
-        return [
-            Utils.math.multiply(Utils.math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
-            Utils.math.multiply(Utils.math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
-            Utils.math.multiply(Utils.math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
-        ];
-    }
-
-    /**
-     * Norms of reciprocal vectors.
-     */
-    get reciprocalVectorNorms(): Vector3DSchema {
-        return this.reciprocalVectors.map((vec) => Utils.math.norm(vec) as number) as Vector3DSchema;
-    }
-
-    /**
-     * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
-     */
-    get reciprocalVectorRatios(): Vector3DSchema {
-        const norms: number[] = this.reciprocalVectorNorms;
-        const maxNorm: number = Utils.math.max(...norms) as number;
-        return norms.map((n: number) => n / maxNorm) as Vector3DSchema;
-    }
-
-    /**
-     * Get point (in crystal coordinates) in cartesian coordinates.
-     * @param {KPointCoordinates} point - point in 3D space
-     * @return {KPointCoordinates}
-     */
-    getCartesianCoordinates(point: KPointCoordinates): KPointCoordinates {
-        return Utils.math.multiply(point, this.reciprocalVectors) as KPointCoordinates;
-    }
-
-    /**
-     * Get the list of high-symmetry points for the current lattice.
-     * @return {SymmetryPoint[]}
-     */
-    get symmetryPoints(): SymmetryPoint[] {
-        return symmetryPoints(this);
-    }
-
-    /**
-     * Get the default path in reciprocal space for the current lattice.
-     * @return {Array<{point: string; steps: number}>}
-     */
-    get defaultKpointPath(): Array<{ point: string; steps: number }> {
-        const pathsObj = paths as PathsType;
-        return pathsObj[this.typeExtended as string] || pathsObj[this.type as string] || [];
-    }
-
-    /**
-     * Find/mark the high symmetry points on a list with raw data and return the edited list.
-     * @param {KPointCoordinates[]} dataPoints - list of point coordinates
-     * @return {KPointPath}
-     */
-    extractKpointPath(dataPoints: KPointCoordinates[] = []): KPointPath {
-        const kpointPath: KPointPath = [];
-        const symmPoints: SymmetryPoint[] = this.symmetryPoints;
-
-        dataPoints.forEach((point: KPointCoordinates, index: number) => {
-            const symmPoint: SymmetryPoint | undefined = symmPoints.find((x) => {
-                return Utils.math.vEqualWithTolerance(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: number, index: number): number {
-        const norms: number[] = this.reciprocalVectorNorms;
-        const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
-        const N: number = Utils.math.cbrt(
-            (nPoints * norms[index] ** 2) / (norms[j] * norms[k]),
-        ) as number;
-        return Utils.math.max(1, Utils.math.ceil(N)) as number;
-    }
-
-    /**
-     * Calculate grid dimensions from total number of k-points.
-     * @param {number} nKpoints - Total number of k-points.
-     * @return Grid dimensions
-     */
-    getDimensionsFromPointsCount(nKpoints: number) {
-        const indices = [0, 1, 2] as const;
-        return indices.map((i) => this.calculateDimension(nKpoints, i)) as Vector3DSchema;
-    }
-
-    get conversionTable(): ConversionTable {
-        const { a } = this;
-        return {
-            [ATOMIC_COORD_UNITS.cartesian]: {
-                [UNITS.angstrom]: (2 * Utils.math.PI) / a,
-            },
-            [UNITS.angstrom]: {
-                [ATOMIC_COORD_UNITS.cartesian]: a / (2 * Utils.math.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)
-     */
-    getDimensionsFromSpacing(spacing: number, units: string = ATOMIC_COORD_UNITS.cartesian) {
-        const factor: number = this.conversionTable[units][ATOMIC_COORD_UNITS.cartesian] || 1;
-        return this.reciprocalVectorNorms.map((norm: number) => {
-            return Utils.math.max(1, Utils.math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
-        }) as Vector3DSchema;
-    }
-
-    /**
-     * 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 = ATOMIC_COORD_UNITS.cartesian,
-    ): number {
-        const factor: number = this.conversionTable[ATOMIC_COORD_UNITS.cartesian][units] || 1;
-        const norms: number[] = this.reciprocalVectorNorms;
-        return (
-            factor *
-            (Utils.math.mean(
-                dimensions.map((dim: number, i: number) => norms[i] / Utils.math.max(1, dim)),
-            ) as number)
-        );
-    }
-}