Merge pull request #86 from staadecker/improve-plots

More plot improvements

Author: pesap

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())

switch_model/generators/core/build.py

@@ -720,22 +720,7 @@ def post_solve(m, outdir):
     )
 
 
-<<<<<<< HEAD
-def graph(tools):
-    graph_capacity(tools)
-    graph_buildout_per_tech(tools)
-
-
-def compare(tools):
-    graph_buildout(tools)
-
-
-=======
-@graph(
-    "generation_capacity_per_period",
-    title="Online Generation Capacity Per Period"
-)
->>>>>>> b3590fdb (Redesign graphing API)
+@graph("generation_capacity_per_period", title="Online Generation Capacity Per Period")
 def graph_capacity(tools):
     # Load gen_cap.csv
     gen_cap = tools.get_dataframe("gen_cap.csv")
@@ -768,33 +753,25 @@ def graph_capacity(tools):
 
     # Plot
     # Get a new set of axis to create a breakdown of the generation capacity
-<<<<<<< HEAD
-    ax = tools.get_axes(
-        out="generation_capacity_per_period",
-        title="Online generating capacity by period",
-    )
     capacity_df.plot(
         kind="bar",
-        ax=ax,
-=======
-    capacity_df.plot(
-        kind='bar',
         ax=tools.get_axes(),
->>>>>>> b3590fdb (Redesign graphing API)
         stacked=True,
         ylabel="Capacity Online (GW)",
         xlabel="Period",
         color=tools.get_colors(len(capacity_df.index)),
     )
 
+    tools.bar_label()
+
 
 @graph(
     "buildout_gen_per_period",
     title="Built Capacity per Period",
-    supports_multi_scenario=True
+    supports_multi_scenario=True,
 )
 def graph_buildout(tools):
-    build_gen = tools.get_dataframe("BuildGen.csv")
+    build_gen = tools.get_dataframe("BuildGen.csv", dtype={"GEN_BLD_YRS_1": str})
     build_gen = build_gen.rename(
         {
             "GEN_BLD_YRS_1": "GENERATION_PROJECT",
@@ -804,13 +781,7 @@ def graph_buildout(tools):
         axis=1,
     )
     build_gen = tools.transform.build_year(build_gen)
-<<<<<<< HEAD
-    gen = tools.get_dataframe(
-        "generation_projects_info", from_inputs=True, all_scenarios=True
-    )
-=======
     gen = tools.get_dataframe("generation_projects_info", from_inputs=True)
->>>>>>> b3590fdb (Redesign graphing API)
     gen = tools.transform.gen_type(gen)
     gen = gen[["GENERATION_PROJECT", "gen_type", "scenario_name"]]
     build_gen = build_gen.merge(
@@ -845,33 +816,22 @@ def graph_buildout(tools):
 
     # Plot
     # Get a new set of axis to create a breakdown of the generation capacity
-<<<<<<< HEAD
-    ax = tools.get_axes(out="buildout_per_period", title="Built capacity per period")
     build_gen.plot(
         kind="bar",
-        ax=ax,
-=======
-    build_gen.plot(
-        kind='bar',
         ax=tools.get_axes(),
->>>>>>> b3590fdb (Redesign graphing API)
         stacked=True,
         ylabel="Capacity Online (GW)",
         xlabel="Period",
         color=tools.get_colors(len(build_gen.index)),
     )
-<<<<<<< HEAD
-
-=======
->>>>>>> b3590fdb (Redesign graphing API)
 
 
 @graph(
     "gen_buildout_per_tech_period",
     title="Buildout relative to max allowed for period",
     note="\nNote 1: This graph excludes predetermined buildout and projects that have no capacity limit."
-         "\nTechnologies that contain projects with no capacity limit are marked by a * and their graphs may"
-         "be misleading."
+    "\nTechnologies that contain projects with no capacity limit are marked by a * and their graphs may"
+    "be misleading.",
 )
 def graph_buildout_per_tech(tools):
     # Load gen_cap.csv
@@ -920,32 +880,16 @@ def graph_buildout_per_tech(tools):
     # Set the name of the legend.
     df = df.rename_axis("Type", axis="columns")
     # Add a * to tech
-<<<<<<< HEAD
     df = df.rename(
         lambda c: f"{c}*" if c in unlimited_gen_types.values else c, axis="columns"
     )
-    # Get axes to graph on
-    ax = tools.get_axes(
-        out="gen_buildout_per_tech_no_pred",
-        title="Buildout relative to max allowed for period",
-        note="\nNote 1: This graph excludes predetermined buildout and projects that have no capacity limit."
-        "\nTechnologies that contain projects with no capacity limit are marked by a * and their graphs may"
-        "be misleading.",
-    )
-=======
-    df = df.rename(lambda c: f"{c}*" if c in unlimited_gen_types.values else c, axis='columns')
->>>>>>> b3590fdb (Redesign graphing API)
     # Plot
     colors = tools.get_colors()
     if colors is not None:
         # Add the same colors but with a * to support our legend.
         colors.update({f"{k}*": v for k, v in colors.items()})
-<<<<<<< HEAD
-    df.plot(ax=ax, kind="line", color=colors, xlabel="Period", marker="x")
-=======
     ax = tools.get_axes()
-    df.plot(ax=ax, kind='line', color=colors, xlabel='Period', marker="x")
->>>>>>> b3590fdb (Redesign graphing API)
+    df.plot(ax=ax, kind="line", color=colors, xlabel="Period", marker="x")
     # Set the y-axis to use percent
     ax.yaxis.set_major_formatter(tools.mplt.ticker.PercentFormatter(1.0))
     # Horizontal line at 100%

switch_model/generators/core/dispatch.py

@@ -774,7 +774,6 @@ def graph_hourly_curtailment(tools):
 @graph(
     "total_dispatch",
     title="Total dispatched electricity",
-    is_long=True,
 )
 def graph_total_dispatch(tools):
     # ---------------------------------- #
@@ -829,6 +828,134 @@ def graph_total_dispatch(tools):
 >>>>>>> b3590fdb (Redesign graphing API)
     )
 
+    tools.bar_label()
+
+@graph(
+    "energy_balance",
+    title="Energy Balance For Every Month",
+    supports_multi_scenario=True,
+    is_long=True
+)
+def energy_balance(tools):
+    # Get dispatch dataframe
+    cols = ["timestamp", "gen_tech", "gen_energy_source", "DispatchGen_MW", "scenario_name", "scenario_index",
+            "Curtailment_MW"]
+    df = tools.get_dataframe("dispatch.csv", drop_scenario_info=False)[cols]
+    df = tools.transform.gen_type(df)
+
+    # Rename and add needed columns
+    df["Dispatch Limit"] = df["DispatchGen_MW"] + df["Curtailment_MW"]
+    df = df.drop("Curtailment_MW", axis=1)
+    df = df.rename({"DispatchGen_MW": "Dispatch"}, axis=1)
+    # Sum dispatch across all the projects of the same type and timepoint
+    key_columns = ["timestamp", "gen_type", "scenario_name", "scenario_index"]
+    df = df.groupby(key_columns, as_index=False).sum()
+    df = df.melt(id_vars=key_columns, value_vars=["Dispatch", "Dispatch Limit"], var_name="Type")
+    df = df.rename({"gen_type": "Source"}, axis=1)
+
+    discharge = df[(df["Source"] == "Storage") & (df["Type"] == "Dispatch")].drop(["Source", "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="Source")
+    load["Type"] = "Dispatch"
+
+    # 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",
+            "Source",
+            "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["Source"] = "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["Type"] = "Dispatch"
+    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
+
+    # 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="Source", linetype="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.scales.scale_linetype_manual(
+               values={"Dispatch Limit": "dotted", "Dispatch": "solid"}
+           ) + \
+           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",