Merge branch 'add_generation_groups' into improv_hydro

# Conflicts:
#	switch_model/solve.py

Author: staadecker

database/2021-06-15_add_generation_plants_groups.sql

@@ -0,0 +1,63 @@
+/*
+####################
+Add generation plants groups
+
+Date applied:
+Description:
+This script adds the option to specify generation plant groups.
+The generation groups are specified in the table generation_plant_group.
+Plants are assigned to a group by adding them to the many-to-many table generation_plant_group_member.
+Groups are assigned to a generation_plant_scenario_id by specifying them in generation_plant_scenario_group_member
+#################
+*/
+
+CREATE TABLE switch.generation_plant_group
+(
+    generation_plant_group_id serial                NOT NULL,
+    description               text                  NOT NULL,
+    name                      character varying(30) NOT NULL,
+    PRIMARY KEY (generation_plant_group_id)
+);
+
+COMMENT ON TABLE switch.generation_plant_group
+    IS 'This table specifies all the generation plant groups. Every group has a set of generation plants (see generation_plant_group_member). Groups can be assigned to a generation_plant_scenario (see generation_plant_scenario_group_member).';
+
+CREATE TABLE switch.generation_plant_group_member
+(
+    generation_plant_group_id integer,
+    generation_plant_id       integer,
+    PRIMARY KEY (generation_plant_group_id, generation_plant_id)
+);
+
+ALTER TABLE switch.generation_plant_group_member
+    ADD CONSTRAINT generation_plant_group_member_group_id_fkey
+        FOREIGN KEY (generation_plant_group_id)
+            REFERENCES switch.generation_plant_group (generation_plant_group_id);
+
+ALTER TABLE switch.generation_plant_group_member
+    ADD CONSTRAINT generation_plant_group_member_generation_plant_id_fkey
+        FOREIGN KEY (generation_plant_id)
+            REFERENCES switch.generation_plant (generation_plant_id);
+
+COMMENT ON TABLE switch.generation_plant_group_member
+    IS 'This table is a many-to-many table that specifies the generation plants that are associated with a generation group.';
+
+CREATE TABLE switch.generation_plant_scenario_group_member
+(
+    generation_plant_scenario_id integer,
+    generation_plant_group_id    integer,
+    PRIMARY KEY (generation_plant_scenario_id, generation_plant_group_id)
+);
+
+ALTER TABLE switch.generation_plant_scenario_group_member
+    ADD CONSTRAINT generation_plant_scenario_group_member_scenario_id_fkey
+        FOREIGN KEY (generation_plant_scenario_id)
+            REFERENCES switch.generation_plant_scenario (generation_plant_scenario_id);
+
+ALTER TABLE switch.generation_plant_scenario_group_member
+    ADD CONSTRAINT generation_plant_scenario_group_member_group_id_fkey
+        FOREIGN KEY (generation_plant_group_id)
+            REFERENCES switch.generation_plant_group (generation_plant_group_id);
+
+COMMENT ON TABLE switch.generation_plant_scenario_group_member
+    IS 'This table is a many-to-many table that specifies which generation plant groups belong to which generation plant scenarios';

database/2021-06-18_add_gen_store_energy_to_power_ratio.sql

@@ -0,0 +1,13 @@
+/*
+####################
+Add column gen_store_energy_to_power_ratio
+
+Date applied: 2021-06-18
+Description:
+This script adds a column to the generation_plant
+table called gen_storage_energy_to_power_ratio specifying
+the storage duration
+#################
+*/
+
+ALTER TABLE switch.generation_plant ADD COLUMN gen_storage_energy_to_power_ratio real;

switch_model/__main__.py

@@ -4,74 +4,70 @@
 """Script to handle switch <cmd> calls from the command line."""
 from __future__ import print_function
 
-import sys, os
+import argparse
+import importlib
+import sys
 import switch_model
+from switch_model.utilities import get_git_branch
+
+def version():
+    print("Switch model version " + switch_model.__version__)
+    branch = get_git_branch()
+    if branch is not None:
+        print(f"Switch Git branch: {branch}")
+    return 0
+
+def help_text():
+    print(
+        f"Must specifiy one of the following commands: {list(cmds.keys())}.\nE.g. Run 'switch solve' or 'switch get_inputs'.")
+
+
+def get_module_runner(module):
+    def runner():
+        importlib.import_module(module).main()
+    return runner
+
+
+cmds = {
+    "solve": get_module_runner("switch_model.solve"),
+    "solve-scenarios": get_module_runner("switch_model.solve_scenarios"),
+    "test": get_module_runner("switch_model.test"),
+    "upgrade": get_module_runner("switch_model.upgrade"),
+    "get_inputs": get_module_runner("switch_model.wecc.get_inputs"),
+    "drop": get_module_runner("switch_model.tools.drop"),
+    "new": get_module_runner("switch_model.tools.new"),
+    "graph": get_module_runner("switch_model.tools.graph.cli_graph"),
+    "compare": get_module_runner("switch_model.tools.graph.cli_compare"),
+    "db": get_module_runner("switch_model.wecc.__main__"),
+    "help": help_text
+}
 
 
 def main():
-    # TODO make a proper command line tool with help information for each option
-    cmds = [
-        "solve",
-        "solve-scenarios",
-        "test",
-        "upgrade",
-        "get_inputs",
-        "--version",
-        "drop",
-        "new",
-        "graph",
-        "compare",
-        "sampling",
-    ]
-    if len(sys.argv) >= 2 and sys.argv[1] in cmds:
-        # If users run a script from the command line, the location of the script
-        # gets added to the start of sys.path; if they call a module from the
-        # command line then an empty entry gets added to the start of the path,
-        # indicating the current working directory. This module is often called
-        # from a command-line script, but we want the current working
-        # directory in the path because users may try to load local modules via
-        # the configuration files, so we make sure that's always in the path.
-        sys.path[0] = ""
-
-        # adjust the argument list to make it look like someone ran "python -m <module>" directly
-        cmd = sys.argv[1]
-        sys.argv[0] += " " + cmd
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--version", default=False, action="store_true", help="Get version info")
+    parser.add_argument("subcommand", choices=cmds.keys(), help="The possible switch subcommands", nargs="?",
+                        default="help")
+
+    # If users run a script from the command line, the location of the script
+    # gets added to the start of sys.path; if they call a module from the
+    # command line then an empty entry gets added to the start of the path,
+    # indicating the current working directory. This module is often called
+    # from a command-line script, but we want the current working
+    # directory in the path because users may try to load local modules via
+    # the configuration files, so we make sure that's always in the path.
+    sys.path[0] = ""
+
+    args, remaining_args = parser.parse_known_args()
+
+    if args.version:
+        return version()
+
+    # adjust the argument list to make it look like someone ran "python -m <module>" directly
+    if len(sys.argv) > 1:
+        sys.argv[0] += " " + sys.argv[1]
         del sys.argv[1]
-        if cmd == "--version":
-            print("Switch model version " + switch_model.__version__)
-            from switch_model.utilities import get_git_branch
-            branch = get_git_branch()
-            if branch is not None:
-                print(f"Switch Git branch: {branch}")
-            return 0
-        if cmd == "solve":
-            from switch_model.solve import main
-        elif cmd == "solve-scenarios":
-            from switch_model.solve_scenarios import main
-        elif cmd == "test":
-            from switch_model.test import main
-        elif cmd == "upgrade":
-            from switch_model.upgrade import main
-        elif cmd == "get_inputs":
-            from switch_model.wecc.get_inputs import main
-        elif cmd == "sampling":
-            from switch_model.wecc.sampling import main
-        elif cmd == "drop":
-            from switch_model.tools.drop import main
-        elif cmd == "new":
-            from switch_model.tools.new import main
-        elif cmd == "graph":
-            from switch_model.tools.graph.cli_graph import main
-        elif cmd == "compare":
-            from switch_model.tools.graph.cli_compare import main
-        main()
-    else:
-        print(
-            "Usage: {} {{{}}} ...".format(
-                os.path.basename(sys.argv[0]), ", ".join(cmds)
-            )
-        )
-        print("Use one of these commands with --help for more information.")
+    cmds[args.subcommand]()
 
 
 if __name__ == "__main__":

switch_model/generators/core/dispatch.py

@@ -20,6 +20,7 @@
 
 import os, collections
 
+from pyomo.core.base.misc import sorted_robust
 from pyomo.environ import *
 import pandas as pd
 
@@ -403,16 +404,18 @@ def post_solve(instance, outdir):
     dispatch_annual_summary.pdf - A figure of annual summary data. Only written
     if the ggplot python library is installed.
     """
+    sorted_gen = sorted_robust(instance.GENERATION_PROJECTS)
     write_table(
         instance, instance.TIMEPOINTS,
         output_file=os.path.join(outdir, "dispatch-wide.csv"),
-        headings=("timestamp",) + tuple(sorted(instance.GENERATION_PROJECTS)),
+        headings=("timestamp",) + tuple(sorted_gen),
         values=lambda m, t: (m.tp_timestamp[t],) + tuple(
             m.DispatchGen[p, t] if (p, t) in m.GEN_TPS
             else 0.0
-            for p in sorted(m.GENERATION_PROJECTS)
+            for p in sorted_gen
         )
     )
+    del sorted_gen
 
     def c(func):
         return (value(func(g, t)) for g, t in instance.GEN_TPS)

switch_model/reporting/__init__.py

@@ -19,7 +19,9 @@
 
 """
 from __future__ import print_function
-from switch_model.utilities import string_types, add_info
+from pyomo.core.base.misc import sorted_robust
+from switch_model.utilities import string_types
+from switch_model.utilities.results_info import add_info
 from switch_model.utilities.scaling import get_unscaled_var
 dependencies = 'switch_model.financials'
 
@@ -93,7 +95,7 @@ def write_table(instance, *indexes, output_file=None, **kwargs):
         try:
             rows = (format_row(values(instance, *unpack_elements(x)), cell_formatter) for x in
                     itertools.product(*indexes))
-            w.writerows(sorted(rows) if instance.options.sorted_output else rows)
+            w.writerows(sorted_robust(rows) if instance.options.sorted_output else rows)
         except TypeError: # lambda got wrong number of arguments
             # use old code, which doesn't unpack the indices
             w.writerows(
@@ -166,7 +168,7 @@ def save_generic_results(instance, outdir, sorted_output):
                                 [var.name])
                 # Results are saved in a random order by default for
                 # increased speed. Sorting is available if wanted.
-                items = sorted(var.items()) if sorted_output else list(var.items())
+                items = sorted_robust(var.items()) if sorted_output else list(var.items())
                 for key, obj in items:
                     writer.writerow(format_row(tuple(make_iterable(key)) + (obj,), cell_formatter))
             else: