@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/src/js/context/providers/CollinearMagnetizationDataManager.ts

@@ -0,0 +1,140 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    CollinearMagnetizationContextItemSchema,
+    CollinearMagnetizationContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import materialContextMixin, {
+    type MaterialContextMixin,
+    type MaterialExternalContext,
+} from "../mixins/MaterialContextMixin";
+import type { UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+
+type Data = CollinearMagnetizationContextProviderSchema;
+type Schema = CollinearMagnetizationContextItemSchema;
+type ExternalContext = JinjaExternalContext & MaterialExternalContext;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface CollinearMagnetizationDataManager extends MaterialContextMixin {}
+
+const defaultData = {
+    value: 0.0,
+    isTotalMagnetization: false,
+    totalMagnetization: 0.0,
+};
+
+const jsonSchemaId = "context-providers-directory/collinear-magnetization-context-provider";
+
+class CollinearMagnetizationDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name = "collinearMagnetization" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "collinearMagnetization");
+
+        return new CollinearMagnetizationDataManager(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    private readonly isTotalMagnetization: boolean;
+
+    private readonly firstElement: string;
+
+    private readonly uniqueElementsWithLabels: string[];
+
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext) {
+        super(contextItem, externalContext);
+        this.initMaterialContextMixin(externalContext);
+
+        this.uniqueElementsWithLabels = [
+            ...new Set(this.material?.Basis?.elementsWithLabelsArray || []),
+        ];
+
+        this.firstElement =
+            this.uniqueElementsWithLabels?.length > 0 ? this.uniqueElementsWithLabels[0] : "";
+
+        this.isTotalMagnetization = this.data?.isTotalMagnetization || false;
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            "properties.startingMagnetization": {
+                maxItems: this.uniqueElementsWithLabels.length,
+            },
+            "properties.startingMagnetization.items.properties.atomicSpecies": {
+                enum: this.uniqueElementsWithLabels,
+                default: this.firstElement,
+            },
+            "properties.startingMagnetization.items.properties.value": {
+                default: defaultData.value,
+            },
+            "properties.isTotalMagnetization": {
+                default: defaultData.isTotalMagnetization,
+            },
+            "properties.totalMagnetization": {
+                default: defaultData.totalMagnetization,
+            },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        return {
+            startingMagnetization: [
+                {
+                    index: 1,
+                    atomicSpecies: this.firstElement,
+                    value: defaultData.value,
+                },
+            ],
+            isTotalMagnetization: defaultData.isTotalMagnetization,
+            totalMagnetization: defaultData.totalMagnetization,
+        };
+    }
+
+    setData(data: Data) {
+        const startingMagnetization = data.startingMagnetization.map((row) => ({
+            ...row,
+            index: this.uniqueElementsWithLabels.indexOf(row.atomicSpecies) + 1,
+        }));
+
+        super.setData({
+            ...data,
+            startingMagnetization,
+        });
+    }
+
+    get uiSchemaStyled() {
+        return {
+            startingMagnetization: {
+                items: {
+                    atomicSpecies: {
+                        "ui:classNames": "col-xs-3",
+                    },
+                    value: {
+                        "ui:classNames": "col-xs-6",
+                    },
+                },
+                "ui:readonly": this.isTotalMagnetization,
+            },
+            isTotalMagnetization: {},
+            totalMagnetization: {
+                "ui:classNames": "col-xs-6",
+                "ui:readonly": !this.isTotalMagnetization,
+            },
+        };
+    }
+}
+
+materialContextMixin(CollinearMagnetizationDataManager.prototype);
+
+export default CollinearMagnetizationDataManager;

package/src/js/context/providers/Hubbard/HubbardContextManagerLegacy.ts

@@ -0,0 +1,93 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    HubbardLegacyContextItemSchema,
+    HubbardLegacyContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "../base/ContextProvider";
+import HubbardContextProvider, { type HubbardExternalContext } from "./HubbardContextProvider";
+
+type Schema = HubbardLegacyContextItemSchema;
+type Data = HubbardLegacyContextProviderSchema;
+
+const defaultHubbardConfig = {
+    hubbardUValue: 1.0,
+};
+
+const jsonSchemaId = "context-providers-directory/hubbard-legacy-context-provider";
+
+export default class HubbardContextManagerLegacy extends HubbardContextProvider<Schema> {
+    readonly name = "hubbard_legacy" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(
+        unitContext: UnitContext,
+        externalContext: HubbardExternalContext,
+    ) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "hubbard_legacy");
+
+        return new HubbardContextManagerLegacy(contextItem, externalContext);
+    }
+
+    readonly jsonSchema: JSONSchema7;
+
+    readonly uiSchemaStyled = {
+        "ui:options": {
+            addable: true,
+            orderable: false,
+            removable: true,
+        },
+        items: {
+            atomicSpeciesIndex: { "ui:readonly": true },
+        },
+    } as const;
+
+    constructor(contextItem: Partial<Schema>, externalContext: HubbardExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            "items.properties.atomicSpecies": {
+                enum: this.uniqueElementsWithLabels,
+            },
+            "items.properties.hubbardUValue": {
+                default: defaultHubbardConfig.hubbardUValue,
+            },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        return [
+            {
+                ...defaultHubbardConfig,
+                atomicSpecies: this.firstElement,
+                atomicSpeciesIndex: this.uniqueElementsWithLabels?.length > 0 ? 1 : undefined,
+            },
+        ];
+    }
+
+    setData(data: Data) {
+        const hubbardUValues = data.map((row) => {
+            const atomicSpeciesIndex =
+                this.uniqueElementsWithLabels?.length > 0
+                    ? this.uniqueElementsWithLabels.indexOf(row.atomicSpecies || "") + 1
+                    : undefined;
+
+            return {
+                ...row,
+                atomicSpeciesIndex,
+            };
+        }) as Data;
+
+        super.setData(hubbardUValues);
+    }
+}

package/src/js/context/providers/Hubbard/HubbardContextProvider.ts

@@ -0,0 +1,85 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type {
+    HubbardJContextItemSchema,
+    HubbardLegacyContextItemSchema,
+    HubbardUContextItemSchema,
+    HubbardVContextItemSchema,
+} from "@mat3ra/esse/dist/js/types";
+
+import materialContextMixin, {
+    type MaterialContextMixin,
+    type MaterialExternalContext,
+} from "../../mixins/MaterialContextMixin";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "../base/JSONSchemaDataProvider";
+
+type Schema =
+    | HubbardJContextItemSchema
+    | HubbardUContextItemSchema
+    | HubbardVContextItemSchema
+    | HubbardLegacyContextItemSchema;
+
+export type HubbardExternalContext = JinjaExternalContext & MaterialExternalContext;
+
+type Base = typeof JSONSchemaDataProvider<Schema, HubbardExternalContext> &
+    Constructor<MaterialContextMixin>;
+
+abstract class HubbardContextProvider<
+    S extends Schema,
+    EC extends HubbardExternalContext = HubbardExternalContext,
+> extends (JSONSchemaDataProvider as Base) {
+    abstract readonly name: S["name"];
+
+    abstract getDefaultData(): S["data"];
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    protected readonly uniqueElementsWithLabels: string[];
+
+    protected readonly firstElement: string;
+
+    protected readonly secondSpecies: string;
+
+    protected readonly orbitalList = [
+        "2p",
+        "3s",
+        "3p",
+        "3d",
+        "4s",
+        "4p",
+        "4d",
+        "4f",
+        "5s",
+        "5p",
+        "5d",
+        "5f",
+        "6s",
+        "6p",
+        "6d",
+        "7s",
+        "7p",
+        "7d",
+    ];
+
+    constructor(contextItem: Partial<S>, externalContext: EC) {
+        super(contextItem, externalContext);
+        this.initMaterialContextMixin(externalContext);
+
+        this.uniqueElementsWithLabels = [
+            ...new Set(this.material.Basis?.elementsWithLabelsArray || []),
+        ];
+
+        this.firstElement =
+            this.uniqueElementsWithLabels?.length > 0 ? this.uniqueElementsWithLabels[0] : "";
+
+        this.secondSpecies =
+            this.uniqueElementsWithLabels?.length > 1
+                ? this.uniqueElementsWithLabels[1]
+                : this.firstElement;
+    }
+}
+
+materialContextMixin(HubbardContextProvider.prototype);
+
+export default HubbardContextProvider;

package/src/js/context/providers/Hubbard/HubbardJContextManager.ts

@@ -0,0 +1,82 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    HubbardJContextItemSchema,
+    HubbardJContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "../base/ContextProvider";
+import HubbardContextProvider, { type HubbardExternalContext } from "./HubbardContextProvider";
+
+type Schema = HubbardJContextItemSchema;
+type Data = HubbardJContextProviderSchema;
+
+const defaultHubbardConfig = {
+    paramType: "J" as const,
+    atomicSpecies: "",
+    atomicOrbital: "2p",
+    value: 1.0,
+};
+
+const jsonSchemaId = "context-providers-directory/hubbard-j-context-provider";
+
+export default class HubbardJContextManager extends HubbardContextProvider<Schema> {
+    readonly name = "hubbard_j" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(
+        unitContext: UnitContext,
+        externalContext: HubbardExternalContext,
+    ) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "hubbard_j");
+
+        return new HubbardJContextManager(contextItem, externalContext);
+    }
+
+    readonly uiSchemaStyled = {
+        "ui:options": {
+            addable: true,
+            orderable: true,
+            removable: true,
+        },
+    } as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: HubbardExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            "items.properties.paramType": {
+                default: defaultHubbardConfig.paramType,
+            },
+            "items.properties.atomicSpecies": {
+                enum: this.uniqueElementsWithLabels,
+                default: this.firstElement,
+            },
+            "items.properties.atomicOrbital": {
+                enum: this.orbitalList,
+                default: defaultHubbardConfig.atomicOrbital,
+            },
+            "items.properties.value": {
+                default: defaultHubbardConfig.value,
+            },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        return [
+            {
+                ...defaultHubbardConfig,
+                atomicSpecies: this.firstElement,
+            },
+        ];
+    }
+}

package/src/js/context/providers/Hubbard/HubbardUContextManager.ts

@@ -0,0 +1,78 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    HubbardUContextItemSchema,
+    HubbardUContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "../base/ContextProvider";
+import HubbardContextProvider, { type HubbardExternalContext } from "./HubbardContextProvider";
+
+type Schema = HubbardUContextItemSchema;
+type Data = HubbardUContextProviderSchema;
+
+const defaultHubbardConfig = {
+    atomicSpecies: "",
+    atomicOrbital: "2p",
+    hubbardUValue: 1.0,
+};
+
+const jsonSchemaId = "context-providers-directory/hubbard-u-context-provider";
+
+export default class HubbardUContextManager extends HubbardContextProvider<Schema> {
+    readonly name = "hubbard_u" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(
+        unitContext: UnitContext,
+        externalContext: HubbardExternalContext,
+    ) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "hubbard_u");
+
+        return new HubbardUContextManager(contextItem, externalContext);
+    }
+
+    readonly uiSchemaStyled = {
+        "ui:options": {
+            addable: true,
+            orderable: false,
+            removable: true,
+        },
+    } as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: HubbardExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            "items.properties.atomicSpecies": {
+                enum: this.uniqueElementsWithLabels,
+                default: this.firstElement,
+            },
+            "items.properties.atomicOrbital": {
+                enum: this.orbitalList,
+                default: defaultHubbardConfig.atomicOrbital,
+            },
+            "items.properties.hubbardUValue": {
+                default: defaultHubbardConfig.hubbardUValue,
+            },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        return [
+            {
+                ...defaultHubbardConfig,
+                atomicSpecies: this.firstElement,
+            },
+        ];
+    }
+}

package/src/js/context/providers/Hubbard/HubbardVContextManager.ts

@@ -0,0 +1,100 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type {
+    HubbardVContextItemSchema,
+    HubbardVContextProviderSchema,
+} from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { UnitContext } from "../base/ContextProvider";
+import HubbardContextProvider, { type HubbardExternalContext } from "./HubbardContextProvider";
+
+type Schema = HubbardVContextItemSchema;
+type Data = HubbardVContextProviderSchema;
+
+const defaultHubbardConfig = {
+    atomicSpecies: "",
+    atomicOrbital: "2p",
+    atomicSpecies2: "",
+    atomicOrbital2: "2p",
+    siteIndex: 1,
+    siteIndex2: 1,
+    hubbardVValue: 1.0,
+};
+
+const jsonSchemaId = "context-providers-directory/hubbard-v-context-provider";
+
+export default class HubbardVContextManager extends HubbardContextProvider<Schema> {
+    readonly name = "hubbard_v" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(
+        unitContext: UnitContext,
+        externalContext: HubbardExternalContext,
+    ) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "hubbard_v");
+
+        return new HubbardVContextManager(contextItem, externalContext);
+    }
+
+    readonly uiSchemaStyled = {
+        "ui:options": {
+            addable: true,
+            orderable: true,
+            removable: true,
+        },
+    } as const;
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: HubbardExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            "items.properties.atomicSpecies": {
+                enum: this.uniqueElementsWithLabels,
+                default: this.firstElement,
+            },
+            "items.properties.siteIndex": {
+                default: defaultHubbardConfig.siteIndex,
+            },
+            "items.properties.atomicOrbital": {
+                enum: this.orbitalList,
+                default: defaultHubbardConfig.atomicOrbital,
+            },
+            "items.properties.atomicSpecies2": {
+                enum: this.uniqueElementsWithLabels,
+                default: this.secondSpecies,
+            },
+            "items.properties.siteIndex2": {
+                default:
+                    this.uniqueElementsWithLabels?.length > 1 ? 2 : defaultHubbardConfig.siteIndex2,
+            },
+            "items.properties.atomicOrbital2": {
+                enum: this.orbitalList,
+                default: defaultHubbardConfig.atomicOrbital,
+            },
+            "items.properties.hubbardVValue": {
+                default: defaultHubbardConfig.hubbardVValue,
+            },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    getDefaultData(): Data {
+        return [
+            {
+                ...defaultHubbardConfig,
+                atomicSpecies: this.firstElement,
+                atomicSpecies2: this.secondSpecies,
+                siteIndex2:
+                    this.uniqueElementsWithLabels?.length > 1 ? 2 : defaultHubbardConfig.siteIndex2,
+            },
+        ];
+    }
+}

package/src/js/context/providers/IonDynamicsDataManager.ts

@@ -0,0 +1,64 @@
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { DynamicsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+
+import type { BaseExternalContext, UnitContext } from "./base/ContextProvider";
+import JSONSchemaFormDataProvider from "./base/JSONSchemaFormDataProvider";
+
+type Schema = DynamicsContextItemSchema;
+
+const jsonSchemaId = "context-providers-directory/ion-dynamics-context-provider";
+
+const defaultData = {
+    numberOfSteps: 100,
+    timeStep: 5.0,
+    electronMass: 100.0,
+    temperature: 300.0,
+};
+
+export default class IonDynamicsDataManager extends JSONSchemaFormDataProvider<Schema> {
+    readonly name = "dynamics" as const;
+
+    readonly domain = "important" as const;
+
+    readonly entityName = "unit" as const;
+
+    static createFromUnitContext(unitContext: UnitContext, externalContext: BaseExternalContext) {
+        const contextItem = this.findContextItem<Schema>(unitContext, "dynamics");
+
+        return new IonDynamicsDataManager(contextItem, externalContext);
+    }
+
+    readonly uiSchema = {
+        numberOfSteps: {},
+        timeStep: {},
+        electronMass: {},
+        temperature: {},
+    } as const;
+
+    readonly extraData = {};
+
+    readonly jsonSchema: JSONSchema7;
+
+    constructor(contextItem: Partial<Schema>, externalContext: BaseExternalContext) {
+        super(contextItem, externalContext);
+
+        const jsonSchema = JSONSchemasInterface.getPatchedSchemaById(jsonSchemaId, {
+            numberOfSteps: { default: defaultData.numberOfSteps },
+            timeStep: { default: defaultData.timeStep },
+            electronMass: { default: defaultData.electronMass },
+            temperature: { default: defaultData.temperature },
+        });
+
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+
+        this.jsonSchema = jsonSchema;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}