hestia-earth-models 0.51.0__tar.gz → 0.51.1__tar.gz

{hestia-earth-models-0.51.0/hestia_earth_models.egg-info → hestia-earth-models-0.51.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.51.0
+Version: 0.51.1
 Summary: Hestia's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: Hestia Team

{hestia-earth-models-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.1/hestia_earth/models/emepEea2019/utils.py

@@ -0,0 +1,35 @@
+from hestia_earth.schema import NodeType, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+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.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 = 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'}),
+        cycle.get('@type', cycle.get('type')) == NodeType.CYCLE.value  # ignore adding 0 value for Transformation
+    ]) else values

{hestia-earth-models-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.1/hestia_earth/models/impact_assessment/__init__.py

@@ -0,0 +1,13 @@
+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): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

{hestia-earth-models-0.51.0 → hestia-earth-models-0.51.1}/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-0.51.1/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 []