@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/src/js/context/providers/by_application/vasp/VASPInputDataManager.ts

@@ -0,0 +1,89 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { InputContextItemSchema, VASPContextProviderSchema } from "@mat3ra/esse/dist/js/types";
+import type { Material } from "@mat3ra/made";
+import type { JSONSchema7 } from "json-schema";
+
+import materialContextMixin, {
+    type MaterialContextMixin,
+    type MaterialExternalContext,
+} from "../../../mixins/MaterialContextMixin";
+import materialsContextMixin, {
+    type MaterialsContextMixin,
+    type MaterialsExternalContext,
+} from "../../../mixins/MaterialsContextMixin";
+import type { UnitContext } from "../../base/ContextProvider";
+import JSONSchemaDataProvider, {
+    type JinjaExternalContext,
+} from "../../base/JSONSchemaDataProvider";
+
+type Data = VASPContextProviderSchema;
+type Schema = InputContextItemSchema & { data: Data };
+type ExternalContext = JinjaExternalContext & MaterialExternalContext & MaterialsExternalContext;
+
+interface VASPInputDataManager extends MaterialContextMixin, MaterialsContextMixin {}
+
+const jsonSchemaId = "context-providers-directory/by-application/vasp-context-provider";
+
+class VASPInputDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "input" as const;
+
+    readonly domain = "executable" as const;
+
+    readonly entityName = "unit" as const;
+
+    isEdited = false;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "input");
+
+        return new VASPInputDataManager(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(config: Partial<Schema>, externalContext: ExternalContext) {
+        super(config, externalContext);
+        this.initMaterialsContextMixin(externalContext);
+        this.initMaterialContextMixin(externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getSchemaById(jsonSchemaId);
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    private buildVASPContext(material: Material): Data {
+        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),
+            contextProviderName: "vasp" as const,
+        };
+    }
+
+    private getDataPerMaterial() {
+        if (!this.materials || this.materials.length <= 1) return {};
+
+        return { perMaterial: this.materials.map((material) => this.buildVASPContext(material)) };
+    }
+
+    getDefaultData() {
+        // consider adjusting so that below values are read from PlanewaveDataManager
+        // ECUTWFC;
+        // ECUTRHO;
+
+        return {
+            ...this.buildVASPContext(this.material),
+            ...this.getDataPerMaterial(),
+        };
+    }
+}
+
+materialContextMixin(VASPInputDataManager.prototype);
+materialsContextMixin(VASPInputDataManager.prototype);
+
+export default VASPInputDataManager;

package/src/js/context/providers/by_application/vasp/VASPNEBInputDataManager.ts

@@ -0,0 +1,92 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    InputContextItemSchema,
+    VASPNEBContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import materialContextMixin, {
+    type MaterialContextMixin,
+    type MaterialExternalContext,
+} from "../../../mixins/MaterialContextMixin";
+import materialsContextMixin, {
+    type MaterialsContextMixin,
+    type MaterialsExternalContext,
+} from "../../../mixins/MaterialsContextMixin";
+import materialsSetContextMixin, {
+    type MaterialsSetContextMixin,
+    type MaterialsSetExternalContext,
+} from "../../../mixins/MaterialsSetContextMixin";
+import type { UnitContext } from "../../base/ContextProvider";
+import JSONSchemaDataProvider, {
+    type JinjaExternalContext,
+} from "../../base/JSONSchemaDataProvider";
+import VASPInputDataManager from "./VASPInputDataManager";
+
+type Data = VASPNEBContextProviderSchema;
+type Schema = InputContextItemSchema & { data: Data };
+type ExternalContext = JinjaExternalContext &
+    MaterialExternalContext &
+    MaterialsExternalContext &
+    MaterialsSetExternalContext;
+
+interface VASPNEBInputDataManager
+    extends MaterialContextMixin,
+        MaterialsContextMixin,
+        MaterialsSetContextMixin {}
+
+const jsonSchemaId = "context-providers-directory/by-application/vasp-neb-context-provider";
+
+class VASPNEBInputDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "input" as const;
+
+    readonly domain = "executable" as const;
+
+    readonly entityName = "unit" as const;
+
+    isEdited = false;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "input");
+
+        return new VASPNEBInputDataManager(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(config: Partial<Schema>, externalContext: ExternalContext) {
+        super(config, externalContext);
+        this.initMaterialContextMixin(externalContext);
+        this.initMaterialsContextMixin(externalContext);
+        this.initMaterialsSetContextMixin(externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getSchemaById(jsonSchemaId);
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData() {
+        const VASPContexts = this.sortMaterialsByIndexInSet(this.materials).map((material) => {
+            return new VASPInputDataManager({}, { ...this.externalContext, material }).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) => {
+                return data.POSCAR_WITH_CONSTRAINTS;
+            }),
+            contextProviderName: "vasp-neb" as const,
+        };
+    }
+}
+
+materialContextMixin(VASPNEBInputDataManager.prototype);
+materialsContextMixin(VASPNEBInputDataManager.prototype);
+materialsSetContextMixin(VASPNEBInputDataManager.prototype);
+
+export default VASPNEBInputDataManager;

package/src/js/context/providers/index.ts

@@ -0,0 +1,155 @@
+import type { AssignmentUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import type { ApplicationExternalContext } from "../mixins/ApplicationContextMixin";
+import type { MaterialExternalContext } from "../mixins/MaterialContextMixin";
+import type { MaterialsExternalContext } from "../mixins/MaterialsContextMixin";
+import type { MaterialsSetExternalContext } from "../mixins/MaterialsSetContextMixin";
+import type { UnitContext } from "./base/ContextProvider";
+import type { JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+import BoundaryConditionsFormDataManager from "./BoundaryConditionsFormDataManager";
+import QENEBInputDataManager from "./by_application/espresso/QENEBInputDataManager";
+import QEPWXInputDataManager, {
+    type JobExternalContext,
+    type MethodDataExternalContext,
+    type WorkflowExternalContext,
+} from "./by_application/espresso/QEPWXInputDataManager";
+import NWChemInputDataManager from "./by_application/nwchem/NWChemInputDataManager";
+import VASPInputDataManager from "./by_application/vasp/VASPInputDataManager";
+import VASPNEBInputDataManager from "./by_application/vasp/VASPNEBInputDataManager";
+import CollinearMagnetizationDataManager from "./CollinearMagnetizationDataManager";
+import HubbardContextManagerLegacy from "./Hubbard/HubbardContextManagerLegacy";
+import HubbardJContextManager from "./Hubbard/HubbardJContextManager";
+import HubbardUContextManager from "./Hubbard/HubbardUContextManager";
+import HubbardVContextManager from "./Hubbard/HubbardVContextManager";
+import IonDynamicsDataManager from "./IonDynamicsDataManager";
+import MLSettingsDataManager from "./MLSettingsDataManager";
+import MLTrainTestSplitDataManager from "./MLTrainTestSplitDataManager";
+import NEBFormDataManager from "./NEBFormDataManager";
+import NonCollinearMagnetizationDataManager from "./NonCollinearMagnetizationDataManager";
+import PlanewaveCutoffDataManager from "./PlanewaveCutoffDataManager";
+import IGridFormDataManager from "./PointsGrid/IGridFormDataManager";
+import KGridFormDataManager from "./PointsGrid/KGridFormDataManager";
+import QGridFormDataManager from "./PointsGrid/QGridFormDataManager";
+import ExplicitKPath2PIBAFormDataManager from "./PointsPath/ExplicitKPath2PIBAFormDataManager";
+import ExplicitKPathFormDataManager from "./PointsPath/ExplicitKPathFormDataManager";
+import IPathFormDataManager from "./PointsPath/IPathFormDataManager";
+import KPathFormDataManager from "./PointsPath/KPathFormDataManager";
+import QPathFormDataManager from "./PointsPath/QPathFormDataManager";
+
+/**
+ * Registry mapping provider names (as they appear in templates) to their classes.
+ * This is the single source of truth for provider mappings.
+ */
+export const PROVIDER_REGISTRY = {
+    PlanewaveCutoffDataManager,
+    KGridFormDataManager,
+    QGridFormDataManager,
+    IGridFormDataManager,
+    QPathFormDataManager,
+    IPathFormDataManager,
+    KPathFormDataManager,
+    ExplicitKPathFormDataManager,
+    ExplicitKPath2PIBAFormDataManager,
+    HubbardJContextManager,
+    HubbardUContextManager,
+    HubbardVContextManager,
+    HubbardContextManagerLegacy,
+    NEBFormDataManager,
+    BoundaryConditionsFormDataManager,
+    MLSettingsDataManager,
+    MLTrainTestSplitDataManager,
+    IonDynamicsContextProvider: IonDynamicsDataManager, // Note: name mismatch preserved from original
+    CollinearMagnetizationDataManager,
+    NonCollinearMagnetizationDataManager,
+    QEPWXInputDataManager,
+    QENEBInputDataManager,
+    VASPInputDataManager,
+    VASPNEBInputDataManager,
+    NWChemInputDataManager,
+} as const;
+
+export type AssignmentContext = Record<
+    AssignmentUnitSchema["operand"],
+    AssignmentUnitSchema["value"]
+>;
+
+export type SubworkflowContext = {
+    subworkflowContext: AssignmentContext;
+};
+
+/**
+ * External context type used by ExecutionUnitInput when creating providers.
+ * This type is always expected to be present when providers are instantiated.
+ */
+export type ExternalContext = ApplicationExternalContext &
+    WorkflowExternalContext &
+    JobExternalContext &
+    MaterialsExternalContext &
+    MethodDataExternalContext &
+    MaterialsSetExternalContext &
+    MaterialExternalContext &
+    JinjaExternalContext &
+    SubworkflowContext;
+
+/**
+ * Type for provider names as they appear in templates.
+ */
+export type ProviderName = keyof typeof PROVIDER_REGISTRY;
+
+/**
+ * Union type of all context provider instances.
+ * Derived from the registry for type safety.
+ */
+export type AnyContextProvider = InstanceType<(typeof PROVIDER_REGISTRY)[ProviderName]>;
+
+/**
+ * Factory function to create a context provider instance from its name.
+ *
+ * @param name - The provider name as it appears in templates
+ * @param context - The unit context
+ * @param externalContext - The external context (must match the ExternalContext type defined in this file)
+ * @returns An instance of the requested context provider
+ * @throws Error if the provider name is unknown
+ */
+export function createProvider(
+    name: ProviderName,
+    context: UnitContext,
+    externalContext: ExternalContext,
+): AnyContextProvider {
+    const ProviderClass = PROVIDER_REGISTRY[name];
+    if (!ProviderClass) {
+        throw new Error(`Unknown provider: ${name}`);
+    }
+    // The full ExternalContext is a superset of each provider's expected context type,
+    // so passing it to every provider's createFromUnitContext is type-safe (no assertion).
+    return ProviderClass.createFromUnitContext(context, externalContext);
+}
+
+// Re-export all provider classes for convenience
+export {
+    BoundaryConditionsFormDataManager,
+    QENEBInputDataManager,
+    QEPWXInputDataManager,
+    NWChemInputDataManager,
+    VASPInputDataManager,
+    VASPNEBInputDataManager,
+    CollinearMagnetizationDataManager,
+    HubbardContextManagerLegacy,
+    HubbardJContextManager,
+    HubbardUContextManager,
+    HubbardVContextManager,
+    IonDynamicsDataManager,
+    MLSettingsDataManager,
+    MLTrainTestSplitDataManager,
+    NEBFormDataManager,
+    NonCollinearMagnetizationDataManager,
+    PlanewaveCutoffDataManager,
+    IGridFormDataManager,
+    KGridFormDataManager,
+    QGridFormDataManager,
+    ExplicitKPath2PIBAFormDataManager,
+    ExplicitKPathFormDataManager,
+    IPathFormDataManager,
+    KPathFormDataManager,
+    QPathFormDataManager,
+};

package/src/js/context/providers/settings.ts

@@ -0,0 +1,13 @@
+class GlobalSettings {
+    "PointsGridFormDataProvider.defaultKPPRA" = 5;
+
+    get defaultKPPRA() {
+        return this["PointsGridFormDataProvider.defaultKPPRA"];
+    }
+
+    setDefaultKPPRA(kppra: number) {
+        this["PointsGridFormDataProvider.defaultKPPRA"] = kppra;
+    }
+}
+
+export const globalSettings = new GlobalSettings();

package/src/js/convergence/ConvergenceParameter.ts

@@ -0,0 +1,37 @@
+interface ConvergenceParameterProps {
+    initialValue: number | [number, number, number];
+}
+
+export type ConvergenceParameterConfig = ConvergenceParameterProps & {
+    increment?: string | number;
+};
+
+export type UnitContext = {
+    data: {
+        dimensions: [string, string, string];
+        shifts: [0, 0, 0];
+    };
+    isUsingJinjaVariables: true;
+};
+
+export default abstract class ConvergenceParameter {
+    abstract readonly name: "N_k" | "N_k_nonuniform";
+
+    abstract readonly finalValue: string;
+
+    abstract readonly increment: string;
+
+    abstract readonly unitContext: UnitContext;
+
+    readonly initialValue: string;
+
+    constructor({ initialValue }: ConvergenceParameterProps) {
+        this.initialValue =
+            typeof initialValue === "string" ? initialValue : JSON.stringify(initialValue);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+    useVariablesFromUnitContext(_flowchartId: string): { scope: string; name: string }[] {
+        return [];
+    }
+}

package/src/js/convergence/NonUniformKGridConvergence.ts

@@ -0,0 +1,38 @@
+import ConvergenceParameter, {
+    type ConvergenceParameterConfig,
+    type UnitContext,
+} from "./ConvergenceParameter";
+
+export default class NonUniformKGridConvergence extends ConvergenceParameter {
+    readonly increment: string;
+
+    readonly name = "N_k_nonuniform" as const;
+
+    readonly finalValue = "N_k_nonuniform" as const;
+
+    readonly unitContext: UnitContext = {
+        data: {
+            dimensions: [`{{${this.name}[0]}}`, `{{${this.name}[1]}}`, `{{${this.name}[2]}}`],
+            shifts: [0, 0, 0],
+        },
+        isUsingJinjaVariables: true,
+    };
+
+    constructor({ initialValue, increment }: ConvergenceParameterConfig) {
+        super({ initialValue });
+
+        this.increment = `[${this.initialValue}[i] + math.floor(iteration * ${
+            increment || ""
+        } * float(context['kgrid']['reciprocalVectorRatios'][i])) for i in range(3)]`;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    useVariablesFromUnitContext(flowchartId: string) {
+        return [
+            {
+                scope: flowchartId,
+                name: "context",
+            },
+        ];
+    }
+}

package/src/js/convergence/UniformKGridConvergence.ts

@@ -0,0 +1,26 @@
+import ConvergenceParameter, {
+    type ConvergenceParameterConfig,
+    type UnitContext,
+} from "./ConvergenceParameter";
+
+export default class UniformKGridConvergence extends ConvergenceParameter {
+    readonly increment: string;
+
+    readonly name = "N_k" as const;
+
+    readonly finalValue = `${this.name} + 0` as const;
+
+    readonly unitContext: UnitContext = {
+        data: {
+            dimensions: [`{{${this.name}}}`, `{{${this.name}}}`, `{{${this.name}}}`],
+            shifts: [0, 0, 0],
+        },
+        isUsingJinjaVariables: true,
+    };
+
+    constructor({ initialValue, increment }: ConvergenceParameterConfig) {
+        super({ initialValue });
+
+        this.increment = `${this.name} + ${increment || ""}`;
+    }
+}

package/src/js/convergence/factory.ts

@@ -0,0 +1,18 @@
+import { type ConvergenceParameterConfig } from "./ConvergenceParameter";
+import NonUniformKGridConvergence from "./NonUniformKGridConvergence";
+import UniformKGridConvergence from "./UniformKGridConvergence";
+
+type FactoryParams = ConvergenceParameterConfig & {
+    name: "N_k" | "N_k_nonuniform";
+};
+
+export function createConvergenceParameter({ name, ...params }: FactoryParams) {
+    switch (name) {
+        case "N_k":
+            return new UniformKGridConvergence(params);
+        case "N_k_nonuniform":
+            return new NonUniformKGridConvergence(params);
+        default:
+            throw new Error(`Invalid convergence parameter name: ${name}`);
+    }
+}

package/src/js/{enums.js → enums.ts}

@@ -1,10 +1,3 @@
-/**
- * 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",
@@ -16,28 +9,40 @@ export const UNIT_TYPES = {
     assignment: "assignment",
     condition: "condition",
     subworkflow: "subworkflow",
-    processing: "processing",
     io: "io",
     assertion: "assertion",
-};
+} as const;
+
+export enum UnitType {
+    convergence = "convergence",
+    exit = "exit",
+    execution = "execution",
+    map = "map",
+    reduce = "reduce",
+    assignment = "assignment",
+    condition = "condition",
+    subworkflow = "subworkflow",
+    io = "io",
+    assertion = "assertion",
+}
 
-export const UNIT_STATUSES = {
-    idle: "idle",
-    active: "active",
-    finished: "finished",
-    error: "error",
-    warning: "warning",
-};
+export enum UnitTag {
+    hasConvergenceParam = "hasConvergenceParam",
+    hasConvergenceResult = "hasConvergenceResult",
+}
 
-export const UNIT_TAGS = {
-    hasConvergenceParam: "hasConvergenceParam",
-    hasConvergenceResult: "hasConvergenceResult",
-};
+export enum UnitStatus {
+    idle = "idle",
+    active = "active",
+    finished = "finished",
+    error = "error",
+    warning = "warning",
+}
 
 export const WORKFLOW_STATUSES = {
     "up-to-date": "up-to-date",
     outdated: "outdated",
-};
+} as const;
 
 export const TAB_NAVIGATION_CONFIG = {
     overview: {
@@ -60,6 +65,6 @@ export const TAB_NAVIGATION_CONFIG = {
         className: "",
         href: "sw-compute",
     },
-};
+} as const;
 
 export const UNIT_NAME_INVALID_CHARS = "/";

package/src/js/generated/AssertionUnitSchemaMixin.ts

@@ -0,0 +1,34 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AssertionUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type AssertionUnitSchemaMixin = AssertionUnitMixinSchema;
+
+export type AssertionUnitInMemoryEntity = InMemoryEntity & AssertionUnitSchemaMixin;
+
+export function assertionUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & AssertionUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & AssertionUnitSchemaMixin = {
+        get type() {
+            return this.prop<AssertionUnitMixinSchema["type"]>("type");
+        },
+        set type(value: AssertionUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get statement() {
+            return this.requiredProp<AssertionUnitMixinSchema["statement"]>("statement");
+        },
+        set statement(value: AssertionUnitMixinSchema["statement"]) {
+            this.setProp("statement", value);
+        },
+        get errorMessage() {
+            return this.prop<AssertionUnitMixinSchema["errorMessage"]>("errorMessage");
+        },
+        set errorMessage(value: AssertionUnitMixinSchema["errorMessage"]) {
+            this.setProp("errorMessage", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/AssignmentUnitSchemaMixin.ts

@@ -0,0 +1,40 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AssignmentUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type AssignmentUnitSchemaMixin = AssignmentUnitMixinSchema;
+
+export type AssignmentUnitInMemoryEntity = InMemoryEntity & AssignmentUnitSchemaMixin;
+
+export function assignmentUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & AssignmentUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & AssignmentUnitSchemaMixin = {
+        get type() {
+            return this.prop<AssignmentUnitMixinSchema["type"]>("type");
+        },
+        set type(value: AssignmentUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get input() {
+            return this.prop<AssignmentUnitMixinSchema["input"]>("input");
+        },
+        set input(value: AssignmentUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+        get operand() {
+            return this.requiredProp<AssignmentUnitMixinSchema["operand"]>("operand");
+        },
+        set operand(value: AssignmentUnitMixinSchema["operand"]) {
+            this.setProp("operand", value);
+        },
+        get value() {
+            return this.requiredProp<AssignmentUnitMixinSchema["value"]>("value");
+        },
+        set value(value: AssignmentUnitMixinSchema["value"]) {
+            this.setProp("value", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}