hestia-earth-models 0.70.0__py3-none-any.whl → 0.70.1__py3-none-any.whl

hestia_earth/models/ipcc2019/ch4ToAirFloodedRice.py

@@ -1,8 +1,10 @@
+from functools import reduce
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
-from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
+from hestia_earth.models.utils import multiply_values
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.product import has_flooded_rice
@@ -12,18 +14,17 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [{"@type": "Practice", "value": "", "term.@id": "croppingDuration"}],
+        "practices": [
+            {"@type": "Practice", "value": "", "term.@id": "croppingDuration"},
+            {"@type": "Practice", "value": "", "term.termType": ["landUseManagement", "waterRegime"]}
+        ],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"}
         },
         "optional": {
             "inputs": [
-                {
-                    "@type": "Input",
-                    "value": "",
-                    "term.termType": "organicFertiliser"
-                },
+                {"@type": "Input", "value": "", "term.termType": "organicFertiliser"},
                 {
                     "@type": "Input",
                     "value": "",
@@ -32,28 +33,35 @@ REQUIREMENTS = {
                 }
             ],
             "products": [{"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"}],
-            "practices": [
-                {"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"},
-                {"@type": "Practice", "value": "", "term.termType": "landUseManagement"},
-                {"@type": "Practice", "value": "", "term.termType": "waterRegime"}
-            ]
+            "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}]
         }
     }
 }
 LOOKUPS = {
     "landUseManagement": [
-        "IPCC_2019_CH4_rice_SFw", "IPCC_2019_CH4_rice_SFw-min", "IPCC_2019_CH4_rice_SFw-max",
-        "IPCC_2019_CH4_rice_SFw-sd",
-        "IPCC_2019_CH4_rice_SFp", "IPCC_2019_CH4_rice_SFp-min", "IPCC_2019_CH4_rice_SFp-max",
+        "IPCC_2019_CH4_rice_SFp",
+        "IPCC_2019_CH4_rice_SFp-min",
+        "IPCC_2019_CH4_rice_SFp-max",
         "IPCC_2019_CH4_rice_SFp-sd"
     ],
     "waterRegime": [
-        "IPCC_2019_CH4_rice_SFw", "IPCC_2019_CH4_rice_SFw-min", "IPCC_2019_CH4_rice_SFw-max",
-        "IPCC_2019_CH4_rice_SFw-sd",
-        "IPCC_2019_CH4_rice_SFp", "IPCC_2019_CH4_rice_SFp-min", "IPCC_2019_CH4_rice_SFp-max",
-        "IPCC_2019_CH4_rice_SFp-sd"
+        "IPCC_2019_CH4_rice_SFw",
+        "IPCC_2019_CH4_rice_SFw-min",
+        "IPCC_2019_CH4_rice_SFw-max",
+        "IPCC_2019_CH4_rice_SFw-sd"
+    ],
+    "organicFertiliser": [
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_min",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_max",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_sd"
+    ],
+    "cropResidueManagement": [
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_min",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_max",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_sd"
     ],
-    "organicFertiliser": ["IPCC_2019_CH4_rice_CFOA_kg_fresh_weight", "IPCC_2019_CH4_rice_CFOA_kg_dry_weight"],
     "region-ch4ef-IPCC2019": ["CH4_ef", "CH4_ef_min", "CH4_ef_max", "CH4_ef_sd"]
 }
 RETURNS = {
@@ -68,92 +76,138 @@ RETURNS = {
 }
 TERM_ID = 'ch4ToAirFloodedRice'
 TIER = EmissionMethodTier.TIER_1.value
+_STATS = ['value', 'min', 'max', 'sd']
 
 
 def _emission(value: float, min: float, max: float, sd: float):
     emission = _new_emission(TERM_ID, MODEL)
     emission['value'] = [value]
-    emission['min'] = [min]
-    emission['max'] = [max]
-    emission['sd'] = [sd]
+    if min is not None:
+        emission['min'] = [min]
+    if max is not None:
+        emission['max'] = [max]
+    if sd is not None:
+        emission['sd'] = [sd]
     emission['methodTier'] = TIER
     emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
     return emission
 
 
-def _get_CH4_ef(country: str, suffix: str = ''):
+def _get_CH4_ef(country: str, suffix: str = 'value'):
     lookup_name = 'region-ch4ef-IPCC2019.csv'
+    lookup = 'CH4_ef'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     return safe_parse_float(
-        get_region_lookup_value(lookup_name, country, 'CH4_ef' + suffix, model=MODEL, term=TERM_ID)
+        get_region_lookup_value(lookup_name, country, lookup, model=MODEL, term=TERM_ID),
+        default=None
     )
 
 
-def _get_practice_lookup(term: dict, col: str):
-    return safe_parse_float(get_lookup_value(term, col, model=MODEL, term=TERM_ID))
-
-
-def _get_cropResidue_value(cycle: dict, suffix: str = ''):
+def _get_cropResidue_value(cycle: dict, suffix: str = 'value'):
+    product_id = 'aboveGroundCropResidueIncorporated'
     abgIncorporated = list_sum(
-        find_term_match(cycle.get('products', []), 'aboveGroundCropResidueIncorporated').get('value', [])
+        find_term_match(cycle.get('products', []), product_id).get('value', []),
+        default=None
     )
     abgManagement = filter_list_term_type(cycle.get('practices', []), TermTermType.CROPRESIDUEMANAGEMENT)
     term = abgManagement[0].get('term', {}) if len(abgManagement) > 0 else None
+    lookup = 'IPCC_2019_CH4_rice_CFOA_kg_dry_weight'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     factor = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['organicFertiliser'][1] + suffix, model=MODEL, term=TERM_ID)
-    ) if term else 0
-    return abgIncorporated * factor
+        get_lookup_value(term, lookup, model=MODEL, term=TERM_ID),
+        default=None
+    ) if term else None
 
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{'cropResidue_' + suffix: log_as_table({
+                    'product-id': product_id,
+                    'product-value': abgIncorporated,
+                    'factor': factor
+                })})
 
-def _get_fertiliser_value(input: dict, suffix: str = ''):
+    return multiply_values([abgIncorporated, factor])
+
+
+def _get_fertiliser_values(input: dict, suffix: str = 'value'):
     term = input.get('term', {})
+    lookup = 'IPCC_2019_CH4_rice_CFOA_kg_fresh_weight'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     factor = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['organicFertiliser'][0] + suffix, model=MODEL, term=TERM_ID)
+        get_lookup_value(term, lookup, model=MODEL, term=TERM_ID),
+        default=None
     )
-    return list_sum(input.get('value', [])) * factor
+    value = list_sum(input.get('value', []))
+    return {'input-id': term.get('@id'), 'input-value': value, 'factor': factor}
 
 
-def _calculate_SFo(cycle: dict, suffix: str = ''):
-    cropResidue = _get_cropResidue_value(cycle, suffix)
-    fertilisers = get_organicFertiliser_inputs(cycle)
-    fert_value = list_sum([_get_fertiliser_value(i, suffix) for i in fertilisers])
-    return (1 + (fert_value/1000) + (cropResidue/1000)) ** 0.59
+def _get_fertiliser_value(cycle: dict, suffix: str = 'value'):
+    fertiliser_values = [_get_fertiliser_values(i, suffix) for i in get_organicFertiliser_inputs(cycle)]
 
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{'fertiliser_' + suffix: log_as_table(fertiliser_values)})
 
-def _calculate_SF_average(practices: list, factor: str):
-    values = [
-        (_get_practice_lookup(p.get('term', {}), factor), list_sum(p.get('value', []), None)) for p in practices
+    valid_fertiliser_values = [
+        value for value in fertiliser_values
+        if all([value.get('input-value') is not None, value.get('factor') is not None])
     ]
-    # sum only values that are numbers
-    return list_sum([factor * percent / 100 for factor, percent in values if percent is not None])
+    fert_value = list_sum([
+        value.get('input-value') * value.get('factor')
+        for value in valid_fertiliser_values
+    ])
+    return fert_value
 
 
-def _calculate_factor(cycle: dict, country: str, practices: list, suffix: str = ''):
-    CH4_ef = _get_CH4_ef(country, suffix)
-    SFw = _calculate_SF_average(practices, 'IPCC_2019_CH4_rice_SFw' + suffix)
-    SFp = _calculate_SF_average(practices, 'IPCC_2019_CH4_rice_SFp' + suffix)
-    SFo = _calculate_SFo(cycle, suffix)
-    debugValues(cycle, model=MODEL, term=TERM_ID, **{
-        'CH4_ef' + suffix: CH4_ef,
-        'SFw' + suffix: SFw,
-        'SFp' + suffix: SFp,
-        'SFo' + suffix: SFo
-    })
-    return CH4_ef * (SFw if SFw > 0 else 1) * (SFp if SFp > 0 else 1) * SFo
+def _calculate_SFo(cycle: dict, suffix: str = 'value'):
+    cropResidue = _get_cropResidue_value(cycle, suffix)
+    fertiliser = _get_fertiliser_value(cycle, suffix)
 
+    return (1 + (fertiliser/1000) + (cropResidue/1000)) ** 0.59
 
-def _get_croppingDuration(croppingDuration: dict, key: str = 'value'):
-    return list_sum(croppingDuration.get(key, croppingDuration.get('value', [])))
 
+def _get_practice_values(practice: dict, col: str, default=None):
+    term = practice.get('term', {})
+    factor = safe_parse_float(get_lookup_value(term, col, model=MODEL, term=TERM_ID), default)
+    return {
+        'practice-id': term.get('@id'),
+        'factor': factor,
+        'practice-value': list_sum(practice.get('value', []), default=default)
+    } if factor is not None else None
 
-def _run(cycle: dict, croppingDuration: dict, country: str):
-    practices = filter_list_term_type(cycle.get('practices', []), [
-        TermTermType.WATERREGIME, TermTermType.LANDUSEMANAGEMENT
-    ])
 
-    value = _calculate_factor(cycle, country, practices) * _get_croppingDuration(croppingDuration)
-    min = _calculate_factor(cycle, country, practices, '_min') * _get_croppingDuration(croppingDuration, 'min')
-    max = _calculate_factor(cycle, country, practices, '_max') * _get_croppingDuration(croppingDuration, 'max')
-    sd = (max-min)/4
+def _calculate_SF_total(cycle: dict, practices: list, lookup: str, suffix: str = 'value', default=None):
+    lookup_column = '-'.join([lookup, suffix]) if suffix != 'value' else lookup
+    values = non_empty_list([_get_practice_values(p, lookup_column) for p in practices])
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{lookup_column: log_as_table(values)})
+
+    used_values = [value for value in values if value.get('practice-value') is not None]
+
+    # sum only values that are numbers
+    return (
+        list_sum([
+            value.get('factor') * value.get('practice-value') for value in used_values
+        ], default=None) / list_sum([
+            value.get('practice-value') for value in used_values
+        ])
+    ) if used_values else (
+        default if suffix == 'value' else None
+    )
+
+
+def _value_from_factors(values: list, key: str = 'value'):
+    # get the value from all factors, and only run if all are provided
+    all_values = [value.get(key) for value in values]
+    return multiply_values(all_values) if all([v is not None for v in all_values]) else None
+
+
+def _run(values: list):
+    value = _value_from_factors(values, 'value')
+    min = _value_from_factors(values, 'min')
+    max = _value_from_factors(values, 'max')
+    sd = _value_from_factors(values, 'sd')
+
+    sd = (max-min)/4 if all([max, min]) else None
 
     return [_emission(value, min, max, sd)]
 
@@ -162,20 +216,51 @@ def _should_run(cycle: dict):
     country = cycle.get('site', {}).get('country', {}).get('@id')
 
     flooded_rice = has_flooded_rice(cycle.get('products', []))
+    practices = cycle.get('practices', [])
 
-    croppingDuration = find_term_match(cycle.get('practices', []), 'croppingDuration', None)
+    croppingDuration = find_term_match(practices, 'croppingDuration', None)
     has_croppingDuration = croppingDuration is not None
+    croppingDuration = reduce(lambda p, key: p | {
+        key: list_sum(croppingDuration.get(key) or [], default=None)
+    }, _STATS, {}) if has_croppingDuration else {}
+
+    CH4_ef = reduce(lambda p, key: p | {key: _get_CH4_ef(country, key)}, _STATS, {})
+    SFo = reduce(lambda p, key: p | {key: _calculate_SFo(cycle, key)}, _STATS, {})
+
+    water_regime = filter_list_term_type(practices, TermTermType.WATERREGIME)
+    SFw = reduce(lambda p, key: p | {
+        key: _calculate_SF_total(cycle, water_regime, 'IPCC_2019_CH4_rice_SFw', key)
+    }, _STATS, {})
+
+    land_use_management = filter_list_term_type(practices, TermTermType.LANDUSEMANAGEMENT)
+    SFp = reduce(lambda p, key: p | {
+        key: _calculate_SF_total(cycle, land_use_management, 'IPCC_2019_CH4_rice_SFp', key, default=1)
+    }, _STATS, {})
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     has_flooded_rice=flooded_rice,
-                    has_croppingDuration=has_croppingDuration,
-                    country=country)
-
-    should_run = all([flooded_rice, has_croppingDuration, country])
+                    country=country,
+                    values=log_as_table([
+                        {'name': 'croppingDuration'} | croppingDuration,
+                        {'name': 'CH4-ef'} | CH4_ef,
+                        {'name': 'SFo'} | SFo,
+                        {'name': 'SFw'} | SFw,
+                        {'name': 'SFp'} | SFp,
+                    ]))
+
+    should_run = all([
+        flooded_rice,
+        has_croppingDuration,
+        country,
+        CH4_ef.get('value') is not None,
+        SFo.get('value') is not None,
+        SFw.get('value') is not None,
+        SFp.get('value') is not None,
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, croppingDuration, country
+    return should_run, [croppingDuration, CH4_ef, SFo, SFw, SFp]
 
 
 def run(cycle: dict):
-    should_run, croppingDuration, country = _should_run(cycle)
-    return _run(cycle, croppingDuration, country) if should_run else []
+    should_run, values = _should_run(cycle)
+    return _run(values) if should_run else []

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -796,26 +796,8 @@ def _preprocess_carbon_stocks(
     list[CarbonStock]
         A list of carbon stocks sorted by date.
     """
-    sorted_measurements = sorted(
-        flatten([split_node_by_dates(m) for m in carbon_stock_measurements]),
-        key=lambda node: _gapfill_datestr(node["dates"][0], DatestrGapfillMode.END)
-    )
-
-    values = flatten(node["value"] for node in sorted_measurements)
-
-    sds = flatten(
-        node.get("sd", []) or [_calc_nominal_sd(v, _NOMINAL_ERROR) for v in node["value"]]
-        for node in sorted_measurements
-    )
-
-    dates = flatten(
-        [_gapfill_datestr(datestr, DatestrGapfillMode.END) for datestr in node["dates"]]
-        for node in sorted_measurements
-    )
-
-    methods = flatten(
-        [MeasurementMethodClassification(node.get("methodClassification")) for _ in node["value"]]
-        for node in sorted_measurements
+    dates, values, sds, methods = _extract_node_data(
+        flatten([split_node_by_dates(m) for m in carbon_stock_measurements])
     )
 
     correlation_matrix = compute_time_series_correlation_matrix(
@@ -842,6 +824,35 @@ def _preprocess_carbon_stocks(
     ]
 
 
+def _extract_node_data(nodes: list[dict]) -> list[dict]:
+
+    def group_node(result, node) -> dict[str, dict]:
+        date = _gapfill_datestr(node["dates"][0], DatestrGapfillMode.END)
+        result[date] = result.get(date, []) + [node]
+        return result
+
+    grouped_nodes = reduce(group_node, nodes, dict())
+
+    def get_values(date):
+        return flatten(node.get("value", []) for node in grouped_nodes[date])
+
+    def get_sds(date):
+        return flatten(
+            node.get("sd", []) or [_calc_nominal_sd(v, _NOMINAL_ERROR) for v in node.get("value", [])]
+            for node in grouped_nodes[date]
+        )
+
+    def get_methods(date):
+        return flatten(node.get("methodClassification", []) for node in grouped_nodes[date])
+
+    dates = sorted(grouped_nodes.keys())
+    values = [mean(get_values(date)) for date in dates]
+    sds = [mean(get_sds(date)) for date in dates]
+    methods = [min_measurement_method_classification(get_methods(date)) for date in dates]
+
+    return dates, values, sds, methods
+
+
 def _calc_nominal_sd(value: float, error: float) -> float:
     """
     Calculate a nominal SD for a carbon stock measurement. Can be used to gap fill SD when information not present in

hestia_earth/models/ipcc2019/co2ToAirUreaHydrolysis.py

@@ -1,5 +1,5 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 from hestia_earth.utils.model import find_term_match
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
@@ -68,14 +68,21 @@ def _should_run(cycle: dict):
     uan_share = get_country_breakdown(MODEL, TERM_ID, country_id, LOOKUPS['inorganicFertiliser'][1])
     urea_unspecified_as_n = list_sum(find_term_match(inputs, UNSPECIFIED_TERM_ID).get('value', []))
 
-    urea_values = [{'id': id, 'values': _get_urea_values(cycle, inputs, id)} for id in term_ids] + ([
-        {'id': 'ureaKgN', 'values': [urea_unspecified_as_n * urea_share]},
-        {'id': 'ureaAmmoniumNitrateKgN', 'values': [urea_unspecified_as_n * uan_share]}
-    ] if all([
-        urea_share,
-        uan_share,
-        urea_unspecified_as_n > 0
-    ]) else [])
+    urea_values = [
+        {
+            'id': id,
+            'values': _get_urea_values(cycle, inputs, id)
+        } for id in term_ids
+    ] + non_empty_list([
+        {
+            'id': 'ureaKgN',
+            'values': [urea_unspecified_as_n * urea_share]
+        } if urea_share is not None else None,
+        {
+            'id': 'ureaAmmoniumNitrateKgN',
+            'values': [urea_unspecified_as_n * uan_share]
+        } if urea_share is not None else None
+    ] if urea_unspecified_as_n > 0 else [])
     has_urea_value = any([len(data.get('values')) > 0 for data in urea_values])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,

hestia_earth/models/ipcc2019/nonCo2EmissionsToAirNaturalVegetationBurning.py

@@ -156,8 +156,6 @@ _Inventory = dict[int, _InventoryYear]
 {year (int): data (_InventoryYear)}
 """
 
-_EmissionInventory = dict[_EmissionTermId, npt.NDArray]
-
 
 _BIOMASS_CATEGORY_TO_FUEL_CATEGORY = {
     BiomassCategory.FOREST: {
@@ -518,9 +516,9 @@ def _sum_cycle_emissions(term_id: _EmissionTermId, cycle_id: str, inventory: _In
     return reduce(add_cycle_emissions, inventory.keys(), np.array(0))
 
 
-def _compile_run_data(
+def _compile_inventory(
     cycle: dict, site: dict, land_cover_nodes: list[dict], eco_climate_zone: EcoClimateZone
-) -> tuple[_EmissionInventory, _Inventory, dict]:
+):
     """
     Compile the run data for the model, collating data from `site.management` and related cycles. An annualised
     inventory of land cover change and natural vegetation burning events is constructed. Emissions from burning events
@@ -539,18 +537,12 @@ def _compile_run_data(
 
     Returns
     -------
-    emission_inventory : _EmissionInventory
-        A dictionary of emissions relevant to the cycle the model is run on, in the format:
-        ```
-        {
-            emission_term_id (str): value (NDArray),
-            ...
-        }
-        ```
+    should_run : bool
+        Whether the model should be run.
     inventory : _Inventory
-        An inventory of model data
+        An inventory of model data.
     logs : dict
-        Data from the compilation process that should be logged.
+        Data about the inventory compilation to be logged.
     """
     cycle_id = cycle.get("@id")
     related_cycles_ = related_cycles(site, cycles_mapping={cycle_id: cycle})
@@ -586,9 +578,15 @@ def _compile_run_data(
         Returns
         -------
         inventory : dict
-            An inventory of model data, updated to include the new model year.
+            An inventory of model data, updated to include the input year.
         """
-        land_cover_nodes = next((nodes for year_, nodes in land_cover_grouped.items() if year_ >= year), [])  # Backfill
+        land_cover_nodes = land_cover_grouped.get(
+            next(
+                (k for k in sorted(land_cover_grouped) if k >= year),  # backfill if possible
+                min(land_cover_grouped, key=lambda k: abs(k - year))   # else forward-fill
+            ),
+            []
+        )
 
         biomass_category_summary = summarise_land_cover_nodes(land_cover_nodes)
         prev_biomass_category_summary = inventory.get(year-1, {}).get("biomass_category_summary", {})
@@ -656,17 +654,17 @@ def _compile_run_data(
 
     inventory = reduce(build_inventory_year, range(min_year, max_year+1), dict())
 
-    emission_inventory = {
-        term_id: value for term_id in EMISSION_TERM_IDS
-        if np.all((value := _sum_cycle_emissions(term_id, cycle_id, inventory)) > 0)
-    }
+    n_land_cover_years = len(land_cover_grouped)
 
     logs = {
+        "n_land_cover_years": n_land_cover_years,
         "percent_burned": percent_burned,
         "seed": seed,
     }
 
-    return emission_inventory, inventory, logs
+    should_run = bool(inventory and n_land_cover_years > 1)
+
+    return should_run, inventory, logs
 
 
 def _format_bool(value: Optional[bool]) -> str:
@@ -831,23 +829,16 @@ def _format_inventory(term_id: _EmissionTermId, cycle_id: str, inventory: dict)
     ) if inventory else "None"
 
 
-def _should_run_emission(
-    term_id: _EmissionTermId, cycle: dict, emission_inventory: _EmissionInventory, inventory: dict, logs: dict
-):
+def _log_emission_data(should_run: bool, term_id: _EmissionTermId, cycle: dict, inventory: dict, logs: dict):
     """
-    Determine, based on the compiled data, whether the model should run for a specifc emission term id. Format and log
-    the model logs and inventory.
+    Format and log the model logs and inventory.
     """
-    should_run = term_id in emission_inventory
-
     formatted_logs = _format_logs(logs)
     formatted_inventory = _format_inventory(term_id, cycle.get("@id"), inventory)
 
     logRequirements(cycle, model=MODEL, term=term_id, **formatted_logs, inventory=formatted_inventory)
     logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return should_run
-
 
 def _should_run(cycle: dict):
     """
@@ -861,8 +852,8 @@ def _should_run(cycle: dict):
 
     Returns
     -------
-    tuple[bool, dict]
-        should_run, emission_inventory
+    tuple[bool, _Inventory]
+        should_run, inventory
     """
     site = _get_site(cycle)
 
@@ -873,7 +864,7 @@ def _should_run(cycle: dict):
 
     has_valid_site_type = all([site_type, site_type not in _EXCLUDED_SITE_TYPES])
     has_valid_eco_climate_zone = all([eco_climate_zone, eco_climate_zone not in _EXCLUDED_ECO_CLIMATE_ZONES])
-    has_land_cover_nodes = len(land_cover_nodes) > 0
+    has_land_cover_nodes = len(land_cover_nodes) > 1
 
     should_compile_inventory = all([
         has_valid_site_type,
@@ -881,9 +872,9 @@ def _should_run(cycle: dict):
         has_land_cover_nodes
     ])
 
-    emission_inventory, inventory, compilation_logs = (
-        _compile_run_data(cycle, site, land_cover_nodes, eco_climate_zone)
-        if should_compile_inventory else ({}, {}, {})
+    should_run, inventory, compilation_logs = (
+        _compile_inventory(cycle, site, land_cover_nodes, eco_climate_zone)
+        if should_compile_inventory else (False, {}, {})
     )
 
     logs = {
@@ -897,21 +888,18 @@ def _should_run(cycle: dict):
         **compilation_logs
     }
 
-    should_run = all([
-        any([
-            _should_run_emission(term_id, cycle, emission_inventory, inventory, logs) for term_id in EMISSION_TERM_IDS
-        ])
-    ])
+    for term_id in EMISSION_TERM_IDS:
+        _log_emission_data(should_run, term_id, cycle, inventory, logs)
 
-    return should_run, emission_inventory
+    return should_run, inventory
 
 
-def _run_emission(term_id: _EmissionTermId, emissions: dict[_EmissionTermId, npt.NDArray]) -> list[dict]:
+def _run_emission(term_id: _EmissionTermId, cycle_id: str, inventory: _Inventory) -> list[dict]:
     """
-    Retrieve the pre-computed emissions and format them as a HESTIA
+    Retrieve the sum relevant emissions and format them as a HESTIA
     [Emission node](https://www.hestia.earth/schema/Emission).
     """
-    emission = emissions[term_id]
+    emission = _sum_cycle_emissions(term_id, cycle_id, inventory)
     descriptive_stats = calc_descriptive_stats(emission, STATS_DEFINITION, decimals=3)
     return _emission(term_id, **descriptive_stats)
 
@@ -932,5 +920,5 @@ def run(cycle: dict):
         `ch4ToAirNaturalVegetationBurning` **OR** `coToAirNaturalVegetationBurning` **OR**
         `n2OToAirNaturalVegetationBurningDirect` **OR** `noxToAirNaturalVegetationBurning`.
     """
-    should_run, emission_inventory = _should_run(cycle)
-    return [_run_emission(term_id, emission_inventory) for term_id in emission_inventory] if should_run else []
+    should_run, inventory = _should_run(cycle)
+    return [_run_emission(term_id, cycle.get("@id"), inventory) for term_id in EMISSION_TERM_IDS] if should_run else []