Merge pull request #70 from staadecker/info-file

Add framework for a results.txt file

Author: PatyHidalgo

docs/Contribute.md

@@ -44,3 +44,36 @@ Read [`docs/Graphs.md`](./Graphs.md) to see learn to add graphs.
 ## Modifying the database
 
 Read [`docs/Database.md`](./Database.md) to learn about the database.
+
+## Outputting results
+
+Once the model is solved, the `post_solve()` function in each module is called.
+Within the `post_solve()` function you may 
+
+- Call `write_table()` to create
+a .csv file with data from the solution (see existing modules for examples).
+  
+- Call `add_info()` (from `utilities/result_info.py`) to add a line 
+of information to the `outputs/info.txt` file. `add_info()` can also be added to `graph()`.
+
+### Example
+
+```python
+from switch_model.utilities.results_info import add_info
+from switch_model.reporting import write_table
+import os
+...
+def post_solve(instance, outdir):
+    ...
+    # This will add the a line to info.txt in the outputs folder
+    add_info("Some important value", instance.important_value)
+    ...
+    # This will create my_table.csv
+    write_table(
+        instance, 
+        instance.TIMEPOINTS, # Set that the values function will iterate over
+        output_file=os.path.join(outdir, "my_table.csv"),
+        headings=("timepoint", "some value"),
+        values=lambda m, t: (t, m.some_value[t])
+    )
+```

switch_model/generators/core/dispatch.py

@@ -696,7 +696,10 @@ def graph_curtailment_per_tech(tools):
         title="Percent of total dispatchable capacity curtailed",
     )
     # Plot
-    df.plot(ax=ax, kind="line", color=tools.get_colors(), xlabel="Period")
+    color = tools.get_colors()
+    kwargs = dict() if color is None else dict(color=color)
+    df.plot(ax=ax, kind="line", xlabel="Period", **kwargs)
+
     # Set the y-axis to use percent
     ax.yaxis.set_major_formatter(tools.mplt.ticker.PercentFormatter(1.0))
     # Horizontal line at 100%

switch_model/reporting/__init__.py

@@ -19,7 +19,7 @@
 
 """
 from __future__ import print_function
-from switch_model.utilities import string_types
+from switch_model.utilities import string_types, add_info
 from switch_model.utilities.scaling import get_unscaled_var
 
 dependencies = "switch_model.financials"
@@ -235,8 +235,10 @@ def get_value(obj):
 
 
 def save_total_cost_value(instance, outdir):
+    total_cost = round(value(instance.SystemCost), ndigits=2)
+    add_info("Total Cost", f"$ {total_cost}")
     with open(os.path.join(outdir, "total_cost.txt"), "w") as fh:
-        fh.write("{}\n".format(round(value(instance.SystemCost), ndigits=2)))
+        fh.write(f"{total_cost}\n")
 
 
 def save_cost_components(m, outdir):

switch_model/solve.py

@@ -10,6 +10,12 @@
 
 import sys, os, shlex, re, inspect, textwrap, types, pickle, traceback, gc
 import warnings
+import datetime
+import platform
+
+from pyomo.solvers.plugins.solvers.direct_or_persistent_solver import (
+    DirectOrPersistentSolver,
+)
 
 import switch_model
 from switch_model.utilities import (
@@ -20,13 +26,14 @@
     LogOutput,
     warn,
     query_yes_no,
-    create_info_file,
     get_module_list,
     add_module_args,
     _ScaledVariable,
+    add_git_info,
 )
 from switch_model.upgrade import do_inputs_need_upgrade, upgrade_inputs
 from switch_model.tools.graphing import graph
+from switch_model.utilities.results_info import save_info, add_info, ResultsInfoSection
 
 
 def main(
@@ -116,6 +123,9 @@ def debug(type, value, tb):
             if not os.path.isdir(model.options.outputs_dir):
                 raise IOError("Directory specified for prior solution does not exist.")
 
+        add_info("Host name", platform.node(), section=ResultsInfoSection.GENERAL)
+        add_git_info()
+
         # get a list of modules to iterate through
         iterate_modules = get_iteration_list(model)
 
@@ -217,6 +227,7 @@ def debug(type, value, tb):
         # (repeated if model is reloaded, to automatically run any new export code)
         if not instance.options.no_post_solve:
             if instance.options.verbose:
+                timer.step_time()
                 print("Executing post solve functions...")
             instance.post_solve()
             if instance.options.verbose:
@@ -226,8 +237,23 @@ def debug(type, value, tb):
             graph.main(args=["--overwrite"])
 
         total_time = start_to_end_timer.step_time_as_str()
-        create_info_file(
-            getattr(instance.options, "outputs_dir", "outputs"), run_time=total_time
+        add_info("Total run time", total_time, section=ResultsInfoSection.GENERAL)
+
+        add_info(
+            "End date",
+            datetime.datetime.now().strftime("%Y-%m-%d"),
+            section=ResultsInfoSection.GENERAL,
+        )
+        add_info(
+            "End time",
+            datetime.datetime.now().strftime("%H:%M:%S"),
+            section=ResultsInfoSection.GENERAL,
+        )
+
+        save_info(
+            os.path.join(
+                getattr(instance.options, "outputs_dir", "outputs"), "info.txt"
+            )
         )
 
         if instance.options.verbose:
@@ -921,6 +947,9 @@ def solve(model):
         keepfiles=model.options.keepfiles,
         tee=model.options.tee,
         symbolic_solver_labels=model.options.symbolic_solver_labels,
+        save_results=model.options.save_solution
+        if isinstance(solver, DirectOrPersistentSolver)
+        else None,
     )
 
     if model.options.warm_start is not None:
@@ -992,35 +1021,6 @@ def solve(model):
             )
         raise RuntimeError("Infeasible model")
 
-    # Raise an error if the solver failed to produce a solution
-    # Note that checking for results.solver.status in {SolverStatus.ok,
-    # SolverStatus.warning} is not enough because with a warning there will
-    # sometimes be a solution and sometimes not.
-    # Note: the results object originally contains values for model components
-    # in results.solution.variable, etc., but pyomo.solvers.solve erases it via
-    # result.solution.clear() after calling model.solutions.load_from() with it.
-    # load_from() loads values into the model.solutions._entry, so we check there.
-    # (See pyomo.PyomoModel.ModelSolutions.add_solution() for the code that
-    # actually creates _entry).
-    # Another option might be to check that model.solutions[-1].status (previously
-    # result.solution.status, but also cleared) is in
-    # pyomo.opt.SolutionStatus.['optimal', 'bestSoFar', 'feasible', 'globallyOptimal', 'locallyOptimal'],
-    # but this seems pretty foolproof (if undocumented).
-    if len(model.solutions[-1]._entry["variable"]) == 0:
-        # no solution returned
-        print("Solver terminated without a solution.")
-        print("  Solver Status: ", results.solver.status)
-        print("  Solution Status: ", model.solutions[-1].status)
-        print("  Termination Condition: ", results.solver.termination_condition)
-        if (
-            model.options.solver == "glpk"
-            and results.solver.termination_condition == TerminationCondition.other
-        ):
-            print(
-                "Hint: glpk has been known to classify infeasible problems as 'other'."
-            )
-        raise RuntimeError("Solver failed to find an optimal solution.")
-
     # Report any warnings; these are written to stderr so users can find them in
     # error logs (e.g. on HPC systems). These can occur, e.g., if solver reaches
     # time limit or iteration limit but still returns a valid solution

switch_model/utilities/__init__.py

@@ -7,15 +7,17 @@
 from __future__ import print_function
 
 import os, types, sys, argparse, time, datetime, traceback, subprocess, platform
+import warnings
 
 import switch_model.__main__ as main
 from pyomo.environ import *
 from pyomo.core.base.set import UnknownSetDimen
 from pyomo.dataportal import DataManagerFactory
 from pyomo.dataportal.plugins.csv_table import CSVTable
+
+from switch_model.utilities.results_info import add_info, ResultsInfoSection
 from switch_model.utilities.scaling import _ScaledVariable, _get_unscaled_expression
 import pyomo.opt
-import yaml
 
 # Define string_types (same as six.string_types). This is useful for
 # distinguishing between strings and other iterables.
@@ -950,16 +952,6 @@ def query_yes_no(question, default="yes"):
             sys.stdout.write("Please respond with 'yes' or 'no' " "(or 'y' or 'n').\n")
 
 
-def load_config():
-    """Read the config.yaml configuration file"""
-    if not os.path.isfile("config.yaml"):
-        raise Exception(
-            "config.yaml does not exist. Try running 'switch new' to auto-create it."
-        )
-    with open("config.yaml") as f:
-        return yaml.load(f, Loader=yaml.FullLoader)
-
-
 def run_command(command):
     return (
         subprocess.check_output(command.split(" "), cwd=os.path.dirname(__file__))
@@ -968,28 +960,14 @@ def run_command(command):
     )
 
 
-def get_git_hash():
-    return run_command("git rev-parse HEAD")
-
-
-def get_git_branch():
-    return run_command("git rev-parse --abbrev-ref HEAD")
-
-
-def create_info_file(output_path, run_time=None):
-    content = ""
-    content += f"End date: {datetime.datetime.now().strftime('%Y-%m-%d')}\n"
-    content += f"End time: {datetime.datetime.now().strftime('%H:%M:%S')}\n"
+def add_git_info():
     try:
-        content += f"SWITCH Git Commit Hash: {get_git_hash()}\n"
-        content += f"SWITCH Git Branch: {get_git_branch()}\n"
+        commit_num = run_command("git rev-parse HEAD")
+        branch = run_command("git rev-parse --abbrev-ref HEAD")
+        add_info("Git Commit", commit_num, section=ResultsInfoSection.GENERAL)
+        add_info("Git Branch", branch, section=ResultsInfoSection.GENERAL)
     except:
-        print("Warning: failed to get commit hash or branch for info.txt.")
-    if run_time is not None:
-        content += f"Run time: {run_time}\n"
-    content += f"Host name: {platform.node()}\n"
-    with open(os.path.join(output_path, "info.txt"), "w") as f:
-        f.write(content)
+        warnings.warn("Failed to get Git Branch or Commit Hash for info.txt.")
 
 
 def get_module_list(args=None, include_solve_module=True):

switch_model/utilities/results_info.py

@@ -0,0 +1,23 @@
+import enum
+
+
+class ResultsInfoSection(enum.Enum):
+    GENERAL = "1. General"
+    RESULTS = "2. Results"
+
+
+info = {}
+
+
+def add_info(name: str, value="", section=ResultsInfoSection.RESULTS):
+    if section not in info:
+        info[section] = []
+
+    info[section].append(str(name) + ": " + str(value))
+
+
+def save_info(filepath):
+    with open(filepath, "w") as f:
+        for section, rows in sorted(info.items(), key=lambda x: x[0].value):
+            f.write(f"##########\n" f"{section.value}\n" f"##########\n\n")
+            f.write("\n".join(rows) + "\n\n")