hestia-earth-models 0.59.0__py3-none-any.whl → 0.59.2__py3-none-any.whl

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/nh3ToAirOrganicFertiliser.py

@@ -0,0 +1,104 @@
+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 _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 input_values
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    min = list_sum([
+        v.get('N', 0) * v.get('min', 0) for v in input_values
+    ]) * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+
+    max = list_sum([
+        v.get('N', 0) * v.get('max', 0) for v in input_values
+    ]) * 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/noxToAirOrganicFertiliser.py

@@ -0,0 +1,104 @@
+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_NOx-N", "IPCC_2019_FRACGASM_NOx-N-min", "IPCC_2019_FRACGASM_NOx-N-max"]
+}
+TERM_ID = 'noxToAirOrganicFertiliser'
+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 _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 input_values
+    ]) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    min = list_sum([
+        v.get('N', 0) * v.get('min', 0) for v in input_values
+    ]) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    max = list_sum([
+        v.get('N', 0) * v.get('max', 0) for v in input_values
+    ]) * get_atomic_conversion(Units.KG_NOX, 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/organicCarbonPerHa.py

@@ -18,12 +18,15 @@ from typing import (
 from hestia_earth.schema import (
     CycleFunctionalUnit,
     MeasurementMethodClassification,
+    SchemaType,
     SiteSiteType,
     TermTermType,
 )
+from hestia_earth.utils.api import find_related
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
 
+from hestia_earth.models.utils import _load_calculated_node
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match,
@@ -42,7 +45,6 @@ from hestia_earth.models.utils.measurement import (
     _new_measurement,
 )
 from hestia_earth.models.utils.property import get_node_property
-from hestia_earth.models.utils.site import related_cycles
 from hestia_earth.models.utils.term import (
     get_cover_crop_property_terms,
     get_crop_residue_incorporated_or_left_on_field_terms,
@@ -182,7 +184,7 @@ CARBON_CONTENT_TERM_ID = "carbonContent"
 NITROGEN_CONTENT_TERM_ID = "nitrogenContent"
 LIGNIN_CONTENT_TERM_ID = "ligninContent"
 
-CROP_RESIDUE_PROPERTY_TERM_IDS = [
+CARBON_INPUT_PROPERTY_TERM_IDS = [
     CARBON_CONTENT_TERM_ID,
     NITROGEN_CONTENT_TERM_ID,
     LIGNIN_CONTENT_TERM_ID
@@ -190,8 +192,7 @@ CROP_RESIDUE_PROPERTY_TERM_IDS = [
 
 CARBON_SOURCE_TERM_TYPES = [
     TermTermType.ORGANICFERTILISER.value,
-    TermTermType.SOILAMENDMENT.value,
-    TermTermType.SEED.value
+    TermTermType.SOILAMENDMENT.value
 ]
 
 MIN_RUN_IN_PERIOD = 5
@@ -1834,17 +1835,12 @@ def _iterate_carbon_source(node: dict) -> Union[CarbonSource, None]:
     CarbonSource | None
         A `CarbonSource` named tuple if the node is a carbon source with the required properties, else `None`.
     """
-    term = node.get("term", {})
     mass = list_sum(node.get("value", []))
     carbon_content, nitrogen_content, lignin_content = (
-        get_node_property(node, term_id, False).get("value", 0)/100 for term_id in CROP_RESIDUE_PROPERTY_TERM_IDS
+        get_node_property(node, term_id).get("value", 0)/100 for term_id in CARBON_INPUT_PROPERTY_TERM_IDS
     )
 
     should_run = all([
-        any([
-            term.get("@id", None) in get_crop_residue_incorporated_or_left_on_field_terms(),
-            term.get("termType") in CARBON_SOURCE_TERM_TYPES
-        ]),
         mass > 0,
         0 < carbon_content <= 1,
         0 < nitrogen_content <= 1,
@@ -1878,7 +1874,13 @@ def _get_carbon_sources_from_cycles(cycles: dict) -> list[CarbonSource]:
         [cycle.get("inputs", []) + cycle.get("products", []) for cycle in cycles]
     ))
 
-    return non_empty_list([_iterate_carbon_source(node) for node in inputs_and_products])
+    return non_empty_list([
+        _iterate_carbon_source(node) for node in inputs_and_products
+        if any([
+            node.get("term", {}).get("@id") in get_crop_residue_incorporated_or_left_on_field_terms(),
+            node.get("term", {}).get("termType") in CARBON_SOURCE_TERM_TYPES
+        ])
+    ])
 
 
 # --- TIER 2 SOC MODEL ---
@@ -1925,6 +1927,8 @@ def _run_tier_2(
         The length of the run-in period in years, must be greater than or equal to 1, default value: `5`.
     run_with_irrigation : bool, optional
         `True` if the model should run while taking into account irrigation, `False` if not.
+    sand_content : float, optional
+        A back-up sand content for if none are found in the inventory, decimal proportion, default value: `0.33`.
     params : dict | None, optional
         Overrides for the model parameters. If `None` only default parameters will be used.
 
@@ -1952,8 +1956,11 @@ def _run_tier_2(
     )
 
     sand_content = next(
-        group[_InventoryKey.SAND_CONTENT]/100 for group in valid_inventory.values()
-        if _InventoryKey.SAND_CONTENT in group
+        (
+            group[_InventoryKey.SAND_CONTENT] for group in valid_inventory.values()
+            if _InventoryKey.SAND_CONTENT in group
+        ),
+        sand_content
     )
 
     # --- MERGE ANY USER-SET PARAMETERS WITH THE IPCC DEFAULTS ---
@@ -3539,7 +3546,7 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     site_type = site.get("siteType", "")
     management_nodes = site.get("management", [])
     measurement_nodes = site.get("measurements", [])
-    cycles = related_cycles(site.get("@id"))
+    cycles = _calculated_cycles(site.get("@id"))
 
     has_management = len(management_nodes) > 0
     has_measurements = len(measurement_nodes) > 0
@@ -3596,6 +3603,26 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     return should_run_tier_1, should_run_tier_2, inventory, kwargs
 
 
+def _calculated_cycles(site_id: str):
+    """
+    Get the list of `Cycle`s related to the `Site`. Gets the `recalculated` data if available, else `original`.
+
+    Parameters
+    ----------
+    site_id : str
+        The `@id` of the `Site`.
+
+    Returns
+    -------
+    list[dict]
+        The related `Cycle`s as `dict`.
+    """
+    nodes = find_related(SchemaType.SITE, site_id, SchemaType.CYCLE)
+    return list(
+        map(lambda node: _load_calculated_node(node, SchemaType.CYCLE), nodes or [])
+    )
+
+
 def _should_run_tier_1(
     inventory: dict,
     *,
@@ -3615,6 +3642,8 @@ def _should_run_tier_1(
 
 def _should_run_tier_2(
     inventory: dict,
+    *,
+    sand_content: float = None,
     **_
 ) -> bool:
     """
@@ -3624,7 +3653,7 @@ def _should_run_tier_2(
     return all([
         len(valid_years) >= MIN_RUN_IN_PERIOD,
         check_consecutive(valid_years),
-        any(inventory.get(year).get(_InventoryKey.SAND_CONTENT) for year in valid_years)
+        any(inventory.get(year).get(_InventoryKey.SAND_CONTENT) for year in valid_years) or sand_content
     ])
 
 
@@ -3650,20 +3679,20 @@ def _log_inventory(inventory: dict) -> str:
                 group.get(_InventoryKey.CI_CATEGORY).value if group.get(_InventoryKey.CI_CATEGORY) else None
             ),
             "temperature-monthly": (
-                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.TEMP_MONTHLY))
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.TEMP_MONTHLY, []))
                 if group.get(_InventoryKey.TEMP_MONTHLY) else None
             ),
             "precipitation-monthly": (
-                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PRECIP_MONTHLY))
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PRECIP_MONTHLY, []))
                 if group.get(_InventoryKey.PRECIP_MONTHLY) else None
             ),
             "pet-monthly": (
-                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PET_MONTHLY))
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PET_MONTHLY, []))
                 if group.get(_InventoryKey.PET_MONTHLY) else None
             ),
             "irrigated-monthly": (
-                " ".join(str(val) for val in group.get(_InventoryKey.IRRIGATED_MONTHLY))
-                if group.get(_InventoryKey.PET_MONTHLY) else None
+                " ".join(str(val) for val in group.get(_InventoryKey.IRRIGATED_MONTHLY, []))
+                if group.get(_InventoryKey.IRRIGATED_MONTHLY) else None
             ),
             "sand-content": group.get(_InventoryKey.SAND_CONTENT, None),
             "carbon-input": group.get(_InventoryKey.CARBON_INPUT, None),
@@ -3715,8 +3744,17 @@ def _build_inventory_tier_2(
     }
 
     inventory = merge(grouped_data, grouped_should_run)
+
+    # get a back-up value for sand content if no dated ones are available
+    sand_content = get_node_value(find_term_match(
+        [m for m in measurement_nodes if m.get("depthUpper") == DEPTH_UPPER and m.get("depthLower") == DEPTH_LOWER],
+        SAND_CONTENT_TERM_ID,
+        {}
+    )) / 100
+
     kwargs = {
-        "run_with_irrigation": True
+        "run_with_irrigation": True,
+        "sand_content": sand_content
     }
 
     return inventory, kwargs
@@ -3811,7 +3849,7 @@ def _get_grouped_sand_content_measurements(grouped_measurements: dict) -> dict:
     }
 
     return {
-        year: {_InventoryKey.SAND_CONTENT: get_node_value(measurement)}
+        year: {_InventoryKey.SAND_CONTENT: get_node_value(measurement)/100}
         for year, measurement in grouped_sand_content_measurements.items() if measurement
     }
 

hestia_earth/models/ipcc2019/utils.py

@@ -5,8 +5,6 @@ from hestia_earth.utils.tools import safe_parse_float
 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 hestia_earth.models.utils.constant import Units, get_atomic_conversion
-from hestia_earth.models.utils.blank_node import find_terms_value
 from hestia_earth.models.utils.term import get_lookup_value, get_milkYield_terms
 from hestia_earth.models.utils.ecoClimateZone import get_ecoClimateZone_lookup_value
 from . import MODEL
@@ -19,16 +17,6 @@ COEFF_N_NH3NOX_organic_animal = [0.21, 0.00, 0.31, 0.0775]
 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):
     eco_climate_zone = get_ecoClimateZone(cycle)
     is_eco_climate_zone_dry = eco_climate_zone % 2 == 0
@@ -130,6 +118,31 @@ N2O_FACTORS = {
         'max': 0.029
     }
 }
+EF4_FACTORS = {
+    'dry': {
+        'value': 0.005,
+        'min': 0,
+        'max': 0.011
+
+    },
+    'wet': {
+        'value': 0.014,
+        'min': 0.011,
+        'max': 0.017
+    },
+    'default': {
+        'value': 0.01,
+        'min': 0.002,
+        'max': 0.018
+    }
+}
+EF5_FACTORS = {
+    'default': {
+        'value': 0.011,
+        'min': 0.0,
+        'max': 0.02
+    }
+}
 
 
 def _get_waterRegime_lookup(model_term_id: str, practice: dict, col: str):
@@ -140,11 +153,10 @@ def _is_wet(ecoClimateZone: str = None):
     return get_ecoClimateZone_lookup_value(ecoClimateZone, 'wet') == 1 if ecoClimateZone else None
 
 
-def _ecoClimate_factors(input_term_type: TermTermType, ecoClimateZone: str = None):
+def ecoClimate_factors(factors: dict, input_term_type: TermTermType = None, ecoClimateZone: str = None):
     is_wet = _is_wet(ecoClimateZone)
     factors_key = 'default' if is_wet is None else 'wet' if is_wet else 'dry'
-    factors = N2O_FACTORS[factors_key]
-    return (factors.get(input_term_type) if factors_key == 'wet' else factors, is_wet is None)
+    return (factors[factors_key].get(input_term_type, factors[factors_key]), ecoClimateZone is None)
 
 
 def _flooded_rice_factors(model_term_id: str, cycle: dict):
@@ -169,4 +181,4 @@ def get_N2O_factors(
     flooded_rice: bool = False
 ):
     return _flooded_rice_factors(model_term_id, cycle) if flooded_rice \
-        else _ecoClimate_factors(input_term_type, ecoClimateZone)
+        else ecoClimate_factors(N2O_FACTORS, input_term_type, ecoClimateZone)