Get outputs for first year

Author: tsmbland

src/muse/mca.py

@@ -306,7 +306,9 @@ def run(self) -> None:
             # Save sector outputs
             for sector in self.sectors:
                 if type(sector) is Sector:
-                    sector.save_outputs()
+                    if year_idx == 0:
+                        sector.save_outputs(years[0])
+                    sector.save_outputs(years[1])
 
             # If we need to account for the carbon budget, we might need to change
             # the budget for the future, too.
@@ -324,6 +326,10 @@ def run(self) -> None:
                 self.market.prices.sel(dims), new_market.prices.sel(year=years[1])
             )
 
+            if year_idx == 0:
+                # Necessary to get global outputs for the first year of the framework
+                self.outputs(self.market, self.sectors, year=years[0])
+
             # Global outputs
             investment_year = years[1]
             self.outputs(self.market, self.sectors, year=investment_year)

src/muse/outputs/mca.py

@@ -8,7 +8,9 @@
     @register_output_quantity
     def quantity(
         sectors: List[AbstractSector],
-        market: xr.Dataset, **kwargs
+        market: xr.Dataset,
+        year: int,
+        **kwargs
     ) -> Union[pd.DataFrame, xr.DataArray]:
         pass
 
@@ -76,9 +78,13 @@ def round_values(function: Callable) -> OUTPUT_QUANTITY_SIGNATURE:
 
     @wraps(function)
     def rounded(
-        market: xr.Dataset, sectors: list[AbstractSector], rounding: int = 4, **kwargs
+        market: xr.Dataset,
+        sectors: list[AbstractSector],
+        year: int,
+        rounding: int = 4,
+        **kwargs,
     ) -> xr.DataArray:
-        result = function(market, sectors, **kwargs)
+        result = function(market=market, sectors=sectors, year=year, **kwargs)
 
         if hasattr(result, "to_dataframe"):
             result = result.to_dataframe()
@@ -150,15 +156,17 @@ def reformat_finite_resources(params):
 @register_output_quantity
 @round_values
 def consumption(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current consumption."""
     return market_quantity(market.consumption, **kwargs).to_dataframe().reset_index()
 
 
 @register_output_quantity
 @round_values
-def supply(market: xr.Dataset, sectors: list[AbstractSector], **kwargs) -> pd.DataFrame:
+def supply(
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
+) -> pd.DataFrame:
     """Current supply."""
     return market_quantity(market.supply, **kwargs).to_dataframe().reset_index()
 
@@ -168,6 +176,7 @@ def supply(market: xr.Dataset, sectors: list[AbstractSector], **kwargs) -> pd.Da
 def prices(
     market: xr.Dataset,
     sectors: list[AbstractSector],
+    year: int,
     **kwargs,
 ) -> pd.DataFrame:
     """Current MCA market prices."""
@@ -177,7 +186,7 @@ def prices(
 @register_output_quantity
 @round_values
 def capacity(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current capacity across all sectors."""
     return _aggregate_sectors(sectors, op=sector_capacity)
@@ -236,14 +245,14 @@ def _aggregate_sectors(
 
 @register_output_quantity(name=["fuel_costs"])
 def metric_fuel_costs(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current fuel costs across all sectors."""
-    return _aggregate_sectors(sectors, market, op=sector_fuel_costs)
+    return _aggregate_sectors(sectors, market, year, op=sector_fuel_costs)
 
 
 def sector_fuel_costs(
-    sector: AbstractSector, market: xr.Dataset, **kwargs
+    sector: AbstractSector, market: xr.Dataset, year: int, **kwargs
 ) -> pd.DataFrame:
     """Sector fuel costs with agent annotations."""
     from muse.commodities import is_fuel
@@ -258,13 +267,13 @@ def sector_fuel_costs(
     if len(technologies) > 0:
         for a in agents:
             agent_market["consumption"] = (market.consumption * a.quantity).sel(
-                year=a.year
+                year=year
             )
             commodity = is_fuel(technologies.comm_usage)
 
             capacity = a.filter_input(
                 a.assets.capacity,
-                year=a.year,
+                year=year,
             ).fillna(0.0)
 
             production = supply(
@@ -273,7 +282,7 @@ def sector_fuel_costs(
                 technologies,
             )
 
-            prices = a.filter_input(market.prices, year=a.year)
+            prices = a.filter_input(market.prices, year=year)
             fcons = consumption(
                 technologies=technologies, production=production, prices=prices
             )
@@ -282,7 +291,7 @@ def sector_fuel_costs(
             data_agent["agent"] = a.name
             data_agent["category"] = a.category
             data_agent["sector"] = getattr(sector, "name", "unnamed")
-            data_agent["year"] = a.year
+            data_agent["year"] = year
             data_agent = multiindex_to_coords(data_agent, "timeslice").to_dataframe(
                 "fuel_consumption_costs"
             )
@@ -298,14 +307,14 @@ def sector_fuel_costs(
 
 @register_output_quantity(name=["capital_costs"])
 def metric_capital_costs(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current capital costs across all sectors."""
-    return _aggregate_sectors(sectors, market, op=sector_capital_costs)
+    return _aggregate_sectors(sectors, market, year, op=sector_capital_costs)
 
 
 def sector_capital_costs(
-    sector: AbstractSector, market: xr.Dataset, **kwargs
+    sector: AbstractSector, market: xr.Dataset, year: int, **kwargs
 ) -> pd.DataFrame:
     """Sector capital costs with agent annotations."""
     data_sector: list[xr.DataArray] = []
@@ -314,17 +323,17 @@ def sector_capital_costs(
 
     if len(technologies) > 0:
         for a in agents:
-            capacity = a.filter_input(a.assets.capacity, year=a.year).fillna(0.0)
+            capacity = a.filter_input(a.assets.capacity, year=year).fillna(0.0)
             data = a.filter_input(
                 technologies[["cap_par", "cap_exp"]],
-                year=a.year,
+                year=year,
                 technology=capacity.technology,
             )
             data_agent = distribute_timeslice(data.cap_par * (capacity**data.cap_exp))
             data_agent["agent"] = a.name
             data_agent["category"] = a.category
             data_agent["sector"] = getattr(sector, "name", "unnamed")
-            data_agent["year"] = a.year
+            data_agent["year"] = year
             data_agent = multiindex_to_coords(data_agent, "timeslice").to_dataframe(
                 "capital_costs"
             )
@@ -340,14 +349,14 @@ def sector_capital_costs(
 
 @register_output_quantity(name=["emission_costs"])
 def metric_emission_costs(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current emission costs across all sectors."""
-    return _aggregate_sectors(sectors, market, op=sector_emission_costs)
+    return _aggregate_sectors(sectors, market, year, op=sector_emission_costs)
 
 
 def sector_emission_costs(
-    sector: AbstractSector, market: xr.Dataset, **kwargs
+    sector: AbstractSector, market: xr.Dataset, year: int, **kwargs
 ) -> pd.DataFrame:
     """Sector emission costs with agent annotations."""
     from muse.commodities import is_enduse, is_pollutant
@@ -361,21 +370,21 @@ def sector_emission_costs(
     if len(technologies) > 0:
         for a in agents:
             agent_market["consumption"] = (market.consumption * a.quantity).sel(
-                year=a.year
+                year=year
             )
 
-            capacity = a.filter_input(a.assets.capacity, year=a.year).fillna(0.0)
+            capacity = a.filter_input(a.assets.capacity, year=year).fillna(0.0)
             allemissions = a.filter_input(
                 technologies.fixed_outputs,
                 commodity=is_pollutant(technologies.comm_usage),
                 technology=capacity.technology,
-                year=a.year,
+                year=year,
             )
             envs = is_pollutant(technologies.comm_usage)
             enduses = is_enduse(technologies.comm_usage)
             i = (np.where(envs))[0][0]
             red_envs = envs[i].commodity.values
-            prices = a.filter_input(market.prices, year=a.year, commodity=red_envs)
+            prices = a.filter_input(market.prices, year=year, commodity=red_envs)
             production = supply(
                 agent_market,
                 capacity,
@@ -387,7 +396,7 @@ def sector_emission_costs(
             data_agent["agent"] = a.name
             data_agent["category"] = a.category
             data_agent["sector"] = getattr(sector, "name", "unnamed")
-            data_agent["year"] = a.year
+            data_agent["year"] = year
             data_agent = multiindex_to_coords(data_agent, "timeslice").to_dataframe(
                 "emission_costs"
             )
@@ -404,13 +413,15 @@ def sector_emission_costs(
 
 @register_output_quantity(name=["LCOE"])
 def metric_lcoe(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current lifetime levelised cost across all sectors."""
-    return _aggregate_sectors(sectors, market, op=sector_lcoe)
+    return _aggregate_sectors(sectors, market, year, op=sector_lcoe)
 
 
-def sector_lcoe(sector: AbstractSector, market: xr.Dataset, **kwargs) -> pd.DataFrame:
+def sector_lcoe(
+    sector: AbstractSector, market: xr.Dataset, year: int, **kwargs
+) -> pd.DataFrame:
     """Levelized cost of energy () of technologies over their lifetime."""
     from muse.costs import levelized_cost_of_energy as LCOE
     from muse.quantities import capacity_to_service_demand, consumption
@@ -485,13 +496,15 @@ def sector_lcoe(sector: AbstractSector, market: xr.Dataset, **kwargs) -> pd.Data
 
 @register_output_quantity(name=["EAC"])
 def metric_eac(
-    market: xr.Dataset, sectors: list[AbstractSector], **kwargs
+    market: xr.Dataset, sectors: list[AbstractSector], year: int, **kwargs
 ) -> pd.DataFrame:
     """Current emission costs across all sectors."""
-    return _aggregate_sectors(sectors, market, op=sector_eac)
+    return _aggregate_sectors(sectors, market, year, op=sector_eac)
 
 
-def sector_eac(sector: AbstractSector, market: xr.Dataset, **kwargs) -> pd.DataFrame:
+def sector_eac(
+    sector: AbstractSector, market: xr.Dataset, year: int, **kwargs
+) -> pd.DataFrame:
     """Net Present Value of technologies over their lifetime."""
     from muse.costs import equivalent_annual_cost as EAC
     from muse.quantities import capacity_to_service_demand, consumption

src/muse/outputs/sector.py

@@ -107,7 +107,7 @@ def save_multiple_outputs(market, *args, year: int | None = None) -> list[Any]:
             year = int(market.year.max())
 
         return [
-            sink(quantity(market, *args), year=year)
+            sink(quantity(market, *args, year=year), year=year)
             for quantity, sink in zip(quantities, sinks)
         ]
 
@@ -182,6 +182,7 @@ def consumption(
     sum_over: list[str] | None = None,
     drop: list[str] | None = None,
     rounding: int = 4,
+    **kwargs,
 ) -> xr.DataArray:
     """Current consumption."""
     moutput = market.copy(deep=True).reset_index("timeslice")
@@ -202,6 +203,7 @@ def supply(
     sum_over: list[str] | None = None,
     drop: list[str] | None = None,
     rounding: int = 4,
+    **kwargs,
 ) -> xr.DataArray:
     """Current supply."""
     moutput = market.copy(deep=True).reset_index("timeslice")
@@ -222,6 +224,7 @@ def costs(
     sum_over: list[str] | None = None,
     drop: list[str] | None = None,
     rounding: int = 4,
+    **kwargs,
 ) -> xr.DataArray:
     """Current costs."""
     from muse.commodities import is_pollutant

src/muse/sectors/sector.py

@@ -275,10 +275,9 @@ def group_assets(x: xr.DataArray) -> xr.DataArray:
         # Convert result to global timeslicing scheme
         return self.convert_to_global_timeslicing(result)
 
-    def save_outputs(self) -> None:
+    def save_outputs(self, year: int) -> None:
         """Calls the outputs function with the current output data."""
-        investment_year = self.output_data.year.values[1]
-        self.outputs(self.output_data, self.capacity, year=investment_year)
+        self.outputs(self.output_data, self.capacity, year=year)
 
     def market_variables(self, market: xr.Dataset, technologies: xr.Dataset) -> Any:
         """Computes resulting market: production, consumption, and costs."""