@mat3ra/wode 2026.4.9-0 → 2026.5.29-0

package/src/js/subworkflows/create.js

@@ -1,220 +0,0 @@
-import { ApplicationRegistry } from "@mat3ra/ade";
-import {
-    default_methods as MethodConfigs,
-    default_models as ModelConfigs,
-    MethodConversionHandler,
-    MethodFactory,
-    ModelFactory,
-} from "@mat3ra/mode";
-import { ApplicationMethodStandata } from "@mat3ra/standata";
-import _ from "lodash";
-
-import { UnitFactory } from "../units";
-import { builders } from "../units/builders";
-import { applyConfig } from "../utils";
-import { dynamicSubworkflowsByApp, getSurfaceEnergySubworkflowUnits } from "./dynamic";
-import { Subworkflow } from "./subworkflow";
-
-// NOTE: DFTModel => DFTModelConfig, configs should have the same name as the model/method class + "Config" at the end
-function _getConfigFromModelOrMethodName(name, kind) {
-    const configs = kind === "Model" ? ModelConfigs : MethodConfigs;
-    if (!configs[`${name}Config`]) {
-        // eslint-disable-next-line no-param-reassign
-        name = `Unknown${kind}`;
-    }
-    return configs[`${name}Config`];
-}
-
-/**
- * @summary Create model from subworkflow data
- * @param config {Object} model config
- * @param modelFactoryCls {any} model factory to use
- * @returns {DFTModel|Model}
- */
-function createModel({ config, modelFactoryCls }) {
-    const { name, config: modelConfig = {} } = config;
-    const defaultConfig = _getConfigFromModelOrMethodName(name, "Model");
-    return modelFactoryCls.create({ ...defaultConfig, ...modelConfig });
-}
-
-/**
- * @summary Create method from subworkflow data
- * @param config {Object} method configuration
- * @param methodFactoryCls {any}
- * @param applicationConfig {Object} application configuration
- * @returns {{method, setSearchText}}
- */
-function createMethod({ config, methodFactoryCls, applicationConfig = {} }) {
-    const { name, setSearchText = null, config: methodConfig = {} } = config;
-    const defaultConfig = _getConfigFromModelOrMethodName(name, "Method");
-    const defaultConfigForApp =
-        new ApplicationMethodStandata().getDefaultMethodConfigForApplication(applicationConfig);
-    const defaultConfigForAppSimple =
-        defaultConfigForApp && defaultConfigForApp.units
-            ? MethodConversionHandler.convertToSimple(defaultConfigForApp)
-            : defaultConfigForApp;
-    const method = methodFactoryCls.create({
-        ...defaultConfig,
-        ...defaultConfigForAppSimple,
-        ...methodConfig,
-    });
-    return { method, setSearchText };
-}
-
-/**
- * @summary Create top-level objects used in subworkflow initialization
- * @param subworkflowData {Object} subworkflow data
- * @param AppRegistry
- * @param modelFactoryCls {any} model factory class
- * @param methodFactoryCls {any} method factory class
- * @returns {{application: *, method: *, model: (DFTModel|Model), setSearchText: String|null}}
- */
-function createTopLevel({ subworkflowData, modelFactoryCls, methodFactoryCls, AppRegistry }) {
-    const { application: appConfig, model: modelConfig, method: methodConfig } = subworkflowData;
-    const application = AppRegistry.createApplication(appConfig);
-    const model = createModel({ config: modelConfig, modelFactoryCls });
-    const { method, setSearchText } = createMethod({
-        config: methodConfig,
-        methodFactoryCls,
-        applicationConfig: appConfig,
-    });
-    return {
-        application,
-        model,
-        method,
-        setSearchText,
-    };
-}
-
-/**
- * @summary Create workflow unit from JSON configuration
- *      Supports applying functions to the builder prior to building via "functions"
- *      Supports applying attributes to the builder after building via "attributes"
- * @param config {Object} unit config
- * @param application {*} application
- * @param unitBuilders {Object} workflow unit builders
- * @param unitFactoryCls {*} workflow unit class factory
- * @returns {*|{head: boolean, preProcessors: [], postProcessors: [], name: *, flowchartId: *, type: *, results: [], monitors: []}}
- */
-export function createUnit({ config, application, unitBuilders, unitFactoryCls, cache = [] }) {
-    const { type, config: unitConfig } = config;
-    if (type === "executionBuilder") {
-        const { name, execName, flavorName, flowchartId } = unitConfig;
-        const builder = new unitBuilders.ExecutionUnitConfigBuilder(
-            name,
-            application,
-            execName,
-            flavorName,
-            flowchartId,
-            cache,
-        );
-
-        // config should contain "functions" and "attributes"
-        const cfg = applyConfig({ obj: builder, config, callBuild: true });
-        return unitFactoryCls.create(cfg);
-    }
-
-    return unitFactoryCls.create({ type, ...unitConfig });
-}
-
-/**
- * @summary Dynamically create subworkflow units
- * @param dynamicSubworkflow {String} name of unit creation function
- * @param units {Array} configured units to provide to dynamic unit creation
- * @param unitBuilders {Object} unit configuration builders
- * @param unitFactoryCls {*} unit factory class
- * @param application {*} application (optional)
- * @returns {*}
- */
-function createDynamicUnits({
-    dynamicSubworkflow,
-    units,
-    unitBuilders,
-    unitFactoryCls,
-    application = null,
-}) {
-    const { name, subfolder } = dynamicSubworkflow;
-    const func = subfolder && _.get(dynamicSubworkflowsByApp, `${subfolder}.${name}`, () => {});
-    switch (name) {
-        case "surfaceEnergy":
-            // eslint-disable-next-line no-case-declarations
-            const [scfUnit] = units;
-            return getSurfaceEnergySubworkflowUnits({ scfUnit, unitBuilders });
-        case "getQpointIrrep":
-            return func({ unitBuilders, unitFactoryCls, application });
-        default:
-            throw new Error(`dynamicSubworkflow=${name} not recognized`);
-    }
-}
-
-function createSubworkflow({
-    subworkflowData,
-    cache = [],
-    AppRegistry = ApplicationRegistry,
-    modelFactoryCls = ModelFactory,
-    methodFactoryCls = MethodFactory,
-    subworkflowCls = Subworkflow,
-    unitFactoryCls = UnitFactory,
-    unitBuilders = builders,
-}) {
-    const { application, model, method, setSearchText } = createTopLevel({
-        subworkflowData,
-        AppRegistry,
-        modelFactoryCls,
-        methodFactoryCls,
-    });
-
-    let units = [];
-    const { name, units: unitConfigs, config = {}, dynamicSubworkflow = null } = subworkflowData;
-    unitConfigs.forEach((_config) => {
-        units.push(
-            createUnit({
-                config: _config,
-                application,
-                unitBuilders,
-                unitFactoryCls,
-                cache,
-            }),
-        );
-    });
-    if (dynamicSubworkflow) {
-        units = createDynamicUnits({
-            dynamicSubworkflow,
-            units,
-            unitBuilders,
-            unitFactoryCls,
-            application,
-        });
-    }
-
-    let subworkflow = subworkflowCls.fromArguments(application, model, method, name, units, config);
-    const { functions = {}, attributes = {} } = config;
-    subworkflow = applyConfig({ obj: subworkflow, config: { functions, attributes } });
-    if (setSearchText) subworkflow.model.Method.setSearchText(setSearchText);
-    return subworkflow;
-}
-
-/**
- * @summary Convenience wrapper around createSubworkflow to create by app name and swf name
- * @param appName {String} application name
- * @param swfName {String} subworkflow name (snake_case.yml)
- * @param workflowSubworkflowMapByApplication {Object} object containing all workflow/subworkflow map by application
- * @param swArgs {Object} classes for instantiation
- * @returns {*} subworkflow object
- */
-function createSubworkflowByName({
-    appName,
-    swfName,
-    workflowSubworkflowMapByApplication,
-    ...swArgs
-}) {
-    const { subworkflows } = workflowSubworkflowMapByApplication;
-    const { [appName]: allSubworkflowData } = subworkflows;
-    const { [swfName]: subworkflowData } = allSubworkflowData;
-    return createSubworkflow({
-        subworkflowData,
-        ...swArgs,
-    });
-}
-
-export { createSubworkflow, createSubworkflowByName };

package/src/js/subworkflows/dynamic/espresso/getQpointIrrep.js

@@ -1,35 +0,0 @@
-import { UNIT_TYPES } from "../../../enums";
-
-/**
- * @summary Get QptIrr units used in phonon map calculations
- * @param unitBuilders {Object} unit builders
- * @param unitFactoryCls {*} unit factory class
- * @param application {*} application instance
- * @returns {[{head: boolean, preProcessors: [], postProcessors: [], name: *, flowchartId: *, type: *, results: [], monitors: []},*]}
- */
-function getQpointIrrep({ unitBuilders, unitFactoryCls, application }) {
-    const { ExecutionUnitConfigBuilder } = unitBuilders;
-
-    const pythonUnit = new ExecutionUnitConfigBuilder(
-        "python",
-        application,
-        "python",
-        "espresso_xml_get_qpt_irr",
-    ).build();
-
-    const assignmentUnit = unitFactoryCls.create({
-        type: UNIT_TYPES.assignment,
-        input: [
-            {
-                scope: pythonUnit.flowchartId,
-                name: "STDOUT",
-            },
-        ],
-        operand: "Q_POINTS",
-        value: "json.loads(STDOUT)",
-    });
-
-    return [pythonUnit, assignmentUnit];
-}
-
-export { getQpointIrrep };

package/src/js/subworkflows/dynamic/index.js

@@ -1,8 +0,0 @@
-import { getQpointIrrep } from "./espresso/getQpointIrrep";
-import { getSurfaceEnergySubworkflowUnits } from "./surfaceEnergy";
-
-const dynamicSubworkflowsByApp = {
-    espresso: { getQpointIrrep },
-};
-
-export { getSurfaceEnergySubworkflowUnits, dynamicSubworkflowsByApp };

package/src/js/subworkflows/dynamic/surfaceEnergy.js

@@ -1,124 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-
-function getIOUnitEndpointOptions(query, projection = "{}") {
-    return {
-        params: {
-            query,
-            projection,
-        },
-    };
-}
-
-function getAssignmentUnitInput(unit, name) {
-    return [
-        {
-            name,
-            scope: unit.flowchartId,
-        },
-    ];
-}
-
-function getSurfaceEnergySubworkflowUnits({ scfUnit, unitBuilders }) {
-    const { IOUnitConfigBuilder, AssignmentUnitConfigBuilder, AssertionUnitConfigBuilder } =
-        unitBuilders;
-
-    let input, endpointOptions;
-    endpointOptions = getIOUnitEndpointOptions("{'_id': MATERIAL_ID}");
-    const getSlabUnit = new IOUnitConfigBuilder("io-slab", "materials", endpointOptions).build();
-
-    input = getAssignmentUnitInput(getSlabUnit, "DATA");
-    const setSlabUnit = new AssignmentUnitConfigBuilder("slab", "SLAB", "DATA[0]", input).build();
-
-    endpointOptions = getIOUnitEndpointOptions("{'_id': SLAB.metadata.bulkId}");
-    const getBulkUnit = new IOUnitConfigBuilder("io-bulk", "materials", endpointOptions).build();
-
-    const BULKValue = "DATA[0] if DATA else None";
-    input = getAssignmentUnitInput(getBulkUnit, "DATA");
-    const setBulkUnit = new AssignmentUnitConfigBuilder("bulk", "BULK", BULKValue, input).build();
-
-    const assertBulkUnit = new AssertionUnitConfigBuilder(
-        "assert-bulk",
-        "BULK != None",
-        "Bulk material does not exist!",
-    ).build();
-
-    const query = Utils.str.removeNewLinesAndExtraSpaces(`{
-        'exabyteId': BULK.exabyteId,
-        'data.name': 'total_energy',
-        'group': {'$regex': ''.join((SUBWORKFLOW.application.shortName, ':'))}
-    }`);
-    // Do not confuse `sort` with `$sort`. `sort` is used in meteor collections and `$sort` is used in Mongo queries.
-    const projection = "{'sort': {'precision.value': -1}, 'limit': 1}";
-    endpointOptions = getIOUnitEndpointOptions(query, projection);
-    const getEBulkUnit = new IOUnitConfigBuilder(
-        "io-e-bulk",
-        "refined-properties",
-        endpointOptions,
-    ).build();
-
-    input = getAssignmentUnitInput(getEBulkUnit, "DATA");
-    const EBULKValue = "DATA[0].data.value if DATA else None";
-    const setEBulkUnit = new AssignmentUnitConfigBuilder(
-        "e-bulk",
-        "E_BULK",
-        EBULKValue,
-        input,
-    ).build();
-
-    const assertEBulkUnit = new AssertionUnitConfigBuilder(
-        "assert-e-bulk",
-        "E_BULK != None",
-        "E_BULK does not exist!",
-    ).build();
-
-    const AValue = "np.linalg.norm(np.cross(SLAB.lattice.vectors.a, SLAB.lattice.vectors.b))";
-    const setSurfaceUnit = new AssignmentUnitConfigBuilder("surface", "A", AValue).build();
-
-    const setNBulkUnit = new AssignmentUnitConfigBuilder(
-        "n-bulk",
-        "N_BULK",
-        "len(BULK.basis.elements)",
-    ).build();
-    const setNSlabUnit = new AssignmentUnitConfigBuilder(
-        "n-slab",
-        "N_SLAB",
-        "len(SLAB.basis.elements)",
-    ).build();
-
-    input = getAssignmentUnitInput(scfUnit, "total_energy");
-    const setESlabUnit = new AssignmentUnitConfigBuilder(
-        "e-slab",
-        "E_SLAB",
-        "total_energy",
-        input,
-    ).build();
-
-    const results = [{ name: "surface_energy" }];
-    const SEValue = "1 / (2 * A) * (E_SLAB - E_BULK * (N_SLAB/N_BULK))";
-    const surfaceEnergyUnit = new AssignmentUnitConfigBuilder(
-        "surface-energy",
-        "SURFACE_ENERGY",
-        SEValue,
-        [],
-        results,
-    ).build();
-
-    return [
-        getSlabUnit,
-        setSlabUnit,
-        getBulkUnit,
-        setBulkUnit,
-        assertBulkUnit,
-        getEBulkUnit,
-        setEBulkUnit,
-        assertEBulkUnit,
-        setSurfaceUnit,
-        setNBulkUnit,
-        setNSlabUnit,
-        scfUnit,
-        setESlabUnit,
-        surfaceEnergyUnit,
-    ];
-}
-
-export { getSurfaceEnergySubworkflowUnits };

package/src/js/subworkflows/index.js

@@ -1,2 +0,0 @@
-export { Subworkflow } from "./subworkflow";
-export { createSubworkflowByName } from "./create";