hestia-earth-models 0.59.1__py3-none-any.whl → 0.59.3__py3-none-any.whl

hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserIndirect.py

@@ -1,107 +1,100 @@
-from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 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 hestia_earth.models.utils.emission import _new_emission, get_nh3_no3_nox_to_n
+from hestia_earth.models.utils.cycle import get_ecoClimateZone
+from .utils import ecoClimate_factors, EF4_FACTORS, EF5_FACTORS
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "completeness.water": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
-            }
-        }],
         "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"}]
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            }
         }
     }
 }
 RETURNS = {
     "Emission": [{
         "value": "",
-        "sd": "",
-        "min": "",
-        "max": "",
-        "methodTier": "tier 1",
-        "statsDefinition": "modelled"
+        "methodTier": "tier 1"
     }]
 }
-
 TERM_ID = 'n2OToAirInorganicFertiliserIndirect'
+TIER = EmissionMethodTier.TIER_1.value
 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):
+def _emission(value: float, min: float, max: float, aggregated: bool = False):
     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
+    emission['methodModelDescription'] = 'Aggregated version' if aggregated else 'Disaggregated version'
     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)
+def _run(cycle: dict, no3: float, nh3: float, nox: float):
+    ecoClimateZone = get_ecoClimateZone(cycle)
+
+    ef4, aggregated = ecoClimate_factors(EF4_FACTORS, ecoClimateZone=ecoClimateZone)
+    ef5 = EF5_FACTORS.get('default')
+
     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)
-    )]
+                ecoClimateZone=ecoClimateZone,
+                ef4_factors_used=log_as_table(ef4),
+                ef5_factors_used=log_as_table(ef5),
+                aggregated=aggregated)
+
+    value = sum([
+        no3 * ef5['value'],
+        nh3 * ef4['value'],
+        nox * ef4['value']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    min = sum([
+        no3 * ef5['min'],
+        nh3 * ef4['min'],
+        nox * ef4['min']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    max = sum([
+        no3 * ef5['max'],
+        nh3 * ef4['max'],
+        nox * ef4['max']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    return [_emission(value, min, max, aggregated=aggregated)]
 
 
 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, 'fertiliser')
-    water_complete = _is_term_type_complete(cycle, TermTermType.WATER)
+    nh3_n, no3_n, nox_n = get_nh3_no3_nox_to_n(cycle, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    N_inorganic_fertiliser=N_inorganic_fertiliser,
-                    ecoClimateZone=ecoClimateZone,
-                    term_type_fertiliser_complete=fertiliser_complete,
-                    term_type_water_complete=water_complete)
+                    no3_n=no3_n,
+                    nh3_n=nh3_n,
+                    nox_n=nox_n,
+                    term_type_cropResidue_complete=term_type_complete)
 
-    should_run = all([N_inorganic_fertiliser is not None, ecoClimateZone, fertiliser_complete, water_complete])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run
+    should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, no3_n, nh3_n, nox_n
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []
+def run(cycle: dict):
+    should_run, no3, nh3, nox = _should_run(cycle)
+    return _run(cycle, no3, nh3, nox) if should_run else []

hestia_earth/models/ipcc2019/n2OToAirOrganicFertiliserIndirect.py

@@ -1,108 +1,100 @@
-from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 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_organic_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_organic_animal, get_FracNH3NOx_N2O, \
-    get_FracLEACH_H
+from hestia_earth.models.utils.emission import _new_emission, get_nh3_no3_nox_to_n
+from hestia_earth.models.utils.cycle import get_ecoClimateZone
+from .utils import ecoClimate_factors, EF4_FACTORS, EF5_FACTORS
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "completeness.water": "True",
-        "inputs": [
-            {
-                "@type": "Input",
-                "value": "",
-                "term.termType": "organicFertiliser",
-                "term.units": "kg N"
-            }
-        ],
         "emissions": [
-            {"@type": "Emission", "value": "", "term.@id": "no3ToGroundwaterInorganicFertiliser"},
-            {"@type": "Emission", "value": "", "term.@id": "nh3ToAirInorganicFertiliser"},
-            {"@type": "Emission", "value": "", "term.@id": "noxToAirInorganicFertiliser"}
+            {"@type": "Emission", "value": "", "term.@id": "no3ToGroundwaterOrganicFertiliser"},
+            {"@type": "Emission", "value": "", "term.@id": "nh3ToAirOrganicFertiliser"},
+            {"@type": "Emission", "value": "", "term.@id": "noxToAirOrganicFertiliser"}
         ],
-        "site": {
-            "@type": "Site",
-            "measurements": [{"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}]
-        },
         "optional": {
-            "practices": [{"@type": "Practice", "value": "", "term.termType": "waterRegime"}]
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            }
         }
     }
 }
 RETURNS = {
     "Emission": [{
         "value": "",
-        "sd": "",
-        "min": "",
-        "max": "",
-        "methodTier": "tier 1",
-        "statsDefinition": "modelled"
+        "methodTier": "tier 1"
     }]
 }
-
 TERM_ID = 'n2OToAirOrganicFertiliserIndirect'
-NO3_TERM_ID = 'no3ToGroundwaterInorganicFertiliser'
-NH3_TERM_ID = 'nh3ToAirInorganicFertiliser'
-NOX_TERM_ID = 'noxToAirInorganicFertiliser'
 TIER = EmissionMethodTier.TIER_1.value
+NO3_TERM_ID = 'no3ToGroundwaterOrganicFertiliser'
+NH3_TERM_ID = 'nh3ToAirOrganicFertiliser'
+NOX_TERM_ID = 'noxToAirOrganicFertiliser'
 
 
-def _emission(value: float, sd: float, min: float, max: float):
+def _emission(value: float, min: float, max: float, aggregated: bool = False):
     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
+    emission['methodModelDescription'] = 'Aggregated version' if aggregated else 'Disaggregated version'
     return emission
 
 
-def _run(cycle: dict):
-    N_total = get_organic_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)
+def _run(cycle: dict, no3: float, nh3: float, nox: float):
+    ecoClimateZone = get_ecoClimateZone(cycle)
+
+    ef4, aggregated = ecoClimate_factors(EF4_FACTORS, ecoClimateZone=ecoClimateZone)
+    ef5 = EF5_FACTORS.get('default')
+
     debugValues(cycle, model=MODEL, term=TERM_ID,
-                no3_n=no3_n,
-                nh3_n=nh3_n,
-                nox_n=nox_n)
+                ecoClimateZone=ecoClimateZone,
+                ef4_factors_used=log_as_table(ef4),
+                ef5_factors_used=log_as_table(ef5),
+                aggregated=aggregated)
 
-    value, min_val, max_val, std = [
-        get_FracNH3NOx_N2O(cycle, TERM_ID)[x] * (
-            N_total * COEFF_N_NH3NOX_organic_animal[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)
-    )]
+    value = sum([
+        no3 * ef5['value'],
+        nh3 * ef4['value'],
+        nox * ef4['value']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    min = sum([
+        no3 * ef5['min'],
+        nh3 * ef4['min'],
+        nox * ef4['min']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    max = sum([
+        no3 * ef5['max'],
+        nh3 * ef4['max'],
+        nox * ef4['max']
+    ]) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    return [_emission(value, min, max, aggregated=aggregated)]
 
 
 def _should_run(cycle: dict):
-    N_organic_fertiliser = get_organic_fertiliser_N_total(cycle)
-    ecoClimateZone = get_ecoClimateZone(cycle)
-    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
-    water_complete = _is_term_type_complete(cycle, TermTermType.WATER)
+    nh3_n, no3_n, nox_n = get_nh3_no3_nox_to_n(cycle, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID)
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    N_organic_fertiliser=N_organic_fertiliser,
-                    ecoClimateZone=ecoClimateZone,
-                    term_type_fertiliser_complete=fertiliser_complete,
-                    term_type_water_complete=water_complete)
+                    no3_n=no3_n,
+                    nh3_n=nh3_n,
+                    nox_n=nox_n,
+                    term_type_cropResidue_complete=term_type_complete)
 
-    should_run = all([N_organic_fertiliser is not None, ecoClimateZone, fertiliser_complete, water_complete])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run
+    should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, no3_n, nh3_n, nox_n
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []
+def run(cycle: dict):
+    should_run, no3, nh3, nox = _should_run(cycle)
+    return _run(cycle, no3, nh3, nox) if should_run else []

hestia_earth/models/ipcc2019/nh3ToAirInorganicFertiliser.py

@@ -0,0 +1,112 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.model import filter_list_term_type, find_term_match
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils.blank_node import get_N_total
+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.cycle import get_inorganic_fertiliser_N_total
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            }
+        ]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled",
+        "methodModelDescription": ["Aggregated version", "Disaggragated version"]
+    }]
+}
+LOOKUPS = {
+    "inorganicFertiliser": ["IPCC_2019_FRACGASF_NH3-N", "IPCC_2019_FRACGASF_NH3-N-min", "IPCC_2019_FRACGASF_NH3-N-max"]
+}
+TERM_ID = 'nh3ToAirInorganicFertiliser'
+TIER = EmissionMethodTier.TIER_1.value
+TERM_TYPE = TermTermType.INORGANICFERTILISER
+UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
+
+
+def _emission(value: float, min: float, max: float, aggregated: bool = False):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['methodTier'] = TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodModelDescription'] = 'Aggregated version' if aggregated else 'Disaggregated version'
+    return emission
+
+
+def _input_values(input: dict):
+    N_total = list_sum(get_N_total([input]))
+    lookups = LOOKUPS[TERM_TYPE.value]
+    return {
+        'id': input.get('term', {}).get('@id'),
+        'N': N_total,
+        'value': get_lookup_value(input.get('term', {}), lookups[0]),
+        'min': get_lookup_value(input.get('term', {}), lookups[1]),
+        'max': get_lookup_value(input.get('term', {}), lookups[2])
+    }
+
+
+def _filter_input_values(values: list, key: str): return [value for value in values if value.get(key)]
+
+
+def _run(cycle: dict):
+    inputs = filter_list_term_type(cycle.get('inputs', []), TERM_TYPE)
+    input_values = list(map(_input_values, inputs))
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                input_values=log_as_table(input_values))
+
+    value = list_sum([
+        v.get('N', 0) * v.get('value', 0) for v in _filter_input_values(input_values, 'value')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    min = list_sum([
+        v.get('N', 0) * v.get('min', 0) for v in _filter_input_values(input_values, 'min')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    max = list_sum([
+        v.get('N', 0) * v.get('max', 0) for v in _filter_input_values(input_values, 'max')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    aggregated = list_sum(find_term_match(inputs, UNSPECIFIED_TERM_ID).get('value', [0])) > 0
+
+    return [_emission(value, min, max, aggregated=aggregated)]
+
+
+def _should_run(cycle: dict):
+    N_inorganic_fertiliser = get_inorganic_fertiliser_N_total(cycle)
+    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    N_inorganic_fertiliser=N_inorganic_fertiliser,
+                    term_type_fertiliser_complete=fertiliser_complete)
+
+    should_run = all([N_inorganic_fertiliser is not None, fertiliser_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

hestia_earth/models/ipcc2019/nh3ToAirOrganicFertiliser.py

@@ -0,0 +1,107 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils.blank_node import get_N_total
+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.cycle import get_organic_fertiliser_N_total
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            }
+        ]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled",
+        "methodModelDescription": "Aggregated version"
+    }]
+}
+LOOKUPS = {
+    "organicFertiliser": ["IPCC_2019_FRACGASM_NH3-N", "IPCC_2019_FRACGASM_NH3-N-min", "IPCC_2019_FRACGASM_NH3-N-max"]
+}
+TERM_ID = 'nh3ToAirOrganicFertiliser'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float, min: float, max: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['methodTier'] = TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodModelDescription'] = 'Aggregated version'
+    return emission
+
+
+def _input_values(input: dict):
+    N_total = list_sum(get_N_total([input]))
+    return {
+        'id': input.get('term', {}).get('@id'),
+        'N': N_total,
+        'value': get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser'][0]),
+        'min': get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser'][1]),
+        'max': get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser'][2])
+    }
+
+
+def _filter_input_values(values: list, key: str): return [value for value in values if value.get(key)]
+
+
+def _run(cycle: dict):
+    inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER)
+    input_values = list(map(_input_values, inputs))
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                input_values=log_as_table(input_values))
+
+    value = list_sum([
+        v.get('N', 0) * v.get('value', 0) for v in _filter_input_values(input_values, 'value')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    min = list_sum([
+        v.get('N', 0) * v.get('min', 0) for v in _filter_input_values(input_values, 'min')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    max = list_sum([
+        v.get('N', 0) * v.get('max', 0) for v in _filter_input_values(input_values, 'max')
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    return [_emission(value, min, max)]
+
+
+def _should_run(cycle: dict):
+    N_organic_fertiliser = get_organic_fertiliser_N_total(cycle)
+    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    N_organic_fertiliser=N_organic_fertiliser,
+                    term_type_fertiliser_complete=fertiliser_complete)
+
+    should_run = all([N_organic_fertiliser is not None, fertiliser_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

hestia_earth/models/ipcc2019/noxToAirInorganicFertiliser.py

@@ -0,0 +1,112 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.model import filter_list_term_type, find_term_match
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils.blank_node import get_N_total
+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.cycle import get_inorganic_fertiliser_N_total
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            }
+        ]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled",
+        "methodModelDescription": ["Aggregated version", "Disaggragated version"]
+    }]
+}
+LOOKUPS = {
+    "inorganicFertiliser": ["IPCC_2019_FRACGASF_NOx-N", "IPCC_2019_FRACGASF_NOx-N-min", "IPCC_2019_FRACGASF_NOx-N-max"]
+}
+TERM_ID = 'noxToAirInorganicFertiliser'
+TIER = EmissionMethodTier.TIER_1.value
+TERM_TYPE = TermTermType.INORGANICFERTILISER
+UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
+
+
+def _emission(value: float, min: float, max: float, aggregated: bool = False):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['methodTier'] = TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodModelDescription'] = 'Aggregated version' if aggregated else 'Disaggregated version'
+    return emission
+
+
+def _input_values(input: dict):
+    N_total = list_sum(get_N_total([input]))
+    lookups = LOOKUPS[TERM_TYPE.value]
+    return {
+        'id': input.get('term', {}).get('@id'),
+        'N': N_total,
+        'value': get_lookup_value(input.get('term', {}), lookups[0]),
+        'min': get_lookup_value(input.get('term', {}), lookups[1]),
+        'max': get_lookup_value(input.get('term', {}), lookups[2])
+    }
+
+
+def _filter_input_values(values: list, key: str): return [value for value in values if value.get(key)]
+
+
+def _run(cycle: dict):
+    inputs = filter_list_term_type(cycle.get('inputs', []), TERM_TYPE)
+    input_values = list(map(_input_values, inputs))
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                input_values=log_as_table(input_values))
+
+    value = list_sum([
+        v.get('N', 0) * v.get('value', 0) for v in _filter_input_values(input_values, 'value')
+    ]) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    min = list_sum([
+        v.get('N', 0) * v.get('min', 0) for v in _filter_input_values(input_values, 'min')
+    ]) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    max = list_sum([
+        v.get('N', 0) * v.get('max', 0) for v in _filter_input_values(input_values, 'max')
+    ]) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    aggregated = list_sum(find_term_match(inputs, UNSPECIFIED_TERM_ID).get('value', [0])) > 0
+
+    return [_emission(value, min, max, aggregated=aggregated)]
+
+
+def _should_run(cycle: dict):
+    N_inorganic_fertiliser = get_inorganic_fertiliser_N_total(cycle)
+    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    N_inorganic_fertiliser=N_inorganic_fertiliser,
+                    term_type_fertiliser_complete=fertiliser_complete)
+
+    should_run = all([N_inorganic_fertiliser is not None, fertiliser_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []