web: Update favicon

web/src/components/CaseBuilder/CaseBuilder.tsx

@@ -20,6 +20,8 @@ import ProfiledUnitsComponent from "./ProfiledUnits";
 import ThermalUnitsComponent from "./ThermalUnits";
 import TransmissionLinesComponent from "./TransmissionLines";
 import { UnitCommitmentScenario } from "../../core/Data/types";
+import StorageComponent from "./StorageUnits";
+import PriceSensitiveLoadsComponent from "./Psload";
 
 export interface CaseBuilderSectionProps {
   scenario: UnitCommitmentScenario;
@@ -30,7 +32,13 @@ export interface CaseBuilderSectionProps {
 const CaseBuilder = () => {
   const [scenario, setScenario] = useState(() => {
     const savedScenario = localStorage.getItem("scenario");
-    return savedScenario ? JSON.parse(savedScenario) : BLANK_SCENARIO;
+    if (!savedScenario) return BLANK_SCENARIO;
+    const [processedScenario, err] = preprocess(JSON.parse(savedScenario));
+    if (err) {
+      console.log(err);
+      return BLANK_SCENARIO;
+    }
+    return processedScenario!!;
   });
   const [undoStack, setUndoStack] = useState<UnitCommitmentScenario[]>([]);
   const [toastMessage, setToastMessage] = useState<string>("");
@@ -112,6 +120,16 @@ const CaseBuilder = () => {
           onDataChanged={onDataChanged}
           onError={setToastMessage}
         />
+        <StorageComponent
+          scenario={scenario}
+          onDataChanged={onDataChanged}
+          onError={setToastMessage}
+        />
+        <PriceSensitiveLoadsComponent
+          scenario={scenario}
+          onDataChanged={onDataChanged}
+          onError={setToastMessage}
+        />
         <TransmissionLinesComponent
           scenario={scenario}
           onDataChanged={onDataChanged}

web/src/components/CaseBuilder/ProfiledUnits.tsx

@@ -174,7 +174,7 @@ const ProfiledUnitsComponent = (props: CaseBuilderSectionProps) => {
 
   return (
     <div>
-      <SectionHeader title="Profiled Units">
+      <SectionHeader title="Profiled units">
         <SectionButton icon={faPlus} tooltip="Add" onClick={onAdd} />
         <SectionButton
           icon={faDownload}

web/src/components/CaseBuilder/Psload.tsx

@@ -0,0 +1,175 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import DataTable, {
+  ColumnSpec,
+  generateCsv,
+  generateTableColumns,
+  generateTableData,
+  parseCsv,
+} from "../Common/Forms/DataTable";
+import { CaseBuilderSectionProps } from "./CaseBuilder";
+import { useRef } from "react";
+import FileUploadElement from "../Common/Buttons/FileUploadElement";
+import { ValidationError } from "../../core/Data/validate";
+import SectionHeader from "../Common/SectionHeader/SectionHeader";
+import SectionButton from "../Common/Buttons/SectionButton";
+import {
+  faDownload,
+  faPlus,
+  faUpload,
+} from "@fortawesome/free-solid-svg-icons";
+import { UnitCommitmentScenario } from "../../core/Data/types";
+import { ColumnDefinition } from "tabulator-tables";
+import {
+  changePriceSensitiveLoadData,
+  createPriceSensitiveLoad,
+  deletePriceSensitiveLoad,
+  renamePriceSensitiveLoad,
+} from "../../core/Operations/psloadOps";
+import { offerDownload } from "../Common/io";
+
+export const PriceSensitiveLoadsColumnSpec: ColumnSpec[] = [
+  {
+    title: "Name",
+    type: "string",
+    width: 100,
+  },
+  {
+    title: "Bus",
+    type: "busRef",
+    width: 100,
+  },
+  {
+    title: "Revenue ($/MW)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Demand (MW)",
+    type: "number[T]",
+    width: 70,
+  },
+];
+
+export const generatePriceSensitiveLoadsData = (
+  scenario: UnitCommitmentScenario,
+): [any[], ColumnDefinition[]] => {
+  const columns = generateTableColumns(scenario, PriceSensitiveLoadsColumnSpec);
+  const data = generateTableData(
+    scenario["Price-sensitive loads"],
+    PriceSensitiveLoadsColumnSpec,
+    scenario,
+  );
+  return [data, columns];
+};
+
+const PriceSensitiveLoadsComponent = (props: CaseBuilderSectionProps) => {
+  const fileUploadElem = useRef<FileUploadElement>(null);
+
+  const onDownload = () => {
+    const [data, columns] = generatePriceSensitiveLoadsData(props.scenario);
+    const csvContents = generateCsv(data, columns);
+    offerDownload(csvContents, "text/csv", "psloads.csv");
+  };
+
+  const onUpload = () => {
+    fileUploadElem.current!.showFilePicker((csv: any) => {
+      // Parse provided CSV file
+      const [psloads, err] = parseCsv(
+        csv,
+        PriceSensitiveLoadsColumnSpec,
+        props.scenario,
+      );
+
+      // Handle validation errors
+      if (err) {
+        props.onError(err.message);
+        return;
+      }
+
+      // Generate new scenario
+      props.onDataChanged({
+        ...props.scenario,
+        "Price-sensitive loads": psloads,
+      });
+    });
+  };
+
+  const onAdd = () => {
+    const [newScenario, err] = createPriceSensitiveLoad(props.scenario);
+    if (err) {
+      props.onError(err.message);
+      return;
+    }
+    props.onDataChanged(newScenario);
+  };
+
+  const onDelete = (name: string): ValidationError | null => {
+    const newScenario = deletePriceSensitiveLoad(name, props.scenario);
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  const onDataChanged = (
+    name: string,
+    field: string,
+    newValue: string,
+  ): ValidationError | null => {
+    const [newScenario, err] = changePriceSensitiveLoadData(
+      name,
+      field,
+      newValue,
+      props.scenario,
+    );
+    if (err) {
+      props.onError(err.message);
+      return err;
+    }
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  const onRename = (
+    oldName: string,
+    newName: string,
+  ): ValidationError | null => {
+    const [newScenario, err] = renamePriceSensitiveLoad(
+      oldName,
+      newName,
+      props.scenario,
+    );
+    if (err) {
+      props.onError(err.message);
+      return err;
+    }
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  return (
+    <div>
+      <SectionHeader title="Price-sensitive loads">
+        <SectionButton icon={faPlus} tooltip="Add" onClick={onAdd} />
+        <SectionButton
+          icon={faDownload}
+          tooltip="Download"
+          onClick={onDownload}
+        />
+        <SectionButton icon={faUpload} tooltip="Upload" onClick={onUpload} />
+      </SectionHeader>
+      <DataTable
+        onRowDeleted={onDelete}
+        onRowRenamed={onRename}
+        onDataChanged={onDataChanged}
+        generateData={() => generatePriceSensitiveLoadsData(props.scenario)}
+      />
+      <FileUploadElement ref={fileUploadElem} accept=".csv" />
+    </div>
+  );
+};
+
+export default PriceSensitiveLoadsComponent;

web/src/components/CaseBuilder/StorageUnits.tsx

@@ -0,0 +1,235 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import DataTable, {
+  ColumnSpec,
+  generateCsv,
+  generateTableColumns,
+  generateTableData,
+  parseCsv,
+} from "../Common/Forms/DataTable";
+import { CaseBuilderSectionProps } from "./CaseBuilder";
+import { useRef } from "react";
+import FileUploadElement from "../Common/Buttons/FileUploadElement";
+import { ValidationError } from "../../core/Data/validate";
+import SectionHeader from "../Common/SectionHeader/SectionHeader";
+import SectionButton from "../Common/Buttons/SectionButton";
+import {
+  faDownload,
+  faPlus,
+  faUpload,
+} from "@fortawesome/free-solid-svg-icons";
+import { UnitCommitmentScenario } from "../../core/Data/types";
+import { ColumnDefinition } from "tabulator-tables";
+import {
+  changeStorageUnitData,
+  createStorageUnit,
+  deleteStorageUnit,
+  renameStorageUnit,
+} from "../../core/Operations/storageOps";
+import { offerDownload } from "../Common/io";
+
+export const StorageUnitsColumnSpec: ColumnSpec[] = [
+  {
+    title: "Name",
+    type: "string",
+    width: 100,
+  },
+  {
+    title: "Bus",
+    type: "busRef",
+    width: 100,
+  },
+  {
+    title: "Minimum level (MWh)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Maximum level (MWh)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Charge cost ($/MW)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Discharge cost ($/MW)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Charge efficiency",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Discharge efficiency",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Loss factor",
+    type: "number",
+    width: 80,
+  },
+  {
+    title: "Minimum charge rate (MW)",
+    type: "number",
+    width: 140,
+  },
+  {
+    title: "Maximum charge rate (MW)",
+    type: "number",
+    width: 140,
+  },
+  {
+    title: "Minimum discharge rate (MW)",
+    type: "number",
+    width: 140,
+  },
+  {
+    title: "Maximum discharge rate (MW)",
+    type: "number",
+    width: 150,
+  },
+  {
+    title: "Initial level (MWh)",
+    type: "number",
+    width: 100,
+  },
+  {
+    title: "Last period minimum level (MWh)",
+    type: "number",
+    width: 160,
+  },
+  {
+    title: "Last period maximum level (MWh)",
+    type: "number",
+    width: 160,
+  },
+];
+
+export const generateStorageUnitsData = (
+  scenario: UnitCommitmentScenario,
+): [any[], ColumnDefinition[]] => {
+  const columns = generateTableColumns(scenario, StorageUnitsColumnSpec);
+  const data = generateTableData(
+    scenario["Storage units"],
+    StorageUnitsColumnSpec,
+    scenario,
+  );
+  return [data, columns];
+};
+
+const StorageUnitsComponent = (props: CaseBuilderSectionProps) => {
+  const fileUploadElem = useRef<FileUploadElement>(null);
+
+  const onDownload = () => {
+    const [data, columns] = generateStorageUnitsData(props.scenario);
+    const csvContents = generateCsv(data, columns);
+    offerDownload(csvContents, "text/csv", "storage_units.csv");
+  };
+
+  const onUpload = () => {
+    fileUploadElem.current!.showFilePicker((csv: any) => {
+      // Parse provided CSV file
+      const [storageUnits, err] = parseCsv(
+        csv,
+        StorageUnitsColumnSpec,
+        props.scenario,
+      );
+
+      // Handle validation errors
+      if (err) {
+        props.onError(err.message);
+        return;
+      }
+
+      // Generate new scenario
+      props.onDataChanged({
+        ...props.scenario,
+        "Storage units": storageUnits,
+      });
+    });
+  };
+
+  const onAdd = () => {
+    const [newScenario, err] = createStorageUnit(props.scenario);
+    if (err) {
+      props.onError(err.message);
+      return;
+    }
+    props.onDataChanged(newScenario);
+  };
+
+  const onDelete = (name: string): ValidationError | null => {
+    const newScenario = deleteStorageUnit(name, props.scenario);
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  const onDataChanged = (
+    name: string,
+    field: string,
+    newValue: string,
+  ): ValidationError | null => {
+    const [newScenario, err] = changeStorageUnitData(
+      name,
+      field,
+      newValue,
+      props.scenario,
+    );
+    if (err) {
+      props.onError(err.message);
+      return err;
+    }
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  const onRename = (
+    oldName: string,
+    newName: string,
+  ): ValidationError | null => {
+    const [newScenario, err] = renameStorageUnit(
+      oldName,
+      newName,
+      props.scenario,
+    );
+    if (err) {
+      props.onError(err.message);
+      return err;
+    }
+    props.onDataChanged(newScenario);
+    return null;
+  };
+
+  return (
+    <div>
+      <SectionHeader title="Storage units">
+        <SectionButton icon={faPlus} tooltip="Add" onClick={onAdd} />
+        <SectionButton
+          icon={faDownload}
+          tooltip="Download"
+          onClick={onDownload}
+        />
+        <SectionButton icon={faUpload} tooltip="Upload" onClick={onUpload} />
+      </SectionHeader>
+      <DataTable
+        onRowDeleted={onDelete}
+        onRowRenamed={onRename}
+        onDataChanged={onDataChanged}
+        generateData={() => generateStorageUnitsData(props.scenario)}
+      />
+      <FileUploadElement ref={fileUploadElem} accept=".csv" />
+    </div>
+  );
+};
+
+export default StorageUnitsComponent;

web/src/components/CaseBuilder/ThermalUnits.tsx

@@ -228,7 +228,7 @@ const ThermalUnitsComponent = (props: CaseBuilderSectionProps) => {
 
   return (
     <div>
-      <SectionHeader title="Thermal Units">
+      <SectionHeader title="Thermal units">
         <SectionButton icon={faPlus} tooltip="Add" onClick={onAdd} />
         <SectionButton
           icon={faDownload}

web/src/components/CaseBuilder/TransmissionLines.tsx

@@ -27,6 +27,7 @@ import {
   changeTransmissionLineData,
   createTransmissionLine,
   deleteTransmissionLine,
+  rebuildContingencies,
   renameTransmissionLine,
 } from "../../core/Operations/transmissionOps";
 import { offerDownload } from "../Common/io";
@@ -68,6 +69,11 @@ export const TransmissionLinesColumnSpec: ColumnSpec[] = [
     type: "number",
     width: 60,
   },
+  {
+    title: "Contingency?",
+    type: "lineContingency",
+    width: 50,
+  },
 ];
 
 const generateTransmissionLinesData = (
@@ -93,6 +99,7 @@ const TransmissionLinesComponent = (props: CaseBuilderSectionProps) => {
 
   const onUpload = () => {
     fileUploadElem.current!.showFilePicker((csv: any) => {
+      // Parse the CSV data
       const [newLines, err] = parseCsv(
         csv,
         TransmissionLinesColumnSpec,
@@ -102,9 +109,19 @@ const TransmissionLinesComponent = (props: CaseBuilderSectionProps) => {
         props.onError(err.message);
         return;
       }
+
+      // Remove contingency field from line and rebuild the contingencies section
+      const lineContingencies = new Set<String>();
+      Object.entries(newLines).forEach(([lineName, line]: [string, any]) => {
+        if (line["Contingency?"]) lineContingencies.add(lineName);
+        delete line["Contingency?"];
+      });
+      const contingencies = rebuildContingencies(lineContingencies);
+
       const newScenario = {
         ...props.scenario,
         "Transmission lines": newLines,
+        Contingencies: contingencies,
       };
       props.onDataChanged(newScenario);
     });
@@ -163,7 +180,7 @@ const TransmissionLinesComponent = (props: CaseBuilderSectionProps) => {
 
   return (
     <div>
-      <SectionHeader title="Transmission Lines">
+      <SectionHeader title="Transmission lines">
         <SectionButton icon={faPlus} tooltip="Add" onClick={onAdd} />
         <SectionButton
           icon={faDownload}

web/src/components/Common/Forms/DataTable.tsx

@@ -18,6 +18,7 @@ import {
   parseNumber,
 } from "../../../core/Operations/commonOps";
 import { UnitCommitmentScenario } from "../../../core/Data/types";
+import { getContingencyTransmissionLines } from "../../../core/Operations/transmissionOps";
 
 export interface ColumnSpec {
   title: string;
@@ -28,7 +29,8 @@ export interface ColumnSpec {
     | "number[N]"
     | "number[T]"
     | "busRef"
-    | "boolean";
+    | "boolean"
+    | "lineContingency";
   length?: number;
   width: number;
 }
@@ -52,6 +54,7 @@ export const generateTableColumns = (
         });
         break;
       case "boolean":
+      case "lineContingency":
         columns.push({
           ...columnsCommonAttrs,
           title: spec.title,
@@ -117,6 +120,7 @@ export const generateTableData = (
 ): any[] => {
   const data: any[] = [];
   const timeslots = generateTimeslots(scenario);
+  let contingencyLines = null;
   for (const [entryName, entryData] of Object.entries(container) as [
     string,
     any,
@@ -135,6 +139,13 @@ export const generateTableData = (
         case "busRef":
           entry[spec.title] = entryData[spec.title];
           break;
+        case "lineContingency":
+          if (contingencyLines === null) {
+            contingencyLines = getContingencyTransmissionLines(scenario);
+            console.log(contingencyLines);
+          }
+          entry[spec.title] = contingencyLines.has(entryName);
+          break;
         case "number[T]":
           for (let i = 0; i < timeslots.length; i++) {
             entry[`${spec.title} ${timeslots[i]}`] = entryData[spec.title][i];
@@ -287,12 +298,12 @@ export const parseCsv = (
           }
           break;
         }
-        case "boolean": {
+        case "boolean":
+        case "lineContingency":
           const [val, err] = parseBool(row[spec.title]);
           if (err) return [data, { message: err.message + rowRef }];
           data[name][spec.title] = val;
           break;
-        }
         default:
           throw Error(`Unknown type: ${spec.type}`);
       }
@@ -361,7 +372,7 @@ interface DataTableProps {
 
 function computeTableHeight(data: any[]): string {
   const numRows = data.length;
-  const height = 70 + Math.min(numRows, 15) * 28;
+  const height = 70 + Math.max(Math.min(numRows, 15), 1) * 28;
   return `${height}px`;
 }
 
@@ -370,6 +381,7 @@ const DataTable = (props: DataTableProps) => {
   const tableRef = useRef<Tabulator | null>(null);
   const [isTableBuilt, setTableBuilt] = useState<Boolean>(false);
   const [activeCell, setActiveCell] = useState<CellComponent | null>(null);
+  const [currentTableData, setCurrentTableData] = useState<any[]>([]);
 
   useEffect(() => {
     const onCellEdited = (cell: CellComponent) => {
@@ -407,27 +419,50 @@ const DataTable = (props: DataTableProps) => {
     const height = computeTableHeight(data);
 
     if (tableRef.current === null) {
-      console.log("new Tabulator");
       tableRef.current = new Tabulator(tableContainerRef.current, {
         layout: "fitColumns",
         data: data,
         columns: columns,
         height: height,
+        index: "Name",
+        placeholder: "No data",
       });
       tableRef.current.on("tableBuilt", () => {
         setTableBuilt(true);
       });
     }
+
     if (isTableBuilt) {
       const newHeight = height;
       const newColumns = columns;
-      const newData = data;
+      const newTableData = data;
       const oldRows = tableRef.current.getRows();
       const activeRowPosition = activeCell?.getRow().getPosition() as number;
       const activeField = activeCell?.getField();
 
       // Update data
-      tableRef.current.replaceData(newData).then(() => {});
+      if (newTableData.length === currentTableData.length) {
+        const updatedRows = newTableData.filter((_, i) => {
+          return (
+            JSON.stringify(newTableData[i]) !==
+            JSON.stringify(currentTableData[i])
+          );
+        });
+        if (updatedRows.length > 0) {
+          tableRef.current
+            .updateData(updatedRows)
+            .then(() => {})
+            .catch((e) => {
+              // WORKAROUND: Updating the same row twice triggers an exception.
+              // In that case, we just update the whole table.
+              console.log(e);
+              tableRef.current!!.replaceData(newTableData).then(() => {});
+            });
+        }
+      } else {
+        tableRef.current.replaceData(newTableData).then(() => {});
+      }
+      setCurrentTableData(newTableData);
 
       // Restore active cell selection
       if (activeCell) {
@@ -472,7 +507,6 @@ const DataTable = (props: DataTableProps) => {
 
       // Set new callbacks
       tableRef.current.on("cellEditing", (cell) => {
-        console.log("cellEditing", cell);
         setActiveCell(cell);
       });
 
@@ -481,6 +515,7 @@ const DataTable = (props: DataTableProps) => {
       });
 
       tableRef.current.on("cellEdited", (cell) => {
+        setActiveCell(null);
         onCellEdited(cell);
       });
     }

web/src/components/Common/Forms/Tables.css

@@ -82,4 +82,15 @@
 
 .tabulator-col-group-cols {
   font-size: 12px;
+}
+
+.tabulator-placeholder {
+    width: 100px !important;
+}
+
+
+.tabulator-placeholder * {
+    font-weight: normal !important;
+    font-size: 14px !important;
+    color: var(--contrast-60) !important;
 }

web/src/core/Data/fixtures.test.ts

@@ -61,6 +61,38 @@ export const TEST_DATA_1: UnitCommitmentScenario = {
       "Flow limit penalty ($/MW)": 5000.0,
     },
   },
+  "Storage units": {
+    su1: {
+      Bus: "b1",
+      "Minimum level (MWh)": 10.0,
+      "Maximum level (MWh)": 100.0,
+      "Charge cost ($/MW)": 2.0,
+      "Discharge cost ($/MW)": 1.0,
+      "Charge efficiency": 0.8,
+      "Discharge efficiency": 0.85,
+      "Loss factor": 0.01,
+      "Minimum charge rate (MW)": 5.0,
+      "Maximum charge rate (MW)": 10.0,
+      "Minimum discharge rate (MW)": 4.0,
+      "Maximum discharge rate (MW)": 8.0,
+      "Initial level (MWh)": 20.0,
+      "Last period minimum level (MWh)": 21.0,
+      "Last period maximum level (MWh)": 22.0,
+    },
+  },
+  "Price-sensitive loads": {
+    ps1: {
+      Bus: "b3",
+      "Revenue ($/MW)": 23.0,
+      "Demand (MW)": [50, 50, 50, 50, 50],
+    },
+  },
+  Contingencies: {
+    l1: {
+      "Affected generators": [],
+      "Affected lines": ["l1"],
+    },
+  },
 };
 
 export const TEST_DATA_2: UnitCommitmentScenario = {
@@ -75,8 +107,11 @@ export const TEST_DATA_2: UnitCommitmentScenario = {
     b2: { "Load (MW)": [10, 20, 30, 40] },
     b3: { "Load (MW)": [0, 30, 0, 40] },
   },
+  Contingencies: {},
   Generators: {},
   "Transmission lines": {},
+  "Storage units": {},
+  "Price-sensitive loads": {},
 };
 
 export const TEST_DATA_BLANK: UnitCommitmentScenario = {
@@ -87,8 +122,11 @@ export const TEST_DATA_BLANK: UnitCommitmentScenario = {
     "Time step (min)": 60,
   },
   Buses: {},
+  Contingencies: {},
   Generators: {},
   "Transmission lines": {},
+  "Storage units": {},
+  "Price-sensitive loads": {},
 };
 
 test("fixtures", () => {});

web/src/core/Data/fixtures.tsx

@@ -20,4 +20,7 @@ export const BLANK_SCENARIO: UnitCommitmentScenario = {
   Buses: {},
   Generators: {},
   "Transmission lines": {},
+  "Storage units": {},
+  "Price-sensitive loads": {},
+  Contingencies: {},
 };

web/src/core/Data/types.tsx

@@ -45,6 +45,35 @@ export interface TransmissionLine {
   "Flow limit penalty ($/MW)": number;
 }
 
+export interface StorageUnit {
+  Bus: string;
+  "Minimum level (MWh)": number;
+  "Maximum level (MWh)": number;
+  "Charge cost ($/MW)": number;
+  "Discharge cost ($/MW)": number;
+  "Charge efficiency": number;
+  "Discharge efficiency": number;
+  "Loss factor": number;
+  "Minimum charge rate (MW)": number;
+  "Maximum charge rate (MW)": number;
+  "Minimum discharge rate (MW)": number;
+  "Maximum discharge rate (MW)": number;
+  "Initial level (MWh)": number;
+  "Last period minimum level (MWh)": number;
+  "Last period maximum level (MWh)": number;
+}
+
+export interface PriceSensitiveLoad {
+  Bus: string;
+  "Revenue ($/MW)": number;
+  "Demand (MW)": number[];
+}
+
+export interface Contingency {
+  "Affected lines": string[];
+  "Affected generators": string[];
+}
+
 export interface UnitCommitmentScenario {
   Parameters: {
     Version: string;
@@ -57,6 +86,15 @@ export interface UnitCommitmentScenario {
   "Transmission lines": {
     [name: string]: TransmissionLine;
   };
+  "Storage units": {
+    [name: string]: StorageUnit;
+  };
+  "Price-sensitive loads": {
+    [name: string]: PriceSensitiveLoad;
+  };
+  Contingencies: {
+    [name: string]: Contingency;
+  };
 }
 
 const getTypedGenerators = <T extends any>(

web/src/core/Operations/commonOps.ts

@@ -253,6 +253,6 @@ export const assertBusesNotEmpty = (
   scenario: UnitCommitmentScenario,
 ): ValidationError | null => {
   if (Object.keys(scenario.Buses).length === 0)
-    return { message: "Profiled unit requires an existing bus." };
+    return { message: "This component requires an existing bus." };
   return null;
 };

web/src/core/Operations/generatorOps.test.ts

@@ -33,7 +33,7 @@ test("createThermalUnit", () => {
 test("createProfiledUnit with blank file", () => {
   const [, err] = createProfiledUnit(TEST_DATA_BLANK);
   assert(err !== null);
-  assert.equal(err.message, "Profiled unit requires an existing bus.");
+  assert.equal(err.message, "This component requires an existing bus.");
 });
 
 test("changeProfiledUnitData", () => {

web/src/core/Operations/parameterOps.ts

@@ -35,6 +35,9 @@ export const changeTimeHorizon = (
         generator["Maximum power (MW)"] = generator["Maximum power (MW)"].slice(0, newT);
       }
     });
+    Object.values(newScenario["Price-sensitive loads"]).forEach((psLoad) => {
+      psLoad["Demand (MW)"] = psLoad["Demand (MW)"].slice(0, newT);
+    });
   } else {
     const padding = Array(newT - oldT).fill(0);
     Object.values(newScenario.Buses).forEach((bus) => {
@@ -46,6 +49,9 @@ export const changeTimeHorizon = (
         generator["Maximum power (MW)"] = generator["Maximum power (MW)"].concat(padding);
       }
     });
+    Object.values(newScenario["Price-sensitive loads"]).forEach((psLoad) => {
+      psLoad["Demand (MW)"] = psLoad["Demand (MW)"].concat(padding);
+    });
   }
   return [newScenario, null];
 };
@@ -156,6 +162,28 @@ export const changeTimeStep = (
     }
   }
 
+  const newPriceSensitiveLoads: { [name: string]: any } = {};
+  for (const psLoadName in scenario["Price-sensitive loads"]) {
+    const psLoad = scenario["Price-sensitive loads"][psLoadName]!;
+    
+    // Build data_y for demand
+    const demand = psLoad["Demand (MW)"];
+    const demandData_y = Array(oldT + 1).fill(0);
+    for (let i = 0; i < oldT; i++) demandData_y[i] = demand[i];
+    demandData_y[oldT] = demandData_y[0];
+
+    // Run interpolation for demand
+    const newDemand = Array(newT).fill(0);
+    for (let i = 0; i < newT; i++) {
+      newDemand[i] = evaluatePwlFunction(data_x, demandData_y, newTimeStep * i);
+    }
+
+    newPriceSensitiveLoads[psLoadName] = {
+      ...psLoad,
+      "Demand (MW)": newDemand,
+    };
+  }
+
   return [
     {
       ...scenario,
@@ -165,6 +193,7 @@ export const changeTimeStep = (
       },
       Buses: newBuses,
       Generators: newGenerators,
+      "Price-sensitive loads": newPriceSensitiveLoads,
     },
     null,
   ];

web/src/core/Operations/preprocessing.test.ts

@@ -20,7 +20,8 @@ export const PREPROCESSING_TEST_DATA_1: any = {
 };
 
 test("preprocess", () => {
-  const newScenario = preprocess(PREPROCESSING_TEST_DATA_1);
+  const [newScenario, err] = preprocess(PREPROCESSING_TEST_DATA_1);
+  assert(err === null);
   assert.deepEqual(newScenario, {
     Parameters: {
       Version: "0.4",
@@ -35,5 +36,11 @@ test("preprocess", () => {
       b2: { "Load (MW)": [10, 10, 10, 10, 10] },
       b3: { "Load (MW)": [27.3729, 26.29698, 25.58005, 25.15675, 25.4268] },
     },
+    "Price-sensitive loads": {},
+    "Storage units": {},
+    "Transmission lines": {},
+    Contingencies: {},
+    Generators: {},
+    Reserves: {},
   });
 });

web/src/core/Operations/preprocessing.ts

@@ -7,6 +7,10 @@
 import { validate, ValidationError } from "../Data/validate";
 import { UnitCommitmentScenario } from "../Data/types";
 import { migrate } from "../Data/migrate";
+import {
+  getContingencyTransmissionLines,
+  rebuildContingencies,
+} from "./transmissionOps";
 
 export const preprocess = (
   data: any,
@@ -41,6 +45,26 @@ export const preprocess = (
     }
   }
 
+  // Add optional fields
+  for (let field of [
+    "Buses",
+    "Generators",
+    "Storage units",
+    "Price-sensitive loads",
+    "Transmission lines",
+    "Reserves",
+    "Contingencies",
+  ]) {
+    if (!result[field]) {
+      result[field] = {};
+    }
+  }
+
   const scenario = result as unknown as UnitCommitmentScenario;
+
+  // Rebuild contingencies
+  const contingencyLines = getContingencyTransmissionLines(scenario);
+  scenario["Contingencies"] = rebuildContingencies(contingencyLines);
+
   return [scenario, null];
 };

web/src/core/Operations/psloadOps.test.ts

@@ -0,0 +1,60 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import { TEST_DATA_1 } from "../Data/fixtures.test";
+import assert from "node:assert";
+import {
+  changePriceSensitiveLoadData,
+  createPriceSensitiveLoad,
+  deletePriceSensitiveLoad,
+  renamePriceSensitiveLoad,
+} from "./psloadOps";
+import { ValidationError } from "../Data/validate";
+
+test("createPriceSensitiveLoad", () => {
+  const [newScenario, err] = createPriceSensitiveLoad(TEST_DATA_1);
+  assert(err === null);
+  assert.equal(Object.keys(newScenario["Price-sensitive loads"]).length, 2);
+  assert("ps2" in newScenario["Price-sensitive loads"]);
+});
+
+test("renamePriceSensitiveLoad", () => {
+  const [newScenario, err] = renamePriceSensitiveLoad(
+    "ps1",
+    "ps2",
+    TEST_DATA_1,
+  );
+  assert(err === null);
+  assert.deepEqual(
+    newScenario["Price-sensitive loads"]["ps2"],
+    TEST_DATA_1["Price-sensitive loads"]["ps1"],
+  );
+  assert.equal(Object.keys(newScenario["Price-sensitive loads"]).length, 1);
+});
+
+test("changePriceSensitiveLoadData", () => {
+  let scenario = TEST_DATA_1;
+  let err: ValidationError | null;
+  [scenario, err] = changePriceSensitiveLoadData("ps1", "Bus", "b3", scenario);
+  assert.equal(err, null);
+  [scenario, err] = changePriceSensitiveLoadData(
+    "ps1",
+    "Demand (MW) 00:00",
+    "99",
+    scenario,
+  );
+  assert.equal(err, null);
+  assert.deepEqual(scenario["Price-sensitive loads"]["ps1"], {
+    Bus: "b3",
+    "Revenue ($/MW)": 23,
+    "Demand (MW)": [99, 50, 50, 50, 50],
+  });
+});
+
+test("deletePriceSensitiveLoad", () => {
+  const newScenario = deletePriceSensitiveLoad("ps1", TEST_DATA_1);
+  assert.equal(Object.keys(newScenario["Price-sensitive loads"]).length, 0);
+});

web/src/core/Operations/psloadOps.ts

@@ -0,0 +1,88 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import { ValidationError } from "../Data/validate";
+import { PriceSensitiveLoad, UnitCommitmentScenario } from "../Data/types";
+import {
+  assertBusesNotEmpty,
+  changeData,
+  generateUniqueName,
+  renameItemInObject,
+} from "./commonOps";
+import { PriceSensitiveLoadsColumnSpec } from "../../components/CaseBuilder/Psload";
+import { generateTimeslots } from "../../components/Common/Forms/DataTable";
+
+export const createPriceSensitiveLoad = (
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const err = assertBusesNotEmpty(scenario);
+  if (err) return [scenario, err];
+  const busName = Object.keys(scenario.Buses)[0]!;
+  const timeslots = generateTimeslots(scenario);
+  const name = generateUniqueName(scenario["Price-sensitive loads"], "ps");
+  return [
+    {
+      ...scenario,
+      "Price-sensitive loads": {
+        ...scenario["Price-sensitive loads"],
+        [name]: {
+          Bus: busName,
+          "Revenue ($/MW)": 0,
+          "Demand (MW)": Array(timeslots.length).fill(0),
+        },
+      },
+    },
+    null,
+  ];
+};
+
+export const renamePriceSensitiveLoad = (
+  oldName: string,
+  newName: string,
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const [newObj, err] = renameItemInObject(
+    oldName,
+    newName,
+    scenario["Price-sensitive loads"],
+  );
+  if (err) return [scenario, err];
+  return [{ ...scenario, "Price-sensitive loads": newObj }, null];
+};
+
+export const changePriceSensitiveLoadData = (
+  name: string,
+  field: string,
+  newValueStr: string,
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const [newObj, err] = changeData(
+    field,
+    newValueStr,
+    scenario["Price-sensitive loads"][name]!,
+    PriceSensitiveLoadsColumnSpec,
+    scenario,
+  );
+  if (err) return [scenario, err];
+  return [
+    {
+      ...scenario,
+      "Price-sensitive loads": {
+        ...scenario["Price-sensitive loads"],
+        [name]: newObj as PriceSensitiveLoad,
+      },
+    },
+    null,
+  ];
+};
+
+export const deletePriceSensitiveLoad = (
+  name: string,
+  scenario: UnitCommitmentScenario,
+): UnitCommitmentScenario => {
+  const { [name]: _, ...newContainer } = scenario["Price-sensitive loads"];
+  return { ...scenario, "Price-sensitive loads": newContainer };
+};

web/src/core/Operations/storageOps.test.ts

@@ -0,0 +1,75 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import { TEST_DATA_1 } from "../Data/fixtures.test";
+import assert from "node:assert";
+import {
+  changeStorageUnitData,
+  createStorageUnit,
+  deleteStorageUnit,
+  renameStorageUnit,
+} from "./storageOps";
+import { ValidationError } from "../Data/validate";
+
+test("createStorageUnit", () => {
+  const [newScenario, err] = createStorageUnit(TEST_DATA_1);
+  assert(err === null);
+  assert.equal(Object.keys(newScenario["Storage units"]).length, 2);
+  assert("su2" in newScenario["Storage units"]);
+});
+
+test("renameStorageUnit", () => {
+  const [newScenario, err] = renameStorageUnit("su1", "su2", TEST_DATA_1);
+  assert(err === null);
+  assert.deepEqual(
+    newScenario["Storage units"]["su2"],
+    TEST_DATA_1["Storage units"]["su1"],
+  );
+  assert.equal(Object.keys(newScenario["Storage units"]).length, 1);
+});
+
+test("changeStorageUnitData", () => {
+  let scenario = TEST_DATA_1;
+  let err: ValidationError | null;
+  [scenario, err] = changeStorageUnitData("su1", "Bus", "b3", scenario);
+  assert.equal(err, null);
+  [scenario, err] = changeStorageUnitData(
+    "su1",
+    "Minimum level (MWh)",
+    "99",
+    scenario,
+  );
+  assert.equal(err, null);
+  [scenario, err] = changeStorageUnitData(
+    "su1",
+    "Maximum discharge rate (MW)",
+    "99",
+    scenario,
+  );
+  assert.equal(err, null);
+  assert.deepEqual(scenario["Storage units"]["su1"], {
+    Bus: "b3",
+    "Minimum level (MWh)": 99.0,
+    "Maximum level (MWh)": 100.0,
+    "Charge cost ($/MW)": 2.0,
+    "Discharge cost ($/MW)": 1.0,
+    "Charge efficiency": 0.8,
+    "Discharge efficiency": 0.85,
+    "Loss factor": 0.01,
+    "Minimum charge rate (MW)": 5.0,
+    "Maximum charge rate (MW)": 10.0,
+    "Minimum discharge rate (MW)": 4.0,
+    "Maximum discharge rate (MW)": 99.0,
+    "Initial level (MWh)": 20.0,
+    "Last period minimum level (MWh)": 21.0,
+    "Last period maximum level (MWh)": 22.0,
+  });
+});
+
+test("deleteStorageUnit", () => {
+  const newScenario = deleteStorageUnit("su1", TEST_DATA_1);
+  assert.equal(Object.keys(newScenario["Storage units"]).length, 0);
+});

web/src/core/Operations/storageOps.ts

@@ -0,0 +1,98 @@
+/*
+ * UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment
+ * Copyright (C) 2020-2025, UChicago Argonne, LLC. All rights reserved.
+ * Released under the modified BSD license. See COPYING.md for more details.
+ */
+
+import { ValidationError } from "../Data/validate";
+import { StorageUnit, UnitCommitmentScenario } from "../Data/types";
+import {
+  assertBusesNotEmpty,
+  changeData,
+  generateUniqueName,
+  renameItemInObject,
+} from "./commonOps";
+import { StorageUnitsColumnSpec } from "../../components/CaseBuilder/StorageUnits";
+
+export const createStorageUnit = (
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const err = assertBusesNotEmpty(scenario);
+  if (err) return [scenario, err];
+  const busName = Object.keys(scenario.Buses)[0]!;
+  const name = generateUniqueName(scenario["Storage units"], "su");
+  return [
+    {
+      ...scenario,
+      "Storage units": {
+        ...scenario["Storage units"],
+        [name]: {
+          Bus: busName,
+          "Minimum level (MWh)": 0,
+          "Maximum level (MWh)": 1,
+          "Charge cost ($/MW)": 0.0,
+          "Discharge cost ($/MW)": 0.0,
+          "Charge efficiency": 1,
+          "Discharge efficiency": 1,
+          "Loss factor": 0,
+          "Minimum charge rate (MW)": 1,
+          "Maximum charge rate (MW)": 1,
+          "Minimum discharge rate (MW)": 1,
+          "Maximum discharge rate (MW)": 1,
+          "Initial level (MWh)": 0,
+          "Last period minimum level (MWh)": 0,
+          "Last period maximum level (MWh)": 1,
+        },
+      },
+    },
+    null,
+  ];
+};
+
+export const renameStorageUnit = (
+  oldName: string,
+  newName: string,
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const [newObj, err] = renameItemInObject(
+    oldName,
+    newName,
+    scenario["Storage units"],
+  );
+  if (err) return [scenario, err];
+  return [{ ...scenario, "Storage units": newObj }, null];
+};
+
+export const changeStorageUnitData = (
+  name: string,
+  field: string,
+  newValueStr: string,
+  scenario: UnitCommitmentScenario,
+): [UnitCommitmentScenario, ValidationError | null] => {
+  const [newObj, err] = changeData(
+    field,
+    newValueStr,
+    scenario["Storage units"][name]!,
+    StorageUnitsColumnSpec,
+    scenario,
+  );
+  if (err) return [scenario, err];
+  return [
+    {
+      ...scenario,
+      "Storage units": {
+        ...scenario["Storage units"],
+        [name]: newObj as StorageUnit,
+      },
+    },
+    null,
+  ];
+};
+
+export const deleteStorageUnit = (
+  name: string,
+  scenario: UnitCommitmentScenario,
+): UnitCommitmentScenario => {
+  const { [name]: _, ...newContainer } = scenario["Storage units"];
+  return { ...scenario, "Storage units": newContainer };
+};

web/src/core/Operations/transmissionOps.test.ts

@@ -10,6 +10,8 @@ import {
   changeTransmissionLineData,
   createTransmissionLine,
   deleteTransmissionLine,
+  getContingencyTransmissionLines,
+  rebuildContingencies,
   renameTransmissionLine,
 } from "./transmissionOps";
 import { ValidationError } from "../Data/validate";
@@ -32,6 +34,12 @@ test("renameTransmissionLine", () => {
     "Emergency flow limit (MW)": 20000.0,
     "Flow limit penalty ($/MW)": 5000.0,
   });
+  assert.deepEqual(newScenario["Contingencies"], {
+    l3: {
+      "Affected lines": ["l3"],
+      "Affected generators": [],
+    },
+  });
   assert.equal(Object.keys(newScenario["Transmission lines"]).length, 1);
 });
 
@@ -72,4 +80,23 @@ test("changeTransmissionLineData", () => {
 test("deleteTransmissionLine", () => {
   const newScenario = deleteTransmissionLine("l1", TEST_DATA_1);
   assert.equal(Object.keys(newScenario["Transmission lines"]).length, 0);
+  assert.equal(Object.keys(newScenario["Contingencies"]).length, 0);
+});
+
+test("getContingencyTransmissionLines", () => {
+  const contLines = getContingencyTransmissionLines(TEST_DATA_1);
+  assert.deepEqual(contLines, new Set(["l1"]));
+});
+
+test("rebuildContingencies", () => {
+  assert.deepEqual(rebuildContingencies(new Set(["l1", "l2"])), {
+    l1: {
+      "Affected lines": ["l1"],
+      "Affected generators": [],
+    },
+    l2: {
+      "Affected lines": ["l2"],
+      "Affected generators": [],
+    },
+  });
 });

web/src/core/Operations/transmissionOps.ts

@@ -8,11 +8,16 @@ import {
   assertBusesNotEmpty,
   changeData,
   generateUniqueName,
+  parseBool,
   renameItemInObject,
 } from "./commonOps";
 import { ValidationError } from "../Data/validate";
 import { TransmissionLinesColumnSpec } from "../../components/CaseBuilder/TransmissionLines";
-import { TransmissionLine, UnitCommitmentScenario } from "../Data/types";
+import {
+  Contingency,
+  TransmissionLine,
+  UnitCommitmentScenario,
+} from "../Data/types";
 
 export const createTransmissionLine = (
   scenario: UnitCommitmentScenario,
@@ -51,7 +56,24 @@ export const renameTransmissionLine = (
     scenario["Transmission lines"],
   );
   if (err) return [scenario, err];
-  return [{ ...scenario, "Transmission lines": newLine }, null];
+
+  // Update transmission line contingencies
+  let newContingencies = scenario["Contingencies"];
+  const contingencyLines = getContingencyTransmissionLines(scenario);
+  if (contingencyLines.has(oldName)) {
+    contingencyLines.delete(oldName);
+    contingencyLines.add(newName);
+    newContingencies = rebuildContingencies(contingencyLines);
+  }
+
+  return [
+    {
+      ...scenario,
+      "Transmission lines": newLine,
+      Contingencies: newContingencies,
+    },
+    null,
+  ];
 };
 
 export const changeTransmissionLineData = (
@@ -60,24 +82,38 @@ export const changeTransmissionLineData = (
   newValueStr: string,
   scenario: UnitCommitmentScenario,
 ): [UnitCommitmentScenario, ValidationError | null] => {
-  const [newLine, err] = changeData(
-    field,
-    newValueStr,
-    scenario["Transmission lines"][line]!,
-    TransmissionLinesColumnSpec,
-    scenario,
-  );
-  if (err) return [scenario, err];
-  return [
-    {
-      ...scenario,
-      "Transmission lines": {
-        ...scenario["Transmission lines"],
-        [line]: newLine as TransmissionLine,
+  if (field === "Contingency?") {
+    // Parse boolean value
+    const [newValue, err] = parseBool(newValueStr);
+    if (err) return [scenario, err];
+
+    // Rebuild contingencies
+    const contLines = getContingencyTransmissionLines(scenario);
+    if (newValue) contLines.add(line);
+    else contLines.delete(line);
+    const newContingencies = rebuildContingencies(contLines);
+
+    return [{ ...scenario, Contingencies: newContingencies }, null];
+  } else {
+    const [newLine, err] = changeData(
+      field,
+      newValueStr,
+      scenario["Transmission lines"][line]!,
+      TransmissionLinesColumnSpec,
+      scenario,
+    );
+    if (err) return [scenario, err];
+    return [
+      {
+        ...scenario,
+        "Transmission lines": {
+          ...scenario["Transmission lines"],
+          [line]: newLine as TransmissionLine,
+        },
       },
-    },
-    null,
-  ];
+      null,
+    ];
+  }
 };
 
 export const deleteTransmissionLine = (
@@ -85,5 +121,43 @@ export const deleteTransmissionLine = (
   scenario: UnitCommitmentScenario,
 ): UnitCommitmentScenario => {
   const { [name]: _, ...newLines } = scenario["Transmission lines"];
-  return { ...scenario, "Transmission lines": newLines };
+
+  // Update transmission line contingencies
+  let newContingencies = scenario["Contingencies"];
+  const contingencyLines = getContingencyTransmissionLines(scenario);
+  if (contingencyLines.has(name)) {
+    contingencyLines.delete(name);
+    newContingencies = rebuildContingencies(contingencyLines);
+  }
+
+  return {
+    ...scenario,
+    "Transmission lines": newLines,
+    Contingencies: newContingencies,
+  };
+};
+
+export const getContingencyTransmissionLines = (
+  scenario: UnitCommitmentScenario,
+): Set<String> => {
+  let result: Set<String> = new Set();
+  Object.entries(scenario.Contingencies).forEach(([name, contingency]) => {
+    if (contingency["Affected lines"].length !== 1)
+      throw Error("not implemented");
+    result.add(contingency["Affected lines"][0]!!);
+  });
+  return result;
+};
+
+export const rebuildContingencies = (
+  contingencyLines: Set<String>,
+): { [name: string]: Contingency } => {
+  const result: { [name: string]: Contingency } = {};
+  contingencyLines.forEach((lineName) => {
+    result[lineName as string] = {
+      "Affected lines": [lineName as string],
+      "Affected generators": [],
+    };
+  });
+  return result;
 };