hestia-earth-models 0.75.1__tar.gz → 0.75.2__tar.gz

{hestia_earth_models-0.75.1/hestia_earth_models.egg-info → hestia_earth_models-0.75.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_models
-Version: 0.75.1
+Version: 0.75.2
 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

{hestia_earth_models-0.75.1 → hestia_earth_models-0.75.2}/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-0.75.1 → hestia_earth_models-0.75.2}/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-0.75.1 → hestia_earth_models-0.75.2}/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-0.75.1 → hestia_earth_models-0.75.2}/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-0.75.1 → hestia_earth_models-0.75.2}/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-0.75.1 → hestia_earth_models-0.75.2}/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