@mat3ra/mode 2025.11.3-0 → 2025.11.5-0

package/src/method.js

@@ -1,77 +0,0 @@
-import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { deepClone } from "@mat3ra/code/dist/js/utils";
-import lodash from "lodash";
-
-import { PseudopotentialMethodConfig } from "./default_methods";
-
-export class Method extends InMemoryEntity {
-    constructor(config) {
-        const data = config.data || {};
-        super({ ...config, data });
-    }
-
-    cloneWithoutData() {
-        const clone = this.clone();
-        clone.setData({});
-        return clone;
-    }
-
-    get type() {
-        return this.prop("type");
-    }
-
-    get subtype() {
-        return this.prop("subtype");
-    }
-
-    setSubtype(subtype) {
-        // TODO: add proper handling of method data subscriptions on type/subtype change
-        this.setProp("subtype", subtype);
-    }
-
-    static get defaultConfig() {
-        return PseudopotentialMethodConfig;
-    }
-
-    get precision() {
-        return this.prop("precision");
-    }
-
-    get data() {
-        return this.prop("data");
-    }
-
-    get searchText() {
-        return this.prop("data.searchText", "");
-    }
-
-    // used to narrow down the list of methodData items available for selection
-    // utilizing "data" field as a "blackbox" container for searchText
-    setSearchText(searchText) {
-        this.setData({ ...this.prop("data"), searchText });
-    }
-
-    setData(data = {}) {
-        this.setProp("data", data);
-    }
-
-    get omitInHashCalculation() {
-        const data = this.prop("data");
-        return !data.searchText && lodash.isEmpty(lodash.omit(data, "searchText"));
-    }
-
-    // data without client-only fields
-    cleanData(fieldsToExclude = []) {
-        const filteredData = { ...this.prop("data") };
-        fieldsToExclude.forEach((f) => {
-            delete filteredData[f];
-        });
-        return filteredData;
-    }
-
-    // override in child class if needed
-    toJSONWithCleanData(fieldsToExclude = []) {
-        const json = { ...this._json, data: this.cleanData(fieldsToExclude) };
-        return deepClone(json);
-    }
-}

package/src/methodConversionHandler.js

@@ -1,125 +0,0 @@
-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/methods/pseudopotential.js

@@ -1,99 +0,0 @@
-import { safeMakeArray } from "@mat3ra/code/dist/js/utils";
-import _ from "underscore";
-
-import { Method } from "../method";
-
-export class PseudopotentialMethod extends Method {
-    constructor(config) {
-        super(config);
-        this.PseudopotentialCls = null;
-    }
-
-    // "Unique" or "selected" pseudopotentials - one per element
-    get pseudo() {
-        return this.prop("data.pseudo", []);
-    }
-
-    // "All" or "non-unique" pseudopotentials available for a choice
-    get allPseudo() {
-        return this.prop("data.allPseudo", []);
-    }
-
-    get pseudopotentials() {
-        return this.pseudo.map((x) => new this.PseudopotentialCls(x));
-    }
-
-    get allPseudopotentials() {
-        return this.allPseudo.map((x) => new this.PseudopotentialCls(x));
-    }
-
-    static extractExchangeCorrelationFromSubworkflow(subworkflow) {
-        const { model } = subworkflow;
-        const approximation = model.subtype;
-        const functional = model.functional ? model.functional.slug || model.functional : "";
-        return {
-            approximation,
-            functional,
-        };
-    }
-
-    hasPseudopotentialFor(element) {
-        return Boolean(this.pseudopotentials.find((x) => x.element === element));
-    }
-
-    /**
-     * @summary Sets one pseudopotential per element. Subsequent applications will override previous.
-     * @param pseudo {Pseudopotential}
-     */
-    setPseudopotentialPerElement(pseudo) {
-        if (!pseudo) {
-            this.setPseudopotentials([]);
-            return;
-        }
-        const arr = this.pseudopotentials.filter((x) => x.element !== pseudo.element);
-        arr.push(pseudo);
-        this.setPseudopotentials(arr);
-    }
-
-    // add new pseudopotentials to the list of all pseudopotentials
-    addToAllPseudos(pseudos) {
-        // eslint-disable-next-line no-param-reassign
-        pseudos = safeMakeArray(pseudos);
-        const allPseudos = this.allPseudopotentials;
-        allPseudos.push(...pseudos);
-        this.setAllPseudopotentials(allPseudos);
-    }
-
-    /**
-     * @param pseudopotentials {Pseudopotential[]}
-     */
-    setPseudopotentials(pseudopotentials) {
-        // sort by alphabetical order to ensure elements order consistency in VASP POSCAR/POTCAR
-        this.setData({
-            ...this.data,
-            pseudo: _.sortBy(pseudopotentials, "element").map((x) => x.toJSON()),
-        });
-    }
-
-    /**
-     * @param pseudopotentials {Pseudopotential[]}
-     */
-    setAllPseudopotentials(pseudopotentials) {
-        // sort by alphabetical order to ensure elements order consistency in VASP POSCAR/POTCAR
-        this.setData({
-            ...this.data,
-            allPseudo: _.sortBy(pseudopotentials, "element").map((x) => x.toJSON()),
-        });
-    }
-
-    // override default `toJSONWithCleanData` method to avoid saving `allPseudo` inside the workflow
-    // TODO: revise after implementing Pseudopotential Sets
-    toJSONWithCleanData(exclude = []) {
-        return super.toJSONWithCleanData(
-            exclude.concat([
-                "allPseudo",
-                // 'pseudo' - not cleaning the field to save it in `Job.workflow`
-            ]),
-        );
-    }
-}

package/src/model.js

@@ -1,127 +0,0 @@
-import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import lodash from "lodash";
-
-import { DFTModelConfig } from "./default_models";
-import { Method } from "./method";
-import { MethodFactory } from "./methods/factory";
-import { getTreeByApplicationNameAndVersion, MODEL_TREE, treeSlugToNamedObject } from "./tree";
-
-export class Model extends InMemoryEntity {
-    constructor({ application, ...config }) {
-        super(config);
-        this._application = application;
-        this._MethodFactory = MethodFactory;
-    }
-
-    get type() {
-        return this.prop("type", this.defaultType);
-    }
-
-    get subtype() {
-        return this.prop("subtype", this.defaultSubtype);
-    }
-
-    setSubtype(subtype) {
-        this.setProp("subtype", subtype);
-        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
-    }
-
-    get allowedTypes() {
-        return Object.keys(this.tree).map((modelSlug) => treeSlugToNamedObject(modelSlug));
-    }
-
-    get allowedSubtypes() {
-        return Object.keys(this.treeBranchForType).map((slug) => treeSlugToNamedObject(slug));
-    }
-
-    get defaultType() {
-        return this.allowedTypes[0]?.slug;
-    }
-
-    get defaultSubtype() {
-        return this.allowedSubtypes[0]?.slug;
-    }
-
-    get tree() {
-        return (this._application && this.treeByApplicationNameAndVersion) || MODEL_TREE;
-    }
-
-    get treeBranchForType() {
-        return this.tree[this.type] || {};
-    }
-
-    get treeBranchForSubType() {
-        return this.treeBranchForType[this.subtype] || {};
-    }
-
-    get treeByApplicationNameAndVersion() {
-        const [name, version] = [this._application.name, this._application.version];
-        return getTreeByApplicationNameAndVersion({ name, version });
-    }
-
-    get groupSlug() {
-        return `${this._application.shortName}:${this.type}:${this.subtype}`;
-    }
-
-    get method() {
-        if (!this._method) {
-            const method = this.prop("method") || this.defaultMethodConfig;
-            this._method = this._MethodFactory.create(method);
-        }
-        return this._method;
-    }
-
-    setMethod(method) {
-        this._method = method;
-    }
-
-    // Consider moving the below to `Method`
-    get methodsFromTree() {
-        return this.treeBranchForSubType.methods || {};
-    }
-
-    get methodTypes() {
-        return Object.keys(this.methodsFromTree).map((m) => treeSlugToNamedObject(m));
-    }
-
-    get methodSubtypes() {
-        return this.methodsFromTree[this.method.type].map((m) => treeSlugToNamedObject(m)) || [];
-    }
-
-    get defaultMethodConfig() {
-        const type = Object.keys(this.methodsFromTree)[0];
-        const subtype = (this.methodsFromTree[type] || [])[0];
-        return { type, subtype };
-    }
-
-    static get defaultConfig() {
-        return {
-            ...DFTModelConfig,
-            method: Method.defaultConfig,
-        };
-    }
-
-    static get allTypes() {
-        return Object.keys(this.tree).map((modelSlug) => treeSlugToNamedObject(modelSlug));
-    }
-
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            type: this.type,
-            subtype: this.subtype,
-            // TODO: use schema-based cleaning instead
-            method: this.method.toJSONWithCleanData(),
-        };
-    }
-
-    // to be used with extra properties
-    // eslint-disable-next-line class-methods-use-this
-    _stringToSlugifiedObject(slug) {
-        return lodash.isString(slug) ? { slug } : slug;
-    }
-
-    get isUnknown() {
-        return this.type === "unknown";
-    }
-}

package/src/modelConversionHandler.js

@@ -1,91 +0,0 @@
-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/models/dft.js

@@ -1,115 +0,0 @@
-import _ from "underscore";
-
-import { MethodFactory } from "../methods/factory";
-import { Model } from "../model";
-import { treeSlugToNamedObject } from "../tree";
-
-export class DFTModel extends Model {
-    constructor(config) {
-        super(config);
-        this._MethodFactory = config.MethodFactory || MethodFactory;
-    }
-
-    /**
-     * @summary Build slug string based on model information
-     * @returns {string}
-     */
-    get groupSlug() {
-        return [
-            this._application.shortName,
-            this.type,
-            this.subtype,
-            this.functional.slug,
-            this.refiners.map((o) => o.slug).join("+"),
-            this.modifiers.map((o) => o.slug).join("+"),
-        ]
-            .join(":")
-            .replace("::", ":")
-            .replace(/:$/, "");
-    }
-
-    get defaultFunctional() {
-        return treeSlugToNamedObject(this.treeBranchForSubType.functionals[0]);
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    get defaultRefiners() {
-        return [];
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    get defaultModifiers() {
-        return [];
-    }
-
-    get functional() {
-        return this.prop("functional", this.defaultFunctional);
-    }
-
-    get refiners() {
-        return this.prop("refiners", this.defaultRefiners);
-    }
-
-    get modifiers() {
-        return this.prop("modifiers", this.defaultModifiers);
-    }
-
-    setSubtype(subtype) {
-        this.setProp("subtype", subtype);
-        this.setFunctional(this.defaultFunctional);
-    }
-
-    setFunctional(functional) {
-        this.setProp("functional", this._stringToSlugifiedObject(functional));
-        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
-    }
-
-    _setArrayProp(name, data) {
-        // eslint-disable-next-line no-param-reassign, no-undef
-        data = safeMakeArray(data).map((r) => this._stringToSlugifiedObject(r));
-        this.setProp(name, data);
-        this[`_${name}`] = data;
-    }
-
-    setRefiners(refiners) {
-        this._setArrayProp("refiners", refiners);
-    }
-
-    setModifiers(modifiers) {
-        this._setArrayProp("modifiers", modifiers);
-    }
-
-    toJSON() {
-        const pickSlugFromObject = (o) => _.pick(o, "slug");
-        return {
-            ...super.toJSON(),
-            functional: pickSlugFromObject(this.functional), // only store slug for `functional`
-            refiners: this.refiners,
-            modifiers: this.modifiers,
-        };
-    }
-
-    /**
-     * Get all functionals in the form of {name: ..., slug: ...} for further use in UI
-     * @returns {Object.<string, string>[]} - List of functional objects
-     */
-    get allFunctionals() {
-        return this.treeBranchForSubType.functionals.map((x) => treeSlugToNamedObject(x));
-    }
-
-    /**
-     * Get all refiners in the form of {name: ..., slug: ...} for further use in UI
-     * @returns {Object.<string, string>[]} - List of refiner objects
-     */
-    get allRefiners() {
-        return this.treeBranchForSubType.refiners.map((x) => treeSlugToNamedObject(x));
-    }
-
-    /**
-     * Get all modifiers in the form of {name: ..., slug: ...} for further use in UI
-     * @returns {Object.<string, string>[]} - List of modifier objects
-     */
-    get allModifiers() {
-        return this.treeBranchForSubType.modifiers.map((x) => treeSlugToNamedObject(x));
-    }
-}