@mat3ra/prode 2025.11.25-0

package/src/js/properties/non-scalar/FinalStructureProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FinalStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type FinalStructurePropertySchemaMixin,
+    finalStructurePropertySchemaMixin,
+} from "../../generated/FinalStructurePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = FinalStructurePropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<FinalStructurePropertySchemaMixin>;
+
+export default class FinalStructureProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.final_structure;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: FinalStructureProperty.propertyName });
+    }
+}
+
+finalStructurePropertySchemaMixin(FinalStructureProperty.prototype);

package/src/js/properties/non-scalar/HubbardUProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { HubbardUParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type HubbardUPropertySchemaMixin,
+    hubbardUPropertySchemaMixin,
+} from "../../generated/HubbardUPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = HubbardUParametersPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<HubbardUPropertySchemaMixin>;
+
+export default class HubbardUProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.hubbard_u;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: HubbardUProperty.propertyName });
+    }
+}
+
+hubbardUPropertySchemaMixin(HubbardUProperty.prototype);

package/src/js/properties/non-scalar/HubbardVNNProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { HubbardVNNParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type HubbardVNNPropertySchemaMixin,
+    hubbardVNNPropertySchemaMixin,
+} from "../../generated/HubbardVNNPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = HubbardVNNParametersPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<HubbardVNNPropertySchemaMixin>;
+
+export default class HubbardVNNProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.hubbard_v_nn;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: HubbardVNNProperty.propertyName });
+    }
+}
+
+hubbardVNNPropertySchemaMixin(HubbardVNNProperty.prototype);

package/src/js/properties/non-scalar/HubbardVProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { HubbardVParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type HubbardVPropertySchemaMixin,
+    hubbardVPropertySchemaMixin,
+} from "../../generated/HubbardVPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = HubbardVParametersPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<HubbardVPropertySchemaMixin>;
+
+export default class HubbardVProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.hubbard_v;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: HubbardVProperty.propertyName });
+    }
+}
+
+hubbardVPropertySchemaMixin(HubbardVProperty.prototype);

package/src/js/properties/non-scalar/IsRelaxedProperty.ts

@@ -0,0 +1,27 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { IsRelaxedPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type IsRelaxedPropertySchemaMixin,
+    isRelaxedPropertySchemaMixin,
+} from "../../generated/IsRelaxedPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = IsRelaxedPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<IsRelaxedPropertySchemaMixin>;
+
+export default class IsRelaxedProperty extends (Property as Base) implements Schema {
+    static readonly isRefined = true;
+
+    static readonly propertyName = PropertyName.is_relaxed;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: IsRelaxedProperty.propertyName });
+    }
+}
+
+isRelaxedPropertySchemaMixin(IsRelaxedProperty.prototype);

package/src/js/properties/non-scalar/JupyterNotebookEndpointProperty.ts

@@ -0,0 +1,26 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { JupyterNotebookEndpointPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    JupyterNotebookEndpointPropertySchemaMixin,
+    jupyterNotebookEndpointPropertySchemaMixin,
+} from "../../generated/JupyterNotebookEndpointPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = JupyterNotebookEndpointPropertySchema;
+type Base = typeof Property<Schema> & Constructor<JupyterNotebookEndpointPropertySchemaMixin>;
+
+class JupyterNotebookEndpointProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.jupyter_notebook_endpoint;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: JupyterNotebookEndpointProperty.propertyName });
+    }
+}
+
+jupyterNotebookEndpointPropertySchemaMixin(JupyterNotebookEndpointProperty.prototype);
+
+export default JupyterNotebookEndpointProperty;

package/src/js/properties/non-scalar/PhononDOSProperty.ts

@@ -0,0 +1,57 @@
+/* eslint-disable class-methods-use-this */
+// eslint-disable-next-line max-classes-per-file
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PhononDensityOfStatesPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+
+import { type FormatterScope } from "../../charts/highcharts";
+import {
+    PhononDOSPropertySchemaMixin,
+    phononDOSPropertySchemaMixin,
+} from "../../generated/PhononDOSPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { DensityOfStatesConfig } from "./DensityOfStatesProperty";
+
+type Schema = PhononDensityOfStatesPropertySchema;
+
+class PhononDOSConfig extends DensityOfStatesConfig {
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function (this: FormatterScope) {
+            return (
+                "<b>state:</b> " +
+                this.series.name +
+                "<br>" +
+                "<b>energy:</b> " +
+                this.key.toFixed(4) +
+                "<br>" +
+                "<b>value: </b>  " +
+                this.y.toFixed(4)
+            );
+        };
+    }
+}
+
+type Base = typeof Property<Schema> & Constructor<PhononDOSPropertySchemaMixin>;
+
+export default class PhononDOSProperty extends (Property as Base) implements Schema {
+    readonly chartConfig: Options;
+
+    readonly subtitle: string = "Phonon Density Of States";
+
+    readonly yAxisTitle: string = `Density Of States (${this.yAxis.units})`;
+
+    readonly xAxisTitle: string = `Frequency (${this.xAxis.units})`;
+
+    static readonly propertyName = PropertyName.phonon_dos;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: PhononDOSProperty.propertyName });
+        this.chartConfig = new PhononDOSConfig(this).config;
+    }
+}
+
+phononDOSPropertySchemaMixin(PhononDOSProperty.prototype);

package/src/js/properties/non-scalar/PhononDispersionsProperty.ts

@@ -0,0 +1,46 @@
+/* eslint-disable class-methods-use-this */
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PhononBandStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { KPointPath } from "@mat3ra/made/dist/js/lattice/reciprocal/lattice_reciprocal";
+import type { Options } from "highcharts";
+
+import {
+    PhononDispersionsPropertySchemaMixin,
+    phononDispersionsPropertySchemaMixin,
+} from "../../generated/PhononDispersionsPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { type XDataArrayNested } from "../include/mixins/2d_plot";
+import { BandStructureConfig } from "./BandStructureProperty";
+
+class PhononDispersionsConfig extends BandStructureConfig {
+    tooltipFormatter(xDataArray: XDataArrayNested, yAxisName = "frequency") {
+        return super.tooltipFormatter(xDataArray, yAxisName);
+    }
+}
+
+type Schema = PhononBandStructurePropertySchema;
+type Base = typeof Property<Schema> & Constructor<PhononDispersionsPropertySchemaMixin>;
+
+class PhononDispersionsProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.phonon_dispersions;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    readonly subtitle = "Phonon Dispersions";
+
+    readonly yAxisTitle = `Frequency (${this.yAxis.units})`;
+
+    readonly chartConfig: Options;
+
+    constructor(config: Omit<Schema, "name"> & { pointsPath?: KPointPath }) {
+        super({ ...config, name: PhononDispersionsProperty.propertyName });
+        this.chartConfig = new PhononDispersionsConfig(this, {
+            pointsPath: config.pointsPath,
+        }).config;
+    }
+}
+
+phononDispersionsPropertySchemaMixin(PhononDispersionsProperty.prototype);
+
+export default PhononDispersionsProperty;

package/src/js/properties/non-scalar/PotentialProfileProperty.ts

@@ -0,0 +1,76 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PotentialProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import zip from "lodash/zip";
+
+import {
+    PotentialProfilePropertySchemaMixin,
+    potentialProfilePropertySchemaMixin,
+} from "../../generated/PotentialProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+
+const NAMES = {
+    0: "averageVHartree",
+    1: "averageVLocal",
+    2: "averageVHartreePlusLocal",
+};
+
+type Schema = PotentialProfilePropertySchema;
+
+export class PotentialProfileConfig extends TwoDimensionalHighChartConfigMixin {
+    readonly tooltipXAxisName: string = "z coordinate";
+
+    readonly tooltipYAxisName: string = "energy";
+
+    get series() {
+        return this.yDataSeries.map((item, index) => {
+            return {
+                animation: false,
+                name: NAMES[index as keyof typeof NAMES],
+                data: zip(this.xDataArray, item) as [number, number][],
+            };
+        });
+    }
+
+    get overrideConfig() {
+        return {
+            ...super.overrideConfig,
+            legend: {
+                layout: "horizontal",
+                align: "center",
+                verticalAlign: "bottom",
+                borderWidth: 0,
+            },
+        };
+    }
+}
+
+type Base = typeof Property<Schema> & Constructor<PotentialProfilePropertySchemaMixin>;
+
+class PotentialProfileProperty extends (Property as Base) implements Schema {
+    readonly subtitle: string = "Potential Profile";
+
+    readonly yAxisTitle: string = `Energy (${this.yAxis.units})`;
+
+    readonly xAxisTitle: string = "Z Coordinate";
+
+    readonly chartConfig: Options = new PotentialProfileConfig(this).config;
+
+    static readonly isRefined = true;
+
+    static readonly propertyName = PropertyName.potential_profile;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: PotentialProfileProperty.propertyName });
+    }
+}
+
+potentialProfilePropertySchemaMixin(PotentialProfileProperty.prototype);
+
+export default PotentialProfileProperty;

package/src/js/properties/non-scalar/ReactionEnergyProfileProperty.ts

@@ -0,0 +1,48 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ReactionEnergyProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+
+import {
+    ReactionEnergyProfilePropertySchemaMixin,
+    reactionEnergyProfilePropertySchemaMixin,
+} from "../../generated/ReactionEnergyProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+
+type Schema = ReactionEnergyProfilePropertySchema;
+
+export class ReactionEnergyProfileConfig extends TwoDimensionalHighChartConfigMixin {
+    readonly tooltipXAxisName: string = "reaction coordinate";
+
+    readonly tooltipYAxisName: string = "energy";
+}
+
+type Base = typeof Property<Schema> & Constructor<ReactionEnergyProfilePropertySchemaMixin>;
+
+class ReactionEnergyProfileProperty extends (Property as Base) implements Schema {
+    readonly subtitle: string = "Reaction Energy Profile";
+
+    readonly yAxisTitle: string = `Energy (${this.yAxis.units})`;
+
+    readonly xAxisTitle: string = "Reaction Coordinate";
+
+    readonly chartConfig: Options = new ReactionEnergyProfileConfig(this).config;
+
+    static readonly isRefined = true;
+
+    static readonly propertyName = PropertyName.reaction_energy_profile;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: ReactionEnergyProfileProperty.propertyName });
+    }
+}
+
+reactionEnergyProfilePropertySchemaMixin(ReactionEnergyProfileProperty.prototype);
+
+export default ReactionEnergyProfileProperty;

package/src/js/properties/non-scalar/WorkflowProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { WorkflowPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    WorkflowPropertySchemaMixin,
+    workflowPropertySchemaMixin,
+} from "../../generated/WorkflowPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = WorkflowPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<WorkflowPropertySchemaMixin>;
+
+export default class WorkflowProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.workflow_pyml_predict;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: WorkflowProperty.propertyName });
+    }
+}
+
+workflowPropertySchemaMixin(WorkflowProperty.prototype);

package/src/js/properties/non-scalar/convergence/ConvergenceElectronicProperty.ts

@@ -0,0 +1,82 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ConvergenceElectronicPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { AxisLabelFormatterOptions, IndividualSeriesOptions, Options } from "highcharts";
+
+import { type FormatterScope, HighChartsConfig } from "../../../charts/highcharts";
+import {
+    ConvergenceElectronicPropertySchemaMixin,
+    convergenceElectronicPropertySchemaMixin,
+} from "../../../generated/ConvergenceElectronicPropertySchemaMixin";
+import Property from "../../../Property";
+import { PropertyName, PropertyType } from "../../../settings";
+
+type Schema = ConvergenceElectronicPropertySchema;
+
+class ConvergenceElectronicConfig extends HighChartsConfig {
+    constructor(monitor: ConvergenceElectronicProperty) {
+        let iteration = 1;
+
+        const series: IndividualSeriesOptions[] = monitor.data.map((values, index) => {
+            const name = parseInt(index.toString(), 10) + 1;
+            return {
+                name: `step-${name}`,
+                data: values.map((value) => {
+                    // give points unique xAxis value to show multiple series properly in highCharts
+                    const point: [number, number] = [iteration, Math.abs(value)];
+                    iteration += 1;
+                    return point;
+                }),
+            };
+        });
+
+        super({
+            subtitle: "Convergence Electronic",
+            yAxisTitle: `Convergence Electronic (${monitor.units})`,
+            xAxisTitle: "Iterations",
+            yAxisType: "logarithmic",
+            series,
+            legend: series.length > 1,
+        });
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    tooltipFormatter() {
+        // note 'this' below refers to Highcharts tooltip scope
+        // eslint-disable-next-line func-names
+        return function (this: FormatterScope) {
+            return "<b>iteration:</b> " + this.key + "<br><b>Δ E:</b> " + this.y.toExponential(1);
+        };
+    }
+
+    yAxis() {
+        return {
+            ...super.yAxis(),
+            labels: {
+                formatter(this: AxisLabelFormatterOptions) {
+                    return this.value.toExponential();
+                },
+            },
+        };
+    }
+}
+
+type Base = typeof Property<Schema> & Constructor<ConvergenceElectronicPropertySchemaMixin>;
+
+class ConvergenceElectronicProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.convergence_electronic;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    static readonly isConvergence = true;
+
+    readonly chartConfig: Options;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: ConvergenceElectronicProperty.propertyName });
+        this.chartConfig = new ConvergenceElectronicConfig(this).config;
+    }
+}
+
+convergenceElectronicPropertySchemaMixin(ConvergenceElectronicProperty.prototype);
+
+export default ConvergenceElectronicProperty;

package/src/js/properties/non-scalar/convergence/ConvergenceIonicProperty.ts

@@ -0,0 +1,62 @@
+/* eslint-disable max-classes-per-file */
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ConvergenceIonicPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+
+import { type FormatterScope, HighChartsConfig } from "../../../charts/highcharts";
+import {
+    ConvergenceIonicPropertySchemaMixin,
+    convergenceIonicPropertySchemaMixin,
+} from "../../../generated/ConvergenceIonicPropertySchemaMixin";
+import Property from "../../../Property";
+import { PropertyName, PropertyType } from "../../../settings";
+
+type Schema = ConvergenceIonicPropertySchema;
+
+class ConvergenceIonicConfig extends HighChartsConfig {
+    constructor(monitor: ConvergenceIonicProperty) {
+        super({
+            subtitle: "Ionic Energy",
+            yAxisTitle: `Ionic Energy (${monitor.units})`,
+            xAxisTitle: "Steps",
+            yAxisType: "linear",
+            series: [
+                {
+                    data: monitor.data.map((value, index) => {
+                        return [Number(index) + 1, value.energy];
+                    }),
+                },
+            ],
+        });
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function (this: FormatterScope) {
+            // eslint-disable-next-line no-useless-concat
+            return "<b>step:</b> " + this.key + "<br>" + "<b>Energy:</b> " + this.y.toFixed(4);
+        };
+    }
+}
+
+type Base = typeof Property<Schema> & Constructor<ConvergenceIonicPropertySchemaMixin>;
+
+class ConvergenceIonicProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.convergence_ionic;
+
+    static readonly propertyType = PropertyType.non_scalar;
+
+    static readonly isConvergence = true;
+
+    readonly chartConfig: Options;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: ConvergenceIonicProperty.propertyName });
+        this.chartConfig = new ConvergenceIonicConfig(this).config;
+    }
+}
+
+convergenceIonicPropertySchemaMixin(ConvergenceIonicProperty.prototype);
+
+export default ConvergenceIonicProperty;

package/src/js/properties/object/TotalEnergyContributionsProperty.ts

@@ -0,0 +1,29 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { TotalEnergyContributionsPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    TotalEnergyContributionsPropertySchemaMixin,
+    totalEnergyContributionsPropertySchemaMixin,
+} from "../../generated/TotalEnergyContributionsPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = TotalEnergyContributionsPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<TotalEnergyContributionsPropertySchemaMixin>;
+
+export default class TotalEnergyContributionsProperty extends (Property as Base) implements Schema {
+    static readonly propertyType = PropertyType.object;
+
+    static readonly propertyName = PropertyName.total_energy_contributions;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: TotalEnergyContributionsProperty.propertyName });
+    }
+
+    get exchangeCorrelation() {
+        return this.exchange_correlation;
+    }
+}
+
+totalEnergyContributionsPropertySchemaMixin(TotalEnergyContributionsProperty.prototype);

package/src/js/properties/scalar/FermiEnergyProperty.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FermiEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    FermiEnergyPropertySchemaMixin,
+    fermiEnergyPropertySchemaMixin,
+} from "../../generated/FermiEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = FermiEnergyPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<FermiEnergyPropertySchemaMixin>;
+
+export default class FermiEnergyProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.fermi_energy;
+
+    static readonly propertyType = PropertyType.scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: FermiEnergyProperty.propertyName });
+    }
+}
+
+fermiEnergyPropertySchemaMixin(FermiEnergyProperty.prototype);

package/src/js/properties/scalar/IonizationPotentialElementalProperty.ts

@@ -0,0 +1,27 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { IonizationPotentialElementalPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    IonizationPotentialElementalPropertySchemaMixin,
+    ionizationPotentialElementalPropertySchemaMixin,
+} from "../../generated/IonizationPotentialElementalPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = IonizationPotentialElementalPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<IonizationPotentialElementalPropertySchemaMixin>;
+
+class IonizationPotentialElementalProperty extends (Property as Base) implements Schema {
+    static readonly propertyName = PropertyName.ionization_potential;
+
+    static readonly propertyType = PropertyType.scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: IonizationPotentialElementalProperty.propertyName });
+    }
+}
+
+ionizationPotentialElementalPropertySchemaMixin(IonizationPotentialElementalProperty.prototype);
+
+export default IonizationPotentialElementalProperty;