hestia-earth-models 0.64.6__py3-none-any.whl → 0.64.8__py3-none-any.whl

hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -1,23 +1,10 @@
-from functools import reduce
-from numpy import random
-
-from hestia_earth.schema import (
-    CycleFunctionalUnit, EmissionMethodTier, EmissionStatsDefinition, MeasurementMethodClassification, SiteSiteType
-)
+from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, SiteSiteType
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.array_builders import gen_seed
-from hestia_earth.models.utils.blank_node import (
-    _get_datestr_format, cumulative_nodes_term_match, DatestrFormat, node_term_match
-)
-from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
+from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.site import related_cycles
 
-from .co2ToAirCarbonStockChange_utils import (
-    _InventoryKey, add_carbon_stock_change_emissions, compile_inventory, rescale_carbon_stock_change_emission
-)
-from .utils import check_consecutive
+from .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
 from . import MODEL
 
 REQUIREMENTS = {
@@ -44,6 +31,11 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "statsDefinition": "simulated",
+        "observations": "",
         "methodTier": "",
         "depth": "30"
     }]
@@ -52,28 +44,8 @@ TERM_ID = 'co2ToAirSoilOrganicCarbonStockChangeManagementChange'
 
 _DEPTH_UPPER = 0
 _DEPTH_LOWER = 30
-_ITERATIONS = 10000
-
-_ORGANIC_CARBON_PER_HA_TERM_ID = 'organicCarbonPerHa'
-
-_VALID_DATE_FORMATS = {
-    DatestrFormat.YEAR,
-    DatestrFormat.YEAR_MONTH,
-    DatestrFormat.YEAR_MONTH_DAY,
-    DatestrFormat.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND
-}
 
-_VALID_MEASUREMENT_METHOD_CLASSIFICATIONS = [
-    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
-    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
-    MeasurementMethodClassification.TIER_3_MODEL,
-    MeasurementMethodClassification.TIER_2_MODEL,
-    MeasurementMethodClassification.TIER_1_MODEL
-]
-"""
-The list of `MeasurementMethodClassification`s that can be used to calculate SOC stock change emissions, ranked in
-order from strongest to weakest.
-"""
+_CARBON_STOCK_TERM_ID = 'organicCarbonPerHa'
 
 _SITE_TYPE_SYSTEMS_MAPPING = {
     SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
@@ -128,98 +100,37 @@ def _emission(
     return emission
 
 
-def _should_run(cycle: dict) -> tuple[bool, str, dict]:
+def run(cycle: dict) -> list[dict]:
     """
-    Determine if calculations should run for a given [Cycle](https://www.hestia.earth/schema/Cycle) based on SOC stock
-    and emissions data.
+    Run the `ipcc2019.co2ToAirSoilOrganicCarbonStockChangeManagementChange`.
 
     Parameters
     ----------
     cycle : dict
-        The cycle dictionary for which the calculations will be evaluated.
+        A HESTIA (Cycle node)[https://www.hestia.earth/schema/Cycle].
 
     Returns
     -------
-    tuple[bool, str, dict]
-        `(should_run, cycle_id, inventory)`
+    list[dict]
+        A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
     """
-    cycle_id = cycle.get("@id")
-    site = _get_site(cycle)
-    soc_measurements = [node for node in site.get("measurements", []) if _validate_soc_measurement(node)]
-    cycles = related_cycles(site)
-
-    seed = gen_seed(site)  # All cycles linked to the same site should be consistent
-    rng = random.default_rng(seed)
-
-    site_type = site.get("siteType")
-    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
-        cumulative_nodes_term_match(
-            cycle.get("practices", []),
-            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
-            cumulative_threshold=0
-        ) for cycle in cycles
-    )
-
-    has_soc_measurements = len(soc_measurements) > 0
-    has_cycles = len(cycles) > 0
-    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
-
-    should_compile_inventory = all([
-        has_soil,
-        has_cycles,
-        has_functional_unit_1_ha,
-        has_soc_measurements,
-    ])
-
-    inventory, logs = (
-        compile_inventory(
-            cycle_id,
-            cycles,
-            soc_measurements,
-            iterations=_ITERATIONS,
-            seed=rng
-        ) if should_compile_inventory else ({}, {})
+    should_run_exec = create_should_run_function(
+        _CARBON_STOCK_TERM_ID,
+        _should_compile_inventory_func,
+        should_run_measurement_func=_should_run_measurement_func
     )
 
-    has_valid_inventory = len(inventory) > 0
-    has_consecutive_years = check_consecutive(inventory.keys())
+    run_exec = create_run_function(_emission)
 
-    logRequirements(
-        cycle, model=MODEL, term=TERM_ID,
-        site_type=site_type,
-        seed=seed,
-        has_soil=has_soil,
-        has_soc_measurements=has_soc_measurements,
-        has_cycles=has_cycles,
-        has_functional_unit_1_ha=has_functional_unit_1_ha,
-        has_valid_inventory=has_valid_inventory,
-        has_consecutive_years=has_consecutive_years,
-        **logs
-    )
-
-    should_run = all([has_valid_inventory, has_consecutive_years])
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
 
+    logRequirements(cycle, model=MODEL, term=TERM_ID, **logs)
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
 
-    return should_run, cycle_id, inventory
-
-
-def _get_site(cycle: dict) -> dict:
-    """
-    Get the [Site](https://www.hestia.earth/schema/Site) data from a [Cycle](https://www.hestia.earth/schema/Cycle).
-
-    Parameters
-    ----------
-    cycle : dict
-
-    Returns
-    -------
-    str
-    """
-    return cycle.get("site", {})
+    return run_exec(cycle_id, inventory) if should_run else []
 
 
-def _validate_soc_measurement(node: dict) -> bool:
+def _should_run_measurement_func(node: dict) -> bool:
     """
     Validate a [Measurement](https://www.hestia.earth/schema/Measurement) to determine whether it is a valid
     `organicCarbonPerHa` node.
@@ -234,57 +145,60 @@ def _validate_soc_measurement(node: dict) -> bool:
     bool
         `True` if the node passes all validation criteria, `False` otherwise.
     """
-    value = node.get("value", [])
-    sd = node.get("sd", [])
-    dates = node.get("dates", [])
     return all([
-        node_term_match(node, _ORGANIC_CARBON_PER_HA_TERM_ID),
-        node.get("depthUpper") == _DEPTH_UPPER,
         node.get("depthLower") == _DEPTH_LOWER,
-        node.get("methodClassification") in (m.value for m in _VALID_MEASUREMENT_METHOD_CLASSIFICATIONS),
-        len(value) > 0,
-        len(value) == len(dates),
-        len(sd) == 0 or len(sd) == len(value),
-        all(_get_datestr_format(datestr) in _VALID_DATE_FORMATS for datestr in dates)
+        node.get("depthUpper") == _DEPTH_UPPER
     ])
 
 
-def _run(cycle_id: str, inventory: dict) -> list[dict]:
+def _should_compile_inventory_func(
+    site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]
+) -> tuple[bool, dict]:
     """
-    Calculate emissions for a specific cycle using grouped SOC stock change and share of emissions data.
-
-    The emission method tier based on the minimum measurement method tier among the SOC stock change data in the
-    grouped data.
+    Determine whether a site is suitable and has enough data to compile a carbon stock inventory.
 
     Parameters
     ----------
-    cycle_id : str
-        The "@id" field of the [Cycle node](https://www.hestia.earth/schema/Cycle).
-    grouped_data : dict
-        A dictionary containing grouped SOC stock change and share of emissions data.
+    site : dict
+        A HESTIA (Site node)[https://www.hestia.earth/schema/Site]
+    cycles : list[dict]
+        A list of HESTIA (Cycle nodes)[https://www.hestia.earth/schema/Cycle] that are related to the site.
+    carbon_stock_measurements : list[dict]
+        A list of HESTIA carbon stock (Measurement nodes)[https://www.hestia.earth/schema/Measurement] that are related
+        to the site.
 
     Returns
     -------
-    list[dict]
-        A list containing emission data calculated for the specified cycle.
+    tuple[bool, dict]
+        `(should_run, logs)`.
     """
-    rescaled_emissions = [
-        rescale_carbon_stock_change_emission(
-            group[_InventoryKey.CO2_EMISSION], group[_InventoryKey.SHARE_OF_EMISSION][cycle_id]
-        ) for group in inventory.values()
-    ]
-    total_emission = reduce(add_carbon_stock_change_emissions, rescaled_emissions)
-
-    descriptive_stats = calc_descriptive_stats(
-        total_emission.value,
-        EmissionStatsDefinition.SIMULATED,
-        decimals=6
+    site_type = site.get("siteType")
+    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
+        cumulative_nodes_term_match(
+            cycle.get("practices", []),
+            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
+            cumulative_threshold=0
+        ) for cycle in cycles
     )
 
-    method_tier = total_emission.method
-    return [_emission(method_tier=method_tier, **descriptive_stats)]
+    has_stock_measurements = len(carbon_stock_measurements) > 0
+    has_cycles = len(cycles) > 0
+    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
+
+    should_run = all([
+        has_soil,
+        has_stock_measurements,
+        has_cycles,
+        has_functional_unit_1_ha
+    ])
 
+    logs = {
+        "site_type": site_type,
+        "has_soil": has_soil,
+        "carbon_stock_term": _CARBON_STOCK_TERM_ID,
+        "has_stock_measurements": has_stock_measurements,
+        "has_cycles": has_cycles,
+        "has_functional_unit_1_ha": has_functional_unit_1_ha,
+    }
 
-def run(cycle: dict) -> list[dict]:
-    should_run, *args = _should_run(cycle)
-    return _run(*args) if should_run else []
+    return should_run, logs

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -141,10 +141,12 @@ LOOKUPS = {
         "isWoolProducingAnimal"
     ],
     "system-liveAnimal-activityCoefficient-ipcc2019": "using animal term @id",
+    "landCover": "grazedPastureGrassInputId",
     "crop-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
     "crop": "grazedPastureGrassInputId",
     "forage-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
-    "landCover": "grazedPastureGrassInputId"
+    "feedFoodAdditive": "hasEnergyContent",
+    "feedFoodAdditive-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"]
 }
 RETURNS = {
     "Input": [{