@mat3ra/wode 2025.10.1-0

package/dist/context/providers/by_application/nwchem/NWChemTotalEnergyContextProvider.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _periodicTable = require("@exabyte-io/periodic-table.js");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _underscore = _interopRequireDefault(require("underscore"));
+var _underscore2 = _interopRequireDefault(require("underscore.string"));
+var _JobContextMixin = require("../../../mixins/JobContextMixin");
+var _MaterialContextMixin = require("../../../mixins/MaterialContextMixin");
+var _MethodDataContextMixin = require("../../../mixins/MethodDataContextMixin");
+var _WorkflowContextMixin = require("../../../mixins/WorkflowContextMixin");
+var _ExecutableContextProvider = _interopRequireDefault(require("../ExecutableContextProvider"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class NWChemTotalEnergyContextProvider extends _ExecutableContextProvider.default {
+  constructor(config) {
+    super(config);
+    _defineProperty(this, "_material", undefined);
+    this.initMethodDataContextMixin();
+    this.initWorkflowContextMixin();
+    this.initJobContextMixin();
+    this.initMaterialContextMixin();
+  }
+  get atomicPositionsWithoutConstraints() {
+    return this.material.Basis.atomicPositions;
+  }
+  get atomicPositions() {
+    const basis = this.material.Basis;
+    basis.toCartesian();
+    return basis.getAtomicPositionsWithConstraintsAsStrings();
+  }
+  get atomSymbols() {
+    return this.material.Basis.uniqueElements;
+  }
+  get cartesianAtomicPositions() {
+    return this.material.Basis.toCartesian !== undefined;
+  }
+  get ATOMIC_SPECIES() {
+    return _underscore.default.map(this.atomSymbols, symbol => {
+      return NWChemTotalEnergyContextProvider.symbolToAtomicSpecies(symbol);
+    }).join("\n");
+  }
+
+  /*
+   * @NOTE: Overriding getData makes this provider "stateless", ie. delivering data from scratch each time and not
+   *        considering the content of `this.data`, and `this.isEdited` field(s).
+   */
+  getData() {
+    /*
+    TODO: Create ability for user to define CHARGE, MULT, BASIS and FUNCTIONAL parameters.
+     */
+    const CHARGE = 0;
+    const MULT = 1;
+    const BASIS = "6-31G";
+    const FUNCTIONAL = "B3LYP";
+    return {
+      CHARGE,
+      MULT,
+      BASIS,
+      NAT: this.atomicPositions.length,
+      NTYP: this.atomSymbols.length,
+      ATOMIC_POSITIONS: this.atomicPositions.join("\n"),
+      ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: this.atomicPositionsWithoutConstraints.join("\n"),
+      ATOMIC_SPECIES: this.ATOMIC_SPECIES,
+      FUNCTIONAL,
+      CARTESIAN: this.cartesianAtomicPositions
+    };
+  }
+  static symbolToAtomicSpecies(symbol, pseudo) {
+    const el = _periodicTable.PERIODIC_TABLE[symbol];
+    const filename = pseudo ? _lodash.default.get(pseudo, "filename", _underscore2.default.strRightBack(pseudo.path || "", "/")) : "";
+    return el ? _underscore2.default.sprintf("%s %f %s", symbol, el.atomic_mass, filename) : undefined;
+  }
+}
+exports.default = NWChemTotalEnergyContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(NWChemTotalEnergyContextProvider.prototype);
+(0, _MethodDataContextMixin.methodDataContextMixin)(NWChemTotalEnergyContextProvider.prototype);
+(0, _WorkflowContextMixin.workflowContextMixin)(NWChemTotalEnergyContextProvider.prototype);
+(0, _JobContextMixin.jobContextMixin)(NWChemTotalEnergyContextProvider.prototype);

package/dist/context/providers/by_application/vasp/VASPContextProvider.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _JobContextMixin = require("../../../mixins/JobContextMixin");
+var _MaterialContextMixin = require("../../../mixins/MaterialContextMixin");
+var _MaterialsContextMixin = require("../../../mixins/MaterialsContextMixin");
+var _MethodDataContextMixin = require("../../../mixins/MethodDataContextMixin");
+var _WorkflowContextMixin = require("../../../mixins/WorkflowContextMixin");
+var _ExecutableContextProvider = _interopRequireDefault(require("../ExecutableContextProvider"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class VASPContextProvider extends _ExecutableContextProvider.default {
+  constructor(config) {
+    super(config);
+    _defineProperty(this, "_material", undefined);
+    _defineProperty(this, "_materials", []);
+    this.initJobContextMixin();
+    this.initMaterialsContextMixin();
+    this.initMethodDataContextMixin();
+    this.initWorkflowContextMixin();
+    this.initMaterialContextMixin();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  buildVASPContext(material) {
+    return {
+      // TODO: figure out whether we need two separate POSCARS, maybe one is enough
+      POSCAR: material.getAsPOSCAR(true, true),
+      POSCAR_WITH_CONSTRAINTS: material.getAsPOSCAR(true)
+    };
+  }
+  getDataPerMaterial() {
+    if (!this.materials || this.materials.length <= 1) return {};
+    return {
+      perMaterial: this.materials.map(material => this.buildVASPContext(material))
+    };
+  }
+
+  /*
+   * @NOTE: Overriding getData makes this provider "stateless", ie. delivering data from scratch each time and not
+   *        considering the content of `this.data`, and `this.isEdited` field(s).
+   */
+  getData() {
+    // consider adjusting so that below values are read from PlanewaveDataManager
+    // ECUTWFC;
+    // ECUTRHO;
+
+    return {
+      ...this.buildVASPContext(this.material),
+      ...this.getDataPerMaterial()
+    };
+  }
+}
+exports.default = VASPContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(VASPContextProvider.prototype);
+(0, _MaterialsContextMixin.materialsContextMixin)(VASPContextProvider.prototype);
+(0, _MethodDataContextMixin.methodDataContextMixin)(VASPContextProvider.prototype);
+(0, _WorkflowContextMixin.workflowContextMixin)(VASPContextProvider.prototype);
+(0, _JobContextMixin.jobContextMixin)(VASPContextProvider.prototype);

package/dist/context/providers/by_application/vasp/VASPNEBContextProvider.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _JobContextMixin = require("../../../mixins/JobContextMixin");
+var _MaterialContextMixin = require("../../../mixins/MaterialContextMixin");
+var _MaterialsContextMixin = require("../../../mixins/MaterialsContextMixin");
+var _MaterialsSetContextMixin = require("../../../mixins/MaterialsSetContextMixin");
+var _MethodDataContextMixin = require("../../../mixins/MethodDataContextMixin");
+var _WorkflowContextMixin = require("../../../mixins/WorkflowContextMixin");
+var _ExecutableContextProvider = _interopRequireDefault(require("../ExecutableContextProvider"));
+var _VASPContextProvider = _interopRequireDefault(require("./VASPContextProvider"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class VASPNEBContextProvider extends _ExecutableContextProvider.default {
+  constructor(config) {
+    super(config);
+    _defineProperty(this, "_materials", []);
+    this.initMaterialContextMixin();
+    this.initMaterialsContextMixin();
+    this.initMaterialsSetContextMixin();
+    this.initMethodDataContextMixin();
+    this.initWorkflowContextMixin();
+    this.initJobContextMixin();
+  }
+  getData() {
+    const sortedMaterials = this.sortMaterialsByIndexInSet(this.materials);
+    const VASPContexts = sortedMaterials.map(material => {
+      const context = {
+        ...this.config.context,
+        material
+      };
+      const config = {
+        ...this.config,
+        context
+      };
+      return new _VASPContextProvider.default(config).getData();
+    });
+    return {
+      FIRST_IMAGE: VASPContexts[0].POSCAR_WITH_CONSTRAINTS,
+      LAST_IMAGE: VASPContexts[VASPContexts.length - 1].POSCAR_WITH_CONSTRAINTS,
+      INTERMEDIATE_IMAGES: VASPContexts.slice(1, VASPContexts.length - 1).map(data => data.POSCAR_WITH_CONSTRAINTS)
+    };
+  }
+}
+exports.default = VASPNEBContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(VASPNEBContextProvider.prototype);
+(0, _MaterialsContextMixin.materialsContextMixin)(VASPNEBContextProvider.prototype);
+(0, _MaterialsSetContextMixin.materialsSetContextMixin)(VASPNEBContextProvider.prototype);
+(0, _MethodDataContextMixin.methodDataContextMixin)(VASPNEBContextProvider.prototype);
+(0, _WorkflowContextMixin.workflowContextMixin)(VASPNEBContextProvider.prototype);
+(0, _JobContextMixin.jobContextMixin)(VASPNEBContextProvider.prototype);

package/dist/context/providers/settings.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.globalSettings = void 0;
+var _ade = require("@exabyte-io/ade.js");
+var _made = require("@mat3ra/made");
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class GlobalSettings {
+  constructor() {
+    _defineProperty(this, "PointsGridFormDataProvider.defaultKPPRA", 5);
+    _defineProperty(this, "Material", _made.Made.Material);
+    _defineProperty(this, "Application", _ade.Application);
+    this.resetDefaults();
+  }
+  get defaultKPPRA() {
+    return this["PointsGridFormDataProvider.defaultKPPRA"];
+  }
+  setApplication(application) {
+    this.Application = application;
+  }
+  setMaterial(material) {
+    this.Material = material;
+  }
+  setDefaultKPPRA(kppra) {
+    this["PointsGridFormDataProvider.defaultKPPRA"] = kppra;
+  }
+  resetDefaults() {
+    this.Material = _made.Made.Material;
+    this.Application = _ade.Application;
+    this["PointsGridFormDataProvider.defaultKPPRA"] = 5;
+  }
+}
+const globalSettings = exports.globalSettings = new GlobalSettings();

package/dist/context/providers.js

@@ -0,0 +1,199 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wodeProviders = void 0;
+var _context = _interopRequireDefault(require("./context"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  BoundaryConditionsFormDataProvider,
+  MLSettingsContextProvider,
+  MLTrainTestSplitContextProvider,
+  NEBFormDataProvider,
+  PlanewaveCutoffsContextProvider,
+  PointsGridFormDataProvider,
+  PointsPathFormDataProvider,
+  ExplicitPointsPathFormDataProvider,
+  ExplicitPointsPath2PIBAFormDataProvider,
+  HubbardJContextProvider,
+  HubbardUContextProvider,
+  HubbardVContextProvider,
+  HubbardContextProviderLegacy,
+  IonDynamicsContextProvider,
+  CollinearMagnetizationContextProvider,
+  NonCollinearMagnetizationContextProvider,
+  VASPContextProvider,
+  VASPNEBContextProvider,
+  QEPWXContextProvider,
+  QENEBContextProvider,
+  NWChemTotalEnergyContextProvider
+} = _context.default;
+const CONTEXT_DOMAINS = {
+  important: "important" // used to generate `ImportantSettings` form
+};
+const _makeImportant = config => Object.assign(config, {
+  domain: CONTEXT_DOMAINS.important
+});
+
+/** ********************************
+ * Method-based context providers *
+ ********************************* */
+
+const wodeProviders = exports.wodeProviders = {
+  // NOTE: subworkflow-level data manager. Will override the unit-level data with the same name via subworkflow context.
+  PlanewaveCutoffDataManager: {
+    providerCls: PlanewaveCutoffsContextProvider,
+    config: _makeImportant({
+      name: "cutoffs",
+      entityName: "subworkflow"
+    })
+  },
+  KGridFormDataManager: {
+    providerCls: PointsGridFormDataProvider,
+    config: _makeImportant({
+      name: "kgrid"
+    })
+  },
+  QGridFormDataManager: {
+    providerCls: PointsGridFormDataProvider,
+    config: _makeImportant({
+      name: "qgrid",
+      divisor: 5
+    }) // Using less points for Qgrid by default
+  },
+  IGridFormDataManager: {
+    providerCls: PointsGridFormDataProvider,
+    config: _makeImportant({
+      name: "igrid",
+      divisor: 0.2
+    }) // Using more points for interpolated grid by default
+  },
+  QPathFormDataManager: {
+    providerCls: PointsPathFormDataProvider,
+    config: _makeImportant({
+      name: "qpath"
+    })
+  },
+  IPathFormDataManager: {
+    providerCls: PointsPathFormDataProvider,
+    config: _makeImportant({
+      name: "ipath"
+    })
+  },
+  KPathFormDataManager: {
+    providerCls: PointsPathFormDataProvider,
+    config: _makeImportant({
+      name: "kpath"
+    })
+  },
+  ExplicitKPathFormDataManager: {
+    providerCls: ExplicitPointsPathFormDataProvider,
+    config: _makeImportant({
+      name: "explicitKPath"
+    })
+  },
+  ExplicitKPath2PIBAFormDataManager: {
+    providerCls: ExplicitPointsPath2PIBAFormDataProvider,
+    config: _makeImportant({
+      name: "explicitKPath2PIBA"
+    })
+  },
+  HubbardJContextManager: {
+    providerCls: HubbardJContextProvider,
+    config: _makeImportant({
+      name: "hubbard_j"
+    })
+  },
+  HubbardUContextManager: {
+    providerCls: HubbardUContextProvider,
+    config: _makeImportant({
+      name: "hubbard_u"
+    })
+  },
+  HubbardVContextManager: {
+    providerCls: HubbardVContextProvider,
+    config: _makeImportant({
+      name: "hubbard_v"
+    })
+  },
+  HubbardContextManagerLegacy: {
+    providerCls: HubbardContextProviderLegacy,
+    config: _makeImportant({
+      name: "hubbard_legacy"
+    })
+  },
+  // NEBFormDataManager context is stored under the same key (`input`) as InputDataManager contexts.
+  NEBFormDataManager: {
+    providerCls: NEBFormDataProvider,
+    config: _makeImportant({
+      name: "neb"
+    })
+  },
+  BoundaryConditionsFormDataManager: {
+    providerCls: BoundaryConditionsFormDataProvider,
+    config: _makeImportant({
+      name: "boundaryConditions"
+    })
+  },
+  MLSettingsDataManager: {
+    providerCls: MLSettingsContextProvider,
+    config: _makeImportant({
+      name: "mlSettings"
+    })
+  },
+  MLTrainTestSplitDataManager: {
+    providerCls: MLTrainTestSplitContextProvider,
+    config: _makeImportant({
+      name: "mlTrainTestSplit"
+    })
+  },
+  IonDynamicsContextProvider: {
+    providerCls: IonDynamicsContextProvider,
+    config: _makeImportant({
+      name: "dynamics"
+    })
+  },
+  CollinearMagnetizationDataManager: {
+    providerCls: CollinearMagnetizationContextProvider,
+    config: _makeImportant({
+      name: "collinearMagnetization"
+    })
+  },
+  NonCollinearMagnetizationDataManager: {
+    providerCls: NonCollinearMagnetizationContextProvider,
+    config: _makeImportant({
+      name: "nonCollinearMagnetization"
+    })
+  },
+  QEPWXInputDataManager: {
+    providerCls: QEPWXContextProvider,
+    config: {
+      name: "input"
+    }
+  },
+  QENEBInputDataManager: {
+    providerCls: QENEBContextProvider,
+    config: {
+      name: "input"
+    }
+  },
+  VASPInputDataManager: {
+    providerCls: VASPContextProvider,
+    config: {
+      name: "input"
+    }
+  },
+  VASPNEBInputDataManager: {
+    providerCls: VASPNEBContextProvider,
+    config: {
+      name: "input"
+    }
+  },
+  NWChemInputDataManager: {
+    providerCls: NWChemTotalEnergyContextProvider,
+    config: {
+      name: "input"
+    }
+  }
+};

package/dist/enums.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WORKFLOW_STATUSES = exports.UNIT_TYPES = exports.UNIT_TAGS = exports.UNIT_STATUSES = exports.UNIT_NAME_INVALID_CHARS = exports.TAB_NAVIGATION_CONFIG = exports.IO_ID_COLUMN = void 0;
+/**
+ * THIS ENUMS ARE SHARED WITH TESTS.
+ * DO NOT IMPORT ANYTHINGS IN THIS MODULE.
+ */
+
+const IO_ID_COLUMN = exports.IO_ID_COLUMN = "exabyteId";
+const UNIT_TYPES = exports.UNIT_TYPES = {
+  // not currently used
+  convergence: "convergence",
+  exit: "exit",
+  // actively used
+  execution: "execution",
+  map: "map",
+  reduce: "reduce",
+  assignment: "assignment",
+  condition: "condition",
+  subworkflow: "subworkflow",
+  processing: "processing",
+  io: "io",
+  assertion: "assertion"
+};
+const UNIT_STATUSES = exports.UNIT_STATUSES = {
+  idle: "idle",
+  active: "active",
+  finished: "finished",
+  error: "error",
+  warning: "warning"
+};
+const UNIT_TAGS = exports.UNIT_TAGS = {
+  hasConvergenceParam: "hasConvergenceParam",
+  hasConvergenceResult: "hasConvergenceResult"
+};
+const WORKFLOW_STATUSES = exports.WORKFLOW_STATUSES = {
+  "up-to-date": "up-to-date",
+  outdated: "outdated"
+};
+const TAB_NAVIGATION_CONFIG = exports.TAB_NAVIGATION_CONFIG = {
+  overview: {
+    itemName: "Overview",
+    className: "",
+    href: "sw-overview"
+  },
+  importantSettings: {
+    itemName: "Important settings",
+    className: "",
+    href: "sw-important-settings"
+  },
+  detailedView: {
+    itemName: "Detailed view",
+    className: "",
+    href: "sw-detailed-view"
+  },
+  compute: {
+    itemName: "Compute",
+    className: "",
+    href: "sw-compute"
+  }
+};
+const UNIT_NAME_INVALID_CHARS = exports.UNIT_NAME_INVALID_CHARS = "/";

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Subworkflow", {
+  enumerable: true,
+  get: function () {
+    return _subworkflows.Subworkflow;
+  }
+});
+Object.defineProperty(exports, "UNIT_STATUSES", {
+  enumerable: true,
+  get: function () {
+    return _enums.UNIT_STATUSES;
+  }
+});
+Object.defineProperty(exports, "UNIT_TYPES", {
+  enumerable: true,
+  get: function () {
+    return _enums.UNIT_TYPES;
+  }
+});
+Object.defineProperty(exports, "UnitFactory", {
+  enumerable: true,
+  get: function () {
+    return _factory.UnitFactory;
+  }
+});
+Object.defineProperty(exports, "Workflow", {
+  enumerable: true,
+  get: function () {
+    return _workflows.Workflow;
+  }
+});
+Object.defineProperty(exports, "builders", {
+  enumerable: true,
+  get: function () {
+    return _builders.builders;
+  }
+});
+Object.defineProperty(exports, "createSubworkflowByName", {
+  enumerable: true,
+  get: function () {
+    return _subworkflows.createSubworkflowByName;
+  }
+});
+Object.defineProperty(exports, "createWorkflowConfigs", {
+  enumerable: true,
+  get: function () {
+    return _workflows.createWorkflowConfigs;
+  }
+});
+Object.defineProperty(exports, "createWorkflows", {
+  enumerable: true,
+  get: function () {
+    return _workflows.createWorkflows;
+  }
+});
+var _enums = require("./enums");
+var _subworkflows = require("./subworkflows");
+var _builders = require("./units/builders");
+var _factory = require("./units/factory");
+var _workflows = require("./workflows");

package/dist/patch.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Template", {
+  enumerable: true,
+  get: function () {
+    return _ade.Template;
+  }
+});
+var _ade = require("@exabyte-io/ade.js");
+var _providers = require("./context/providers");
+// We patch the static providerRegistry here so that
+// Template has all context providers available
+// to it when creating workflows. It is then re-exported
+// from WoDe for use downstream.
+
+_ade.Template.setContextProvidersConfig(_providers.wodeProviders);

package/dist/subworkflows/convergence/factory.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConvergenceParameter = createConvergenceParameter;
+var _non_uniform_kgrid = require("./non_uniform_kgrid");
+var _parameter = require("./parameter");
+var _uniform_kgrid = require("./uniform_kgrid");
+function createConvergenceParameter({
+  name,
+  initialValue,
+  increment
+}) {
+  switch (name) {
+    case "N_k":
+      return new _uniform_kgrid.UniformKGridConvergence({
+        name,
+        initialValue,
+        increment
+      });
+    case "N_k_nonuniform":
+      return new _non_uniform_kgrid.NonUniformKGridConvergence({
+        name,
+        initialValue,
+        increment
+      });
+    default:
+      return new _parameter.ConvergenceParameter({
+        name,
+        initialValue,
+        increment
+      });
+  }
+}

package/dist/subworkflows/convergence/non_uniform_kgrid.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NonUniformKGridConvergence = void 0;
+var _parameter = require("./parameter");
+class NonUniformKGridConvergence extends _parameter.ConvergenceParameter {
+  get increment() {
+    return `[${this.initialValue}[i] + math.floor(iteration * ${this._increment} * float(context['kgrid']['reciprocalVectorRatios'][i])) for i in range(3)]`;
+  }
+  get unitContext() {
+    return {
+      kgrid: {
+        dimensions: [`{{${this.name}[0]}}`, `{{${this.name}[1]}}`, `{{${this.name}[2]}}`],
+        shifts: [0, 0, 0]
+      },
+      isKgridEdited: true,
+      isUsingJinjaVariables: true
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  useVariablesFromUnitContext(flowchartId) {
+    return [{
+      scope: flowchartId,
+      name: "context"
+    }];
+  }
+}
+exports.NonUniformKGridConvergence = NonUniformKGridConvergence;