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

hestia_earth/models/ecoalimV9/cycle.py

@@ -81,6 +81,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoalim_values(ecoalim_key, 'emission')
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
             debugValues(cycle, model=MODEL, term=emission_term_id, model_key=MODEL_KEY,
                         value=value,
                         coefficient=coefficient,

hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -81,6 +81,7 @@ def _add_indicator(cycle: dict, input: dict):
         indicators = ecoalim_values(ecoalim_key, 'resourceUse')
         for indicator_term_id, value in indicators:
             # log run on each indicator so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=indicator_term_id)
             debugValues(cycle, model=MODEL, term=indicator_term_id, model_key=MODEL_KEY,
                         value=value,
                         coefficient=coefficient,

hestia_earth/models/ecoinventV3/__init__.py

@@ -89,6 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
             debugValues(cycle, model=MODEL, term=emission_term_id,
                         value=value,
                         coefficient=coefficient,

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -89,6 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
             debugValues(cycle, model=MODEL, term=emission_term_id,
                         value=value,
                         coefficient=coefficient,

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 []

hestia_earth/models/linkedImpactAssessment/emissions.py

@@ -77,6 +77,7 @@ def _run_emission(cycle: dict, emission_term_id: str, data: dict):
 
         # log run on each emission so we know it did run
         details = values.get('details', {})
+        logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
         debugValues(cycle, model=model, term=emission_term_id,
                     value=value,
                     coefficient=1,

hestia_earth/models/linkedImpactAssessment/utils.py

@@ -8,14 +8,14 @@ from hestia_earth.models.utils.input import load_impacts
 from . import MODEL
 
 
-def _indicator(term_id: str, value: float, input: dict):
-    indicator = _new_indicator(term_id, MODEL)
+def _indicator(model: str, term_id: str, value: float, input: dict):
+    indicator = _new_indicator(term_id, model)
     indicator['value'] = value
     indicator['inputs'] = [input]
     return indicator
 
 
-def _run_indicators(impact_assessment: dict, product: dict, term_id: str):
+def _run_indicators(impact_assessment: dict, product: dict, term_id: str, model: str):
     def run(values: list):
         input = values[0].get('input').get('term', {})
         indicator = values[0].get('indicator')
@@ -24,22 +24,22 @@ def _run_indicators(impact_assessment: dict, product: dict, term_id: str):
             for value in values
         ])
         value = convert_value_from_cycle(
-            impact_assessment, product, sum_values(values_from_cycle), model=MODEL, term_id=term_id
+            impact_assessment, product, sum_values(values_from_cycle), model=model, term_id=term_id
         )
 
         # show values per input in the logs
-        debugValues(impact_assessment, model=MODEL, term=term_id,
+        debugValues(impact_assessment, model=model, term=term_id,
                     value=value,
                     coefficient=1,
                     input=input.get('@id'))
 
         return (
-            _indicator(term_id, value, input) | _include(indicator, ['landCover', 'previousLandCover'])
+            _indicator(model, term_id, value, input) | _include(indicator, ['landCover', 'previousLandCover'])
         ) if value is not None else None
     return run
 
 
-def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str):
+def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str, model: str):
     cycle = impact_assessment.get('cycle', {})
 
     # group all indicators per `landCover` and `previousLandCover`
@@ -71,7 +71,7 @@ def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str)
     ])
     has_indicators = bool(valid_indicators)
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
+    logRequirements(impact_assessment, model=model, term=term_id,
                     indicators=log_as_table([
                         {
                             'indicator-id': value.get('indicator').get('term', {}).get('@id'),
@@ -83,30 +83,30 @@ def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str)
                     ]))
 
     should_run = all([has_indicators])
-    logShouldRun(impact_assessment, MODEL, term_id, should_run)
+    logShouldRun(impact_assessment, model, term_id, should_run)
 
     return non_empty_list(flatten(
-        map(_run_indicators(impact_assessment, product, term_id), grouped_indicators.values())
+        map(_run_indicators(impact_assessment, product, term_id, model), grouped_indicators.values())
     ))
 
 
-def _should_run_inputs_production(impact_assessment: dict, term_id: str):
+def _should_run_inputs_production(impact_assessment: dict, term_id: str, model: str):
     product = get_product(impact_assessment) or {}
     product_id = product.get('term', {}).get('@id')
 
     product_value = list_sum(product.get('value', []), default=None)
     economic_value = product.get('economicValueShare')
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
+    logRequirements(impact_assessment, model=model, term=term_id,
                     product_id=product_id,
                     product_value=product_value,
                     product_economicValueShare=economic_value)
 
     should_run = all([product, product_value, economic_value])
-    logShouldRun(impact_assessment, MODEL, term_id, should_run)
+    logShouldRun(impact_assessment, model, term_id, should_run)
     return should_run, product
 
 
-def run_inputs_production(impact_assessment: dict, term_id: str):
-    should_run, product = _should_run_inputs_production(impact_assessment, term_id)
-    return _run_inputs_production(impact_assessment, product, term_id) if should_run else []
+def run_inputs_production(impact_assessment: dict, term_id: str, model: str = MODEL):
+    should_run, product = _should_run_inputs_production(impact_assessment, term_id, model)
+    return _run_inputs_production(impact_assessment, product, term_id, model) if should_run else []