hestia-earth-models 0.75.1__py3-none-any.whl → 0.75.2__py3-none-any.whl

hestia_earth/models/ipcc2019/nonCo2EmissionsToAirNaturalVegetationBurning.py

@@ -1,30 +1,25 @@
-from enum import Enum
 from functools import lru_cache, reduce
-from itertools import product
 import numpy as np
 import numpy.typing as npt
-from typing import Any, Callable, Literal, Optional, TypedDict, Union
-from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, SiteSiteType
-from hestia_earth.utils.lookup import download_lookup, get_table_value
+from typing import Callable, Union
+
+from hestia_earth.utils.stats import gen_seed
 from hestia_earth.utils.tools import safe_parse_float
-from hestia_earth.utils.stats import gen_seed, repeat_single, truncated_normal_1d
-from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import (
-    debugMissingLookup, format_bool, format_decimal_percentage, format_float, format_nd_array, format_str, log_as_table,
-    logRequirements, logShouldRun
-)
+from hestia_earth.models.utils import split_on_condition
 from hestia_earth.models.utils.blank_node import group_nodes_by_year
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.lookup import get_region_lookup_value
 from hestia_earth.models.utils.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
 
 from . import MODEL
 from .biomass_utils import BiomassCategory, get_valid_management_nodes, summarise_land_cover_nodes
-from .burning_utils import EmissionCategory, FuelCategory
-
+from .burning_utils import (
+    calc_emission, DEFAULT_FACTOR, EmissionCategory, EXCLUDED_ECO_CLIMATE_ZONES, EXCLUDED_SITE_TYPES, FuelCategory,
+    ITERATIONS, get_emission_category, get_percent_burned, get_sample_func, Inventory, InventoryYear,
+    NATURAL_VEGETATION_CATEGORIES, run_emission, sample_fuel_factor, AMORTISATION_PERIOD, log_emission_data, TIER
+)
 
 REQUIREMENTS = {
     "Cycle": {
@@ -86,59 +81,9 @@ RETURNS = {
         "methodClassification": "tier 1 model"
     }]
 }
-TERM_ID = 'ch4ToAirNaturalVegetationBurning,coToAirNaturalVegetationBurning,n2OToAirNaturalVegetationBurningDirect,noxToAirNaturalVegetationBurning'  # noqa: E501
-
-EMISSION_TERM_IDS = TERM_ID.split(",")
-TIER = EmissionMethodTier.TIER_1.value
-STATS_DEFINITION = EmissionStatsDefinition.SIMULATED.value
-
-_ITERATIONS = 10000  # N interations for which the model will run as a Monte Carlo simulation
-_AMORTISATION_PERIOD = 20  # Emissions should be amortised over 20 years
-
-_EXCLUDED_ECO_CLIMATE_ZONES = {EcoClimateZone.POLAR_MOIST, EcoClimateZone.POLAR_DRY}
-_EXCLUDED_SITE_TYPES = {SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value}
-_NATURAL_VEGETATION_CATEGORIES = {
-    BiomassCategory.FOREST,
-    BiomassCategory.NATURAL_FOREST,
-    BiomassCategory.PLANTATION_FOREST
-}
-_DEFAULT_FACTOR = {"value": 0}
-_DEFAULT_PERCENT_BURNED = 0
-
-
-_EmissionTermId = Literal[
-    "ch4ToAirNaturalVegetationBurning",
-    "coToAirNaturalVegetationBurning",
-    "n2OToAirNaturalVegetationBurningDirect",
-    "noxToAirNaturalVegetationBurning"
-]
-
-
-class _InventoryYear(TypedDict, total=False):
-    biomass_category_summary: dict[BiomassCategory, float]
-    natural_vegetation_delta: dict[BiomassCategory, float]
-    fuel_burnt_per_category: dict[FuelCategory, npt.NDArray]
-    annual_emissions: dict[_EmissionTermId, npt.NDArray]
-    amortised_emissions: dict[_EmissionTermId, npt.NDArray]
-    share_of_emissions: dict[str, float]  # {cycle_id (str): value, ...}
-    allocated_emissions: dict[_EmissionTermId, dict[str, npt.NDArray]]
-
-
-_InventoryKey = Literal[
-    "biomass_category_summary",
-    "natural_vegetation_delta",
-    "fuel_burnt_per_category",
-    "annual_emissions",
-    "amortised_emissions",
-    "share_of_emissions",
-    "allocated_emissions"
-]
-
-_Inventory = dict[int, _InventoryYear]
-"""
-{year (int): data (_InventoryYear)}
-"""
+TERM_ID = 'ch4ToAirNaturalVegetationBurning,coToAirNaturalVegetationBurning,n2OToAirNaturalVegetationBurningDirect,nh3ToAirNaturalVegetationBurning,noxToAirNaturalVegetationBurning'  # noqa: E501
 
+_EMISSION_TERM_IDS = TERM_ID.split(",")
 
 _BIOMASS_CATEGORY_TO_FUEL_CATEGORY = {
     BiomassCategory.FOREST: {
@@ -182,24 +127,17 @@ _BIOMASS_CATEGORY_TO_FUEL_CATEGORY = {
 Mapping from IPCC biomass category and eco-climate zone to natural vegetation fuel category.
 """
 
-_FUEL_CATEGORY_TO_EMISSION_CATEGORY = {
-    FuelCategory.BOREAL_FOREST: EmissionCategory.OTHER_FOREST,
-    FuelCategory.EUCALYPT_FOREST: EmissionCategory.OTHER_FOREST,
-    FuelCategory.NATURAL_TROPICAL_FOREST: EmissionCategory.TROPICAL_FOREST,
-    FuelCategory.PRIMARY_TROPICAL_FOREST: EmissionCategory.TROPICAL_FOREST,
-    FuelCategory.SAVANNA_GRASSLAND_EARLY_DRY_SEASON_BURNS: EmissionCategory.SAVANNA_AND_GRASSLAND,
-    FuelCategory.SAVANNA_GRASSLAND_MID_TO_LATE_DRY_SEASON_BURNS: EmissionCategory.SAVANNA_AND_GRASSLAND,
-    FuelCategory.SAVANNA_WOODLAND_EARLY_DRY_SEASON_BURNS: EmissionCategory.SAVANNA_AND_GRASSLAND,
-    FuelCategory.SAVANNA_WOODLAND_MID_TO_LATE_DRY_SEASON_BURNS: EmissionCategory.SAVANNA_AND_GRASSLAND,
-    FuelCategory.SECONDARY_TROPICAL_FOREST: EmissionCategory.TROPICAL_FOREST,
-    FuelCategory.SHRUBLAND: EmissionCategory.SAVANNA_AND_GRASSLAND,
-    FuelCategory.TEMPERATE_FOREST: EmissionCategory.OTHER_FOREST,
-    FuelCategory.TERTIARY_TROPICAL_FOREST: EmissionCategory.TROPICAL_FOREST,
-    FuelCategory.UNKNOWN_TROPICAL_FOREST: EmissionCategory.TROPICAL_FOREST
-}
-"""
-Mapping from natural vegetation fuel category to natural vegetation burning emission category.
-"""
+
+def _emission(term_id: str, kwargs) -> dict:
+    """
+    Build a HESTIA [Emission node](https://www.hestia.earth/schema/Emission) using model output data.
+    """
+    value_keys, other_keys = split_on_condition([*kwargs], lambda k: k in ("value", "sd", "min", "max"))
+    emission = _new_emission(term=term_id, model=MODEL, **{k: kwargs.get(k) for k in value_keys})
+    return emission | {
+        "methodTier": TIER,
+        **{k: kwargs.get(k) for k in other_keys}
+    }
 
 
 def _get_fuel_category(biomass_category: BiomassCategory, eco_climate_zone: EcoClimateZone) -> FuelCategory:
@@ -210,113 +148,18 @@ def _get_fuel_category(biomass_category: BiomassCategory, eco_climate_zone: EcoC
     return _BIOMASS_CATEGORY_TO_FUEL_CATEGORY.get(biomass_category, {}).get(eco_climate_zone)
 
 
-def get_emission_category(fuel_category: FuelCategory) -> EmissionCategory:
-    """
-    Get the IPCC (2019) emission category that corresponds to a fuel category.
-    """
-    return _FUEL_CATEGORY_TO_EMISSION_CATEGORY.get(fuel_category)
-
-
-def _sample_truncated_normal(
-    *, iterations: int, value: float, sd: float, seed: Union[int, np.random.Generator, None] = None, **_
-) -> npt.NDArray:
-    """
-    Randomly sample a model parameter with a truncated normal distribution. Neither fuel factors nor emission factors
-    can be below 0, so truncated normal sampling used.
-    """
-    return truncated_normal_1d(shape=(1, iterations), mu=value, sigma=sd, low=0, high=np.inf, seed=seed)
-
-
-def _sample_constant(*, iterations: int, value: float, **_) -> npt.NDArray:
-    """Sample a constant model parameter."""
-    return repeat_single(shape=(1, iterations), value=value)
-
-
-_KWARGS_TO_SAMPLE_FUNC = {
-    # ("value", "se", "n"): _sample_standard_error_normal,
-    ("value", "sd"): _sample_truncated_normal,
-    ("value",): _sample_constant
-}
-"""
-Mapping from available distribution data to sample function.
-"""
-
-
-def _get_sample_func(kwargs: dict) -> Callable:
-    """
-    Select the correct sample function for a parameter based on the distribution data available. All possible
-    parameters for the model should have, at a minimum, a `value`, meaning that no default function needs to be
-    specified.
-
-    This function has been extracted into it's own method to allow for mocking of sample function.
-
-    Keyword Args
-    ------------
-    value : float
-        The distribution mean.
-    sd : float
-        The standard deviation of the distribution.
-    se : float
-        The standard error of the distribution.
-    n : float
-        Sample size.
-
-    Returns
-    -------
-    Callable
-        The sample function for the distribution.
-    """
-    return next(
-        sample_func for required_kwargs, sample_func in _KWARGS_TO_SAMPLE_FUNC.items()
-        if all(kwarg in kwargs.keys() for kwarg in required_kwargs)
-    )
-
-
-def _get_fuel_factor(fuel_category: FuelCategory) -> dict:
-    """
-    Retrieve distribution data for a specific fuel category.
-    """
-    LOOKUP_KEY = "ipcc2019FuelCategory_tonnesDryMatterCombustedPerHaBurned"
-    LOOKUP_FILENAME = f"{LOOKUP_KEY}.csv"
-    TARGET_DATA = (
-        "value",
-        # "se",  # useless without n data
-        # "n"  # TODO: add n data to lookup
-    )
-
-    row = fuel_category.name
-
-    lookup = download_lookup(LOOKUP_FILENAME)
-
-    data = {
-        target: get_table_value(lookup, "FuelCategory", row, target)
-        for target in TARGET_DATA
-    }
-
-    for term_id, target in product(EMISSION_TERM_IDS, TARGET_DATA):
-        debugMissingLookup(LOOKUP_FILENAME, "FuelCategory", row, target, data.get(target), model=MODEL, term=term_id)
-
-    return (
-        {
-            k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, default=None)) is not None
-        }  # remove missing
-        or _DEFAULT_FACTOR  # if parsed dict empty, return default
-    )
-
-
-def _get_emission_factor(term_id: _EmissionTermId, emission_category: EmissionCategory) -> dict:
+def _get_emission_factor(term_id: str, emission_category: EmissionCategory) -> dict:
     """
     Retrieve distribution data for a specific emission and emission category.
     """
     TERM_TYPE = "emission"
     TARGET_DATA = ("value", "sd")
-
-    column_root = f"IPCC_2019_G_EMITTED_PER_KG_DRY_MATTER_COMBUSTED_{emission_category.name}"
+    COLUMN_ROOT = "IPCC_2019_G_EMITTED_PER_KG_DRY_MATTER_COMBUSTED"
 
     data = {
         target: get_lookup_value(
             {"@id": term_id, "termType": TERM_TYPE},
-            f"{column_root}_{target}",
+            "_".join([COLUMN_ROOT, emission_category.name, target]),
             model=MODEL,
             term=term_id
         ) for target in TARGET_DATA
@@ -326,23 +169,12 @@ def _get_emission_factor(term_id: _EmissionTermId, emission_category: EmissionCa
         {
             k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, default=None)) is not None
         }  # remove missing
-        or _DEFAULT_FACTOR  # if parsed dict empty, return default
+        or DEFAULT_FACTOR  # if parsed dict empty, return default
     )
 
 
-def _sample_fuel_factor(
-    fuel_category: FuelCategory, *, seed: Union[int, np.random.Generator, None] = None
-) -> npt.NDArray:
-    """
-    Generate random samples from a fuel factor's distribution data.
-    """
-    factor_data = _get_fuel_factor(fuel_category)
-    sample_func = _get_sample_func(factor_data)
-    return sample_func(iterations=_ITERATIONS, seed=seed, **factor_data)
-
-
-def _sample_emission_factor(
-    term_id: _EmissionTermId,
+def sample_emission_factor(
+    term_id: str,
     emission_category: EmissionCategory,
     *,
     seed: Union[int, np.random.Generator, None] = None
@@ -351,37 +183,8 @@ def _sample_emission_factor(
     Generate random samples from an emission factor's distribution data.
     """
     factor_data = _get_emission_factor(term_id, emission_category)
-    sample_func = _get_sample_func(factor_data)
-    return sample_func(iterations=_ITERATIONS, seed=seed, **factor_data)
-
-
-def _emission(term_id: str, **kwargs) -> dict:
-    """
-    Build a HESTIA [Emission node](https://www.hestia.earth/schema/Emission) using model output data.
-    """
-    emission = _new_emission(term=term_id, model=MODEL)
-    return emission | {
-        **{k: v for k, v in kwargs.items()},
-        "methodTier": TIER
-    }
-
-
-def _get_site(cycle: dict) -> dict:
-    """
-    Get the site data from a [Cycle node](https://www.hestia.earth/schema/Cycle).
-
-    Used as a test utility to mock the 'site' data in during testing.
-    """
-    return cycle.get("site", {})
-
-
-def get_percent_burned(site: str):
-    LOOKUP_KEY = "region-percentageAreaBurnedDuringForestClearance"
-    LOOKUP_FILENAME = f"{LOOKUP_KEY}.csv"
-    country_id = site.get("country", {}).get("@id")
-
-    value = get_region_lookup_value(LOOKUP_FILENAME, country_id, LOOKUPS[LOOKUP_KEY])
-    return safe_parse_float(value, _DEFAULT_PERCENT_BURNED)
+    sample_func = get_sample_func(factor_data)
+    return sample_func(iterations=ITERATIONS, seed=seed, **factor_data)
 
 
 def _calc_burnt_fuel(area_converted: npt.NDArray, fuel_factor: npt.NDArray, frac_burnt: npt.NDArray) -> npt.NDArray:
@@ -466,38 +269,6 @@ def _build_fuel_burnt_accumulator(
     return accumulate_fuel_burnt
 
 
-def _calc_emission(fuel_burnt: npt.NDArray, emission_factor: npt.NDArray,) -> npt.NDArray:
-    """
-    Calculate the emission from a fuel burning.
-
-    Parameters
-    ----------
-    fuel_burnt : NDArray
-        The mass of burnt fuel (kg).
-    emission_factor : NDArray
-        Conversion factor (kg emission per kg of fuel burnt).
-
-    Returns
-    -------
-    NDArray
-        The mass of emission (kg)
-    """
-    return fuel_burnt * emission_factor
-
-
-def _sum_cycle_emissions(term_id: _EmissionTermId, cycle_id: str, inventory: _Inventory) -> npt.NDArray:
-    """
-    Sum the emissions allocated to a cycle.
-    """
-    KEY = "allocated_emissions"
-
-    def add_cycle_emissions(result: npt.NDArray, year: int) -> npt.NDArray:
-        allocated_emissions = inventory.get(year, {}).get(KEY, {}).get(term_id, {})
-        return result + allocated_emissions.get(cycle_id, np.array(0))
-
-    return reduce(add_cycle_emissions, inventory.keys(), np.array(0))
-
-
 def _compile_inventory(
     cycle: dict, site: dict, land_cover_nodes: list[dict], eco_climate_zone: EcoClimateZone
 ):
@@ -521,7 +292,7 @@ def _compile_inventory(
     -------
     should_run : bool
         Whether the model should be run.
-    inventory : _Inventory
+    inventory : Inventory
         An inventory of model data.
     logs : dict
         Data about the inventory compilation to be logged.
@@ -537,22 +308,22 @@ def _compile_inventory(
     percent_burned = get_percent_burned(site)
 
     @lru_cache(maxsize=len(FuelCategory))
-    def sample_fuel_factor(*args):
+    def sample_fuel_factor_(*args):
         """Fuel factors should not be re-sampled between years, so cache results."""
-        return _sample_fuel_factor(*args, seed=rng)
+        return sample_fuel_factor(*args, _EMISSION_TERM_IDS, seed=rng)
 
-    @lru_cache(maxsize=len(EMISSION_TERM_IDS)*len(EmissionCategory))
-    def sample_emission_factor(*args):
+    @lru_cache(maxsize=len(_EMISSION_TERM_IDS)*len(EmissionCategory))
+    def sample_emission_factor_(*args):
         """Emission factors should not be re-sampled between years, so cache results."""
-        return _sample_emission_factor(*args, seed=rng)
+        return sample_emission_factor(*args, seed=rng)
 
-    accumulate_fuel_burnt = _build_fuel_burnt_accumulator(percent_burned, eco_climate_zone, sample_fuel_factor)
+    accumulate_fuel_burnt = _build_fuel_burnt_accumulator(percent_burned, eco_climate_zone, sample_fuel_factor_)
 
-    def build_inventory_year(inventory: _Inventory, year: int) -> dict:
+    def build_inventory_year(inventory: Inventory, year: int) -> dict:
         """
         Parameters
         ----------
-        inventory : _Inventory
+        inventory : Inventory
             An inventory of model data.
         year : int
             The year of the inventory to build.
@@ -575,7 +346,7 @@ def _compile_inventory(
 
         natural_vegetation_delta = {
             category: biomass_category_summary.get(category, 0) - prev_biomass_category_summary.get(category, 0)
-            for category in _NATURAL_VEGETATION_CATEGORIES
+            for category in NATURAL_VEGETATION_CATEGORIES
         }
 
         fuel_burnt_per_category = reduce(
@@ -586,13 +357,13 @@ def _compile_inventory(
 
         annual_emissions = {
             term_id: sum(
-                _calc_emission(amount, sample_emission_factor(term_id, get_emission_category(fuel_category)))
+                calc_emission(amount, sample_emission_factor_(term_id, get_emission_category(fuel_category)))
                 for fuel_category, amount in fuel_burnt_per_category.items()
-            ) for term_id in EMISSION_TERM_IDS
+            ) for term_id in _EMISSION_TERM_IDS
         }
 
         previous_years = list(inventory.keys())
-        amortisation_slice_index = max(0, len(previous_years) - (_AMORTISATION_PERIOD - 1))
+        amortisation_slice_index = max(0, len(previous_years) - (AMORTISATION_PERIOD - 1))
         amortisation_years = previous_years[amortisation_slice_index:]  # get the previous 19 years, if available
 
         amortised_emissions = {
@@ -600,7 +371,7 @@ def _compile_inventory(
                 annual_emissions[term_id] + sum(
                     inventory[year_]["annual_emissions"][term_id] for year_ in amortisation_years
                 )
-            ) for term_id in EMISSION_TERM_IDS
+            ) for term_id in _EMISSION_TERM_IDS
         }
 
         cycles = cycles_grouped.get(year, [])
@@ -616,10 +387,10 @@ def _compile_inventory(
                 cycle_id: share_of_emission * amortised_emissions[term_id]
                 for cycle_id, share_of_emission in share_of_emissions.items()
             }
-            for term_id in EMISSION_TERM_IDS
+            for term_id in _EMISSION_TERM_IDS
         }
 
-        inventory[year] = _InventoryYear(
+        inventory[year] = InventoryYear(
             biomass_category_summary=biomass_category_summary,
             natural_vegetation_delta=natural_vegetation_delta,
             fuel_burnt_per_category=fuel_burnt_per_category,
@@ -649,147 +420,6 @@ def _compile_inventory(
     return should_run, inventory, logs
 
 
-def _format_column_header(*keys: tuple[Union[Enum, str], ...]) -> str:
-    """Format a variable number of enums and strings for logging as a table column header."""
-    return " ".join(format_str(k.value if isinstance(k, Enum) else format_str(k)) for k in keys)
-
-
-def _format_eco_climate_zone(value: EcoClimateZone) -> str:
-    """Format an eco-climate zone for logging."""
-    return (
-        format_str(str(value.name).lower().replace("_", " ").capitalize()) if isinstance(value, EcoClimateZone)
-        else "None"
-    )
-
-
-_LOGS_FORMAT_DATA: dict[str, Callable] = {
-    "has_valid_site_type": format_bool,
-    "eco_climate_zone": _format_eco_climate_zone,
-    "has_valid_eco_climate_zone": format_bool,
-    "has_land_cover_nodes": format_bool,
-    "should_compile_inventory": format_bool,
-    "percent_burned": lambda x: format_float(x, "pct"),
-}
-_DEFAULT_FORMAT_FUNC = format_str
-
-
-def _format_logs(logs: dict) -> dict[str, str]:
-    """
-    Format model logs - excluding the inventory data, which must be formatted separately.
-    """
-    return {key: _LOGS_FORMAT_DATA.get(key, _DEFAULT_FORMAT_FUNC)(value) for key, value in logs.items()}
-
-
-_INVENTORY_FORMAT_DATA: dict[_InventoryKey, dict[Literal["filter_by", "format_func"], Any]] = {
-    "fuel_burnt_per_category": {
-        "format_func": lambda x: format_nd_array(x, "kg")
-    },
-    "annual_emissions": {
-        "filter_by": ("term_id", ),
-        "format_func": lambda x: format_nd_array(x, "kg")
-    },
-    "amortised_emissions": {
-        "filter_by": ("term_id", ),
-        "format_func": lambda x: format_nd_array(x, "kg")
-    },
-    "share_of_emissions": {
-        "filter_by": ("cycle_id", ),
-        "format_func": format_decimal_percentage
-    },
-    "allocated_emissions": {
-        "filter_by": ("term_id", "cycle_id"),
-        "format_func": lambda x: format_nd_array(x, "kg")
-    }
-}
-"""
-Mapping between inventory key and formatting options for logging in a table. Inventory keys not included in the dict
-will not be logged in the table.
-"""
-
-
-def _flatten_dict(d: dict) -> dict[tuple, Any]:
-    """
-    Flatten a nested dict, returns dict with keys as tuples with format `(key_level_1, key_level_2, ..., key_level_n)`.
-    """
-    def flatten(d: dict, c: Optional[list] = None):
-        c = c or []
-        for a, b in d.items():
-            if not isinstance(b, dict):
-                yield (tuple(c+[a]), b)
-            else:
-                yield from flatten(b, c+[a])
-
-    return dict(flatten(d))
-
-
-def _get_relevant_inner_keys(
-    term_id: _EmissionTermId,
-    cycle_id: str,
-    key: str,
-    inventory: _Inventory,
-    *,
-    filter_by: Optional[tuple[Literal["term_id", "cycle_id"], ...]] = None,
-    **_
-) -> list[tuple]:
-    """
-    Get the column headings for the formatted table. Nested inventory values should be flattened, with nested keys
-    being transformed into a tuple with the format `(key_level_1, key_level_2, ..., key_level_n)`.
-
-    Inner keys not relevant to the emission term being logged or the cycle the model is running on should be excluded.
-    """
-    FILTER_VALUES = {"term_id": term_id, "cycle_id": cycle_id}
-    filter_target = (
-        tuple(val for f in filter_by if (val := FILTER_VALUES.get(f)))
-        if filter_by else None
-    )
-
-    inner_keys = {
-        tuple(k) for inner in inventory.values() for k in _flatten_dict(inner.get(key, {}))
-        if not filter_target or k == filter_target
-    }
-
-    return sorted(
-        inner_keys,
-        key=lambda category: category.value if isinstance(category, Enum) else str(category)
-    )
-
-
-def _format_inventory(term_id: _EmissionTermId, cycle_id: str, inventory: dict) -> str:
-    """
-    Format the inventory for logging as a table.
-
-    Extract relevant data, flatten nested dicts and format inventory values based on expected data type.
-    """
-    relevant_inventory_keys = {
-        inventory_key: _get_relevant_inner_keys(term_id, cycle_id, inventory_key, inventory, **kwargs)
-        for inventory_key, kwargs in _INVENTORY_FORMAT_DATA.items()
-    }
-
-    return log_as_table(
-        {
-            "year": year,
-            **{
-                _format_column_header(inventory_key, *inner_key): _INVENTORY_FORMAT_DATA[inventory_key]["format_func"](
-                    reduce(lambda d, k: d.get(k, {}), [year, inventory_key, *inner_key], inventory)
-                )
-                for inventory_key, relevant_inner_keys in relevant_inventory_keys.items()
-                for inner_key in relevant_inner_keys
-            }
-        } for year in inventory
-    ) if inventory else "None"
-
-
-def _log_emission_data(should_run: bool, term_id: _EmissionTermId, cycle: dict, inventory: dict, logs: dict):
-    """
-    Format and log the model logs and 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, methodTier=TIER)
-
-
 def _should_run(cycle: dict):
     """
     Extract, organise and pre-process required data from the input [Cycle node](https://www.hestia.earth/schema/Site)
@@ -802,18 +432,18 @@ def _should_run(cycle: dict):
 
     Returns
     -------
-    tuple[bool, _Inventory]
+    tuple[bool, Inventory]
         should_run, inventory
     """
-    site = _get_site(cycle)
+    site = cycle.get("site", {})
 
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
     land_cover_nodes = get_valid_management_nodes(site)
 
-    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_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) > 1
 
     should_compile_inventory = all([
@@ -838,22 +468,12 @@ def _should_run(cycle: dict):
         **compilation_logs
     }
 
-    for term_id in EMISSION_TERM_IDS:
-        _log_emission_data(should_run, term_id, cycle, inventory, logs)
+    for term_id in _EMISSION_TERM_IDS:
+        log_emission_data(should_run, term_id, cycle, inventory, logs)
 
     return should_run, inventory
 
 
-def _run_emission(term_id: _EmissionTermId, cycle_id: str, inventory: _Inventory) -> list[dict]:
-    """
-    Retrieve the sum relevant emissions and format them as a HESTIA
-    [Emission node](https://www.hestia.earth/schema/Emission).
-    """
-    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)
-
-
 def run(cycle: dict):
     """
     Run the `nonCo2EmissionsToAirNaturalVegetationBurning` model on a Cycle.
@@ -871,4 +491,7 @@ def run(cycle: dict):
         `n2OToAirNaturalVegetationBurningDirect` **OR** `noxToAirNaturalVegetationBurning`.
     """
     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 []
+    return (
+        [_emission(*run_emission(term_id, cycle.get("@id"), inventory)) for term_id in _EMISSION_TERM_IDS]
+        if should_run else []
+    )

hestia_earth/models/ipcc2019/organicSoilCultivation_utils.py

@@ -129,13 +129,13 @@ def calc_emission(
         "n2OToAirOrganicSoilCultivationDirect"
     ],
     emission_factor: float,
-    histosol: float,
+    organic_soils: float,
     land_occupation: float
 ):
     """
     Calculate the emission and convert it to kg/ha-1.
     """
-    return emission_factor * land_occupation * histosol * _CONVERSION_FACTORS.get(emission_id, 1) / 100
+    return emission_factor * land_occupation * organic_soils * _CONVERSION_FACTORS.get(emission_id, 1) / 100
 
 
 def remap_categories(

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -175,6 +175,7 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
     GE = (
         calculate_GE(animal_values, REM, REG, NEwool, NEm_feed, NEg_feed) / (meanDE/100)
     ) if meanDE else 0
+    has_positive_GE_value = GE >= 0
 
     def run(practice: dict):
         key = practice.get('key', {})
@@ -206,11 +207,12 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),
                         has_positive_feed_values=has_positive_feed_values,
+                        has_positive_GE_value=has_positive_GE_value,
                         animal_logs=logs,
                         animal_lookups=animal_lookups,
                         animal_properties=animal_properties)
 
-        should_run = all([has_positive_feed_values])
+        should_run = all([has_positive_feed_values, has_positive_GE_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, model_key=MODEL_KEY)
 
         return _input(input_term_id, value) if should_run else None