@mat3ra/mode 2025.10.2-0

package/src/methods/pseudopotential.js

@@ -0,0 +1,99 @@
+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

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

@@ -0,0 +1,115 @@
+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));
+    }
+}

package/src/models/factory.js

@@ -0,0 +1,28 @@
+import { Model } from "../model";
+import { getDefaultModelTypeForApplication } from "../tree";
+import { DFTModel } from "./dft";
+
+export class ModelFactory {
+    static DFTModel = DFTModel;
+
+    static Model = Model;
+
+    static create(config) {
+        switch (config.type) {
+            case "dft":
+                return new this.DFTModel(config);
+            default:
+                return new this.Model(config);
+        }
+    }
+
+    static createFromApplication(config) {
+        const { application } = config;
+        const type = application && getDefaultModelTypeForApplication(application);
+        if (!type)
+            throw new Error(
+                `ModelFactory.createFromApplication: cannot determine model type: ${type}`,
+            );
+        return this.create({ ...config, type });
+    }
+}

package/src/tree.js

@@ -0,0 +1,175 @@
+import { deepClone } from "@mat3ra/code/dist/js/utils";
+import { ModelMethodFilter } from "@mat3ra/standata";
+import lodash from "lodash";
+import _ from "underscore";
+
+// TODO: migrate to use manifest instead
+
+export const METHODS = {
+    pseudopotential: "pseudopotential",
+    localorbital: "localorbital",
+    unknown: "unknown",
+};
+
+const methods = {
+    [METHODS.pseudopotential]: ["paw", "nc", "nc-fr", "us"],
+    // TODO: Add additional basis set options, once user choice of specific (i.e 3-21G vs cc-pVDZ) is implemented.
+    [METHODS.localorbital]: ["pople"],
+    [METHODS.unknown]: ["unknown"],
+};
+
+export const getPseudopotentialTypesFromTree = () => methods[METHODS.pseudopotential];
+
+// DFT-specific
+
+const DFTModelRefiners = ["hse", "g0w0"];
+const DFTModelModifiers = ["soc", "magn"];
+
+const DFTModelTree = {
+    gga: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pbe", "pbesol", "pw91", "other"],
+    },
+    lda: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pz", "pw", "vwn", "other"],
+    },
+    hybrid: {
+        methods,
+        functionals: ["b3lyp", "hse06"],
+    },
+    other: {
+        methods,
+        functionals: ["other"],
+    },
+};
+
+export const getDFTFunctionalsFromTree = () => Object.keys(DFTModelTree);
+
+export const getDFTFunctionalsByApproximation = (approximation) => {
+    const branch = DFTModelTree[approximation];
+    return branch && branch.functionals;
+};
+
+// GENERAL
+
+export const MODEL_TREE = {
+    dft: DFTModelTree,
+    ml: {
+        re: {
+            methods: {
+                linear: ["least_squares", "ridge"],
+                kernel_ridge: ["least_squares"],
+            },
+        },
+    },
+    unknown: {
+        unknown: {
+            methods: {
+                unknown: ["unknown"],
+            },
+        },
+    },
+};
+
+export const MODEL_NAMES = {
+    dft: "density functional theory",
+    lda: "local density approximation",
+    gga: "generalized gradient approximation",
+    hybrid: "hybrid functional",
+    ml: "machine learning",
+    re: "regression",
+};
+
+export const treeSlugToNamedObject = (modelSlug) => {
+    return {
+        slug: modelSlug,
+        name: lodash.get(MODEL_NAMES, modelSlug, modelSlug),
+    };
+};
+
+// TODO: find a better way to handle application-specific model-method combination
+// must be a subset of the MODEL_TREE above
+// demonstrate how tree can be modified
+// VASP_MODELS_TREE.gga.functionals = _.omit(VASP_MODELS_TREE.gga.functionals);
+
+const VASP_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft"));
+const ESPRESSO_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft"));
+const NWCHEM_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft"));
+
+["gga", "lda"].forEach((approximation) => {
+    // pick "paw" for vasp
+    VASP_MODELS_TREE.dft[approximation].methods.pseudopotential = VASP_MODELS_TREE.dft[
+        approximation
+    ].methods.pseudopotential.splice(0, 1);
+
+    // assert "us" is the first option
+    ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential =
+        ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential.reverse();
+});
+
+const UNKNOWN_MODELS_TREE = _.pick(MODEL_TREE, "unknown");
+// const ML_MODELS_TREE = _.pick(MODEL_TREE, "ml");
+
+const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION = [
+    {
+        name: "vasp",
+        tree: VASP_MODELS_TREE,
+    },
+    {
+        name: "espresso",
+        tree: ESPRESSO_MODELS_TREE,
+    },
+    {
+        name: "python",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "shell",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "jupyterLab",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "nwchem",
+        tree: NWCHEM_MODELS_TREE,
+    },
+    {
+        name: "deepmd",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+];
+
+export const getTreeByApplicationNameAndVersion = ({
+    name,
+    // eslint-disable-next-line no-unused-vars
+    version,
+}) => {
+    // TODO: add logic to filter by version when necessary
+    const cfgs = MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION.filter(
+        (cfg) => cfg.name === name,
+    ).map((x) => x.tree);
+    return Object.assign({}, ...cfgs);
+};
+
+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);
+}