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

hestia_earth/models/schererPfister2015/utils.py

@@ -68,8 +68,8 @@ def get_water(cycle: dict, precipitation: float):
     return list_sum([irrigation/10, precipitation or 0])
 
 
-def calculate_R(heavy_winter_precipitation: float, water: float):
-    winter_precipitation = 1 if heavy_winter_precipitation > 0 else 0.1
+def calculate_R(heavy_winter_precipitation: bool, water: float):
+    winter_precipitation = 1 if heavy_winter_precipitation else 0.1
     water_coeff = (587.8 - 1.219 * water) + (0.004105 * water ** 2) if water > 850 else (0.0483 * water ** 1.61)
     return water_coeff * winter_precipitation
 

hestia_earth/models/site/brackishWater.py

@@ -23,7 +23,7 @@ TERM_ID = 'brackishWater'
 
 def _measurement():
     data = _new_measurement(TERM_ID)
-    data['value'] = [100]
+    data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data
 

hestia_earth/models/site/flowingWater.py

@@ -31,7 +31,7 @@ SITE_TYPE_TO_TERM_ID = {
 
 def _measurement(site: dict, term_id: str):
     data = _new_measurement(term_id)
-    data['value'] = [1]
+    data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data | get_source(site, BIBLIO_TITLE)
 

hestia_earth/models/site/freshWater.py

@@ -23,7 +23,7 @@ TERM_ID = 'freshWater'
 
 def _measurement():
     data = _new_measurement(TERM_ID)
-    data['value'] = [100]
+    data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data
 

hestia_earth/models/site/management.py

@@ -1,17 +1,31 @@
 """
-Management node with data gap-filled data from cycles.
+Management node
+
+This model provides data gap-filled data from cycles in the form of a list of management nodes
+(https://www.hestia.earth/schema/Management).
+
+It includes products of type crop, forage, landCover (gap-filled with a value of 100) and practices of type waterRegime,
+tillage, cropResidueManagement and landUseManagement.
+
+All values are copied from the source node, except for crop and forage terms in which case the dates are copied from the
+cycle.
+
+When nodes are chronologically consecutive with "% area" or "boolean" units and the same term and value, they are
+condensed into a single node to aid readability.
 """
-from typing import List, Any, Callable
 from functools import reduce
+
 from hestia_earth.schema import SchemaType, TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import filter_list_term_type, linked_node
-from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.tools import safe_parse_float
+from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nodes_id
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.blank_node import get_node_value
+from hestia_earth.models.utils.blank_node import condense_nodes
 from hestia_earth.models.utils.site import related_cycles
+from hestia_earth.models.utils.site import get_land_cover_term_id as get_landCover_term_id_from_site_type
 from . import MODEL
 
 REQUIREMENTS = {
@@ -24,7 +38,8 @@ REQUIREMENTS = {
                 "products": [
                     {
                         "@type": "Product",
-                        "term.termType": ["crop", "forage", "landCover"]
+                        "term.termType": ["crop", "forage", "landCover"],
+                        "units": ["% area", "boolean"]
                     }
                 ],
                 "practices": [
@@ -35,6 +50,7 @@ REQUIREMENTS = {
                             "cropResidueManagement",
                             "landUseManagement"
                         ],
+                        "units": ["% area", "boolean"],
                         "value": ""
                     }
                 ],
@@ -115,18 +131,20 @@ def _extract_node_value(node: dict) -> dict:
     return node | {'value': get_node_value(node)}
 
 
-def _include(value: dict, keys: list): return {k: v for k, v in value.items() if k in keys}
+def _include(value: dict, keys: list) -> dict: return {k: v for k, v in value.items() if k in keys}
 
 
-def _default_dates(cycle: dict, values: list):
+def _default_dates(cycle: dict, values: list) -> list:
+    """Only uses the dates from the cycle if they are missing from the item."""
     return [(_include(cycle, ["startDate", "endDate"]) | v) for v in values]
 
 
 def _overwrite_dates(cycle: dict, values: list) -> list:
+    """Always uses the dates from the cycle."""
     return [v | _include(cycle, ["startDate", "endDate"]) for v in values]
 
 
-def _copy_item_if_exists(source: dict, keys: List[str] = None, dest: dict = None) -> dict:
+def _copy_item_if_exists(source: dict, keys: list[str] = None, dest: dict = None) -> dict:
     keys = keys or []
     dest = dest or {}
     return reduce(lambda p, c: p | ({c: source[c]} if c in source else {}), keys, dest)
@@ -134,25 +152,24 @@ def _copy_item_if_exists(source: dict, keys: List[str] = None, dest: dict = None
 
 def _get_landCover_term_id(product: dict) -> str:
     value = get_lookup_value(product.get('term', {}), LAND_COVER_KEY, model=MODEL, model_key=LAND_COVER_KEY)
-    # TODO: what should happen when there are multiple values?
     return value.split(';')[0] if value else None
 
 
-def _get_items_with_relevant_term_type(
-        cycles: List[dict], item_name: str, relevant_values: list, date_fill: Callable = _default_dates
-):
-    """Get items from the list of cycles with any of the relevant values. Also adds dates if missing."""
-    return flatten(
-        [
-            date_fill(
-                cycle=cycle,
-                values=filter_list_term_type(cycle.get(item_name, []), relevant_values)
-            ) for cycle in cycles
-        ]
-    )
+def _get_relevant_items(
+    cycles: list[dict], item_name: str, relevant_terms: list, date_fill: callable = _default_dates
+) -> list[tuple]:
+    """
+    Get items (optionally in tuples with site_type) from the list of cycles with any of the relevant terms.
+    Also adds dates if missing.
+    """
+    return [
+        (item, cycle.get("site", {}).get("siteType", ""))
+        for cycle in cycles
+        for item in date_fill(cycle=cycle, values=filter_list_term_type(cycle.get(item_name, []), relevant_terms))
+    ]
 
 
-def _get_lookup_with_debug(term: dict, column: str) -> Any:
+def _get_lookup_with_debug(term: dict, column: str) -> any:
     get_lookup_value(term, column, model_key=MODEL_KEY, land_cover_key=LAND_COVER_KEY)
 
 
@@ -169,7 +186,7 @@ def _data_from_input(cycle: dict, term_id: str) -> dict:
     }
 
 
-def _process_rule(cycle, term, term_type) -> List:
+def _process_rule(cycle, term, term_type) -> list:
     relevant_terms = []
     for column, condition, new_term in INPUT_RULES[term_type]:
         lookup_result = _get_lookup_with_debug(term, LOOKUPS[column])
@@ -180,7 +197,7 @@ def _process_rule(cycle, term, term_type) -> List:
     return relevant_terms
 
 
-def _get_relevant_inputs(cycles: List[dict]) -> List:
+def _get_relevant_inputs(cycles: list[dict]) -> list:
     relevant_inputs = []
     for cycle in [c for c in cycles if "inputs" in c]:
         for i in cycle["inputs"]:
@@ -196,27 +213,23 @@ def _get_relevant_inputs(cycles: List[dict]) -> List:
     return relevant_inputs
 
 
-def _should_run(site: dict):
-    # Only get related cycles once.
-    cycles = related_cycles(site)
-
+def _should_run_all_products(cycles):
     products_land_cover = [
         _extract_node_value(
             _include(
                 value=product,
                 keys=["term", "value", "startDate", "endDate", "properties"]
             )
-        ) for product in _get_items_with_relevant_term_type(
+        ) for product, _ in _get_relevant_items(
             cycles=cycles,
             item_name="products",
-            relevant_values=[TermTermType.LANDCOVER]
+            relevant_terms=[TermTermType.LANDCOVER]
         )
     ]
-
-    products_crop_forage = _get_items_with_relevant_term_type(
+    products_crop_forage = _get_relevant_items(
         cycles=cycles,
         item_name="products",
-        relevant_values=[TermTermType.CROP, TermTermType.FORAGE],
+        relevant_terms=[TermTermType.CROP, TermTermType.FORAGE],
         date_fill=_overwrite_dates
     )
     products_crop_forage = [
@@ -228,19 +241,45 @@ def _should_run(site: dict):
                 "value": 100
             }
         )
-        for product in list(filter(_get_landCover_term_id, products_crop_forage))
+        for product in list(filter(_get_landCover_term_id, [i[0] for i in products_crop_forage]))
+    ]
+    products_animal_with_site_type = _get_relevant_items(
+        cycles=cycles,
+        item_name="products",
+        relevant_terms=[TermTermType.LIVEANIMAL, TermTermType.ANIMALPRODUCT]
+    )
+    products_animal = [
+        _copy_item_if_exists(
+            source=product,
+            keys=["startDate", "endDate", "properties"],
+            dest={
+                "term": linked_node(download_hestia(get_landCover_term_id_from_site_type(site_type))),
+                "value": 100
+            }
+        )
+        for product, site_type in products_animal_with_site_type if product
     ]
 
+    return products_animal, products_crop_forage, products_land_cover
+
+
+def _should_run(site: dict):
+    cycles = related_cycles(site)
+
+    products_animal, products_crop_forage, products_land_cover = _should_run_all_products(cycles)
+    all_products = products_land_cover + products_crop_forage + products_animal
+    all_products = condense_nodes(all_products)
+
     practices = [
         _extract_node_value(
             _include(
                 value=practice,
                 keys=["term", "value", "startDate", "endDate"]
             )
-        ) for practice in _get_items_with_relevant_term_type(
+        ) for practice, _ in _get_relevant_items(
             cycles=cycles,
             item_name="practices",
-            relevant_values=[
+            relevant_terms=[
                 TermTermType.WATERREGIME,
                 TermTermType.TILLAGE,
                 TermTermType.CROPRESIDUEMANAGEMENT,
@@ -248,6 +287,7 @@ def _should_run(site: dict):
             ]
         )
     ]
+    practices = condense_nodes(practices)
 
     relevant_inputs = _get_relevant_inputs(cycles)
     logRequirements(
@@ -257,12 +297,13 @@ def _should_run(site: dict):
         model_key=MODEL_KEY,
         products_crop_forage_ids=log_blank_nodes_id(products_crop_forage),
         products_land_cover_ids=log_blank_nodes_id(products_land_cover),
+        products_animal=log_blank_nodes_id(products_animal),
         practice_ids=log_blank_nodes_id(practices),
         inputs=log_blank_nodes_id(relevant_inputs)
     )
-    should_run = any(products_crop_forage + products_land_cover + practices + relevant_inputs)
+    should_run = any(all_products + practices + relevant_inputs)
     logShouldRun(site, MODEL, None, should_run=should_run, model_key=MODEL_KEY)
-    return should_run, products_crop_forage + products_land_cover, practices, relevant_inputs
+    return should_run, all_products, practices, relevant_inputs
 
 
 def run(site: dict):

hestia_earth/models/site/pre_checks/cache_sources.py

@@ -1,7 +1,7 @@
 """
 Pre Checks Cache Sources
 
-This model caches the sources of all models.
+This model caches the sources of all Site models.
 """
 from hestia_earth.models.log import debugValues
 from hestia_earth.models.utils import CACHE_KEY, cached_value
@@ -15,24 +15,20 @@ RETURNS = {
 }
 
 
-def _should_run(site: dict):
+def _run(site: dict):
     sources = find_sources()
-    has_cache = cached_value(site, CACHE_SOURCES_KEY) is not None
+    debugValues(site, sources=';'.join([str(title) for title in sources.keys()]))
+    return sources
 
-    debugValues(site,
-                sources=';'.join([str(title) for title in sources.keys()]),
-                has_cache=has_cache)
 
-    should_run = all([
-        not has_cache,
-        len(sources.keys()) > 0
-    ])
-    return should_run, sources
+def _should_run(site: dict):
+    has_cache = cached_value(site, CACHE_SOURCES_KEY)
+    return not bool(has_cache)
 
 
 def run(site: dict):
-    should_run, sources = _should_run(site)
+    should_run = _should_run(site)
     return {
         **site,
-        CACHE_KEY: cached_value(site) | {CACHE_SOURCES_KEY: sources}
+        CACHE_KEY: cached_value(site) | {CACHE_SOURCES_KEY: _run(site)}
     } if should_run else site

hestia_earth/models/site/salineWater.py

@@ -23,7 +23,7 @@ TERM_ID = 'salineWater'
 
 def _measurement():
     data = _new_measurement(TERM_ID)
-    data['value'] = [100]
+    data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data
 

hestia_earth/models/stehfestBouwman2006/n2OToAirCropResidueDecompositionDirect.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_crop_residue_decomposition_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .n2OToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -59,5 +61,13 @@ def _run(cycle: dict, content_list_of_items: list, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, content_list_of_items, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/n2OToAirExcretaDirect.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_excreta_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .n2OToAirSoilFlux import _get_value, _should_run
 from . import MODEL
@@ -66,5 +68,13 @@ def _run(cycle: dict, content_list_of_items: list, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_excreta_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, content_list_of_items, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/n2OToAirInorganicFertiliserDirect.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.cycle import get_inorganic_fertiliser_N_total
 from .n2OToAirSoilFlux import _get_value, _should_run
 from . import MODEL
@@ -69,5 +71,13 @@ def _run(cycle: dict, content_list_of_items: list, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, content_list_of_items, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/n2OToAirOrganicFertiliserDirect.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.cycle import get_organic_fertiliser_N_total
 from .n2OToAirSoilFlux import _get_value, _should_run
 from . import MODEL
@@ -69,5 +71,13 @@ def _run(cycle: dict, content_list_of_items: list, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, N_total, content_list_of_items = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, content_list_of_items, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/noxToAirCropResidueDecomposition.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_crop_residue_decomposition_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -54,5 +56,13 @@ def _run(cycle: dict, ecoClimateZone: str, nitrogenContent: float, N_total: floa
 
 
 def run(cycle: dict):
-    should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, ecoClimateZone, nitrogenContent, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/noxToAirExcreta.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_excreta_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -61,5 +63,13 @@ def _run(cycle: dict, ecoClimateZone: str, nitrogenContent: float, N_total: floa
 
 
 def run(cycle: dict):
-    should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_excreta_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, ecoClimateZone, nitrogenContent, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/noxToAirInorganicFertiliser.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_inorganic_fertiliser_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -64,5 +66,13 @@ def _run(cycle: dict, ecoClimateZone: str, nitrogenContent: float, N_total: floa
 
 
 def run(cycle: dict):
-    should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, ecoClimateZone, nitrogenContent, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006/noxToAirOrganicFertiliser.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_organic_fertiliser_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -64,5 +66,13 @@ def _run(cycle: dict, ecoClimateZone: str, nitrogenContent: float, N_total: floa
 
 
 def run(cycle: dict):
-    should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, ecoClimateZone, nitrogenContent, N_total = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, ecoClimateZone, nitrogenContent, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirCropResidueDecomposition.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_crop_residue_decomposition_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -51,5 +53,13 @@ def _run(cycle: dict, country_id: str, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, country_id, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, country_id, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirExcreta.py

@@ -1,6 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_excreta_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -58,5 +60,13 @@ def _run(cycle: dict, country_id: str, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, country_id, N_total = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_excreta_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, country_id, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirInorganicFertiliser.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_inorganic_fertiliser_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -61,5 +63,13 @@ def _run(cycle: dict, country_id: str, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, country_id, N_total) if should_run else []

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirOrganicFertiliser.py

@@ -1,6 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import get_organic_fertiliser_N_total
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from .noxToAirSoilFlux import _should_run, _get_value
 from . import MODEL
@@ -61,5 +63,13 @@ def _run(cycle: dict, country_id: str, N_total: float):
 
 
 def run(cycle: dict):
-    should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    default_should_run, country_id, N_total, *args = _should_run(cycle, TERM_ID, TIER)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=term_type_complete)
+
+    should_run = all([default_should_run, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
     return _run(cycle, country_id, N_total) if should_run else []