Add option for info.txt file

Author: staadecker

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

@@ -589,7 +589,10 @@ def graph_curtailment_per_tech(tools):
     # Get axes to graph on
     ax = tools.get_new_axes(out="curtailment_per_period", 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'
 
@@ -208,8 +208,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,16 +10,19 @@
 
 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 (
-    create_model, _ArgumentParser, StepTimer, make_iterable, LogOutput, warn, query_yes_no, create_info_file,
-    get_module_list, add_module_args, _ScaledVariable
+    create_model, _ArgumentParser, StepTimer, make_iterable, LogOutput, warn, query_yes_no,
+    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(args=None, return_model=False, return_instance=False, attach_data_portal=False):
@@ -103,6 +106,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)
 
@@ -111,7 +117,7 @@ def debug(type, value, tb):
             print("Switch {}, http://switch-model.org".format(switch_model.__version__))
             print("=======================================================================")
             print("Arguments:")
-            print(", ".join(k+"="+repr(v) for k, v in model.options.__dict__.items() if v))
+            print(", ".join(k + "=" + repr(v) for k, v in model.options.__dict__.items() if v))
             print("Modules:\n"+", ".join(m for m in modules))
             if iterate_modules:
                 print("Iteration modules:", iterate_modules)
@@ -198,7 +204,15 @@ 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:
             print(f"Total time spent running SWITCH: {total_time}.")
@@ -815,30 +829,6 @@ def solve(model):
             print('solver_options_string and calling this script with "--suffixes iis" or "--gurobi-find-iis".')
         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,12 +7,15 @@
 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
 
@@ -883,27 +886,14 @@ def query_yes_no(question, default="yes"):
 def run_command(command):
     return subprocess.check_output(command.split(" "), cwd=os.path.dirname(__file__)).strip().decode("UTF-8")
 
-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):
     # parse module options

switch_model/utilities/results_info.py

@@ -0,0 +1,27 @@
+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")