hestia-earth-models 0.72.0__py3-none-any.whl → 0.72.1__py3-none-any.whl

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -1,8 +1,7 @@
-from typing import List, Optional, Tuple
-
 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 typing import List, Optional, Tuple
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
 from hestia_earth.models.utils.blank_node import get_lookup_value
@@ -89,6 +88,23 @@ def _indicator_factors(impact_assessment: dict, indicator: dict):
     }
 
 
+def _map_input_ids(value: dict) -> set[str]:
+    return set(map(lambda i: i.get('@id'), value.get('inputs', [])))
+
+
+def _count_duplicate_indicators(reference_indicator: dict, indicators: list) -> int:
+    """
+    Counts the number of `reference_indicator` indicators found in a list of indicators.
+    Uses indicator.term.@id and indicator.inputs to determine uniqueness.
+    """
+    return sum([
+        1
+        for i in indicators
+        if (i["term"]["@id"] == reference_indicator["term"]["@id"]) and (
+                    _map_input_ids(i) == _map_input_ids(reference_indicator))
+    ])
+
+
 def _indicator(value: float) -> dict:
     indicator = _new_indicator(TERM_ID, MODEL)
     indicator['value'] = value
@@ -115,7 +131,7 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list[dict]]:
     processed_indicators = [{
         "indicator": indicator['term']['@id'],
         "valid-indicator": _valid_indicator(indicator),
-        "one-indicator-for-category": sum(1 for i in indicators if i['term']['@id'] == indicator['term']['@id']) == 1,
+        "one-indicator-for-category": _count_duplicate_indicators(indicator, indicators) == 1,
         "indicator-pef-category": indicator.get('term', {}).get('@id'),
     } | _indicator_factors(impact_assessment, indicator) for indicator in indicators]
 

hestia_earth/models/hestia/landCover.py

@@ -148,7 +148,7 @@ def cap_values(dictionary: dict, lower_limit: float = 0, upper_limit: float = 1)
 
 def site_area_sum_to_100(dict_of_percentages: dict):
     return False if dict_of_percentages == {} else (
-        math.isclose(sum(dict_of_percentages.values()), 1.0, rel_tol=0.01) or
+        math.isclose(sum(dict_of_percentages.values()), 1.0, rel_tol=0.05) or
         math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01)
     )
 
@@ -581,6 +581,14 @@ def _get_year_from_landCover(node: dict):
     return int(date[:4])
 
 
+def _scale_site_area_errors(site_area: dict) -> dict:
+    """Redistribute the result of any rounding error in proportion to the other land use types."""
+    # Positive errors would not have been capped, so won't be missing.
+    negative_errors = [v for v in site_area.values() if v < 0.0]
+    return {k: v + negative_errors[0] * v for k, v in site_area.items()} \
+        if negative_errors and abs(negative_errors[0]) < 1 and all([v < 1 for v in site_area.values()]) else site_area
+
+
 def _should_run_historical_land_use_change(site: dict, nodes: list, land_use_type: str) -> tuple[bool, dict]:
     # Assume a single management node for single-cropping.
     return _should_run_historical_land_use_change_single_crop(
@@ -728,7 +736,7 @@ def _should_run_historical_land_use_change_single_crop(
         if land_type != land_use_type
     }
     site_area[land_use_type] = 1 - sum(site_area.values())
-    capped_site_area = cap_values(dictionary=site_area, lower_limit=0, upper_limit=1)
+    capped_site_area = cap_values(dictionary=_scale_site_area_errors(site_area))
 
     sum_of_site_areas_is_100 = site_area_sum_to_100(capped_site_area)
     site_type_allowed = site.get("siteType") in SITE_TYPES

hestia_earth/models/ipcc2019/co2ToAirUreaHydrolysis.py

@@ -2,7 +2,8 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 from hestia_earth.utils.model import find_term_match
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import multiply_values
 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.term import get_urea_terms
@@ -36,66 +37,65 @@ def _emission(value: float):
     return emission
 
 
-def _urea_input_value(cycle: dict):
-    def exec(data: dict):
-        term_id = data.get('id')
-        values = data.get('values')
-        coeff = safe_parse_float(get_term_lookup(term_id, LOOKUPS['inorganicFertiliser'][2]), 1)
-        debugValues(cycle, model=MODEL, term=TERM_ID,
-                    product=term_id,
-                    coefficient=coeff)
-        return list_sum(values) * coeff
-    return exec
+def _urea_emission_factor(term_id: str):
+    return safe_parse_float(get_term_lookup(term_id, LOOKUPS['inorganicFertiliser'][2]), None)
 
 
-def _run(cycle: dict, urea_values: list):
-    value = list_sum(list(map(_urea_input_value(cycle), urea_values)))
+def _run(urea_values: list):
+    value = list_sum([v.get('value') * v.get('factor') for v in urea_values if v.get('value')])
     return [_emission(value)]
 
 
-def _get_urea_values(cycle: dict, inputs: list, term_id: str):
+def _get_urea_value(cycle: dict, inputs: list, term_id: str):
     inputs = list(filter(lambda i: i.get('term', {}).get('@id') == term_id, inputs))
     values = [list_sum(i.get('value'), 0) for i in inputs if len(i.get('value', [])) > 0]
-    return [0] if len(inputs) == 0 and _is_term_type_complete(cycle, 'fertiliser') else values
+    return list_sum(values, default=None)
 
 
 def _should_run(cycle: dict):
+    is_fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
     inputs = cycle.get('inputs', [])
     term_ids = get_urea_terms()
 
     country_id = cycle.get('site', {}).get('country', {}).get('@id')
     urea_share = get_country_breakdown(MODEL, TERM_ID, country_id, LOOKUPS['inorganicFertiliser'][0])
     uan_share = get_country_breakdown(MODEL, TERM_ID, country_id, LOOKUPS['inorganicFertiliser'][1])
-    urea_unspecified_as_n = list_sum(find_term_match(inputs, UNSPECIFIED_TERM_ID).get('value', []))
+    urea_unspecified_as_n = list_sum(find_term_match(inputs, UNSPECIFIED_TERM_ID).get('value', []), default=None)
 
     urea_values = [
         {
-            'id': id,
-            'values': _get_urea_values(cycle, inputs, id)
-        } for id in term_ids
+            'id': term_id,
+            'value': _get_urea_value(cycle, inputs, term_id),
+            'factor': _urea_emission_factor(term_id)
+        } for term_id in term_ids
     ] + non_empty_list([
         {
             'id': 'ureaKgN',
-            'values': [urea_unspecified_as_n * urea_share]
-        } if urea_share is not None else None,
+            'value': multiply_values([urea_unspecified_as_n, urea_share]),
+            'factor': _urea_emission_factor('ureaKgN')
+        },
         {
             'id': 'ureaAmmoniumNitrateKgN',
-            'values': [urea_unspecified_as_n * uan_share]
-        } if urea_share is not None else None
-    ] if urea_unspecified_as_n > 0 else [])
-    has_urea_value = any([len(data.get('values')) > 0 for data in urea_values])
+            'value': multiply_values([urea_unspecified_as_n, uan_share]),
+            'factor': _urea_emission_factor('ureaAmmoniumNitrateKgN')
+        }
+    ] if urea_unspecified_as_n is not None else [])
+
+    has_urea_value = any([data.get('value') is not None for data in urea_values])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_term_type_fertiliser_complete=is_fertiliser_complete,
                     has_urea_value=has_urea_value,
+                    urea_values=log_as_table(urea_values),
                     urea_unspecified_as_n=urea_unspecified_as_n,
                     urea_share=urea_share,
                     uan_share=uan_share)
 
-    should_run = all([has_urea_value])
+    should_run = has_urea_value or is_fertiliser_complete
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, urea_values
 
 
 def run(cycle: dict):
     should_run, urea_values = _should_run(cycle)
-    return _run(cycle, urea_values) if should_run else []
+    return _run(urea_values) if should_run else []