hestia-earth-models 0.64.2__py3-none-any.whl → 0.64.4__py3-none-any.whl

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_1_utils.py

@@ -26,15 +26,14 @@ from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match,
     node_lookup_match, node_term_match, group_nodes_by_year
 )
+from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.property import get_node_property
 
 from .organicCarbonPerHa_utils import (
-    check_irrigation, DEPTH_LOWER, DEPTH_UPPER, EcoClimateZone,
-    get_cover_crop_property_terms_with_cache,
-    get_residue_removed_or_burnt_terms_with_cache,
-    get_upland_rice_land_cover_terms_with_cache,
+    check_irrigation, DEPTH_LOWER, DEPTH_UPPER, get_cover_crop_property_terms_with_cache,
+    get_residue_removed_or_burnt_terms_with_cache, get_upland_rice_land_cover_terms_with_cache,
     IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE, IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE,
     IPCC_MANAGEMENT_CATEGORY_TO_GRASSLAND_MANAGEMENT_TERM_ID,
     IPCC_MANAGEMENT_CATEGORY_TO_TILLAGE_MANAGEMENT_LOOKUP_VALUE, IpccSoilCategory, IpccCarbonInputCategory,
@@ -175,15 +174,15 @@ _SOC_REFS = {
     IpccSoilCategory.SANDY_SOILS: {
         EcoClimateZone.WARM_TEMPERATE_MOIST: {"value": 36000, "uncertainty": 23, "observations": 39},
         EcoClimateZone.WARM_TEMPERATE_DRY: {"value": 10000, "uncertainty": 5, "observations": 338},
-        EcoClimateZone.COOL_TEMPERATE_MOIST: {"value": 81000, "uncertainty": 5, "observations": 334},
-        EcoClimateZone.COOL_TEMPERATE_DRY: {"value": 51000, "uncertainty": 13, "observations": 126},
+        EcoClimateZone.COOL_TEMPERATE_MOIST: {"value": 51000, "uncertainty": 13, "observations": 126},
+        EcoClimateZone.COOL_TEMPERATE_DRY: {"value": 13000, "uncertainty": 33, "observations": 10},
         EcoClimateZone.POLAR_MOIST: {"value": 27000, "uncertainty": 67, "observations": 18},
         EcoClimateZone.POLAR_DRY: {"value": 27000, "uncertainty": 67, "observations": 18},
         EcoClimateZone.BOREAL_MOIST: {"value": 10000, "uncertainty": 90},
         EcoClimateZone.BOREAL_DRY: {"value": 10000, "uncertainty": 90},
         EcoClimateZone.TROPICAL_MONTANE: {"value": 52000, "uncertainty": 34, "observations": 11},
         EcoClimateZone.TROPICAL_WET: {"value": 46000, "uncertainty": 20, "observations": 43},
-        EcoClimateZone.TROPICAL_MOIST: {"value": 27, "uncertainty": 12, "observations": 76},
+        EcoClimateZone.TROPICAL_MOIST: {"value": 27000, "uncertainty": 12, "observations": 76},
         EcoClimateZone.TROPICAL_DRY: {"value": 9000, "uncertainty": 9, "observations": 164}
     },
     IpccSoilCategory.SPODIC_SOILS: {
@@ -645,35 +644,48 @@ def should_run(site: dict) -> tuple[bool, dict, dict]:
     Returns
     -------
     tuple[bool, dict, dict]
-        A tuple containing `(should_run_, inventory, kwargs)`.
+        A tuple containing `(should_run_, inventory, kwargs, logs)`.
     """
     site_type = site.get("siteType", "")
     management_nodes = site.get("management", [])
     measurement_nodes = site.get("measurements", [])
 
+    eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
+    ipcc_soil_category = _assign_ipcc_soil_category(measurement_nodes)
+    soc_ref = _get_soc_ref_preview(ipcc_soil_category, eco_climate_zone)
+
     has_management = len(management_nodes) > 0
     has_measurements = len(measurement_nodes) > 0
 
     should_compile_inventory = all([
         site_type in _VALID_SITE_TYPES,
+        eco_climate_zone not in _EXCLUDED_ECO_CLIMATE_ZONES,
+        soc_ref or -9999 > 0,
         has_management,
         has_measurements
     ])
 
-    inventory, kwargs = (
-        _compile_inventory(site_type, management_nodes, measurement_nodes)
-        if should_compile_inventory else ({}, {})
+    inventory, inventory_logs = (
+        _compile_inventory(
+            site_type,
+            management_nodes,
+            ipcc_soil_category
+        ) if should_compile_inventory else ({}, {})
     )
-    kwargs["seed"] = gen_seed(site)
 
-    should_run_ = all([
-        kwargs.get("eco_climate_zone") not in _EXCLUDED_ECO_CLIMATE_ZONES,
-        (kwargs.get("soc_ref") or -9999) > 0,
-        any(year for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN))
-    ])
+    kwargs = {
+        "seed": gen_seed(site),
+        "eco_climate_zone": eco_climate_zone,
+        "ipcc_soil_category": ipcc_soil_category,
+    }
 
-    logs = {
+    should_run_ = any(
+        year for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN)
+    )
+
+    logs = inventory_logs | {
         "site_type": site_type,
+        "soc_ref": soc_ref,
         "has_management": has_management,
         "has_measurements": has_measurements,
         "should_compile_inventory_tier_1": should_compile_inventory,
@@ -965,7 +977,7 @@ def _calc_soc_stocks(
 
 
 def _compile_inventory(
-    site_type: str, management_nodes: list[dict], measurement_nodes: list[dict]
+    site_type: str, management_nodes: list[dict], ipcc_soil_category: IpccSoilCategory
 ) -> tuple[dict, dict]:
     """
     Builds an annual inventory of data and a dictionary of keyword arguments for the tier 1 model.
@@ -978,17 +990,14 @@ def _compile_inventory(
         A valid [site type](https://www-staging.hestia.earth/schema/Site#siteType).
     management_nodes : list[dict]
         A list of [Management nodes](https://www-staging.hestia.earth/schema/Management).
-    measurement_nodes: list[dict]
-        A list of [Measurement nodes](https://www-staging.hestia.earth/schema/Measurement).
+    ipcc_soil_category : IpccSoilCategory
+        The site's assigned IPCC soil category.
 
     Returns
     -------
     tuple[dict, dict]
-        A tuple containing `(inventory, kwargs)`.
+        A tuple containing `(inventory, logs)`.
     """
-    eco_climate_zone = _get_eco_climate_zone(measurement_nodes)
-    ipcc_soil_category = _assign_ipcc_soil_category(measurement_nodes)
-    soc_ref = _get_soc_ref_preview(ipcc_soil_category, eco_climate_zone)
     grouped_management = group_nodes_by_year(management_nodes)
 
     # If no `landCover` nodes in `site.management` use `site.siteType` to assign static `IpccLandUseCategory`.
@@ -1036,33 +1045,11 @@ def _compile_inventory(
     }
 
     inventory = merge(grouped_data, grouped_should_run)
-    kwargs = {
-        "eco_climate_zone": eco_climate_zone,
-        "ipcc_soil_category": ipcc_soil_category,
-        "run_with_site_type": run_with_site_type,
-        "soc_ref": soc_ref
+    logs = {
+        "run_with_site_type": run_with_site_type
     }
 
-    return inventory, kwargs
-
-
-def _get_eco_climate_zone(measurement_nodes: list[dict]) -> Union[EcoClimateZone, None]:
-    """
-    Get the eco-climate zone value from a list of Measurement nodes.
-
-    Parameters
-    ----------
-    measurement_nodes : list[dict]
-        A list of [Measurement nodes](https://www-staging.hestia.earth/schema/Measurement).
-
-    Returns
-    -------
-    EcoClimateZone | None
-        The eco-climate zone value if found, otherwise `None`.
-    """
-    eco_climate_zone = find_term_match(measurement_nodes, "ecoClimateZone")
-    value = get_node_value(eco_climate_zone)
-    return EcoClimateZone(value) if value else None
+    return inventory, logs
 
 
 def _assign_ipcc_soil_category(

hestia_earth/models/ipcc2019/organicCarbonPerHa_utils.py

@@ -43,25 +43,6 @@ def get_upland_rice_land_cover_terms_with_cache():
     return lru_cache()(get_upland_rice_land_cover_terms)()
 
 
-class EcoClimateZone(Enum):
-    """
-    Enum representing eco-climate zones. The value of each member of the Enum correctly corresponds with the values of
-    `ecoClimateZone` term and the `ecoClimateZone-lookup.csv`.
-    """
-    WARM_TEMPERATE_MOIST = 1
-    WARM_TEMPERATE_DRY = 2
-    COOL_TEMPERATE_MOIST = 3
-    COOL_TEMPERATE_DRY = 4
-    POLAR_MOIST = 5
-    POLAR_DRY = 6
-    BOREAL_MOIST = 7
-    BOREAL_DRY = 8
-    TROPICAL_MONTANE = 9
-    TROPICAL_WET = 10
-    TROPICAL_MOIST = 11
-    TROPICAL_DRY = 12
-
-
 class IpccSoilCategory(Enum):
     """
     Enum representing IPCC Soil Categories.

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -10,7 +10,7 @@ This version of the model will run at the Cycle level, if at least one Cycle Inp
 """
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import lookups_logs, properties_logs
@@ -41,15 +41,22 @@ REQUIREMENTS = {
             "@type": "Site",
             "siteType": "permanent pasture"
         },
-        "practices": [{
-            "@type": "Practice",
-            "value": "",
-            "term.@id": "pastureGrass",
-            "key": {
-                "@type": "Term",
-                "term.termType": "landCover"
+        "practices": [
+            {
+                "@type": "Practice",
+                "value": "",
+                "term.termType": "system"
+            },
+            {
+                "@type": "Practice",
+                "value": "",
+                "term.@id": "pastureGrass",
+                "key": {
+                    "@type": "Term",
+                    "term.termType": "landCover"
+                }
             }
-        }],
+        ],
         "inputs": [{
             "@type": "Input",
             "term.units": "kg",
@@ -142,7 +149,8 @@ LOOKUPS = {
 RETURNS = {
     "Input": [{
         "term.termType": ["crop", "forage"],
-        "value": ""
+        "value": "",
+        "isAnimalFeed": "True"
     }]
 }
 MODEL_KEY = 'pastureGrass'
@@ -151,6 +159,7 @@ MODEL_KEY = 'pastureGrass'
 def _input(term_id: str, value: float):
     node = _new_input(term_id, MODEL)
     node['value'] = [value]
+    node['isAnimalFeed'] = True
     return node
 
 
@@ -163,16 +172,14 @@ def calculate_NEwool(cycle: dict) -> float:
     return sum([value * lookup_value for (value, lookup_value) in product_values])
 
 
-def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: dict):
+def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG: float, systems: list):
     animals = get_animals_by_period(cycle)
-    REM = calculate_REM(meanDE)
-    REG = calculate_REG(meanDE)
     NEwool = calculate_NEwool(cycle)
-    NEm_feed, NEg_feed = calculate_NEfeed(cycle)
+    NEm_feed, NEg_feed, log_feed = calculate_NEfeed(cycle)
 
     animal_values = [{
-        'animalId': animal.get('term', {}).get('@id')
-    } | get_animal_values(cycle, animal, system) for animal in animals]
+        'id': animal.get('term', {}).get('@id')
+    } | get_animal_values(cycle, animal, systems) for animal in animals]
 
     GE = (
         calculate_GE(animal_values, REM, REG, NEwool, NEm_feed, NEg_feed) / (meanDE/100)
@@ -185,15 +192,11 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: dict):
         value = (GE / meanECHHV) * (list_sum(practice.get('value', [0])) / 100)
 
         logs = log_as_table([v | {
-            'practiceKeyId': key_id,
-            'REM': REM,
-            'REG': REG,
             'NEwool': NEwool,
-            'NEmFeed': NEm_feed,
-            'NEgFeed': NEg_feed,
-            'GE': GE,
-            'meanECHHV': meanECHHV,
-            'meanDE': meanDE
+            'total-feed-NEm': NEm_feed,
+            'total-feed-NEg': NEg_feed,
+            'practiceKeyId': key_id,
+            'GE': GE
         } for v in animal_values])
         animal_lookups = lookups_logs(MODEL, animals, LOOKUPS, model_key=MODEL_KEY, term=input_term_id)
         animal_properties = properties_logs(animals, properties=[
@@ -207,15 +210,19 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: dict):
             'weightAtOneYear',
             'weightAtSlaughter'
         ])
+        has_positive_feed_values = all([NEm_feed > 0, NEg_feed > 0])
 
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+                        feed_logs=log_as_table(log_feed),
+                        has_positive_feed_values=has_positive_feed_values,
                         animal_logs=logs,
                         animal_lookups=animal_lookups,
                         animal_properties=animal_properties)
 
-        logShouldRun(cycle, MODEL, input_term_id, True, model_key=MODEL_KEY)
+        should_run = all([has_positive_feed_values])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, model_key=MODEL_KEY)
 
-        return _input(input_term_id, value)
+        return _input(input_term_id, value) if should_run else None
 
     return run
 
@@ -231,6 +238,8 @@ def _should_run(cycle: dict, practices: dict):
 
     meanDE = calculate_meanDE(practices)
     meanECHHV = calculate_meanECHHV(practices)
+    REM = calculate_REM(meanDE)
+    REG = calculate_REG(meanDE)
 
     should_run = all([
         animalFeed_complete,
@@ -251,15 +260,19 @@ def _should_run(cycle: dict, practices: dict):
                         term_type_freshForage_incomplete=freshForage_incomplete,
                         has_cycle_inputs_feed=has_cycle_inputs_feed,
                         all_animals_have_value=all_animals_have_value,
-                        meanDE=calculate_meanDE(practices, term=term_id),
-                        meanECHHV=calculate_meanECHHV(practices, term=term_id))
+                        grass_MeanDE=calculate_meanDE(practices, term=term_id),
+                        grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                        grass_REM=REM,
+                        grass_REG=REG)
 
         logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
-    return should_run, meanDE, meanECHHV, systems[0] if systems else None
+    return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
 def run(cycle: dict):
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
-    should_run, meanDE, meanECHHV, system = _should_run(cycle, practices)
-    return list(map(_run_practice(cycle, meanDE, meanECHHV, system), practices)) if should_run else []
+    should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, practices)
+    return non_empty_list(
+        map(_run_practice(cycle, meanDE, meanECHHV, REM, REG, systems), practices)
+    ) if should_run else []

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -25,12 +25,20 @@ def _get_grouping(animal: dict) -> str:
     return get_lookup_value(term, 'ipcc2019AnimalTypeGrouping', model=MODEL, model_key=MODEL_KEY)
 
 
-def _get_activityCoefficient(cycle: dict, animal: dict, system: dict) -> float:
+def _get_activityCoefficient(animal: dict, systems: list) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
-    system_id = system.get('term', {}).get('@id')
     lookup = download_lookup('system-liveAnimal-activityCoefficient-ipcc2019.csv')
-    activityCoefficient = safe_parse_float(get_table_value(lookup, 'termid', system_id, column_name(term_id)), 0)
+
+    activityCoefficient = list_sum([
+        safe_parse_float(
+            get_table_value(lookup, 'termid', system.get('term', {}).get('@id'), column_name(term_id)),
+            0
+        ) * list_sum(system.get('value', [0]))
+        for system in systems
+    ]) / list_sum([
+        list_sum(system.get('value', [0])) for system in systems
+    ])
 
     return activityCoefficient
 
@@ -49,16 +57,16 @@ def _calculate_NEm(cycle: dict, animal: dict) -> float:
     return NEm
 
 
-def _calculate_NEa_cattleAndBuffalo(cycle: dict, animal: dict, system: dict, NEm: float) -> float:
-    activityCoefficient = _get_activityCoefficient(cycle, animal, system)
+def _calculate_NEa_cattleAndBuffalo(cycle: dict, animal: dict, systems: list, NEm: float) -> float:
+    activityCoefficient = _get_activityCoefficient(animal, systems)
 
     NEa = activityCoefficient * NEm
 
     return NEa
 
 
-def _calculate_NEa_sheepAndGoat(cycle: dict, animal: dict, system: dict, _NEm: float) -> float:
-    activityCoefficient = _get_activityCoefficient(cycle, animal, system)
+def _calculate_NEa_sheepAndGoat(cycle: dict, animal: dict, systems: list, _NEm: float) -> float:
+    activityCoefficient = _get_activityCoefficient(animal, systems)
 
     liveweightPerHead = get_node_property(animal, 'liveweightPerHead', False).get('value', 0)
     animal_value = animal.get('value', 0)
@@ -74,9 +82,9 @@ _NEa_BY_GROUPING = {
 }
 
 
-def _calculate_NEa(cycle: dict, animal: dict, system: dict, NEm: float) -> float:
+def _calculate_NEa(cycle: dict, animal: dict, systems: list, NEm: float) -> float:
     grouping = _get_grouping(animal)
-    return _NEa_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal, system, NEm)
+    return _NEa_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal, systems, NEm)
 
 
 def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
@@ -234,7 +242,7 @@ def _calculate_feed_meanDE(log_node: dict, input: dict) -> float:
     debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 energyContent=energyContent,
                 energyDigestibility=energyDigestibility,
-                meanDE=meanDE)
+                feed_MeanDE=meanDE)
 
     return meanDE
 
@@ -246,7 +254,7 @@ def _calculate_NEfeed_m(log_node: dict, input: dict, meanDE: float) -> float:
     REm = calculate_REM(energyDigestibility * 100)
 
     debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                REm=REm)
+                feed_REm=REm)
 
     input_value = list_sum(input.get('value'))
     return meanDE * REm * input_value
@@ -259,7 +267,7 @@ def _calculate_NEfeed_g(log_node: dict, input: dict, meanDE: float) -> float:
     REg = calculate_REG(energyDigestibility * 100)
 
     debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                REg=REg)
+                feed_REg=REg)
 
     input_value = list_sum(input.get('value'))
     return meanDE * REg * input_value
@@ -267,21 +275,29 @@ def _calculate_NEfeed_g(log_node: dict, input: dict, meanDE: float) -> float:
 
 def calculate_NEfeed(node: dict) -> tuple:
     inputs = get_feed_inputs(node)
+
     # calculate meanDE for each input first
-    inputs = [(input, _calculate_feed_meanDE(node, input)) for input in inputs]
-    NEfeed_m = sum([
-        _calculate_NEfeed_m(node, input, meanDE) for (input, meanDE) in inputs
-    ]) if len(inputs) > 0 else 0
-    NEfeed_g = sum([
-        _calculate_NEfeed_g(node, input, meanDE) for (input, meanDE) in inputs
-    ]) if len(inputs) > 0 else 0
+    values = [
+        (i, {'id': i.get('term', {}).get('@id'), 'meanDE': _calculate_feed_meanDE(node, i)})
+        for i in inputs
+    ]
+    values = [
+        value | {
+            'NEm': _calculate_NEfeed_m(node, input, value.get('meanDE')),
+            'NEg': _calculate_NEfeed_g(node, input, value.get('meanDE'))
+        }
+        for input, value in values
+    ]
+
+    NEfeed_m = sum([value.get('NEm') for value in values]) if len(values) > 0 else 0
+    NEfeed_g = sum([value.get('NEg') for value in values]) if len(values) > 0 else 0
 
-    return (NEfeed_m, NEfeed_g)
+    return (NEfeed_m, NEfeed_g, values)
 
 
-def get_animal_values(cycle: dict, animal: dict, system: dict) -> dict:
+def get_animal_values(cycle: dict, animal: dict, systems: list) -> dict:
     NEm = _calculate_NEm(cycle, animal)
-    NEa = _calculate_NEa(cycle, animal, system, NEm)
+    NEa = _calculate_NEa(cycle, animal, systems, NEm)
     NEl = _calculate_NEl(cycle, animal)
     NEwork = _calculate_NEwork(cycle, animal, NEm)
     NEp = _calculate_NEp(cycle, animal, NEm)