Change 1000 to 1e3

Author: staadecker

switch_model/generators/core/dispatch.py

@@ -618,7 +618,7 @@ def graph_hourly_dispatch(tools):
     # Read dispatch.csv
     df = tools.get_dataframe("dispatch.csv")
     # Convert to GW
-    df["DispatchGen_MW"] /= 1000
+    df["DispatchGen_MW"] /= 1e3
     # Plot Dispatch
     tools.graph_time_matrix(
         df,
@@ -710,7 +710,7 @@ def graph_hourly_curtailment(tools):
 >>>>>>> b3590fdb (Redesign graphing API)
     # Keep only renewable
     df = df[df["is_renewable"]]
-    df["Curtailment_MW"] /= 1e3
+    df["Curtailment_MW"] /= 1e3  # Convert to GW
     tools.graph_scenario_matrix(
         df,
 <<<<<<< HEAD

switch_model/generators/extensions/storage.py

@@ -514,73 +514,48 @@ def post_solve(instance, outdir):
 @graph(
     "state_of_charge",
     title="State of Charge Throughout the Year",
-    supports_multi_scenario=True
+    supports_multi_scenario=True,
 )
 def graph_state_of_charge(tools):
     # Get the total state of charge per timepoint and scenario
-<<<<<<< HEAD
-    df = tools.get_dataframe("storage_dispatch", all_scenarios=True)
+    df = tools.get_dataframe("storage_dispatch")
     df = df.groupby(["timepoint", "scenario_name"], as_index=False)[
         "StateOfCharge"
     ].sum()
-=======
-    df = tools.get_dataframe("storage_dispatch")
-    df = df.groupby(["timepoint", "scenario_name"], as_index=False)["StateOfCharge"].sum()
->>>>>>> b3590fdb (Redesign graphing API)
     # Add datetime information
     df = tools.transform.timestamp(df, timestamp_col="timepoint")
     # Count num rows
     num_periods = len(df["period"].unique())
 
     # Get the total capacity per period and scenario
-<<<<<<< HEAD
-    capacity = tools.get_dataframe("storage_capacity.csv", all_scenarios=True)
+    capacity = tools.get_dataframe("storage_capacity.csv")
     capacity = capacity.groupby(["period", "scenario_name"], as_index=False)[
         "OnlineEnergyCapacityMWh"
     ].sum()
-=======
-    capacity = tools.get_dataframe("storage_capacity.csv")
-    capacity = capacity.groupby(["period", "scenario_name"], as_index=False)["OnlineEnergyCapacityMWh"].sum()
->>>>>>> b3590fdb (Redesign graphing API)
 
     # Add the capacity to our dataframe
     df = df.merge(
         capacity, on=["period", "scenario_name"], validate="many_to_one", how="left"
     )
 
     # Convert values to GWh
-    df["StateOfCharge"] = df["StateOfCharge"] / 1000
-    df["OnlineEnergyCapacityMWh"] /= 1000
+    df["StateOfCharge"] /= 1e3
+    df["OnlineEnergyCapacityMWh"] /= 1e3
 
     # Plot with plotnine
     pn = tools.pn
-<<<<<<< HEAD
     plot = (
         pn.ggplot(df, pn.aes(x="datetime", y="StateOfCharge"))
         + pn.geom_line()
-        + pn.labs(
-            y="State of Charge (GWh)",
-            x="Time of Year",
-            title="State of Charge Throughout the Year",
-        )
+        + pn.labs(y="State of Charge (GWh)", x="Time of Year")
         + pn.geom_hline(
             pn.aes(yintercept="OnlineEnergyCapacityMWh"),
             linetype="dashed",
             color="blue",
         )
     )
 
-    tools.save_figure(
-        "state_of_charge", by_scenario_and_period(tools, plot, num_periods).draw()
-    )
-=======
-    plot = pn.ggplot(df, pn.aes(x="datetime", y="StateOfCharge")) \
-           + pn.geom_line() \
-           + pn.labs(y="State of Charge (GWh)", x="Time of Year") \
-           + pn.geom_hline(pn.aes(yintercept="OnlineEnergyCapacityMWh"), linetype="dashed", color='blue')
-
     tools.save_figure(by_scenario_and_period(tools, plot, num_periods).draw())
->>>>>>> b3590fdb (Redesign graphing API)
 
 
 @graph(
@@ -590,30 +565,20 @@ def graph_state_of_charge(tools):
 )
 def graph_state_of_charge_per_duration(tools):
     # Read the capacity of each project and label they by duration
-<<<<<<< HEAD
-    capacity = tools.get_dataframe("storage_capacity.csv", all_scenarios=True)
+    capacity = tools.get_dataframe("storage_capacity.csv")
     capacity["duration"] = (
         capacity["OnlineEnergyCapacityMWh"] / capacity["OnlinePowerCapacityMW"]
     )
-=======
-    capacity = tools.get_dataframe("storage_capacity.csv")
-    capacity["duration"] = capacity["OnlineEnergyCapacityMWh"] / capacity["OnlinePowerCapacityMW"]
->>>>>>> b3590fdb (Redesign graphing API)
     capacity["duration"] = tools.pd.cut(
         capacity["duration"],
         bins=(0, 10, 25, 300, 365),
         precision=0,
     )
 
     # Get the total state of charge at each timepoint for each project
-<<<<<<< HEAD
-    df = tools.get_dataframe("storage_dispatch", all_scenarios=True)[
+    df = tools.get_dataframe("storage_dispatch")[
         ["generation_project", "timepoint", "StateOfCharge", "scenario_name"]
     ]
-=======
-    df = tools.get_dataframe("storage_dispatch")[
-        ["generation_project", "timepoint", "StateOfCharge", "scenario_name"]]
->>>>>>> b3590fdb (Redesign graphing API)
     df = tools.transform.timestamp(df, timestamp_col="timepoint")
 
     # Add the capacity information to the state of charge information
@@ -627,35 +592,21 @@ def graph_state_of_charge_per_duration(tools):
         ["duration", "scenario_name", "datetime", "period"], as_index=False
     )[["StateOfCharge", "OnlineEnergyCapacityMWh"]].sum()
     # Convert to GWh
-    df["StateOfCharge"] /= 1000
+    df["StateOfCharge"] /= 1e3
 
     # Plot with plotnine
     pn = tools.pn
-<<<<<<< HEAD
     plot = (
         pn.ggplot(df, pn.aes(x="datetime", y="StateOfCharge", color="duration"))
         + pn.geom_line(alpha=0.5)
         + pn.labs(
-            y="State of Charge (GWh)",
-            x="Time of Year",
-            title="State of Charge Throughout the Year by Duration",
-            color="Storage Duration (h)",
+            y="State of Charge (GWh)", x="Time of Year", color="Storage Duration (h)"
         )
     )
 
     tools.save_figure(
-        "state_of_charge_per_duration",
-        by_scenario_and_period(tools, plot, len(df["period"].unique())).draw(),
+        by_scenario_and_period(tools, plot, len(df["period"].unique())).draw()
     )
-=======
-    plot = pn.ggplot(df, pn.aes(x="datetime", y="StateOfCharge", color="duration")) \
-           + pn.geom_line(alpha=0.5) \
-           + pn.labs(y="State of Charge (GWh)",
-                     x="Time of Year",
-                     color="Storage Duration (h)")
-
-    tools.save_figure(by_scenario_and_period(tools, plot, len(df["period"].unique())).draw())
->>>>>>> b3590fdb (Redesign graphing API)
 
 
 @graph(
@@ -668,12 +619,12 @@ def graph_dispatch_cycles(tools):
     # Add datetime column
     df = tools.transform.timestamp(df, timestamp_col="timepoint")
     # Find charge in GWh
-    df["charge"] = df["StateOfCharge"] / 1000
+    df["StateOfCharge"] /= 1e3
 
     # Storage Frequency graph
     df = df.set_index("datetime")
     df = df.sort_index()
-    charge = df["charge"].values
+    charge = df["StateOfCharge"].values
     # TODO don't hardcode
     timestep = (df.index[1] - df.index[0]).seconds / 3600
     N = len(charge)
@@ -692,37 +643,28 @@ def graph_dispatch_cycles(tools):
     ax.set_xlabel("Cycles per hour")
 
     # Plot
-<<<<<<< HEAD
     ax = tools.get_axes(
         "storage_dispatch_cycle_duration",
         title="Storage cycle duration based on fourier transform" " of state of charge",
     )
-=======
-    ax = tools.get_axes("storage_dispatch_cycle_duration",
-                        title="Storage cycle duration based on fourier transform"
-                              " of state of charge")
->>>>>>> b3590fdb (Redesign graphing API)
     ax.semilogx(1 / xfreq, yfreq)
     ax.set_xlabel("Hours per cycle")
     ax.grid(True, which="both", axis="x")
 
 
-@graph(
-    "graph_buildout",
-    supports_multi_scenario=True
-)
+@graph("graph_buildout", supports_multi_scenario=True)
 def graph_buildout(tools):
     """
     Create graphs relating to the storage that has been built
     """
     df = tools.get_dataframe("storage_builds.csv")
     df = tools.transform.load_zone(df)
-    df["power"] = df["IncrementalPowerCapacityMW"] / 1000
     # Filter out rows where there's no power built
-    df = df[df["power"] != 0]
+    df = df[df["IncrementalPowerCapacityMW"] != 0]
     df["duration"] = (
         df["IncrementalEnergyCapacityMWh"] / df["IncrementalPowerCapacityMW"]
     )
+    df["power"] = df["IncrementalPowerCapacityMW"] / 1e3
     df = tools.transform.build_year(df)
     pn = tools.pn
     num_regions = len(df["region"].unique())
@@ -737,16 +679,11 @@ def graph_buildout(tools):
         )
     )
 
-<<<<<<< HEAD
-    tools.save_figure("storage_duration", by_scenario(tools, plot).draw())
+    tools.save_figure(by_scenario(tools, plot).draw(), "storage_duration")
     tools.save_figure(
-        "storage_duration_by_region",
         by_scenario_and_region(tools, plot, num_regions).draw(),
+        "storage_duration_by_region",
     )
-=======
-    tools.save_figure(by_scenario(tools, plot).draw(), "storage_duration")
-    tools.save_figure(by_scenario_and_region(tools, plot, num_regions).draw(), "storage_duration_by_region")
->>>>>>> b3590fdb (Redesign graphing API)
 
     plot = (
         pn.ggplot(df, pn.aes(x="duration"))
@@ -758,16 +695,11 @@ def graph_buildout(tools):
         )
     )
 
-<<<<<<< HEAD
-    tools.save_figure("storage_duration_histogram", by_scenario(tools, plot).draw())
+    tools.save_figure(by_scenario(tools, plot).draw(), "storage_duration_histogram")
     tools.save_figure(
-        "storage_duration_histogram_by_region",
         by_scenario_and_region(tools, plot, num_regions).draw(),
+        "storage_duration_histogram_by_region",
     )
-=======
-    tools.save_figure(by_scenario(tools, plot).draw(), "storage_duration_histogram")
-    tools.save_figure(by_scenario_and_region(tools, plot, num_regions).draw(), "storage_duration_histogram_by_region")
->>>>>>> b3590fdb (Redesign graphing API)
 
 
 def by_scenario(tools, plot):