@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/src/js/lattice/unit_cell.ts

@@ -1,66 +0,0 @@
-import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
-
-export type UnitCellProps = [
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    string,
-];
-
-// TODO: refactor and remove the need for UnitCell
-export class UnitCell {
-    ax: number;
-
-    ay: number;
-
-    az: number;
-
-    bx: number;
-
-    by: number;
-
-    bz: number;
-
-    cx: number;
-
-    cy: number;
-
-    cz: number;
-
-    units: string;
-
-    constructor([ax, ay, az, bx, by, bz, cx, cy, cz, units]: UnitCellProps) {
-        this.ax = ax;
-        this.ay = ay;
-        this.az = az;
-        this.bx = bx;
-        this.by = by;
-        this.bz = bz;
-        this.cx = cx;
-        this.cy = cy;
-        this.cz = cz;
-        this.units = units;
-    }
-
-    vectorA(): Vector3DSchema {
-        return [this.ax, this.ay, this.az];
-    }
-
-    vectorB(): Vector3DSchema {
-        return [this.bx, this.by, this.bz];
-    }
-
-    vectorC(): Vector3DSchema {
-        return [this.cx, this.cy, this.cz];
-    }
-
-    axes(): [Vector3DSchema, Vector3DSchema, Vector3DSchema] {
-        return [this.vectorA(), this.vectorB(), this.vectorC()];
-    }
-}

package/src/js/made.ts

@@ -1,62 +0,0 @@
-import { Basis } from "./basis/basis";
-import { Cell } from "./cell/cell";
-import { ATOMIC_COORD_UNITS, coefficients, tolerance, units } from "./constants";
-import { AtomicConstraints } from "./constraints/constraints";
-import {
-    defaultNonPeriodicMinimumLatticeSize,
-    diatomicLatticePaddingFactor,
-    Lattice,
-    molecularLatticePaddingFactor,
-} from "./lattice/lattice";
-import { DEFAULT_LATTICE_UNITS, LATTICE_TYPE_CONFIGS } from "./lattice/lattice_types";
-import { ReciprocalLattice } from "./lattice/reciprocal/lattice_reciprocal";
-import { UnitCell } from "./lattice/unit_cell";
-import Material, { defaultMaterialConfig } from "./Material";
-import parsers from "./parsers/parsers";
-import tools from "./tools/index";
-
-export const Made = {
-    coefficients,
-    tolerance,
-    units,
-    ATOMIC_COORD_UNITS,
-
-    Material,
-    defaultMaterialConfig,
-    Lattice,
-    Cell,
-    UnitCell,
-    defaultNonPeriodicMinimumLatticeSize,
-    diatomicLatticePaddingFactor,
-    molecularLatticePaddingFactor,
-    ReciprocalLattice,
-    Basis,
-    AtomicConstraints,
-
-    parsers,
-    tools,
-    LATTICE_TYPE_CONFIGS,
-    DEFAULT_LATTICE_UNITS,
-};
-
-export {
-    coefficients,
-    tolerance,
-    units,
-    ATOMIC_COORD_UNITS,
-    Material,
-    defaultMaterialConfig,
-    Lattice,
-    Cell,
-    UnitCell,
-    defaultNonPeriodicMinimumLatticeSize,
-    diatomicLatticePaddingFactor,
-    molecularLatticePaddingFactor,
-    ReciprocalLattice,
-    Basis,
-    AtomicConstraints,
-    parsers,
-    tools,
-    LATTICE_TYPE_CONFIGS,
-    DEFAULT_LATTICE_UNITS,
-};

package/src/js/parsers/cif.ts

@@ -1,25 +0,0 @@
-export interface Meta {
-    icsdId?: number;
-}
-
-/**
- * Extracts meta information from a CIF file
- * @param txt - CIF file text.
- */
-function parseMeta(txt: string): Meta {
-    const REGEX = {
-        ICSD_ID: /_database_code_ICSD\s+(\d+)/,
-    };
-    const meta: Meta = {};
-    const groups = txt.match(REGEX.ICSD_ID);
-
-    if (groups) {
-        meta.icsdId = Number(groups[1]);
-    }
-
-    return meta;
-}
-
-export default {
-    parseMeta,
-};

package/src/js/parsers/errors.ts

@@ -1,6 +0,0 @@
-export class InvalidLineError extends Error {
-    constructor(num: number, content: string) {
-        super(`Invalid line: ${num}`);
-        console.log(`Invalid line: ${num}, content: ${content}`);
-    }
-}

package/src/js/parsers/espresso.ts

@@ -1,29 +0,0 @@
-import { MaterialEnhancedSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
-import { map } from "lodash";
-import s from "underscore.string";
-
-import { Lattice } from "../lattice/lattice";
-import xyz from "./xyz";
-
-/**
- * Construct textual representation of a materialOrConfig according to Quantum ESPRESSO pw.x input format.
- */
-function toEspressoFormat(materialOrConfig: MaterialSchema | MaterialEnhancedSchema): string {
-    const l = new Lattice(materialOrConfig.lattice);
-    const vectors = l.vectorArrays;
-    const vectorsAsString = map(vectors, (v) => {
-        return `${s.sprintf("%14.9f", v[0])}\t${s.sprintf("%14.9f", v[1])}\t${s.sprintf(
-            "%14.9f",
-            v[2],
-        )}`;
-    }).join("\n");
-    return s.sprintf(
-        "CELL_PARAMETERS (angstroms)\n%s\n\nATOMIC_POSITIONS (crystal)\n%s",
-        vectorsAsString,
-        xyz.fromMaterial(materialOrConfig),
-    );
-}
-
-export default {
-    toEspressoFormat,
-};

package/src/js/parsers/native_format_parsers.ts

@@ -1,52 +0,0 @@
-import type { MaterialConfig } from "../Material";
-import Poscar from "./poscar";
-
-const NATIVE_FORMAT = {
-    JSON: "json",
-    POSCAR: "poscar",
-    CIF: "cif",
-    PWX: "pwx",
-    XYZ: "xyz",
-    UNKNOWN: "unknown",
-} as const;
-
-/**
- * @summary Detects the format of the input string
- * @throws If the input string is unknown format
- * @param text input string to detect format
- * @returns Format of the input string
- */
-function detectFormat(text: string) {
-    const jsonRegex = /^\s*\{/;
-    if (jsonRegex.test(text)) return NATIVE_FORMAT.JSON;
-    if (Poscar.isPoscar(text)) return NATIVE_FORMAT.POSCAR;
-
-    return NATIVE_FORMAT.UNKNOWN;
-}
-
-/**
- * @summary Function to handle conversion from native formats
- * @param text - input string to detect format and convert
- * @throws If the input string is of unknown format
- * @return Material config
- */
-function convertFromNativeFormat(text: string): MaterialConfig {
-    const format = detectFormat(text);
-
-    switch (format) {
-        case NATIVE_FORMAT.JSON:
-            return JSON.parse(text);
-        case NATIVE_FORMAT.POSCAR:
-            return Poscar.fromPoscar(text);
-        case NATIVE_FORMAT.UNKNOWN:
-            throw new Error(`Unknown format`);
-        // TODO:  add more formats
-        default:
-            throw new Error(`Unsupported format: ${format}`);
-    }
-}
-
-export default {
-    detectFormat,
-    convertFromNativeFormat,
-};

package/src/js/parsers/parsers.ts

@@ -1,13 +0,0 @@
-import cif from "./cif";
-import espresso from "./espresso";
-import nativeFormatParsers from "./native_format_parsers";
-import poscar from "./poscar";
-import xyz from "./xyz";
-
-export default {
-    xyz,
-    poscar,
-    cif,
-    espresso,
-    nativeFormatParsers,
-};

package/src/js/parsers/poscar.ts

@@ -1,218 +0,0 @@
-import {
-    BasisSchema,
-    Coordinate3DSchema,
-    MaterialEnhancedSchema,
-    MaterialSchema,
-    Vector3DSchema,
-} from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import s from "underscore.string";
-
-import { ConstrainedBasis } from "../basis/constrained_basis";
-import { AtomicCoordinateValue } from "../basis/coordinates";
-import { AtomicElementValue } from "../basis/elements";
-import { Cell } from "../cell/cell";
-import { ATOMIC_COORD_UNITS } from "../constants";
-import { AtomicConstraintValue } from "../constraints/constraints";
-import { Lattice } from "../lattice/lattice";
-import type { MaterialConfig } from "../Material";
-
-const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, Utils.math.precise(x));
-const _latticeVectorsToString = (vectors: Vector3DSchema[]) =>
-    vectors.map((v) => v.map((c) => _print(c)).join("\t")).join("\n");
-const atomicConstraintsCharFromBool = (bool: boolean): string => (bool ? "T" : "F");
-
-/**
- * Obtain a textual representation of a material in POSCAR format.
- * @param materialOrConfig - material class instance or config object.
- * @param omitConstraints - whether to discard constraints when serializing.
- */
-function toPoscar(
-    materialOrConfig: MaterialSchema | MaterialEnhancedSchema,
-    omitConstraints = false,
-): string {
-    const lattice = new Lattice(materialOrConfig.lattice);
-    const vectorsAsString = _latticeVectorsToString(lattice.vectorArrays);
-    const constraints =
-        "constraints" in materialOrConfig.basis ? materialOrConfig.basis.constraints : [];
-    const basis = new ConstrainedBasis({
-        ...materialOrConfig.basis,
-        cell: Cell.fromVectorsArray(lattice.vectorArrays),
-        constraints: omitConstraints ? [] : constraints,
-    });
-    const BasisLines: string[] = [];
-    let addSelectiveDynamics = false;
-    basis._elements.values.forEach((item, idx) => {
-        const coord = basis.getCoordinateValueByIndex(idx).map((x) => _print(x));
-        const constraintsAsString = omitConstraints
-            ? ""
-            : basis.AtomicConstraints.getAsStringByIndex(idx, atomicConstraintsCharFromBool);
-        if (constraintsAsString && !omitConstraints) addSelectiveDynamics = true;
-        BasisLines.push([coord.join(" "), constraintsAsString, item].join(" "));
-    });
-    const basisContent = BasisLines.join("\n");
-    const elementsLine = basis.elementCounts.map((e) => e.value).join(" ");
-    const countsLine = basis.elementCounts.map((e) => parseInt(`${e.count}`, 10)).join(" ");
-    const coordsType =
-        materialOrConfig.basis.units === ATOMIC_COORD_UNITS.cartesian ? "cartesian" : "direct";
-
-    return [
-        materialOrConfig.name,
-        "1.0",
-        vectorsAsString,
-        elementsLine,
-        countsLine,
-        // add selective dynamics only if there are some constraints!
-        ...(addSelectiveDynamics ? ["Selective dynamics"] : []),
-        coordsType,
-        basisContent,
-    ].join("\n");
-}
-
-/**
- * @summary calculates the number of atoms in a poscar file based on the summation of the numbers in line 7 of the file.
- * Poscar file formatting: https://www.vasp.at/wiki/index.php/POSCAR
- */
-export function atomsCount(poscarFileContent: string): number {
-    const lines = Utils.str.removeCommentsFromSourceCode(poscarFileContent).split("\n");
-    const atomsLine = lines[6].split(/\s+/);
-    return atomsLine.map((x) => parseInt(x, 10)).reduce((a, b) => a + b);
-}
-
-/**
- * Parses POSCAR file into a Material config object.
- * @param fileContent - POSCAR file content.
- * @return Material config.
- */
-function fromPoscar(fileContent: string): MaterialConfig {
-    const cleanContent = Utils.str.removeCommentsFromSourceCode(fileContent, "fortran");
-    const lines = cleanContent.split("\n");
-
-    const comment = lines[0];
-    // TODO: alat should be handled!!!!
-    // const latticeConstant = parseFloat(lines[1].trim());
-
-    // Atom symbols and counts
-    const atomSymbols = lines[5].trim().split(/\s+/);
-    const atomCounts = lines[6].trim().split(/\s+/).map(Number);
-
-    // Check if selective dynamics and coordinates type is used
-    let selectiveDynamics = false;
-    let coordinateType = "";
-    let startLine = 7;
-    if (lines[startLine].trim()[0].toLowerCase() === "s") {
-        selectiveDynamics = true;
-        coordinateType = lines[8].trim()[0].toLowerCase();
-        startLine = 9;
-    } else {
-        coordinateType = lines[7].trim()[0].toLowerCase();
-        startLine = 8;
-    }
-
-    const elements = atomSymbols
-        .map((symbol: string, i: number): string[] => Array(atomCounts[i]).fill(symbol))
-        .reduce((a, b) => a.concat(b), []) as AtomicElementValue[];
-
-    // Atom coordinates and constraints
-    const coordinates: AtomicCoordinateValue[] = [];
-    const constraints: AtomicConstraintValue[] = [];
-    let atomIndex = 0;
-    for (let i = 0; i < atomSymbols.length; i++) {
-        for (let j = 0; j < atomCounts[i]; j++) {
-            const lineComponents = lines[startLine + atomIndex].trim().split(/\s+/);
-            const coordinate: AtomicCoordinateValue = [
-                parseFloat(lineComponents[0]),
-                parseFloat(lineComponents[1]),
-                parseFloat(lineComponents[2]),
-            ];
-            coordinates.push(coordinate as Coordinate3DSchema);
-
-            // Add constraints if selective dynamics is used
-            if (selectiveDynamics) {
-                const constraint: AtomicConstraintValue = [
-                    lineComponents[3] === "T",
-                    lineComponents[4] === "T",
-                    lineComponents[5] === "T",
-                ];
-                constraints.push(constraint);
-            }
-            atomIndex += 1;
-        }
-    }
-
-    const lattice = Lattice.fromVectorsArray([
-        lines[2].trim().split(/\s+/).map(Number) as Vector3DSchema,
-        lines[3].trim().split(/\s+/).map(Number) as Vector3DSchema,
-        lines[4].trim().split(/\s+/).map(Number) as Vector3DSchema,
-    ]);
-
-    const basis = ConstrainedBasis.fromElementsCoordinatesAndConstraints({
-        elements,
-        coordinates,
-        units:
-            coordinateType === "c"
-                ? (ATOMIC_COORD_UNITS.cartesian as BasisSchema["units"])
-                : (ATOMIC_COORD_UNITS.crystal as BasisSchema["units"]),
-        cell: Cell.fromVectorsArray(lattice.vectorArrays),
-        constraints,
-    });
-
-    const materialConfig: MaterialConfig = {
-        lattice: lattice.toJSON(),
-        basis: basis.toJSON(),
-        name: comment,
-        isNonPeriodic: false,
-    };
-
-    return materialConfig;
-}
-
-/**
- * @summary Checks if a string has a POSCAR format (first 8 lines are read)
- * @param text - string to check
- */
-function isPoscar(text: string): boolean {
-    const lines = Utils.str.removeCommentsFromSourceCode(text, "fortran").split("\n");
-
-    // Checking number of lines, minimum requirement for POSCAR
-    if (lines.length < 7) {
-        return false;
-    }
-
-    // Check the lattice constant (a single floating point number)
-    if (!/^[+-]?[\d.]+$/.test(lines[1].trim())) {
-        return false;
-    }
-
-    // Check the lattice vectors (three lines, each with three floating point numbers)
-    for (let i = 2; i <= 4; i++) {
-        if (!/^[-+]?\d*\.\d+\s+[-+]?\d*\.\d+\s+[-+]?\d*\.\d+$/.test(lines[i].trim())) {
-            return false;
-        }
-    }
-
-    // Check the atomic species line (alphabetic characters, space-separated)
-    if (!/^[a-zA-Z\s]+$/.test(lines[5].trim())) {
-        return false;
-    }
-
-    // Check the number of atoms per species line (digits, space-separated)
-    if (!/^[\d\s]+$/.test(lines[6].trim())) {
-        return false;
-    }
-
-    // Check the coordinate type line (only first character is neccessary, "s" or "S" for "Selective dynamics",
-    // "d" or "D" for "Direct", or "c" or "C" for "Cartesian")
-    if (!/^[sdc]/.test(lines[7].trim().toLowerCase())) {
-        return false;
-    }
-    return true;
-}
-
-export default {
-    isPoscar,
-    toPoscar,
-    fromPoscar,
-    atomicConstraintsCharFromBool,
-    atomsCount,
-};

package/src/js/parsers/xyz.ts

@@ -1,190 +0,0 @@
-import { MaterialEnhancedSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
-import { isEmpty, isNaN, map } from "lodash";
-import s from "underscore.string";
-
-import { ConstrainedBasis, ConstrainedBasisConfig } from "../basis/constrained_basis";
-import { AtomicCoordinateValue } from "../basis/coordinates";
-import { AtomicElementValue } from "../basis/elements";
-import { Cell } from "../cell/cell";
-import { AtomicConstraintValue } from "../constraints/constraints";
-import { Lattice } from "../lattice/lattice";
-import { InvalidLineError } from "./errors";
-import { CombinatorialBasis } from "./xyz_combinatorial_basis";
-
-// Regular expression for an XYZ line with atomic constraints, eg. Si    0.000000    0.500000    0.446678 1 1 1`
-// eslint-disable-next-line max-len
-const XYZ_LINE_REGEX =
-    /[A-Z][a-z]?(\d)?\s+((-?\d+\.?\d*|\.\d+)\s+(-?\d+\.?\d*|\.\d+)\s+(-?\d+\.?\d*|\.\d+)(\s+)?(\s+[0-1]\s+[0-1]\s+[0-1](\s+)?)?)$/;
-
-export const XYZ_COORDINATE_PRECISION = 4;
-/**
- * Validates XYZ file's line. Line should be in following format "Si 0.5 0.5 0.5".
- * Raises an error if line is in wrong format.
- */
-function validateLine(xyzLine: string, index: number) {
-    const words = xyzLine.split(" ").filter((x) => x.trim() !== "");
-
-    if (!xyzLine.match(XYZ_LINE_REGEX)) {
-        throw new InvalidLineError(index, xyzLine);
-    }
-
-    const coordinates = [parseFloat(words[1]), parseFloat(words[2]), parseFloat(words[3])];
-    coordinates.forEach((num, i) => {
-        if (isNaN(num)) {
-            throw new Error(`Coordinates should be a number. Possible error in ${i} coordinate`);
-        }
-    });
-}
-
-/**
- * Validates that passed string is well-formed XYZ file.
- */
-export function validate(xyzTxt: string) {
-    // The @types/underscore.string package does not provide interfaces for function chaining at the moment. Disable TS here
-    // @ts-ignore
-    s(xyzTxt)
-        .trim()
-        .lines()
-        .filter((x: string) => x.trim() !== "")
-        .forEach(validateLine);
-}
-
-export interface ParsedObject {
-    element: AtomicElementValue;
-    coordinate: AtomicCoordinateValue;
-    constraints: AtomicConstraintValue;
-    label?: number;
-}
-
-/**
- * Parses XYZ line and returns an object.
- * @param line - line of text
- */
-function _parseXYZLineAsWords(line: string): ParsedObject {
-    const words = s.words(line);
-    const elementWithOptionalLabel = words[0];
-    const element = elementWithOptionalLabel.replace(/\d$/, "") as AtomicElementValue; // Fe1 => Fe
-    const generateConstraintValue = (n: number) => parseInt(`${n}`, 10) !== 0;
-
-    const basisLineConfig: ParsedObject = {
-        element,
-        coordinate: [+words[1], +words[2], +words[3]],
-        // Below maps zero values to false (atom is fixed) and non-zero values to true (atom is moving)
-        constraints: [
-            generateConstraintValue(+words[4]),
-            generateConstraintValue(+words[5]),
-            generateConstraintValue(+words[6]),
-        ],
-    };
-
-    if (elementWithOptionalLabel !== element) {
-        return {
-            ...basisLineConfig,
-            label: parseInt(elementWithOptionalLabel[elementWithOptionalLabel.length - 1], 10),
-        };
-    }
-
-    return basisLineConfig;
-}
-
-/**
- * Parse XYZ text for basis.
- * @param txt Text
- * @param units Coordinate units
- * @param cell Basis Cell
- */
-function toBasisConfig(txt: string, units = "angstrom", cell = new Cell()): ConstrainedBasisConfig {
-    // @ts-ignore
-    const lines: string[] = s(txt).trim().lines();
-    const listOfObjects = map(lines, _parseXYZLineAsWords);
-
-    const basisConfig = {
-        elements: listOfObjects.map((elm, idx) => {
-            return {
-                id: idx,
-                value: elm.element,
-            };
-        }),
-        coordinates: listOfObjects.map((elm, idx) => {
-            return {
-                id: idx,
-                value: elm.coordinate,
-            };
-        }),
-        units,
-        cell,
-        constraints: listOfObjects.map((elm, idx) => {
-            return {
-                id: idx,
-                value: elm.constraints,
-            };
-        }),
-    };
-
-    const labels: {
-        id: number;
-        value: number;
-    }[] = [];
-
-    listOfObjects.forEach((elm, idx) => {
-        if (elm.label) {
-            labels.push({
-                id: idx,
-                value: elm.label,
-            });
-        }
-    });
-
-    if (!isEmpty(labels)) {
-        return {
-            ...basisConfig,
-            labels,
-        } as ConstrainedBasisConfig;
-    }
-
-    return basisConfig as ConstrainedBasisConfig;
-}
-
-/**
- * Create XYZ from Basis class instance.
- * @param basisClsInstance Basis class instance.
- * @param coordinatePrintFormat Output format for coordinates.
- * @return Basis string in XYZ format
- */
-function fromBasis(basisClsInstance: ConstrainedBasis, coordinatePrintFormat: string): string {
-    const XYZArray = basisClsInstance.getAtomicPositionsWithConstraintsAsStrings(
-        coordinatePrintFormat,
-        XYZ_COORDINATE_PRECISION,
-    );
-    return `${XYZArray.join("\n")}\n`;
-}
-
-/**
- * Create XYZ from Material class instance (or its JSON config).
- * Prefer fromBasis when you already have a ConstrainedBasis instance.
- */
-function fromMaterial(
-    materialOrConfig: MaterialSchema | MaterialEnhancedSchema,
-    fractional = false,
-): string {
-    const lattice = new Lattice(materialOrConfig.lattice);
-    const constraints =
-        "constraints" in materialOrConfig.basis ? materialOrConfig.basis.constraints : [];
-    const basis = new ConstrainedBasis({
-        ...materialOrConfig.basis,
-        cell: Cell.fromVectorsArray(lattice.vectorArrays),
-        constraints,
-    });
-    if (fractional) {
-        basis.toCrystal();
-    }
-    return fromBasis(basis, "%11.6f");
-}
-
-export default {
-    validate,
-    fromMaterial,
-    toBasisConfig,
-    fromBasis,
-    CombinatorialBasis,
-};