hestia-earth-models 0.51.0__py3-none-any.whl → 0.51.1__py3-none-any.whl

hestia_earth/models/agribalyse2016/machineryInfrastructureDepreciatedAmountPerCycle.py

@@ -10,9 +10,9 @@ the machinery-to-diesel ratio was doubled in countries with a [Human Development
 of less than 0.8.
 """
 from hestia_earth.schema import InputStatsDefinition
-from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum, flatten
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.productivity import _get_productivity, PRODUCTIVITY
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
@@ -55,15 +55,24 @@ def _input(value: float):
 
 
 def _get_input_value_from_term(inputs: list, term_id: str):
-    val = find_term_match(inputs, term_id, None)
-    return val.get('value', [0])[0] if val is not None else 0
+    values = flatten([
+        input.get('value', []) for input in inputs if input.get('term', {}).get('@id') == term_id
+    ])
+    return list_sum(values, 0) if len(values) > 0 else None
 
 
 def get_value(country: dict, cycle: dict):
     liquid_fuels = get_liquid_fuel_terms()
     productivity_key = _get_productivity(country)
     machinery_usage = 11.5 if productivity_key == PRODUCTIVITY.HIGH else 23
-    fuel_use = sum([_get_input_value_from_term(cycle.get('inputs', []), term_id) for term_id in liquid_fuels])
+    values = [(term_id, _get_input_value_from_term(cycle.get('inputs', []), term_id)) for term_id in liquid_fuels]
+    value_logs = log_as_table([{'id': term_id, 'value': value} for term_id, value in values])
+    values = [value for term_id, value in values if value is not None]
+    fuel_use = list_sum(values, 0)
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                productivity_key=productivity_key.value,
+                fuel_use_details=value_logs,
+                fuel_use=fuel_use)
     return fuel_use/machinery_usage if fuel_use > 0 else None
 
 

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "co2ToAirFuelCombustionEmepEea2019"
+    "fuel": "co2ToAirFuelCombustionEmepEea2019",
+    "operation": "co2ToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                     "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "n2oToAirFuelCombustionEmepEea2019"
+    "fuel": "n2OToAirFuelCombustionEmepEea2019",
+    "operation": "n2OToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/nh3ToAirExcreta.py

@@ -6,6 +6,7 @@ from hestia_earth.utils.tools import safe_parse_float, list_sum
 from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun, log_as_table
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import total_excreta_tan
 from . import MODEL
@@ -62,6 +63,8 @@ def _run(excreta_EF_product: float):
 
 
 def _should_run(cycle: dict):
+    excreta_complete = _is_term_type_complete(cycle, {'termType': TermTermType.EXCRETA.value})
+
     practices = filter_list_term_type(cycle.get('practices', []), TermTermType.EXCRETAMANAGEMENT)
     practice_id = practices[0].get('term', {}).get('@id') if len(practices) > 0 else None
 
@@ -76,15 +79,16 @@ def _should_run(cycle: dict):
     ])
     excreta_EF_products = [v * f for id, v, f in excreta_values if f is not None]
     has_excreta_EF_products = len(excreta_EF_products) > 0
-    excreta_EF_product = list_sum(excreta_EF_products)
+    excreta_EF_product = list_sum(excreta_EF_products, 0)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    excreta_complete=excreta_complete,
                     practice_id=practice_id,
                     excreta=excreta_logs,
                     excreta_EF_product=excreta_EF_product,
                     has_excreta_EF_products=has_excreta_EF_products)
 
-    should_run = all([has_excreta_EF_products])
+    should_run = excreta_complete or all([has_excreta_EF_products])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, excreta_EF_product
 

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "noxToAirFuelCombustionEmepEea2019"
+    "fuel": "noxToAirFuelCombustionEmepEea2019",
+    "operation": "noxToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "so2ToAirFuelCombustionEmepEea2019"
+    "fuel": "so2ToAirFuelCombustionEmepEea2019",
+    "operation": "so2ToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/utils.py

@@ -1,14 +1,33 @@
 from hestia_earth.schema import NodeType, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import non_empty_list
+from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.utils.completeness import _is_term_type_complete
-from hestia_earth.models.utils.lookup import factor_value
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+
+def _get_fuel_input_value(term_id: str, lookup_col: str):
+    def get_value(input: dict):
+        input_term = input.get('term', {})
+        input_term_id = input_term.get('@id')
+        operation_term = input.get('operation', {})
+        input_value = list_sum(input.get('value', []))
+
+        operation_factor = extract_grouped_data(
+            get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id), input_term_id
+        ) if operation_term else None
+        input_factor = operation_factor or get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+
+        return input_value * safe_parse_float(input_factor)
+    return get_value
 
 
 def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
     inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
-    values = non_empty_list(map(factor_value(None, term_id, f"{TermTermType.FUEL.value}.csv", lookup_col), inputs))
+    values = list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
+
     return [0] if all([
         len(values) == 0,
         _is_term_type_complete(cycle, {'termType': 'electricityFuel'}),

hestia_earth/models/geospatialDatabase/aware.py

@@ -11,7 +11,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -27,15 +28,15 @@ EE_PARAMS = {
 
 
 def _download(site: dict):
-    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['field'], by_region=False)
+    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['field'])
 
 
 def _run(site: dict): return _download(site)
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
 
     logRequirements(site, model=MODEL, model_key=MODEL_KEY,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/geospatialDatabase/ecoregion.py

@@ -13,7 +13,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -29,7 +30,7 @@ EE_PARAMS = {
 
 
 def _download(site: dict):
-    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['fields'], by_region=False)
+    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['fields'])
 
 
 def _run(site: dict):
@@ -41,8 +42,8 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
 
     logRequirements(site, model=MODEL, key=MODEL_KEY,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/geospatialDatabase/region.py

@@ -8,15 +8,13 @@ from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import linked_node
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
-from .utils import download, has_geospatial_data, should_download
+from .utils import download, has_coordinates
 from . import MODEL
 
 REQUIREMENTS = {
     "Site": {
-        "or": [
-            {"latitude": "", "longitude": ""},
-            {"boundary": {}}
-        ]
+        "latitude": "",
+        "longitude": ""
     }
 }
 RETURNS = {
@@ -39,7 +37,7 @@ def _download_by_level(site: dict, level: int):
             'fields': field
         },
         field,
-        by_region=False
+        only_coordinates=True
     )
     try:
         return None if gadm_id is None else linked_node(download_hestia(f"GADM-{gadm_id}"))
@@ -60,14 +58,12 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_coordinates = has_coordinates(site)
 
     logRequirements(site, model=MODEL, key=MODEL_KEY,
-                    contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    contains_coordinates=contains_coordinates)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_coordinates])
     logShouldRun(site, MODEL, None, should_run, key=MODEL_KEY)
     return should_run
 

hestia_earth/models/geospatialDatabase/utils.py

@@ -15,13 +15,16 @@ MAX_AREA_SIZE = int(os.getenv('MAX_AREA_SIZE', '5000'))
 def _collection_name(id: str): return id if '/' in id else f"users/hestiaplatform/{id}"
 
 
-def _has_coordinates(site: dict): return site.get('latitude') is not None and site.get('longitude') is not None
+def has_coordinates(site: dict): return all([site.get('latitude') is not None, site.get('longitude') is not None])
+
+
+def has_boundary(site: dict): return site.get('boundary') is not None
 
 
 def _site_gadm_id(site: dict): return site.get('region', site.get('country', {})).get('@id')
 
 
-def has_geospatial_data(site: dict, by_region=True):
+def has_geospatial_data(site: dict):
     """
     Determines whether the Site has enough geospatial data to run calculations. We are checking for:
     1. If the coordinates (latitude and longitude) are present
@@ -33,49 +36,60 @@ def has_geospatial_data(site: dict, by_region=True):
     ----------
     site : dict
         The `Site` node.
-    by_region : bool
-        If we can run using the region ID (`region` or `country` fields). Defaults to true.
 
     Returns
     -------
     bool
         If we should run geospatial calculations on this model or not.
     """
-    has_region = _site_gadm_id(site) is not None
-    has_boundary = site.get('boundary') is not None
-    return _has_coordinates(site) or (by_region and has_region) or has_boundary
+    return has_coordinates(site) or _site_gadm_id(site) is not None or has_boundary(site)
 
 
-def _geospatial_data(site: dict, by_region=True):
+def _geospatial_data(site: dict, only_coordinates=False):
     return {
         'latitude': site.get('latitude'),
         'longitude': site.get('longitude'),
-        'boundary': site.get('boundary'),
-        **({'gadm_id': _site_gadm_id(site)} if by_region else {})
+        **({} if only_coordinates else {
+            'boundary': site.get('boundary'),
+            'gadm_id': _site_gadm_id(site)
+        })
     }
 
 
-def should_download(term: str, site: dict, by_region=True) -> bool:
+def _get_geospatial_area_size(site: dict):
     try:
         from hestia_earth.earth_engine import get_size_km2
     except ImportError:
         raise ImportError("Run `pip install hestia_earth.earth_engine` to use this functionality")
 
     try:
-        current_size = get_size_km2(_geospatial_data(site, by_region))
-        # coordinates will not return a size
-        if current_size is not None:
-            logRequirements(site, model=MODEL, term=term,
-                            current_size=int(current_size),
-                            max_area_size=MAX_AREA_SIZE)
-            return current_size <= MAX_AREA_SIZE
-        return True
-    except Exception as e:
-        # if the type is unknown, a geospatial param is missing and will be detected by `has_geospatial_data`
-        return 'Unkown type' in str(e)
+        return get_size_km2(_geospatial_data(site))
+    except Exception:
+        return None
+
+
+def _get_area_size(site: dict):
+    return (
+        # fallback if `boundary` provided but no `boundaryArea` was computed
+        site.get('boundaryArea') or _get_geospatial_area_size(site)
+    ) if has_boundary(site) else download_hestia(_site_gadm_id(site)).get('area')
+
+
+def _is_below_max_size(term: str, site: dict) -> bool:
+    current_size = _get_area_size(site)
+    if current_size is not None:
+        logRequirements(site, model=MODEL, term=term,
+                        current_size=int(current_size),
+                        max_area_size=MAX_AREA_SIZE)
+        return current_size <= MAX_AREA_SIZE
+    return True
+
+
+def should_download(term: str, site: dict) -> bool:
+    return has_coordinates(site) or _is_below_max_size(term, site)
 
 
-def download(term: str, site: dict, data: dict, field: str, by_region=True) -> dict:
+def download(term: str, site: dict, data: dict, field: str, only_coordinates=False) -> dict:
     """
     Downloads data from Hestia Earth Engine API.
 
@@ -93,7 +107,7 @@ def download(term: str, site: dict, data: dict, field: str, by_region=True) -> d
         collection = data.get('collection')
         res = run({
             **data,
-            **_geospatial_data(site, by_region=by_region),
+            **_geospatial_data(site, only_coordinates=only_coordinates),
             'max_area': MAX_AREA_SIZE,
             'collection': _collection_name(collection)
         })
@@ -124,7 +138,7 @@ def _coordinates_query(site: dict):
                 }
             }
         }
-    } if _has_coordinates(site) else None
+    } if has_coordinates(site) else None
 
 
 def _region_query(site: dict):

hestia_earth/models/geospatialDatabase/waterDepth.py

@@ -9,7 +9,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -38,7 +39,7 @@ def _measurement(value: float):
 
 
 def _download(site: dict):
-    return download(TERM_ID, site, EE_PARAMS, EE_PARAMS['reducer'], by_region=False)
+    return download(TERM_ID, site, EE_PARAMS, EE_PARAMS['reducer'])
 
 
 def _run(site: dict):
@@ -47,8 +48,8 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(TERM_ID, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(TERM_ID, site)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/impact_assessment/__init__.py

@@ -2,12 +2,12 @@ from os.path import dirname, abspath
 import sys
 from importlib import import_module
 
+from hestia_earth.models.utils.blank_node import run_if_required
+
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 MODEL = 'impact_assessment'
 PKG = '.'.join(['hestia_earth', 'models', MODEL])
 
 
-def run(model: str, data):
-    run = getattr(import_module(f".{model}", package=PKG), 'run')
-    return run(data)
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/ipcc2019/croppingDuration.py

@@ -76,7 +76,7 @@ def _should_run(cycle: dict):
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     country=country,
                     cycleDuration=cycleDuration,
-                    flooded_rice=flooded_rice)
+                    has_flooded_rice=flooded_rice)
 
     should_run = all([country, cycleDuration, flooded_rice])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)

hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserIndirect.py

@@ -0,0 +1,106 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.cycle import get_inorganic_fertiliser_N_total, get_ecoClimateZone
+from hestia_earth.models.utils.emission import _new_emission
+from .utils import get_nh3_no3_nox_to_n, COEFF_NO3_N2O, COEFF_N_NH3NOX_inorganic, get_FracNH3NOx_N2O, get_FracLEACH_H
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "completeness.water": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "inorganicFertiliser",
+                "term.units": "kg N"
+            }
+        ],
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "no3ToGroundwaterInorganicFertiliser"},
+            {"@type": "Emission", "value": "", "term.@id": "nh3ToAirInorganicFertiliser"},
+            {"@type": "Emission", "value": "", "term.@id": "noxToAirInorganicFertiliser"}
+        ],
+        "site": {
+            "@type": "Site",
+            "measurements": [{"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}]
+        },
+        "optional": {
+            "practices": [{"@type": "Practice", "value": "", "term.termType": "waterRegime"}]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+
+TERM_ID = 'n2OToAirInorganicFertiliserIndirect'
+NO3_TERM_ID = 'no3ToGroundwaterInorganicFertiliser'
+NH3_TERM_ID = 'nh3ToAirInorganicFertiliser'
+NOX_TERM_ID = 'noxToAirInorganicFertiliser'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float, sd: float, min: float, max: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['sd'] = [sd]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['methodTier'] = TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    return emission
+
+
+def _run(cycle: dict):
+    N_total = get_inorganic_fertiliser_N_total(cycle)
+    nh3_n, no3_n, nox_n = get_nh3_no3_nox_to_n(cycle, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID)
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                no3_n=no3_n,
+                nh3_n=nh3_n,
+                nox_n=nox_n)
+    value, min_val, max_val, std = [
+        get_FracNH3NOx_N2O(cycle, TERM_ID)[x] * (
+            N_total * COEFF_N_NH3NOX_inorganic[x] if nox_n == 0 or nh3_n == 0 else nh3_n + nox_n
+        ) +
+        COEFF_NO3_N2O[x] * (
+            N_total * get_FracLEACH_H(cycle, TERM_ID)[x] if no3_n == 0 else no3_n
+        ) for x in range(4)
+    ]
+    return [_emission(
+        value * get_atomic_conversion(Units.KG_N2O, Units.TO_N),
+        std * get_atomic_conversion(Units.KG_N2O, Units.TO_N),
+        min_val * get_atomic_conversion(Units.KG_N2O, Units.TO_N),
+        max_val * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    )]
+
+
+def _should_run(cycle: dict):
+    N_inorganic_fertiliser = get_inorganic_fertiliser_N_total(cycle)
+    ecoClimateZone = get_ecoClimateZone(cycle)
+    fertiliser_complete = _is_term_type_complete(cycle, {'termType': 'fertiliser'})
+    water_complete = _is_term_type_complete(cycle, {'termType': TermTermType.WATER.value})
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    N_inorganic_fertiliser=N_inorganic_fertiliser,
+                    ecoClimateZone=ecoClimateZone,
+                    fertiliser_complete=fertiliser_complete,
+                    water_complete=water_complete)
+
+    should_run = all([N_inorganic_fertiliser >= 0, ecoClimateZone, fertiliser_complete, water_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []