Reinforcement costs now computed and reported per-MW

reVX/least_cost_xmission/least_cost_paths.py

@@ -646,27 +646,22 @@ def _rasterize_transmission(transmission_lines, xmission_config, cost_shape,
     """Rasterize transmission lines and assemble them into a dict. """
 
     transmission_lines_dict = {}
-    capacities = sorted(xmission_config['power_classes'],
-                        key=lambda x: xmission_config['power_classes'][x])
+    capacities = sorted(xmission_config['power_classes'].values())
     v_min = 0
     for capacity in capacities[:-1]:
-        power_class = str(xmission_config['power_classes'][capacity])
-        cost_layer = 'tie_line_costs_{}MW'.format(power_class)
-        v_max = xmission_config['power_to_voltage'][power_class]
-
+        v_max = xmission_config['power_to_voltage'][str(capacity)]
         curr_lines = transmission_lines[
             (transmission_lines["voltage"] > v_min)
             & (transmission_lines["voltage"] <= v_max)
         ]
         out = _rasterize_transmission_layer(curr_lines, cost_shape,
                                             cost_transform)
-        transmission_lines_dict[cost_layer] = out
+        transmission_lines_dict[int(capacity)] = out
         v_min = v_max
 
     curr_lines = transmission_lines[transmission_lines["voltage"] > v_min]
-    cost_layer = 'tie_line_costs_{}'.format(capacities[-1])
     out = _rasterize_transmission_layer(curr_lines, cost_shape, cost_transform)
-    transmission_lines_dict[cost_layer] = out
+    transmission_lines_dict[int(capacities[-1])] = out
     return transmission_lines_dict
 
 

reVX/least_cost_xmission/least_cost_xmission_cli.py

@@ -349,7 +349,7 @@ def merge_reinforcement_costs(ctx, cost_fpath, reinforcement_cost_fpath,
 
     logger.info("Merging reinforcement costs into transmission costs...")
 
-    r_cols = ["reinforcement_dist_km", "reinforcement_cost"]
+    r_cols = ["reinforcement_dist_km", "reinforcement_cost_per_mw"]
     costs[r_cols] = r_costs.loc[costs["trans_gid"], r_cols].values
 
     logger.info("Writing output to {!r}".format(out_file))

reVX/least_cost_xmission/trans_cap_costs.py

@@ -62,8 +62,8 @@ def __init__(self, cost_fpath, start_indices, capacity_class, row_slice,
         self._col_slice = col_slice
         self._capacity_class = self._config._parse_cap_class(capacity_class)
 
-        line_cap = self._config['power_classes'][self.capacity_class]
-        cost_layer = 'tie_line_costs_{}MW'.format(line_cap)
+        self._line_cap_mw = self._config['power_classes'][self.capacity_class]
+        cost_layer = 'tie_line_costs_{}MW'.format(self._line_cap_mw)
         self._cost, self._mcp_cost = self._clip_costs(
             cost_fpath, cost_layer, row_slice, col_slice,
             barrier_mult=barrier_mult)
@@ -1199,13 +1199,14 @@ def __init__(self, transmission_lines, cost_fpath, start_indices,
                          capacity_class=capacity_class, row_slice=row_slice,
                          col_slice=col_slice, xmission_config=xmission_config,
                          barrier_mult=barrier_mult)
-
+        self._cost = self._cost / self._line_cap_mw
         with ExclusionLayers(cost_fpath) as f:
-            for cost_layer, lines in transmission_lines.items():
+            for capacity_mw, lines in transmission_lines.items():
                 t_lines = np.where(lines[row_slice, col_slice])
+                cost_layer = 'tie_line_costs_{}MW'.format(capacity_mw)
                 costs = f[cost_layer, row_slice, col_slice][t_lines]
                 self._mcp_cost[t_lines] = costs * 1e-9
-                self._cost[t_lines] = costs
+                self._cost[t_lines] = costs / capacity_mw
 
     @classmethod
     def run(cls, transmission_lines, cost_fpath, start_indices, end_indices,
@@ -1286,7 +1287,7 @@ def run(cls, transmission_lines, cost_fpath, start_indices, end_indices,
                 f['longitude', row_slice, col_slice][row, col])
 
         tie_lines = tie_lines.rename({'length_km': 'reinforcement_dist_km',
-                                      'cost': 'reinforcement_cost',
+                                      'cost': 'reinforcement_cost_per_mw',
                                       'poi_lat': 'reinforcement_poi_lat',
                                       'poi_lon': 'reinforcement_poi_lon'},
                                      axis=1)

tests/test_xmission_least_cost_paths.py

@@ -227,9 +227,9 @@ def test_reinforcement_cli(runner, ba_regions_and_network_nodes):
         assert len(test["reinforcement_poi_lon"].unique()) == 4
 
         assert len(test) == 69
-        assert np.isclose(test.reinforcement_cost.min(), 1235514.316,
+        assert np.isclose(test.reinforcement_cost_per_mw.min(), 3332.695,
                           atol=0.001)
-        assert np.isclose(test.reinforcement_cost.max(), 156662169.251,
+        assert np.isclose(test.reinforcement_cost_per_mw.max(), 569757.740,
                           atol=0.001)
         assert np.isclose(test.reinforcement_dist_km.min(), 1.918, atol=0.001)
         assert np.isclose(test.reinforcement_dist_km.max(), 80.353, atol=0.001)