@mat3ra/wode 2025.10.1-0

package/dist/context/providers/MLSettingsContextProvider.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MLSettingsContextProvider = void 0;
+var _ContextProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/ContextProvider"));
+var _ApplicationContextMixin = require("../mixins/ApplicationContextMixin");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class MLSettingsContextProvider extends _ContextProvider.default {
+  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 {
+      target_column_name: "target",
+      problem_category: "regression"
+    };
+  }
+  get jsonSchema() {
+    return {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: " ",
+      description: "Settings important to machine learning runs.",
+      type: "object",
+      properties: {
+        target_column_name: {
+          type: "string",
+          default: this.defaultData.target_column_name
+        },
+        problem_category: {
+          type: "string",
+          default: this.defaultData.problem_category,
+          enum: ["regression", "classification", "clustering"]
+        }
+      }
+    };
+  }
+}
+exports.MLSettingsContextProvider = MLSettingsContextProvider;
+(0, _ApplicationContextMixin.applicationContextMixin)(MLSettingsContextProvider.prototype);

package/dist/context/providers/MLTrainTestSplitContextProvider.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MLTrainTestSplitContextProvider = void 0;
+var _ContextProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/ContextProvider"));
+var _ApplicationContextMixin = require("../mixins/ApplicationContextMixin");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class MLTrainTestSplitContextProvider extends _ContextProvider.default {
+  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
+        }
+      }
+    };
+  }
+}
+exports.MLTrainTestSplitContextProvider = MLTrainTestSplitContextProvider;
+(0, _ApplicationContextMixin.applicationContextMixin)(MLTrainTestSplitContextProvider.prototype);

package/dist/context/providers/NEBFormDataProvider.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NEBFormDataProvider = void 0;
+var _JSONSchemaFormDataProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class NEBFormDataProvider extends _JSONSchemaFormDataProvider.default {
+  // 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
+        }
+      }
+    };
+  }
+}
+exports.NEBFormDataProvider = NEBFormDataProvider;

package/dist/context/providers/NonCollinearMagnetizationContextProvider.js

@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NonCollinearMagnetizationContextProvider = void 0;
+var _JSONSchemaFormDataProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _MaterialContextMixin = require("../mixins/MaterialContextMixin");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class NonCollinearMagnetizationContextProvider extends _JSONSchemaFormDataProvider.default {
+  constructor(config) {
+    super(config);
+    this.initMaterialContextMixin();
+    this.isStartingMagnetization = _lodash.default.get(this.data, "isStartingMagnetization", true);
+    this.isConstrainedMagnetization = _lodash.default.get(this.data, "isConstrainedMagnetization", false);
+    this.isExistingChargeDensity = _lodash.default.get(this.data, "isExistingChargeDensity", false);
+    this.isArbitrarySpinDirection = _lodash.default.get(this.data, "isArbitrarySpinDirection", false);
+    this.isFixedMagnetization = _lodash.default.get(this.data, "isFixedMagnetization", false);
+    this.constrainedMagnetization = _lodash.default.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
+            }
+          }
+        }
+      }
+    };
+  }
+}
+exports.NonCollinearMagnetizationContextProvider = NonCollinearMagnetizationContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(NonCollinearMagnetizationContextProvider.prototype);

package/dist/context/providers/PlanewaveCutoffsContextProvider.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PlanewaveCutoffsContextProvider = void 0;
+var _ContextProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/ContextProvider"));
+var _ApplicationContextMixin = require("../mixins/ApplicationContextMixin");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const cutoffConfig = {
+  vasp: {},
+  // assuming default cutoffs for VASP
+  espresso: {
+    // assuming the default GBRV set of pseudopotentials is used
+    wavefunction: 40,
+    density: 200
+  }
+};
+class PlanewaveCutoffsContextProvider extends _ContextProvider.default {
+  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
+        }
+      }
+    };
+  }
+}
+exports.PlanewaveCutoffsContextProvider = PlanewaveCutoffsContextProvider;
+(0, _ApplicationContextMixin.applicationContextMixin)(PlanewaveCutoffsContextProvider.prototype);