@mat3ra/wode 2025.11.19-0 → 2025.11.26-0

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

@@ -1,9 +1,12 @@
 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();
@@ -133,137 +136,44 @@ export class NonCollinearMagnetizationContextProvider extends JSONSchemaFormData
         };
     }
 
-    get jsonSchema() {
+    get jsonSchemaPatchConfig() {
         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,
-                        },
-                    },
-                },
+            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,4 +1,5 @@
 import { ContextProvider } from "@mat3ra/ade";
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
 
 import { applicationContextMixin } from "../mixins/ApplicationContextMixin";
 
@@ -12,6 +13,8 @@ const cutoffConfig = {
 };
 
 export class PlanewaveCutoffsContextProvider extends ContextProvider {
+    jsonSchemaId = "context-providers-directory/planewave-cutoffs-context-provider";
+
     constructor(config) {
         super(config);
         this.initApplicationContextMixin();
@@ -32,6 +35,13 @@ export class PlanewaveCutoffsContextProvider extends ContextProvider {
         };
     }
 
+    get jsonSchemaPatchConfig() {
+        return {
+            wavefunction: { default: this.defaultData.wavefunction },
+            density: { default: this.defaultData.density },
+        };
+    }
+
     get _cutoffConfigPerApplication() {
         return cutoffConfig[this.application.name];
     }
@@ -45,23 +55,10 @@ export class PlanewaveCutoffsContextProvider extends ContextProvider {
     }
 
     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,
-                },
-            },
-        };
+        return JSONSchemasInterface.getPatchedSchemaById(
+            this.jsonSchemaId,
+            this.jsonSchemaPatchConfig,
+        );
     }
 }
 

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

@@ -1,6 +1,7 @@
 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";
 
@@ -8,6 +9,8 @@ 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();
@@ -91,58 +94,37 @@ export class PointsGridFormDataProvider extends JSONSchemaFormDataProvider {
         );
     }
 
-    get jsonSchema() {
-        const vector = {
-            type: "array",
-            items: {
-                type: "number",
-            },
-            minItems: 3,
-            maxItems: 3,
-        };
-
+    get jsonSchemaPatchConfig() {
+        // Helper function to create vector schema with defaults
         const vector_ = (defaultValue, isStringType = false) => {
             const isArray = Array.isArray(defaultValue);
             return {
-                ...vector,
+                type: "array",
                 items: {
                     type: isStringType ? "string" : "number",
                     ...(isArray ? {} : { default: defaultValue }),
                 },
+                minItems: 3,
+                maxItems: 3,
                 ...(isArray ? { default: defaultValue } : {}),
             };
         };
 
         return {
-            $schema: "http://json-schema.org/draft-07/schema#",
+            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)}.`,
-            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",
-                },
-            },
+            required: ["dimensions", "shifts"],
             dependencies: {
                 gridMetricType: {
                     oneOf: [
                         {
                             properties: {
-                                gridMetricType: {
-                                    enum: ["KPPRA"],
-                                },
+                                gridMetricType: { enum: ["KPPRA"] },
                                 gridMetricValue: {
                                     type: "integer",
                                     minimum: 1,
@@ -158,9 +140,7 @@ export class PointsGridFormDataProvider extends JSONSchemaFormDataProvider {
                         },
                         {
                             properties: {
-                                gridMetricType: {
-                                    enum: ["spacing"],
-                                },
+                                gridMetricType: { enum: ["spacing"] },
                                 gridMetricValue: {
                                     type: "number",
                                     minimum: 0,
@@ -177,10 +157,16 @@ export class PointsGridFormDataProvider extends JSONSchemaFormDataProvider {
                     ],
                 },
             },
-            required: ["dimensions", "shifts"],
         };
     }
 
+    get jsonSchema() {
+        return JSONSchemasInterface.getPatchedSchemaById(
+            this.jsonSchemaId,
+            this.jsonSchemaPatchConfig,
+        );
+    }
+
     get uiSchema() {
         const _arraySubStyle = (emptyValue = 0) => {
             return {

package/src/js/context/providers/PointsPathFormDataProvider.js

@@ -2,6 +2,7 @@
 /* eslint react/prop-types: 0 */
 import { JSONSchemaFormDataProvider } from "@mat3ra/ade";
 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 s from "underscore.string";
 
@@ -12,6 +13,8 @@ const defaultPoint = "Г";
 const defaultSteps = 10;
 
 export class PointsPathFormDataProvider extends JSONSchemaFormDataProvider {
+    jsonSchemaId = "context-providers-directory/points-path-data-provider";
+
     constructor(config) {
         super(config);
         this.initMaterialContextMixin();
@@ -32,32 +35,27 @@ export class PointsPathFormDataProvider extends JSONSchemaFormDataProvider {
         return this.reciprocalLattice.symmetryPoints;
     }
 
-    get jsonSchema() {
-        // no need to pass context to get symmetry points on client
+    get jsonSchemaPatchConfig() {
         const points = [].concat(this.symmetryPoints).map((x) => x.point);
+
         return {
-            $schema: "http://json-schema.org/draft-07/schema#",
-            title: " ",
-            description: "path in reciprocal space",
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    point: {
-                        type: "string",
-                        default: defaultPoint,
-                        enum: points,
-                    },
-                    steps: {
-                        type: "integer",
-                        default: defaultSteps,
-                    },
-                },
+            "items.properties.point": {
+                default: defaultPoint,
+                enum: points,
+            },
+            "items.properties.steps": {
+                default: defaultSteps,
             },
-            minItems: 1,
         };
     }
 
+    get jsonSchema() {
+        return JSONSchemasInterface.getPatchedSchemaById(
+            this.jsonSchemaId,
+            this.jsonSchemaPatchConfig,
+        );
+    }
+
     // eslint-disable-next-line class-methods-use-this
     get uiSchema() {
         return {