hestia-earth-models 0.75.1__py3-none-any.whl → 0.75.2__py3-none-any.whl

hestia_earth/models/config/Cycle.json

@@ -1294,6 +1294,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "emissionsToAirOrganicSoilBurning",
+        "runStrategy": "always",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "schmidt2007",

hestia_earth/models/cycle/product/economicValueShare.py

@@ -1,5 +1,5 @@
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, to_precision
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.term import get_lookup_value
@@ -43,7 +43,7 @@ MIN_COMPLETE_VALUE = 80  # when the products are complete lower the min threshol
 
 
 def _product(product: dict, value: float):
-    return product | {MODEL_KEY: value}
+    return product | {MODEL_KEY: to_precision(value, 2 if value < 1 else 3 if value < 10 else 4)}
 
 
 def _is_complete(cycle: dict): return cycle.get('completeness', {}).get('product', False)
@@ -57,11 +57,11 @@ def _total_evs(products: list): return sum([p.get(MODEL_KEY, 0) for p in product
 
 def _product_with_value(product: dict):
     value = product.get(MODEL_KEY, lookup_share(MODEL_KEY, product))
-    return product | {MODEL_KEY: value} if value is not None else product
+    return _product(product, value) if value is not None else product
 
 
 def _rescale_value(products: list, total: float):
-    return list(map(lambda p: {**p, MODEL_KEY: p.get(MODEL_KEY) * 100 / total}, products))
+    return list(map(lambda p: _product(p, p.get(MODEL_KEY) * 100 / total), products))
 
 
 def _should_run_by_default(cycle: dict, products: list):

hestia_earth/models/geospatialDatabase/histosol.py

@@ -1,7 +1,10 @@
-from hestia_earth.schema import MeasurementMethodClassification
+from hestia_earth.schema import MeasurementMethodClassification, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.blank_node import get_node_value
+from hestia_earth.utils.tools import pick
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement, total_other_soilType_value
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -16,10 +19,10 @@ REQUIREMENTS = {
         "none": {
             "measurements": [{
                 "@type": "Measurement",
-                "value": "100",
+                "value": "> 0",
                 "depthUpper": "0",
                 "depthLower": "30",
-                "term.termType": "soilType"
+                "term.termType": ["soilType", "usdaSoilType"]
             }]
         }
     }
@@ -39,12 +42,14 @@ EE_PARAMS = {
     'reducer': 'mean'
 }
 BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture Organization of the United Nations (FAO).'  # noqa: E501
+_DEPTH_UPPER = 0
+_DEPTH_LOWER = 30
 
 
 def _measurement(site: dict, value: float):
     measurement = _new_measurement(term=TERM_ID, value=value)
-    measurement['depthUpper'] = 0
-    measurement['depthLower'] = 30
+    measurement['depthUpper'] = _DEPTH_UPPER
+    measurement['depthLower'] = _DEPTH_LOWER
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 
@@ -58,15 +63,30 @@ def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
 
-    total_measurements_value = total_other_soilType_value(site.get('measurements', []), TERM_ID)
+    measurements = filter_list_term_type(site.get('measurements', []), [
+        TermTermType.SOILTYPE,
+        TermTermType.USDASOILTYPE
+    ])
+    measurements = [m for m in measurements if all([
+        m.get('depthUpper', -1) == _DEPTH_UPPER,
+        m.get('depthLower', 0) == _DEPTH_LOWER,
+        get_node_value(m) > 0
+    ])]
+    has_soil_type_measurements = len(measurements) > 0
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
                     below_max_area_size=below_max_area_size,
-                    total_soilType_measurements_value=total_measurements_value,
-                    total_soilType_measurements_value_is_0=total_measurements_value == 0)
+                    has_soil_type_measurements=has_soil_type_measurements,
+                    soil_type_measurements=log_as_table([
+                        {
+                            'id': m.get('term', {}).get('@id'),
+                            'termType': m.get('term', {}).get('termType'),
+                            'value': get_node_value(m)
+                        } | pick(m, ['depthUpper', 'depthLower']) for m in measurements
+                    ]))
 
-    should_run = all([contains_geospatial_data, below_max_area_size, total_measurements_value == 0])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_soil_type_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/hestia/aboveGroundCropResidueTotal.py

@@ -9,8 +9,8 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidue"}],
-        "products": [{"@type": "Product", "value": "", "term.termType": "cropResidueManagement"}]
+        "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}],
+        "products": [{"@type": "Product", "value": "", "term.termType": "cropResidue"}]
     }
 }
 RETURNS = {

hestia_earth/models/hestia/soilClassification.py

@@ -19,16 +19,18 @@ from . import MODEL
 REQUIREMENTS = {
     "Site": {
         "optional": {
-            "measurements": [{
-                "@type": "Measurement",
-                "value": "",
-                "depthUpper": "",
-                "depthLower": "",
-                "term.termType": "soilType",
-                "optional": {
-                    "dates": ""
+            "measurements": [
+                {
+                    "@type": "Measurement",
+                    "value": "",
+                    "depthUpper": "",
+                    "depthLower": "",
+                    "term.termType": ["soilType", "usdaSoilType"],
+                    "optional": {
+                        "dates": ""
+                    }
                 }
-            }]
+            ]
         }
     }
 }
@@ -41,7 +43,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "soilType": "IPCC_SOIL_CATEGORY"
+    "soilType": "IPCC_SOIL_CATEGORY",
+    "usdaSoilType": "IPCC_SOIL_CATEGORY"
 }
 TERM_ID = 'organicSoils,mineralSoils'
 
@@ -50,6 +53,10 @@ ORGANIC_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[0]
 MINERAL_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[1]
 METHOD = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
 
+_INPUT_TERM_TYPES = (
+    TermTermType.SOILTYPE,
+    TermTermType.USDASOILTYPE
+)
 TARGET_LOOKUP_VALUE = IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE[IpccSoilCategory.ORGANIC_SOILS]
 
 IS_100_THRESHOLD = 99.5
@@ -65,6 +72,7 @@ def _measurement(term_id: str, **kwargs):
 
 class _SoilTypeDatum(NamedTuple):
     term_id: str
+    term_type: str
     depth_upper: float
     depth_lower: float
     dates: list[str]
@@ -105,14 +113,16 @@ def _extract_soil_type_data(node: dict) -> _SoilTypeDatum:
     depth_upper = node.get("depthUpper")
     depth_lower = node.get("depthLower")
     depth_interval = (depth_upper, depth_lower)
+    term_type = node.get("term", {}).get("termType")
 
     return _SoilTypeDatum(
         term_id=node.get("term", {}).get("@id"),
+        term_type=term_type,
         depth_upper=depth_upper,
         depth_lower=depth_lower,
         dates=node.get("dates", []),
         value=get_node_value(node),
-        is_organic=node_lookup_match(node, LOOKUPS["soilType"], TARGET_LOOKUP_VALUE),
+        is_organic=node_lookup_match(node, LOOKUPS[term_type], TARGET_LOOKUP_VALUE),
         is_complete_depth=all(depth is not None for depth in depth_interval),
         is_standard_depth=depth_interval in STANDARD_DEPTHS,
     )
@@ -126,7 +136,7 @@ def _classify_soil_type_data(soil_type_data: list[_SoilTypeDatum]):
 
     def classify(inventory: _SoilTypeInventory, datum: _SoilTypeDatum) -> _SoilTypeInventory:
         """
-        Sum the values of organic and mineral `soilType` Measurements by depth interval and date.
+        Sum the values of organic and mineral `soilType`/`usdaSoilType` Measurements by depth interval and date.
         """
         keys = _soil_type_data_to_inventory_keys(datum)
 
@@ -252,7 +262,7 @@ def _filter_data_by_depth_availability(data: list[_SoilTypeDatum]):
 
 def _should_run(site: dict):
     soil_type_nodes = split_nodes_by_dates(
-        filter_list_term_type(site.get("measurements", []), TermTermType.SOILTYPE)
+        get_soil_type_nodes(site)
     )
 
     filtered_by, soil_type_data = _filter_data_by_depth_availability(
@@ -280,6 +290,14 @@ def _should_run(site: dict):
     return should_run, inventory
 
 
+def get_soil_type_nodes(site: dict) -> list[dict]:
+    measurements = site.get("measurements", [])
+    return next(
+        (nodes for term_type in _INPUT_TERM_TYPES if (nodes := filter_list_term_type(measurements, term_type))),
+        []
+    )
+
+
 _INVENTORY_KEY_TO_FIELD_KEY = {
     "depth_upper": "depthUpper",
     "depth_lower": "depthLower",

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -200,6 +200,7 @@ def _run_practice(
         GE = (
             calculate_GE([values], REM, REG, NEwool, NEm_feed, NEg_feed) / (meanDE/100)
         ) if meanDE else 0
+        has_positive_GE_value = GE >= 0
 
         value = (GE / meanECHHV) * (list_sum(practice.get('value', [0])) / 100)
 
@@ -229,11 +230,12 @@ def _run_practice(
         logRequirements(cycle, model=MODEL, term=input_term_id, animalId=animal.get('animalId'), model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),
                         has_positive_feed_values=has_positive_feed_values,
+                        has_positive_GE_value=has_positive_GE_value,
                         animal_logs=logs,
                         animal_lookups=animal_lookups,
                         animal_properties=animal_properties)
 
-        should_run = all([has_positive_feed_values])
+        should_run = all([has_positive_feed_values, has_positive_GE_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, animalId=animal.get('animalId'), model_key=MODEL_KEY)
 
         return _input(input_term_id, value) if should_run else None