@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/src/js/context/providers.js

@@ -1,140 +0,0 @@
-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/js/index.js

@@ -1,57 +0,0 @@
-import { wodeProviders } from "./context/providers";
-import { PointsPathFormDataProvider } from "./context/providers/PointsPathFormDataProvider";
-import { globalSettings } from "./context/providers/settings";
-import {
-    TAB_NAVIGATION_CONFIG,
-    UNIT_NAME_INVALID_CHARS,
-    UNIT_STATUSES,
-    UNIT_TYPES,
-    WORKFLOW_STATUSES,
-} from "./enums";
-import { createSubworkflowByName, Subworkflow } from "./subworkflows";
-import {
-    AssertionUnit,
-    AssignmentUnit,
-    BaseUnit,
-    ConditionUnit,
-    ExecutionUnit,
-    IOUnit,
-    MapUnit,
-    ProcessingUnit,
-    ReduceUnit,
-    SubworkflowUnit,
-} from "./units";
-import { builders } from "./units/builders";
-import { UnitFactory } from "./units/factory";
-import { defaultMapConfig } from "./units/map";
-import { createWorkflow, createWorkflowConfigs, createWorkflows, Workflow } from "./workflows";
-
-export {
-    Subworkflow,
-    Workflow,
-    createWorkflow,
-    createWorkflows,
-    createWorkflowConfigs,
-    createSubworkflowByName,
-    UnitFactory,
-    builders,
-    UNIT_TYPES,
-    UNIT_STATUSES,
-    TAB_NAVIGATION_CONFIG,
-    UNIT_NAME_INVALID_CHARS,
-    WORKFLOW_STATUSES,
-    BaseUnit,
-    ExecutionUnit,
-    AssertionUnit,
-    AssignmentUnit,
-    ConditionUnit,
-    IOUnit,
-    MapUnit,
-    ProcessingUnit,
-    ReduceUnit,
-    SubworkflowUnit,
-    defaultMapConfig,
-    wodeProviders,
-    PointsPathFormDataProvider,
-    globalSettings,
-};

package/src/js/patch.js

@@ -1,12 +0,0 @@
-import { Template } from "@mat3ra/ade";
-
-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/js/subworkflows/convergence/enums.js

@@ -1,12 +0,0 @@
-import schemas from "@mat3ra/esse/dist/js/schemas.json";
-
-const convergenceEnumOptionsSchema = schemas.find(
-    (schema) => schema.$id === "workflow/subworkflow/convergence/enum-options",
-);
-const values = convergenceEnumOptionsSchema?.definitions?.ConvergenceParameterNameEnum?.enum || [];
-
-export const ConvergenceParameterName = Object.freeze({
-    N_k: values[0] || "N_k",
-    N_k_nonuniform: values[1] || "N_k_nonuniform",
-    N_k_nonuniform_2D: values[2] || "N_k_nonuniform_2D",
-});

package/src/js/subworkflows/convergence/factory.js

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

package/src/js/subworkflows/convergence/non_uniform_kgrid.js

@@ -1,28 +0,0 @@
-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/js/subworkflows/convergence/parameter.js

@@ -1,58 +0,0 @@
-/* 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/js/subworkflows/convergence/uniform_kgrid.js

@@ -1,22 +0,0 @@
-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/js/subworkflows/convergence.js

@@ -1,196 +0,0 @@
-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;
-        }
-    };