@mat3ra/wode 2025.10.1-0

package/src/context/providers/PointsPathFormDataProvider.js

@@ -0,0 +1,165 @@
+/* eslint-disable max-classes-per-file */
+/* eslint react/prop-types: 0 */
+import JSONSchemaFormDataProvider from "@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider";
+import { math as codeJSMath } from "@mat3ra/code/dist/js/math";
+import { Made } from "@mat3ra/made";
+import s from "underscore.string";
+
+import { applicationContextMixin } from "../mixins/ApplicationContextMixin";
+import { materialContextMixin } from "../mixins/MaterialContextMixin";
+
+const defaultPoint = "Г";
+const defaultSteps = 10;
+
+export class PointsPathFormDataProvider extends JSONSchemaFormDataProvider {
+    constructor(config) {
+        super(config);
+        this.initMaterialContextMixin();
+        this.initApplicationContextMixin();
+        this.reciprocalLattice = new Made.ReciprocalLattice(this.material.lattice);
+        this.symmetryPoints = this.symmetryPointsFromMaterial;
+    }
+
+    get isEditedIsSetToFalseOnMaterialUpdate() {
+        return this.isMaterialUpdated || this.isMaterialCreatedDefault;
+    }
+
+    get defaultData() {
+        return this.reciprocalLattice.defaultKpointPath;
+    }
+
+    get symmetryPointsFromMaterial() {
+        return this.reciprocalLattice.symmetryPoints;
+    }
+
+    get jsonSchema() {
+        // no need to pass context to get symmetry points on client
+        const points = [].concat(this.symmetryPoints).map((x) => x.point);
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: " ",
+            description: "path in reciprocal space",
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    point: {
+                        type: "string",
+                        default: defaultPoint,
+                        enum: points,
+                    },
+                    steps: {
+                        type: "integer",
+                        default: defaultSteps,
+                    },
+                },
+            },
+            minItems: 1,
+        };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get uiSchema() {
+        return {
+            items: {},
+        };
+    }
+
+    get uiSchemaStyled() {
+        return {
+            items: {
+                point: this.defaultFieldStyles,
+                steps: this.defaultFieldStyles,
+            },
+        };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get templates() {
+        return {};
+    }
+
+    getBrillouinZoneImageComponent(title) {
+        const hasRequiredFn = typeof this.material.getBrillouinZoneImageComponent === "function";
+        if (!hasRequiredFn) {
+            console.log(
+                "PointsPathFormDataProvider: Material class has no function" +
+                    " 'getBrillouinZoneImageComponent'! Returning empty Object instead.",
+            );
+            return null;
+        }
+        return this.material.getBrillouinZoneImageComponent(title);
+    }
+
+    get useExplicitPath() {
+        return this.application.name === "vasp";
+    }
+
+    // override yieldData to avoid storing explicit path in saved context
+    yieldDataForRendering() {
+        return this.yieldData(this.useExplicitPath);
+    }
+
+    transformData(path = [], useExplicitPath = false) {
+        const rawData = path.map((p) => {
+            const point = this.symmetryPoints.find((sp) => sp.point === p.point);
+            return { ...p, coordinates: point.coordinates };
+        });
+        const processedData = useExplicitPath ? this._convertToExplicitPath(rawData) : rawData;
+        // make coordinates into string and add formatting
+        return processedData.map((p) => {
+            const coordinates = this.is2PIBA
+                ? this.get2PIBACoordinates(p.coordinates)
+                : p.coordinates;
+            p.coordinates = coordinates.map((c) => s.sprintf("%14.9f", c));
+            return p;
+        });
+    }
+
+    get2PIBACoordinates(point) {
+        return this.reciprocalLattice.getCartesianCoordinates(point);
+    }
+
+    // Initially, path contains symmetry points with steps counts.
+    // This function explicitly calculates each point between symmetry points by step counts.
+    // eslint-disable-next-line class-methods-use-this
+    _convertToExplicitPath(path) {
+        const points = [];
+        for (let i = 0; i < path.length - 1; i++) {
+            const startPoint = path[i];
+            const endPoint = path[i + 1];
+            const middlePoints = codeJSMath.calculateSegmentsBetweenPoints3D(
+                startPoint.coordinates,
+                endPoint.coordinates,
+                startPoint.steps,
+            );
+            points.push(startPoint.coordinates);
+            points.push(...middlePoints);
+            // Include endPoint into path for the last section, otherwise it will be included by next loop iteration
+            if (path.length - 2 === i) points.push(endPoint.coordinates);
+        }
+        return points.map((x) => {
+            return {
+                coordinates: x,
+                steps: 1,
+            };
+        });
+    }
+}
+
+export class ExplicitPointsPathFormDataProvider extends PointsPathFormDataProvider {
+    // eslint-disable-next-line class-methods-use-this
+    get useExplicitPath() {
+        return true;
+    }
+}
+
+export class ExplicitPointsPath2PIBAFormDataProvider extends ExplicitPointsPathFormDataProvider {
+    // eslint-disable-next-line class-methods-use-this
+    get is2PIBA() {
+        return true;
+    }
+}
+
+materialContextMixin(PointsPathFormDataProvider.prototype);
+applicationContextMixin(PointsPathFormDataProvider.prototype);

package/src/context/providers/by_application/ExecutableContextProvider.js

@@ -0,0 +1,10 @@
+import ContextProvider from "@exabyte-io/ade.js/dist/js/context/ContextProvider";
+
+export default class ExecutableContextProvider extends ContextProvider {
+    constructor(config) {
+        super({
+            ...config,
+            domain: "executable",
+        });
+    }
+}

package/src/context/providers/by_application/espresso/QENEBContextProvider.js

@@ -0,0 +1,56 @@
+import lodash from "lodash";
+
+import { jobContextMixin } from "../../../mixins/JobContextMixin";
+import { materialContextMixin } from "../../../mixins/MaterialContextMixin";
+import { materialsContextMixin } from "../../../mixins/MaterialsContextMixin";
+import { materialsSetContextMixin } from "../../../mixins/MaterialsSetContextMixin";
+import { methodDataContextMixin } from "../../../mixins/MethodDataContextMixin";
+import { workflowContextMixin } from "../../../mixins/WorkflowContextMixin";
+import ExecutableContextProvider from "../ExecutableContextProvider";
+import QEPWXContextProvider from "./QEPWXContextProvider";
+
+export default class QENEBContextProvider extends ExecutableContextProvider {
+    _material = undefined;
+
+    _materials = [];
+
+    _materialsSet = undefined;
+
+    constructor(config) {
+        super(config);
+        this.initJobContextMixin();
+        this.initMaterialsContextMixin();
+        this.initMethodDataContextMixin();
+        this.initWorkflowContextMixin();
+        this.initMaterialContextMixin();
+        this.initMaterialsSetContextMixin();
+    }
+
+    getData() {
+        const sortedMaterials = this.sortMaterialsByIndexInSet(this.materials);
+        const PWXContexts = sortedMaterials.map((material) => {
+            const context = { ...this.config.context, material };
+            const config = { ...this.config, context };
+            return new QEPWXContextProvider(config).getData();
+        });
+
+        return {
+            ...lodash.omit(PWXContexts[0], [
+                "ATOMIC_POSITIONS",
+                "ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS",
+            ]),
+            FIRST_IMAGE: PWXContexts[0].ATOMIC_POSITIONS,
+            LAST_IMAGE: PWXContexts[PWXContexts.length - 1].ATOMIC_POSITIONS,
+            INTERMEDIATE_IMAGES: PWXContexts.slice(1, PWXContexts.length - 1).map(
+                (data) => data.ATOMIC_POSITIONS,
+            ),
+        };
+    }
+}
+
+materialContextMixin(QENEBContextProvider.prototype);
+materialsContextMixin(QENEBContextProvider.prototype);
+methodDataContextMixin(QENEBContextProvider.prototype);
+workflowContextMixin(QENEBContextProvider.prototype);
+jobContextMixin(QENEBContextProvider.prototype);
+materialsSetContextMixin(QENEBContextProvider.prototype);

package/src/context/providers/by_application/espresso/QEPWXContextProvider.js

@@ -0,0 +1,166 @@
+import { PERIODIC_TABLE } from "@exabyte-io/periodic-table.js";
+import path from "path";
+import s from "underscore.string";
+
+import { jobContextMixin } from "../../../mixins/JobContextMixin";
+import { materialContextMixin } from "../../../mixins/MaterialContextMixin";
+import { materialsContextMixin } from "../../../mixins/MaterialsContextMixin";
+import { methodDataContextMixin } from "../../../mixins/MethodDataContextMixin";
+import { workflowContextMixin } from "../../../mixins/WorkflowContextMixin";
+import ExecutableContextProvider from "../ExecutableContextProvider";
+
+export default class QEPWXContextProvider extends ExecutableContextProvider {
+    _material = undefined;
+
+    _materials = [];
+
+    constructor(config) {
+        super(config);
+        this.initMaterialsContextMixin();
+        this.initMethodDataContextMixin();
+        this.initWorkflowContextMixin();
+        this.initJobContextMixin();
+        this.initMaterialContextMixin();
+    }
+
+    static atomSymbols(material) {
+        return material.Basis.uniqueElements;
+    }
+
+    static uniqueElementsWithLabels(material) {
+        // return unique items
+        return [...new Set(material.Basis.elementsWithLabelsArray)];
+    }
+
+    /** Returns the input text block for atomic positions WITH constraints.
+     */
+    static atomicPositionsWithConstraints(material) {
+        return material.Basis.getAtomicPositionsWithConstraintsAsStrings().join("\n");
+    }
+
+    /** Returns the input text block for atomic positions
+     *  Note: does NOT include constraints
+     */
+    static atomicPositions(material) {
+        return material.Basis.atomicPositions.join("\n");
+    }
+
+    static NAT(material) {
+        return material.Basis.atomicPositions.length;
+    }
+
+    static NTYP(material) {
+        return material.Basis.uniqueElements.length;
+    }
+
+    static NTYP_WITH_LABELS(material) {
+        return this.uniqueElementsWithLabels(material).length;
+    }
+
+    buildQEPWXContext(material) {
+        const IBRAV = 0; // use CELL_PARAMETERS to define Bravais lattice
+
+        return {
+            IBRAV,
+            RESTART_MODE: this.RESTART_MODE,
+            ATOMIC_SPECIES: this.ATOMIC_SPECIES(material),
+            ATOMIC_SPECIES_WITH_LABELS: this.ATOMIC_SPECIES_WITH_LABELS(material),
+            NAT: QEPWXContextProvider.NAT(material),
+            NTYP: QEPWXContextProvider.NTYP(material),
+            NTYP_WITH_LABELS: QEPWXContextProvider.NTYP_WITH_LABELS(material),
+            ATOMIC_POSITIONS: QEPWXContextProvider.atomicPositionsWithConstraints(material),
+            ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: QEPWXContextProvider.atomicPositions(material),
+            CELL_PARAMETERS: QEPWXContextProvider.CELL_PARAMETERS(material),
+        };
+    }
+
+    getDataPerMaterial() {
+        if (!this.materials || this.materials.length <= 1) return {};
+        return { perMaterial: this.materials.map((material) => this.buildQEPWXContext(material)) };
+    }
+
+    /*
+     * @NOTE: Overriding getData makes this provider "stateless", ie. delivering data from scratch each time and not
+     *        considering the content of `this.data`, and `this.isEdited` field(s).
+     */
+    getData() {
+        // the below values are read from PlanewaveDataManager instead
+        // ECUTWFC = 40;
+        // ECUTRHO = 200;
+
+        return {
+            ...this.buildQEPWXContext(this.material),
+            ...this.getDataPerMaterial(),
+        };
+    }
+
+    get RESTART_MODE() {
+        return this.job.parentJob || this.workflow.hasRelaxation ? "restart" : "from_scratch";
+    }
+
+    getPseudoBySymbol(symbol) {
+        return (this.methodData.pseudo || []).find((p) => p.element === symbol);
+    }
+
+    /** Builds ATOMIC SPECIES block of pw.x input in the format
+     *  X   Mass_X   PseudoPot_X
+     *  where X            is the atom label
+     *        Mass_X       is the mass of element X [amu]
+     *        PseudoPot_X  is the pseudopotential filename associated with element X
+     *
+     *  Note: assumes this.methodData is defined
+     */
+    ATOMIC_SPECIES(material) {
+        return QEPWXContextProvider.atomSymbols(material)
+            .map((symbol) => {
+                const pseudo = this.getPseudoBySymbol(symbol);
+                return QEPWXContextProvider.symbolToAtomicSpecie(symbol, pseudo);
+            })
+            .join("\n");
+    }
+
+    ATOMIC_SPECIES_WITH_LABELS(material) {
+        return QEPWXContextProvider.uniqueElementsWithLabels(material)
+            .map((symbol) => {
+                const symbolWithoutLabel = symbol.replace(/\d$/, "");
+                const label = symbol.match(/\d$/g) ? symbol.match(/\d$/g)?.[0] : "";
+                const pseudo = this.getPseudoBySymbol(symbolWithoutLabel);
+                return QEPWXContextProvider.elementAndPseudoToAtomicSpecieWithLabels(
+                    symbolWithoutLabel,
+                    pseudo,
+                    label,
+                );
+            })
+            .join("\n");
+    }
+
+    static CELL_PARAMETERS(material) {
+        return material.Lattice.vectorArrays
+            .map((x) => {
+                return x
+                    .map((y) => {
+                        return s.sprintf("%14.9f", y).trim();
+                    })
+                    .join(" ");
+            })
+            .join("\n");
+    }
+
+    static symbolToAtomicSpecie(symbol, pseudo) {
+        const el = PERIODIC_TABLE[symbol];
+        const filename = pseudo?.filename || path.basename(pseudo?.path || "");
+        return s.sprintf("%s %f %s", symbol, el.atomic_mass, filename) || "";
+    }
+
+    static elementAndPseudoToAtomicSpecieWithLabels(symbol, pseudo, label = "") {
+        const el = PERIODIC_TABLE[symbol];
+        const filename = pseudo?.filename || path.basename(pseudo?.path || "");
+        return s.sprintf("%s%s %f %s", symbol, label, el.atomic_mass, filename) || "";
+    }
+}
+
+materialContextMixin(QEPWXContextProvider.prototype);
+materialsContextMixin(QEPWXContextProvider.prototype);
+methodDataContextMixin(QEPWXContextProvider.prototype);
+workflowContextMixin(QEPWXContextProvider.prototype);
+jobContextMixin(QEPWXContextProvider.prototype);

package/src/context/providers/by_application/nwchem/NWChemTotalEnergyContextProvider.js

@@ -0,0 +1,86 @@
+import { PERIODIC_TABLE } from "@exabyte-io/periodic-table.js";
+import lodash from "lodash";
+import _ from "underscore";
+import s from "underscore.string";
+
+import { jobContextMixin } from "../../../mixins/JobContextMixin";
+import { materialContextMixin } from "../../../mixins/MaterialContextMixin";
+import { methodDataContextMixin } from "../../../mixins/MethodDataContextMixin";
+import { workflowContextMixin } from "../../../mixins/WorkflowContextMixin";
+import ExecutableContextProvider from "../ExecutableContextProvider";
+
+export default class NWChemTotalEnergyContextProvider extends ExecutableContextProvider {
+    _material = undefined;
+
+    constructor(config) {
+        super(config);
+        this.initMethodDataContextMixin();
+        this.initWorkflowContextMixin();
+        this.initJobContextMixin();
+        this.initMaterialContextMixin();
+    }
+
+    get atomicPositionsWithoutConstraints() {
+        return this.material.Basis.atomicPositions;
+    }
+
+    get atomicPositions() {
+        const basis = this.material.Basis;
+        basis.toCartesian();
+        return basis.getAtomicPositionsWithConstraintsAsStrings();
+    }
+
+    get atomSymbols() {
+        return this.material.Basis.uniqueElements;
+    }
+
+    get cartesianAtomicPositions() {
+        return this.material.Basis.toCartesian !== undefined;
+    }
+
+    get ATOMIC_SPECIES() {
+        return _.map(this.atomSymbols, (symbol) => {
+            return NWChemTotalEnergyContextProvider.symbolToAtomicSpecies(symbol);
+        }).join("\n");
+    }
+
+    /*
+     * @NOTE: Overriding getData makes this provider "stateless", ie. delivering data from scratch each time and not
+     *        considering the content of `this.data`, and `this.isEdited` field(s).
+     */
+    getData() {
+        /*
+        TODO: Create ability for user to define CHARGE, MULT, BASIS and FUNCTIONAL parameters.
+         */
+        const CHARGE = 0;
+        const MULT = 1;
+        const BASIS = "6-31G";
+        const FUNCTIONAL = "B3LYP";
+
+        return {
+            CHARGE,
+            MULT,
+            BASIS,
+            NAT: this.atomicPositions.length,
+            NTYP: this.atomSymbols.length,
+            ATOMIC_POSITIONS: this.atomicPositions.join("\n"),
+            ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: this.atomicPositionsWithoutConstraints.join("\n"),
+            ATOMIC_SPECIES: this.ATOMIC_SPECIES,
+            FUNCTIONAL,
+            CARTESIAN: this.cartesianAtomicPositions,
+        };
+    }
+
+    static symbolToAtomicSpecies(symbol, pseudo) {
+        const el = PERIODIC_TABLE[symbol];
+        const filename = pseudo
+            ? lodash.get(pseudo, "filename", s.strRightBack(pseudo.path || "", "/"))
+            : "";
+        return el ? s.sprintf("%s %f %s", symbol, el.atomic_mass, filename) : undefined;
+    }
+}
+
+materialContextMixin(NWChemTotalEnergyContextProvider.prototype);
+methodDataContextMixin(NWChemTotalEnergyContextProvider.prototype);
+workflowContextMixin(NWChemTotalEnergyContextProvider.prototype);
+jobContextMixin(NWChemTotalEnergyContextProvider.prototype);

package/src/context/providers/by_application/vasp/VASPContextProvider.js

@@ -0,0 +1,56 @@
+import { jobContextMixin } from "../../../mixins/JobContextMixin";
+import { materialContextMixin } from "../../../mixins/MaterialContextMixin";
+import { materialsContextMixin } from "../../../mixins/MaterialsContextMixin";
+import { methodDataContextMixin } from "../../../mixins/MethodDataContextMixin";
+import { workflowContextMixin } from "../../../mixins/WorkflowContextMixin";
+import ExecutableContextProvider from "../ExecutableContextProvider";
+
+export default class VASPContextProvider extends ExecutableContextProvider {
+    _material = undefined;
+
+    _materials = [];
+
+    constructor(config) {
+        super(config);
+        this.initJobContextMixin();
+        this.initMaterialsContextMixin();
+        this.initMethodDataContextMixin();
+        this.initWorkflowContextMixin();
+        this.initMaterialContextMixin();
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    buildVASPContext(material) {
+        return {
+            // TODO: figure out whether we need two separate POSCARS, maybe one is enough
+            POSCAR: material.getAsPOSCAR(true, true),
+            POSCAR_WITH_CONSTRAINTS: material.getAsPOSCAR(true),
+        };
+    }
+
+    getDataPerMaterial() {
+        if (!this.materials || this.materials.length <= 1) return {};
+        return { perMaterial: this.materials.map((material) => this.buildVASPContext(material)) };
+    }
+
+    /*
+     * @NOTE: Overriding getData makes this provider "stateless", ie. delivering data from scratch each time and not
+     *        considering the content of `this.data`, and `this.isEdited` field(s).
+     */
+    getData() {
+        // consider adjusting so that below values are read from PlanewaveDataManager
+        // ECUTWFC;
+        // ECUTRHO;
+
+        return {
+            ...this.buildVASPContext(this.material),
+            ...this.getDataPerMaterial(),
+        };
+    }
+}
+
+materialContextMixin(VASPContextProvider.prototype);
+materialsContextMixin(VASPContextProvider.prototype);
+methodDataContextMixin(VASPContextProvider.prototype);
+workflowContextMixin(VASPContextProvider.prototype);
+jobContextMixin(VASPContextProvider.prototype);

package/src/context/providers/by_application/vasp/VASPNEBContextProvider.js

@@ -0,0 +1,46 @@
+import { jobContextMixin } from "../../../mixins/JobContextMixin";
+import { materialContextMixin } from "../../../mixins/MaterialContextMixin";
+import { materialsContextMixin } from "../../../mixins/MaterialsContextMixin";
+import { materialsSetContextMixin } from "../../../mixins/MaterialsSetContextMixin";
+import { methodDataContextMixin } from "../../../mixins/MethodDataContextMixin";
+import { workflowContextMixin } from "../../../mixins/WorkflowContextMixin";
+import ExecutableContextProvider from "../ExecutableContextProvider";
+import VASPContextProvider from "./VASPContextProvider";
+
+export default class VASPNEBContextProvider extends ExecutableContextProvider {
+    _materials = [];
+
+    constructor(config) {
+        super(config);
+        this.initMaterialContextMixin();
+        this.initMaterialsContextMixin();
+        this.initMaterialsSetContextMixin();
+        this.initMethodDataContextMixin();
+        this.initWorkflowContextMixin();
+        this.initJobContextMixin();
+    }
+
+    getData() {
+        const sortedMaterials = this.sortMaterialsByIndexInSet(this.materials);
+        const VASPContexts = sortedMaterials.map((material) => {
+            const context = { ...this.config.context, material };
+            const config = { ...this.config, context };
+            return new VASPContextProvider(config).getData();
+        });
+
+        return {
+            FIRST_IMAGE: VASPContexts[0].POSCAR_WITH_CONSTRAINTS,
+            LAST_IMAGE: VASPContexts[VASPContexts.length - 1].POSCAR_WITH_CONSTRAINTS,
+            INTERMEDIATE_IMAGES: VASPContexts.slice(1, VASPContexts.length - 1).map(
+                (data) => data.POSCAR_WITH_CONSTRAINTS,
+            ),
+        };
+    }
+}
+
+materialContextMixin(VASPNEBContextProvider.prototype);
+materialsContextMixin(VASPNEBContextProvider.prototype);
+materialsSetContextMixin(VASPNEBContextProvider.prototype);
+methodDataContextMixin(VASPNEBContextProvider.prototype);
+workflowContextMixin(VASPNEBContextProvider.prototype);
+jobContextMixin(VASPNEBContextProvider.prototype);

package/src/context/providers/settings.js

@@ -0,0 +1,38 @@
+import { Application } from "@exabyte-io/ade.js";
+import { Made } from "@mat3ra/made";
+
+class GlobalSettings {
+    "PointsGridFormDataProvider.defaultKPPRA" = 5;
+
+    Material = Made.Material;
+
+    Application = Application;
+
+    constructor() {
+        this.resetDefaults();
+    }
+
+    get defaultKPPRA() {
+        return this["PointsGridFormDataProvider.defaultKPPRA"];
+    }
+
+    setApplication(application) {
+        this.Application = application;
+    }
+
+    setMaterial(material) {
+        this.Material = material;
+    }
+
+    setDefaultKPPRA(kppra) {
+        this["PointsGridFormDataProvider.defaultKPPRA"] = kppra;
+    }
+
+    resetDefaults() {
+        this.Material = Made.Material;
+        this.Application = Application;
+        this["PointsGridFormDataProvider.defaultKPPRA"] = 5;
+    }
+}
+
+export const globalSettings = new GlobalSettings();