hestia-earth-models 0.74.13__py3-none-any.whl → 0.74.15__py3-none-any.whl

hestia_earth/models/hestia/soilClassification.py

@@ -0,0 +1,314 @@
+from functools import reduce
+from typing import NamedTuple, Optional
+from pydash import merge
+
+from hestia_earth.schema import MeasurementMethodClassification, TermTermType
+from hestia_earth.utils.blank_node import get_node_value, flatten
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.hestia.soilMeasurement import STANDARD_DEPTHS
+from hestia_earth.models.ipcc2019.organicCarbonPerHa_utils import (
+    IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE, IpccSoilCategory
+)
+from hestia_earth.models.log import format_bool, format_float, format_str, log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.utils import split_on_condition
+from hestia_earth.models.utils.blank_node import node_lookup_match, split_nodes_by_dates
+from hestia_earth.models.utils.measurement import _new_measurement
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "optional": {
+            "measurements": [{
+                "@type": "Measurement",
+                "value": "",
+                "depthUpper": "",
+                "depthLower": "",
+                "term.termType": "soilType",
+                "optional": {
+                    "dates": ""
+                }
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "",
+        "depthUpper": "",
+        "depthLower": "",
+        "methodClassification": "modelled using other measurements"
+    }]
+}
+LOOKUPS = {
+    "soilType": "IPCC_SOIL_CATEGORY"
+}
+TERM_ID = 'organicSoils,mineralSoils'
+
+MEASUREMENT_TERM_IDS = TERM_ID.split(',')
+ORGANIC_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[0]
+MINERAL_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[1]
+METHOD = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
+
+TARGET_LOOKUP_VALUE = IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE[IpccSoilCategory.ORGANIC_SOILS]
+
+IS_100_THRESHOLD = 99.5
+
+
+def _measurement(term_id: str, **kwargs):
+    measurement = _new_measurement(term_id)
+    return measurement | {
+        **{k: v for k, v in kwargs.items()},
+        "methodClassification": METHOD
+    }
+
+
+class _SoilTypeDatum(NamedTuple):
+    term_id: str
+    depth_upper: float
+    depth_lower: float
+    dates: list[str]
+    value: float
+    is_organic: bool
+    is_complete_depth: bool
+    is_standard_depth: bool
+
+
+class _InventoryKey(NamedTuple):
+    depth_upper: float
+    depth_lower: float
+    date: Optional[str]
+
+
+_InventoryGroup = dict[str, float]
+
+_SoilTypeInventory = dict[_InventoryKey, _InventoryGroup]
+
+
+_DEFAULT_INVENTORY: _SoilTypeInventory = {
+    _InventoryKey(None, None, None): {
+        "organicSoils": 0,
+        "mineralSoils": 100
+    }
+}
+
+
+def _soil_type_data_to_inventory_keys(datum: _SoilTypeDatum):
+    return (
+        [_InventoryKey(datum.depth_upper, datum.depth_lower, date) for date in dates]
+        if len((dates := datum.dates)) > 0
+        else [_InventoryKey(datum.depth_upper, datum.depth_lower, None)]
+    )
+
+
+def _extract_soil_type_data(node: dict) -> _SoilTypeDatum:
+    depth_upper = node.get("depthUpper")
+    depth_lower = node.get("depthLower")
+    depth_interval = (depth_upper, depth_lower)
+
+    return _SoilTypeDatum(
+        term_id=node.get("term", {}).get("@id"),
+        depth_upper=depth_upper,
+        depth_lower=depth_lower,
+        dates=node.get("dates", []),
+        value=get_node_value(node),
+        is_organic=node_lookup_match(node, LOOKUPS["soilType"], TARGET_LOOKUP_VALUE),
+        is_complete_depth=all(depth is not None for depth in depth_interval),
+        is_standard_depth=depth_interval in STANDARD_DEPTHS,
+    )
+
+
+def _classify_soil_type_data(soil_type_data: list[_SoilTypeDatum]):
+    """
+    Calculate the values of `organicSoils` and `mineralSoils` from `soilType` measurements for each unique combination
+    of depth interval and date.
+    """
+
+    def classify(inventory: _SoilTypeInventory, datum: _SoilTypeDatum) -> _SoilTypeInventory:
+        """
+        Sum the values of organic and mineral `soilType` Measurements by depth interval and date.
+        """
+        keys = _soil_type_data_to_inventory_keys(datum)
+
+        inner_key = ORGANIC_SOILS_TERM_ID if datum.is_organic else MINERAL_SOILS_TERM_ID
+
+        update_dict = {
+            key: (inner := inventory.get(key, {})) | {
+                inner_key: min(inner.get(inner_key, 0) + datum.value, 100)
+            } for key in keys
+        }
+
+        return merge(dict(), inventory, update_dict)
+
+    inventory = _select_most_complete_groups(reduce(classify, soil_type_data, {}))
+
+    return {
+        key: {
+            ORGANIC_SOILS_TERM_ID: (org := group.get(ORGANIC_SOILS_TERM_ID, 0)),
+            MINERAL_SOILS_TERM_ID: 100 - org
+        } for key, group in inventory.items()
+    }
+
+
+def _group_keys_by_depth(inventory: _SoilTypeInventory) -> dict[tuple, list[_InventoryKey]]:
+
+    def group(result: dict[tuple, list[_InventoryKey]], key: _InventoryKey) -> dict[tuple, list[_InventoryKey]]:
+        depth_interval = (key.depth_upper, key.depth_lower)
+        update_dict = {depth_interval: result.get(depth_interval, []) + [key]}
+        return result | update_dict
+
+    return reduce(group, inventory.keys(), {})
+
+
+def _select_most_complete_groups(inventory: _SoilTypeInventory):
+    """
+    For each depth interval, we need to choose the inventory items that have the most complete information.
+
+    Items should be prioritised in the following order:
+
+    - If only dated items are available, use dated
+    - If only undated items are available, use undated
+    - If there are a mix of dated and undated items:
+        - If dated items include organic soils measurements, use dated
+        - If undated items include organic soils measurements, use undated
+        - Otherwise, use dated
+    """
+    grouped = _group_keys_by_depth(inventory)
+
+    def select(result: set[_InventoryKey], keys: list[_InventoryKey]) -> set[_InventoryKey]:
+        with_dates, without_dates = split_on_condition(set(keys), lambda k: k.date is not None)
+
+        with_dates_have_org_value = any(
+            (
+                ORGANIC_SOILS_TERM_ID in (group := inventory.get(key, {}))
+                or group.get(MINERAL_SOILS_TERM_ID, 0) >= IS_100_THRESHOLD
+            ) for key in with_dates
+        )
+
+        without_dates_have_org_value = any(
+            (
+                ORGANIC_SOILS_TERM_ID in (group := inventory.get(key, {}))
+                or group.get(MINERAL_SOILS_TERM_ID, 0) >= IS_100_THRESHOLD
+            ) for key in without_dates
+        )
+
+        run_with_dates = (
+            with_dates_have_org_value
+            or (with_dates and not without_dates_have_org_value)
+        )
+
+        return result | (with_dates if run_with_dates else without_dates)
+
+    selected_keys = reduce(select, grouped.values(), set())
+
+    return {k: v for k, v in inventory.items() if k in selected_keys}
+
+
+def _format_dates(dates: list[str]):
+    """Format a list of datestrings for logging."""
+    return " ".join(format_str(date) for date in dates) if isinstance(dates, list) and len(dates) else "None"
+
+
+_DATUM_KEY_TO_FORMAT_FUNC = {
+    "depth_upper": lambda x: format_float(x, "cm"),
+    "depth_lower": lambda x: format_float(x, "cm"),
+    "dates": _format_dates,
+    "value": lambda x: format_float(x, "pct area"),
+    "is_organic": format_bool,
+    "is_complete_depth": format_bool,
+    "is_standard_depth": format_bool,
+}
+DEFAULT_FORMAT_FUNC = format_str
+
+
+def _format_soil_data(data: list[_SoilTypeDatum]):
+    return log_as_table(
+        {
+            format_str(k): _DATUM_KEY_TO_FORMAT_FUNC.get(k, DEFAULT_FORMAT_FUNC)(v) for k, v in datum._asdict().items()
+        } for datum in data
+    ) if data else "None"
+
+
+_FILTER_BY = (
+    "is_standard_depth",
+    "is_complete_depth"
+)
+
+
+def _filter_data_by_depth_availability(data: list[_SoilTypeDatum]):
+    """
+    If measurements with depth available -> discard measurements without depth
+    If measurements with standard depth available -> discard non-standard depths
+    Else, use measurements with depth
+    """
+    return next(
+        (
+            (filter_, result) for filter_ in _FILTER_BY
+            if (result := [datum for datum in data if datum.__getattribute__(filter_)])
+        ),
+        (None, data)
+    )
+
+
+def _should_run(site: dict):
+    soil_type_nodes = split_nodes_by_dates(
+        filter_list_term_type(site.get("measurements", []), TermTermType.SOILTYPE)
+    )
+
+    filtered_by, soil_type_data = _filter_data_by_depth_availability(
+        [_extract_soil_type_data(node) for node in soil_type_nodes]
+    )
+
+    inventory = _classify_soil_type_data(soil_type_data) if soil_type_data else _DEFAULT_INVENTORY
+
+    should_run = all([
+        inventory
+    ])
+
+    for term_id in MEASUREMENT_TERM_IDS:
+
+        logRequirements(
+            site,
+            model=MODEL,
+            term=term_id,
+            soil_type_data=_format_soil_data(soil_type_data),
+            filtered_by=format_str(filtered_by)
+        )
+
+        logShouldRun(site, MODEL, term_id, should_run)
+
+    return should_run, inventory
+
+
+_INVENTORY_KEY_TO_FIELD_KEY = {
+    "depth_upper": "depthUpper",
+    "depth_lower": "depthLower",
+    "date": "dates"
+}
+_INVENTORY_KEY_TO_FIELD_VALUE = {
+    "date": lambda x: [x]
+}
+
+
+def _key_to_measurement_fields(key: _InventoryKey):
+    return {
+        _INVENTORY_KEY_TO_FIELD_KEY.get(k, k): _INVENTORY_KEY_TO_FIELD_VALUE.get(k, lambda x: x)(v)
+        for k, v in key._asdict().items() if v is not None
+    }
+
+
+def _run(inventory: _SoilTypeInventory) -> list[dict]:
+    return flatten(
+        [
+            _measurement(
+                term_id,
+                value=[value],
+                **_key_to_measurement_fields(key)
+            ) for term_id, value in value.items()
+        ] for key, value in inventory.items()
+    )
+
+
+def run(site: dict):
+    should_run, valid_inventory = _should_run(site)
+    return _run(valid_inventory) if should_run else []

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -2,7 +2,7 @@ from enum import Enum
 from functools import reduce
 from numpy import average, copy, random, vstack
 from numpy.typing import NDArray
-from typing import Optional, Union
+from typing import Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
@@ -12,7 +12,7 @@ from hestia_earth.utils.tools import non_empty_list
 from hestia_earth.utils.stats import gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_bool, format_float, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 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
@@ -338,7 +338,7 @@ def _format_inventory(inventory: dict) -> str:
         {
             "year": year,
             **{
-                _format_column_header(category): _format_number(
+                _format_column_header(category): format_float(
                     inventory.get(year, {}).get(_InventoryKey.LAND_COVER_SUMMARY, {}).get(category, 0)
                 ) for category in land_covers
             },
@@ -384,16 +384,6 @@ def _get_loggable_inventory_keys(inventory: dict) -> list:
     return sorted(unique_keys, key=lambda key_: key_order[key_])
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(bool(value))
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
     """Format an enum or str for logging as a table column header."""
     as_string = value.value if isinstance(value, Enum) else str(value)
@@ -401,8 +391,8 @@ def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
 
 
 _INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_COVER_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LCC_EVENT: _format_number
+    _InventoryKey.LAND_COVER_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LCC_EVENT: format_float
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -2,7 +2,7 @@ from enum import Enum
 from functools import reduce
 from numpy import average, copy, random, vstack
 from numpy.typing import NDArray
-from typing import Optional, Union
+from typing import Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
@@ -12,7 +12,7 @@ from hestia_earth.utils.tools import non_empty_list
 from hestia_earth.utils.stats import gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_bool, format_float, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 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
@@ -325,7 +325,7 @@ def _format_inventory(inventory: dict) -> str:
         {
             "year": year,
             **{
-                _format_column_header(category): _format_number(
+                _format_column_header(category): format_float(
                     inventory.get(year, {}).get(_InventoryKey.BIOMASS_CATEGORY_SUMMARY, {}).get(category, 0)
                 ) for category in land_covers
             },
@@ -371,16 +371,6 @@ def _get_loggable_inventory_keys(inventory: dict) -> list:
     return sorted(unique_keys, key=lambda key_: key_order[key_])
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(bool(value))
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
     """Format an enum or str for logging as a table column header."""
     as_string = value.value if isinstance(value, Enum) else str(value)
@@ -388,8 +378,8 @@ def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
 
 
 _INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_COVER_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LCC_EVENT: _format_number
+    _InventoryKey.LAND_COVER_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LCC_EVENT: format_float
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of

hestia_earth/models/ipcc2019/biocharOrganicCarbonPerHa.py

@@ -11,7 +11,7 @@ from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 from hestia_earth.utils.stats import gen_seed, truncated_normal_1d
 from hestia_earth.utils.tools import non_empty_list
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_nd_array, format_str, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import group_nodes_by_year, filter_list_term_type
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.property import get_node_property
@@ -280,17 +280,17 @@ def _format_inventory(inventory: dict) -> str:
     return log_as_table(
         {
             "year": year,
-            "stable-oc-from-biochar": _format_factor(inventory.get(year))
+            "stable-oc-from-biochar": format_nd_array(inventory.get(year))
         } for year in inventory_years
     ) if should_run else "None"
 
 
 def _format_logs(logs: dict):
     """
-    Format model logs. Format method selected based on dict key, with `_format_str` as fallback.
+    Format model logs. Format method selected based on dict key, with `format_str` as fallback.
     """
     return {
-        _format_str(key): _LOG_KEY_TO_FORMAT_FUNC.get(key, _format_str)(value) for key, value in logs.items()
+        format_str(key): _LOG_KEY_TO_FORMAT_FUNC.get(key, format_str)(value) for key, value in logs.items()
     }
 
 
@@ -303,45 +303,11 @@ def _format_factor_cache(factor_cache: dict) -> str:
     return log_as_table(
         {
             "term-id": term_id,
-            **{_format_str(key): _format_factor(value) for key, value in factor_dict.items()}
+            **{format_str(key): format_nd_array(value) for key, value in factor_dict.items()}
         } for term_id, factor_dict in factor_cache.items()
     ) if should_run else "None"
 
 
-def _format_factor(value) -> str:
-    """
-    Format a model factor. Method selected based on factor type (ndarray, int or float).
-    """
-    format_func = next(
-        (func for type, func in _TYPE_TO_FORMAT_FUNC.items() if isinstance(value, type)),
-        None
-    )
-    return format_func(value) if format_func else "None"
-
-
-def _format_nd_array(value) -> str:
-    return f"{np.mean(value):.3g} ± {np.std(value):.3g}"
-
-
-def _format_number(value) -> str:
-    return f"{value:.3g}"
-
-
-_INVALID_CHARS = {"_", ":", ",", "="}
-_REPLACEMENT_CHAR = "-"
-
-
-def _format_str(value: str, *_) -> str:
-    """Format a string for logging in a table. Remove all characters used to render the table on the front end."""
-    return reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
-
-
-_TYPE_TO_FORMAT_FUNC = {
-    np.ndarray: _format_nd_array,
-    (float, int): _format_number
-}
-
-
 _LOG_KEY_TO_FORMAT_FUNC = {
     "factor_cache": _format_factor_cache
 }

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -74,7 +74,8 @@ LOOKUPS = {
     ],
     "crop-property": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"],
     "forage-property": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"],
-    "processedFood-property": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+    "processedFood-property": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"],
+    "feedFoodAdditive": ["hasEnergyContent"]
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/ipcc2019/ch4ToAirOrganicSoilCultivation.py

@@ -2,7 +2,7 @@ import numpy as np
 import numpy.typing as npt
 from typing import Callable, Union
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import format_nd_array, format_float, logRequirements, logShouldRun
 from hestia_earth.utils.stats import (
     discrete_uniform_1d, gen_seed, normal_1d, repeat_single, triangular_1d
 )
@@ -15,8 +15,8 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_ditch_category, assign_organic_soil_category, calc_emission, DitchCategory, format_nd_array, format_number,
-    get_ditch_frac, get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
+    assign_ditch_category, assign_organic_soil_category, calc_emission, DitchCategory, get_ditch_frac,
+    get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -226,8 +226,8 @@ def _should_run(cycle: dict):
         emission_factor=format_nd_array(emission_factor),
         ditch_factor=format_nd_array(ditch_factor),
         ditch_frac=format_nd_array(ditch_frac),
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -18,7 +18,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 from hestia_earth.utils.stats import correlated_normal_2d, gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table
+from hestia_earth.models.log import format_bool, format_float, format_int, format_nd_array, log_as_table
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import (
     _gapfill_datestr, _get_datestr_format, cumulative_nodes_term_match, DatestrGapfillMode, DatestrFormat,
@@ -1386,7 +1386,7 @@ def _format_cycle_inventory(cycle_inventory: dict) -> str:
         {
             "year": year,
             **{
-                id: _format_number(group.get(KEY, {}).get(id, 0)) for id in unique_cycles
+                id: format_float(group.get(KEY, {}).get(id, 0)) for id in unique_cycles
             }
         } for year, group in cycle_inventory.items()
     ) if should_run else "None"
@@ -1450,21 +1450,6 @@ def _format_land_use_inventory(land_use_inventory: dict) -> str:
     ) if should_run else "None"
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(value) if isinstance(value, bool) else "None"
-
-
-def _format_int(value: Optional[float]) -> str:
-    """Format an int for logging in a table. If the value is invalid, return `"None"` as a string."""
-    return f"{value:.0f}" if isinstance(value, (float, int)) else "None"
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table. If the value is invalid, return `"None"` as a string."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 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
@@ -1483,16 +1468,16 @@ def _format_named_tuple(value: Optional[Union[CarbonStock, CarbonStockChange, Ca
     Extract and format just the value and discard the other data. If the value is invalid, return `"None"` as a string.
     """
     return (
-        _format_number(mean(value.value))
+        format_nd_array(mean(value.value))
         if isinstance(value, (CarbonStock, CarbonStockChange, CarbonStockChangeEmission))
         else "None"
     )
 
 
 _LAND_USE_INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_USE_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LUC_EVENT: _format_int,
-    _InventoryKey.YEARS_SINCE_INVENTORY_START: _format_int
+    _InventoryKey.LAND_USE_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LUC_EVENT: format_int,
+    _InventoryKey.YEARS_SINCE_INVENTORY_START: format_int
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of

hestia_earth/models/ipcc2019/co2ToAirOrganicSoilCultivation.py

@@ -5,7 +5,7 @@ from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
 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 logRequirements, logShouldRun
+from hestia_earth.models.log import format_float, format_nd_array, logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import land_occupation_per_ha
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.emission import _new_emission
@@ -13,8 +13,7 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_organic_soil_category, calc_emission, format_nd_array, format_number, get_emission_factor,
-    OrganicSoilCategory, valid_eco_climate_zone
+    assign_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -183,8 +182,8 @@ def _should_run(cycle: dict):
         eco_climate_zone=eco_climate_zone,
         organic_soil_category=organic_soil_category,
         emission_factor=format_nd_array(emission_factor),
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/n2OToAirOrganicSoilCultivationDirect.py

@@ -1,6 +1,6 @@
 from hestia_earth.schema import EmissionMethodTier
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import format_float, logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import land_occupation_per_ha
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,7 +8,7 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_organic_soil_category, calc_emission, format_number, get_emission_factor, OrganicSoilCategory,
+    assign_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory,
     remap_categories, valid_eco_climate_zone
 )
 from . import MODEL
@@ -122,9 +122,9 @@ def _should_run(cycle: dict):
         cycle, model=MODEL, term=TERM_ID,
         eco_climate_zone=eco_climate_zone,
         organic_soil_category=organic_soil_category,
-        emission_factor=f"{format_number(emission_factor_mean)} ± {format_number(emission_factor_sd)}",
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        emission_factor=f"{format_float(emission_factor_mean)} ± {format_float(emission_factor_sd)}",
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([