@mat3ra/prode 2025.11.25-0

package/dist/js/properties/non-scalar/BandStructureProperty.d.ts

@@ -0,0 +1,186 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { BandStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { KPointPath } from "@mat3ra/made/dist/js/lattice/reciprocal/lattice_reciprocal";
+import type { Options, PlotLines } from "highcharts";
+import { type FormatterScope, HighChartsConfig } from "../../charts/highcharts";
+import { type BandStructurePropertySchemaMixin } from "../../generated/BandStructurePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { type XDataArray, type XDataArrayNested, type YDataSeries } from "../include/mixins/2d_plot";
+export declare const _POINT_COORDINATES_PRECISION_ = 4;
+export declare class BandStructureConfig extends HighChartsConfig {
+    readonly yDataSeries: YDataSeries;
+    readonly spin?: number[];
+    readonly xDataArray: XDataArrayNested;
+    readonly pointsDistanceArray: number[];
+    readonly fermiEnergy: number | null;
+    readonly pointsPath: KPointPath | undefined;
+    constructor(property: {
+        spin?: number[];
+        subtitle: string;
+        yAxisTitle: string;
+        yDataSeries: [number, ...number[]][];
+        xDataArray: (number | number[])[];
+    }, chartConfig?: {
+        fermiEnergy?: number | null;
+        pointsPath?: KPointPath;
+    });
+    cleanXDataArray(rawData?: XDataArray): XDataArrayNested;
+    calculatePointsDistance(listOfPoints?: XDataArrayNested): number[];
+    findSymmetryPointIndex(xDataArray: XDataArrayNested, point: number[]): number;
+    plotXLines(): PlotLines[];
+    plotXLineAtPoint({ point, distance }: {
+        point: string;
+        distance: number | null;
+    }): PlotLines;
+    get series(): {
+        data: [number, number][];
+        name: string;
+        color: string;
+        animation: boolean;
+    }[];
+    xAxis(): {
+        minorGridLineColor: string;
+        minorGridLineWidth: number;
+        minorTickLength: number;
+        title: {
+            text: string;
+            offset: number;
+        };
+        type: string;
+        tickPositioner: () => never[];
+        plotLines: PlotLines[] | undefined;
+        labels: {
+            enabled: boolean;
+        };
+    };
+    tooltipFormatter(xDataArray: XDataArrayNested, yAxisName?: string): (this: FormatterScope) => string;
+    yAxis(): {
+        gridZIndex: number;
+        plotLines: PlotLines[];
+        allowDecimals?: boolean;
+        alternateGridColor?: string;
+        breaks?: import("highcharts").AxisBreak[];
+        categories?: any[] | null;
+        ceiling?: number;
+        className?: string;
+        crosshair?: import("highcharts").CrosshairObject | boolean;
+        dateTimeLabelFormats?: import("highcharts").DateTimeFormats;
+        description?: string;
+        endOnTick?: boolean;
+        events?: {
+            afterBreaks?(event: Event): void;
+            afterSetExtremes?(event: import("highcharts").AxisEvent): void;
+            pointBreak?(event: Event): void;
+            setExtremes?(event: import("highcharts").AxisEvent): void;
+        };
+        floor?: number | null;
+        gridLineColor?: string;
+        gridLineDashStyle?: string;
+        gridLineWidth?: number;
+        gridLineInterpolation?: string;
+        id?: string;
+        labels?: import("highcharts").AxisLabels;
+        lineColor?: string | import("highcharts").Gradient;
+        lineWidth?: number;
+        linkedTo?: number;
+        max?: number | null;
+        maxPadding?: number;
+        maxZoom?: number;
+        min?: number | null;
+        minPadding?: number;
+        minRange?: number;
+        minTickInterval?: number;
+        minorGridLineColor?: string;
+        minorGridLineDashStyle?: string;
+        minorGridLineWidth?: number;
+        minorTickColor?: string;
+        minorTickInterval?: number | string | null;
+        minorTickLength?: number;
+        minorTickPosition?: string;
+        minorTickWidth?: number;
+        offset?: number;
+        opposite?: boolean;
+        plotBands?: import("highcharts").PlotBands[];
+        reversed?: boolean;
+        reversedStacks?: boolean;
+        showEmpty?: boolean;
+        showFirstLabel?: boolean;
+        showLastLabel?: boolean;
+        softMax?: number;
+        softMin?: number;
+        stackLabels?: {
+            align?: string;
+            enabled?: boolean;
+            format?: string;
+            formatter?: Function;
+            rotation?: number;
+            style?: import("highcharts").CSSObject;
+            textAlign?: string;
+            useHTML?: boolean;
+            verticalAlign?: string;
+            x?: number;
+            y?: number;
+        };
+        startOfWeek?: number;
+        startOnTick?: boolean;
+        stops?: Array<Array<number | string>>;
+        tickAmount?: number;
+        tickColor?: string;
+        tickInterval?: number | null;
+        tickLength?: number;
+        tickPixelInterval?: number | null;
+        tickPosition?: string;
+        tickPositioner?(min: number, max: number): void;
+        tickPositions?: number[];
+        tickWidth?: number;
+        tickmarkPlacement?: string | null;
+        title?: import("highcharts").AxisTitle | null;
+        type?: string;
+        units?: Array<[string, number[]]>;
+        visible?: boolean;
+    };
+    get overrideConfig(): {
+        chart: {
+            animation: boolean;
+            type: string;
+            zoomType: string;
+        };
+        plotOptions: {
+            spline: {
+                lineWidth: number;
+                states: {
+                    hover: {
+                        lineWidth: number;
+                    };
+                };
+                marker: {
+                    enabled: boolean;
+                };
+            };
+        };
+        tooltip: {
+            valueSuffix: string;
+            formatter: (this: FormatterScope) => string;
+        };
+        legend: {
+            enabled: boolean;
+        };
+    };
+}
+type Schema = BandStructurePropertySchema;
+type Base = typeof Property<Schema> & Constructor<BandStructurePropertySchemaMixin>;
+declare const BandStructureProperty_base: Base;
+export default class BandStructureProperty extends BandStructureProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.band_structure;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name"> & {
+        fermiEnergy?: number | null;
+        pointsPath?: KPointPath;
+    });
+}
+export {};

package/dist/js/properties/non-scalar/BandStructureProperty.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BandStructureConfig = exports._POINT_COORDINATES_PRECISION_ = void 0;
+/* eslint-disable class-methods-use-this */
+// eslint-disable-next-line max-classes-per-file
+const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const zip_1 = __importDefault(require("lodash/zip"));
+const highcharts_1 = require("../../charts/highcharts");
+const BandStructurePropertySchemaMixin_1 = require("../../generated/BandStructurePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+exports._POINT_COORDINATES_PRECISION_ = 4; // number of decimals to keep for point coordinates
+class BandStructureConfig extends highcharts_1.HighChartsConfig {
+    constructor(property, chartConfig) {
+        var _a;
+        super({
+            subtitle: property.subtitle,
+            yAxisTitle: property.yAxisTitle,
+            yAxisType: "linear",
+        });
+        this.yDataSeries = property.yDataSeries;
+        this.spin = property.spin;
+        this.xDataArray = this.cleanXDataArray(property.xDataArray);
+        this.pointsPath = chartConfig === null || chartConfig === void 0 ? void 0 : chartConfig.pointsPath;
+        this.pointsDistanceArray = this.calculatePointsDistance(this.xDataArray);
+        this.fermiEnergy = (_a = chartConfig === null || chartConfig === void 0 ? void 0 : chartConfig.fermiEnergy) !== null && _a !== void 0 ? _a : null;
+        this.plotXLineAtPoint = this.plotXLineAtPoint.bind(this);
+        this.plotXLines = this.plotXLines.bind(this);
+    }
+    // round each value in array to certain precision
+    cleanXDataArray(rawData = []) {
+        return rawData.map((p) => {
+            if (!p || !Array.isArray(p))
+                return [];
+            return p.map((c) => {
+                return math_1.math.roundValueToNDecimals(c, exports._POINT_COORDINATES_PRECISION_);
+            });
+        });
+    }
+    // returns the array of distances calculated from an array of points
+    calculatePointsDistance(listOfPoints = []) {
+        let pointsDistanceSum = 0;
+        return listOfPoints.map((el, idx, arr) => {
+            if (idx !== 0) {
+                const distance = math_1.math.vDist(el, arr[idx - 1]);
+                pointsDistanceSum += Number(distance);
+            }
+            return pointsDistanceSum;
+        });
+    }
+    // find index of a point inside an array of points
+    findSymmetryPointIndex(xDataArray, point) {
+        return xDataArray.findIndex((p) => math_1.math.vDist(p, point) === 0);
+    }
+    // create config for vertical lines at high symmetry points
+    plotXLines() {
+        const copiedXDataArray = (0, utils_1.deepClone)(this.xDataArray);
+        return this.pointsPath
+            ? this.pointsPath
+                .map((p) => {
+                const idx = this.findSymmetryPointIndex(copiedXDataArray, p.coordinates);
+                // "reset" element at index if found to avoid duplicate matches
+                if (idx > -1)
+                    copiedXDataArray[idx] = [-1, -1, -1];
+                return {
+                    point: p.point,
+                    distance: idx > -1 ? this.pointsDistanceArray[idx] : null,
+                };
+            })
+                .map(this.plotXLineAtPoint)
+            : [];
+    }
+    plotXLineAtPoint({ point, distance }) {
+        return {
+            label: {
+                verticalAlign: "bottom",
+                rotation: 0,
+                align: "center",
+                y: 20,
+                x: 0,
+                text: point,
+            },
+            value: distance !== null && distance !== void 0 ? distance : undefined,
+            width: 1,
+            dashStyle: "solid",
+            color: "#E0E0E0",
+        };
+    }
+    get series() {
+        const { fermiEnergy } = this;
+        const series_ = this.yDataSeries.map((item, index) => {
+            var _a;
+            // shift values by fermiEnergy
+            const itemUpdated = item.map((x) => {
+                return fermiEnergy ? Number(x) - fermiEnergy : Number(x);
+            });
+            const spin = (_a = this.spin) === null || _a === void 0 ? void 0 : _a[index];
+            const spinText = spin && spin > 0 ? "up" : "down";
+            return {
+                data: (0, zip_1.default)(this.pointsDistanceArray, itemUpdated),
+                name: spinText,
+                color: spinText === "up" ? "#3677d9" : "#ff7f0e",
+                animation: false,
+            };
+        });
+        return series_;
+    }
+    xAxis() {
+        return {
+            minorGridLineColor: "#E0E0E0",
+            minorGridLineWidth: 2,
+            minorTickLength: 0,
+            title: {
+                text: "Path in reciprocal space",
+                offset: 40,
+            },
+            type: "linear",
+            tickPositioner: () => [], // disable ticks
+            plotLines: this.pointsPath ? this.plotXLines() : undefined,
+            labels: {
+                enabled: false,
+            },
+        };
+    }
+    tooltipFormatter(xDataArray, yAxisName = "energy") {
+        // note 'this' below refers to Highcharts tooltip scope
+        // eslint-disable-next-line func-names
+        return function () {
+            return ("<b>spin:</b> " +
+                this.series.name +
+                "<br>" +
+                "<b>point:</b> " +
+                xDataArray.map((p) => {
+                    if (!Array.isArray(p)) {
+                        console.error("xDataArray is not a nested array", xDataArray);
+                        return [];
+                    }
+                    return p.map((c) => c.toFixed(exports._POINT_COORDINATES_PRECISION_));
+                })[this.point.index] +
+                "<br>" +
+                "<b>" +
+                yAxisName +
+                ": </b>  " +
+                this.y.toFixed(exports._POINT_COORDINATES_PRECISION_));
+        };
+    }
+    yAxis() {
+        return {
+            ...super.yAxis(),
+            gridZIndex: 1,
+            plotLines: this.fermiEnergy
+                ? this.plotSingleLine({
+                    value: 0.0,
+                    width: 2, // to be shown above above grid/tickLine at zero
+                    label: {
+                        text: "E_F",
+                        style: {
+                            color: "red",
+                        },
+                        y: -5,
+                        x: -10,
+                    },
+                })
+                : [],
+        };
+    }
+    get overrideConfig() {
+        const { xDataArray } = this;
+        return {
+            chart: {
+                animation: false,
+                type: "spline",
+                zoomType: "xy",
+            },
+            plotOptions: {
+                spline: {
+                    lineWidth: 2,
+                    states: {
+                        hover: {
+                            lineWidth: 6,
+                        },
+                    },
+                    marker: {
+                        enabled: false,
+                    },
+                },
+            },
+            tooltip: {
+                valueSuffix: "",
+                formatter: this.tooltipFormatter(xDataArray),
+            },
+            legend: {
+                enabled: false,
+            },
+        };
+    }
+}
+exports.BandStructureConfig = BandStructureConfig;
+class BandStructureProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: BandStructureProperty.propertyName });
+        this.subtitle = "Electronic Bandstructure";
+        this.yAxisTitle = `Energy (${this.yAxis.units})`;
+        this.chartConfig = new BandStructureConfig(this, {
+            fermiEnergy: config.fermiEnergy,
+            pointsPath: config.pointsPath,
+        }).config;
+    }
+}
+BandStructureProperty.isRefined = true;
+BandStructureProperty.propertyName = settings_1.PropertyName.band_structure;
+BandStructureProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = BandStructureProperty;
+(0, BandStructurePropertySchemaMixin_1.bandStructurePropertySchemaMixin)(BandStructureProperty.prototype);

package/dist/js/properties/non-scalar/ChargeDensityProfileProperty.d.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ChargeDensityProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { type ChargeDensityProfilePropertySchemaMixin } from "../../generated/ChargeDensityProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+export declare class ChargeDensityProfileConfig extends TwoDimensionalHighChartConfigMixin {
+    readonly tooltipXAxisName = "z coordinate";
+    readonly tooltipYAxisName = "charge density";
+}
+type Schema = ChargeDensityProfilePropertySchema;
+type Base = typeof Property<Schema> & Constructor<ChargeDensityProfilePropertySchemaMixin>;
+declare const ChargeDensityProfileProperty_base: Base;
+declare class ChargeDensityProfileProperty extends ChargeDensityProfileProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.charge_density_profile;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export default ChargeDensityProfileProperty;

package/dist/js/properties/non-scalar/ChargeDensityProfileProperty.js

@@ -0,0 +1,34 @@
+"use strict";
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargeDensityProfileConfig = void 0;
+const ChargeDensityProfilePropertySchemaMixin_1 = require("../../generated/ChargeDensityProfilePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const _2d_plot_1 = require("../include/mixins/2d_plot");
+class ChargeDensityProfileConfig extends _2d_plot_1.TwoDimensionalHighChartConfigMixin {
+    constructor() {
+        super(...arguments);
+        this.tooltipXAxisName = "z coordinate";
+        this.tooltipYAxisName = "charge density";
+    }
+}
+exports.ChargeDensityProfileConfig = ChargeDensityProfileConfig;
+class ChargeDensityProfileProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: ChargeDensityProfileProperty.propertyName });
+        this.subtitle = "Charge Density Profile";
+        this.yAxisTitle = `Charge Density (${this.yAxis.units})`;
+        this.xAxisTitle = "Z Coordinate";
+        this.chartConfig = new ChargeDensityProfileConfig(this).config;
+    }
+}
+ChargeDensityProfileProperty.isRefined = true;
+ChargeDensityProfileProperty.propertyName = settings_1.PropertyName.charge_density_profile;
+ChargeDensityProfileProperty.propertyType = settings_1.PropertyType.non_scalar;
+(0, ChargeDensityProfilePropertySchemaMixin_1.chargeDensityProfilePropertySchemaMixin)(ChargeDensityProfileProperty.prototype);
+exports.default = ChargeDensityProfileProperty;

package/dist/js/properties/non-scalar/DensityOfStatesProperty.d.ts

@@ -0,0 +1,145 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types.js";
+import type { DensityOfStatesPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { IndividualSeriesOptions, Options } from "highcharts";
+import { type FormatterScope, HighChartsConfig } from "../../charts/highcharts";
+import { type DensityOfStatesPropertySchemaMixin } from "../../generated/DensityOfStatesPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { type YDataSeries } from "../include/mixins/2d_plot";
+type Schema = DensityOfStatesPropertySchema;
+export declare class DensityOfStatesConfig extends HighChartsConfig {
+    readonly yDataSeries: YDataSeries;
+    readonly fermiEnergy: number | null;
+    readonly xDataArray: Schema["xDataArray"];
+    readonly legends: Schema["legend"];
+    get overrideConfig(): {
+        colors: string[];
+        credits: {
+            enabled: boolean;
+        };
+        chart: {
+            type: string;
+            zoomType: string;
+            animation: boolean;
+        };
+        legend: {
+            layout: string;
+            align: string;
+            verticalAlign: string;
+            borderWidth: number;
+        };
+    };
+    constructor(property: {
+        subtitle: string;
+        yAxisTitle: string;
+        xAxisTitle: string;
+        yDataSeries: YDataSeries;
+        legend?: Schema["legend"];
+        xDataArray: Schema["xDataArray"];
+    }, chartConfig?: {
+        fermiEnergy?: number | null;
+    });
+    cleanXDataArray(rawData: Schema["xDataArray"]): number[];
+    get series(): IndividualSeriesOptions[];
+    tooltipFormatter(): (this: FormatterScope) => string;
+    xAxis(): {
+        plotLines: import("highcharts").PlotLines[];
+        allowDecimals?: boolean;
+        alternateGridColor?: string;
+        breaks?: import("highcharts").AxisBreak[];
+        categories?: any[] | null;
+        ceiling?: number;
+        className?: string;
+        crosshair?: import("highcharts").CrosshairObject | boolean;
+        dateTimeLabelFormats?: import("highcharts").DateTimeFormats;
+        description?: string;
+        endOnTick?: boolean;
+        events?: {
+            afterBreaks?(event: Event): void;
+            afterSetExtremes?(event: import("highcharts").AxisEvent): void;
+            pointBreak?(event: Event): void;
+            setExtremes?(event: import("highcharts").AxisEvent): void;
+        };
+        floor?: number | null;
+        gridLineColor?: string;
+        gridLineDashStyle?: string;
+        gridLineWidth?: number;
+        gridLineInterpolation?: string;
+        gridZIndex?: number;
+        id?: string;
+        labels?: import("highcharts").AxisLabels;
+        lineColor?: string | import("highcharts").Gradient;
+        lineWidth?: number;
+        linkedTo?: number;
+        max?: number | null;
+        maxPadding?: number;
+        maxZoom?: number;
+        min?: number | null;
+        minPadding?: number;
+        minRange?: number;
+        minTickInterval?: number;
+        minorGridLineColor?: string;
+        minorGridLineDashStyle?: string;
+        minorGridLineWidth?: number;
+        minorTickColor?: string;
+        minorTickInterval?: number | string | null;
+        minorTickLength?: number;
+        minorTickPosition?: string;
+        minorTickWidth?: number;
+        offset?: number;
+        opposite?: boolean;
+        plotBands?: import("highcharts").PlotBands[];
+        reversed?: boolean;
+        reversedStacks?: boolean;
+        showEmpty?: boolean;
+        showFirstLabel?: boolean;
+        showLastLabel?: boolean;
+        softMax?: number;
+        softMin?: number;
+        stackLabels?: {
+            align?: string;
+            enabled?: boolean;
+            format?: string;
+            formatter?: Function;
+            rotation?: number;
+            style?: import("highcharts").CSSObject;
+            textAlign?: string;
+            useHTML?: boolean;
+            verticalAlign?: string;
+            x?: number;
+            y?: number;
+        };
+        startOfWeek?: number;
+        startOnTick?: boolean;
+        stops?: Array<Array<number | string>>;
+        tickAmount?: number;
+        tickColor?: string;
+        tickInterval?: number | null;
+        tickLength?: number;
+        tickPixelInterval?: number | null;
+        tickPosition?: string;
+        tickPositioner?(min: number, max: number): void;
+        tickPositions?: number[];
+        tickWidth?: number;
+        tickmarkPlacement?: string | null;
+        title?: import("highcharts").AxisTitle | null;
+        type?: string;
+        units?: Array<[string, number[]]>;
+        visible?: boolean;
+    };
+}
+type Base = typeof Property<Schema> & Constructor<DensityOfStatesPropertySchemaMixin>;
+declare const DensityOfStatesProperty_base: Base;
+export default class DensityOfStatesProperty extends DensityOfStatesProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.density_of_states;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name"> & {
+        fermiEnergy?: number | null;
+    });
+}
+export {};