Cleanup for Bugs

Signed-off-by: Davey Elder <iandavidelder@gmail.com>

Author: idelder

scripts/generate_etl_figure.py

@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Any
 
 import matplotlib
 import matplotlib.patches as mpatches
@@ -109,7 +110,12 @@
 ax.set_yticklabels(y_labels, fontsize=8.5, color=PALETTE['tick'])
 
 # ——— Dashed reference lines to axes from segment endpoints ———————————————————
-dash_kw = {'color': PALETTE['inactive'], 'linewidth': 0.8, 'linestyle': ':', 'zorder': 1}
+dash_kw: dict[str, Any] = {
+    'color': PALETTE['inactive'],
+    'linewidth': 0.8,
+    'linestyle': ':',
+    'zorder': 1,
+}
 for ql, qu, cl, cu in segments:
     ax.plot([ql, ql], [0, cl], **dash_kw)
     ax.plot([qu, qu], [0, cu], **dash_kw)

temoa/_internal/run_actions.py

@@ -247,7 +247,8 @@ def solve_instance(
             # it also doesn't seem to support duals properly so disable those
             if solver_name == 'appsi_highs':
                 dual_suffix = instance.component('dual')
-                dual_suffix._direction = Suffix.LOCAL
+                if dual_suffix is not None:
+                    dual_suffix.direction = Suffix.LOCAL
                 result = optimizer.solve(instance)
             else:
                 result = optimizer.solve(instance, suffixes=solver_suffixes_list)

temoa/extensions/economies_of_scale/core/data_puller.py

@@ -98,90 +98,84 @@ def poll_costs(
         else:
             # The period `p` for an investment cost is its vintage `v`.
             key = (cast('Region', r), cast('Period', p), cast('Technology', t), cast('Vintage', p))
-            if CostType.INVEST in entries.get(key, {}):
-                entries[key][CostType.D_INVEST] += discounted_cost
-                entries[key][CostType.INVEST] += undiscounted_cost
-            else:
-                entries[key].update(
-                    {CostType.D_INVEST: discounted_cost, CostType.INVEST: undiscounted_cost}
-                )
+            entry = entries[key]
+            entry[CostType.D_INVEST] = entry.get(CostType.D_INVEST, 0.0) + discounted_cost
+            entry[CostType.INVEST] = entry.get(CostType.INVEST, 0.0) + undiscounted_cost
 
     for r, p, t in model.cost_fixed_eos_period_rpt:
         fixed_cost = value(cost_fixed_eos.period_cost(model, r, p, t))
         if fixed_cost < epsilon:
             continue
 
-        undiscounted_fixed_cost = fixed_cost * value(model.period_length[p])
-        discounted_fixed_cost = costs.fixed_or_variable_cost(
+        ud_fixed = float(fixed_cost * value(model.period_length[p]))
+        d_fixed = costs.fixed_or_variable_cost(
             1,
             fixed_cost,
             value(model.period_length[p]),
             global_discount_rate=global_discount_rate,
             p_0=p_0,
             p=p,
         )
+        d_fixed = float(value(d_fixed))
 
         if '-' in r:
             exchange_costs.add_cost_record(
                 r,
                 period=p,
                 tech=t,
                 vintage=p,
-                cost=float(value(discounted_fixed_cost)),
+                cost=d_fixed,
                 cost_type=CostType.D_FIXED,
             )
             exchange_costs.add_cost_record(
                 r,
                 period=p,
                 tech=t,
                 vintage=p,
-                cost=float(undiscounted_fixed_cost),
+                cost=ud_fixed,
                 cost_type=CostType.FIXED,
             )
         else:
-            entries[r, p, t, p].update(
-                {
-                    CostType.D_FIXED: float(value(discounted_fixed_cost)),
-                    CostType.FIXED: float(undiscounted_fixed_cost),
-                }
-            )
+            key = (cast('Region', r), cast('Period', p), cast('Technology', t), cast('Vintage', p))
+            entry = entries[key]
+            entry[CostType.D_FIXED] = entry.get(CostType.D_FIXED, 0.0) + d_fixed
+            entry[CostType.FIXED] = entry.get(CostType.FIXED, 0.0) + ud_fixed
 
-    for r, p, t in model.cost_fixed_eos_period_rpt:
+    for r, p, t in model.cost_variable_eos_period_rpt:
         variable_cost = value(cost_variable_eos.period_cost(model, r, p, t))
         if variable_cost < epsilon:
             continue
 
-        undiscounted_variable_cost = variable_cost * value(model.period_length[p])
-        discounted_variable_cost = costs.fixed_or_variable_cost(
+        ud_variable = float(variable_cost * value(model.period_length[p]))
+        d_variable = costs.fixed_or_variable_cost(
             1,
             variable_cost,
             value(model.period_length[p]),
             global_discount_rate=global_discount_rate,
             p_0=p_0,
             p=p,
         )
+        d_variable = float(value(d_variable))
 
         if '-' in r:
             exchange_costs.add_cost_record(
                 r,
                 period=p,
                 tech=t,
                 vintage=p,
-                cost=float(value(discounted_variable_cost)),
+                cost=d_variable,
                 cost_type=CostType.D_VARIABLE,
             )
             exchange_costs.add_cost_record(
                 r,
                 period=p,
                 tech=t,
                 vintage=p,
-                cost=float(undiscounted_variable_cost),
+                cost=ud_variable,
                 cost_type=CostType.VARIABLE,
             )
         else:
-            entries[r, p, t, p].update(
-                {
-                    CostType.D_VARIABLE: float(value(discounted_variable_cost)),
-                    CostType.VARIABLE: float(undiscounted_variable_cost),
-                }
-            )
+            key = (cast('Region', r), cast('Period', p), cast('Technology', t), cast('Vintage', p))
+            entry = entries[key]
+            entry[CostType.D_VARIABLE] = entry.get(CostType.D_VARIABLE, 0.0) + d_variable
+            entry[CostType.VARIABLE] = entry.get(CostType.VARIABLE, 0.0) + ud_variable

temoa/extensions/economies_of_scale/core/model.py

@@ -169,6 +169,8 @@ def register_model_components(model: TemoaModel) -> None:
         rule=cost_fixed_eos.cost_fixed_eos_capacity_upper_bound_constraint,
     )
 
+    m.append_cost_fixed_eos_to_total_cost = BuildAction(rule=cost_fixed_eos.total_cost)
+
     # -- cost_variable_eos ---
     m.cost_variable_eos_segments = {}
 

temoa/extensions/method_of_morris/morris.py

@@ -47,8 +47,6 @@ def evaluate(
     with TableWriter(config) as table_writer:
         table_writer.write_results(model=mdl)
 
-    import contextlib
-
     with contextlib.closing(sqlite3.connect(db_file)) as con:
         cur = con.cursor()
         cur.execute('SELECT * FROM output_objective')

tests/test_table_writer.py

@@ -9,7 +9,7 @@ class LoanCostInput(TypedDict):
     capacity: float
     invest_cost: float
     loan_life: float
-    loan_rate: float
+    loan_annualize: float
     global_discount_rate: float
     process_life: int
     p_0: int