@mat3ra/mode 2025.10.2-0 → 2025.11.5-0

package/src/js/model.ts

@@ -0,0 +1,168 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type {
+    ApplicationSchemaBase,
+    BaseMethod,
+    BaseModel,
+    SlugifiedEntry,
+    SlugifiedEntryOrSlug,
+} from "@mat3ra/esse/dist/js/types";
+import lodash from "lodash";
+
+import { DFTModelConfig } from "./default_models";
+import { type ModelSchemaMixin, modelSchemaMixin } from "./generated/ModelSchemaMixin";
+import { Method } from "./method";
+import { MethodFactory } from "./methods/factory";
+import { getTreeByApplicationNameAndVersion, MODEL_TREE, treeSlugToNamedObject } from "./tree";
+import type { ModelConfig, MethodTreeBranch, ModelTree } from "./types";
+
+const EMPTY_BRANCH: MethodTreeBranch = { methods: {} };
+
+type Base = typeof InMemoryEntity & Constructor<ModelSchemaMixin>;
+
+export class Model extends (InMemoryEntity as Base) implements BaseModel {
+    protected _application?: ApplicationSchemaBase;
+
+    protected _MethodFactory: typeof MethodFactory;
+
+    protected _method?: Method;
+
+    constructor(config: ModelConfig) {
+        const { application, ...entityConfig } = config as any;
+        super(entityConfig);
+        this._application = application as ApplicationSchemaBase | undefined;
+        this._MethodFactory = MethodFactory;
+    }
+
+    // get type(): string {
+    //     return this.prop<string>("type", this.defaultType);
+    // }
+
+    // get subtype(): StringOrNamedSlug {
+    //     return this.prop<StringOrNamedSlug>("subtype", this.defaultSubtype);
+    // }
+
+    setSubtype(subtype: SlugifiedEntryOrSlug): void {
+        this.setProp("subtype", subtype);
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+
+    get allowedTypes(): SlugifiedEntry[] {
+        return Object.keys(this.tree).map((modelSlug) => treeSlugToNamedObject(modelSlug));
+    }
+
+    get allowedSubtypes(): SlugifiedEntry[] {
+        return Object.keys(this.treeBranchForType).map((slug) => treeSlugToNamedObject(slug));
+    }
+
+    get defaultType(): string {
+        return this.allowedTypes[0]?.slug || "";
+    }
+
+    get defaultSubtype(): string {
+        return this.allowedSubtypes[0]?.slug || "";
+    }
+
+    get tree(): ModelTree {
+        if (this._application) {
+            const treeByApplication = this.treeByApplicationNameAndVersion;
+            if (treeByApplication) return treeByApplication;
+        }
+        return MODEL_TREE;
+    }
+
+    get treeBranchForType(): Record<string, MethodTreeBranch> {
+        return this.tree[this.type] || {};
+    }
+
+    get treeBranchForSubType(): MethodTreeBranch {
+        return this.treeBranchForType[this.subtypeSlug] || EMPTY_BRANCH;
+    }
+
+    get treeByApplicationNameAndVersion(): ModelTree | undefined {
+        if (!this._application) return undefined;
+        const { name, version } = this._application;
+        return getTreeByApplicationNameAndVersion({ name, version });
+    }
+
+    get groupSlug(): string {
+        const subtype = this.subtypeSlug;
+        if (!this._application) return `${this.type}:${subtype}`;
+        return `${this._application.shortName}:${this.type}:${subtype}`;
+    }
+
+    get Method(): Method {
+        if (!this._method) {
+            const methodOrConfig = this.method;
+            const config = methodOrConfig || this.defaultMethodConfig;
+            this._method = this._MethodFactory.create(config);
+        }
+        return this._method;
+    }
+
+    setMethod(method: Method): void {
+        this._method = method;
+    }
+
+    get methodsFromTree(): Record<string, string[]> {
+        return this.treeBranchForSubType.methods || {};
+    }
+
+    get methodTypes(): SlugifiedEntry[] {
+        return Object.keys(this.methodsFromTree).map((type) => treeSlugToNamedObject(type));
+    }
+
+    get methodSubtypes(): SlugifiedEntry[] {
+        const { type } = this.method;
+        const subtypes = this.methodsFromTree[type] || [];
+        return subtypes.map((slug) => treeSlugToNamedObject(slug));
+    }
+
+    get defaultMethodConfig(): BaseMethod {
+        const methodTypes = Object.keys(this.methodsFromTree);
+        const type = methodTypes[0];
+        if (!type) return Method.defaultConfig;
+        const subtype = this.methodsFromTree[type]?.[0];
+        if (!subtype) return Method.defaultConfig;
+        return { type, subtype };
+    }
+
+    static get defaultConfig(): ModelConfig {
+        return {
+            ...DFTModelConfig,
+            method: Method.defaultConfig,
+        };
+    }
+
+    static get allTypes(): SlugifiedEntry[] {
+        return Object.keys(MODEL_TREE).map((modelSlug) => treeSlugToNamedObject(modelSlug));
+    }
+
+    toJSON(): Record<string, unknown> {
+        const json = super.toJSON();
+        return {
+            ...json,
+            type: this.type,
+            subtype: this.subtype,
+            method: (this.method as any).toJSONWithCleanData(),
+        };
+    }
+
+    protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry {
+        if (lodash.isString(slug)) {
+            return { slug } as SlugifiedEntry;
+        }
+        return slug;
+    }
+
+    get isUnknown(): boolean {
+        return this.type === "unknown";
+    }
+
+    protected get subtypeSlug(): string {
+        const subtype = this.subtype as SlugifiedEntryOrSlug;
+        return typeof subtype === "string" ? subtype : subtype.slug;
+    }
+}
+
+modelSchemaMixin(Model.prototype);

package/src/js/modelConversionHandler.ts

@@ -0,0 +1,102 @@
+import { CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+
+import * as tree from "./tree";
+import type { ModelConfig, SimplifiedCategorizedModel } from "./types";
+
+export function safelyGetSlug(slugObj: SlugifiedEntryOrSlug): string {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+export class ModelConversionHandler {
+    static convertToSimple(categorizedModel: CategorizedModel | undefined): ModelConfig {
+        if (!categorizedModel) return this.convertUnknownToSimple();
+        switch (categorizedModel.categories.tier3) {
+            case "dft":
+                return this.convertDftToSimple(categorizedModel);
+            case "ml":
+                return this.convertMlToSimple();
+            default:
+                return this.convertUnknownToSimple();
+        }
+    }
+
+    static convertDftToSimple(categorizedModel: CategorizedModel): ModelConfig {
+        if (!categorizedModel.categories?.subtype) return this.convertUnknownToSimple();
+        const subtypeCategory = categorizedModel.categories.subtype as SlugifiedEntryOrSlug;
+        const subtype = safelyGetSlug(subtypeCategory);
+        const functionalParam = (categorizedModel.parameters as any)?.functional;
+        const functionalSlug = functionalParam
+            ? safelyGetSlug(functionalParam as SlugifiedEntryOrSlug)
+            : "";
+        return {
+            type: "dft",
+            subtype,
+            functional: tree.treeSlugToNamedObject(functionalSlug),
+        };
+    }
+
+    static convertMlToSimple(): ModelConfig {
+        return {
+            type: "ml",
+            subtype: "re",
+        };
+    }
+
+    static convertUnknownToSimple(): ModelConfig {
+        return {
+            type: "unknown",
+            subtype: "unknown",
+        };
+    }
+
+    static convertToCategorized(
+        simpleModel: ModelConfig | undefined,
+        allModels: CategorizedModel[] = [],
+    ): SimplifiedCategorizedModel | undefined {
+        switch (simpleModel?.type) {
+            case "dft":
+                return this.convertDftToCategorized(simpleModel, allModels);
+            case "ml":
+                return this.convertMlToCategorized(simpleModel);
+            case "unknown":
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+
+    static convertDftToCategorized(
+        simpleModel: ModelConfig,
+        allModels: CategorizedModel[] = [],
+    ): SimplifiedCategorizedModel | undefined {
+        const { subtype, functional: functionalStringOrObject } = simpleModel;
+        const defaultFunctionals: Record<string, string> = {
+            lda: "pz",
+            gga: "pbe",
+            hybrid: "b3lyp",
+        };
+        let functional: string | undefined;
+        if (!functionalStringOrObject) {
+            functional = defaultFunctionals[subtype as string];
+        } else {
+            functional = safelyGetSlug(functionalStringOrObject as SlugifiedEntryOrSlug);
+        }
+        const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+        return allModels.find((categorized) => categorized.path === path);
+    }
+
+    static convertMlToCategorized(simpleModel: ModelConfig): SimplifiedCategorizedModel {
+        const subtype = safelyGetSlug(simpleModel.subtype as SlugifiedEntryOrSlug);
+        return {
+            name: "Regression",
+            path: "/st/det/ml/re/none",
+            categories: {
+                tier1: "st",
+                tier2: "det",
+                tier3: "ml",
+                type: subtype,
+            },
+            parameters: {},
+        };
+    }
+}

package/src/js/models/dft.ts

@@ -0,0 +1,110 @@
+import { safeMakeArray } from "@mat3ra/code/dist/js/utils";
+import { SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import _ from "underscore";
+
+import { MethodFactory } from "../methods/factory";
+import { Model } from "../model";
+import { treeSlugToNamedObject } from "../tree";
+import type { ModelConfig } from "../types";
+
+export class DFTModel extends Model {
+    constructor(config: ModelConfig & { MethodFactory?: typeof MethodFactory }) {
+        super(config);
+        this._MethodFactory = config.MethodFactory || MethodFactory;
+    }
+
+    get groupSlug(): string {
+        const functionalSlug = this.functional.slug;
+        const refinersSlug = this.refiners.map((o) => o.slug).join("+");
+        const modifiersSlug = this.modifiers.map((o) => o.slug).join("+");
+        const slugs = [
+            this._application?.shortName,
+            this.type,
+            this.subtype,
+            functionalSlug,
+            refinersSlug,
+            modifiersSlug,
+        ].filter(Boolean);
+        return slugs.join(":");
+    }
+
+    get defaultFunctional(): SlugifiedEntry {
+        const [slug] = this.treeBranchForSubType.functionals || [];
+        return treeSlugToNamedObject(slug);
+    }
+
+    get defaultRefiners(): SlugifiedEntry[] {
+        return [];
+    }
+
+    get defaultModifiers(): SlugifiedEntry[] {
+        return [];
+    }
+
+    get functional(): SlugifiedEntry {
+        return this.prop<SlugifiedEntry>("functional", this.defaultFunctional);
+    }
+
+    get refiners(): SlugifiedEntry[] {
+        return this.prop<SlugifiedEntry[]>("refiners", this.defaultRefiners);
+    }
+
+    get modifiers(): SlugifiedEntry[] {
+        return this.prop<SlugifiedEntry[]>("modifiers", this.defaultModifiers);
+    }
+
+    setSubtype(subtype: SlugifiedEntryOrSlug): void {
+        this.setProp("subtype", subtype);
+        this.setFunctional(this.defaultFunctional);
+    }
+
+    setFunctional(functional: SlugifiedEntryOrSlug): void {
+        this.setProp("functional", this._stringToSlugifiedObject(functional));
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+
+    private _setArrayProp(
+        name: "refiners" | "modifiers",
+        data: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[],
+    ): void {
+        const normalized = safeMakeArray(data).map((item) => this._stringToSlugifiedObject(item));
+        this.setProp(name, normalized);
+        (this as unknown as Record<string, SlugifiedEntry[]>)[`_${name}`] = normalized;
+    }
+
+    setRefiners(refiners: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void {
+        this._setArrayProp("refiners", refiners);
+    }
+
+    setModifiers(modifiers: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void {
+        this._setArrayProp("modifiers", modifiers);
+    }
+
+    toJSON(): Record<string, unknown> {
+        const pickSlugFromObject = (item: SlugifiedEntry) => _.pick(item, "slug");
+        return {
+            ...super.toJSON(),
+            functional: pickSlugFromObject(this.functional),
+            refiners: this.refiners,
+            modifiers: this.modifiers,
+        };
+    }
+
+    get allFunctionals(): SlugifiedEntry[] {
+        return (this.treeBranchForSubType.functionals || []).map((slug) =>
+            treeSlugToNamedObject(slug),
+        );
+    }
+
+    get allRefiners(): SlugifiedEntry[] {
+        return (this.treeBranchForSubType.refiners || []).map((slug) =>
+            treeSlugToNamedObject(slug),
+        );
+    }
+
+    get allModifiers(): SlugifiedEntry[] {
+        return (this.treeBranchForSubType.modifiers || []).map((slug) =>
+            treeSlugToNamedObject(slug),
+        );
+    }
+}

package/src/{models/factory.js → js/models/factory.ts}

@@ -1,5 +1,6 @@
 import { Model } from "../model";
 import { getDefaultModelTypeForApplication } from "../tree";
+import type { ModelConfig } from "../types";
 import { DFTModel } from "./dft";
 
 export class ModelFactory {
@@ -7,7 +8,7 @@ export class ModelFactory {
 
     static Model = Model;
 
-    static create(config) {
+    static create(config: ModelConfig): Model {
         switch (config.type) {
             case "dft":
                 return new this.DFTModel(config);
@@ -16,13 +17,17 @@ export class ModelFactory {
         }
     }
 
-    static createFromApplication(config) {
+    static createFromApplication(config: ModelConfig): Model {
         const { application } = config;
-        const type = application && getDefaultModelTypeForApplication(application);
-        if (!type)
+        if (!application) {
+            throw new Error("ModelFactory.createFromApplication: application is required");
+        }
+        const type = getDefaultModelTypeForApplication(application);
+        if (!type) {
             throw new Error(
                 `ModelFactory.createFromApplication: cannot determine model type: ${type}`,
             );
+        }
         return this.create({ ...config, type });
     }
 }

package/src/{tree.js → js/tree.ts}

@@ -1,24 +1,26 @@
 import { deepClone } from "@mat3ra/code/dist/js/utils";
-import { ModelMethodFilter } from "@mat3ra/standata";
+import { ApplicationSchemaBase, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
 import lodash from "lodash";
 import _ from "underscore";
 
+import type { ModelTree } from "./types";
+
 // TODO: migrate to use manifest instead
 
 export const METHODS = {
     pseudopotential: "pseudopotential",
     localorbital: "localorbital",
     unknown: "unknown",
-};
+} as const;
 
-const methods = {
+const methods: Record<string, string[]> = {
     [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];
+export const getPseudopotentialTypesFromTree = (): string[] => methods[METHODS.pseudopotential];
 
 // DFT-specific
 
@@ -48,16 +50,16 @@ const DFTModelTree = {
     },
 };
 
-export const getDFTFunctionalsFromTree = () => Object.keys(DFTModelTree);
+export const getDFTFunctionalsFromTree = (): string[] => Object.keys(DFTModelTree);
 
-export const getDFTFunctionalsByApproximation = (approximation) => {
-    const branch = DFTModelTree[approximation];
+export const getDFTFunctionalsByApproximation = (approximation: string): string[] | undefined => {
+    const branch = DFTModelTree[approximation as keyof typeof DFTModelTree];
     return branch && branch.functionals;
 };
 
 // GENERAL
 
-export const MODEL_TREE = {
+export const MODEL_TREE: ModelTree = {
     dft: DFTModelTree,
     ml: {
         re: {
@@ -76,7 +78,7 @@ export const MODEL_TREE = {
     },
 };
 
-export const MODEL_NAMES = {
+export const MODEL_NAMES: Record<string, string> = {
     dft: "density functional theory",
     lda: "local density approximation",
     gga: "generalized gradient approximation",
@@ -85,7 +87,7 @@ export const MODEL_NAMES = {
     re: "regression",
 };
 
-export const treeSlugToNamedObject = (modelSlug) => {
+export const treeSlugToNamedObject = (modelSlug: string): SlugifiedEntry => {
     return {
         slug: modelSlug,
         name: lodash.get(MODEL_NAMES, modelSlug, modelSlug),
@@ -97,11 +99,13 @@ export const treeSlugToNamedObject = (modelSlug) => {
 // 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"));
+type DftOnlyTree = { dft: typeof DFTModelTree };
 
-["gga", "lda"].forEach((approximation) => {
+const VASP_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft")) as DftOnlyTree;
+const ESPRESSO_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft")) as DftOnlyTree;
+const NWCHEM_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft")) as DftOnlyTree;
+
+(["gga", "lda"] as const).forEach((approximation) => {
     // pick "paw" for vasp
     VASP_MODELS_TREE.dft[approximation].methods.pseudopotential = VASP_MODELS_TREE.dft[
         approximation
@@ -112,10 +116,13 @@ const NWCHEM_MODELS_TREE = deepClone(_.pick(MODEL_TREE, "dft"));
         ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential.reverse();
 });
 
-const UNKNOWN_MODELS_TREE = _.pick(MODEL_TREE, "unknown");
+const UNKNOWN_MODELS_TREE = _.pick(MODEL_TREE, "unknown") as ModelTree;
 // const ML_MODELS_TREE = _.pick(MODEL_TREE, "ml");
 
-const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION = [
+const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION: Array<{
+    name: string;
+    tree: ModelTree;
+}> = [
     {
         name: "vasp",
         tree: VASP_MODELS_TREE,
@@ -148,28 +155,14 @@ const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION = [
 
 export const getTreeByApplicationNameAndVersion = ({
     name,
-    // eslint-disable-next-line no-unused-vars
-    version,
-}) => {
+}: Pick<ApplicationSchemaBase, "name" | "version">): ModelTree => {
     // 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);
+    ).map((cfg) => cfg.tree);
     return Object.assign({}, ...cfgs);
 };
 
-export const getDefaultModelTypeForApplication = (application) => {
+export const getDefaultModelTypeForApplication = (application: ApplicationSchemaBase): string => {
     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);
-}

package/src/js/types/index.ts

@@ -0,0 +1,37 @@
+import type {
+    ApplicationSchemaBase,
+    BaseModel,
+    CategorizedMethod,
+    CategorizedModel,
+    CategorizedUnitMethod,
+} from "@mat3ra/esse/dist/js/types";
+
+export type ModelConfig = Pick<BaseModel, "type" | "subtype"> &
+    Partial<Omit<BaseModel, "type" | "subtype">> & {
+        application?: ApplicationSchemaBase;
+    };
+
+export type SimplifiedCategorizedModel = Pick<
+    CategorizedModel,
+    "name" | "path" | "categories" | "parameters"
+>;
+
+export type SimplifiedCategorizedMethod = Pick<CategorizedMethod, "name" | "path"> & {
+    units: CategorizedUnitMethod[];
+};
+
+export interface PseudopotentialLike {
+    element?: string;
+    toJSON(): Record<string, unknown>;
+}
+
+export type PseudopotentialCtor = new (config: Record<string, unknown>) => PseudopotentialLike;
+
+export interface MethodTreeBranch {
+    methods: Record<string, string[]>;
+    functionals?: string[];
+    refiners?: string[];
+    modifiers?: string[];
+}
+
+export type ModelTree = Record<string, Record<string, MethodTreeBranch>>;

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "@mat3ra/tsconfig/tsconfig-js-py-dev.json"
+}

package/.babelrc

@@ -1,17 +0,0 @@
-{
-    "presets": [
-        [
-            "@babel/preset-env",
-            {
-                "targets": {
-                    "node": "current"
-                }
-            }
-        ],
-        "@babel/preset-react",
-    ],
-    "plugins": [
-        "@babel/plugin-proposal-class-properties"
-    ]
-}
-