@mat3ra/wode 2025.10.1-0

package/src/context/providers.js

@@ -0,0 +1,140 @@
+import context from "./context";
+
+const {
+    BoundaryConditionsFormDataProvider,
+    MLSettingsContextProvider,
+    MLTrainTestSplitContextProvider,
+    NEBFormDataProvider,
+    PlanewaveCutoffsContextProvider,
+    PointsGridFormDataProvider,
+    PointsPathFormDataProvider,
+    ExplicitPointsPathFormDataProvider,
+    ExplicitPointsPath2PIBAFormDataProvider,
+    HubbardJContextProvider,
+    HubbardUContextProvider,
+    HubbardVContextProvider,
+    HubbardContextProviderLegacy,
+    IonDynamicsContextProvider,
+    CollinearMagnetizationContextProvider,
+    NonCollinearMagnetizationContextProvider,
+    VASPContextProvider,
+    VASPNEBContextProvider,
+    QEPWXContextProvider,
+    QENEBContextProvider,
+    NWChemTotalEnergyContextProvider,
+} = context;
+
+const CONTEXT_DOMAINS = {
+    important: "important", // used to generate `ImportantSettings` form
+};
+
+const _makeImportant = (config) => Object.assign(config, { domain: CONTEXT_DOMAINS.important });
+
+/** ********************************
+ * Method-based context providers *
+ ********************************* */
+
+export const wodeProviders = {
+    // NOTE: subworkflow-level data manager. Will override the unit-level data with the same name via subworkflow context.
+    PlanewaveCutoffDataManager: {
+        providerCls: PlanewaveCutoffsContextProvider,
+        config: _makeImportant({ name: "cutoffs", entityName: "subworkflow" }),
+    },
+    KGridFormDataManager: {
+        providerCls: PointsGridFormDataProvider,
+        config: _makeImportant({ name: "kgrid" }),
+    },
+    QGridFormDataManager: {
+        providerCls: PointsGridFormDataProvider,
+        config: _makeImportant({ name: "qgrid", divisor: 5 }), // Using less points for Qgrid by default
+    },
+    IGridFormDataManager: {
+        providerCls: PointsGridFormDataProvider,
+        config: _makeImportant({ name: "igrid", divisor: 0.2 }), // Using more points for interpolated grid by default
+    },
+    QPathFormDataManager: {
+        providerCls: PointsPathFormDataProvider,
+        config: _makeImportant({ name: "qpath" }),
+    },
+    IPathFormDataManager: {
+        providerCls: PointsPathFormDataProvider,
+        config: _makeImportant({ name: "ipath" }),
+    },
+    KPathFormDataManager: {
+        providerCls: PointsPathFormDataProvider,
+        config: _makeImportant({ name: "kpath" }),
+    },
+    ExplicitKPathFormDataManager: {
+        providerCls: ExplicitPointsPathFormDataProvider,
+        config: _makeImportant({ name: "explicitKPath" }),
+    },
+    ExplicitKPath2PIBAFormDataManager: {
+        providerCls: ExplicitPointsPath2PIBAFormDataProvider,
+        config: _makeImportant({ name: "explicitKPath2PIBA" }),
+    },
+    HubbardJContextManager: {
+        providerCls: HubbardJContextProvider,
+        config: _makeImportant({ name: "hubbard_j" }),
+    },
+    HubbardUContextManager: {
+        providerCls: HubbardUContextProvider,
+        config: _makeImportant({ name: "hubbard_u" }),
+    },
+    HubbardVContextManager: {
+        providerCls: HubbardVContextProvider,
+        config: _makeImportant({ name: "hubbard_v" }),
+    },
+    HubbardContextManagerLegacy: {
+        providerCls: HubbardContextProviderLegacy,
+        config: _makeImportant({ name: "hubbard_legacy" }),
+    },
+    // NEBFormDataManager context is stored under the same key (`input`) as InputDataManager contexts.
+    NEBFormDataManager: {
+        providerCls: NEBFormDataProvider,
+        config: _makeImportant({ name: "neb" }),
+    },
+    BoundaryConditionsFormDataManager: {
+        providerCls: BoundaryConditionsFormDataProvider,
+        config: _makeImportant({ name: "boundaryConditions" }),
+    },
+    MLSettingsDataManager: {
+        providerCls: MLSettingsContextProvider,
+        config: _makeImportant({ name: "mlSettings" }),
+    },
+    MLTrainTestSplitDataManager: {
+        providerCls: MLTrainTestSplitContextProvider,
+        config: _makeImportant({ name: "mlTrainTestSplit" }),
+    },
+    IonDynamicsContextProvider: {
+        providerCls: IonDynamicsContextProvider,
+        config: _makeImportant({ name: "dynamics" }),
+    },
+    CollinearMagnetizationDataManager: {
+        providerCls: CollinearMagnetizationContextProvider,
+        config: _makeImportant({ name: "collinearMagnetization" }),
+    },
+    NonCollinearMagnetizationDataManager: {
+        providerCls: NonCollinearMagnetizationContextProvider,
+        config: _makeImportant({ name: "nonCollinearMagnetization" }),
+    },
+    QEPWXInputDataManager: {
+        providerCls: QEPWXContextProvider,
+        config: { name: "input" },
+    },
+    QENEBInputDataManager: {
+        providerCls: QENEBContextProvider,
+        config: { name: "input" },
+    },
+    VASPInputDataManager: {
+        providerCls: VASPContextProvider,
+        config: { name: "input" },
+    },
+    VASPNEBInputDataManager: {
+        providerCls: VASPNEBContextProvider,
+        config: { name: "input" },
+    },
+    NWChemInputDataManager: {
+        providerCls: NWChemTotalEnergyContextProvider,
+        config: { name: "input" },
+    },
+};

package/src/enums.js

@@ -0,0 +1,65 @@
+/**
+ * THIS ENUMS ARE SHARED WITH TESTS.
+ * DO NOT IMPORT ANYTHINGS IN THIS MODULE.
+ */
+
+export const IO_ID_COLUMN = "exabyteId";
+
+export const UNIT_TYPES = {
+    // not currently used
+    convergence: "convergence",
+    exit: "exit",
+    // actively used
+    execution: "execution",
+    map: "map",
+    reduce: "reduce",
+    assignment: "assignment",
+    condition: "condition",
+    subworkflow: "subworkflow",
+    processing: "processing",
+    io: "io",
+    assertion: "assertion",
+};
+
+export const UNIT_STATUSES = {
+    idle: "idle",
+    active: "active",
+    finished: "finished",
+    error: "error",
+    warning: "warning",
+};
+
+export const UNIT_TAGS = {
+    hasConvergenceParam: "hasConvergenceParam",
+    hasConvergenceResult: "hasConvergenceResult",
+};
+
+export const WORKFLOW_STATUSES = {
+    "up-to-date": "up-to-date",
+    outdated: "outdated",
+};
+
+export const TAB_NAVIGATION_CONFIG = {
+    overview: {
+        itemName: "Overview",
+        className: "",
+        href: "sw-overview",
+    },
+    importantSettings: {
+        itemName: "Important settings",
+        className: "",
+        href: "sw-important-settings",
+    },
+    detailedView: {
+        itemName: "Detailed view",
+        className: "",
+        href: "sw-detailed-view",
+    },
+    compute: {
+        itemName: "Compute",
+        className: "",
+        href: "sw-compute",
+    },
+};
+
+export const UNIT_NAME_INVALID_CHARS = "/";

package/src/index.js

@@ -0,0 +1,17 @@
+import { UNIT_STATUSES, UNIT_TYPES } from "./enums";
+import { createSubworkflowByName, Subworkflow } from "./subworkflows";
+import { builders } from "./units/builders";
+import { UnitFactory } from "./units/factory";
+import { createWorkflowConfigs, createWorkflows, Workflow } from "./workflows";
+
+export {
+    Subworkflow,
+    Workflow,
+    createWorkflows,
+    createWorkflowConfigs,
+    createSubworkflowByName,
+    UnitFactory,
+    builders,
+    UNIT_TYPES,
+    UNIT_STATUSES,
+};

package/src/patch.js

@@ -0,0 +1,12 @@
+import { Template } from "@exabyte-io/ade.js";
+
+import { wodeProviders } from "./context/providers";
+
+// We patch the static providerRegistry here so that
+// Template has all context providers available
+// to it when creating workflows. It is then re-exported
+// from WoDe for use downstream.
+
+Template.setContextProvidersConfig(wodeProviders);
+
+export { Template };

package/src/subworkflows/convergence/factory.js

@@ -0,0 +1,14 @@
+import { NonUniformKGridConvergence } from "./non_uniform_kgrid";
+import { ConvergenceParameter } from "./parameter";
+import { UniformKGridConvergence } from "./uniform_kgrid";
+
+export function createConvergenceParameter({ name, initialValue, increment }) {
+    switch (name) {
+        case "N_k":
+            return new UniformKGridConvergence({ name, initialValue, increment });
+        case "N_k_nonuniform":
+            return new NonUniformKGridConvergence({ name, initialValue, increment });
+        default:
+            return new ConvergenceParameter({ name, initialValue, increment });
+    }
+}

package/src/subworkflows/convergence/non_uniform_kgrid.js

@@ -0,0 +1,28 @@
+import { ConvergenceParameter } from "./parameter";
+
+export class NonUniformKGridConvergence extends ConvergenceParameter {
+    get increment() {
+        return `[${this.initialValue}[i] + math.floor(iteration * ${this._increment} * float(context['kgrid']['reciprocalVectorRatios'][i])) for i in range(3)]`;
+    }
+
+    get unitContext() {
+        return {
+            kgrid: {
+                dimensions: [`{{${this.name}[0]}}`, `{{${this.name}[1]}}`, `{{${this.name}[2]}}`],
+                shifts: [0, 0, 0],
+            },
+            isKgridEdited: true,
+            isUsingJinjaVariables: true,
+        };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    useVariablesFromUnitContext(flowchartId) {
+        return [
+            {
+                scope: flowchartId,
+                name: "context",
+            },
+        ];
+    }
+}

package/src/subworkflows/convergence/parameter.js

@@ -0,0 +1,58 @@
+/* eslint-disable class-methods-use-this */
+import lodash from "lodash";
+
+export class ConvergenceParameter {
+    constructor({ name, initialValue, increment }) {
+        this.name = name;
+        this._initialValue = initialValue;
+        this._increment = increment;
+    }
+
+    /**
+     * Getter for initial value as string.
+     * Note: this will be used in assignment unit.
+     * @return {string}
+     */
+    get initialValue() {
+        if (!lodash.isString(this._initialValue)) {
+            return JSON.stringify(this._initialValue);
+        }
+        return this._initialValue;
+    }
+
+    /**
+     * @summary Defines how to increment the parameter.
+     * @return {string} - increment operation used in assignment unit
+     */
+    get increment() {
+        return ""; // overwrite in derived class
+    }
+
+    /**
+     * Defines content for updating the unit context
+     * @return {Object}
+     */
+    get unitContext() {
+        return {};
+    }
+
+    /**
+     * Defines value once convergence is reached (for 'exit' unit).
+     * Note: This is used in assignment unit and most often the variable will be assigned to itself.
+     * @return {string}
+     */
+    get finalValue() {
+        return `${this.name}`;
+    }
+
+    /**
+     * Create list of  variables to fetch from a unit.
+     * Note: this is used for the `input` field for an assignment unit.
+     * @param {string} flowchartId - flowchartId of unit containing context variables
+     * @return {Object|{scope, name}}
+     */
+    // eslint-disable-next-line class-methods-use-this, no-unused-vars
+    useVariablesFromUnitContext(flowchartId) {
+        return [];
+    }
+}

package/src/subworkflows/convergence/uniform_kgrid.js

@@ -0,0 +1,22 @@
+import { ConvergenceParameter } from "./parameter";
+
+export class UniformKGridConvergence extends ConvergenceParameter {
+    get increment() {
+        return `${this.name} + ${this._increment}`;
+    }
+
+    get unitContext() {
+        return {
+            kgrid: {
+                dimensions: [`{{${this.name}}}`, `{{${this.name}}}`, `{{${this.name}}}`],
+                shifts: [0, 0, 0],
+            },
+            isKgridEdited: true,
+            isUsingJinjaVariables: true,
+        };
+    }
+
+    get finalValue() {
+        return `${this.name} + 0`;
+    }
+}

package/src/subworkflows/convergence.js

@@ -0,0 +1,196 @@
+import merge from "lodash/merge";
+
+import { UNIT_TAGS, UNIT_TYPES } from "../enums";
+import { createConvergenceParameter } from "./convergence/factory";
+
+export const ConvergenceMixin = (superclass) =>
+    class extends superclass {
+        get convergenceParam() {
+            return this.findUnitWithTag("hasConvergenceParam")?.operand || undefined;
+        }
+
+        get convergenceResult() {
+            return this.findUnitWithTag("hasConvergenceResult")?.operand || undefined;
+        }
+
+        convergenceSeries(scopeTrack) {
+            if (!this.hasConvergence || !scopeTrack?.length) return [];
+            let lastResult;
+            const series = scopeTrack
+                .map((scopeItem, i) => ({
+                    x: i,
+                    param: scopeItem.scope?.global[this.convergenceParam],
+                    y: scopeItem.scope?.global[this.convergenceResult],
+                }))
+                .filter(({ y }) => {
+                    const isNewResult = y !== undefined && y !== lastResult;
+                    lastResult = y;
+                    return isNewResult;
+                });
+            return series.map((item, i) => {
+                return {
+                    x: i + 1,
+                    param: item.param,
+                    y: item.y,
+                };
+            });
+        }
+
+        addConvergence({
+            parameter,
+            parameterInitial,
+            parameterIncrement,
+            result,
+            resultInitial,
+            condition,
+            operator,
+            tolerance,
+            maxOccurrences,
+        }) {
+            // RF: added TODO comments for future improvements
+
+            const { units } = this;
+            // Find unit to converge: should contain passed result in its results list
+            // TODO: make user to select unit for convergence explicitly
+            const unitForConvergence = units.find((x) =>
+                x.resultNames.find((name) => name === result),
+            );
+
+            if (!unitForConvergence) {
+                // eslint-disable-next-line no-undef
+                sAlert.error(
+                    `Subworkflow does not contain unit with '${result}' as extracted property.`,
+                );
+                throw new Error("There is no result to converge");
+            }
+
+            // initialize parameter
+            const param = createConvergenceParameter({
+                name: parameter,
+                initialValue: parameterInitial,
+                increment: parameterIncrement,
+            });
+
+            // Replace kgrid to be ready for convergence
+            // TODO: kgrid should be abstracted and selected by user
+            const providers = unitForConvergence.importantSettingsProviders;
+            const gridProvider = providers.find((p) => p.name === "kgrid" || p.name === "qgrid");
+            let mergedContext = param.unitContext;
+            if (gridProvider) {
+                mergedContext = merge(gridProvider.yieldData(), param.unitContext);
+                gridProvider.setData(mergedContext);
+                gridProvider.setIsEdited(true);
+            }
+            unitForConvergence.updateContext(mergedContext);
+
+            const prevResult = "prev_result";
+            const iteration = "iteration";
+
+            // Assignment with result's initial value
+            const prevResultInit = this._UnitFactory.create({
+                name: "init result",
+                type: UNIT_TYPES.assignment,
+                head: true,
+                operand: prevResult,
+                value: resultInitial,
+            });
+
+            // Assignment with initial value of convergence parameter
+            const paramInit = this._UnitFactory.create({
+                name: "init parameter",
+                type: UNIT_TYPES.assignment,
+                operand: param.name,
+                value: param.initialValue,
+                tags: [UNIT_TAGS.hasConvergenceParam],
+            });
+
+            // Assignment with initial value of iteration counter
+            const iterInit = this._UnitFactory.create({
+                name: "init counter",
+                type: UNIT_TYPES.assignment,
+                operand: iteration,
+                value: 1,
+            });
+
+            // Assignment for storing iteration result: extracts 'result' from convergence unit scope
+            const storePrevResult = this._UnitFactory.create({
+                name: "store result",
+                type: UNIT_TYPES.assignment,
+                input: [
+                    {
+                        scope: unitForConvergence.flowchartId,
+                        name: result,
+                    },
+                ],
+                operand: prevResult,
+                value: result,
+            });
+
+            // Assignment for convergence param increase
+            const nextStep = this._UnitFactory.create({
+                name: "update parameter",
+                type: UNIT_TYPES.assignment,
+                input: param.useVariablesFromUnitContext(unitForConvergence.flowchartId),
+                operand: param.name,
+                value: param.increment,
+                next: unitForConvergence.flowchartId,
+            });
+
+            // Final step of convergence
+            const exit = this._UnitFactory.create({
+                type: UNIT_TYPES.assignment,
+                name: "exit",
+                input: [],
+                operand: param.name,
+                value: param.finalValue,
+            });
+
+            // Final step of convergence
+            const storeResult = this._UnitFactory.create({
+                name: "update result",
+                type: UNIT_TYPES.assignment,
+                input: [
+                    {
+                        scope: unitForConvergence.flowchartId,
+                        name: result,
+                    },
+                ],
+                operand: result,
+                value: result,
+                tags: [UNIT_TAGS.hasConvergenceResult],
+            });
+
+            // Assign next iteration value
+            const nextIter = this._UnitFactory.create({
+                name: "update counter",
+                type: UNIT_TYPES.assignment,
+                input: [],
+                operand: iteration,
+                value: `${iteration} + 1`,
+            });
+
+            // Convergence condition unit
+            const conditionUnit = this._UnitFactory.create({
+                name: "check convergence",
+                type: UNIT_TYPES.condition,
+                statement: `${condition} ${operator} ${tolerance}`,
+                then: exit.flowchartId,
+                else: storePrevResult.flowchartId,
+                maxOccurrences,
+                next: storePrevResult.flowchartId,
+            });
+
+            this.addUnit(paramInit, 0);
+            this.addUnit(prevResultInit, 1);
+            this.addUnit(iterInit, 2);
+            this.addUnit(storeResult);
+            this.addUnit(conditionUnit);
+            this.addUnit(storePrevResult);
+            this.addUnit(nextIter);
+            this.addUnit(nextStep);
+            this.addUnit(exit);
+
+            // `addUnit` adjusts the `next` field, hence the below.
+            nextStep.next = unitForConvergence.flowchartId;
+        }
+    };