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

hestia_earth/models/cycle/{irrigated.py → irrigatedTypeUnspecified.py}

@@ -24,7 +24,7 @@ RETURNS = {
         "value": ""
     }]
 }
-TERM_ID = 'irrigated'
+TERM_ID = 'irrigatedTypeUnspecified'
 MIN_IRRIGATION_M3 = 250
 
 
@@ -34,6 +34,9 @@ def _practice(value: float):
     return practice
 
 
+def _is_irrigation_practice(practice: dict): return practice.get('term', {}).get('units', '') in ['%', '% area']
+
+
 def _run(irrigation_m3: float):
     value = 100 if irrigation_m3 > MIN_IRRIGATION_M3 else 0
     return [_practice(value)]
@@ -61,9 +64,6 @@ def _should_run(cycle: dict):
     return should_run, irrigation_value_m3
 
 
-def _is_irrigation_practice(practice: dict): return practice.get('term', {}).get('units', '') in ['%', '% area']
-
-
 def run(cycle: dict):
     should_run, irrigation_m3 = _should_run(cycle)
     return _run(irrigation_m3) if should_run else []

hestia_earth/models/cycle/residueIncorporated.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
             {"@type": "Product", "term.@id": "aboveGroundCropResidueTotal", "value": "> 0"},
             {"@type": "Product", "term.@id": "aboveGroundCropResidueIncorporated", "value": "> 0"}
         ],
-        "not": {
+        "none": {
             "practices": [{
                 "@type": "Practice",
                 "term.@id": [

hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -42,11 +42,11 @@ LOOKUPS = {
 RETURNS = {
     "Emission": [{
         "value": "",
-        "methodTier": "tier 1"
+        "methodTier": "tier 2"
     }]
 }
 TERM_ID = 'nh3ToAirInorganicFertiliser'
-TIER = EmissionMethodTier.TIER_1.value
+TIER = EmissionMethodTier.TIER_2.value
 UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
 
 

hestia_earth/models/geospatialDatabase/clayContent.py

@@ -1,7 +1,8 @@
 from hestia_earth.schema import MeasurementMethodClassification
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.blank_node import has_original_by_ids
+from hestia_earth.models.utils.measurement import SOIL_TEXTURE_IDS, _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -12,7 +13,17 @@ REQUIREMENTS = {
             {"latitude": "", "longitude": ""},
             {"boundary": {}},
             {"region": {"@type": "Term", "termType": "region"}}
-        ]
+        ],
+        "none": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "clayContent",
+                    "sandContent",
+                    "siltContent"
+                ]
+            }]
+        }
     }
 }
 RETURNS = {
@@ -54,12 +65,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
+    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    below_max_area_size=below_max_area_size,
+                    has_original_texture_measurements=has_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/geospatialDatabase/sandContent.py

@@ -1,7 +1,8 @@
 from hestia_earth.schema import MeasurementMethodClassification
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.blank_node import has_original_by_ids
+from hestia_earth.models.utils.measurement import SOIL_TEXTURE_IDS, _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -12,7 +13,17 @@ REQUIREMENTS = {
             {"latitude": "", "longitude": ""},
             {"boundary": {}},
             {"region": {"@type": "Term", "termType": "region"}}
-        ]
+        ],
+        "none": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "clayContent",
+                    "sandContent",
+                    "siltContent"
+                ]
+            }]
+        }
     }
 }
 RETURNS = {
@@ -54,12 +65,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
+    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    below_max_area_size=below_max_area_size,
+                    has_original_texture_measurements=has_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/impact_assessment/irrigated.py

@@ -18,9 +18,6 @@ REQUIREMENTS = {
 RETURNS = {
     "`true` if the `Cycle` was irrigated, `false` otherwise": ""
 }
-LOOKUPS = {
-    "waterRegime": "irrigated"
-}
 MODEL_KEY = 'irrigated'
 
 

hestia_earth/models/ipcc2019/co2ToAirSoilCarbonStockChangeManagementChange.py

@@ -580,22 +580,22 @@ def _calc_grouped_soc_stock_changes(grouped_soc_stocks: dict) -> dict:
 
 def _calc_sum_cycle_occupancy(cycles: list[dict]) -> float:
     """
-    Calculate the sum of cycle occupancies based on the `fraction_of_year` field added by the `group_nodes_by_year`
-    function.
+    Calculate the sum of cycle occupancies based on the `fraction_of_group_duration` field added by the
+    `group_nodes_by_year` function.
 
-    If a cycle does not have the "fraction_of_year" key, it is treated as zero occupancy for that year.
+    If a cycle does not have the "fraction_of_group_duration" key, it is treated as zero occupancy for that year.
 
     Parameters
     ----------
     cycles : List[dict]
-        List of cycles, where each cycle dictionary should contain a "fraction_of_year" key.
+        List of cycles, where each cycle dictionary should contain a "fraction_of_group_duration" key.
 
     Returns
     -------
     float
         The sum of cycle occupancies based on the fraction of the year.
     """
-    return sum(cycle.get("fraction_of_year", 0) for cycle in cycles)
+    return sum(cycle.get("fraction_of_group_duration", 0) for cycle in cycles)
 
 
 def _calc_grouped_share_of_emissions(cycles: list[dict]) -> dict:
@@ -604,14 +604,14 @@ def _calc_grouped_share_of_emissions(cycles: list[dict]) -> dict:
     of an inventory year.
 
     This function groups cycles by year, then calculates the share of emissions for each cycle based on the
-    "fraction_of_year" value. The share of emissions is normalized by the sum of cycle occupancies for the entire
-    dataset to ensure the values represent a valid share.
+    "fraction_of_group_duration" value. The share of emissions is normalized by the sum of cycle occupancies for the
+    entire dataset to ensure the values represent a valid share.
 
     Parameters
     ----------
     cycles : List[dict]
         List of [Cycle nodes](https://www.hestia.earth/schema/Cycle), where each cycle dictionary should contain a
-        "fraction_of_year" key added by the `group_nodes_by_year` function.
+        "fraction_of_group_duration" key added by the `group_nodes_by_year` function.
 
     Returns
     -------
@@ -623,7 +623,8 @@ def _calc_grouped_share_of_emissions(cycles: list[dict]) -> dict:
     return {
         year: {
             INNER_KEY: {
-                cycle["@id"]: cycle.get("fraction_of_year", 0) / _calc_sum_cycle_occupancy(cycles) for cycle in cycles
+                cycle["@id"]: cycle.get("fraction_of_group_duration", 0) / _calc_sum_cycle_occupancy(cycles)
+                for cycle in cycles
             }
         } for year, cycles in grouped_cycles.items()
     }

hestia_earth/models/ipcc2019/n2OToAirCropResidueDecompositionDirect.py

@@ -1,15 +1,12 @@
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
-from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, 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.emission import _new_emission
 from hestia_earth.models.utils.cycle import get_ecoClimateZone, get_crop_residue_decomposition_N_total
-from hestia_earth.models.utils.ecoClimateZone import get_ecoClimateZone_lookup_value
-from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.product import has_flooded_rice
+from .utils import get_N2O_factors
 from . import MODEL
 
 REQUIREMENTS = {
@@ -51,28 +48,6 @@ LOOKUPS = {
 }
 TERM_ID = 'n2OToAirCropResidueDecompositionDirect'
 TIER = EmissionMethodTier.TIER_1.value
-FACTORS = {
-    'dry': {
-        'value': 0.005,
-        'min': 0,
-        'max': 0.011
-    },
-    'wet': {
-        'value': 0.006,
-        'min': 0.001,
-        'max': 0.011
-    },
-    'default': {
-        'value': 0.01,
-        'min': 0.001,
-        'max': 0.018
-    },
-    'flooded_rice': {
-        'value': 0.004,
-        'min': 0,
-        'max': 0.029
-    }
-}
 
 
 def _emission(value: float, min: float, max: float, sd: float, aggregated: bool = False):
@@ -87,33 +62,11 @@ def _emission(value: float, min: float, max: float, sd: float, aggregated: bool
     return emission
 
 
-def _get_waterRegime_lookup(practice: dict, col: str):
-    return safe_parse_float(get_lookup_value(practice.get('term', {}), col, model=MODEL, term=TERM_ID), None)
-
-
-def _flooded_rice_factors(cycle: dict):
-    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.WATERREGIME)
-    practice = next((p for p in practices if _get_waterRegime_lookup(p, LOOKUPS['waterRegime'][0]) is not None), None)
-
-    factors = {
-        'value': _get_waterRegime_lookup(practice, LOOKUPS['waterRegime'][0]),
-        'min': _get_waterRegime_lookup(practice, LOOKUPS['waterRegime'][1]),
-        'max': _get_waterRegime_lookup(practice, LOOKUPS['waterRegime'][2])
-    } if practice else FACTORS['flooded_rice']
-
-    return (factors, practice is None)
-
-
-def _is_wet(ecoClimateZone: str = None):
-    return get_ecoClimateZone_lookup_value(ecoClimateZone, 'wet') == 1 if ecoClimateZone else None
-
-
 def _run(cycle: dict, N_total: float, ecoClimateZone: str = None, flooded_rice: bool = False):
     converted_N_total = N_total * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
-    is_wet = _is_wet(ecoClimateZone)
-    factors_key = 'default' if is_wet is None else 'wet' if is_wet else 'dry'
-
-    factors, aggregated = _flooded_rice_factors(cycle) if flooded_rice else (FACTORS[factors_key], is_wet is None)
+    factors, aggregated = get_N2O_factors(
+        TERM_ID, cycle, TermTermType.CROPRESIDUE, ecoClimateZone=ecoClimateZone, flooded_rice=flooded_rice
+    )
 
     debugValues(cycle, model=MODEL, term=TERM_ID,
                 factors_used=log_as_table(factors),

hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserDirect.py

@@ -0,0 +1,104 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, 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.emission import _new_emission
+from hestia_earth.models.utils.cycle import get_ecoClimateZone, get_inorganic_fertiliser_N_total
+from hestia_earth.models.utils.product import has_flooded_rice
+from .utils import get_N2O_factors
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "inputs": [{
+            "@type": "Input",
+            "value": "",
+            "term.units": ["kg", "kg N"],
+            "term.termType": "inorganicFertiliser",
+            "optional": {
+                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+            }
+        }],
+        "optional": {
+            "endDate": "",
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            },
+            "products": [{"@type": "Product", "term.@id": "riceGrainInHuskFlooded"}],
+            "practices": [{"@type": "Practice", "term.termType": "waterRegime"}]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled",
+        "methodModelDescription": ["Aggregated version", "Disaggregated version"]
+    }]
+}
+LOOKUPS = {
+    "waterRegime": ["IPCC_2019_N2O_rice", "IPCC_2019_N2O_rice-min", "IPCC_2019_N2O_rice-max"]
+}
+TERM_ID = 'n2OToAirInorganicFertiliserDirect'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float, min: float, max: float, sd: float, aggregated: bool = False):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['sd'] = [sd]
+    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: float, ecoClimateZone: str = None, flooded_rice: bool = False):
+    converted_N_total = N_total * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    factors, aggregated = get_N2O_factors(
+        TERM_ID, cycle, TermTermType.INORGANICFERTILISER, ecoClimateZone=ecoClimateZone, flooded_rice=flooded_rice
+    )
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                factors_used=log_as_table(factors),
+                aggregated=aggregated)
+
+    value = converted_N_total * factors['value']
+    min = converted_N_total * factors['min']
+    max = converted_N_total * factors['max']
+    sd = converted_N_total * (factors['max'] - factors['min'])/4
+    return [_emission(value, min, max, sd, aggregated=aggregated)]
+
+
+def _should_run(cycle: dict):
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+    N_total = get_inorganic_fertiliser_N_total(cycle)
+    ecoClimateZone = get_ecoClimateZone(cycle)
+
+    flooded_rice = has_flooded_rice(cycle.get('products', []))
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_complete=term_type_complete,
+                    N_total=N_total,
+                    has_flooded_rice=flooded_rice,
+                    ecoClimateZone=ecoClimateZone)
+
+    should_run = all([N_total is not None, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, N_total, ecoClimateZone, flooded_rice
+
+
+def run(cycle: dict):
+    should_run, N_total, ecoClimateZone, flooded_rice = _should_run(cycle)
+    return _run(cycle, N_total, ecoClimateZone, flooded_rice) if should_run else []

hestia_earth/models/ipcc2019/n2OToAirOrganicFertiliserDirect.py

@@ -0,0 +1,105 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, 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.emission import _new_emission
+from hestia_earth.models.utils.cycle import get_ecoClimateZone, get_organic_fertiliser_N_total
+from hestia_earth.models.utils.product import has_flooded_rice
+from .utils import get_N2O_factors
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.fertiliser": "True",
+        "inputs": [{
+            "@type": "Input",
+            "value": "",
+            "term.units": ["kg", "kg N"],
+            "term.termType": "organicFertiliser",
+            "optional": {
+                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+            }
+        }],
+        "optional": {
+            "endDate": "",
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            },
+            "products": [{"@type": "Product", "term.@id": "riceGrainInHuskFlooded"}],
+            "practices": [{"@type": "Practice", "term.termType": "waterRegime"}]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled",
+        "methodModelDescription": ["Aggregated version", "Disaggregated version"]
+    }]
+}
+LOOKUPS = {
+    "waterRegime": ["IPCC_2019_N2O_rice", "IPCC_2019_N2O_rice-min", "IPCC_2019_N2O_rice-max"]
+}
+TERM_ID = 'n2OToAirOrganicFertiliserDirect'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float, min: float, max: float, sd: float, aggregated: bool = False):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['sd'] = [sd]
+    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: float, ecoClimateZone: str = None, flooded_rice: bool = False):
+    converted_N_total = N_total * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    factors, aggregated = get_N2O_factors(
+        TERM_ID, cycle, TermTermType.ORGANICFERTILISER, ecoClimateZone=ecoClimateZone, flooded_rice=flooded_rice
+    )
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                factors_used=log_as_table(factors),
+                aggregated=aggregated)
+
+    print(N_total, get_atomic_conversion(Units.KG_N2O, Units.TO_N), factors['value'])
+    value = converted_N_total * factors['value']
+    min = converted_N_total * factors['min']
+    max = converted_N_total * factors['max']
+    sd = converted_N_total * (factors['max'] - factors['min'])/4
+    return [_emission(value, min, max, sd, aggregated=aggregated)]
+
+
+def _should_run(cycle: dict):
+    term_type_complete = _is_term_type_complete(cycle, 'fertiliser')
+    N_total = get_organic_fertiliser_N_total(cycle)
+    ecoClimateZone = get_ecoClimateZone(cycle)
+
+    flooded_rice = has_flooded_rice(cycle.get('products', []))
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_complete=term_type_complete,
+                    N_total=N_total,
+                    has_flooded_rice=flooded_rice,
+                    ecoClimateZone=ecoClimateZone)
+
+    should_run = all([N_total is not None, term_type_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, N_total, ecoClimateZone, flooded_rice
+
+
+def run(cycle: dict):
+    should_run, N_total, ecoClimateZone, flooded_rice = _should_run(cycle)
+    return _run(cycle, N_total, ecoClimateZone, flooded_rice) if should_run else []