@mat3ra/wode 2025.10.1-0

package/src/context/providers/MLTrainTestSplitContextProvider.js

@@ -0,0 +1,45 @@
+import ContextProvider from "@exabyte-io/ade.js/dist/js/context/ContextProvider";
+
+import { applicationContextMixin } from "../mixins/ApplicationContextMixin";
+
+export class MLTrainTestSplitContextProvider extends ContextProvider {
+    constructor(config) {
+        super(config);
+        this.initApplicationContextMixin();
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get uiSchema() {
+        return {
+            target_column_name: {},
+            problem_category: {},
+        };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get defaultData() {
+        return {
+            fraction_held_as_test_set: 0.2,
+        };
+    }
+
+    get jsonSchema() {
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: " ",
+            description:
+                "Fraction held as the test set. For example, a value of 0.2 corresponds to an 80/20 train/test split.",
+            type: "object",
+            properties: {
+                fraction_held_as_test_set: {
+                    type: "number",
+                    default: this.defaultData.fraction_held_as_test_set,
+                    minimum: 0,
+                    maximum: 1,
+                },
+            },
+        };
+    }
+}
+
+applicationContextMixin(MLTrainTestSplitContextProvider.prototype);

package/src/context/providers/NEBFormDataProvider.js

@@ -0,0 +1,32 @@
+import JSONSchemaFormDataProvider from "@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider";
+
+export class NEBFormDataProvider extends JSONSchemaFormDataProvider {
+    // eslint-disable-next-line class-methods-use-this
+    get defaultData() {
+        return {
+            nImages: 1,
+        };
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get uiSchema() {
+        return {
+            nImages: {},
+        };
+    }
+
+    get jsonSchema() {
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: " ",
+            description: "Number of intermediate NEB images.",
+            type: "object",
+            properties: {
+                nImages: {
+                    type: "number",
+                    default: this.defaultData.nImages,
+                },
+            },
+        };
+    }
+}

package/src/context/providers/NonCollinearMagnetizationContextProvider.js

@@ -0,0 +1,269 @@
+import JSONSchemaFormDataProvider from "@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider";
+import lodash from "lodash";
+
+import { materialContextMixin } from "../mixins/MaterialContextMixin";
+
+export class NonCollinearMagnetizationContextProvider extends JSONSchemaFormDataProvider {
+    constructor(config) {
+        super(config);
+        this.initMaterialContextMixin();
+        this.isStartingMagnetization = lodash.get(this.data, "isStartingMagnetization", true);
+        this.isConstrainedMagnetization = lodash.get(
+            this.data,
+            "isConstrainedMagnetization",
+            false,
+        );
+        this.isExistingChargeDensity = lodash.get(this.data, "isExistingChargeDensity", false);
+        this.isArbitrarySpinDirection = lodash.get(this.data, "isArbitrarySpinDirection", false);
+        this.isFixedMagnetization = lodash.get(this.data, "isFixedMagnetization", false);
+        this.constrainedMagnetization = lodash.get(this.data, "constrainedMagnetization", {});
+    }
+
+    get uniqueElementsWithLabels() {
+        const elementsWithLabelsArray = this.material?.Basis?.elementsWithLabelsArray || [];
+        return [...new Set(elementsWithLabelsArray)];
+    }
+
+    get defaultData() {
+        const startingMagnetization = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                value: 0.0,
+            };
+        });
+
+        const spinAngles = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                angle1: 0.0,
+                angle2: 0.0,
+            };
+        });
+
+        return {
+            isExistingChargeDensity: false,
+            isStartingMagnetization: true,
+            isConstrainedMagnetization: false,
+            isArbitrarySpinAngle: false,
+            isFixedMagnetization: false,
+            lforcet: true,
+            spinAngles,
+            startingMagnetization,
+            constrainedMagnetization: {
+                lambda: 0.0,
+                constrainType: "atomic direction",
+            },
+            fixedMagnetization: {
+                x: 0.0,
+                y: 0.0,
+                z: 0.0,
+            },
+        };
+    }
+
+    get uiSchemaStyled() {
+        return {
+            isExistingChargeDensity: {},
+            lforcet: {
+                "ui:readonly": !this.isExistingChargeDensity,
+                "ui:widget": "radio",
+                "ui:options": {
+                    inline: true,
+                },
+            },
+            isArbitrarySpinDirection: {},
+            spinAngles: {
+                items: {
+                    atomicSpecies: {
+                        ...this.defaultFieldStyles,
+                        "ui:readonly": true,
+                    },
+                    angle1: this.defaultFieldStyles,
+                    angle2: this.defaultFieldStyles,
+                },
+                "ui:readonly": !this.isArbitrarySpinDirection,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isStartingMagnetization: {},
+            startingMagnetization: {
+                items: {
+                    atomicSpecies: {
+                        ...this.defaultFieldStyles,
+                        "ui:readonly": true,
+                    },
+                    value: {
+                        "ui:classNames": "col-xs-6",
+                    },
+                },
+                "ui:readonly": !this.isStartingMagnetization,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isConstrainedMagnetization: {},
+            constrainedMagnetization: {
+                constrainType: this.defaultFieldStyles,
+                lambda: this.defaultFieldStyles,
+                "ui:readonly": !this.isConstrainedMagnetization,
+            },
+            isFixedMagnetization: {
+                "ui:readonly": !(
+                    this.isConstrainedMagnetization &&
+                    this.constrainedMagnetization?.constrainType === "total"
+                ),
+            },
+            fixedMagnetization: {
+                x: this.defaultFieldStyles,
+                y: this.defaultFieldStyles,
+                z: this.defaultFieldStyles,
+                "ui:readonly": !(
+                    this.isFixedMagnetization &&
+                    this.isConstrainedMagnetization &&
+                    this.constrainedMagnetization?.constrainType === "total"
+                ),
+            },
+        };
+    }
+
+    get jsonSchema() {
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: "",
+            description:
+                "Set initial parameters for non-collinear spin magnetic (SOC) calculation.",
+            type: "object",
+            properties: {
+                isStartingMagnetization: {
+                    type: "boolean",
+                    title: "Set starting magnetization",
+                    default: true,
+                },
+                startingMagnetization: {
+                    type: "array",
+                    minItems: this.uniqueElementsWithLabels.length,
+                    maxItems: this.uniqueElementsWithLabels.length,
+                    items: {
+                        type: "object",
+                        properties: {
+                            atomicSpecies: {
+                                type: "string",
+                                title: "Atomic species",
+                            },
+                            value: {
+                                type: "number",
+                                title: "Starting magnetization",
+                                default: 0.0,
+                                minimum: -1.0,
+                                maximum: 1.0,
+                            },
+                        },
+                    },
+                },
+                isExistingChargeDensity: {
+                    type: "boolean",
+                    title: "Start calculation from existing charge density",
+                    default: false,
+                },
+                lforcet: {
+                    title: "Set lforcet to",
+                    type: "boolean",
+                    oneOf: [
+                        { const: true, title: "True" },
+                        { const: false, title: "False" },
+                    ],
+                },
+                isArbitrarySpinDirection: {
+                    type: "boolean",
+                    title: "Set spin directions",
+                    default: false,
+                },
+                spinAngles: {
+                    type: "array",
+                    minItems: this.uniqueElementsWithLabels.length,
+                    maxItems: this.uniqueElementsWithLabels.length,
+                    items: {
+                        type: "object",
+                        properties: {
+                            atomicSpecies: {
+                                type: "string",
+                                title: "Atomic species",
+                            },
+                            angle1: {
+                                type: "number",
+                                title: "Angle1 (deg)",
+                                default: 0.0,
+                            },
+                            angle2: {
+                                type: "number",
+                                title: "Angle2 (deg)",
+                                default: 0.0,
+                            },
+                        },
+                    },
+                },
+                isConstrainedMagnetization: {
+                    type: "boolean",
+                    title: "Set constrained magnetization",
+                    default: false,
+                },
+                constrainedMagnetization: {
+                    type: "object",
+                    properties: {
+                        constrainType: {
+                            type: "string",
+                            title: "Constrain type",
+                            enum: [
+                                "none",
+                                "total",
+                                "atomic",
+                                "total direction",
+                                "atomic direction",
+                            ],
+                            default: "atomic direction",
+                        },
+                        lambda: {
+                            type: "number",
+                            title: "lambda",
+                            default: 0.0,
+                        },
+                    },
+                },
+                isFixedMagnetization: {
+                    type: "boolean",
+                    title: "Set Fixed magnetization (only applicable to constrained magnetization of 'total' type)",
+                    default: true,
+                },
+                fixedMagnetization: {
+                    type: "object",
+                    properties: {
+                        x: {
+                            type: "number",
+                            title: "X-component",
+                            default: 0.0,
+                        },
+                        y: {
+                            type: "number",
+                            title: "Y-component",
+                            default: 0.0,
+                        },
+                        z: {
+                            type: "number",
+                            title: "Z-component",
+                            default: 0.0,
+                        },
+                    },
+                },
+            },
+        };
+    }
+}
+
+materialContextMixin(NonCollinearMagnetizationContextProvider.prototype);

package/src/context/providers/PlanewaveCutoffsContextProvider.js

@@ -0,0 +1,68 @@
+import ContextProvider from "@exabyte-io/ade.js/dist/js/context/ContextProvider";
+
+import { applicationContextMixin } from "../mixins/ApplicationContextMixin";
+
+const cutoffConfig = {
+    vasp: {}, // assuming default cutoffs for VASP
+    espresso: {
+        // assuming the default GBRV set of pseudopotentials is used
+        wavefunction: 40,
+        density: 200,
+    },
+};
+
+export class PlanewaveCutoffsContextProvider extends ContextProvider {
+    constructor(config) {
+        super(config);
+        this.initApplicationContextMixin();
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get uiSchema() {
+        return {
+            wavefunction: {},
+            density: {},
+        };
+    }
+
+    get defaultData() {
+        return {
+            wavefunction: this.defaultECUTWFC,
+            density: this.defaultECUTRHO,
+        };
+    }
+
+    get _cutoffConfigPerApplication() {
+        return cutoffConfig[this.application.name];
+    }
+
+    get defaultECUTWFC() {
+        return this._cutoffConfigPerApplication.wavefunction || null;
+    }
+
+    get defaultECUTRHO() {
+        return this._cutoffConfigPerApplication.density || null;
+    }
+
+    get jsonSchema() {
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            title: " ",
+            description:
+                "Planewave cutoff parameters for electronic wavefunctions and density. Units are specific to simulation engine.",
+            type: "object",
+            properties: {
+                wavefunction: {
+                    type: "number",
+                    default: this.defaultECUTWFC,
+                },
+                density: {
+                    type: "number",
+                    default: this.defaultECUTRHO,
+                },
+            },
+        };
+    }
+}
+
+applicationContextMixin(PlanewaveCutoffsContextProvider.prototype);

package/src/context/providers/PointsGridFormDataProvider.js

@@ -0,0 +1,285 @@
+import JSONSchemaFormDataProvider from "@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider";
+import { units as UNITS } from "@mat3ra/code/dist/js/constants";
+import { math as codeJSMath } from "@mat3ra/code/dist/js/math";
+import { Made } from "@mat3ra/made";
+import lodash from "lodash";
+
+import { materialContextMixin } from "../mixins/MaterialContextMixin";
+import { globalSettings } from "./settings";
+
+export class PointsGridFormDataProvider extends JSONSchemaFormDataProvider {
+    constructor(config) {
+        super(config);
+        this.initMaterialContextMixin();
+
+        this._divisor = config.divisor || 1; // KPPRA will be divided by this number
+        this.reciprocalLattice = new Made.ReciprocalLattice(this.material.lattice);
+
+        this.dimensions = lodash.get(this.data, "dimensions") || this._defaultDimensions;
+        this.shifts = lodash.get(this.data, "shifts") || this._defaultShifts;
+
+        // init class fields from data (as constructed from context in parent)
+        this.gridMetricType = lodash.get(this.data, "gridMetricType") || "KPPRA";
+        this.gridMetricValue =
+            lodash.get(this.data, "gridMetricValue") || this._getDefaultGridMetricValue("KPPRA");
+        this.preferGridMetric = lodash.get(this.data, "preferGridMetric", false);
+
+        this._metricDescription = {
+            KPPRA: `${this.name[0].toUpperCase()}PPRA (${this.name[0]}pt per reciprocal atom)`, // KPPRA or QPPRA
+            spacing: "grid spacing",
+        };
+        this.defaultClassNames = "col-xs-12 col-sm-6 col-md-3 col-lg-2";
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultShift() {
+        return 0;
+    }
+
+    get _defaultDimensions() {
+        return this.calculateDimensions({
+            gridMetricType: "KPPRA",
+            gridMetricValue: this._getDefaultGridMetricValue("KPPRA"),
+        });
+    }
+
+    get _defaultShifts() {
+        return Array(3).fill(this.getDefaultShift());
+    }
+
+    _getDefaultGridMetricValue(metric) {
+        switch (metric) {
+            case "KPPRA":
+                return Math.floor(globalSettings.defaultKPPRA / this._divisor);
+            case "spacing":
+                return 0.3;
+            default:
+                console.error("Metric type not recognized!");
+                return 1;
+        }
+    }
+
+    get _defaultData() {
+        return {
+            dimensions: this._defaultDimensions,
+            shifts: this._defaultShifts,
+            gridMetricType: "KPPRA",
+            gridMetricValue: this._getDefaultGridMetricValue("KPPRA"),
+            preferGridMetric: false,
+            reciprocalVectorRatios: this.reciprocalVectorRatios,
+        };
+    }
+
+    get _defaultDataWithMaterial() {
+        const { gridMetricType, gridMetricValue } = this;
+        // if `data` is present and material is updated, prioritize `data` when `preferGridMetric` is not set
+        return this.preferGridMetric
+            ? {
+                  dimensions: this.calculateDimensions({ gridMetricType, gridMetricValue }),
+                  shifts: this._defaultShifts,
+              }
+            : this.data || this._defaultData;
+    }
+
+    get defaultData() {
+        return this.material ? this._defaultDataWithMaterial : this._defaultData;
+    }
+
+    get reciprocalVectorRatios() {
+        return this.reciprocalLattice.reciprocalVectorRatios.map((r) =>
+            Number(codeJSMath.numberToPrecision(r, 3)),
+        );
+    }
+
+    get jsonSchema() {
+        const vector = {
+            type: "array",
+            items: {
+                type: "number",
+            },
+            minItems: 3,
+            maxItems: 3,
+        };
+
+        const vector_ = (defaultValue, isStringType = false) => {
+            const isArray = Array.isArray(defaultValue);
+            return {
+                ...vector,
+                items: {
+                    type: isStringType ? "string" : "number",
+                    ...(isArray ? {} : { default: defaultValue }),
+                },
+                ...(isArray ? { default: defaultValue } : {}),
+            };
+        };
+
+        return {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            description: `3D grid with shifts. Default min value for ${
+                this._metricDescription[this.gridMetricType]
+            } is ${this._getDefaultGridMetricValue(this.gridMetricType)}.`,
+            type: "object",
+            properties: {
+                dimensions: vector_(this._defaultDimensions, this.isUsingJinjaVariables),
+                shifts: vector_(this.getDefaultShift()),
+                reciprocalVectorRatios: vector_(this.reciprocalVectorRatios),
+                gridMetricType: {
+                    type: "string",
+                    enum: ["KPPRA", "spacing"],
+                    default: "KPPRA",
+                },
+                gridMetricValue: {
+                    type: "number",
+                },
+                preferGridMetric: {
+                    type: "boolean",
+                },
+            },
+            dependencies: {
+                gridMetricType: {
+                    oneOf: [
+                        {
+                            properties: {
+                                gridMetricType: {
+                                    enum: ["KPPRA"],
+                                },
+                                gridMetricValue: {
+                                    type: "integer",
+                                    minimum: 1,
+                                    title: "Value",
+                                    default: this.gridMetricValue,
+                                },
+                                preferGridMetric: {
+                                    type: "boolean",
+                                    title: "prefer KPPRA",
+                                    default: this.preferGridMetric,
+                                },
+                            },
+                        },
+                        {
+                            properties: {
+                                gridMetricType: {
+                                    enum: ["spacing"],
+                                },
+                                gridMetricValue: {
+                                    type: "number",
+                                    minimum: 0,
+                                    title: "Value [1/Å]",
+                                    default: this.gridMetricValue,
+                                },
+                                preferGridMetric: {
+                                    type: "boolean",
+                                    title: "prefer spacing",
+                                    default: this.preferGridMetric,
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+            required: ["dimensions", "shifts"],
+        };
+    }
+
+    get uiSchema() {
+        const _arraySubStyle = (emptyValue = 0) => {
+            return {
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+                items: {
+                    "ui:disabled": this.preferGridMetric,
+                    // TODO: extract the actual current values from context
+                    "ui:placeholder": "1",
+                    "ui:emptyValue": emptyValue,
+                    "ui:label": false,
+                },
+            };
+        };
+
+        return {
+            dimensions: _arraySubStyle(1),
+            shifts: _arraySubStyle(0),
+            gridMetricType: {
+                "ui:title": "Grid Metric",
+            },
+            gridMetricValue: {
+                "ui:disabled": !this.preferGridMetric,
+                "ui:emptyValue": this.gridMetricValue,
+                "ui:placeholder": this.gridMetricValue.toString(), // make string to prevent prop type error
+            },
+            preferGridMetric: {
+                "ui:emptyValue": true,
+                "ui:disabled": this.isUsingJinjaVariables,
+            },
+            reciprocalVectorRatios: {
+                "ui:title": "reciprocal vector ratios",
+                "ui:orderable": false,
+                "ui:removable": false,
+                "ui:readonly": true,
+                items: {
+                    "ui:label": false,
+                },
+            },
+        };
+    }
+
+    _getDimensionsFromKPPRA(KPPRA) {
+        const nAtoms = this.material ? this.material.Basis.nAtoms : 1;
+        return this.reciprocalLattice.getDimensionsFromPointsCount(KPPRA / nAtoms);
+    }
+
+    _getKPPRAFromDimensions(dimensions) {
+        const nAtoms = this.material ? this.material.Basis.nAtoms : 1;
+        return dimensions.reduce((a, b) => a * b) * nAtoms;
+    }
+
+    static _canTransform(data) {
+        return (
+            (data.preferGridMetric && data.gridMetricType && data.gridMetricValue) ||
+            (!data.preferGridMetric && data.dimensions.every((d) => typeof d === "number"))
+        );
+    }
+
+    calculateDimensions({ gridMetricType, gridMetricValue, units = UNITS.angstrom }) {
+        switch (gridMetricType) {
+            case "KPPRA":
+                return this._getDimensionsFromKPPRA(gridMetricValue);
+            case "spacing":
+                return this.reciprocalLattice.getDimensionsFromSpacing(gridMetricValue, units);
+            default:
+                return [1, 1, 1];
+        }
+    }
+
+    calculateGridMetric({ gridMetricType, dimensions, units = UNITS.angstrom }) {
+        switch (gridMetricType) {
+            case "KPPRA":
+                return this._getKPPRAFromDimensions(dimensions);
+            case "spacing":
+                return lodash.round(
+                    this.reciprocalLattice.getSpacingFromDimensions(dimensions, units),
+                    3,
+                );
+            default:
+                return 1;
+        }
+    }
+
+    transformData(data) {
+        if (!this.constructor._canTransform(data)) {
+            return data;
+        }
+        // dimensions are calculated from grid metric or vice versa
+        if (data.preferGridMetric) {
+            data.dimensions = this.calculateDimensions(data);
+        } else {
+            data.gridMetricValue = this.calculateGridMetric(data);
+        }
+        return data;
+    }
+}
+
+materialContextMixin(PointsGridFormDataProvider.prototype);