hestia-earth-models 0.61.7__py3-none-any.whl → 0.62.0__py3-none-any.whl

hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -1,6 +1,8 @@
 from collections.abc import Iterable
+from datetime import datetime
 from enum import Enum
 from functools import reduce
+from itertools import product
 from pydash.objects import merge
 from typing import NamedTuple, Optional, Union
 
@@ -8,15 +10,19 @@ from hestia_earth.schema import (
     CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification
 )
 from hestia_earth.utils.date import diff_in_days
-from hestia_earth.utils.tools import flatten, non_empty_list
+from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import (
-    group_nodes_by_year, GroupNodesByYearMode, node_term_match,
+    _get_datestr_format, _gapfill_datestr, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
-from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.measurement import OLDEST_DATE
+from hestia_earth.models.utils.emission import _new_emission, min_emission_method_tier
+from hestia_earth.models.utils.measurement import (
+    group_measurements_by_method_classification, min_measurement_method_classification,
+    to_measurement_method_classification
+)
 from hestia_earth.models.utils.site import related_cycles
 
 from .utils import check_consecutive
@@ -57,580 +63,679 @@ DEPTH_LOWER = 30
 
 ORGANIC_CARBON_PER_HA_TERM_ID = 'organicCarbonPerHa'
 
+VALID_DATE_FORMATS = {
+    DatestrFormat.YEAR,
+    DatestrFormat.YEAR_MONTH,
+    DatestrFormat.YEAR_MONTH_DAY,
+    DatestrFormat.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND
+}
+
+VALID_MEASUREMENT_METHOD_CLASSIFICATIONS = [
+    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
+    MeasurementMethodClassification.TIER_3_MODEL,
+    MeasurementMethodClassification.TIER_2_MODEL,
+    MeasurementMethodClassification.TIER_1_MODEL
+]
+"""
+The list of `MeasurementMethodClassification`s that can be used to calculate SOC stock change emissions, ranked in
+order from strongest to weakest.
+"""
+
+
+class _InventoryKey(Enum):
+    """
+    The inner keys of the annualised inventory created by the `_compile_inventory` function.
+
+    The value of each enum member is formatted to be used as a column header in the `log_as_table` function.
+    """
+    SOC_STOCK = "soc-stock"
+    SOC_STOCK_CHANGE = "soc-stock-change"
+    CO2_EMISSION = "co2-emission"
+    SHARE_OF_EMISSION = "share-of-emissions"
+
 
 SocStock = NamedTuple("SocStock", [
     ("value", float),
+    ("date", str),
     ("method", MeasurementMethodClassification)
 ])
 """
-NamedTuple representing either an SOC stock or SOC stock change.
+NamedTuple representing an SOC stock.
 
 Attributes
 ----------
 value : float
     The value of the SOC stock (kg C ha-1).
+date : str
+    The date of the measurement as a datestr with format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
 method: MeasurementMethodClassification
     The measurement method for the SOC stock.
 """
 
-
-_InnerKey = Enum("_InnerKey", [
-    "SOC_STOCK",
-    "SOC_STOCK_CHANGE",
-    "SHARE_OF_EMISSIONS"
+SocStockChange = NamedTuple("SocStockChange", [
+    ("value", float),
+    ("start_date", str),
+    ("end_date", str),
+    ("method", MeasurementMethodClassification)
 ])
 """
-The inner keys of the annualised inventory created by the `_should_run` function.
-"""
-
+NamedTuple representing an SOC stock change.
 
-REQUIRED_INNER_KEYS = [_InnerKey.SHARE_OF_EMISSIONS, _InnerKey.SOC_STOCK_CHANGE]
+Attributes
+----------
+value : float
+    The value of the SOC stock change (kg C ha-1).
+start_date : str
+    The start date of the SOC stock change event as a datestr with the format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
+end_date : str
+    The end date of the SOC stock change event as a datestr with the format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
+method: MeasurementMethodClassification
+    The measurement method for the SOC stock change.
+"""
 
-MEASUREMENT_METHOD_RANKING = [
-    MeasurementMethodClassification.UNSOURCED_ASSUMPTION,
-    MeasurementMethodClassification.EXPERT_OPINION,
-    MeasurementMethodClassification.COUNTRY_LEVEL_STATISTICAL_DATA,
-    MeasurementMethodClassification.REGIONAL_STATISTICAL_DATA,
-    MeasurementMethodClassification.GEOSPATIAL_DATASET,
-    MeasurementMethodClassification.PHYSICAL_MEASUREMENT_ON_NEARBY_SITE,
-    MeasurementMethodClassification.TIER_1_MODEL,
-    MeasurementMethodClassification.TIER_2_MODEL,
-    MeasurementMethodClassification.TIER_3_MODEL,
-    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
-    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT
-]
+SocStockChangeEmission = NamedTuple("SocStockChangeEmission", [
+    ("value", float),
+    ("start_date", str),
+    ("end_date", str),
+    ("method", EmissionMethodTier)
+])
 """
-A ranking of `MeasurementMethodClassification`s from weakest to strongest used to determine the `EmissionMethodTier` of
-the `co2ToAirSoilOrganicCarbonStockChangeManagementChange` output.
+NamedTuple representing an SOC stock change emission.
 
-The `EmissionMethodTier` should be based on the weakest `MeasurementMethodClassification` between the current SOC and
-previous SOC.
+Attributes
+----------
+value : float
+    The value of the SOC stock change (kg CO2 ha-1).
+start_date : str
+    The start date of the SOC stock change emission as a datestr with the format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
+end_date : str
+    The end date of the SOC stock change emission as a datestr with the format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
+method: MeasurementMethodClassification
+    The emission method tier.
 """
 
 
-def _to_measurement_method_classification(
-    method: Union[str, MeasurementMethodClassification]
-) -> Optional[MeasurementMethodClassification]:
+def _emission(value: float, method_tier: EmissionMethodTier) -> dict:
     """
-    Convert the input to a MeasurementMethodClassification object if possible.
+    Create an emission node based on the provided value and method tier.
+
+    See [Emission schema](https://www.hestia.earth/schema/Emission) for more information.
 
     Parameters
     ----------
-    method : str | MeasurementMethodClassification
-        The measurement method as either a `str` or `MeasurementMethodClassification`.
+    value : float
+        The emission value (kg CO2 ha-1).
+
+    method_tier : EmissionMethodTier
+        The emission method tier.
 
     Returns
     -------
-    MeasurementMethodClassification | None
-        The matching `MeasurementMethodClassification` or `None` if invalid string.
+    dict
+        The emission dictionary with keys 'depth', 'value', and 'methodTier'.
     """
-    return (
-        method if isinstance(method, MeasurementMethodClassification)
-        else MeasurementMethodClassification(method) if method in (m.value for m in MeasurementMethodClassification)
-        else None
-    )
+    emission = _new_emission(TERM_ID, MODEL)
+    emission["depth"] = DEPTH_LOWER
+    emission["value"] = [value]
+    emission["methodTier"] = method_tier.value
+    return emission
 
 
-def _get_min_measurement_method(
-    *methods: Union[MeasurementMethodClassification, Iterable[MeasurementMethodClassification]]
-) -> MeasurementMethodClassification:
+def _should_run(cycle: dict) -> tuple[bool, str, dict]:
     """
-    Get the minimum ranking measurement method from the provided methods.
+    Determine if calculations should run for a given [Cycle](https://www.hestia.earth/schema/Cycle) based on SOC stock
+    and emissions data.
 
     Parameters
     ----------
-    *methods : MeasurementMethodClassification | Iterable[MeasurementMethodClassification]
-        Measurement methods or iterables of measurement methods.
+    cycle : dict
+        The cycle dictionary for which the calculations will be evaluated.
 
     Returns
     -------
-    MeasurementMethodClassification
-        The measurement method with the minimum ranking.
+    tuple[bool, str, dict]
+        `(should_run, cycle_id, inventory)`
     """
+    cycle_id = cycle.get("@id")
+    site = _get_site(cycle)
+    soc_measurements = [node for node in site.get("measurements", []) if _validate_soc_measurement(node)]
+    cycles = related_cycles(site)
 
-    # flatten methods into a single list, convert any strings into `MeasurementMethodClassification`s
-    # and remove invalid methods.
-    _methods = non_empty_list(flatten([
-        [_to_measurement_method_classification(method) for method in arg] if isinstance(arg, Iterable)
-        else [_to_measurement_method_classification(arg)] for arg in methods
-    ]))
-
-    return min(
-        _methods,
-        key=lambda method: MEASUREMENT_METHOD_RANKING.index(method),
-        default=list(MEASUREMENT_METHOD_RANKING)[0]
-    )
+    has_soc_measurements = len(soc_measurements) > 0
+    has_cycles = len(cycles) > 0
+    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
 
+    should_compile_inventory = all([has_cycles, has_functional_unit_1_ha, has_soc_measurements])
 
-def _get_max_measurement_method(
-    *methods: Union[MeasurementMethodClassification, Iterable[MeasurementMethodClassification]]
-) -> MeasurementMethodClassification:
-    """
-    Get the max ranking measurement method from the provided methods.
+    inventory, logs = _compile_inventory(cycle_id, cycles, soc_measurements) if should_compile_inventory else ({}, {})
 
-    Parameters
-    ----------
-    *methods : MeasurementMethodClassification | Iterable[MeasurementMethodClassification]
-        Measurement methods or iterables of measurement methods.
-
-    Returns
-    -------
-    MeasurementMethodClassification
-        The measurement method with the maximum ranking.
-    """
+    has_valid_inventory = len(inventory) > 0
+    has_consecutive_years = check_consecutive(inventory.keys())
 
-    # flatten methods into a single list, convert any strings into `MeasurementMethodClassification`s
-    # and remove invalid methods.
-    _methods = non_empty_list(flatten([
-        [_to_measurement_method_classification(method) for method in arg] if isinstance(arg, Iterable)
-        else [_to_measurement_method_classification(arg)] for arg in methods
-    ]))
-
-    return max(
-        _methods,
-        key=lambda method: MEASUREMENT_METHOD_RANKING.index(method),
-        default=MEASUREMENT_METHOD_RANKING[-1]
+    logRequirements(
+        cycle, model=MODEL, term=TERM_ID,
+        has_soc_measurements=has_soc_measurements,
+        has_cycles=has_cycles,
+        has_functional_unit_1_ha=has_functional_unit_1_ha,
+        has_valid_inventory=has_valid_inventory,
+        has_consecutive_years=has_consecutive_years,
+        **logs
     )
 
+    should_run = all([has_valid_inventory, has_consecutive_years])
 
-DEFAULT_EMISSION_METHOD_TIER = EmissionMethodTier.TIER_1
-MEASUREMENT_METHOD_CLASSIFICATION_TO_EMISSION_METHOD_TIER = {
-    MeasurementMethodClassification.TIER_2_MODEL: EmissionMethodTier.TIER_2,
-    MeasurementMethodClassification.TIER_3_MODEL: EmissionMethodTier.TIER_3,
-    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS: EmissionMethodTier.MEASURED,
-    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT: EmissionMethodTier.MEASURED,
-}
-"""
-A mapping between `MeasurementMethodClassification`s and `EmissionMethodTier`s. As SOC measurements can be
-measured/estimated through a variety of methods, the emission model needs be able to assign an emission tier for each.
-Any `MeasurementMethodClassification` not in the mapping should be assigned `DEFAULT_EMISSION_METHOD_TIER`.
-"""
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
 
+    return should_run, cycle_id, inventory
 
-def _get_emission_method_tier(
-    measurement_method: MeasurementMethodClassification
-) -> EmissionMethodTier:
+
+def _get_site(cycle: dict) -> dict:
     """
-    Get the emission method tier based on the provided measurement method.
+    Get the [Site](https://www.hestia.earth/schema/Site) data from a [Cycle](https://www.hestia.earth/schema/Cycle).
 
     Parameters
     ----------
-    measurement_method : MeasurementMethodClassification
-        The measurement method classification.
+    cycle : dict
 
     Returns
     -------
-    EmissionMethodTier
-        The corresponding emission method tier.
+    str
     """
-    return MEASUREMENT_METHOD_CLASSIFICATION_TO_EMISSION_METHOD_TIER.get(
-        measurement_method, DEFAULT_EMISSION_METHOD_TIER
-    )
+    return cycle.get("site", {})
 
 
-def _emission(
-    value: float, method_tier: EmissionMethodTier
-) -> dict:
+def _validate_soc_measurement(node: dict) -> bool:
     """
-    Create an emission node based on the provided value and method tier.
-
-    See [Emission schema](https://www.hestia.earth/schema/Emission) for more information.
+    Validate a [Measurement](https://www.hestia.earth/schema/Measurement) to determine whether it is a valid
+    `organicCarbonPerHa` node.
 
     Parameters
     ----------
-    value : float
-        The emission value (kg CO2 ha-1).
-
-    method_tier : EmissionMethodTier
-        The emission method tier.
+    node : dict
+        The node to be validated.
 
     Returns
     -------
-    dict
-        The emission dictionary with keys 'depth', 'value', and 'methodTier'.
+    bool
+        `True` if the node passes all validation criteria, `False` otherwise.
     """
-    emission = _new_emission(TERM_ID, MODEL)
-    emission["depth"] = DEPTH_LOWER
-    emission["value"] = [value]
-    emission["methodTier"] = method_tier.value
-    return emission
+    value = node.get("value", [])
+    dates = node.get("dates", [])
+    return all([
+        node_term_match(node, ORGANIC_CARBON_PER_HA_TERM_ID),
+        node.get("depthUpper") == DEPTH_UPPER,
+        node.get("depthLower") == DEPTH_LOWER,
+        node.get("methodClassification") in (m.value for m in VALID_MEASUREMENT_METHOD_CLASSIFICATIONS),
+        len(value) > 0,
+        len(value) == len(dates),
+        all(_get_datestr_format(datestr) in VALID_DATE_FORMATS for datestr in dates)
+    ])
 
 
-def _linear_interpolate_soc_stock(
-    start_year: int,
-    end_year: int,
-    start_soc_stock: SocStock,
-    end_soc_stock: SocStock,
-    year: int
-) -> SocStock:
+def _compile_inventory(cycle_id: str, cycles: list[dict], soc_measurements: list[dict]) -> tuple[dict, dict]:
     """
-    Linearly interpolate the SocStock value for a specific year between two given years.
+    Compile an annual inventory of SOC stocks, SOC stock changes, SOC stock change emissions and the share of emissions
+    of cycles.
 
-    The `MeasurementMethodClassification` of any SOC stocks estimated using this method should be `tier 1 model` as the
-    method is derived from IPCC (2019) Tier 1 SOC model.
+    A separate inventory is compiled for each valid `MeasurementMethodClassification` present in the input data, which
+    are then merged together by selecting the strongest available method for each relevant inventory year.
+
+    The returned inventory has the shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SOC_STOCK: value (SocStock),
+            _InventoryKey.SOC_STOCK_CHANGE: value (SocStockChange),
+            _InventoryKey.CO2_EMISSION: value (SocStockChangeEmission),
+            _InventoryKey.SHARE_OF_EMISSION: {
+                cycle_id (str): value (float),
+                ...cycle_ids
+            }
+        },
+        ...years
+    }
+    ```
 
     Parameters
     ----------
-    start_year : int
-        The start year for interpolation.
-    end_year : int
-        The end year for interpolation.
-    start_soc_stock : SocStock
-        The `SocStock` corresponding to the start year.
-    end_soc_stock : SocStock
-        The `SocStock` corresponding to the end year.
-    year : int
-        The target year for interpolation.
+    cycle_id : str
+    cycles : list[dict]
+    soc_measurements: list[dict]
 
     Returns
     -------
-    SocStock
-        The interpolated `SocStock` for the specified year.
+    tuple[dict, dict]
+        `(inventory, logs)`
     """
-    METHOD = MeasurementMethodClassification.TIER_1_MODEL
+    cycle_inventory = _compile_cycle_inventory(cycles)
 
-    time_ratio = (year - start_year) / (end_year - start_year)
-    soc_delta = (end_soc_stock.value - start_soc_stock.value) * time_ratio
-    value = start_soc_stock.value + soc_delta
+    soc_measurements_by_method = group_measurements_by_method_classification(soc_measurements)
+    soc_inventory = {
+        method: _compile_soc_inventory(soc_measurements)
+        for method, soc_measurements in soc_measurements_by_method.items()
+    }
 
-    return SocStock(value, METHOD)
+    logs = {
+        "cycle_inventory": _format_cycle_inventory(cycle_inventory),
+        "soc_inventory": _format_soc_inventory(soc_inventory)
+    }
 
+    inventory = _squash_inventory(cycle_id, cycle_inventory, soc_inventory)
+    return inventory, logs
 
-def _calc_soc_stock_change(start_soc_stock: SocStock, end_soc_stock: SocStock) -> SocStock:
+
+def _compile_cycle_inventory(cycles: list[dict]) -> dict:
     """
-    Calculate the change in SOC stock change between the current and previous states.
+    Calculate grouped share of emissions for cycles based on the amount they contribute the the overall land management
+    of an inventory year.
 
-    The method should be the weaker of the two `MeasurementMethodClassification`s.
+    This function groups cycles by year, then calculates the share of emissions for each cycle based on the
+    "fraction_of_group_duration" value. The share of emissions is normalized by the sum of cycle occupancies for the
+    entire dataset to ensure the values represent a valid share.
+
+    The returned inventory has the shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SHARE_OF_EMISSION: {
+                cycle_id (str): value (float),
+                ...cycle_ids
+            }
+        },
+        ...years
+    }
+    ```
 
     Parameters
     ----------
-    start_soc_stock : SocStock
-        The SOC stock at the start (kg C ha-1).
-
-    end_soc_stock : SocStock
-        The SOC stock at the end (kg C ha-1).
+    cycles : list[dict]
+        List of [Cycle nodes](https://www.hestia.earth/schema/Cycle), where each cycle dictionary should contain a
+        "fraction_of_group_duration" key added by the `group_nodes_by_year` function.
 
     Returns
     -------
-    SocStock
-        The SOC stock change (kg C ha-1).
+    dict
+        A dictionary with grouped share of emissions for each cycle based on the fraction of the year.
     """
-    value = end_soc_stock.value - start_soc_stock.value
-    method = _get_min_measurement_method(end_soc_stock.method, start_soc_stock.method)
-
-    return SocStock(value, method)
+    grouped_cycles = group_nodes_by_year(cycles)
+    return {
+        year: {
+            _InventoryKey.SHARE_OF_EMISSION: {
+                cycle["@id"]: (
+                    cycle.get("fraction_of_group_duration", 0)
+                    / sum(cycle.get("fraction_of_group_duration", 0) for cycle in cycles)
+                ) for cycle in cycles
+            }
+        } for year, cycles in grouped_cycles.items()
+    }
 
 
-def _convert_c_to_co2(kg_c: float) -> float:
+def _compile_soc_inventory(soc_measurements: list[dict]) -> dict:
     """
-    Convert mass of carbon (C) to carbon dioxide (CO2) using the atomic conversion ratio.
+    Compile an annual inventory of SOC stock data and pre-computed SOC stock change emissions.
 
-    n.b. `get_atomic_conversion` returns the ratio C:CO2 (~44/12).
+    The returned inventory has the shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SOC_STOCK: value (SocStock),
+            _InventoryKey.SOC_STOCK_CHANGE: value (SocStockChange),
+            _InventoryKey.CO2_EMISSION: value (SocStockChangeEmission)
+        },
+        ...years
+    }
+    ```
 
     Parameters
     ----------
-    kg_c : float
-        Mass of carbon (C) to be converted to carbon dioxide (CO2) (kg C).
+    soc_measurements : list[dict]
+        List of pre-validated `organicCarbonPerHa` [Measurement nodes](https://www.hestia.earth/schema/Measurement).
 
     Returns
     -------
-    float
-        Mass of carbon dioxide (CO2) resulting from the conversion (kg CO2).
+    dict
+        The annual inventory.
     """
-    return kg_c * get_atomic_conversion(Units.KG_CO2, Units.TO_C)
 
+    values = flatten(measurement.get("value", []) for measurement in soc_measurements)
+    dates = flatten(
+        [_gapfill_datestr(datestr, DatestrGapfillMode.END) for datestr in measurement.get("dates", [])]
+        for measurement in soc_measurements
+    )
+    methods = flatten(
+        [MeasurementMethodClassification(measurement.get("methodClassification")) for _ in measurement.get("value", [])]
+        for measurement in soc_measurements
+    )
 
-def _soc_stock_stock_change_to_co2_emission(
-    soc_stock_change_value: float,
-    share_of_emission: float
-) -> float:
-    """
-    Convert SOC stock change to CO2 emission using the given share of emission.
+    soc_stocks = sorted(
+        [SocStock(value, datestr, method) for value, datestr, method in zip(values, dates, methods)],
+        key=lambda soc_stock: soc_stock.date
+    )
 
-    Parameters
-    ----------
-    soc_stock_change_value : float
-        The change in SOC stock value.
+    def interpolate_between(result: dict, soc_stock_pair: tuple[SocStock, SocStock]) -> dict:
+        start, end = soc_stock_pair[0], soc_stock_pair[1]
 
-    share_of_emission : float
-        The share of emission associated with the SOC stock change.
+        start_date = safe_parse_date(start.date, datetime.min)
+        end_date = safe_parse_date(end.date, datetime.min)
 
-    Returns
-    -------
-    float
-        The corresponding CO2 emission resulting from the SOC stock change.
-    """
-    return -1 * share_of_emission * _convert_c_to_co2(soc_stock_change_value)
+        should_run = (
+            datetime.min != start_date != end_date
+            and end_date > start_date
+        )
 
+        update = {
+            year: {_InventoryKey.SOC_STOCK: lerp_soc_stocks(start, end, f"{year}-12-31T23:59:59")}
+            for year in range(start_date.year, end_date.year+1)
+        } if should_run else {}
 
-def _sorted_merge(*sources: Union[dict, list[dict]]) -> dict:
+        return result | update
+
+    soc_stocks_by_year = reduce(interpolate_between, pairwise(soc_stocks), dict())
+
+    soc_stock_changes_by_year = {
+        year: {
+            _InventoryKey.SOC_STOCK_CHANGE: calc_soc_stock_change(
+                start_group[_InventoryKey.SOC_STOCK],
+                end_group[_InventoryKey.SOC_STOCK]
+            )
+        } for (_, start_group), (year, end_group) in pairwise(soc_stocks_by_year.items())
+    }
+
+    co2_emissions_by_method_and_year = {
+        year: {
+            _InventoryKey.CO2_EMISSION: calc_soc_stock_change_emission(
+                group[_InventoryKey.SOC_STOCK_CHANGE]
+            )
+        } for year, group in soc_stock_changes_by_year.items()
+    }
+
+    return _sorted_merge(soc_stocks_by_year, soc_stock_changes_by_year, co2_emissions_by_method_and_year)
+
+
+def lerp_soc_stocks(start: SocStock, end: SocStock, target_date: str) -> SocStock:
     """
-    Merge dictionaries and return the result as a new dictionary with keys sorted in order to preserve the temporal
-    order of inventory years.
+    Estimate, using linear interpolation, an SOC stock for a specific date based on the the SOC stocks of two other
+    dates.
 
     Parameters
     ----------
-    *sources : dict | List[dict]
-        One or more dictionaries or lists of dictionaries to be merged.
+    start : SocStock
+        The `SocStock` at the start (kg C ha-1).
+    end : SocStock
+        The `SocStock` at the end (kg C ha-1).
+    target_date : str
+        The target date for interpolation as a datestr with format `YYYY`, `YYYY-MM`, `YYYY-MM-DD` or
+    `YYYY-MM-DDTHH:mm:ss`.
 
     Returns
     -------
-    dict
-        A new dictionary containing the merged key-value pairs, with keys sorted.
+    SocStock
+        The interpolated `SocStock` for the specified date (kg C ha-1).
     """
+    time_ratio = diff_in_days(start.date, target_date) / diff_in_days(start.date, end.date)
+    soc_delta = (end.value - start.value) * time_ratio
 
-    _sources = non_empty_list(
-        flatten([arg if isinstance(arg, list) else [arg] for arg in sources])
-    )
+    value = start.value + soc_delta
+    method = min_measurement_method_classification(start.method, end.method)
 
-    merged = reduce(merge, _sources, {})
-    return dict(sorted(merged.items()))
+    return SocStock(value, target_date, method)
 
 
-def _validate_soc_measurement_node(node: dict) -> bool:
+def calc_soc_stock_change(start: SocStock, end: SocStock) -> SocStockChange:
     """
-    Validate a SOC measurement node against specified criteria.
+    Calculate the change in SOC stock change between the current and previous states.
+
+    The method should be the weaker of the two `MeasurementMethodClassification`s.
 
     Parameters
     ----------
-    node : dict
-        The SOC [Measurement node](https://www.hestia.earth/schema/Measurement) to be validated.
+    start : SocStock
+        The SOC stock at the start (kg C ha-1).
+
+    end : SocStock
+        The SOC stock at the end (kg C ha-1).
 
     Returns
     -------
-    bool
-        True if the node passes all validation criteria, False otherwise.
+    SocStockChange
+        The SOC stock change (kg C ha-1).
     """
-    return all([
-        node_term_match(node, ORGANIC_CARBON_PER_HA_TERM_ID),
-        node.get("depthUpper") == DEPTH_UPPER,
-        node.get("depthLower") == DEPTH_LOWER
-    ])
+    value = end.value - start.value
+    method = min_measurement_method_classification(start.method, end.method)
+    return SocStockChange(value, start.date, end.date, method)
 
 
-def _nodes_to_soc_stock(year: int, nodes: list[dict]) -> SocStock:
+def calc_soc_stock_change_emission(soc_stock_change: SocStockChange) -> SocStockChangeEmission:
     """
-    Reduces all the the SOC measurement nodes in an inventory year into a single value and measurement method.
-
-    Any nodes with missing or invalid `dates` field will already have been filtered out at this point, so we can assume
-    `node.value` and `node.dates` will have equal number of elements. See test case `missing-measurement-dates`.
+    Convert an `SocStockChange` into an `SocStockChangeEmission`.
 
     Parameters
     ----------
-    year : int
-        The target year for calculating the SOC stock.
-
-    nodes : List[dict]
-        List of [Measurement nodes](https://www.hestia.earth/schema/Measurement) containing SOC data.
+    soc_stock_change : SocStockChange
+        The SOC stock at the start (kg C ha-1).
 
     Returns
     -------
-    SocStock
-        The calculated SOC stock for the specified year.
+    SocStockChangeEmission
+        The SOC stock change emission (kg CO2 ha-1).
     """
-    target_date = f"{year}-12-31T23:59:59"
-
-    values = flatten([measurement.get("value", []) for measurement in nodes])
-    dates = flatten([measurement.get("dates", []) for measurement in nodes])
-    methods = flatten([
-        [measurement.get("methodClassification") for _ in measurement.get("value", [])]
-        for measurement in nodes
-    ])
-
-    closest_date = min(
-        dates,
-        key=lambda date: abs(diff_in_days(date if date else OLDEST_DATE, target_date)),
-    )
-
-    closest_method = _get_max_measurement_method(
-        method for method, date in zip(methods, dates) if date == closest_date
-    )
+    value = convert_c_to_co2(soc_stock_change.value) * -1
+    method = convert_mmc_to_emt(soc_stock_change.method)
+    return SocStockChangeEmission(value, soc_stock_change.start_date, soc_stock_change.end_date, method)
 
-    value = next(
-        (value for value, method in zip(values, methods) if method == closest_method.value), 0
-    )
 
-    return SocStock(value, closest_method)
+_DEFAULT_EMISSION_METHOD_TIER = EmissionMethodTier.TIER_1
+_MEASUREMENT_METHOD_CLASSIFICATION_TO_EMISSION_METHOD_TIER = {
+    MeasurementMethodClassification.TIER_2_MODEL: EmissionMethodTier.TIER_2,
+    MeasurementMethodClassification.TIER_3_MODEL: EmissionMethodTier.TIER_3,
+    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS: EmissionMethodTier.MEASURED,
+    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT: EmissionMethodTier.MEASURED,
+}
+"""
+A mapping between `MeasurementMethodClassification`s and `EmissionMethodTier`s. As SOC measurements can be
+measured/estimated through a variety of methods, the emission model needs be able to assign an emission tier for each.
+Any `MeasurementMethodClassification` not in the mapping should be assigned `DEFAULT_EMISSION_METHOD_TIER`.
+"""
 
 
-def _group_soc_stocks(site: dict) -> dict:
+def convert_mmc_to_emt(
+    measurement_method_classification: MeasurementMethodClassification
+) -> EmissionMethodTier:
     """
-    Group valid `organicCarbonPerHa` measurement nodes by year (based on node "dates" field) and reduce them to a
-    single `SocStock` for each year.
+    Get the emission method tier based on the provided measurement method classification.
 
     Parameters
     ----------
-    site : dict
-        A [Site node](https://www.hestia.earth/schema/Cycle).
+    measurement_method : MeasurementMethodClassification
+        The measurement method classification.
 
     Returns
     -------
-    dict
-        A dictionary where each key represents a year and its corresponding value is a dictionary containing SOC stock
-        information under the inner key specified by _InnerKey.SOC_STOCK.
+    EmissionMethodTier
+        The corresponding emission method tier.
     """
-    INNER_KEY = _InnerKey.SOC_STOCK
-
-    grouped_soc_measurements = group_nodes_by_year(
-        (node for node in site.get("measurements", []) if _validate_soc_measurement_node(node)),
-        mode=GroupNodesByYearMode.DATES
+    return _MEASUREMENT_METHOD_CLASSIFICATION_TO_EMISSION_METHOD_TIER.get(
+        to_measurement_method_classification(measurement_method_classification),
+        _DEFAULT_EMISSION_METHOD_TIER
     )
 
-    return {
-        year: {
-            INNER_KEY: (
-                _nodes_to_soc_stock(year, nodes)
-            )
-        } for year, nodes in grouped_soc_measurements.items()
-    }
-
 
-def _interpolate_grouped_soc_stocks(grouped_soc_stocks: dict) -> dict:
+def convert_c_to_co2(kg_c: float) -> float:
     """
-    Interpolate SOC stocks for years between grouped SOC stock data.
+    Convert mass of carbon (C) to carbon dioxide (CO2) using the atomic conversion ratio.
 
-    This function iterates over the provided grouped SOC stock data and performs linear interpolation for years between
-    existing data points. The result is a dictionary with SOC stock information for all years, including those without
-    initially available data.
+    n.b. `get_atomic_conversion` returns the ratio C:CO2 (~44/12).
 
     Parameters
     ----------
-    grouped_soc_stocks : dict
-        Dictionary containing grouped SOC stock data with years as keys.
+    kg_c : float
+        Mass of carbon (C) to be converted to carbon dioxide (CO2) (kg C).
 
     Returns
     -------
-    dict
-        A dictionary with interpolated SOC stock data for missing years.
+    float
+        Mass of carbon dioxide (CO2) resulting from the conversion (kg CO2).
     """
-
-    INNER_KEY = _InnerKey.SOC_STOCK
-
-    def group_interpolate(data: dict, i: int):
-        current_year = list(grouped_soc_stocks.keys())[i]
-        prev_year = list(grouped_soc_stocks.keys())[i-1]
-
-        current_soc_stock = grouped_soc_stocks[current_year][INNER_KEY]
-        prev_soc_stock = grouped_soc_stocks[prev_year][INNER_KEY]
-
-        return data | {
-            inner_year: {
-                INNER_KEY: _linear_interpolate_soc_stock(
-                    prev_year, current_year, prev_soc_stock, current_soc_stock, inner_year
-                )
-            } for inner_year in range(prev_year+1, current_year)
-        }
-
-    return reduce(group_interpolate, range(1, len(grouped_soc_stocks)), dict())
+    return kg_c * get_atomic_conversion(Units.KG_CO2, Units.TO_C)
 
 
-def _get_grouped_soc_stocks(site: dict) -> dict:
+def _sorted_merge(*sources: Union[dict, list[dict]]) -> dict:
     """
-    Get grouped and interpolated SOC stocks for a site.
-
-    This function combines grouping and interpolation of SOC stocks for a given site, providing a comprehensive
-    dictionary with SOC stock information for all years.
+    Merge dictionaries and return the result as a new dictionary with keys sorted in order to preserve the temporal
+    order of inventory years.
 
     Parameters
     ----------
-    site : dict
-        The site dictionary containing SOC measurements.
+    *sources : dict | list[dict]
+        One or more dictionaries or lists of dictionaries to be merged.
 
     Returns
     -------
     dict
-        A dictionary with grouped and interpolated SOC stock data for all years.
+        A new dictionary containing the merged key-value pairs, with keys sorted.
     """
-    grouped_soc_stocks = _group_soc_stocks(site)
-    grouped_interpolated_soc_stocks = _interpolate_grouped_soc_stocks(grouped_soc_stocks)
-    return _sorted_merge(grouped_soc_stocks, grouped_interpolated_soc_stocks)
 
+    _sources = non_empty_list(
+        flatten([arg if isinstance(arg, list) else [arg] for arg in sources])
+    )
 
-def _calc_grouped_soc_stock_changes(grouped_soc_stocks: dict) -> dict:
+    merged = reduce(merge, _sources, {})
+    return dict(sorted(merged.items()))
+
+
+def _squash_inventory(cycle_id: str, cycle_inventory: dict, soc_inventory: dict) -> dict:
     """
-    Calculate SOC stock changes between grouped SOC stock data for consecutive years.
+    Merge the `cycle_inventory` and `soc_inventory` for each inventory year by selecting the strongest available
+    `MeasurementMethodClassification`. Years that do not overlap with the Cycle node that the emission model is running
+    on should be discarded as they are not relevant.
 
     Parameters
     ----------
-    grouped_soc_stocks : dict
-        Dictionary containing grouped SOC stock data with years as keys.
+    cycle_id : str
+    cycle_inventory : dict
+    soc_inventory: dict
 
     Returns
     -------
     dict
-        A dictionary with calculated SOC stock changes for consecutive years.
+        The squashed inventory.
+    """
+    inventory_years = sorted(set(non_empty_list(
+        flatten(list(years) for years in soc_inventory.values())
+        + list(cycle_inventory.keys())
+    )))
+
+    def should_run_group(method: MeasurementMethodClassification, year: int) -> bool:
+        soc_stock_inventory_group = soc_inventory.get(method, {}).get(year, {})
+        share_of_emissions_group = cycle_inventory.get(year, {})
+
+        has_emission = _InventoryKey.CO2_EMISSION in soc_stock_inventory_group.keys()
+        is_relevant_for_cycle = cycle_id in share_of_emissions_group.get(_InventoryKey.SHARE_OF_EMISSION, {}).keys()
+        return all([has_emission, is_relevant_for_cycle])
+
+    def squash(result: dict, year: int) -> dict:
+        update_dict = next(
+            (
+                {year: reduce(merge, [soc_inventory[method][year], cycle_inventory[year]], dict())}
+                for method in VALID_MEASUREMENT_METHOD_CLASSIFICATIONS if should_run_group(method, year)
+            ),
+            {}
+        )
+        return result | update_dict
+
+    return reduce(squash, inventory_years, dict())
+
+
+def _format_cycle_inventory(cycle_inventory: dict) -> str:
+    """
+    Format the cycle inventory for logging as a table. Rows represent inventory years, columns represent the share of
+    emission for each cycle present in the inventory. If the inventory is invalid, return `"None"` as a string.
     """
-    INNER_KEY = _InnerKey.SOC_STOCK_CHANGE
+    KEY = _InventoryKey.SHARE_OF_EMISSION
 
-    def group_changes(data: dict, i: int):
-        current_year = list(grouped_soc_stocks.keys())[i]
-        prev_year = list(grouped_soc_stocks.keys())[i-1]
+    unique_cycles = sorted(
+        set(non_empty_list(flatten(list(group[KEY]) for group in cycle_inventory.values()))),
+        key=lambda id: next((year, id) for year in cycle_inventory if id in cycle_inventory[year][KEY])
+    )
 
-        current_soc_stock = grouped_soc_stocks[current_year][_InnerKey.SOC_STOCK]
-        prev_soc_stock = grouped_soc_stocks[prev_year][_InnerKey.SOC_STOCK]
+    should_run = cycle_inventory and len(unique_cycles) > 0
 
-        return data | {
-            current_year: {
-                INNER_KEY: _calc_soc_stock_change(prev_soc_stock, current_soc_stock)
+    return log_as_table(
+        {
+            "year": year,
+            **{
+                id: _format_number(group.get(KEY, {}).get(id, 0)) for id in unique_cycles
             }
-        }
-
-    return reduce(group_changes, range(1, len(grouped_soc_stocks)), dict())
+        } for year, group in cycle_inventory.items()
+    ) if should_run else "None"
 
 
-def _calc_sum_cycle_occupancy(cycles: list[dict]) -> float:
+def _format_soc_inventory(soc_inventory: dict) -> str:
     """
-    Calculate the sum of cycle occupancies based on the `fraction_of_group_duration` field added by the
-    `group_nodes_by_year` function.
+    Format the SOC inventory for logging as a table. Rows represent inventory years, columns represent soc stock change
+    data for each measurement method classification present in inventory. If the inventory is invalid, return `"None"`
+    as a string.
+    """
+    KEYS = [
+        _InventoryKey.SOC_STOCK,
+        _InventoryKey.SOC_STOCK_CHANGE,
+        _InventoryKey.CO2_EMISSION
+    ]
 
-    If a cycle does not have the "fraction_of_group_duration" key, it is treated as zero occupancy for that year.
+    methods = soc_inventory.keys()
+    method_columns = list(product(methods, KEYS))
+    inventory_years = sorted(set(non_empty_list(flatten(list(years) for years in soc_inventory.values()))))
 
-    Parameters
-    ----------
-    cycles : List[dict]
-        List of cycles, where each cycle dictionary should contain a "fraction_of_group_duration" key.
+    should_run = soc_inventory and len(inventory_years) > 0
 
-    Returns
-    -------
-    float
-        The sum of cycle occupancies based on the fraction of the year.
-    """
-    return sum(cycle.get("fraction_of_group_duration", 0) for cycle in cycles)
+    return log_as_table(
+        {
+            "year": year,
+            **{
+                _format_column_header(method, key): _format_named_tuple(
+                    soc_inventory.get(method, {}).get(year, {}).get(key, {})
+                ) for method, key in method_columns
+            }
+        } for year in inventory_years
+    ) if should_run else "None"
 
 
-def _calc_grouped_share_of_emissions(cycles: list[dict]) -> dict:
-    """
-    Calculate grouped share of emissions for cycles based on the amount they contribute the the overall land management
-    of an inventory year.
+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"
 
-    This function groups cycles by year, then calculates the share of emissions for each cycle based on the
-    "fraction_of_group_duration" value. The share of emissions is normalized by the sum of cycle occupancies for the
-    entire dataset to ensure the values represent a valid share.
 
-    Parameters
-    ----------
-    cycles : List[dict]
-        List of [Cycle nodes](https://www.hestia.earth/schema/Cycle), where each cycle dictionary should contain a
-        "fraction_of_group_duration" key added by the `group_nodes_by_year` function.
+def _format_column_header(method: MeasurementMethodClassification, inventory_key: _InventoryKey) -> str:
+    """
+    Format a measurement method classification and inventory key for logging in a table as a column header. Replace any
+    whitespaces in the method value with dashes and concatenate it with the inventory key value, which already has the
+    correct format.
+    """
+    return "-".join([
+        method.value.replace(" ", "-"),
+        inventory_key.value
+    ])
 
-    Returns
-    -------
-    dict
-        A dictionary with grouped share of emissions for each cycle based on the fraction of the year.
+
+def _format_named_tuple(value: Optional[Union[SocStock, SocStockChange, SocStockChangeEmission]]) -> str:
     """
-    INNER_KEY = _InnerKey.SHARE_OF_EMISSIONS
-    grouped_cycles = group_nodes_by_year(cycles)
-    return {
-        year: {
-            INNER_KEY: {
-                cycle["@id"]: cycle.get("fraction_of_group_duration", 0) / _calc_sum_cycle_occupancy(cycles)
-                for cycle in cycles
-            }
-        } for year, cycles in grouped_cycles.items()
-    }
+    Format a named tuple (`SocStock`, `SocStockChange` or `SocStockChangeEmission`) for logging in a table. Extract and
+    format just the value and discard the other data. If the value is invalid, return `"None"` as a string.
+    """
+    return (
+        _format_number(value.value)
+        if isinstance(value, (SocStock, SocStockChange, SocStockChangeEmission))
+        else "None"
+    )
 
 
-def _run(cycle_id: str, grouped_data: dict) -> list[dict]:
+def _run(cycle_id: str, inventory: dict) -> list[dict]:
     """
     Calculate emissions for a specific cycle using grouped SOC stock change and share of emissions data.
 
@@ -641,7 +746,6 @@ def _run(cycle_id: str, grouped_data: dict) -> list[dict]:
     ----------
     cycle_id : str
         The "@id" field of the [Cycle node](https://www.hestia.earth/schema/Cycle).
-
     grouped_data : dict
         A dictionary containing grouped SOC stock change and share of emissions data.
 
@@ -650,110 +754,59 @@ def _run(cycle_id: str, grouped_data: dict) -> list[dict]:
     list[dict]
         A list containing emission data calculated for the specified cycle.
     """
+    total_emission = _sum_soc_stock_change_emissions([
+        _rescale_stock_change_emission(
+            group[_InventoryKey.CO2_EMISSION], group[_InventoryKey.SHARE_OF_EMISSION][cycle_id]
+        ) for group in inventory.values()
+    ])
 
-    value = sum(
-        _soc_stock_stock_change_to_co2_emission(
-            group[_InnerKey.SOC_STOCK_CHANGE].value,
-            group[_InnerKey.SHARE_OF_EMISSIONS].get(cycle_id, 1)
-        ) for group in grouped_data.values()
-    )
-
-    method_tier = _get_emission_method_tier(
-        _get_min_measurement_method(
-            group[_InnerKey.SOC_STOCK_CHANGE].method for group in grouped_data.values()
-        )
-    )
-
+    value = round(total_emission.value, 6)
+    method_tier = total_emission.method
     return [_emission(value, method_tier)]
 
 
-def get_site(cycle: dict) -> dict:
-    return cycle.get("site", {})
-
-
-def _should_run(cycle: dict) -> tuple:
+def _rescale_stock_change_emission(emission: SocStockChangeEmission, factor: float) -> SocStockChangeEmission:
     """
-    Determine if calculations should run for a given cycle based on SOC stock and emissions data.
-
-    This function assesses whether calculations should run for a given cycle by checking the availability of SOC stock
-    data and cycle nodes. It retrieves SOC stock data and for the site linked to the cycle, calculates SOC stock
-    changes and share of emissions, and merges the data into a grouped format. The function checks for the presence of
-    necessary keys in the grouped data and ensures that the years are consecutive before determining if calculations
-    should run.
+    Rescale an `SocStockChangeEmission` by a specified factor.
 
     Parameters
     ----------
-    cycle : dict
-        The cycle dictionary for which the calculations will be evaluated.
+    emission : SocStockChangeEmission
+        An SOC stock change emission (kg CO2 ha-1).
+    factor : float
+        A scaling factor (e.g., a [Cycles](https://www.hestia.earth/schema/Cycle)'s share of an annual emission).
 
     Returns
     -------
-    tuple
-        A tuple containing a boolean indicating whether calculations should run,
-        the cycle identifier, and grouped SOC stock and emissions data.
+    SocStockChangeEmission
+        The rescaled emission.
     """
-    cycle_id = cycle.get("@id")
-    site = get_site(cycle)
-    cycles = related_cycles(site)
+    value = emission.value * factor
+    return SocStockChangeEmission(value, emission.start_date, emission.end_date, emission.method)
 
-    grouped_soc_stocks = _get_grouped_soc_stocks(site)
-    grouped_soc_stock_changes = _calc_grouped_soc_stock_changes(grouped_soc_stocks)
-    grouped_share_of_emissions = _calc_grouped_share_of_emissions(cycles)
 
-    def _should_run_group(year: int, group: dict) -> bool:
-        is_data_complete = all(key in group.keys() for key in REQUIRED_INNER_KEYS)
-        is_relevant_for_cycle = cycle_id in group.get(_InnerKey.SHARE_OF_EMISSIONS, {}).keys()
-        return is_data_complete and is_relevant_for_cycle
-
-    inventory = _sorted_merge(grouped_soc_stocks, grouped_soc_stock_changes, grouped_share_of_emissions)
-    valid_years = [year for year, group in inventory.items() if _should_run_group(year, group)]
-
-    num_organic_carbon_per_ha_measurements = len(
-        [node for node in site.get('measurements', []) if _validate_soc_measurement_node(node)]
-    )
-    has_organic_carbon_per_ha_measurements = num_organic_carbon_per_ha_measurements > 1
-    has_functional_unit_1_ha = all(
-        cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles
-    )
-    has_valid_inventory = len(valid_years) > 0 and check_consecutive(valid_years)
+def _sum_soc_stock_change_emissions(emissions: Iterable[SocStockChangeEmission]) -> SocStockChangeEmission:
+    """
+    Sum together multiple `SocStockChangeEmission`s.
 
-    logRequirements(
-        cycle, model=MODEL, term=TERM_ID,
-        has_organic_carbon_per_ha_measurements=has_organic_carbon_per_ha_measurements,
-        has_functional_unit_1_ha=has_functional_unit_1_ha,
-        has_valid_inventory=has_valid_inventory,
-        inventory=log_as_table(
-            {
-                "year": year,
-                "should-run": year in valid_years,
-                "soc-stock": (
-                    group.get(_InnerKey.SOC_STOCK).value if group.get(_InnerKey.SOC_STOCK)
-                    else None
-                ),
-                "soc-stock-method": (
-                    group.get(_InnerKey.SOC_STOCK).method.value if group.get(_InnerKey.SOC_STOCK)
-                    else None
-                ),
-                "soc-stock-change": (
-                    group.get(_InnerKey.SOC_STOCK_CHANGE).value if group.get(_InnerKey.SOC_STOCK_CHANGE)
-                    else None
-                ),
-                "soc-stock-change-method": (
-                    group.get(_InnerKey.SOC_STOCK_CHANGE).method.value if group.get(_InnerKey.SOC_STOCK_CHANGE)
-                    else None
-                ),
-                "share-of-emission": group.get(_InnerKey.SHARE_OF_EMISSIONS, {}).get(cycle_id, 0)
-            } for year, group in inventory.items()
-        )
-    )
+    Parameters
+    ----------
+    emissions : Iterable[SocStockChangeEmission]
+        A list of SOC stock change emissions (kg CO2 ha-1).
 
-    should_run = has_functional_unit_1_ha and has_valid_inventory
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    Returns
+    -------
+    SocStockChangeEmission
+        The summed emission.
+    """
+    value = sum(e.value for e in emissions)
+    start_date = min(e.start_date for e in emissions)
+    end_date = max(e.end_date for e in emissions)
+    method = min_emission_method_tier(e.method for e in emissions)
 
-    return should_run, cycle_id, {year: group for year, group in inventory.items() if year in valid_years}
+    return SocStockChangeEmission(value, start_date, end_date, method)
 
 
 def run(cycle: dict) -> list[dict]:
     should_run, *args = _should_run(cycle)
-
     return _run(*args) if should_run else []