Create energy balance throughout the year plot

staadecker · staadecker · commit 6ed6a8f2f93d · 2023-01-27T23:39:03.000-06:00
diff --git a/switch_model/balancing/load_zones.py b/switch_model/balancing/load_zones.py
@@ -286,9 +286,9 @@ def get_component_per_year(m, z, p, component):
 @graph(
     "energy_balance_duals",
     title="Energy balance duals per period",
-    note="Note: Outliers and zero-valued duals are ignored."
+    note="Note: Outliers and zero-valued duals are ignored.",
 )
-def graph(tools):
+def graph_energy_balance(tools):
     load_balance = tools.get_dataframe("load_balance.csv")
     load_balance = tools.transform.timestamp(load_balance)
     load_balance["energy_balance_duals"] = (
@@ -303,22 +303,50 @@ def graph(tools):
     # Don't include the zero-valued duals
     load_balance = load_balance.replace(0, tools.np.nan)
     if load_balance.count().sum() != 0:
-<<<<<<< HEAD
-        ax = tools.get_axes(
-            "energy_balance_duals",
-            title="Energy balance duals per period",
-            note="Note: Outliers and zero-valued duals are ignored.",
-        )
         load_balance.plot.box(
-            ax=ax,
+            ax=tools.get_axes(),
             xlabel="Period",
             ylabel="Energy balance duals (cents/kWh)",
             showfliers=False,
-=======
-        load_balance.plot.box(
-            ax=tools.get_axes(),
-            xlabel='Period',
-            ylabel='Energy balance duals (cents/kWh)',
-            showfliers=False
->>>>>>> b3590fdb (Redesign graphing API)
         )
+
+
+@graph("daily_demand", title="Total daily demand", supports_multi_scenario=True)
+def demand(tools):
+    df = tools.get_dataframe("loads.csv", from_inputs=True, drop_scenario_info=False)
+    df = df.groupby(["TIMEPOINT", "scenario_name"], as_index=False).sum()
+    df = tools.transform.timestamp(df, key_col="TIMEPOINT", use_timepoint=True)
+    df = df.groupby(
+        ["season", "hour", "scenario_name", "time_row"], as_index=False
+    ).mean()
+    df["zone_demand_mw"] /= 1e3
+    pn = tools.pn
+
+    plot = (
+        pn.ggplot(df)
+        + pn.geom_line(pn.aes(x="hour", y="zone_demand_mw", color="scenario_name"))
+        + pn.facet_grid("time_row ~ season")
+        + pn.labs(x="Hour (PST)", y="Demand (GW)", color="Scenario")
+    )
+    tools.save_figure(plot.draw())
+
+
+@graph("demand", title="Total demand", supports_multi_scenario=True)
+def yearly_demand(tools):
+    df = tools.get_dataframe("loads.csv", from_inputs=True, drop_scenario_info=False)
+    df = df.groupby(["TIMEPOINT", "scenario_name"], as_index=False).sum()
+    df = tools.transform.timestamp(df, key_col="TIMEPOINT", use_timepoint=True)
+    df["zone_demand_mw"] *= df["tp_duration"] / 1e3
+    df["day"] = df["datetime"].dt.day_of_year
+    df = df.groupby(["day", "scenario_name", "time_row"], as_index=False)[
+        "zone_demand_mw"
+    ].sum()
+    pn = tools.pn
+
+    plot = (
+        pn.ggplot(df)
+        + pn.geom_line(pn.aes(x="day", y="zone_demand_mw", color="scenario_name"))
+        + pn.facet_grid("time_row ~ .")
+        + pn.labs(x="Day of Year", y="Demand (GW)", color="Scenario")
+    )
+    tools.save_figure(plot.draw())
diff --git a/switch_model/generators/core/dispatch.py b/switch_model/generators/core/dispatch.py
@@ -788,29 +788,114 @@ def graph_total_dispatch(tools):
 
     tools.bar_label()
 
-@graph("energy_balance", title="Annual Contributions to the energy balance")
+@graph(
+    "energy_balance",
+    title="Energy Balance For Every Month",
+    supports_multi_scenario=True,
+    is_long=True
+)
 def energy_balance(tools):
-    load = tools.get_dataframe("load_balance_annual.csv").set_index("period")
-    load.loc["total", :] = load.sum()
-    load = load.rename(
-        {
-            "zone_demand_mw": "Demand",
-            "ZoneTotalCentralDispatch": "Generation (incl. storage discharge)",
-            "TXPowerNet": "Transmission Losses",
-            "StorageNetCharge": "Storage Charging"
-        }, axis=1
-    ).sort_values(axis=1, by="total")
-    load = load.drop("total", axis=0)
-
-    load /= 1e6  # Convert to TWh
-    load.plot(
-        kind="bar",
-        ax=tools.get_axes(),
-        ylabel="Annual Contribution to Energy Balance (TWh)",
-        xlabel="Period"
-    )
+    # Get dispatch dataframe
+    cols = ["timestamp", "gen_tech", "gen_energy_source", "DispatchGen_MW", "scenario_name", "scenario_index"]
+    df = tools.get_dataframe("dispatch.csv", drop_scenario_info=False)[cols]
+    df = tools.transform.gen_type(df)
+    # Sum dispatch across all the projects of the same type and timepoint
+    df = df.groupby(["timestamp", "gen_type", "scenario_name", "scenario_index"], as_index=False).sum()
+    df = df.rename({"gen_type": "Type", "DispatchGen_MW": "value"}, axis=1)
+
+    discharge = df[df["Type"] == "Storage"].drop("Type", axis=1).rename({"value": "discharge"}, axis=1)
+
+    # Get load dataframe
+    load = tools.get_dataframe("load_balance.csv", drop_scenario_info=False)
+    load = load.drop("normalized_energy_balance_duals_dollar_per_mwh", axis=1)
+
+    # Sum load across all the load zones
+    key_columns = ["timestamp", "scenario_name", "scenario_index"]
+    load = load.groupby(key_columns, as_index=False).sum()
+
+    # Subtract storage dispatch from generation and add it to the storage charge to get net flow
+    load = load.merge(
+        discharge,
+        how="left",
+        on=key_columns,
+        validate="one_to_one"
+    )
+    load["ZoneTotalCentralDispatch"] -= load["discharge"]
+    load["StorageNetCharge"] += load["discharge"]
+    load = load.drop("discharge", axis=1)
+
+    # Rename and convert from wide to long format
+    load = load.rename({
+        "ZoneTotalCentralDispatch": "Total Generation (excl. storage discharge)",
+        "TXPowerNet": "Transmission Losses",
+        "StorageNetCharge": "Storage Net Flow",
+        "zone_demand_mw": "Demand",
+    }, axis=1).sort_index(axis=1)
+    load = load.melt(id_vars=key_columns, var_name="Type")
+
+    # Merge dispatch contributions with load contributions
+    df = pd.concat([load, df])
+
+    # Add the timestamp information and make period string to ensure it doesn't mess up the graphing
+    df = tools.transform.timestamp(df).astype({"period": str})
+
+    # Convert to TWh (incl. multiply by timepoint duration)
+    df["value"] *= df["tp_duration"] / 1e6
+
+    FREQUENCY = "1W"
+
+    def groupby_time(df):
+        return df.groupby(
+            ["scenario_name", "period", "Type", tools.pd.Grouper(key="datetime", freq=FREQUENCY, origin="start")])[
+            "value"]
+
+    df = groupby_time(df).sum().reset_index()
+
+    # Get the state of charge data
+    soc = tools.get_dataframe("StateOfCharge.csv", dtype={"STORAGE_GEN_TPS_1": str}, drop_scenario_info=False)
+    soc = soc.rename({"STORAGE_GEN_TPS_2": "timepoint", "StateOfCharge": "value"}, axis=1)
+    # Sum over all the projects that are in the same scenario with the same timepoint
+    soc = soc.groupby(["timepoint", "scenario_name"], as_index=False).sum()
+    soc["Type"] = "State Of Charge"
+    soc["value"] /= 1e6  # Convert to TWh
+
+    # Group by time
+    soc = tools.transform.timestamp(soc, use_timepoint=True, key_col="timepoint").astype({"period": str})
+    soc = groupby_time(soc).mean().reset_index()
+
+    # Add state of charge to dataframe
+    df = pd.concat([df, soc])
+    # Add column for day since that's what we really care about
+    df["day"] = df["datetime"].dt.dayofyear
 
-    tools.bar_label()
+    # Plot
+    # Get the colors for the lines
+    colors = tools.get_colors()
+    colors.update({
+        "Transmission Losses": "brown",
+        "Storage Net Flow": "cadetblue",
+        "Demand": "black",
+        "Total Generation (excl. storage discharge)": "black",
+        "State Of Charge": "green"
+    })
+
+    # plot
+    num_periods = df["period"].nunique()
+    pn = tools.pn
+    plot = pn.ggplot(df) + \
+           pn.geom_line(pn.aes(x="day", y="value", color="Type")) + \
+           pn.facet_grid("period ~ scenario_name") + \
+           pn.labs(y="Contribution to Energy Balance (TWh)") + \
+           pn.scales.scale_color_manual(values=colors, aesthetics="color", na_value=colors["Other"]) + \
+           pn.scales.scale_x_continuous(
+               name="Month",
+               labels=["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+               breaks=(15, 46, 76, 106, 137, 167, 198, 228, 259, 289, 319, 350),
+               limits=(0, 366)) + \
+           pn.theme(
+               figure_size=(pn.options.figure_size[0] * tools.num_scenarios, pn.options.figure_size[1] * num_periods))
+
+    tools.save_figure(plot.draw())
 
 @graph(
     "curtailment_per_period",
diff --git a/switch_model/generators/extensions/storage.py b/switch_model/generators/extensions/storage.py
@@ -523,7 +523,7 @@ def graph_state_of_charge(tools):
         "StateOfCharge"
     ].sum()
     # Add datetime information
-    df = tools.transform.timestamp(df, timestamp_col="timepoint")
+    df = tools.transform.timestamp(df, key_col="timepoint")
     # Count num rows
     num_periods = len(df["period"].unique())
 
@@ -591,7 +591,7 @@ def graph_state_of_charge_per_duration(tools):
     df = tools.get_dataframe("storage_dispatch")[
         ["generation_project", "timepoint", "StateOfCharge", "scenario_name"]
     ]
-    df = tools.transform.timestamp(df, timestamp_col="timepoint")
+    df = tools.transform.timestamp(df, key_col="timepoint")
 
     # Add the capacity information to the state of charge information
     df = df.merge(
@@ -631,7 +631,7 @@ def graph_dispatch_cycles(tools):
     # Aggregate by timepoint
     df = df.groupby("timepoint", as_index=False).sum()
     # Add datetime column
-    df = tools.transform.timestamp(df, timestamp_col="timepoint")
+    df = tools.transform.timestamp(df, key_col="timepoint")
     # Find charge in GWh
     df["StateOfCharge"] /= 1e3
 
diff --git a/switch_model/tools/graph/main.py b/switch_model/tools/graph/main.py
@@ -148,6 +148,7 @@ def gen_type(
         map_name="default",
         gen_tech_col="gen_tech",
         energy_source_col="gen_energy_source",
+        drop_previous_col=True,
     ):
         """
         Returns a dataframe that contains a column 'gen_type'.
@@ -157,11 +158,17 @@ def gen_type(
         """
         # If there's no mapping, we simply make the mapping the sum of both columns
         # Read the tech_colors and tech_types csv files.
-        df = df.copy()  # Don't edit the original
         try:
+            cols = [
+                "map_name",
+                "gen_type",
+                "gen_tech",
+                "energy_source",
+                "scenario_index",
+            ]
             tech_types = self.tools.get_dataframe(
-                "graph_tech_types.csv", from_inputs=True
-            )
+                "graph_tech_types.csv", from_inputs=True, drop_scenario_info=False
+            )[cols]
         except FileNotFoundError:
             df["gen_type"] = df[gen_tech_col] + "_" + df[energy_source_col]
             return df
@@ -172,9 +179,9 @@ def gen_type(
         # we want to merge by scenario
         left_on = [gen_tech_col, energy_source_col]
         right_on = ["gen_tech", "energy_source"]
-        if "scenario_name" in tech_types:
-            left_on.append("scenario_name")
-            right_on.append("scenario_name")
+        if "scenario_index" in df:
+            left_on.append("scenario_index")
+            right_on.append("scenario_index")
         df = df.merge(
             tech_types,
             left_on=left_on,
@@ -185,6 +192,8 @@ def gen_type(
         df["gen_type"] = df["gen_type"].fillna(
             "Other"
         )  # Fill with Other so the colors still work
+        if drop_previous_col:
+            df = df.drop([gen_tech_col, energy_source_col], axis=1)
         return df
 
     def build_year(self, df, build_year_col="build_year"):
@@ -203,7 +212,7 @@ def build_year(self, df, build_year_col="build_year"):
         )
         return df
 
-    def timestamp(self, df, timestamp_col="timestamp"):
+    def timestamp(self, df, key_col="timestamp", use_timepoint=False):
         """
         Adds the following columns to the dataframe:
         - time_row: by default the period but can be overridden by graph_timestamp_map.csv
@@ -226,17 +235,34 @@ def timestamp(self, df, timestamp_col="timestamp"):
             validate="many_to_one",
         )
         timestamp_mapping = timepoints[
-            ["timestamp", "ts_period", "timeseries"]
+            [
+                "timepoint_id",
+                "timestamp",
+                "ts_period",
+                "timeseries",
+                "ts_duration_of_tp",
+            ]
         ].drop_duplicates()
-        timestamp_mapping = timestamp_mapping.rename({"ts_period": "period"}, axis=1)
+        timestamp_mapping = timestamp_mapping.rename(
+            {
+                "ts_period": "period",
+                "timepoint_id": "timepoint",
+                "ts_duration_of_tp": "tp_duration",
+            },
+            axis=1,
+        )
         timestamp_mapping = timestamp_mapping.astype({"period": "category"})
 
-        df = df.rename({timestamp_col: "timestamp"}, axis=1)
-        df = df.merge(
-            timestamp_mapping,
-            how="left",
-            on="timestamp",
-        )
+        if use_timepoint:
+            df = df.rename({key_col: "timepoint"}, axis=1)
+            df = df.merge(timestamp_mapping, how="left", on="timepoint")
+        else:
+            df = df.rename({key_col: "timestamp"}, axis=1)
+            df = df.merge(
+                timestamp_mapping,
+                how="left",
+                on="timestamp",
+            )
 
         try:
             # TODO support using graph_timestamp_map on multiple scenarios
@@ -258,6 +284,8 @@ def timestamp(self, df, timestamp_col="timestamp"):
             .dt.tz_convert(self.time_zone)
         )
         df["hour"] = df["datetime"].dt.hour
+        season_map = {1: "Winter", 2: "Spring", 3: "Summer", 4: "Fall"}
+        df["season"] = df["datetime"].dt.quarter.apply(lambda x: season_map[x])
 
         return df
 
@@ -515,6 +543,8 @@ def _load_dataframe(self, path, dtype=None, **kwargs) -> pd.DataFrame:
                 index_col=False,
                 # Fix: force the datatype to str for some columns to avoid warnings of mismatched types
                 dtype=dtype,
+                sep=",",
+                engine="c",
                 **kwargs,
             )
             df["scenario_name"] = scenario.name
