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

hestia_earth/models/ipcc2019/noxToAirOrganicFertiliser.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_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 _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_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)
+
+    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,
@@ -105,7 +107,14 @@ REQUIREMENTS = {
                     "value": "",
                     "startDate": "",
                     "endDate": "",
-                    "term.@id": "organicFertiliserOrSoilCarbonIncreasingAmendmentUsed"
+                    "term.@id": "organicFertiliserUsed"
+                },
+                {
+                    "@type": "Management",
+                    "value": "",
+                    "startDate": "",
+                    "endDate": "",
+                    "term.@id": "amendmentIncreasingSoilCarbonUsed"
                 },
                 {"@type": "Management", "value": "", "startDate": "", "endDate": "", "term.@id": "shortBareFallow"}
             ]
@@ -182,7 +191,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 +199,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
@@ -237,7 +245,8 @@ IMPROVED_PASTURE_TERM_ID = "improvedPasture"
 SHORT_BARE_FALLOW_TERM_ID = "shortBareFallow"
 ANIMAL_MANURE_USED_TERM_ID = "animalManureUsed"
 INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID = "inorganicNitrogenFertiliserUsed"
-ORGANIC_FERTILISER_USED_TERM_ID = "organicFertiliserOrSoilCarbonIncreasingAmendmentUsed"
+ORGANIC_FERTILISER_USED_TERM_ID = "organicFertiliserUsed"
+SOIL_AMENDMENT_USED_TERM_ID = "amendmentIncreasingSoilCarbonUsed"
 
 CLAY_CONTENT_MAX = 8
 SAND_CONTENT_MIN = 70
@@ -1834,17 +1843,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 +1882,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 +1935,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 +1964,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 ---
@@ -3294,7 +3309,7 @@ def _get_carbon_input_kwargs(
 
     has_organic_fertiliser_or_soil_amendment_used = any(
         get_node_value(node) for node in land_use_management_nodes
-        if node_term_match(node, ORGANIC_FERTILISER_USED_TERM_ID)
+        if node_term_match(node, [ORGANIC_FERTILISER_USED_TERM_ID, SOIL_AMENDMENT_USED_TERM_ID])
     )
 
     has_practice_increasing_c_input = cumulative_nodes_match(
@@ -3539,7 +3554,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 +3611,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 +3650,8 @@ def _should_run_tier_1(
 
 def _should_run_tier_2(
     inventory: dict,
+    *,
+    sand_content: float = None,
     **_
 ) -> bool:
     """
@@ -3624,7 +3661,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
     ])
 
 
@@ -3663,7 +3700,7 @@ def _log_inventory(inventory: dict) -> str:
             ),
             "irrigated-monthly": (
                 " ".join(str(val) for val in group.get(_InventoryKey.IRRIGATED_MONTHLY, []))
-                if group.get(_InventoryKey.PET_MONTHLY) else None
+                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 +3752,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 +3857,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)

hestia_earth/models/site/soilMeasurement.py

@@ -0,0 +1,197 @@
+"""
+Soil Measurement
+
+This model harmonises matching soil measurements into depth ranges of 0-30 and 0-50 and gap fills missing measurements.
+"""
+from collections import defaultdict
+from copy import deepcopy
+from hestia_earth.schema import MeasurementMethodClassification
+from hestia_earth.utils.tools import non_empty_list, flatten
+
+from hestia_earth.models.log import logRequirements, logShouldRun, logErrorRun
+from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "measurements": [
+            {"@type": "Measurement", "depthUpper": "", "depthLower": ""}
+        ]
+    }
+}
+
+RETURNS = {
+    "Measurement": [{
+        "value": "",
+        "depthUpper": 0,
+        "depthLower": [30, 50],
+        "dates": "",
+        "methodClassification": "modelled using other measurements"
+    }]
+}
+
+LOOKUPS = {
+    "measurement": ["recommendAddingDepth", "depthSensitive"]
+}
+
+MODEL_KEY = 'soilMeasurement'
+STANDARD_DEPTHS = {(0, 30), (0, 50)}
+
+
+def _measurement(value: float, date: str, term_id: str, standard_fields: dict):
+    data = _new_measurement(term=term_id)
+    data["value"] = [value]
+    data["depthUpper"] = standard_fields["depthUpper"]
+    data["depthLower"] = standard_fields["depthLower"]
+    data["methodClassification"] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
+    if date and date[0]:
+        data["dates"] = [date]
+    return data
+
+
+def _get_overlap(in_lower: int, in_upper: int, out_lower: int, out_upper: int):
+    """Returns the amount of overlap between upper-lower and range_upper-range_lower."""
+    if in_lower >= in_upper or out_lower >= out_upper or in_lower >= out_upper or in_upper <= out_lower:
+        return 0
+
+    overlap_range = [max(in_lower, out_lower), min(in_upper, out_upper)]
+    return max(overlap_range) - min(overlap_range)
+
+
+def _harmonise_measurements(measurements_list: list, standard_depth_lower: int, standard_depth_upper: int) -> float:
+    """Gather measurements and calculate modelled value."""
+    total_weight_values = 0
+    total_weights = 0
+    for measurement_dict in measurements_list:
+        value = measurement_dict.get("value", [])[0]
+        depth_lower = measurement_dict.get("depthLower", 0)
+        depth_upper = measurement_dict.get("depthUpper", 0)
+        # Note that the upper/lower here is reversed as lower in the ground (greater depth),
+        # means higher numbers.
+        weight = _get_overlap(
+            in_lower=depth_upper,
+            in_upper=depth_lower,
+            out_lower=standard_depth_upper,
+            out_upper=standard_depth_lower
+        )
+        total_weights += weight
+        total_weight_values += value * weight
+    modelled_value = total_weight_values / total_weights if total_weights else 0
+    return modelled_value
+
+
+def _expand_multiple_measurements(measurements):
+    """Split/expand measurements with arrays of values and dates into distinct measurements."""
+    expanded_measurements = []
+    for measurement in measurements:
+        if "dates" in measurement and len(measurement.get("value", [])) != len(measurement.get("dates", [])):
+            logErrorRun(
+                model=MODEL,
+                term=measurement.get("term", {}),
+                error="Inconsistent field lengths between values and dates fields in measurement."
+            )
+        elif len(measurement.get("value", [])) < 2:
+            expanded_measurements.append(measurement)
+        else:
+            for v, d in zip(measurement.get("value", []), measurement.get("dates", [])):
+                new_measurement = deepcopy(measurement)
+                new_measurement.update({"value": [v], "dates": [d]})
+                expanded_measurements.append(new_measurement)
+
+    return expanded_measurements
+
+
+def _group_measurements_by_date_method_term(measurements):
+    group_by_result = defaultdict(list)
+    for measurement_dict in measurements:
+        dates = measurement_dict.get("dates", [])
+        method = measurement_dict.get("method", {}).get("@id", "")
+        term_id = measurement_dict.get("term", {}).get("@id", "")
+        if not dates:
+            dates = [measurement_dict.get('endDate', "")]
+        group_by_result[(dates[0], method, term_id)].append(measurement_dict)
+    return group_by_result
+
+
+def _run_harmonisation(measurements: list, needed_depths: list):
+    results = []
+    grouped_measurements = _group_measurements_by_date_method_term(
+        _expand_multiple_measurements(measurements)
+    )
+
+    for (date, method, term_id), measurements_list in grouped_measurements.items():
+        # For a target depth
+        for depth_upper, depth_lower in needed_depths:
+            modelled_value = _harmonise_measurements(
+                measurements_list=measurements_list,
+                standard_depth_upper=depth_upper,
+                standard_depth_lower=depth_lower
+            )
+            if modelled_value:
+                results.append(
+                    _measurement(
+                        value=modelled_value,
+                        date=date,
+                        standard_fields={
+                            "depthUpper": depth_upper,
+                            "depthLower": depth_lower
+                        },
+                        term_id=term_id
+                    )
+                )
+
+    return results
+
+
+def _run_gap_fill_depths(measurements_missing_depths: list) -> list:
+    return [dict(m, **{"depthUpper": 0, "depthLower": 30}) for m in measurements_missing_depths]
+
+
+def _get_needed_depths(site: dict) -> list:
+    needed_depths = list(STANDARD_DEPTHS)
+    for measurement in site.get("measurements", []):
+        if (measurement.get("depthUpper"), measurement.get("depthLower")) in needed_depths:
+            needed_depths.remove((int(measurement["depthUpper"]), int(measurement["depthLower"])))
+
+    return needed_depths
+
+
+def _should_run(site: dict, model_key: str):
+    # we only work with measurements with depths
+    measurements = [
+        m for m in site.get("measurements", [])
+        if get_lookup_value(m.get("term", {}), LOOKUPS["measurement"][0], model=MODEL, model_key=model_key)
+    ]
+
+    measurements_with_depths = [m for m in measurements if all([
+        "depthUpper" in m.keys(),
+        "depthLower" in m.keys(),
+        (int(m.get("depthUpper", 0)), int(m.get("depthLower", 0))) not in STANDARD_DEPTHS
+    ])]
+    has_measurements_with_depths = len(measurements_with_depths) > 0
+
+    measurements_missing_depth_recommended = [m for m in measurements if all([
+        "depthUpper" not in m.keys(),
+        "depthLower" not in m.keys(),
+        not get_lookup_value(m.get("term", {}), LOOKUPS["measurement"][1], model=MODEL, model_key=model_key)
+    ])]
+
+    logRequirements(site, model=MODEL, model_key=model_key,
+                    has_measurements_with_depths=has_measurements_with_depths,
+                    has_missing_depths=bool(measurements_missing_depth_recommended))
+
+    should_run = has_measurements_with_depths or bool(measurements_missing_depth_recommended)
+    for measurement in measurements_with_depths + measurements_missing_depth_recommended:
+        term_id = measurement.get("term", {}).get("@id", {})
+        logShouldRun(site, MODEL, term_id, should_run)
+    return should_run, measurements_with_depths, measurements_missing_depth_recommended
+
+
+def run(site: dict):
+    should_run, measurements_with_depths, measurements_missing_depth = _should_run(site=site, model_key=MODEL_KEY)
+    needed_depths = _get_needed_depths(site)
+    return non_empty_list(flatten(
+        _run_harmonisation(measurements=measurements_with_depths, needed_depths=needed_depths)
+        + _run_gap_fill_depths(measurements_missing_depths=measurements_missing_depth)
+    )) if should_run else []

hestia_earth/models/utils/cycle.py

@@ -1,6 +1,6 @@
 from hestia_earth.schema import CycleFunctionalUnit, SiteSiteType, TermTermType
 from hestia_earth.utils.model import filter_list_term_type, find_term_match, find_primary_product
-from hestia_earth.utils.tools import flatten, list_sum, safe_parse_float, safe_parse_date
+from hestia_earth.utils.tools import list_sum, safe_parse_float, safe_parse_date
 
 from ..log import logRequirements, debugValues
 from .lookup import factor_value
@@ -368,7 +368,7 @@ def is_organic(cycle: dict):
     return any([get_lookup_value(p.get('term', {}), 'isOrganic') == 'organic' for p in practices])
 
 
-def is_irrigated(cycle: dict):
+def is_irrigated(cycle: dict, **log_ars):
     """
     Check if the `Cycle` is irrigated, i.e. if it contains an irrigated `Practice` with a value above `0`.
 
@@ -376,16 +376,17 @@ def is_irrigated(cycle: dict):
     ----------
     cycle : dict
         The `Cycle`.
+    log_ars : dict[str, Any]
+        Extra loggging, e.g. model, term.
 
     Returns
     -------
     bool
         `True` if the `Cycle` is irrigated, `False` otherwise.
     """
-    irrigated_practices = [
-        p for p in cycle.get('practices', []) if p.get('term', {}).get('@id', '').startswith('irrigated')
-    ]
-    return list_sum(flatten([p.get('value', []) for p in irrigated_practices])) > 0
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.WATERREGIME)
+    irrigated_practices = [p for p in practices if get_lookup_value(p.get('term', {}), 'irrigated', **log_ars)]
+    return any([list_sum(p.get('value', []), 0) > 0 for p in irrigated_practices])
 
 
 def cycle_end_year(cycle: dict):

hestia_earth/models/utils/emission.py

@@ -4,6 +4,8 @@ from hestia_earth.utils.model import linked_node
 from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
 
 from . import _term_id, _include_methodModel
+from .blank_node import find_terms_value
+from .constant import Units, get_atomic_conversion
 
 
 def _new_emission(term, model=None):
@@ -17,3 +19,16 @@ def is_in_system_boundary(term_id: str):
     value = get_table_value(lookup, 'termid', term_id, column_name('inHestiaDefaultSystemBoundary'))
     # handle numpy boolean
     return not (not value)
+
+
+def get_nh3_no3_nox_to_n(cycle: dict, nh3_term_id: str, no3_term_id: str, nox_term_id: str, allow_none: bool = False):
+    default_value = 0 if allow_none else None
+
+    nh3 = find_terms_value(cycle.get('emissions', []), nh3_term_id, default=default_value)
+    nh3 = None if nh3 is None else nh3 / get_atomic_conversion(Units.KG_NH3, Units.TO_N)
+    no3 = find_terms_value(cycle.get('emissions', []), no3_term_id, default=default_value)
+    no3 = None if no3 is None else no3 / get_atomic_conversion(Units.KG_NO3, Units.TO_N)
+    nox = find_terms_value(cycle.get('emissions', []), nox_term_id, default=default_value)
+    nox = None if nox is None else nox / get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+
+    return (nh3, no3, nox)

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.59.1'
+VERSION = '0.59.3'

{hestia_earth_models-0.59.1.dist-info → hestia_earth_models-0.59.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.59.1
+Version: 0.59.3
 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