@mat3ra/wode 2025.10.1-0

package/dist/subworkflows/convergence/parameter.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConvergenceParameter = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable class-methods-use-this */
+
+class ConvergenceParameter {
+  constructor({
+    name,
+    initialValue,
+    increment
+  }) {
+    this.name = name;
+    this._initialValue = initialValue;
+    this._increment = increment;
+  }
+
+  /**
+   * Getter for initial value as string.
+   * Note: this will be used in assignment unit.
+   * @return {string}
+   */
+  get initialValue() {
+    if (!_lodash.default.isString(this._initialValue)) {
+      return JSON.stringify(this._initialValue);
+    }
+    return this._initialValue;
+  }
+
+  /**
+   * @summary Defines how to increment the parameter.
+   * @return {string} - increment operation used in assignment unit
+   */
+  get increment() {
+    return ""; // overwrite in derived class
+  }
+
+  /**
+   * Defines content for updating the unit context
+   * @return {Object}
+   */
+  get unitContext() {
+    return {};
+  }
+
+  /**
+   * Defines value once convergence is reached (for 'exit' unit).
+   * Note: This is used in assignment unit and most often the variable will be assigned to itself.
+   * @return {string}
+   */
+  get finalValue() {
+    return `${this.name}`;
+  }
+
+  /**
+   * Create list of  variables to fetch from a unit.
+   * Note: this is used for the `input` field for an assignment unit.
+   * @param {string} flowchartId - flowchartId of unit containing context variables
+   * @return {Object|{scope, name}}
+   */
+  // eslint-disable-next-line class-methods-use-this, no-unused-vars
+  useVariablesFromUnitContext(flowchartId) {
+    return [];
+  }
+}
+exports.ConvergenceParameter = ConvergenceParameter;

package/dist/subworkflows/convergence/uniform_kgrid.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UniformKGridConvergence = void 0;
+var _parameter = require("./parameter");
+class UniformKGridConvergence extends _parameter.ConvergenceParameter {
+  get increment() {
+    return `${this.name} + ${this._increment}`;
+  }
+  get unitContext() {
+    return {
+      kgrid: {
+        dimensions: [`{{${this.name}}}`, `{{${this.name}}}`, `{{${this.name}}}`],
+        shifts: [0, 0, 0]
+      },
+      isKgridEdited: true,
+      isUsingJinjaVariables: true
+    };
+  }
+  get finalValue() {
+    return `${this.name} + 0`;
+  }
+}
+exports.UniformKGridConvergence = UniformKGridConvergence;

package/dist/subworkflows/convergence.js

@@ -0,0 +1,189 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConvergenceMixin = void 0;
+var _merge = _interopRequireDefault(require("lodash/merge"));
+var _enums = require("../enums");
+var _factory = require("./convergence/factory");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const ConvergenceMixin = superclass => class extends superclass {
+  get convergenceParam() {
+    return this.findUnitWithTag("hasConvergenceParam")?.operand || undefined;
+  }
+  get convergenceResult() {
+    return this.findUnitWithTag("hasConvergenceResult")?.operand || undefined;
+  }
+  convergenceSeries(scopeTrack) {
+    if (!this.hasConvergence || !scopeTrack?.length) return [];
+    let lastResult;
+    const series = scopeTrack.map((scopeItem, i) => ({
+      x: i,
+      param: scopeItem.scope?.global[this.convergenceParam],
+      y: scopeItem.scope?.global[this.convergenceResult]
+    })).filter(({
+      y
+    }) => {
+      const isNewResult = y !== undefined && y !== lastResult;
+      lastResult = y;
+      return isNewResult;
+    });
+    return series.map((item, i) => {
+      return {
+        x: i + 1,
+        param: item.param,
+        y: item.y
+      };
+    });
+  }
+  addConvergence({
+    parameter,
+    parameterInitial,
+    parameterIncrement,
+    result,
+    resultInitial,
+    condition,
+    operator,
+    tolerance,
+    maxOccurrences
+  }) {
+    // RF: added TODO comments for future improvements
+
+    const {
+      units
+    } = this;
+    // Find unit to converge: should contain passed result in its results list
+    // TODO: make user to select unit for convergence explicitly
+    const unitForConvergence = units.find(x => x.resultNames.find(name => name === result));
+    if (!unitForConvergence) {
+      // eslint-disable-next-line no-undef
+      sAlert.error(`Subworkflow does not contain unit with '${result}' as extracted property.`);
+      throw new Error("There is no result to converge");
+    }
+
+    // initialize parameter
+    const param = (0, _factory.createConvergenceParameter)({
+      name: parameter,
+      initialValue: parameterInitial,
+      increment: parameterIncrement
+    });
+
+    // Replace kgrid to be ready for convergence
+    // TODO: kgrid should be abstracted and selected by user
+    const providers = unitForConvergence.importantSettingsProviders;
+    const gridProvider = providers.find(p => p.name === "kgrid" || p.name === "qgrid");
+    let mergedContext = param.unitContext;
+    if (gridProvider) {
+      mergedContext = (0, _merge.default)(gridProvider.yieldData(), param.unitContext);
+      gridProvider.setData(mergedContext);
+      gridProvider.setIsEdited(true);
+    }
+    unitForConvergence.updateContext(mergedContext);
+    const prevResult = "prev_result";
+    const iteration = "iteration";
+
+    // Assignment with result's initial value
+    const prevResultInit = this._UnitFactory.create({
+      name: "init result",
+      type: _enums.UNIT_TYPES.assignment,
+      head: true,
+      operand: prevResult,
+      value: resultInitial
+    });
+
+    // Assignment with initial value of convergence parameter
+    const paramInit = this._UnitFactory.create({
+      name: "init parameter",
+      type: _enums.UNIT_TYPES.assignment,
+      operand: param.name,
+      value: param.initialValue,
+      tags: [_enums.UNIT_TAGS.hasConvergenceParam]
+    });
+
+    // Assignment with initial value of iteration counter
+    const iterInit = this._UnitFactory.create({
+      name: "init counter",
+      type: _enums.UNIT_TYPES.assignment,
+      operand: iteration,
+      value: 1
+    });
+
+    // Assignment for storing iteration result: extracts 'result' from convergence unit scope
+    const storePrevResult = this._UnitFactory.create({
+      name: "store result",
+      type: _enums.UNIT_TYPES.assignment,
+      input: [{
+        scope: unitForConvergence.flowchartId,
+        name: result
+      }],
+      operand: prevResult,
+      value: result
+    });
+
+    // Assignment for convergence param increase
+    const nextStep = this._UnitFactory.create({
+      name: "update parameter",
+      type: _enums.UNIT_TYPES.assignment,
+      input: param.useVariablesFromUnitContext(unitForConvergence.flowchartId),
+      operand: param.name,
+      value: param.increment,
+      next: unitForConvergence.flowchartId
+    });
+
+    // Final step of convergence
+    const exit = this._UnitFactory.create({
+      type: _enums.UNIT_TYPES.assignment,
+      name: "exit",
+      input: [],
+      operand: param.name,
+      value: param.finalValue
+    });
+
+    // Final step of convergence
+    const storeResult = this._UnitFactory.create({
+      name: "update result",
+      type: _enums.UNIT_TYPES.assignment,
+      input: [{
+        scope: unitForConvergence.flowchartId,
+        name: result
+      }],
+      operand: result,
+      value: result,
+      tags: [_enums.UNIT_TAGS.hasConvergenceResult]
+    });
+
+    // Assign next iteration value
+    const nextIter = this._UnitFactory.create({
+      name: "update counter",
+      type: _enums.UNIT_TYPES.assignment,
+      input: [],
+      operand: iteration,
+      value: `${iteration} + 1`
+    });
+
+    // Convergence condition unit
+    const conditionUnit = this._UnitFactory.create({
+      name: "check convergence",
+      type: _enums.UNIT_TYPES.condition,
+      statement: `${condition} ${operator} ${tolerance}`,
+      then: exit.flowchartId,
+      else: storePrevResult.flowchartId,
+      maxOccurrences,
+      next: storePrevResult.flowchartId
+    });
+    this.addUnit(paramInit, 0);
+    this.addUnit(prevResultInit, 1);
+    this.addUnit(iterInit, 2);
+    this.addUnit(storeResult);
+    this.addUnit(conditionUnit);
+    this.addUnit(storePrevResult);
+    this.addUnit(nextIter);
+    this.addUnit(nextStep);
+    this.addUnit(exit);
+
+    // `addUnit` adjusts the `next` field, hence the below.
+    nextStep.next = unitForConvergence.flowchartId;
+  }
+};
+exports.ConvergenceMixin = ConvergenceMixin;

package/dist/subworkflows/create.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubworkflow = createSubworkflow;
+exports.createSubworkflowByName = createSubworkflowByName;
+exports.createUnit = createUnit;
+var _ApplicationRegistry = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/ApplicationRegistry"));
+var _mode = require("@exabyte-io/mode.js");
+var _standata = require("@mat3ra/standata");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _units = require("../units");
+var _builders = require("../units/builders");
+var _utils = require("../utils");
+var _dynamic = require("./dynamic");
+var _subworkflow = require("./subworkflow");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// NOTE: DFTModel => DFTModelConfig, configs should have the same name as the model/method class + "Config" at the end
+function _getConfigFromModelOrMethodName(name, kind) {
+  const configs = kind === "Model" ? _mode.default_models : _mode.default_methods;
+  if (!configs[`${name}Config`]) {
+    // eslint-disable-next-line no-param-reassign
+    name = `Unknown${kind}`;
+  }
+  return configs[`${name}Config`];
+}
+
+/**
+ * @summary Create model from subworkflow data
+ * @param config {Object} model config
+ * @param modelFactoryCls {any} model factory to use
+ * @returns {DFTModel|Model}
+ */
+function createModel({
+  config,
+  modelFactoryCls
+}) {
+  const {
+    name,
+    config: modelConfig = {}
+  } = config;
+  const defaultConfig = _getConfigFromModelOrMethodName(name, "Model");
+  return modelFactoryCls.create({
+    ...defaultConfig,
+    ...modelConfig
+  });
+}
+
+/**
+ * @summary Create method from subworkflow data
+ * @param config {Object} method configuration
+ * @param methodFactoryCls {any}
+ * @returns {{method, setSearchText}}
+ */
+function createMethod({
+  config,
+  methodFactoryCls
+}) {
+  const {
+    name,
+    setSearchText = null,
+    config: methodConfig = {}
+  } = config;
+  const defaultConfig = _getConfigFromModelOrMethodName(name, "Method");
+  const method = methodFactoryCls.create({
+    ...defaultConfig,
+    ...methodConfig
+  });
+  return {
+    method,
+    setSearchText
+  };
+}
+
+/**
+ * @summary Create top-level objects used in subworkflow initialization
+ * @param subworkflowData {Object} subworkflow data
+ * @param AppRegistry
+ * @param modelFactoryCls {any} model factory class
+ * @param methodFactoryCls {any} method factory class
+ * @returns {{application: *, method: *, model: (DFTModel|Model), setSearchText: String|null}}
+ */
+function createTopLevel({
+  subworkflowData,
+  modelFactoryCls,
+  methodFactoryCls,
+  AppRegistry
+}) {
+  const {
+    application: appConfig,
+    model: modelConfig,
+    method: methodConfig
+  } = subworkflowData;
+  const application = AppRegistry.createApplication(appConfig);
+  const model = createModel({
+    config: modelConfig,
+    modelFactoryCls
+  });
+  const {
+    method,
+    setSearchText
+  } = createMethod({
+    config: methodConfig,
+    methodFactoryCls
+  });
+  return {
+    application,
+    model,
+    method,
+    setSearchText
+  };
+}
+
+/**
+ * @summary Create workflow unit from JSON configuration
+ *      Supports applying functions to the builder prior to building via "functions"
+ *      Supports applying attributes to the builder after building via "attributes"
+ * @param config {Object} unit config
+ * @param application {*} application
+ * @param unitBuilders {Object} workflow unit builders
+ * @param unitFactoryCls {*} workflow unit class factory
+ * @returns {*|{head: boolean, preProcessors: [], postProcessors: [], name: *, flowchartId: *, type: *, results: [], monitors: []}}
+ */
+function createUnit({
+  config,
+  application,
+  unitBuilders,
+  unitFactoryCls
+}) {
+  const {
+    type,
+    config: unitConfig
+  } = config;
+  if (type === "executionBuilder") {
+    const {
+      name,
+      execName,
+      flavorName,
+      flowchartId
+    } = unitConfig;
+    const builder = new unitBuilders.ExecutionUnitConfigBuilder(name, application, execName, flavorName, flowchartId);
+
+    // config should contain "functions" and "attributes"
+    const cfg = (0, _utils.applyConfig)({
+      obj: builder,
+      config,
+      callBuild: true
+    });
+    return unitFactoryCls.create(cfg);
+  }
+  return unitFactoryCls.create({
+    type,
+    ...unitConfig
+  });
+}
+
+/**
+ * @summary Dynamically create subworkflow units
+ * @param dynamicSubworkflow {String} name of unit creation function
+ * @param units {Array} configured units to provide to dynamic unit creation
+ * @param unitBuilders {Object} unit configuration builders
+ * @param unitFactoryCls {*} unit factory class
+ * @param application {*} application (optional)
+ * @returns {*}
+ */
+function createDynamicUnits({
+  dynamicSubworkflow,
+  units,
+  unitBuilders,
+  unitFactoryCls,
+  application = null
+}) {
+  const {
+    name,
+    subfolder
+  } = dynamicSubworkflow;
+  const func = subfolder && _lodash.default.get(_dynamic.dynamicSubworkflowsByApp, `${subfolder}.${name}`, () => {});
+  switch (name) {
+    case "surfaceEnergy":
+      // eslint-disable-next-line no-case-declarations
+      const [scfUnit] = units;
+      return (0, _dynamic.getSurfaceEnergySubworkflowUnits)({
+        scfUnit,
+        unitBuilders
+      });
+    case "getQpointIrrep":
+      return func({
+        unitBuilders,
+        unitFactoryCls,
+        application
+      });
+    default:
+      throw new Error(`dynamicSubworkflow=${name} not recognized`);
+  }
+}
+function createSubworkflow({
+  subworkflowData,
+  AppRegistry = _ApplicationRegistry.default,
+  modelFactoryCls = _mode.ModelFactory,
+  methodFactoryCls = _mode.MethodFactory,
+  subworkflowCls = _subworkflow.Subworkflow,
+  unitFactoryCls = _units.UnitFactory,
+  unitBuilders = _builders.builders
+}) {
+  const {
+    application,
+    model,
+    method,
+    setSearchText
+  } = createTopLevel({
+    subworkflowData,
+    AppRegistry,
+    modelFactoryCls,
+    methodFactoryCls
+  });
+  let units = [];
+  const {
+    name,
+    units: unitConfigs,
+    config = {},
+    dynamicSubworkflow = null
+  } = subworkflowData;
+  unitConfigs.forEach(_config => {
+    units.push(createUnit({
+      config: _config,
+      application,
+      unitBuilders,
+      unitFactoryCls
+    }));
+  });
+  if (dynamicSubworkflow) {
+    units = createDynamicUnits({
+      dynamicSubworkflow,
+      units,
+      unitBuilders,
+      unitFactoryCls,
+      application
+    });
+  }
+  const {
+    functions = {},
+    attributes = {},
+    ...cfg
+  } = config;
+  let subworkflow = subworkflowCls.fromArguments(application, model, method, name, units, cfg);
+  subworkflow = (0, _utils.applyConfig)({
+    obj: subworkflow,
+    config: {
+      functions,
+      attributes
+    }
+  });
+  if (setSearchText) subworkflow.model.method.setSearchText(setSearchText);
+  return subworkflow;
+}
+
+/**
+ * @summary Convenience wrapper around createSubworkflow to create by app name and swf name
+ * @param appName {String} application name
+ * @param swfName {String} subworkflow name (snake_case.yml)
+ * @param workflowSubworkflowMapByApplication {Object} object containing all workflow/subworkflow map by application
+ * @param swArgs {Object} classes for instantiation
+ * @returns {*} subworkflow object
+ */
+function createSubworkflowByName({
+  appName,
+  swfName,
+  workflowSubworkflowMapByApplication = _standata.workflowSubforkflowMapByApplication,
+  ...swArgs
+}) {
+  const {
+    subworkflows
+  } = workflowSubworkflowMapByApplication;
+  const {
+    [appName]: allSubworkflowData
+  } = subworkflows;
+  const {
+    [swfName]: subworkflowData
+  } = allSubworkflowData;
+  return createSubworkflow({
+    subworkflowData,
+    ...swArgs
+  });
+}

package/dist/subworkflows/dynamic/espresso/getQpointIrrep.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getQpointIrrep = getQpointIrrep;
+var _enums = require("../../../enums");
+/**
+ * @summary Get QptIrr units used in phonon map calculations
+ * @param unitBuilders {Object} unit builders
+ * @param unitFactoryCls {*} unit factory class
+ * @param application {*} application instance
+ * @returns {[{head: boolean, preProcessors: [], postProcessors: [], name: *, flowchartId: *, type: *, results: [], monitors: []},*]}
+ */
+function getQpointIrrep({
+  unitBuilders,
+  unitFactoryCls,
+  application
+}) {
+  const {
+    ExecutionUnitConfigBuilder
+  } = unitBuilders;
+  const pythonUnit = new ExecutionUnitConfigBuilder("python", application, "python", "espresso_xml_get_qpt_irr").build();
+  const assignmentUnit = unitFactoryCls.create({
+    type: _enums.UNIT_TYPES.assignment,
+    input: [{
+      scope: pythonUnit.flowchartId,
+      name: "STDOUT"
+    }],
+    operand: "Q_POINTS",
+    value: "json.loads(STDOUT)"
+  });
+  return [pythonUnit, assignmentUnit];
+}

package/dist/subworkflows/dynamic/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dynamicSubworkflowsByApp = void 0;
+Object.defineProperty(exports, "getSurfaceEnergySubworkflowUnits", {
+  enumerable: true,
+  get: function () {
+    return _surfaceEnergy.getSurfaceEnergySubworkflowUnits;
+  }
+});
+var _getQpointIrrep = require("./espresso/getQpointIrrep");
+var _surfaceEnergy = require("./surfaceEnergy");
+const dynamicSubworkflowsByApp = exports.dynamicSubworkflowsByApp = {
+  espresso: {
+    getQpointIrrep: _getQpointIrrep.getQpointIrrep
+  }
+};

package/dist/subworkflows/dynamic/surfaceEnergy.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSurfaceEnergySubworkflowUnits = getSurfaceEnergySubworkflowUnits;
+var _utils = require("@mat3ra/utils");
+function getIOUnitEndpointOptions(query, projection = "{}") {
+  return {
+    params: {
+      query,
+      projection
+    }
+  };
+}
+function getAssignmentUnitInput(unit, name) {
+  return [{
+    name,
+    scope: unit.flowchartId
+  }];
+}
+function getSurfaceEnergySubworkflowUnits({
+  scfUnit,
+  unitBuilders
+}) {
+  const {
+    IOUnitConfigBuilder,
+    AssignmentUnitConfigBuilder,
+    AssertionUnitConfigBuilder
+  } = unitBuilders;
+  let input, endpointOptions;
+  endpointOptions = getIOUnitEndpointOptions("{'_id': MATERIAL_ID}");
+  const getSlabUnit = new IOUnitConfigBuilder("io-slab", "materials", endpointOptions).build();
+  input = getAssignmentUnitInput(getSlabUnit, "DATA");
+  const setSlabUnit = new AssignmentUnitConfigBuilder("slab", "SLAB", "DATA[0]", input).build();
+  endpointOptions = getIOUnitEndpointOptions("{'_id': SLAB.metadata.bulkId}");
+  const getBulkUnit = new IOUnitConfigBuilder("io-bulk", "materials", endpointOptions).build();
+  const BULKValue = "DATA[0] if DATA else None";
+  input = getAssignmentUnitInput(getBulkUnit, "DATA");
+  const setBulkUnit = new AssignmentUnitConfigBuilder("bulk", "BULK", BULKValue, input).build();
+  const assertBulkUnit = new AssertionUnitConfigBuilder("assert-bulk", "BULK != None", "Bulk material does not exist!").build();
+  const query = _utils.Utils.str.removeNewLinesAndExtraSpaces(`{
+        'exabyteId': BULK.exabyteId,
+        'data.name': 'total_energy',
+        'group': {'$regex': ''.join((SUBWORKFLOW.application.shortName, ':'))}
+    }`);
+  // Do not confuse `sort` with `$sort`. `sort` is used in meteor collections and `$sort` is used in Mongo queries.
+  const projection = "{'sort': {'precision.value': -1}, 'limit': 1}";
+  endpointOptions = getIOUnitEndpointOptions(query, projection);
+  const getEBulkUnit = new IOUnitConfigBuilder("io-e-bulk", "refined-properties", endpointOptions).build();
+  input = getAssignmentUnitInput(getEBulkUnit, "DATA");
+  const EBULKValue = "DATA[0].data.value if DATA else None";
+  const setEBulkUnit = new AssignmentUnitConfigBuilder("e-bulk", "E_BULK", EBULKValue, input).build();
+  const assertEBulkUnit = new AssertionUnitConfigBuilder("assert-e-bulk", "E_BULK != None", "E_BULK does not exist!").build();
+  const AValue = "np.linalg.norm(np.cross(SLAB.lattice.vectors.a, SLAB.lattice.vectors.b))";
+  const setSurfaceUnit = new AssignmentUnitConfigBuilder("surface", "A", AValue).build();
+  const setNBulkUnit = new AssignmentUnitConfigBuilder("n-bulk", "N_BULK", "len(BULK.basis.elements)").build();
+  const setNSlabUnit = new AssignmentUnitConfigBuilder("n-slab", "N_SLAB", "len(SLAB.basis.elements)").build();
+  input = getAssignmentUnitInput(scfUnit, "total_energy");
+  const setESlabUnit = new AssignmentUnitConfigBuilder("e-slab", "E_SLAB", "total_energy", input).build();
+  const results = [{
+    name: "surface_energy"
+  }];
+  const SEValue = "1 / (2 * A) * (E_SLAB - E_BULK * (N_SLAB/N_BULK))";
+  const surfaceEnergyUnit = new AssignmentUnitConfigBuilder("surface-energy", "SURFACE_ENERGY", SEValue, [], results).build();
+  return [getSlabUnit, setSlabUnit, getBulkUnit, setBulkUnit, assertBulkUnit, getEBulkUnit, setEBulkUnit, assertEBulkUnit, setSurfaceUnit, setNBulkUnit, setNSlabUnit, scfUnit, setESlabUnit, surfaceEnergyUnit];
+}