@mat3ra/mode 2025.10.2-0 → 2025.11.3-0

package/dist/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "Method", {
     return _method.Method;
   }
 });
+Object.defineProperty(exports, "MethodConversionHandler", {
+  enumerable: true,
+  get: function () {
+    return _methodConversionHandler.MethodConversionHandler;
+  }
+});
 Object.defineProperty(exports, "MethodFactory", {
   enumerable: true,
   get: function () {
@@ -27,6 +33,12 @@ Object.defineProperty(exports, "Model", {
     return _model.Model;
   }
 });
+Object.defineProperty(exports, "ModelConversionHandler", {
+  enumerable: true,
+  get: function () {
+    return _modelConversionHandler.ModelConversionHandler;
+  }
+});
 Object.defineProperty(exports, "ModelFactory", {
   enumerable: true,
   get: function () {
@@ -39,24 +51,19 @@ Object.defineProperty(exports, "PseudopotentialMethod", {
     return _pseudopotential.PseudopotentialMethod;
   }
 });
-exports.tree = exports.default_models = exports.default_methods = exports.categorizedModelList = exports.categorizedMethodList = void 0;
-var _standata = require("@mat3ra/standata");
+exports.tree = exports.default_models = exports.default_methods = void 0;
 var default_methods = _interopRequireWildcard(require("./default_methods"));
 exports.default_methods = default_methods;
 var default_models = _interopRequireWildcard(require("./default_models"));
 exports.default_models = default_models;
 var _method = require("./method");
+var _methodConversionHandler = require("./methodConversionHandler");
 var _factory = require("./methods/factory");
 var _pseudopotential = require("./methods/pseudopotential");
 var _model = require("./model");
+var _modelConversionHandler = require("./modelConversionHandler");
 var _dft = require("./models/dft");
 var _factory2 = require("./models/factory");
 var tree = _interopRequireWildcard(require("./tree"));
 exports.tree = tree;
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-// TODO : can replace these with subpackages in exports in package.json
-
-const methodStandata = new _standata.MethodStandata();
-const modelStandata = new _standata.ModelStandata();
-const categorizedMethodList = exports.categorizedMethodList = methodStandata.getAll();
-const categorizedModelList = exports.categorizedModelList = modelStandata.getAll();
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }

package/dist/methodConversionHandler.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MethodConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+var _default_methods = require("./default_methods");
+function safelyGetSlug(slugObj) {
+  return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+/**
+ * The method interface converts between the legacy method data structure (type, subtype)
+ * and the categorized method data structure (units with tier1, tier2, ...).
+ */
+class MethodConversionHandler {
+  static convertToSimple(cm) {
+    if (!cm) return this.convertUnknownToSimple();
+    const pspUnits = cm.units.filter(u => u.categories.type === "psp");
+    const aoUnit = cm.units.find(u => u.categories.type === "ao");
+    const reUnit = cm.units.find(u => u.name && u.name.includes("regression"));
+    if (pspUnits.length) return this.convertPspUnitsToSimple(pspUnits);
+    if (aoUnit) return this.convertAoUnitToSimple();
+    if (reUnit) return this.convertRegressionUnitToSimple(reUnit);
+    return this.convertRegressionUnitToSimple(reUnit);
+  }
+  static convertUnknownToSimple() {
+    return _default_methods.UnknownMethodConfig;
+  }
+  static convertPspUnitsToSimple(cm) {
+    const [firstPspUnit, ...otherUnits] = cm;
+    if (!firstPspUnit || !firstPspUnit.categories?.subtype) return this.convertUnknownToSimple();
+    const subtype = otherUnits?.length ? "any" : firstPspUnit.categories.subtype;
+    return {
+      type: "pseudopotential",
+      subtype
+    };
+  }
+  static convertAoUnitToSimple() {
+    return _default_methods.LocalOrbitalMethodConfig;
+  }
+  static convertRegressionUnitToSimple(cm) {
+    const type = cm.categories.type || "linear";
+    const subtype = cm.categories.subtype || "least_squares";
+    return {
+      type: safelyGetSlug(type),
+      subtype: safelyGetSlug(subtype),
+      data: cm.data,
+      precision: cm.precision
+    };
+  }
+  static convertToCategorized(sm, allMethods = []) {
+    switch (sm?.type) {
+      case "pseudopotential":
+        return this.convertPspToCategorized(sm, allMethods);
+      case "localorbital":
+        return this.convertAoToCategorized(sm);
+      case "linear":
+        return this.convertRegressionToCategorized(sm);
+      case "kernel_ridge":
+        return this.convertRegressionToCategorized(sm);
+      default:
+        return undefined;
+    }
+  }
+  static convertPspToCategorized(sm, allMethods = []) {
+    const subtype = safelyGetSlug(sm.subtype);
+    // the "any" subtype is equivalent to the method representing all planewave-pseudopotential
+    // methods. All other subtypes are equivalent to using a specific PW-PSP method.
+    const path = subtype === "any" ? "/qm/wf/none/psp/us::/qm/wf/none/psp/nc::/qm/wf/none/psp/nc-fr::/qm/wf/none/psp/paw::/qm/wf/none/pw/none" : `/qm/wf/none/smearing/gaussian::/linalg/diag/none/davidson/none::/qm/wf/none/psp/${subtype}::/qm/wf/none/pw/none`;
+    return allMethods.find(catMethod => {
+      return catMethod.path === path;
+    });
+  }
+  static convertAoToCategorized(sm) {
+    const subtype = safelyGetSlug(sm.subtype);
+    return {
+      units: [{
+        parameters: {
+          basisSlug: "6-31G"
+        },
+        categories: {
+          tier1: "qm",
+          tier2: "wf",
+          type: "ao",
+          subtype
+        },
+        tags: ["atomic orbital"],
+        name: "Wave function: LCAO - Pople basis set (6-31G)",
+        path: "/qm/wf/none/ao/pople?basisSlug=6-31G"
+      }],
+      name: "Wave function: LCAO - Pople basis set (6-31G)",
+      path: "/qm/wf/none/ao/pople?basisSlug=6-31G"
+    };
+  }
+  static convertRegressionToCategorized(sm) {
+    const type = safelyGetSlug(sm.type);
+    const subtype = safelyGetSlug(sm.subtype);
+    const {
+      precision,
+      data
+    } = sm;
+    const path = `/none/none/none/${type}/${subtype}`;
+    const nameMap = {
+      kernel_ridge: "Kernel ridge",
+      linear: "Linear",
+      least_squares: "least squares",
+      ridge: "ridge"
+    };
+    const name = `${nameMap[type]} ${nameMap[subtype]} regression`;
+    return {
+      units: [{
+        categories: {
+          type,
+          subtype
+        },
+        name,
+        path,
+        precision,
+        data
+      }],
+      name,
+      path
+    };
+  }
+}
+exports.MethodConversionHandler = MethodConversionHandler;

package/dist/modelConversionHandler.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModelConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+var tree = _interopRequireWildcard(require("./tree"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function safelyGetSlug(slugObj) {
+  return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+/**
+ * The model interface converts between the legacy model data structure (type, subtype, functional)
+ * and the categorized model data structure (tier1, tier2, ...).
+ */
+class ModelConversionHandler {
+  static convertToSimple(cm) {
+    if (!cm) return this.convertUnknownToSimple();
+
+    // eslint-disable-next-line default-case
+    switch (cm.categories.tier3) {
+      case "dft":
+        return this.convertDftToSimple(cm);
+      case "ml":
+        return this.convertMlToSimple();
+      default:
+        return this.convertUnknownToSimple();
+    }
+  }
+  static convertDftToSimple(cm) {
+    if (!cm.categories?.subtype) return this.convertUnknownToSimple();
+    const {
+      subtype
+    } = cm.categories;
+    const functional = cm.parameters?.functional;
+    return {
+      type: "dft",
+      subtype,
+      functional: tree.treeSlugToNamedObject(functional)
+    };
+  }
+  static convertMlToSimple() {
+    return {
+      type: "ml",
+      subtype: "re"
+    };
+  }
+  static convertUnknownToSimple() {
+    return {
+      type: "unknown",
+      subtype: "unknown"
+    };
+  }
+  static convertToCategorized(sm, allModels = []) {
+    switch (sm?.type) {
+      case "dft":
+        return this.convertDftToCategorized(sm, allModels);
+      case "ml":
+        return this.convertMlToCategorized(sm);
+      case "unknown":
+        return undefined;
+      default:
+        return undefined;
+    }
+  }
+  static convertDftToCategorized(sm, allModels = []) {
+    const {
+      subtype,
+      functional: functionalStringOrObject
+    } = sm;
+    const defaultFunctionals = {
+      lda: "pz",
+      gga: "pbe",
+      hybrid: "b3lyp"
+    };
+    let functional;
+    if (!functionalStringOrObject) {
+      functional = defaultFunctionals[subtype];
+    } else {
+      functional = safelyGetSlug(functionalStringOrObject);
+    }
+    const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+    return allModels.find(cm => cm.path === path);
+  }
+  static convertMlToCategorized(sm) {
+    const subtype = safelyGetSlug(sm.subtype);
+    return {
+      name: "Regression",
+      path: "/st/det/ml/re/none",
+      categories: {
+        tier1: "st",
+        tier2: "det",
+        tier3: "ml",
+        type: subtype
+      },
+      parameters: {}
+    };
+  }
+}
+exports.ModelConversionHandler = ModelConversionHandler;

package/dist/tree.js

@@ -3,11 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MODEL_TREE = exports.MODEL_NAMES = exports.METHODS = void 0;
-exports.filterMethodsByModel = filterMethodsByModel;
-exports.treeSlugToNamedObject = exports.getTreeByApplicationNameAndVersion = exports.getPseudopotentialTypesFromTree = exports.getDefaultModelTypeForApplication = exports.getDFTFunctionalsFromTree = exports.getDFTFunctionalsByApproximation = void 0;
+exports.treeSlugToNamedObject = exports.getTreeByApplicationNameAndVersion = exports.getPseudopotentialTypesFromTree = exports.getDefaultModelTypeForApplication = exports.getDFTFunctionalsFromTree = exports.getDFTFunctionalsByApproximation = exports.MODEL_TREE = exports.MODEL_NAMES = exports.METHODS = void 0;
 var _utils = require("@mat3ra/code/dist/js/utils");
-var _standata = require("@mat3ra/standata");
 var _lodash = _interopRequireDefault(require("lodash"));
 var _underscore = _interopRequireDefault(require("underscore"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -147,19 +144,4 @@ exports.getTreeByApplicationNameAndVersion = getTreeByApplicationNameAndVersion;
 const getDefaultModelTypeForApplication = application => {
   return Object.keys(getTreeByApplicationNameAndVersion(application))[0];
 };
-
-/**
- * Filter list of method configs based on model
- * @param {Object[]} methodList - Array of method configs
- * @param {Object} model - Model config for which methods should be filtered
- * @return {Object[]}
- */
-exports.getDefaultModelTypeForApplication = getDefaultModelTypeForApplication;
-function filterMethodsByModel({
-  methodList,
-  model
-}) {
-  if (!model) return [];
-  const modelMethodFilter = new _standata.ModelMethodFilter();
-  return modelMethodFilter.getCompatibleMethods(model, methodList);
-}
+exports.getDefaultModelTypeForApplication = getDefaultModelTypeForApplication;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/mode",
-    "version": "2025.10.2-0",
+    "version": "2025.11.3-0",
     "description": "MOdel and method DEfinitions",
     "scripts": {
         "test": "nyc --reporter=text mocha --recursive --bail --require @babel/register/lib --require tests/setup.js tests",

package/src/index.js

@@ -1,22 +1,16 @@
-import { MethodStandata, ModelStandata } from "@mat3ra/standata";
-
 import * as default_methods from "./default_methods";
 import * as default_models from "./default_models";
 import { Method } from "./method";
+import { MethodConversionHandler } from "./methodConversionHandler";
 import { MethodFactory } from "./methods/factory";
 import { PseudopotentialMethod } from "./methods/pseudopotential";
 import { Model } from "./model";
+import { ModelConversionHandler } from "./modelConversionHandler";
 import { DFTModel } from "./models/dft";
 import { ModelFactory } from "./models/factory";
 // TODO : can replace these with subpackages in exports in package.json
 import * as tree from "./tree";
 
-const methodStandata = new MethodStandata();
-const modelStandata = new ModelStandata();
-
-const categorizedMethodList = methodStandata.getAll();
-const categorizedModelList = modelStandata.getAll();
-
 export {
     Method,
     Model,
@@ -24,9 +18,9 @@ export {
     ModelFactory,
     PseudopotentialMethod,
     DFTModel,
+    MethodConversionHandler,
+    ModelConversionHandler,
     tree,
     default_models,
     default_methods,
-    categorizedModelList,
-    categorizedMethodList,
 };

package/src/methodConversionHandler.js

@@ -0,0 +1,125 @@
+import { LocalOrbitalMethodConfig, UnknownMethodConfig } from "./default_methods";
+
+export function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+/**
+ * The method interface converts between the legacy method data structure (type, subtype)
+ * and the categorized method data structure (units with tier1, tier2, ...).
+ */
+export class MethodConversionHandler {
+    static convertToSimple(cm) {
+        if (!cm) return this.convertUnknownToSimple();
+        const pspUnits = cm.units.filter((u) => u.categories.type === "psp");
+        const aoUnit = cm.units.find((u) => u.categories.type === "ao");
+        const reUnit = cm.units.find((u) => u.name && u.name.includes("regression"));
+        if (pspUnits.length) return this.convertPspUnitsToSimple(pspUnits);
+        if (aoUnit) return this.convertAoUnitToSimple();
+        if (reUnit) return this.convertRegressionUnitToSimple(reUnit);
+        return this.convertRegressionUnitToSimple(reUnit);
+    }
+
+    static convertUnknownToSimple() {
+        return UnknownMethodConfig;
+    }
+
+    static convertPspUnitsToSimple(cm) {
+        const [firstPspUnit, ...otherUnits] = cm;
+        if (!firstPspUnit || !firstPspUnit.categories?.subtype)
+            return this.convertUnknownToSimple();
+        const subtype = otherUnits?.length ? "any" : firstPspUnit.categories.subtype;
+        return {
+            type: "pseudopotential",
+            subtype,
+        };
+    }
+
+    static convertAoUnitToSimple() {
+        return LocalOrbitalMethodConfig;
+    }
+
+    static convertRegressionUnitToSimple(cm) {
+        const type = cm.categories.type || "linear";
+        const subtype = cm.categories.subtype || "least_squares";
+        return {
+            type: safelyGetSlug(type),
+            subtype: safelyGetSlug(subtype),
+            data: cm.data,
+            precision: cm.precision,
+        };
+    }
+
+    static convertToCategorized(sm, allMethods = []) {
+        switch (sm?.type) {
+            case "pseudopotential":
+                return this.convertPspToCategorized(sm, allMethods);
+            case "localorbital":
+                return this.convertAoToCategorized(sm);
+            case "linear":
+                return this.convertRegressionToCategorized(sm);
+            case "kernel_ridge":
+                return this.convertRegressionToCategorized(sm);
+            default:
+                return undefined;
+        }
+    }
+
+    static convertPspToCategorized(sm, allMethods = []) {
+        const subtype = safelyGetSlug(sm.subtype);
+        // the "any" subtype is equivalent to the method representing all planewave-pseudopotential
+        // methods. All other subtypes are equivalent to using a specific PW-PSP method.
+        const path =
+            subtype === "any"
+                ? "/qm/wf/none/psp/us::/qm/wf/none/psp/nc::/qm/wf/none/psp/nc-fr::/qm/wf/none/psp/paw::/qm/wf/none/pw/none"
+                : `/qm/wf/none/smearing/gaussian::/linalg/diag/none/davidson/none::/qm/wf/none/psp/${subtype}::/qm/wf/none/pw/none`;
+
+        return allMethods.find((catMethod) => {
+            return catMethod.path === path;
+        });
+    }
+
+    static convertAoToCategorized(sm) {
+        const subtype = safelyGetSlug(sm.subtype);
+        return {
+            units: [
+                {
+                    parameters: { basisSlug: "6-31G" },
+                    categories: { tier1: "qm", tier2: "wf", type: "ao", subtype },
+                    tags: ["atomic orbital"],
+                    name: "Wave function: LCAO - Pople basis set (6-31G)",
+                    path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+                },
+            ],
+            name: "Wave function: LCAO - Pople basis set (6-31G)",
+            path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+        };
+    }
+
+    static convertRegressionToCategorized(sm) {
+        const type = safelyGetSlug(sm.type);
+        const subtype = safelyGetSlug(sm.subtype);
+        const { precision, data } = sm;
+        const path = `/none/none/none/${type}/${subtype}`;
+        const nameMap = {
+            kernel_ridge: "Kernel ridge",
+            linear: "Linear",
+            least_squares: "least squares",
+            ridge: "ridge",
+        };
+        const name = `${nameMap[type]} ${nameMap[subtype]} regression`;
+        return {
+            units: [
+                {
+                    categories: { type, subtype },
+                    name,
+                    path,
+                    precision,
+                    data,
+                },
+            ],
+            name,
+            path,
+        };
+    }
+}

package/src/modelConversionHandler.js

@@ -0,0 +1,91 @@
+import * as tree from "./tree";
+
+export function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+/**
+ * The model interface converts between the legacy model data structure (type, subtype, functional)
+ * and the categorized model data structure (tier1, tier2, ...).
+ */
+export class ModelConversionHandler {
+    static convertToSimple(cm) {
+        if (!cm) return this.convertUnknownToSimple();
+
+        // eslint-disable-next-line default-case
+        switch (cm.categories.tier3) {
+            case "dft":
+                return this.convertDftToSimple(cm);
+            case "ml":
+                return this.convertMlToSimple();
+            default:
+                return this.convertUnknownToSimple();
+        }
+    }
+
+    static convertDftToSimple(cm) {
+        if (!cm.categories?.subtype) return this.convertUnknownToSimple();
+        const { subtype } = cm.categories;
+        const functional = cm.parameters?.functional;
+        return {
+            type: "dft",
+            subtype,
+            functional: tree.treeSlugToNamedObject(functional),
+        };
+    }
+
+    static convertMlToSimple() {
+        return {
+            type: "ml",
+            subtype: "re",
+        };
+    }
+
+    static convertUnknownToSimple() {
+        return {
+            type: "unknown",
+            subtype: "unknown",
+        };
+    }
+
+    static convertToCategorized(sm, allModels = []) {
+        switch (sm?.type) {
+            case "dft":
+                return this.convertDftToCategorized(sm, allModels);
+            case "ml":
+                return this.convertMlToCategorized(sm);
+            case "unknown":
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+
+    static convertDftToCategorized(sm, allModels = []) {
+        const { subtype, functional: functionalStringOrObject } = sm;
+        const defaultFunctionals = { lda: "pz", gga: "pbe", hybrid: "b3lyp" };
+        let functional;
+        if (!functionalStringOrObject) {
+            functional = defaultFunctionals[subtype];
+        } else {
+            functional = safelyGetSlug(functionalStringOrObject);
+        }
+        const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+        return allModels.find((cm) => cm.path === path);
+    }
+
+    static convertMlToCategorized(sm) {
+        const subtype = safelyGetSlug(sm.subtype);
+        return {
+            name: "Regression",
+            path: "/st/det/ml/re/none",
+            categories: {
+                tier1: "st",
+                tier2: "det",
+                tier3: "ml",
+                type: subtype,
+            },
+            parameters: {},
+        };
+    }
+}

package/src/tree.js

@@ -1,5 +1,4 @@
 import { deepClone } from "@mat3ra/code/dist/js/utils";
-import { ModelMethodFilter } from "@mat3ra/standata";
 import lodash from "lodash";
 import _ from "underscore";
 
@@ -161,15 +160,3 @@ export const getTreeByApplicationNameAndVersion = ({
 export const getDefaultModelTypeForApplication = (application) => {
     return Object.keys(getTreeByApplicationNameAndVersion(application))[0];
 };
-
-/**
- * Filter list of method configs based on model
- * @param {Object[]} methodList - Array of method configs
- * @param {Object} model - Model config for which methods should be filtered
- * @return {Object[]}
- */
-export function filterMethodsByModel({ methodList, model }) {
-    if (!model) return [];
-    const modelMethodFilter = new ModelMethodFilter();
-    return modelMethodFilter.getCompatibleMethods(model, methodList);
-}