@mat3ra/made 2024.3.22-0

package/src/js/parsers/espresso.ts

@@ -0,0 +1,30 @@
+import { MaterialSchema } from "@mat3ra/esse/lib/js/types";
+import _ from "underscore";
+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.
+ * @param materialOrConfig - material class instance or its config object
+ */
+function toEspressoFormat(materialOrConfig: MaterialSchema): 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.js

@@ -0,0 +1,51 @@
+import Poscar from "./poscar";
+
+const NATIVE_FORMAT = {
+    JSON: "json",
+    POSCAR: "poscar",
+    CIF: "cif",
+    PWX: "pwx",
+    XYZ: "xyz",
+    UNKNOWN: "unknown",
+};
+
+/**
+ * @summary Detects the format of the input string
+ * @throws {Error} - If the input string is unknown format
+ * @param {string} text -  input string to detect format
+ * @returns {NATIVE_FORMAT} - Format of the input string
+ */
+function detectFormat(text) {
+    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 {String} text - input string to detect format and convert
+ * @throws {Error} - If the input string is of unknown format
+ * @return {Object} - Material config
+ */
+function convertFromNativeFormat(text) {
+    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.js

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,201 @@
+import s from "underscore.string";
+
+import { ConstrainedBasis } from "../basis/constrained_basis";
+import { Coordinate } from "../basis/types";
+import { ATOMIC_COORD_UNITS } from "../constants";
+import { Constraint, ConstraintValue } from "../constraints/constraints";
+import { Lattice } from "../lattice/lattice";
+import { Vector } from "../lattice/types";
+import math from "../math";
+import { MaterialJSON } from "../types";
+
+const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, math.precise(x));
+const _latticeVectorsToString = (vectors: Vector[]) =>
+    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 passed with material.
+ */
+function toPoscar(materialOrConfig: MaterialJSON, omitConstraints = false): string {
+    const lattice = new Lattice(materialOrConfig.lattice);
+    const vectorsAsString = _latticeVectorsToString(lattice.vectorArrays);
+    // @ts-ignore
+    const basis = new ConstrainedBasis({
+        ...materialOrConfig.basis,
+        cell: lattice.vectorArrays,
+    });
+    const BasisLines: string[] = [];
+    let addSelectiveDynamics = false;
+    basis._elements.array.forEach((item, idx) => {
+        const coord = basis.getCoordinateByIndex(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 atomsLine = poscarFileContent.split("\n")[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): object {
+    const lines = fileContent.split("\n");
+
+    const comment = lines[0];
+    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: string[] = atomSymbols
+        .map((symbol: string, i: number): string[] => Array(atomCounts[i]).fill(symbol))
+        .reduce((a, b) => a.concat(b), []);
+
+    // Atom coordinates and constraints
+    const coordinates: Coordinate[] = [];
+    const constraints: Constraint[] = [];
+    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: Coordinate = [
+                parseFloat(lineComponents[0]),
+                parseFloat(lineComponents[1]),
+                parseFloat(lineComponents[2]),
+            ];
+            coordinates.push(coordinate);
+
+            // Add constraints if selective dynamics is used
+            if (selectiveDynamics) {
+                const constraint: ConstraintValue = [
+                    lineComponents[3] === "T",
+                    lineComponents[4] === "T",
+                    lineComponents[5] === "T",
+                ];
+                constraints.push({ id: j, value: constraint });
+            }
+            atomIndex += 1;
+        }
+    }
+
+    const lattice = Lattice.fromVectors({
+        a: lines[2].trim().split(/\s+/).map(Number) as Vector,
+        b: lines[3].trim().split(/\s+/).map(Number) as Vector,
+        c: lines[4].trim().split(/\s+/).map(Number) as Vector,
+        alat: latticeConstant,
+        units: "angstrom",
+    });
+
+    const basis = new ConstrainedBasis({
+        elements,
+        coordinates,
+        units: coordinateType === "c" ? ATOMIC_COORD_UNITS.cartesian : ATOMIC_COORD_UNITS.crystal,
+        cell: lattice.vectorArrays,
+        constraints,
+    });
+
+    const 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 = text.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

@@ -0,0 +1,216 @@
+import { MaterialSchema } from "@mat3ra/esse/lib/js/types";
+import _ from "underscore";
+import s from "underscore.string";
+
+import { Basis } from "../basis/basis";
+import { ConstrainedBasis } from "../basis/constrained_basis";
+import { Constraint } from "../constraints/constraints";
+import { Lattice } from "../lattice/lattice";
+import { Vector } from "../lattice/types";
+import math from "../math";
+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+)?)?)$/;
+
+/**
+ * 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: string;
+    coordinates: Vector;
+    constraints: [boolean, boolean, boolean];
+    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: string = words[0];
+    const element: string = elementWithOptionalLabel.replace(/\d$/, ""); // Fe1 => Fe
+    const constraint = (n: number) => parseInt(`${n}`, 10) !== 0;
+
+    const basisLineConfig: ParsedObject = {
+        element,
+        coordinates: [+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: [constraint(+words[4]), constraint(+words[5]), constraint(+words[6])],
+    };
+
+    if (elementWithOptionalLabel !== element) {
+        return {
+            ...basisLineConfig,
+            label: parseInt(elementWithOptionalLabel[elementWithOptionalLabel.length - 1], 10),
+        };
+    }
+
+    return basisLineConfig;
+}
+
+// TODO: reuse Basis Definition(s) from ESSE/Code.js instead
+export interface BasisConfig {
+    elements: {
+        id: number;
+        value: string;
+    }[];
+    labels?: {
+        id: number;
+        value: number;
+    }[];
+    coordinates: {
+        id: number;
+        value: Vector;
+    }[];
+    units: string;
+    cell: Vector[];
+    constraints: Constraint[];
+}
+
+/**
+ * Parse XYZ text for basis.
+ * @param txt Text
+ * @param units Coordinate units
+ * @param cell Basis Cell
+ */
+function toBasisConfig(txt: string, units = "angstrom", cell = Basis.defaultCell): BasisConfig {
+    // @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.coordinates,
+            };
+        }),
+        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,
+        };
+    }
+
+    return basisConfig;
+}
+
+/**
+ * Create XYZ from Basis class instance.
+ * @param basisClsInstance Basis class instance.
+ * @param printFormat Output format for coordinates.
+ * @param skipRounding Whether to round the numbers (ie. to avoid negative zeros).
+ * @return Basis string in XYZ format
+ */
+function fromBasis(
+    basisClsInstance: ConstrainedBasis,
+    printFormat = "%9.5f",
+    skipRounding = false,
+) {
+    const XYZArray: string[] = [];
+    basisClsInstance._elements.array.forEach((item, idx) => {
+        // assume that _elements and _coordinates are indexed equivalently
+        const atomicLabel = basisClsInstance.atomicLabelsArray[idx];
+        const elementWithLabel = item + atomicLabel;
+        const element = s.sprintf("%-3s", elementWithLabel);
+        const coordinates = basisClsInstance.getCoordinateByIndex(idx).map((x) => {
+            return s.sprintf(printFormat, skipRounding ? x : math.precise(math.roundToZero(x)));
+        });
+        const constraints = basisClsInstance.constraints
+            ? basisClsInstance.AtomicConstraints.getAsStringByIndex(idx)
+            : "";
+        XYZArray.push([element, coordinates.join(" "), constraints].join(" "));
+    });
+    return `${XYZArray.join("\n")}\n`;
+}
+
+/**
+ * Create XYZ from Material class instance (or its JSON config).
+ * @param materialOrConfig Material.
+ * @param fractional Coordinate units as fractional.
+ * @return Class Instance
+ */
+function fromMaterial(materialOrConfig: MaterialSchema, fractional = false): string {
+    const lattice = new Lattice(materialOrConfig.lattice);
+    // @ts-ignore
+    const basis = new ConstrainedBasis({
+        ...materialOrConfig.basis,
+        cell: lattice.vectorArrays,
+    });
+    if (fractional) {
+        basis.toCrystal();
+    }
+    return fromBasis(basis, "%11.6f");
+}
+
+export default {
+    validate,
+    fromMaterial,
+    toBasisConfig,
+    fromBasis,
+    CombinatorialBasis,
+};