hestia-earth-models 0.70.2__py3-none-any.whl → 0.70.4__py3-none-any.whl

hestia_earth/models/config/Cycle.json

@@ -182,6 +182,14 @@
       "mergeStrategy": "list",
       "stage": 1
     },
+    {
+      "key": "practices",
+      "model": "cycle",
+      "value": "practice.landCover",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     {
       "key": "products",
       "model": "hestia",

hestia_earth/models/cycle/practice/landCover.py

@@ -0,0 +1,181 @@
+from functools import reduce
+from hestia_earth.schema import TermTermType, SiteSiteType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import non_empty_list, flatten, list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import _omit, _include
+from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.blank_node import condense_nodes
+from hestia_earth.models.utils.crop import get_landCover_term_id
+from .. import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "endDate": "",
+        "products": [
+            {
+                "@type": "Product",
+                "term.termType": ["crop", "forage"],
+                "optional": {
+                    "startDate": "",
+                    "endDate": ""
+                }
+            }
+        ],
+        "site": {
+            "@type": "Site",
+            "siteType": "cropland"
+        },
+        "none": {
+            "practices": [{"@type": "Practice", "term.termType": "landCover"}]
+        },
+        "optional": {
+            "startDate": ""
+        }
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "term.termType": "landCover",
+        "value": "",
+        "endDate": "",
+        "startDate": ""
+    }]
+}
+LOOKUPS = {
+    "crop": ["landCoverTermId", "maximumCycleDuration"],
+    "forage": ["landCoverTermId"],
+    "property": ["GAP_FILL_TO_MANAGEMENT", "CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"]
+}
+MODEL_KEY = 'landCover'
+
+
+def practice(data: dict):
+    node = _new_practice(data.get('id'))
+    node['value'] = [data['value']]
+    node['endDate'] = data['endDate']
+    if data.get('startDate'):
+        node['startDate'] = data['startDate']
+    if data.get('properties'):
+        node['properties'] = data['properties']
+    return node
+
+
+def _should_gap_fill(term: dict):
+    value = get_lookup_value(lookup_term=term, column='GAP_FILL_TO_MANAGEMENT')
+    return bool(value)
+
+
+def _filter_properties(blank_node: dict):
+    properties = list(filter(lambda p: _should_gap_fill(p.get('term', {})), blank_node.get('properties', [])))
+    return _omit(blank_node, ['properties']) | ({'properties': properties} if properties else {})
+
+
+def _map_to_value(value: dict):
+    return {
+        'id': value.get('term', {}).get('@id'),
+        'value': value.get('value'),
+        'startDate': value.get('startDate'),
+        'endDate': value.get('endDate'),
+        'properties': value.get('properties')
+    }
+
+
+def _copy_item_if_exists(source: dict, keys: list[str] = None, dest: dict = None) -> dict:
+    return reduce(lambda p, c: p | ({c: source[c]} if source.get(c) else {}), keys or [], dest or {})
+
+
+def _run(cycle: dict, products: list, total: float):
+    # remove any properties that should not get gap-filled
+    products = list(map(_filter_properties, products))
+
+    nodes = [
+        _map_to_value(_include(cycle, ["startDate", "endDate"]) | _copy_item_if_exists(
+            source=product,
+            keys=['properties', 'startDate', 'endDate'],
+            dest={
+                "term": {'@id': product.get('land-cover-id')},
+                "value": round((100 - total) / len(products), 2)
+            }
+        ))
+        for product in products
+    ]
+
+    return condense_nodes(list(map(practice, nodes)))
+
+
+def _should_group_landCover(term: dict):
+    value = get_lookup_value(lookup_term=term, column='CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY')
+    return bool(value)
+
+
+def _has_prop_grouped_with_landCover(product: dict):
+    return bool(
+        next((
+            p
+            for p in product.get('properties', [])
+            if _should_group_landCover(p.get('term', {}))
+        ), None)
+    )
+
+
+def _product_wit_landCover_id(product: dict):
+    landCover_id = get_landCover_term_id(product.get('term', {}))
+    return product | {'land-cover-id': landCover_id} if landCover_id else None
+
+
+def _should_run(cycle: dict):
+    is_cropland = cycle.get('site', {}).get('siteType') == SiteSiteType.CROPLAND.value
+
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.LANDCOVER)
+    # split practices with properties that group with landCover
+    practices_max_100 = [
+        p for p in practices if _has_prop_grouped_with_landCover(p)
+    ]
+    total_practices_max_100 = list_sum([
+        list_sum(p.get('value', []))
+        for p in practices_max_100
+    ])
+    practices_without_grouped_props = [
+        p for p in practices if not _has_prop_grouped_with_landCover(p)
+    ]
+
+    products = filter_list_term_type(cycle.get('products', []), [TermTermType.CROP, TermTermType.FORAGE])
+    # only take products with a matching landCover term
+    products = non_empty_list(map(_product_wit_landCover_id, products))
+
+    # Products that can sum up to 100% => run if total is below 100%
+    products_max_100 = [
+        p for p in products
+        if _has_prop_grouped_with_landCover(p)
+    ] if total_practices_max_100 < 100 else []
+
+    # Products that must sum up to 100% => can not run practices already exist as already 100%
+    products_is_100 = [
+        p for p in products
+        if not _has_prop_grouped_with_landCover(p)
+    ] if not practices_without_grouped_props else []
+
+    has_crop_forage_products = bool(products_max_100 + products_is_100)
+
+    logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
+                    is_cropland=is_cropland,
+                    has_crop_forage_products=has_crop_forage_products)
+
+    should_run = all([is_cropland, has_crop_forage_products])
+    logShouldRun(cycle, MODEL, None, should_run, model_key=MODEL_KEY)
+
+    return should_run, [
+        (products_max_100, total_practices_max_100),
+        (products_is_100, 0)
+    ]
+
+
+def run(cycle: dict):
+    should_run, products_list = _should_run(cycle)
+    return flatten([
+        _run(cycle, products, total)
+        for products, total in products_list if products
+    ]) if should_run else []

hestia_earth/models/emepEea2019/nh3ToAirExcreta.py

@@ -46,7 +46,7 @@ def _run(excreta_EF_input: float):
 def _should_run(cycle: dict):
     excreta_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
     excreta_EF_input = get_excreta_inputs_with_factor(
-        cycle, f"{list(LOOKUPS.keys())[0]}.csv", excreta_convertion_func=total_excreta_tan, model=MODEL, term=TERM_ID
+        cycle, f"{list(LOOKUPS.keys())[0]}.csv", excreta_conversion_func=total_excreta_tan, model=MODEL, term=TERM_ID
     )
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,

hestia_earth/models/geospatialDatabase/altitude.py

@@ -27,6 +27,7 @@ EE_PARAMS = {
     'collection': 'USGS/GMTED2010_FULL',
     'ee_type': 'raster',
     'band_name': 'med',
+    'reducer': 'mode',
     'is_image': True
 }
 BIBLIO_TITLE = 'An Enhanced Global Elevation Model Generalized From Multiple Higher Resolution Source Datasets'

hestia_earth/models/geospatialDatabase/clayContent.py

@@ -92,14 +92,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
-    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
+    has_no_original_texture_measurements = not has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
                     below_max_area_size=below_max_area_size,
-                    has_original_texture_measurements=has_original_texture_measurements)
+                    has_no_original_texture_measurements=has_no_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
+    should_run = all([contains_geospatial_data, below_max_area_size, has_no_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/geospatialDatabase/sandContent.py

@@ -92,14 +92,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
-    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
+    has_no_original_texture_measurements = not has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
                     below_max_area_size=below_max_area_size,
-                    has_original_texture_measurements=has_original_texture_measurements)
+                    has_no_original_texture_measurements=has_no_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
+    should_run = all([contains_geospatial_data, below_max_area_size, has_no_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/geospatialDatabase/utils.py

@@ -157,8 +157,7 @@ def _get_cached_data(term: str, site: dict, data: dict):
         isinstance(cache, dict),
         cache_sub_key
     ]) else cache
-    if value is not None:
-        debugValues(site, model=MODEL, term=term, value_from_cache=value)
+    debugValues(site, model=MODEL, term=term, value_from_cache=value)
     return value
 
 

hestia_earth/models/hestia/landCover.py

@@ -16,7 +16,7 @@ from hestia_earth.models.utils.constant import DAYS_IN_YEAR
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.lookup import get_region_lookup_value
-from hestia_earth.models.utils.blank_node import _node_date, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
+from hestia_earth.models.utils.blank_node import DatestrFormat, _gapfill_datestr, DatestrGapfillMode
 from .utils import (
     IPCC_LAND_USE_CATEGORY_ANNUAL,
     IPCC_LAND_USE_CATEGORY_PERENNIAL,
@@ -410,8 +410,15 @@ def _get_faostat_name(term: dict) -> str:
     return _get_lookup_with_cache(term, "cropGroupingFaostatArea")
 
 
+def _get_most_common_or_alphabetically_first(crop_terms: list) -> str:
+    histogram = {term: crop_terms.count(term) for term in crop_terms}
+    max_freq = max(histogram.values())
+    # Sorted; to be deterministic
+    return sorted([term for term, freq in histogram.items() if freq == max_freq])[0]
+
+
 def _get_complete_faostat_to_crop_mapping() -> dict:
-    """Returns mapping in the format: {faostat_name: IPPC_LAND_USE_CATEGORY, ...}"""
+    """Returns mapping in the format: {faostat_name: IPCC_LAND_USE_CATEGORY, ...}"""
     lookup = download_lookup("crop.csv")
     mappings = defaultdict(list)
     for crop_term_id in [row[0] for row in lookup]:
@@ -421,7 +428,7 @@ def _get_complete_faostat_to_crop_mapping() -> dict:
         if key:
             mappings[key].append(crop_ipcc_land_use_category(crop_term_id=crop_term_id, lookup_term_type="crop"))
     return {
-        fao_name: max(set(crop_terms), key=crop_terms.count)
+        fao_name: _get_most_common_or_alphabetically_first(crop_terms)
         for fao_name, crop_terms in mappings.items()
     }
 
@@ -758,26 +765,32 @@ def _collect_land_use_types(nodes: list) -> list:
             "id": node.get("term", {}).get("@id"),
             "land-use-type": _get_land_use_term_from_node(node),
             "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10],
-            "startDate": _gapfill_datestr(
-                datestr=node.get("startDate"), mode=DatestrGapfillMode.START
-            )[:10] if node.get("startDate") else None
+            "startDate": _gapfill_datestr(datestr=node.get("startDate"), mode=DatestrGapfillMode.START)[:10]
         } for node in nodes
     ]
 
 
-def _no_prior_land_cover_data(nodes: list, node: dict) -> bool:
+def _no_prior_land_cover_data(nodes: list, target_node: dict) -> bool:
+    """
+    Returns true if there are no nodes whose start & end dates the target_node falls within,
+    including a tolerance.
+    """
     target_date = (
-        datetime.strptime(node.get('startDate') or node.get('endDate'), DatestrFormat.YEAR_MONTH_DAY.value)
+        datetime.strptime(target_node.get('startDate') or target_node.get('endDate'),
+                          DatestrFormat.YEAR_MONTH_DAY.value)
         - timedelta(days=DEFAULT_WINDOW_IN_YEARS * DAYS_IN_YEAR)
     )
+    tolerance = timedelta(days=DATE_TOLERANCE_IN_YEARS * DAYS_IN_YEAR)
     previous_nodes = [
         node for node in nodes
-        if abs(_node_date(node) - target_date) < timedelta(days=DATE_TOLERANCE_IN_YEARS * DAYS_IN_YEAR)
+        if datetime.strptime(node.get("startDate"), DatestrFormat.YEAR_MONTH_DAY.value) - tolerance
+        < target_date <
+        datetime.strptime(node.get("endDate"), DatestrFormat.YEAR_MONTH_DAY.value) + tolerance
     ]
     return len(previous_nodes) == 0
 
 
-def _should_run(site: dict) -> tuple[bool, dict]:
+def _should_run(site: dict) -> tuple[bool, list, dict]:
     management_nodes = _collect_land_use_types(
         [
             node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
@@ -795,8 +808,8 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     land_use_type = relevant_nodes[0].get("land-use-type") if relevant_nodes else None
 
     has_no_prior_land_cover_data = _no_prior_land_cover_data(
-        nodes=relevant_nodes,
-        node=relevant_nodes[-1:][0]
+        nodes=management_nodes,
+        target_node=relevant_nodes[-1:][0]
     ) if relevant_nodes else None
 
     should_run_nodes, site_area = _should_run_historical_land_use_change(

hestia_earth/models/hestia/management.py

@@ -1,6 +1,5 @@
 from typing import List
 from datetime import timedelta, datetime
-from functools import reduce
 from hestia_earth.schema import SchemaType, TermTermType, SiteSiteType, COMPLETENESS_MAPPING
 from hestia_earth.utils.lookup import column_name, get_table_value, download_lookup
 from hestia_earth.utils.model import filter_list_term_type
@@ -8,7 +7,7 @@ from hestia_earth.utils.tools import safe_parse_float, flatten
 from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils import _include, _omit, group_by
+from hestia_earth.models.utils import _include, group_by
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.blank_node import condense_nodes, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
@@ -24,20 +23,16 @@ REQUIREMENTS = {
             "Cycle": [{
                 "@type": "Cycle",
                 "endDate": "",
-                "products": [
-                    {
-                        "@type": "Product",
-                        "term.termType": ["crop", "forage", "landCover"]
-                    }
-                ],
                 "practices": [
                     {
+                        "@type": "Practice",
                         "term.termType": [
                             "waterRegime",
                             "tillage",
                             "cropResidueManagement",
                             "landUseManagement",
-                            "system"
+                            "system",
+                            "landCover"
                         ],
                         "value": ""
                     }
@@ -62,7 +57,6 @@ REQUIREMENTS = {
 }
 RETURNS = {
     "Management": [{
-        "@type": "Management",
         "term.termType": [
             "landCover", "waterRegime", "tillage", "cropResidueManagement", "landUseManagement", "system"
         ],
@@ -78,7 +72,7 @@ LOOKUPS = {
     "organicFertiliser": "ANIMAL_MANURE",
     "soilAmendment": "PRACTICE_INCREASING_C_INPUT",
     "landUseManagement": "GAP_FILL_TO_MANAGEMENT",
-    "property": ["GAP_FILL_TO_MANAGEMENT", "CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"]
+    "property": "GAP_FILL_TO_MANAGEMENT"
 }
 MODEL_KEY = 'management'
 
@@ -87,7 +81,8 @@ _PRACTICES_TERM_TYPES = [
     TermTermType.TILLAGE,
     TermTermType.CROPRESIDUEMANAGEMENT,
     TermTermType.LANDUSEMANAGEMENT,
-    TermTermType.SYSTEM
+    TermTermType.SYSTEM,
+    TermTermType.LANDCOVER
 ]
 _PRACTICES_COMPLETENESS_MAPPING = COMPLETENESS_MAPPING.get(SchemaType.PRACTICE.value, {})
 _ANIMAL_MANURE_USED_TERM_ID = "animalManureUsed"
@@ -125,7 +120,6 @@ _INPUT_RULES = {
 _SKIP_LAND_COVER_SITE_TYPES = [
     SiteSiteType.CROPLAND.value
 ]
-_CYCLE_DATE_TERM_TYPES = {TermTermType.CROP.value, TermTermType.FORAGE.value}
 
 
 def management(data: dict):
@@ -188,11 +182,6 @@ def _should_gap_fill(term: dict):
     return bool(value)
 
 
-def _filter_properties(blank_node: dict):
-    properties = list(filter(lambda p: _should_gap_fill(p.get('term', {})), blank_node.get('properties', [])))
-    return _omit(blank_node, ['properties']) | ({'properties': properties} if properties else {})
-
-
 def _map_to_value(value: dict):
     return {
         'id': value.get('term', {}).get('@id'),
@@ -207,10 +196,6 @@ def _extract_node_value(node: dict) -> dict:
     return node | {'value': get_node_value(node)}
 
 
-def _copy_item_if_exists(source: dict, keys: list[str] = None, dest: dict = None) -> dict:
-    return reduce(lambda p, c: p | ({c: source[c]} if source.get(c) else {}), keys or [], dest or {})
-
-
 def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermType], completeness_mapping: dict = {}):
     """
     Get items from the list of cycles with any of the relevant terms.
@@ -278,84 +263,6 @@ def _run_from_siteType(site: dict, cycle: dict):
     }] if should_run else []
 
 
-def _run_products(cycle: dict, products: list, total_products: int = None, use_cycle_dates: bool = False):
-    default_dates = _include_with_date_gap_fill(cycle, ["startDate", "endDate"])
-    return [
-        _map_to_value(default_dates | _copy_item_if_exists(
-            source=product,
-            keys=['properties', 'startDate', 'endDate'],
-            dest={
-                "term": {'@id': get_landCover_term_id(product.get('term', {}))},
-                "value": round(100 / (total_products or len(products)), 2)
-            }
-        ) | (
-            default_dates if use_cycle_dates or product.get("term", {}).get("termType") in _CYCLE_DATE_TERM_TYPES
-            else {}
-        ))
-        for product in products
-    ]
-
-
-def _run_from_landCover(cycle: dict, crop_forage_products: list):
-    """
-    Copy landCover items, and include crop/forage landCover items with properties to count in ratio.
-    """
-    land_cover_products = [
-        _map_to_value(_extract_node_value(
-            _include_with_date_gap_fill(
-                value=product,
-                keys=["term", "value", "startDate", "endDate", "properties"]
-            )
-        )) for product in _get_relevant_items(
-            cycle=cycle,
-            item_name="products",
-            term_types=[TermTermType.LANDCOVER]
-        )
-    ]
-    return land_cover_products + _run_products(
-        cycle,
-        crop_forage_products,
-        total_products=len(crop_forage_products) + len(land_cover_products),
-        use_cycle_dates=True
-    )
-
-
-def _should_group_landCover(term: dict):
-    value = get_lookup_value(lookup_term=term, column='CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY')
-    return bool(value)
-
-
-def _has_prop_grouped_with_landCover(product: dict):
-    return bool(
-        next((
-            p
-            for p in product.get('properties', [])
-            if _should_group_landCover(p.get('term', {}))
-        ), None)
-    )
-
-
-def _run_from_crop_forage(cycle: dict, site: dict):
-    products = _get_relevant_items(
-        cycle=cycle,
-        item_name="products",
-        term_types=[TermTermType.CROP, TermTermType.FORAGE]
-    ) if site.get("siteType", "") == SiteSiteType.CROPLAND.value else []
-    # only take products with a matching landCover term
-    products = [p for p in products if get_landCover_term_id(p.get('term', {}))]
-    # remove any properties that should not get gap-filled
-    products = list(map(_filter_properties, products))
-
-    # split products with properties that group with landCover
-    products_with_gap_filled_props = [p for p in products if _has_prop_grouped_with_landCover(p)]
-    products_without_gap_filled_props = [p for p in products if not _has_prop_grouped_with_landCover(p)]
-
-    return _run_from_landCover(
-        cycle=cycle,
-        crop_forage_products=products_with_gap_filled_props
-    ) + _run_products(cycle, products_without_gap_filled_props, use_cycle_dates=False)
-
-
 def _should_run_practice(practice: dict):
     """
     Include only landUseManagement practices where GAP_FILL_TO_MANAGEMENT = True
@@ -369,7 +276,7 @@ def _run_from_practices(cycle: dict):
         _extract_node_value(
             _include_with_date_gap_fill(
                 value=practice,
-                keys=["term", "value", "startDate", "endDate"]
+                keys=["term", "value", "startDate", "endDate", "properties"]
             )
         ) for practice in _get_relevant_items(
             cycle=cycle,
@@ -378,18 +285,16 @@ def _run_from_practices(cycle: dict):
             completeness_mapping=_PRACTICES_COMPLETENESS_MAPPING
         )
     ]
-    practices = list(map(_map_to_value, filter(_should_run_practice, practices)))
-    return practices
+    return list(map(_map_to_value, filter(_should_run_practice, practices)))
 
 
 def _run_cycle(site: dict, cycle: dict):
     inputs = _run_from_inputs(site, cycle)
-    products = _run_from_crop_forage(site=site, cycle=cycle)
     site_types = _run_from_siteType(site=site, cycle=cycle)
     practices = _run_from_practices(cycle)
     return [
         node | {'cycle-id': cycle.get('@id')}
-        for node in inputs + products + site_types + practices
+        for node in inputs + site_types + practices
     ]
 
 
@@ -409,5 +314,4 @@ def run(site: dict):
         )
         logShouldRun(site, MODEL, id, True, model_key=MODEL_KEY)
 
-    management_nodes = condense_nodes(list(map(management, nodes)))
-    return management_nodes
+    return condense_nodes(list(map(management, nodes)))

hestia_earth/models/ipcc2019/ch4ToAirOrganicSoilCultivation.py

@@ -16,8 +16,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, get_ditch_frac,
-    get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
+    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
 )
 from . import MODEL
 
@@ -224,11 +224,11 @@ def _should_run(cycle: dict):
         eco_climate_zone=eco_climate_zone,
         organic_soil_category=organic_soil_category,
         ditch_category=ditch_category,
-        emission_factor=f"{np.mean(emission_factor):.3f}",
-        ditch_factor=f"{np.mean(ditch_factor):.3f}",
-        ditch_frac=f"{np.mean(ditch_frac):.3f}",
-        land_occupation=land_occupation,
-        histosol=histosol
+        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)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/co2ToAirOrganicSoilCultivation.py

@@ -14,7 +14,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_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory, valid_eco_climate_zone
+    assign_organic_soil_category, calc_emission, format_nd_array, format_number, get_emission_factor,
+    OrganicSoilCategory, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -182,9 +183,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"{np.mean(emission_factor):.3f}",
-        land_occupation=land_occupation,
-        histosol=histosol
+        emission_factor=format_nd_array(emission_factor),
+        land_occupation=format_number(land_occupation),
+        histosol=format_number(histosol)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/n2OToAirOrganicSoilCultivationDirect.py

@@ -8,8 +8,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_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory, remap_categories,
-    valid_eco_climate_zone
+    assign_organic_soil_category, calc_emission, format_number, get_emission_factor, OrganicSoilCategory,
+    remap_categories, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -127,9 +127,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"{emission_factor_mean} ± {emission_factor_sd}",
-        land_occupation=land_occupation,
-        histosol=histosol
+        emission_factor=f"{format_number(emission_factor_mean)} ± {format_number(emission_factor_sd)}",
+        land_occupation=format_number(land_occupation),
+        histosol=format_number(histosol)
     )
 
     should_run = all([
@@ -151,8 +151,8 @@ def _should_run(cycle: dict):
 
 
 def _run(emission_factor_mean: float, emission_factor_sd: float, histosol: float, land_occupation: float):
-    value = calc_emission(TERM_ID, emission_factor_mean, histosol, land_occupation)
-    sd = calc_emission(TERM_ID, emission_factor_sd, histosol, land_occupation)
+    value = round(calc_emission(TERM_ID, emission_factor_mean, histosol, land_occupation), 6)
+    sd = round(calc_emission(TERM_ID, emission_factor_sd, histosol, land_occupation), 6)
     return [_emission(value, sd)]
 
 

hestia_earth/models/ipcc2019/no3ToGroundwaterExcreta.py

@@ -98,7 +98,7 @@ def _should_run(cycle: dict):
 
     use_excreta_management = _should_run_with_excreta_management(cycle)
     excreta_EF_input = get_excreta_inputs_with_factor(
-        cycle, f"{list(LOOKUPS.keys())[0]}.csv", excreta_convertion_func=total_excreta, model=MODEL, term=TERM_ID
+        cycle, f"{list(LOOKUPS.keys())[0]}.csv", excreta_conversion_func=total_excreta, model=MODEL, term=TERM_ID
     ) if use_excreta_management else None
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,