@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/src/js/context/providers/MLTrainTestSplitContextProvider.js

@@ -1,43 +0,0 @@
-import { ContextProvider } from "@mat3ra/ade";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-
-import { applicationContextMixin } from "../mixins/ApplicationContextMixin";
-
-export class MLTrainTestSplitContextProvider extends ContextProvider {
-    jsonSchemaId = "context-providers-directory/ml-train-test-split-context-provider";
-
-    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 jsonSchemaPatchConfig() {
-        return {
-            fraction_held_as_test_set: { default: this.defaultData.fraction_held_as_test_set },
-        };
-    }
-
-    get jsonSchema() {
-        return JSONSchemasInterface.getPatchedSchemaById(
-            this.jsonSchemaId,
-            this.jsonSchemaPatchConfig,
-        );
-    }
-}
-
-applicationContextMixin(MLTrainTestSplitContextProvider.prototype);

package/src/js/context/providers/NEBFormDataProvider.js

@@ -1,33 +0,0 @@
-import { JSONSchemaFormDataProvider } from "@mat3ra/ade";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-
-export class NEBFormDataProvider extends JSONSchemaFormDataProvider {
-    jsonSchemaId = "context-providers-directory/neb-data-provider";
-
-    // eslint-disable-next-line class-methods-use-this
-    get defaultData() {
-        return {
-            nImages: 1,
-        };
-    }
-
-    get jsonSchemaPatchConfig() {
-        return {
-            nImages: { default: this.defaultData.nImages },
-        };
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    get uiSchema() {
-        return {
-            nImages: {},
-        };
-    }
-
-    get jsonSchema() {
-        return JSONSchemasInterface.getPatchedSchemaById(
-            this.jsonSchemaId,
-            this.jsonSchemaPatchConfig,
-        );
-    }
-}

package/src/js/context/providers/NonCollinearMagnetizationContextProvider.js

@@ -1,179 +0,0 @@
-import { JSONSchemaFormDataProvider } from "@mat3ra/ade";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-import lodash from "lodash";
-
-import { materialContextMixin } from "../mixins/MaterialContextMixin";
-
-export class NonCollinearMagnetizationContextProvider extends JSONSchemaFormDataProvider {
-    jsonSchemaId = "context-providers-directory/non-collinear-magnetization-context-provider";
-
-    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 jsonSchemaPatchConfig() {
-        return {
-            isExistingChargeDensity: { default: false },
-            isStartingMagnetization: { default: true },
-            isArbitrarySpinAngle: { default: false },
-            isConstrainedMagnetization: { default: false },
-            isFixedMagnetization: { default: true },
-            startingMagnetization: {
-                minItems: this.uniqueElementsWithLabels.length,
-                maxItems: this.uniqueElementsWithLabels.length,
-            },
-            "startingMagnetization.items.properties.value": {
-                default: 0.0,
-                minimum: -1.0,
-                maximum: 1.0,
-            },
-            spinAngles: {
-                minItems: this.uniqueElementsWithLabels.length,
-                maxItems: this.uniqueElementsWithLabels.length,
-            },
-            "spinAngles.items.properties.angle1": { default: 0.0 },
-            "spinAngles.items.properties.angle2": { default: 0.0 },
-            "constrainedMagnetization.properties.constrainType": {
-                default: "atomic direction",
-            },
-            "constrainedMagnetization.properties.lambda": { default: 0.0 },
-            "fixedMagnetization.properties.x": { default: 0.0 },
-            "fixedMagnetization.properties.y": { default: 0.0 },
-            "fixedMagnetization.properties.z": { default: 0.0 },
-        };
-    }
-
-    get jsonSchema() {
-        return JSONSchemasInterface.getPatchedSchemaById(
-            this.jsonSchemaId,
-            this.jsonSchemaPatchConfig,
-        );
-    }
-}
-
-materialContextMixin(NonCollinearMagnetizationContextProvider.prototype);

package/src/js/context/providers/PlanewaveCutoffsContextProvider.js

@@ -1,65 +0,0 @@
-import { ContextProvider } from "@mat3ra/ade";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-
-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 {
-    jsonSchemaId = "context-providers-directory/planewave-cutoffs-context-provider";
-
-    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 jsonSchemaPatchConfig() {
-        return {
-            wavefunction: { default: this.defaultData.wavefunction },
-            density: { default: this.defaultData.density },
-        };
-    }
-
-    get _cutoffConfigPerApplication() {
-        return cutoffConfig[this.application.name];
-    }
-
-    get defaultECUTWFC() {
-        return this._cutoffConfigPerApplication.wavefunction || null;
-    }
-
-    get defaultECUTRHO() {
-        return this._cutoffConfigPerApplication.density || null;
-    }
-
-    get jsonSchema() {
-        return JSONSchemasInterface.getPatchedSchemaById(
-            this.jsonSchemaId,
-            this.jsonSchemaPatchConfig,
-        );
-    }
-}
-
-applicationContextMixin(PlanewaveCutoffsContextProvider.prototype);

package/src/js/context/providers/PointsGridFormDataProvider.js

@@ -1,271 +0,0 @@
-import { JSONSchemaFormDataProvider } from "@mat3ra/ade";
-import { units as UNITS } from "@mat3ra/code/dist/js/constants";
-import { math as codeJSMath } from "@mat3ra/code/dist/js/math";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-import { Made } from "@mat3ra/made";
-import lodash from "lodash";
-
-import { materialContextMixin } from "../mixins/MaterialContextMixin";
-import { globalSettings } from "./settings";
-
-export class PointsGridFormDataProvider extends JSONSchemaFormDataProvider {
-    jsonSchemaId = "context-providers-directory/points-grid-data-provider";
-
-    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 jsonSchemaPatchConfig() {
-        // Helper function to create vector schema with defaults
-        const vector_ = (defaultValue, isStringType = false) => {
-            const isArray = Array.isArray(defaultValue);
-            return {
-                type: "array",
-                items: {
-                    type: isStringType ? "string" : "number",
-                    ...(isArray ? {} : { default: defaultValue }),
-                },
-                minItems: 3,
-                maxItems: 3,
-                ...(isArray ? { default: defaultValue } : {}),
-            };
-        };
-
-        return {
-            dimensions: vector_(this._defaultDimensions, this.isUsingJinjaVariables),
-            shifts: vector_(this.getDefaultShift()),
-            reciprocalVectorRatios: vector_(this.reciprocalVectorRatios),
-            gridMetricType: { default: "KPPRA" },
-            description: `3D grid with shifts. Default min value for ${
-                this._metricDescription[this.gridMetricType]
-            } is ${this._getDefaultGridMetricValue(this.gridMetricType)}.`,
-            required: ["dimensions", "shifts"],
-            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,
-                                },
-                            },
-                        },
-                    ],
-                },
-            },
-        };
-    }
-
-    get jsonSchema() {
-        return JSONSchemasInterface.getPatchedSchemaById(
-            this.jsonSchemaId,
-            this.jsonSchemaPatchConfig,
-        );
-    }
-
-    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);