@mat3ra/wode 2025.10.1-0

package/src/workflows/create.js

@@ -0,0 +1,222 @@
+import { createSubworkflow } from "../subworkflows/create";
+import { UnitFactory } from "../units";
+import { defaultMapConfig } from "../units/map";
+import { applyConfig, findUnit } from "../utils";
+import { Workflow } from "./workflow";
+
+/**
+ * @summary Helper for creating Map units for complex workflows
+ * @param config {Object} map unit configuration
+ * @param unitFactoryCls {*} class factory for map unit
+ * @returns {*} map unit
+ */
+function createMapUnit({ config, unitFactoryCls = UnitFactory }) {
+    let { input: defaultInput } = defaultMapConfig;
+    if (config.input) {
+        defaultInput = { ...defaultInput, ...config.input };
+    }
+    const unit = unitFactoryCls.create({ ...defaultMapConfig, input: defaultInput });
+    return unit;
+}
+
+/**
+ * @summary Update subworkflow units with patch configuration defined in the workflow config
+ * @param subworkflowData {Object} subworkflow data
+ * @param unitConfigs {Array<Object>} array of patch configs for subworkflow units
+ * @returns subworkflowData {Object} subworkflowData with patches applied to units
+ */
+function updateUnitConfigs({ subworkflowData, unitConfigs }) {
+    unitConfigs.forEach((config) => {
+        const { index, type, config: unitConfig } = config; // unitConfig should contain 'attributes' key
+        const unit = findUnit({ subworkflowData, index, type });
+        console.log(`  patching ${type} unit ${index} of subworkflow ${subworkflowData.name}`);
+        unit.config = applyConfig({ obj: unit.config, config: unitConfig });
+        return null;
+    });
+    return subworkflowData;
+}
+
+/**
+ * @summary Use subworkflow.createSubworkflow to create a Subworkflow unit
+ * @param appName {String} application name
+ * @param unitData {*} object containing subworkflow configuration data
+ * @param workflowData {*} object containing all workflow configuration data
+ * @param swArgs {*} subworkflow classes
+ * @returns {*} subworkflow object
+ */
+function createSubworkflowUnit({ appName, unitData, workflowData, ...swArgs }) {
+    const { name: unitName, unitConfigs, config } = unitData;
+    const { subworkflows } = workflowData;
+    const { [appName]: dataByApp } = subworkflows;
+    let { [unitName]: subworkflowData } = dataByApp;
+    subworkflowData.config = { ...subworkflowData.config, ...config };
+    if (unitConfigs) subworkflowData = updateUnitConfigs({ subworkflowData, unitConfigs });
+    return createSubworkflow({
+        subworkflowData,
+        ...swArgs,
+    });
+}
+
+/**
+ * @summary Create the first workflow object specified in a workflow configuration
+ * @param workflow {*|null} the workflow (if already initialized, no-op)
+ * @param unit {*} workflow unit object
+ * @param type {String} value in ["workflow", "subworkflow"]
+ * @param workflowCls {*} workflow class
+ * @returns {Workflow|*} workflow object
+ */
+function createWorkflowHead({ workflow, unit, type, workflowCls }) {
+    if (workflow) return workflow;
+    let wf;
+    switch (type) {
+        case "workflow":
+            wf = unit;
+            break;
+        case "subworkflow":
+            wf = workflowCls.fromSubworkflow(unit);
+            break;
+        default:
+            throw new Error(`workflow type=${type} not understood.`);
+    }
+    return wf;
+}
+
+/**
+ * @summary Combine workflow units together
+ * @param workflow {*} the workflow object
+ * @param unit {*} workflow/subworkflow object
+ * @param config {*} additional configuration for e.g. map units
+ * @param type {String} value in ["workflow", "subworkflow"]
+ * @param unitFactoryCls {*} unit factory class for e.g. map units
+ * @returns {*} modified workflow
+ */
+function composeWorkflow({ workflow, unit, config, type, unitFactoryCls }) {
+    /* eslint-disable no-case-declarations */
+    switch (type) {
+        case "workflow":
+            const { mapUnit: isMapUnit, ...mapUnitConfig } = config;
+            if (isMapUnit) {
+                const mapUnit = createMapUnit({ config: mapUnitConfig, unitFactoryCls });
+                workflow.addMapUnit(mapUnit, unit);
+            } else {
+                console.log("adding workflows directly to workflows is not supported.");
+            }
+            break;
+        case "subworkflow":
+            workflow.addSubworkflow(unit);
+            break;
+        default:
+            throw new Error(`workflow type=${type} not understood.`);
+    }
+    /* eslint-enable no-case-declarations */
+    return workflow;
+}
+
+/**
+ * @summary Convert a flattened array of workflow units to a properly constructed workflow
+ * @param wfUnits {Array} array of workflow units
+ * @param workflowCls {*} workflow class
+ * @param unitFactoryCls {*} unit factory class
+ * @returns {*} constructed workflow
+ */
+function createFromWorkflowUnits({ wfUnits, workflowCls, unitFactoryCls }) {
+    let workflow, unit, config, type;
+    wfUnits.map((wfUnit) => {
+        ({ unit, config, type } = wfUnit);
+        if (!workflow) {
+            workflow = createWorkflowHead({
+                workflow,
+                unit,
+                type,
+                workflowCls,
+            });
+        } else {
+            workflow = composeWorkflow({
+                workflow,
+                unit,
+                config,
+                type,
+                unitFactoryCls,
+            });
+        }
+        return null;
+    });
+    return applyConfig({ obj: workflow, config });
+}
+
+/**
+ * @summary Creates a flattened array of workflow units from nested workflow/subworkflow
+ * configuration data comprising a simple or complex workflow
+ * @param appName
+ * @param units
+ * @param swArgs
+ * @returns {*[]}
+ */
+function createWorkflowUnits({
+    appName,
+    workflowData,
+    workflowSubworkflowMapByApplication,
+    workflowCls,
+    ...swArgs
+}) {
+    const wfUnits = [];
+    const { units } = workflowData;
+    let unit, config;
+    units.map((unitData) => {
+        const { type } = unitData;
+        switch (type) {
+            case "workflow":
+                ({ config } = unitData);
+                unit = createWorkflowUnits({
+                    appName,
+                    workflowData: unitData,
+                    workflowSubworkflowMapByApplication,
+                    workflowCls,
+                    ...swArgs,
+                });
+                break;
+            case "subworkflow":
+                ({ config } = workflowData);
+                unit = createSubworkflowUnit({
+                    appName,
+                    unitData,
+                    workflowData: workflowSubworkflowMapByApplication,
+                    ...swArgs,
+                });
+                break;
+            default:
+                break;
+        }
+        wfUnits.push({ config, unit, type });
+        return null;
+    });
+    return createFromWorkflowUnits({
+        wfUnits,
+        workflowCls,
+        subworkflowCls: swArgs.subworkflowCls,
+        unitFactoryCls: swArgs.unitFactoryCls,
+    });
+}
+
+function createWorkflow({
+    appName,
+    workflowData,
+    workflowSubworkflowMapByApplication,
+    workflowCls = Workflow,
+    ...swArgs
+}) {
+    const { name } = workflowData;
+    console.log(`wode: creating ${appName} workflow ${name}`);
+    const wf = createWorkflowUnits({
+        appName,
+        workflowData,
+        workflowSubworkflowMapByApplication,
+        workflowCls,
+        ...swArgs,
+    });
+    wf.setName(name);
+    wf.applicationName = appName;
+    return wf;
+}
+
+export { createWorkflow };

package/src/workflows/default.js

@@ -0,0 +1,39 @@
+export default {
+    name: "New Workflow",
+    properties: [],
+    subworkflows: [
+        {
+            _id: "c6e9dbbee8929de01f4e76ee",
+            application: {
+                name: "espresso",
+                summary: "Quantum Espresso",
+                version: "6.3",
+            },
+            model: {
+                method: {
+                    subtype: "us",
+                    type: "pseudopotential",
+                },
+                subtype: "gga",
+                type: "dft",
+            },
+            name: "New Subworkflow",
+            properties: [],
+            units: [],
+        },
+    ],
+    workflows: [],
+    units: [
+        {
+            _id: "c6e9dbbee8929de01f4e76ee",
+            flowchartId: "da2c090ede4dc2fa6e66647f",
+            head: true,
+            monitors: [],
+            postProcessors: [],
+            preProcessors: [],
+            results: [],
+            type: "subworkflow",
+            name: "New Subworkflow",
+        },
+    ],
+};

package/src/workflows/index.js

@@ -0,0 +1,99 @@
+import { allApplications } from "@exabyte-io/ade.js";
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import schemas from "@mat3ra/esse/dist/js/schemas.json";
+import { workflowSubforkflowMapByApplication } from "@mat3ra/standata";
+
+// Import Template here to apply context provider patch
+// eslint-disable-next-line no-unused-vars
+import { Template } from "../patch";
+import { createWorkflow } from "./create";
+import { Workflow } from "./workflow";
+
+// Running this to set schemas for validation, removing the redundant data from application-flavors tree: `flavors`
+JSONSchemasInterface.setSchemas(schemas);
+
+/*
+    Workflow construction follows these rules:
+        1. Workflow is constructed as a collection of subworkflows defined in JSON
+        2. A "units" key should contain at least one object referencing the workflow itself
+        3. Additional workflows are added in order specified in the same "units" array
+        4. map units are added along with their workflows according to data in "units"
+        5. top-level subworkflows are added directly in the order also specified by "units"
+ */
+function createWorkflows({
+    appName = null,
+    workflowCls = Workflow,
+    workflowSubworkflowMapByApplication = workflowSubforkflowMapByApplication,
+    ...swArgs
+}) {
+    let apps = appName !== null ? [appName] : allApplications;
+    const allApplicationsFromWorkflowData = Object.keys(
+        workflowSubworkflowMapByApplication.workflows,
+    );
+    // output warning if allApplications and allApplicationsFromWorkflowData do not match
+    if (appName === null) {
+        if (apps.sort().join(",") !== allApplicationsFromWorkflowData.sort().join(",")) {
+            // eslint-disable-next-line no-console
+            console.warn(
+                `Warning: allApplications and allApplicationsFromWorkflowData do not match: 
+                ${apps.sort().join(",")} !== ${allApplicationsFromWorkflowData.sort().join(",")}`,
+            );
+            console.warn("Using allApplicationsFromWorkflowData");
+        }
+        apps = allApplicationsFromWorkflowData;
+    }
+    const wfs = [];
+    const { workflows } = workflowSubworkflowMapByApplication;
+    apps.map((name) => {
+        const { [name]: dataByApp } = workflows;
+        Object.values(dataByApp).map((workflowDataForApp) => {
+            wfs.push(
+                createWorkflow({
+                    appName: name,
+                    workflowData: workflowDataForApp,
+                    workflowSubworkflowMapByApplication,
+                    workflowCls,
+                    ...swArgs,
+                }),
+            );
+            return null;
+        });
+        return null;
+    });
+    return wfs;
+}
+
+/**
+ * @summary Create workflow configurations for all applications
+ * @param applications {Array<String>} array of application names
+ * @param workflowCls {*} workflow class to instantiate
+ * @param workflowSubworkflowMapByApplication {Object} object containing all workflow/subworkflow map by application
+ * @param swArgs {Object} other classes for instantiation
+ * @returns {Array<Object>} array of workflow configurations
+ */
+function createWorkflowConfigs({
+    applications,
+    workflowCls = Workflow,
+    workflowSubworkflowMapByApplication,
+    ...swArgs
+}) {
+    const configs = [];
+    applications.forEach((app) => {
+        const workflows = createWorkflows({
+            appName: app,
+            workflowCls,
+            workflowSubworkflowMapByApplication,
+            ...swArgs,
+        });
+        workflows.forEach((wf) => {
+            configs.push({
+                application: app,
+                name: wf.prop("name"),
+                config: wf.toJSON(),
+            });
+        });
+    });
+    return configs;
+}
+
+export { Workflow, createWorkflows, createWorkflowConfigs };

package/src/workflows/relaxation.js

@@ -0,0 +1,41 @@
+import { SubworkflowStandata } from "@mat3ra/standata";
+
+export const RelaxationLogicMixin = (superclass) =>
+    class extends superclass {
+        get relaxationSubworkflow() {
+            const appName = this.subworkflows[0]?.application?.name;
+            if (!appName) return undefined;
+            const subworkflowStandata = new SubworkflowStandata();
+            const relaxationSubworkflow =
+                subworkflowStandata.getRelaxationSubworkflowByApplication(appName);
+            return new this._Subworkflow(relaxationSubworkflow);
+        }
+
+        isRelaxationSubworkflow(subworkflow) {
+            const { relaxationSubworkflow } = this;
+            return (
+                relaxationSubworkflow?.systemName !== undefined &&
+                relaxationSubworkflow.systemName === subworkflow.systemName
+            );
+        }
+
+        get hasRelaxation() {
+            return this.subworkflows.some((subworkflow) =>
+                this.isRelaxationSubworkflow(subworkflow),
+            );
+        }
+
+        toggleRelaxation() {
+            if (this.hasRelaxation) {
+                const relaxSubworkflow = this.subworkflows.find((sw) =>
+                    this.isRelaxationSubworkflow(sw),
+                );
+                this.removeSubworkflow(relaxSubworkflow.id);
+            } else {
+                const vcRelax = this.relaxationSubworkflow;
+                if (vcRelax) {
+                    this.addSubworkflow(vcRelax, true);
+                }
+            }
+        }
+    };