hestia-earth-models 0.64.8__py3-none-any.whl → 0.64.10__py3-none-any.whl

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -10,12 +10,13 @@ from itertools import product
 from numpy import array, random, mean
 from numpy.typing import NDArray
 from pydash.objects import merge
-from typing import Callable, NamedTuple, Optional, Union
+from typing import Any, Callable, NamedTuple, Optional, Union
 
 from hestia_earth.schema import (
-    EmissionMethodTier, EmissionStatsDefinition, MeasurementMethodClassification
+    EmissionMethodTier, EmissionStatsDefinition, MeasurementMethodClassification, TermTermType
 )
 from hestia_earth.utils.date import diff_in_days, YEAR
+from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 
 from hestia_earth.models.log import log_as_table
@@ -44,10 +45,12 @@ _MAX_CORRELATION = 1
 _MIN_CORRELATION = 0.5
 _NOMINAL_ERROR = 75
 """
-carbon stock measurements without an associated `sd` should be assigned a nominal error of 75% (2*sd as a percentage of
+Carbon stock measurements without an associated `sd` should be assigned a nominal error of 75% (2*sd as a percentage of
 the mean).
 """
-_TRANSITION_PERIOD = 20 * YEAR  # 20 years in days
+_DEFAULT_YEARS_SINCE_LUC_EVENT = 999
+_TRANSITION_PERIOD_YEARS = 20
+_TRANSITION_PERIOD_DAYS = 20 * YEAR  # 20 years in days
 _VALID_DATE_FORMATS = {
     DatestrFormat.YEAR,
     DatestrFormat.YEAR_MONTH,
@@ -91,6 +94,9 @@ class _InventoryKey(Enum):
     CARBON_STOCK_CHANGE = "carbon-stock-change"
     CO2_EMISSION = "carbon-emission"
     SHARE_OF_EMISSION = "share-of-emissions"
+    LAND_USE_SUMMARY = "land-use-summary"
+    LAND_USE_CHANGE_EVENT = "luc-event"
+    YEARS_SINCE_LUC_EVENT = "years-since-luc-event"
 
 
 CarbonStock = NamedTuple("CarbonStock", [
@@ -319,9 +325,12 @@ def _add_carbon_stock_change_emissions(
 
 
 def create_should_run_function(
+    *,
     carbon_stock_term_id: str,
     should_compile_inventory_func: Callable[[dict, list[dict], list[dict]], tuple[bool, dict]],
-    should_run_measurement_func: Callable[[dict], bool] = lambda _: True,
+    summarise_land_use_func: Callable[[list[dict]], Any],
+    detect_land_use_change_func: Callable[[Any, Any], bool],
+    should_run_measurement_func: Callable[[dict], bool] = lambda *_: True,
     measurement_method_ranking: list[MeasurementMethodClassification] = DEFAULT_MEASUREMENT_METHOD_RANKING
 ) -> Callable[[dict], tuple[bool, str, dict, dict]]:
     """
@@ -342,6 +351,15 @@ def create_should_run_function(
         `(site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]) -> (should_run: bool, logs: dict)`, to
         determine whether there is enough site and cycles data available to compile the carbon stock change inventory.
 
+    summarise_land_use_func: Callable[[list[dict]], Any]
+        A function with the signature `(nodes: list[dict]) -> Any`, to reduce a list of `landCover`
+        [Management](https://www.hestia.earth/schema/Management) nodes into a land use summary that can be compared
+        with other summaries to determine whether land use change events have occured.
+
+    detect_land_use_change_func: Callable[[Any, Any], bool]
+        A function with the signature `(summary_a: Any, summary_b: Any) -> bool`, to determine whether a land use
+        change event has occured.
+
     should_run_measurement_func : Callable[[dict], bool], optional.
         An optional measurement validation function, with the signature `(measurement: dict) -> bool`, that can be used
         to add in additional criteria (`depthUpper`, `depthLower`, etc.) for the inclusion of a measurement in the
@@ -396,6 +414,8 @@ def create_should_run_function(
             ])
         ]
 
+        land_cover_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+
         seed = gen_seed(site)  # All cycles linked to the same site should be consistent
         rng = random.default_rng(seed)
 
@@ -403,14 +423,20 @@ def create_should_run_function(
             site, cycles, carbon_stock_measurements
         )
 
+        compile_inventory_func = _create_compile_inventory_function(
+            summarise_land_use_func=summarise_land_use_func,
+            detect_land_use_change_func=detect_land_use_change_func,
+            iterations=_ITERATIONS,
+            seed=rng,
+            measurement_method_ranking=measurement_method_ranking
+        )
+
         inventory, inventory_logs = (
-            _compile_inventory(
+            compile_inventory_func(
                 cycle_id,
                 cycles,
                 carbon_stock_measurements,
-                iterations=_ITERATIONS,
-                seed=rng,
-                measurement_method_ranking=measurement_method_ranking
+                land_cover_nodes
             ) if should_compile_inventory else ({}, {})
         )
 
@@ -462,69 +488,126 @@ def _get_site(cycle: dict) -> dict:
     return cycle.get("site", {})
 
 
-def _compile_inventory(
-    cycle_id: str,
-    cycles: list[dict],
-    carbon_stock_measurements: list[dict],
+def _create_compile_inventory_function(
+    *,
+    summarise_land_use_func: Callable[[list[dict]], Any],
+    detect_land_use_change_func: Callable[[Any, Any], bool],
     iterations: int = 10000,
     seed: Union[int, random.Generator, None] = None,
     measurement_method_ranking: list[MeasurementMethodClassification] = DEFAULT_MEASUREMENT_METHOD_RANKING
-) -> tuple[dict, dict]:
+) -> Callable:
     """
-    Compile an annual inventory of carbon stocks, changes in carbon stocks, carbon stock change emissions, and the share
-    of emissions of cycles based on the provided cycles and measurement data.
+    Create a compile inventory function for an emissions from carbon stock change model.
 
-    A separate inventory is compiled for each valid `MeasurementMethodClassification` present in the data, and the
-    strongest available method is chosen for each relevant inventory year. These inventories are then merged into one
-    final result.
-
-    The final inventory structure is:
-    ```
-    {
-        year (int): {
-            _InventoryKey.CARBON_STOCK: value (CarbonStock),
-            _InventoryKey.CARBON_STOCK_CHANGE: value (CarbonStockChange),
-            _InventoryKey.CO2_EMISSION: value (CarbonStockChangeEmission),
-            _InventoryKey.SHARE_OF_EMISSION: {
-                cycle_id (str): value (float),
-                ...cycle_ids
-            }
-        },
-        ...years
-    }
-    ```
+    Model-specific validation functions should be passed as parameters to this higher order function to determine how
+    land cover data is reduced down to a land use summary and how those land use summaries should be compared to
+    determine when land use change events have occured.
 
     Parameters
     ----------
-    cycle_id : str
-        The unique identifier of the cycle being processed.
-    cycles : list[dict]
-        A list of cycle data dictionaries, each representing land management events or cycles, grouped by years.
-    carbon_stock_measurements: list[dict]
-        A list of dictionaries, each representing carbon stock measurements across time and methods.
+    summarise_land_use_func: Callable[[list[dict]], Any]
+        A function with the signature `(nodes: list[dict]) -> Any`, to reduce a list of `landCover`
+        [Management](https://www.hestia.earth/schema/Management) nodes into a land use summary that can be compared
+        with other summaries to determine whether land use change events have occured.
+
+    detect_land_use_change_func: Callable[[Any, Any], bool]
+        A function with the signature `(summary_a: Any, summary_b: Any) -> bool`, to determine whether a land use
+        change event has occured.
+
     iterations : int, optional
         The number of iterations for stochastic processing (default is 10,000).
+
     seed : int, random.Generator, or None, optional
         Seed for random number generation to ensure reproducibility. Default is None.
 
+    measurement_method_ranking : list[MeasurementMethodClassification], optional
+        The order in which to prioritise `MeasurementMethodClassification`s when reducing the inventory down to a
+        single method per year. Defaults to:
+        ```
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
+        MeasurementMethodClassification.TIER_3_MODEL,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+        ```
+        n.b., measurements with methods not included in the ranking will not be included in the inventory.
 
     Returns
-    -------
-    tuple[dict, dict]
-        `(inventory, logs)`
+    ----------
+    Callable
+        The `compile_inventory` function.
     """
-    cycle_inventory = _compile_cycle_inventory(cycles)
-    carbon_stock_inventory = _compile_carbon_stock_inventory(
-        carbon_stock_measurements, iterations=iterations, seed=seed
-    )
+    def compile_inventory(
+        cycle_id: str,
+        cycles: list[dict],
+        carbon_stock_measurements: list[dict],
+        land_cover_nodes: list[dict]
+    ) -> tuple[dict, dict]:
+        """
+        Compile an annual inventory of carbon stocks, changes in carbon stocks, carbon stock change emissions, and the
+        share of emissions of cycles based on the provided cycles and measurement data.
 
-    logs = _generate_logs(cycle_inventory, carbon_stock_inventory)
+        A separate inventory is compiled for each valid `MeasurementMethodClassification` present in the data, and the
+        strongest available method is chosen for each relevant inventory year. These inventories are then merged into
+        one final result.
+
+        The final inventory structure is:
+        ```
+        {
+            year (int): {
+                _InventoryKey.CARBON_STOCK: value (CarbonStock),
+                _InventoryKey.CARBON_STOCK_CHANGE: value (CarbonStockChange),
+                _InventoryKey.CO2_EMISSION: value (CarbonStockChangeEmission),
+                _InventoryKey.SHARE_OF_EMISSION: {
+                    cycle_id (str): value (float),
+                    ...cycle_ids
+                },
+                _InventoryKey.YEARS_SINCE_LUC_EVENT: value (int)
+            },
+            ...years
+        }
+        ```
+
+        Parameters
+        ----------
+        cycle_id : str
+            The unique identifier of the cycle being processed.
+        cycles : list[dict]
+            A list of [Cycle](https://www.hestia.earth/schema/Cycles) nodes related to the site.
+        carbon_stock_measurements : list[dict]
+            A list of [Measurement](https://www.hestia.earth/schema/Measurement) nodes, representing carbon stock
+            measurements across time and methods.
+        land_cover_nodes : list[dict]
+            A list of `landCover `[Management](https://www.hestia.earth/schema/Management) nodes, representing the
+            site's land cover over time.
 
-    inventory = _squash_inventory(
-        cycle_id, cycle_inventory, carbon_stock_inventory, measurement_method_ranking=measurement_method_ranking
-    )
 
-    return inventory, logs
+        Returns
+        -------
+        tuple[dict, dict]
+            `(inventory, logs)`
+        """
+        cycle_inventory = _compile_cycle_inventory(cycles)
+        carbon_stock_inventory = _compile_carbon_stock_inventory(
+            carbon_stock_measurements, iterations=iterations, seed=seed
+        )
+        land_use_inventory = _compile_land_use_inventory(
+            land_cover_nodes, summarise_land_use_func, detect_land_use_change_func
+        )
+
+        inventory = _squash_inventory(
+            cycle_id,
+            cycle_inventory,
+            carbon_stock_inventory,
+            land_use_inventory,
+            measurement_method_ranking=measurement_method_ranking
+        )
+
+        logs = _generate_logs(cycle_inventory, carbon_stock_inventory, land_use_inventory)
+
+        return inventory, logs
+
+    return compile_inventory
 
 
 def _compile_cycle_inventory(cycles: list[dict]) -> dict:
@@ -724,7 +807,7 @@ def _preprocess_carbon_stocks(
         dates,
         decay_fn=lambda dt: exponential_decay(
             dt,
-            tau=calc_tau(_TRANSITION_PERIOD),
+            tau=calc_tau(_TRANSITION_PERIOD_DAYS),
             initial_value=_MAX_CORRELATION,
             final_value=_MIN_CORRELATION
         )
@@ -846,6 +929,100 @@ def _calculate_co2_emissions(carbon_stock_changes_by_year: dict) -> dict:
     }
 
 
+def _compile_land_use_inventory(
+    land_cover_nodes: list[dict],
+    summarise_land_use_func: Callable[[list[dict]], Any],
+    detect_land_use_change_func: Callable[[Any, Any], bool]
+) -> dict:
+    """
+    Compile an annual inventory of land use data.
+
+    The returned inventory has the shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.LAND_USE_SUMMARY: value (Any),
+            _InventoryKey.LAND_USE_CHANGE_EVENT: value (bool),
+            _InventoryKey.YEARS_SINCE_LUC_EVENT: value (int)
+        },
+        ...years
+    }
+    ```
+
+    Parameters
+    ----------
+    land_cover_nodes : list[dict]
+        A list of `landCover` Management nodes, representing the site's land cover over time.
+    summarise_land_use_func: Callable[[list[dict]], Any]
+        A function with the signature `(nodes: list[dict]) -> Any`, to reduce a list of `landCover` Management nodes
+        into a land use summary that can be compared with other summaries to determine whether land use change events
+        have occured.
+    detect_land_use_change_func: Callable[[Any, Any], bool]
+        A function with the signature `(summary_a: Any, summary_b: Any) -> bool`, to determine whether a land use
+        change event has occured.
+
+    Returns
+    -------
+    dict
+        The land use inventory.
+    """
+    land_cover_nodes_by_year = group_nodes_by_year(land_cover_nodes)
+
+    def build_inventory_year(result: dict, year_pair: tuple[int, int]) -> dict:
+        """
+        Build a year of the inventory using the data from `land_cover_nodes_by_year`.
+
+        Parameters
+        ----------
+        inventory: dict
+            The land cover change portion of the inventory. Must have the same shape as the returned dict.
+        year_pair : tuple[int, int]
+            A tuple with the shape `(prev_year, current_year)`.
+        Returns
+        -------
+        dict
+            The land use inventory.
+        """
+
+        prev_year, current_year = year_pair
+        land_cover_nodes = land_cover_nodes_by_year.get(current_year, {})
+
+        land_use_summary = summarise_land_use_func(land_cover_nodes)
+        prev_land_use_summary = result.get(prev_year, {}).get(_InventoryKey.LAND_USE_SUMMARY, {})
+
+        is_luc_event = detect_land_use_change_func(land_use_summary, prev_land_use_summary)
+
+        time_delta = current_year - prev_year
+        prev_years_since_luc_event = result.get(prev_year, {}).get(_InventoryKey.YEARS_SINCE_LUC_EVENT, 0)
+        years_since_luc_event = time_delta if is_luc_event else prev_years_since_luc_event + time_delta
+
+        update_dict = {
+            current_year: {
+                _InventoryKey.LAND_USE_SUMMARY: land_use_summary,
+                _InventoryKey.LAND_USE_CHANGE_EVENT: is_luc_event,
+                _InventoryKey.YEARS_SINCE_LUC_EVENT: years_since_luc_event,
+            }
+        }
+        return result | update_dict
+
+    should_run = len(land_cover_nodes_by_year) > 0
+    start_year = min(land_cover_nodes_by_year.keys(), default=None)
+
+    return reduce(
+        build_inventory_year,
+        pairwise(land_cover_nodes_by_year.keys()),  # Inventory years need data from previous year to be compiled.
+        {
+            start_year: {
+                _InventoryKey.LAND_USE_SUMMARY: summarise_land_use_func(
+                    land_cover_nodes_by_year.get(start_year, [])
+                ),
+                _InventoryKey.LAND_USE_CHANGE_EVENT: False,
+                _InventoryKey.YEARS_SINCE_LUC_EVENT: _DEFAULT_YEARS_SINCE_LUC_EVENT
+            }
+        }
+    ) if should_run else {}
+
+
 def _sorted_merge(*sources: Union[dict, list[dict]]) -> dict:
     """
     Merge one or more dictionaries into a single dictionary, ensuring that the keys are sorted in temporal order.
@@ -873,6 +1050,7 @@ def _squash_inventory(
     cycle_id: str,
     cycle_inventory: dict,
     carbon_stock_inventory: dict,
+    land_use_inventory: dict,
     measurement_method_ranking: list[MeasurementMethodClassification] = DEFAULT_MEASUREMENT_METHOD_RANKING
 ) -> dict:
     """
@@ -884,6 +1062,7 @@ def _squash_inventory(
     ----------
     cycle_id : str
         The unique identifier of the cycle being processed.
+
     cycle_inventory : dict
         A dictionary representing the share of emissions for each cycle, grouped by year.
         Format:
@@ -898,6 +1077,7 @@ def _squash_inventory(
             ...more years
         }
         ```
+
     carbon_stock_inventory : dict
         A dictionary representing carbon stock and emissions data grouped by measurement method and year.
         Format:
@@ -915,6 +1095,32 @@ def _squash_inventory(
         }
         ```
 
+    land_use_inventory : dict
+        A dictionary representing land use and land use change data grouped by year.
+        Format:
+        ```
+        {
+            year (int): {
+                _InventoryKey.LAND_USE_SUMMARY: value (Any),
+                _InventoryKey.LAND_USE_CHANGE_EVENT: value (bool),
+                _InventoryKey.YEARS_SINCE_LUC_EVENT: value (int)
+            },
+            ...years
+        }
+        ```
+
+    measurement_method_ranking : list[MeasurementMethodClassification], optional
+        The order in which to prioritise `MeasurementMethodClassification`s when reducing the inventory down to a
+        single method per year. Defaults to:
+        ```
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
+        MeasurementMethodClassification.TIER_3_MODEL,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+        ```
+        n.b., measurements with methods not included in the ranking will not be included in the inventory.
+
     Returns
     -------
     dict
@@ -951,8 +1157,12 @@ def _squash_inventory(
     def squash(result: dict, year: int) -> dict:
         update_dict = next(
             (
-                {year: reduce(merge, [carbon_stock_inventory[method][year], cycle_inventory[year]], dict())}
-                for method in measurement_method_ranking if should_run_group(method, year)
+                {
+                    year: {
+                        **_get_land_use_change_data(year, land_use_inventory),
+                        **reduce(merge, [carbon_stock_inventory[method][year], cycle_inventory[year]], dict())
+                    }
+                } for method in measurement_method_ranking if should_run_group(method, year)
             ),
             {}
         )
@@ -961,9 +1171,44 @@ def _squash_inventory(
     return reduce(squash, inventory_years, dict())
 
 
-def _generate_logs(cycle_inventory: dict, carbon_stock_inventory: dict) -> dict:
+def _get_land_use_change_data(
+    year: int,
+    land_use_inventory: dict
+) -> dict:
+    """
+    Retrieve a value for `_InventoryKey.YEARS_SINCE_LUC_EVENT` for a specific inventory year, or gapfill it from
+    available data.
+
+    If no land use data is available in the inventory, the site is assumed to have a stable land use and all emissions
+    will be allocated to management changes.
     """
-    Generate logs for the compiled inventory, providing details about cycle and carbon inventories.
+    closest_inventory_year = next(
+        (key for key in land_use_inventory.keys() if key >= year),      # get the next inventory year
+        min(
+            land_use_inventory.keys(), key=lambda x: abs(x - year),     # else the previous
+            default=None                                                # else return `None`
+        )
+    )
+
+    delta_time = closest_inventory_year - year if closest_inventory_year else 0
+    inventory_data = land_use_inventory.get(closest_inventory_year, {})
+
+    years_since_luc_event = (
+        inventory_data.get(_InventoryKey.YEARS_SINCE_LUC_EVENT, _DEFAULT_YEARS_SINCE_LUC_EVENT) - delta_time
+    )
+
+    return {
+        _InventoryKey.YEARS_SINCE_LUC_EVENT: years_since_luc_event
+    }
+
+
+def _generate_logs(
+    cycle_inventory: dict,
+    carbon_stock_inventory: dict,
+    land_use_inventory: dict
+) -> dict:
+    """
+    Generate logs for the compiled inventory, providing details about cycle, carbon and land use inventories.
 
     Parameters
     ----------
@@ -971,6 +1216,8 @@ def _generate_logs(cycle_inventory: dict, carbon_stock_inventory: dict) -> dict:
         The compiled cycle inventory.
     carbon_stock_inventory : dict
         The compiled carbon stock inventory.
+    land_use_inventory : dict
+        The compiled carbon stock inventory.
 
     Returns
     -------
@@ -980,6 +1227,7 @@ def _generate_logs(cycle_inventory: dict, carbon_stock_inventory: dict) -> dict:
     logs = {
         "cycle_inventory": _format_cycle_inventory(cycle_inventory),
         "carbon_stock_inventory": _format_carbon_stock_inventory(carbon_stock_inventory),
+        "land_use_inventory": _format_land_use_inventory(land_use_inventory)
     }
     return logs
 
@@ -1038,6 +1286,43 @@ def _format_carbon_stock_inventory(carbon_stock_inventory: dict) -> str:
     ) if should_run else "None"
 
 
+def _format_land_use_inventory(land_use_inventory: dict) -> str:
+    """
+    Format the carbon stock inventory for logging as a table. Rows represent inventory years, columns represent land
+    use change data. If the inventory is invalid, return `"None"` as a string.
+
+    TODO: Implement logging of land use summary.
+    """
+    KEYS = [
+        _InventoryKey.LAND_USE_CHANGE_EVENT,
+        _InventoryKey.YEARS_SINCE_LUC_EVENT
+    ]
+
+    inventory_years = sorted(set(non_empty_list(years for years in land_use_inventory.keys())))
+    should_run = land_use_inventory and len(inventory_years) > 0
+
+    return log_as_table(
+        {
+            "year": year,
+            **{
+                key.value: _LAND_USE_INVENTORY_KEY_TO_FORMAT_FUNC[key](
+                    land_use_inventory.get(year, {}).get(key)
+                ) for key in KEYS
+            }
+        } for year in inventory_years
+    ) if should_run else "None"
+
+
+def _format_bool(value: Optional[bool]) -> str:
+    """Format a bool for logging in a table."""
+    return str(value) if isinstance(value, bool) else "None"
+
+
+def _format_int(value: Optional[float]) -> str:
+    """Format an int for logging in a table. If the value is invalid, return `"None"` as a string."""
+    return f"{value:.0f}" if isinstance(value, (float, int)) else "None"
+
+
 def _format_number(value: Optional[float]) -> str:
     """Format a float for logging in a table. If the value is invalid, return `"None"` as a string."""
     return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
@@ -1067,8 +1352,20 @@ def _format_named_tuple(value: Optional[Union[CarbonStock, CarbonStockChange, Ca
     )
 
 
+_LAND_USE_INVENTORY_KEY_TO_FORMAT_FUNC = {
+    _InventoryKey.LAND_USE_CHANGE_EVENT: _format_bool,
+    _InventoryKey.YEARS_SINCE_LUC_EVENT: _format_int
+}
+"""
+Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of
+the `dict` keys.
+"""
+
+
 def create_run_function(
-    new_emission_func: Callable[[EmissionMethodTier, dict], dict]
+    new_emission_func: Callable[[EmissionMethodTier, dict], dict],
+    land_use_change_emission_term_id: str,
+    management_change_emission_term_id: str
 ) -> Callable[[str, dict], list[dict]]:
     """
     Create a run function for an emissions from carbon stock change model.
@@ -1080,12 +1377,42 @@ def create_run_function(
     ----------
     new_emission_func : Callable[[EmissionMethodTier, tuple], dict]
         A function, with the signature `(method_tier: dict, **kwargs: dict) -> (emission_node: dict)`.
+    land_use_change_emission_term_id : str
+        The term id for emissions allocated to land use changes.
+    management_change_emission_term_id : str
+        The term id for emissions allocated to management changes.
 
     Returns
     -------
     Callable[[str, dict], list[dict]]
         The customised `run` function with the signature `(cycle_id: str, inventory: dict) -> emissions: list[dict]`.
     """
+    def reduce_emissions(result: dict, year: int, cycle_id: str, inventory: dict):
+        """
+        Assign emissions to either the land use or management change term ids and sum together.
+        """
+        data = inventory[year]
+        years_since_luc_event = data[_InventoryKey.YEARS_SINCE_LUC_EVENT]
+        emission_term_id = (
+            land_use_change_emission_term_id if years_since_luc_event <= _TRANSITION_PERIOD_YEARS
+            else management_change_emission_term_id
+        )
+
+        rescaled_emission = _rescale_carbon_stock_change_emission(
+            data[_InventoryKey.CO2_EMISSION], data[_InventoryKey.SHARE_OF_EMISSION][cycle_id]
+        )
+
+        previous_emission = result.get(emission_term_id)
+
+        update_dict = {
+            emission_term_id: (
+                _add_carbon_stock_change_emissions(previous_emission, rescaled_emission) if previous_emission
+                else rescaled_emission
+            )
+        }
+
+        return result | update_dict
+
     def run(cycle_id: str, inventory: dict) -> list[dict]:
         """
         Calculate emissions for a specific cycle using from a carbon stock change using pre-compiled inventory data.
@@ -1103,22 +1430,24 @@ def create_run_function(
         Returns
         -------
         list[dict]
-            A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
+            A list of [Emission](https://www.hestia.earth/schema/Emission) nodes containing model results.
         """
-        rescaled_emissions = [
-            _rescale_carbon_stock_change_emission(
-                group[_InventoryKey.CO2_EMISSION], group[_InventoryKey.SHARE_OF_EMISSION][cycle_id]
-            ) for group in inventory.values()
-        ]
-        total_emission = reduce(_add_carbon_stock_change_emissions, rescaled_emissions)
-
-        descriptive_stats = calc_descriptive_stats(
-            total_emission.value,
-            EmissionStatsDefinition.SIMULATED,
-            decimals=6
+        assigned_emissions = reduce(
+            lambda result, year: reduce_emissions(result, year, cycle_id, inventory),
+            inventory.keys(),
+            {}
         )
 
-        method_tier = total_emission.method
-        return [new_emission_func(method_tier=method_tier, **descriptive_stats)]
+        return [
+            new_emission_func(
+                term_id=emission_term_id,
+                method_tier=total_emission.method,
+                **calc_descriptive_stats(
+                    total_emission.value,
+                    EmissionStatsDefinition.SIMULATED,
+                    decimals=6
+                )
+            ) for emission_term_id, total_emission in assigned_emissions.items()
+        ]
 
     return run