@mat3ra/wode 2025.10.1-0

package/dist/context/providers/PointsGridFormDataProvider.js

@@ -0,0 +1,272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PointsGridFormDataProvider = void 0;
+var _JSONSchemaFormDataProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider"));
+var _constants = require("@mat3ra/code/dist/js/constants");
+var _math = require("@mat3ra/code/dist/js/math");
+var _made = require("@mat3ra/made");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _MaterialContextMixin = require("../mixins/MaterialContextMixin");
+var _settings = require("./settings");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class PointsGridFormDataProvider extends _JSONSchemaFormDataProvider.default {
+  constructor(config) {
+    super(config);
+    this.initMaterialContextMixin();
+    this._divisor = config.divisor || 1; // KPPRA will be divided by this number
+    this.reciprocalLattice = new _made.Made.ReciprocalLattice(this.material.lattice);
+    this.dimensions = _lodash.default.get(this.data, "dimensions") || this._defaultDimensions;
+    this.shifts = _lodash.default.get(this.data, "shifts") || this._defaultShifts;
+
+    // init class fields from data (as constructed from context in parent)
+    this.gridMetricType = _lodash.default.get(this.data, "gridMetricType") || "KPPRA";
+    this.gridMetricValue = _lodash.default.get(this.data, "gridMetricValue") || this._getDefaultGridMetricValue("KPPRA");
+    this.preferGridMetric = _lodash.default.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(_settings.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(_math.math.numberToPrecision(r, 3)));
+  }
+  get jsonSchema() {
+    const vector = {
+      type: "array",
+      items: {
+        type: "number"
+      },
+      minItems: 3,
+      maxItems: 3
+    };
+    const vector_ = (defaultValue, isStringType = false) => {
+      const isArray = Array.isArray(defaultValue);
+      return {
+        ...vector,
+        items: {
+          type: isStringType ? "string" : "number",
+          ...(isArray ? {} : {
+            default: defaultValue
+          })
+        },
+        ...(isArray ? {
+          default: defaultValue
+        } : {})
+      };
+    };
+    return {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      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"
+        }
+      },
+      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
+              }
+            }
+          }]
+        }
+      },
+      required: ["dimensions", "shifts"]
+    };
+  }
+  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 = _constants.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 = _constants.units.angstrom
+  }) {
+    switch (gridMetricType) {
+      case "KPPRA":
+        return this._getKPPRAFromDimensions(dimensions);
+      case "spacing":
+        return _lodash.default.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;
+  }
+}
+exports.PointsGridFormDataProvider = PointsGridFormDataProvider;
+(0, _MaterialContextMixin.materialContextMixin)(PointsGridFormDataProvider.prototype);

package/dist/context/providers/PointsPathFormDataProvider.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PointsPathFormDataProvider = exports.ExplicitPointsPathFormDataProvider = exports.ExplicitPointsPath2PIBAFormDataProvider = void 0;
+var _JSONSchemaFormDataProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/JSONSchemaFormDataProvider"));
+var _math = require("@mat3ra/code/dist/js/math");
+var _made = require("@mat3ra/made");
+var _underscore = _interopRequireDefault(require("underscore.string"));
+var _ApplicationContextMixin = require("../mixins/ApplicationContextMixin");
+var _MaterialContextMixin = require("../mixins/MaterialContextMixin");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable max-classes-per-file */
+/* eslint react/prop-types: 0 */
+
+const defaultPoint = "Г";
+const defaultSteps = 10;
+class PointsPathFormDataProvider extends _JSONSchemaFormDataProvider.default {
+  constructor(config) {
+    super(config);
+    this.initMaterialContextMixin();
+    this.initApplicationContextMixin();
+    this.reciprocalLattice = new _made.Made.ReciprocalLattice(this.material.lattice);
+    this.symmetryPoints = this.symmetryPointsFromMaterial;
+  }
+  get isEditedIsSetToFalseOnMaterialUpdate() {
+    return this.isMaterialUpdated || this.isMaterialCreatedDefault;
+  }
+  get defaultData() {
+    return this.reciprocalLattice.defaultKpointPath;
+  }
+  get symmetryPointsFromMaterial() {
+    return this.reciprocalLattice.symmetryPoints;
+  }
+  get jsonSchema() {
+    // no need to pass context to get symmetry points on client
+    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
+          }
+        }
+      },
+      minItems: 1
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get uiSchema() {
+    return {
+      items: {}
+    };
+  }
+  get uiSchemaStyled() {
+    return {
+      items: {
+        point: this.defaultFieldStyles,
+        steps: this.defaultFieldStyles
+      }
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get templates() {
+    return {};
+  }
+  getBrillouinZoneImageComponent(title) {
+    const hasRequiredFn = typeof this.material.getBrillouinZoneImageComponent === "function";
+    if (!hasRequiredFn) {
+      console.log("PointsPathFormDataProvider: Material class has no function" + " 'getBrillouinZoneImageComponent'! Returning empty Object instead.");
+      return null;
+    }
+    return this.material.getBrillouinZoneImageComponent(title);
+  }
+  get useExplicitPath() {
+    return this.application.name === "vasp";
+  }
+
+  // override yieldData to avoid storing explicit path in saved context
+  yieldDataForRendering() {
+    return this.yieldData(this.useExplicitPath);
+  }
+  transformData(path = [], useExplicitPath = false) {
+    const rawData = path.map(p => {
+      const point = this.symmetryPoints.find(sp => sp.point === p.point);
+      return {
+        ...p,
+        coordinates: point.coordinates
+      };
+    });
+    const processedData = useExplicitPath ? this._convertToExplicitPath(rawData) : rawData;
+    // make coordinates into string and add formatting
+    return processedData.map(p => {
+      const coordinates = this.is2PIBA ? this.get2PIBACoordinates(p.coordinates) : p.coordinates;
+      p.coordinates = coordinates.map(c => _underscore.default.sprintf("%14.9f", c));
+      return p;
+    });
+  }
+  get2PIBACoordinates(point) {
+    return this.reciprocalLattice.getCartesianCoordinates(point);
+  }
+
+  // Initially, path contains symmetry points with steps counts.
+  // This function explicitly calculates each point between symmetry points by step counts.
+  // eslint-disable-next-line class-methods-use-this
+  _convertToExplicitPath(path) {
+    const points = [];
+    for (let i = 0; i < path.length - 1; i++) {
+      const startPoint = path[i];
+      const endPoint = path[i + 1];
+      const middlePoints = _math.math.calculateSegmentsBetweenPoints3D(startPoint.coordinates, endPoint.coordinates, startPoint.steps);
+      points.push(startPoint.coordinates);
+      points.push(...middlePoints);
+      // Include endPoint into path for the last section, otherwise it will be included by next loop iteration
+      if (path.length - 2 === i) points.push(endPoint.coordinates);
+    }
+    return points.map(x => {
+      return {
+        coordinates: x,
+        steps: 1
+      };
+    });
+  }
+}
+exports.PointsPathFormDataProvider = PointsPathFormDataProvider;
+class ExplicitPointsPathFormDataProvider extends PointsPathFormDataProvider {
+  // eslint-disable-next-line class-methods-use-this
+  get useExplicitPath() {
+    return true;
+  }
+}
+exports.ExplicitPointsPathFormDataProvider = ExplicitPointsPathFormDataProvider;
+class ExplicitPointsPath2PIBAFormDataProvider extends ExplicitPointsPathFormDataProvider {
+  // eslint-disable-next-line class-methods-use-this
+  get is2PIBA() {
+    return true;
+  }
+}
+exports.ExplicitPointsPath2PIBAFormDataProvider = ExplicitPointsPath2PIBAFormDataProvider;
+(0, _MaterialContextMixin.materialContextMixin)(PointsPathFormDataProvider.prototype);
+(0, _ApplicationContextMixin.applicationContextMixin)(PointsPathFormDataProvider.prototype);

package/dist/context/providers/by_application/ExecutableContextProvider.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ContextProvider = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/context/ContextProvider"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ExecutableContextProvider extends _ContextProvider.default {
+  constructor(config) {
+    super({
+      ...config,
+      domain: "executable"
+    });
+  }
+}
+exports.default = ExecutableContextProvider;

package/dist/context/providers/by_application/espresso/QENEBContextProvider.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+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 _QEPWXContextProvider = _interopRequireDefault(require("./QEPWXContextProvider"));
+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 QENEBContextProvider extends _ExecutableContextProvider.default {
+  constructor(config) {
+    super(config);
+    _defineProperty(this, "_material", undefined);
+    _defineProperty(this, "_materials", []);
+    _defineProperty(this, "_materialsSet", undefined);
+    this.initJobContextMixin();
+    this.initMaterialsContextMixin();
+    this.initMethodDataContextMixin();
+    this.initWorkflowContextMixin();
+    this.initMaterialContextMixin();
+    this.initMaterialsSetContextMixin();
+  }
+  getData() {
+    const sortedMaterials = this.sortMaterialsByIndexInSet(this.materials);
+    const PWXContexts = sortedMaterials.map(material => {
+      const context = {
+        ...this.config.context,
+        material
+      };
+      const config = {
+        ...this.config,
+        context
+      };
+      return new _QEPWXContextProvider.default(config).getData();
+    });
+    return {
+      ..._lodash.default.omit(PWXContexts[0], ["ATOMIC_POSITIONS", "ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS"]),
+      FIRST_IMAGE: PWXContexts[0].ATOMIC_POSITIONS,
+      LAST_IMAGE: PWXContexts[PWXContexts.length - 1].ATOMIC_POSITIONS,
+      INTERMEDIATE_IMAGES: PWXContexts.slice(1, PWXContexts.length - 1).map(data => data.ATOMIC_POSITIONS)
+    };
+  }
+}
+exports.default = QENEBContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(QENEBContextProvider.prototype);
+(0, _MaterialsContextMixin.materialsContextMixin)(QENEBContextProvider.prototype);
+(0, _MethodDataContextMixin.methodDataContextMixin)(QENEBContextProvider.prototype);
+(0, _WorkflowContextMixin.workflowContextMixin)(QENEBContextProvider.prototype);
+(0, _JobContextMixin.jobContextMixin)(QENEBContextProvider.prototype);
+(0, _MaterialsSetContextMixin.materialsSetContextMixin)(QENEBContextProvider.prototype);

package/dist/context/providers/by_application/espresso/QEPWXContextProvider.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _periodicTable = require("@exabyte-io/periodic-table.js");
+var _path = _interopRequireDefault(require("path"));
+var _underscore = _interopRequireDefault(require("underscore.string"));
+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 QEPWXContextProvider extends _ExecutableContextProvider.default {
+  constructor(config) {
+    super(config);
+    _defineProperty(this, "_material", undefined);
+    _defineProperty(this, "_materials", []);
+    this.initMaterialsContextMixin();
+    this.initMethodDataContextMixin();
+    this.initWorkflowContextMixin();
+    this.initJobContextMixin();
+    this.initMaterialContextMixin();
+  }
+  static atomSymbols(material) {
+    return material.Basis.uniqueElements;
+  }
+  static uniqueElementsWithLabels(material) {
+    // return unique items
+    return [...new Set(material.Basis.elementsWithLabelsArray)];
+  }
+
+  /** Returns the input text block for atomic positions WITH constraints.
+   */
+  static atomicPositionsWithConstraints(material) {
+    return material.Basis.getAtomicPositionsWithConstraintsAsStrings().join("\n");
+  }
+
+  /** Returns the input text block for atomic positions
+   *  Note: does NOT include constraints
+   */
+  static atomicPositions(material) {
+    return material.Basis.atomicPositions.join("\n");
+  }
+  static NAT(material) {
+    return material.Basis.atomicPositions.length;
+  }
+  static NTYP(material) {
+    return material.Basis.uniqueElements.length;
+  }
+  static NTYP_WITH_LABELS(material) {
+    return this.uniqueElementsWithLabels(material).length;
+  }
+  buildQEPWXContext(material) {
+    const IBRAV = 0; // use CELL_PARAMETERS to define Bravais lattice
+
+    return {
+      IBRAV,
+      RESTART_MODE: this.RESTART_MODE,
+      ATOMIC_SPECIES: this.ATOMIC_SPECIES(material),
+      ATOMIC_SPECIES_WITH_LABELS: this.ATOMIC_SPECIES_WITH_LABELS(material),
+      NAT: QEPWXContextProvider.NAT(material),
+      NTYP: QEPWXContextProvider.NTYP(material),
+      NTYP_WITH_LABELS: QEPWXContextProvider.NTYP_WITH_LABELS(material),
+      ATOMIC_POSITIONS: QEPWXContextProvider.atomicPositionsWithConstraints(material),
+      ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: QEPWXContextProvider.atomicPositions(material),
+      CELL_PARAMETERS: QEPWXContextProvider.CELL_PARAMETERS(material)
+    };
+  }
+  getDataPerMaterial() {
+    if (!this.materials || this.materials.length <= 1) return {};
+    return {
+      perMaterial: this.materials.map(material => this.buildQEPWXContext(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() {
+    // the below values are read from PlanewaveDataManager instead
+    // ECUTWFC = 40;
+    // ECUTRHO = 200;
+
+    return {
+      ...this.buildQEPWXContext(this.material),
+      ...this.getDataPerMaterial()
+    };
+  }
+  get RESTART_MODE() {
+    return this.job.parentJob || this.workflow.hasRelaxation ? "restart" : "from_scratch";
+  }
+  getPseudoBySymbol(symbol) {
+    return (this.methodData.pseudo || []).find(p => p.element === symbol);
+  }
+
+  /** Builds ATOMIC SPECIES block of pw.x input in the format
+   *  X   Mass_X   PseudoPot_X
+   *  where X            is the atom label
+   *        Mass_X       is the mass of element X [amu]
+   *        PseudoPot_X  is the pseudopotential filename associated with element X
+   *
+   *  Note: assumes this.methodData is defined
+   */
+  ATOMIC_SPECIES(material) {
+    return QEPWXContextProvider.atomSymbols(material).map(symbol => {
+      const pseudo = this.getPseudoBySymbol(symbol);
+      return QEPWXContextProvider.symbolToAtomicSpecie(symbol, pseudo);
+    }).join("\n");
+  }
+  ATOMIC_SPECIES_WITH_LABELS(material) {
+    return QEPWXContextProvider.uniqueElementsWithLabels(material).map(symbol => {
+      const symbolWithoutLabel = symbol.replace(/\d$/, "");
+      const label = symbol.match(/\d$/g) ? symbol.match(/\d$/g)?.[0] : "";
+      const pseudo = this.getPseudoBySymbol(symbolWithoutLabel);
+      return QEPWXContextProvider.elementAndPseudoToAtomicSpecieWithLabels(symbolWithoutLabel, pseudo, label);
+    }).join("\n");
+  }
+  static CELL_PARAMETERS(material) {
+    return material.Lattice.vectorArrays.map(x => {
+      return x.map(y => {
+        return _underscore.default.sprintf("%14.9f", y).trim();
+      }).join(" ");
+    }).join("\n");
+  }
+  static symbolToAtomicSpecie(symbol, pseudo) {
+    const el = _periodicTable.PERIODIC_TABLE[symbol];
+    const filename = pseudo?.filename || _path.default.basename(pseudo?.path || "");
+    return _underscore.default.sprintf("%s %f %s", symbol, el.atomic_mass, filename) || "";
+  }
+  static elementAndPseudoToAtomicSpecieWithLabels(symbol, pseudo, label = "") {
+    const el = _periodicTable.PERIODIC_TABLE[symbol];
+    const filename = pseudo?.filename || _path.default.basename(pseudo?.path || "");
+    return _underscore.default.sprintf("%s%s %f %s", symbol, label, el.atomic_mass, filename) || "";
+  }
+}
+exports.default = QEPWXContextProvider;
+(0, _MaterialContextMixin.materialContextMixin)(QEPWXContextProvider.prototype);
+(0, _MaterialsContextMixin.materialsContextMixin)(QEPWXContextProvider.prototype);
+(0, _MethodDataContextMixin.methodDataContextMixin)(QEPWXContextProvider.prototype);
+(0, _WorkflowContextMixin.workflowContextMixin)(QEPWXContextProvider.prototype);
+(0, _JobContextMixin.jobContextMixin)(QEPWXContextProvider.prototype);