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

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 []

hestia_earth/models/ipcc2019/n2OToAirOrganicFertiliserIndirect.py

@@ -0,0 +1,108 @@
+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_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 . 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"}
+        ],
+        "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 = 'n2OToAirOrganicFertiliserIndirect'
+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_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)
+    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_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)
+    )]
+
+
+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, {'termType': 'fertiliser'})
+    water_complete = _is_term_type_complete(cycle, {'termType': TermTermType.WATER.value})
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    N_organic_fertiliser=N_organic_fertiliser,
+                    ecoClimateZone=ecoClimateZone,
+                    fertiliser_complete=fertiliser_complete,
+                    water_complete=water_complete)
+
+    should_run = all([N_organic_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 []

hestia_earth/models/ipcc2019/utils.py

@@ -4,6 +4,25 @@ from hestia_earth.models.log import debugValues
 from hestia_earth.models.utils.input import get_total_irrigation_m3
 from hestia_earth.models.utils.cycle import get_ecoClimateZone
 from . import MODEL
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.blank_node import find_terms_value
+
+# From IPCC2019 Indirect N2O emission factor, in N [avg, min, max, std]
+COEFF_NO3_N2O = [0.011, 0.00, 0.02, 0.005]
+# Volatilized Nitrogen as NH3-N and NOx-N per kg N applied organic fertilisers and animal dung and urine
+COEFF_N_NH3NOX_organic_animal = [0.21, 0.00, 0.31, 0.0775]
+# Volatilized Nitrogen as NH3-N and NOx-N per kg N applied inorganic fertilisers
+COEFF_N_NH3NOX_inorganic = [0.11, 0.02, 0.33, 0.0775]
+
+
+def get_nh3_no3_nox_to_n(cycle: dict, nh3_term_id: str, no3_term_id: str, nox_term_id: str):
+    nh3 = find_terms_value(cycle.get('emissions', []), nh3_term_id)
+    nh3 = nh3 / get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+    no3 = find_terms_value(cycle.get('emissions', []), no3_term_id)
+    no3 = no3 / get_atomic_conversion(Units.KG_NO3, Units.TO_N)
+    nox = find_terms_value(cycle.get('emissions', []), nox_term_id)
+    nox = nox / get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+    return nh3, no3, nox
 
 
 def get_FracLEACH_H(cycle: dict, term_id: str):
@@ -21,3 +40,21 @@ def get_FracLEACH_H(cycle: dict, term_id: str):
         is_eco_climate_zone_dry,
         any([irrigation_value_m3 <= 250, is_drip_irrigated])
     ]) else (0.24, 0.01, 0.73, 0.18)  # value, min, max, sd
+
+
+# Indirect N2O emissions from volatilized NH3 and NOx
+def get_FracNH3NOx_N2O(cycle: dict, term_id: str):
+    eco_climate_zone = get_ecoClimateZone(cycle)
+    is_eco_climate_zone_dry = eco_climate_zone % 2 == 0
+    irrigation_value_m3 = get_total_irrigation_m3(cycle)
+    is_drip_irrigated = find_term_match(cycle.get('practices', []), 'irrigatedDripIrrigation', None) is not None
+
+    debugValues(cycle, model=MODEL, term=term_id,
+                is_eco_climate_zone_dry=is_eco_climate_zone_dry,
+                irrigation_value_m3=irrigation_value_m3,
+                is_drip_irrigated=is_drip_irrigated)
+
+    return (0.005, 0, 0.011, 0.00275) if all([
+        is_eco_climate_zone_dry,
+        any([irrigation_value_m3 <= 250, is_drip_irrigated])
+    ]) else (0.014, 0.011, 0.017, 0.0015)  # value, min, max, sd

hestia_earth/models/jarvisAndPain1994/__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 = 'jarvisAndPain1994'
+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/jarvisAndPain1994/n2ToAirExcreta.py

@@ -0,0 +1,53 @@
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
+from . import MODEL
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.emission import _new_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "n2OToAirExcretaDirect"}
+        ]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+TERM_ID = 'n2ToAirExcreta'
+TIER = EmissionMethodTier.TIER_1.value
+N2O_TERM_ID = 'n2OToAirExcretaDirect'
+
+
+def _emission(value: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    return emission
+
+
+def _run(n2o: dict):
+    value = 3 * list_sum(n2o.get("value", [])) / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    return [_emission(value)]
+
+
+def _should_run(cycle: dict):
+    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
+
+    should_run = all([n2o])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, n2o
+
+
+def run(cycle: dict):
+    should_run, n2o = _should_run(cycle)
+    return _run(n2o) if should_run else []

hestia_earth/models/koble2014/aboveGroundCropResidue.py

@@ -9,10 +9,10 @@ This model returns the amounts and destinations of above ground crop residue, wo
 """
 from functools import reduce
 from hestia_earth.schema import ProductStatsDefinition
-from hestia_earth.utils.model import find_primary_product, find_term_match
+from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import flatten, list_sum, list_average
 
-from hestia_earth.models.log import logRequirements, logShouldRun, logger
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from . import MODEL
@@ -52,6 +52,10 @@ MODELS = [
 REMAINING_MODEL = 'aboveGroundCropResidueLeftOnField'
 
 
+def _get_practices(term_id: str):
+    return flatten([model.get('practices', []) for model in MODELS if model.get('term') == term_id])
+
+
 def _get_practice_value(term_ids: list, cycle: dict) -> float:
     # multiple practices starting with the `@id` might be present, group together
     values = flatten([
@@ -66,23 +70,28 @@ def _product(term_id: str, value: float):
     return product
 
 
-def _should_run_model(model, cycle: dict, primary_product: dict):
+def _should_run_model(model, cycle: dict, total_value: float):
     term_id = model.get('term')
     practice_value = _get_practice_value(model.get('practices'), cycle)
     has_product = find_term_match(cycle.get('products', []), term_id, None) is not None
 
     logRequirements(cycle, model=MODEL, term=term_id,
                     practice_value=practice_value,
-                    primary_product=(primary_product or {}).get('@id'),
                     has_product=has_product)
 
-    should_run = all([practice_value is not None, primary_product, not has_product])
+    should_run = all([
+        any([
+            practice_value == 0,
+            practice_value is not None and total_value > 0
+        ]),
+        not has_product
+    ])
     logShouldRun(cycle, MODEL, term_id, should_run)
     return should_run, practice_value
 
 
-def _run_model(model, cycle: dict, primary_product: dict, total_value: float):
-    should_run, practice_value = _should_run_model(model, cycle, primary_product)
+def _run_model(model, cycle: dict, total_value: float):
+    should_run, practice_value = _should_run_model(model, cycle, total_value)
     return total_value * practice_value if should_run else None
 
 
@@ -93,7 +102,6 @@ def _model_value(term_id: str, products: list):
 
 def _run(cycle: dict, total_values: list):
     products = cycle.get('products', [])
-    primary_product = find_primary_product(cycle)
     total_value = list_average(total_values)
     # first, calculate the remaining value available after applying all user-uploaded data
     remaining_value = reduce(
@@ -106,14 +114,19 @@ def _run(cycle: dict, total_values: list):
     # then run every model in order up to the remaining value
     for model in MODELS:
         term_id = model.get('term')
-        value = _run_model(model, cycle, primary_product, total_value)
-        logger.debug('model=%s, term=%s, value=%s', MODEL, term_id, value)
-        if remaining_value > 0 and value is not None and value >= 0:
+        value = _run_model(model, cycle, total_value)
+        debugValues(cycle, model=MODEL, term=term_id,
+                    total_value=total_value,
+                    remaining_value=remaining_value,
+                    value=value)
+
+        if value == 0:
+            values.extend([_product(term_id, value)])
+        elif remaining_value > 0 and value is not None and value >= 0:
             value = value if value < remaining_value else remaining_value
             values.extend([_product(term_id, value)])
             remaining_value = remaining_value - value
             if remaining_value == 0:
-                logger.debug('model=%s, term=%s, no more residue - stopping', MODEL, term_id)
                 break
 
     return values + [
@@ -122,19 +135,29 @@ def _run(cycle: dict, total_values: list):
     ] if remaining_value > 0 else values
 
 
-def _should_run(cycle: dict):
+def _should_run_product(cycle: dict, total_values: list, term_id: str):
     term_type_incomplete = _is_term_type_incomplete(cycle, TOTAL_TERM_ID)
-    total_values = find_term_match(cycle.get('products', []), TOTAL_TERM_ID).get('value', [])
     has_aboveGroundCropResidueTotal = len(total_values) > 0
+    practice_term_ids = _get_practices(term_id)
+    is_value_0 = any([
+        find_term_match(cycle.get('practices', []), term_id).get('value', []) == [0] for term_id in practice_term_ids
+    ])
+
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    has_aboveGroundCropResidueTotal=has_aboveGroundCropResidueTotal,
+                    practice_term_ids=';'.join(practice_term_ids),
+                    practice_value_is_0=is_value_0)
+    should_run = all([has_aboveGroundCropResidueTotal or is_value_0, term_type_incomplete])
+    logShouldRun(cycle, MODEL, term_id, should_run)
+    return should_run
 
-    should_run = all([has_aboveGroundCropResidueTotal, term_type_incomplete])
-    for term_id in TERM_ID.split(','):
-        logRequirements(cycle, model=MODEL, term=term_id,
-                        term_type_cropResidue_incomplete=term_type_incomplete,
-                        has_aboveGroundCropResidueTotal=has_aboveGroundCropResidueTotal)
-        logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return should_run, total_values
+def _should_run(cycle: dict):
+    total_values = find_term_match(cycle.get('products', []), TOTAL_TERM_ID).get('value', [])
+    return any([
+        _should_run_product(cycle, total_values, term_id) for term_id in TERM_ID.split(',')
+    ]), total_values
 
 
 def run(cycle: dict):

hestia_earth/models/koble2014/utils.py

@@ -3,7 +3,7 @@ from hestia_earth.schema import TermTermType, PracticeStatsDefinition
 from hestia_earth.utils.model import find_primary_product, find_term_match
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.term import get_crop_residue_management_terms
@@ -28,6 +28,9 @@ def _should_run(term_id: str, cycle: dict, require_country: bool = False):
     practices = cycle.get('practices', [])
     residue_terms = get_crop_residue_management_terms()
     remaining_value = reduce(lambda prev, term: prev - _model_value(term, practices), residue_terms, 100)
+    residue_values = log_as_table([
+        {'id': term_id, 'value': _model_value(term_id, practices)} for term_id in residue_terms
+    ])
     has_remaining_value = remaining_value > 0
 
     country_id = cycle.get('site', {}).get('country', {}).get('@id')
@@ -36,6 +39,7 @@ def _should_run(term_id: str, cycle: dict, require_country: bool = False):
                     has_primary_product=has_primary_product,
                     crop_residue_incomplete=crop_residue_incomplete,
                     has_remaining_value=has_remaining_value,
+                    crop_residue_values=residue_values,
                     country_id=country_id)
 
     should_run = all([

hestia_earth/models/log.py

@@ -1,6 +1,7 @@
 import os
 import sys
 import logging
+from typing import Union
 
 LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
 
@@ -69,3 +70,21 @@ def debugMissingLookup(lookup_name: str, row: str, row_value: str, col: str, val
 
 def logErrorRun(model: str, term: str, error: str):
     logger.error('model=%s, term=%s, error=%s', model, term, error)
+
+
+def log_as_table(values: Union[list, dict]):
+    """
+    Log a list of values to display as a table.
+    Can either use a single dictionary, represented using id/value pair,
+    or a list of dictionaries using their keys as columns.
+
+    Parameters
+    ----------
+    values : list | dict
+        Values to display as a table.
+    """
+    return ';'.join([
+        f"id:{k}_value:{v}" for k, v in values.items()
+    ] if isinstance(values, dict) else [
+        '_'.join([f"{k}:{v}" for k, v in value.items()]) for value in values
+    ])