@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

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

@@ -0,0 +1,61 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { MlSettingsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import { type UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+
+type Schema = MlSettingsContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+
+const jsonSchemaId = "context-providers-directory/ml-settings-context-provider";
+
+const defaultData = {
+    target_column_name: "target",
+    problem_category: "regression" as const,
+};
+
+class MLSettingsDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "mlSettings" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "mlSettings");
+
+        return new MLSettingsDataManager(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    readonly uiSchema = {
+        target_column_name: {},
+        problem_category: {},
+    } as const;
+
+    readonly extraData = {};
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            target_column_name: { default: defaultData.target_column_name },
+            problem_category: { default: defaultData.problem_category },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}
+
+export default MLSettingsDataManager;

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

@@ -0,0 +1,59 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { MlTrainTestSplitContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import { type UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+
+type Schema = MlTrainTestSplitContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+
+const jsonSchemaId = "context-providers-directory/ml-train-test-split-context-provider";
+
+const defaultData = {
+    fraction_held_as_test_set: 0.2,
+};
+
+class MLTrainTestSplitDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "mlTrainTestSplit" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "mlTrainTestSplit");
+
+        return new MLTrainTestSplitDataManager(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    readonly uiSchema = {
+        target_column_name: {},
+        problem_category: {},
+    } as const;
+
+    readonly extraData = {};
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            fraction_held_as_test_set: { default: defaultData.fraction_held_as_test_set },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}
+
+export default MLTrainTestSplitDataManager;

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

@@ -0,0 +1,57 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { NebContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "./base/ContextProvider";
+import type { JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+import JSONSchemaFormDataProvider from "./base/JSONSchemaFormDataProvider";
+
+type Schema = NebContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+
+const jsonSchemaId = "context-providers-directory/neb-data-provider";
+
+const defaultData = {
+    nImages: 1,
+};
+
+export default class NEBFormDataManager extends JSONSchemaFormDataProvider<Schema> {
+    readonly name = "neb" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "neb");
+
+        return new NEBFormDataManager(contextItem, externalContext);
+    }
+
+    readonly uiSchema = {
+        nImages: {},
+    } as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    readonly extraData = {};
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            nImages: { default: defaultData.nImages },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}

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

@@ -0,0 +1,229 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    NonCollinearMagnetizationContextItemSchema,
+    NonCollinearMagnetizationContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import materialContextMixin, {
+    type MaterialContextMixin,
+    type MaterialExternalContext,
+} from "../mixins/MaterialContextMixin";
+import type { UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+
+type Data = NonCollinearMagnetizationContextProviderSchema;
+type Schema = NonCollinearMagnetizationContextItemSchema;
+type ExternalContext = JinjaExternalContext & MaterialExternalContext;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface NonCollinearMagnetizationDataManager extends MaterialContextMixin {}
+
+const defaultData = {
+    isExistingChargeDensity: false,
+    isStartingMagnetization: true,
+    isConstrainedMagnetization: false,
+    isArbitrarySpinAngle: false,
+    isArbitrarySpinDirection: false,
+    isFixedMagnetization: false,
+    lforcet: true,
+    value: 0.0,
+    angle1: 0.0,
+    angle2: 0.0,
+    constrainType: "atomic direction" as const,
+    lambda: 0.0,
+    fixedMagnetizationX: 0.0,
+    fixedMagnetizationY: 0.0,
+    fixedMagnetizationZ: 0.0,
+};
+
+const jsonSchemaId = "context-providers-directory/non-collinear-magnetization-context-provider";
+
+class NonCollinearMagnetizationDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "nonCollinearMagnetization" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "nonCollinearMagnetization");
+
+        return new NonCollinearMagnetizationDataManager(contextItem, externalContext);
+    }
+
+    readonly isStartingMagnetization: boolean;
+
+    readonly isConstrainedMagnetization: boolean;
+
+    readonly isExistingChargeDensity: boolean;
+
+    readonly isArbitrarySpinDirection: boolean;
+
+    readonly isFixedMagnetization: boolean;
+
+    readonly constrainedMagnetization: Data["constrainedMagnetization"];
+
+    readonly jsonSchema: JSONSchema7;
+
+    private readonly uniqueElementsWithLabels: string[];
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext);
+        this.initMaterialContextMixin(externalContext);
+
+        this.isStartingMagnetization = this.data?.isStartingMagnetization ?? true;
+        this.isConstrainedMagnetization = this.data?.isConstrainedMagnetization ?? false;
+        this.isExistingChargeDensity = this.data?.isExistingChargeDensity ?? false;
+        this.isArbitrarySpinDirection = this.data?.isArbitrarySpinDirection ?? false;
+        this.isFixedMagnetization = this.data?.isFixedMagnetization ?? false;
+        this.constrainedMagnetization = this.data?.constrainedMagnetization ?? {
+            lambda: 0.0,
+            constrainType: "atomic direction" as const,
+        };
+        this.uniqueElementsWithLabels = [
+            ...new Set(this.material?.Basis?.elementsWithLabelsArray || []),
+        ];
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            isExistingChargeDensity: { default: defaultData.isExistingChargeDensity },
+            isStartingMagnetization: { default: defaultData.isStartingMagnetization },
+            isArbitrarySpinAngle: { default: defaultData.isArbitrarySpinAngle },
+            isConstrainedMagnetization: { default: defaultData.isConstrainedMagnetization },
+            isFixedMagnetization: { default: defaultData.isFixedMagnetization },
+            startingMagnetization: {
+                minItems: this.uniqueElementsWithLabels.length,
+                maxItems: this.uniqueElementsWithLabels.length,
+            },
+            "startingMagnetization.items.properties.value": {
+                default: defaultData.value,
+                minimum: -1.0,
+                maximum: 1.0,
+            },
+            spinAngles: {
+                minItems: this.uniqueElementsWithLabels.length,
+                maxItems: this.uniqueElementsWithLabels.length,
+            },
+            "spinAngles.items.properties.angle1": { default: defaultData.angle1 },
+            "spinAngles.items.properties.angle2": { default: defaultData.angle2 },
+            "constrainedMagnetization.properties.constrainType": {
+                default: defaultData.constrainType,
+            },
+            "constrainedMagnetization.properties.lambda": { default: defaultData.lambda },
+            "fixedMagnetization.properties.x": { default: defaultData.fixedMagnetizationX },
+            "fixedMagnetization.properties.y": { default: defaultData.fixedMagnetizationY },
+            "fixedMagnetization.properties.z": { default: defaultData.fixedMagnetizationZ },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        const startingMagnetization = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                value: defaultData.value,
+            };
+        });
+
+        const spinAngles = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                angle1: defaultData.angle1,
+                angle2: defaultData.angle2,
+            };
+        });
+
+        return {
+            isExistingChargeDensity: defaultData.isExistingChargeDensity,
+            isStartingMagnetization: defaultData.isStartingMagnetization,
+            isConstrainedMagnetization: defaultData.isConstrainedMagnetization,
+            isArbitrarySpinAngle: defaultData.isArbitrarySpinAngle,
+            isArbitrarySpinDirection: defaultData.isArbitrarySpinDirection,
+            isFixedMagnetization: defaultData.isFixedMagnetization,
+            lforcet: defaultData.lforcet,
+            spinAngles,
+            startingMagnetization,
+            constrainedMagnetization: {
+                lambda: defaultData.lambda,
+                constrainType: defaultData.constrainType,
+            },
+            fixedMagnetization: {
+                x: defaultData.fixedMagnetizationX,
+                y: defaultData.fixedMagnetizationY,
+                z: defaultData.fixedMagnetizationZ,
+            },
+        };
+    }
+
+    get uiSchemaStyled() {
+        return {
+            isExistingChargeDensity: {},
+            lforcet: {
+                "ui:readonly": !this.isExistingChargeDensity,
+                "ui:widget": "radio",
+                "ui:options": {
+                    inline: true,
+                },
+            },
+            isArbitrarySpinDirection: {},
+            spinAngles: {
+                items: {
+                    atomicSpecies: {
+                        "ui:readonly": true,
+                    },
+                },
+                "ui:readonly": !this.isArbitrarySpinDirection,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isStartingMagnetization: {},
+            startingMagnetization: {
+                items: {
+                    atomicSpecies: {
+                        "ui:readonly": true,
+                    },
+                    value: {
+                        "ui:classNames": "col-xs-6",
+                    },
+                },
+                "ui:readonly": !this.isStartingMagnetization,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isConstrainedMagnetization: {},
+            constrainedMagnetization: {
+                "ui:readonly": !this.isConstrainedMagnetization,
+            },
+            isFixedMagnetization: {
+                "ui:readonly": !(
+                    this.isConstrainedMagnetization &&
+                    this.constrainedMagnetization?.constrainType === "total"
+                ),
+            },
+            fixedMagnetization: {
+                "ui:readonly": !(
+                    this.isFixedMagnetization &&
+                    this.isConstrainedMagnetization &&
+                    this.constrainedMagnetization?.constrainType === "total"
+                ),
+            },
+        };
+    }
+}
+
+materialContextMixin(NonCollinearMagnetizationDataManager.prototype);
+
+export default NonCollinearMagnetizationDataManager;

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

@@ -0,0 +1,110 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { CutoffsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import applicationContextMixin, {
+    type ApplicationContextMixin,
+    type ApplicationExternalContext,
+} from "../mixins/ApplicationContextMixin";
+import ContextProvider, {
+    type BaseExternalContext,
+    type UnitContext,
+} from "./base/ContextProvider";
+
+type ApplicationName = "vasp" | "espresso";
+
+type Schema = CutoffsContextItemSchema;
+type PlanewaveExternalContext = BaseExternalContext & ApplicationExternalContext;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface PlanewaveCutoffDataManager extends ApplicationContextMixin {}
+
+// Type guard to check if a string is a valid ApplicationName
+function isApplicationName(name: string): name is ApplicationName {
+    return name === "vasp" || name === "espresso";
+}
+
+// TODO: create a task to move this handling to standata
+const cutoffConfig: Record<ApplicationName, { wavefunction?: number; density?: number }> = {
+    vasp: { wavefunction: undefined, density: undefined },
+    espresso: { wavefunction: 40, density: 200 },
+};
+
+const defaultData = {
+    wavefunction: undefined,
+    density: undefined,
+};
+
+const jsonSchemaId = "context-providers-directory/planewave-cutoffs-context-provider";
+
+class PlanewaveCutoffDataManager extends ContextProvider<Schema, PlanewaveExternalContext> {
+    readonly name = "cutoffs" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "subworkflow" as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    readonly uiSchema = {
+        wavefunction: {},
+        density: {},
+    } as const;
+
+    readonly extraData = {};
+
+    static createFromUnitContext(
+        unitContext: UnitContext,
+        externalContext: PlanewaveExternalContext,
+    ) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "cutoffs");
+
+        return new PlanewaveCutoffDataManager(contextItem, externalContext);
+    }
+
+    constructor(contextItem: Partial<Schema>, externalContext: PlanewaveExternalContext) {
+        super(contextItem, externalContext);
+        this.initApplicationContextMixin(externalContext);
+
+        const { wavefunction, density } = this.getDefaultData();
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            wavefunction: { default: wavefunction },
+            density: { default: density },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData() {
+        const applicationName = this.application.name;
+
+        // Type-safe check: ensure application name is valid and exists in config
+        if (!isApplicationName(applicationName)) {
+            // Fallback to default values if application is not supported
+            return defaultData;
+        }
+
+        const config = cutoffConfig[applicationName];
+
+        if (!config) {
+            // Fallback to default values if application is not in cutoffConfig
+            return defaultData;
+        }
+
+        const { wavefunction, density } = config;
+
+        return {
+            wavefunction: wavefunction ?? defaultData.wavefunction,
+            density: density ?? defaultData.density,
+        };
+    }
+}
+
+applicationContextMixin(PlanewaveCutoffDataManager.prototype);
+
+export default PlanewaveCutoffDataManager;

package/src/js/context/providers/PointsGrid/IGridFormDataManager.ts

@@ -0,0 +1,36 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { GridContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "../base/ContextProvider";
+import PointsGridFormDataProvider, { type ExternalContext } from "./PointsGridFormDataProvider";
+
+type Name = "igrid";
+type Schema = GridContextItemSchema;
+
+export default class IGridFormDataManager extends PointsGridFormDataProvider<Name> {
+    readonly name = "igrid" as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext, 0.2);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(
+            this.jsonSchemaId,
+            this.jsonSchemaPatchConfig,
+        );
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "igrid");
+
+        return new IGridFormDataManager(contextItem, externalContext);
+    }
+}

package/src/js/context/providers/PointsGrid/KGridFormDataManager.ts

@@ -0,0 +1,46 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { GridContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import ConvergenceParameter from "../../../convergence/ConvergenceParameter";
+import type { UnitContext } from "../base/ContextProvider";
+import PointsGridFormDataProvider, { type ExternalContext } from "./PointsGridFormDataProvider";
+
+type Name = "kgrid";
+type Schema = GridContextItemSchema;
+
+export default class KGridFormDataManager extends PointsGridFormDataProvider<Name> {
+    readonly name = "kgrid" as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext, 1);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(
+            this.jsonSchemaId,
+            this.jsonSchemaPatchConfig,
+        );
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "kgrid");
+
+        return new KGridFormDataManager(contextItem, externalContext);
+    }
+
+    applyConvergenceParameter(parameter: ConvergenceParameter) {
+        this.setData({
+            ...this.getData(),
+            ...parameter.unitContext.data,
+        });
+
+        this.setIsEdited(true);
+    }
+}