hestia-earth-models 0.73.8__py3-none-any.whl → 0.74.0__py3-none-any.whl

hestia_earth/models/ecoinventV3AndEmberClimate/cycle.py

@@ -0,0 +1,144 @@
+from functools import reduce
+from hestia_earth.utils.tools import list_sum, flatten
+from hestia_earth.schema import EmissionMethodTier, TermTermType
+from hestia_earth.utils.blank_node import group_by_keys
+
+from hestia_earth.models.log import logShouldRun, logRequirements, debugValues
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.term import get_electricity_grid_mix_terms
+from .utils import get_input_coefficient
+from ..ecoinventV3.utils import get_input_mappings, ecoinvent_values
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.electricityFuel": "True",
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "inputs": [{
+            "@type": "Input",
+            "term.@id": ["electricityGridMarketMix", "electricityGridRenewableMix"],
+            "value": "> 0",
+            "none": {
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }],
+        "optional": {
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{
+                    "@type": "Input",
+                    "term.@id": ["electricityGridMarketMix", "electricityGridRenewableMix"],
+                    "value": "> 0",
+                    "none": {
+                        "fromCycle": "True",
+                        "producedInCycle": "True"
+                    }
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "term": "",
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": "",
+        "animals": ""
+    }]
+}
+LOOKUPS = {
+    "emission": "inputProductionGroupId",
+    "electricity": "ecoinventMapping",
+    "region-ember-energySources": "",
+    "ember-ecoinvent-mapping": ["ember", "ecoinventId", "ecoinventName"]
+}
+
+MODEL_KEY = 'cycle'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    emission['inputs'] = [input.get('term')]
+    if input.get('operation'):
+        emission['operation'] = input.get('operation')
+    if input.get('animal'):
+        emission['animals'] = [input.get('animal')]
+    return emission
+
+
+def _add_emission(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+    # TODO: as inputs are grouped, there could be more than 1 country
+    country_id = input.get('country', cycle.get('site', {}).get('country', {})).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        ecoinventName, _coefficient = mapping
+        # recalculate the coefficient using the country and year if it should be included
+        coefficient = get_input_coefficient(MODEL, cycle, country_id, ecoinventName) if _coefficient > 0 else 0
+        emissions = ecoinvent_values(ecoinventName, TermTermType.EMISSION)
+        for emission_term_id, data 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=data.get('value'),
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            prev[emission_term_id] = prev.get(emission_term_id, 0) + (data.get('value') * coefficient)
+        return prev
+    return add
+
+
+def _run_input(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+
+    def run(inputs: list):
+        input = inputs[0]
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        input_term_id = input.get('term', {}).get('@id')
+        mappings = get_input_mappings(MODEL, input)
+        has_mappings = len(mappings) > 0
+
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
+
+        logRequirements(cycle, model=MODEL, term=input_term_id,
+                        has_ecoinvent_mappings=has_mappings,
+                        ecoinvent_mappings=';'.join([v[0] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        termType_electricityFuel_complete=electricity_complete,
+                        input_value=input_value)
+
+        should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+
+        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        return [
+            _emission(term_id, value * input_value, input)
+            for term_id, value in grouped_emissions.items()
+        ]
+    return run
+
+
+def run(cycle: dict):
+    terms = get_electricity_grid_mix_terms()
+    inputs = get_background_inputs(cycle)
+    # only keep the inputs matching the grid terms
+    inputs = [i for i in inputs if i.get('term', {}).get('@id') in terms]
+    grouped_inputs = group_by_keys(inputs, ['term', 'operation', 'animal'])
+    return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia_earth/models/emepEea2019/utils.py

@@ -1,12 +1,11 @@
-from functools import reduce
 from hestia_earth.schema import TermTermType, SiteSiteType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.blank_node import group_by_keys
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.completeness import _is_term_type_complete
-from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from hestia_earth.models.utils.emission import _new_emission
@@ -90,7 +89,7 @@ def get_fuel_inputs(term_id: str, cycle: dict, lookup_col: str):
 
 
 def group_fuel_inputs(inputs: list):
-    return reduce(group_by_keys(['input-id', 'operation-id']), inputs, {}) if len(inputs) > 0 else None
+    return group_by_keys(inputs, ['input-id', 'operation-id']) if len(inputs) > 0 else None
 
 
 def _get_emissions_factor(animal: dict, lookup_col: str) -> float:

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -88,20 +88,18 @@ 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.
+    Uses indicator.term.@id and indicator.key 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))
+        if all([
+            i["term"]["@id"] == reference_indicator["term"]["@id"],
+            i.get("key", {}).get("@id") == reference_indicator.get("key", {}).get("@id")
+        ])
     ])
 
 

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -1,11 +1,11 @@
-from functools import reduce
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils.blank_node import group_by_keys
+from hestia_earth.models.utils import unique_values, _omit, _include
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL
@@ -20,7 +20,7 @@ REQUIREMENTS = {
                 "ionisingCompoundsToWaterInputsProduction",
                 "ionisingCompoundsToSaltwaterInputsProduction"
             ],
-            "inputs": [{"@type": "Term", "term.termType": "waste", "term.units": "kg"}]
+            "key": {"@type": "Term", "term.termType": "waste", "term.units": "kg"}
         }]
     }
 }
@@ -34,6 +34,7 @@ LOOKUPS = {
 RETURNS = {
     "Indicator": [{
         "value": "",
+        "key": "",
         "inputs": ""
     }]
 }
@@ -41,31 +42,32 @@ RETURNS = {
 TERM_ID = 'ionisingRadiationKbqU235Eq'
 
 
-def _valid_waste(input: dict) -> bool:
-    return input.get('units', '').startswith("kg") and input.get('termType', '') == TermTermType.WASTE.value
-
-
-def _valid_emission(emission: dict) -> bool:
-    return len(emission.get('inputs', [])) == 1 and isinstance(_node_value(emission), (int, float))
-
-
-def _indicator(value: float, input: dict) -> dict:
+def _indicator(value: float, key: dict, inputs: list) -> dict:
     indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['key'] = key
     indicator['value'] = value
-    indicator['inputs'] = [input]
+    if inputs:
+        indicator['inputs'] = inputs
     return indicator
 
 
 def _run(emissions: list) -> list[dict]:
     indicators = [
-        _indicator(value=list_sum([emission['value'] * emission['coefficient'] for emission in emission_group]),
-                   input=emission_group[0]['input'])
-        for emission_group in reduce(group_by_keys(['input']), emissions, {}).values()
+        _indicator(
+            value=list_sum([emission['value'] * emission['coefficient'] for emission in emission_group]),
+            key=emission_group[0]['key'],
+            inputs=unique_values(flatten([emission.get('inputs', []) for emission in emission_group]))
+        )
+        for emission_group in group_by_keys(emissions, ['key']).values()
     ]
 
     return indicators
 
 
+def _valid_key(term: dict) -> bool:
+    return term.get('units', '').startswith("kg") and term.get('termType') == TermTermType.WASTE.value
+
+
 def _should_run(impact_assessment: dict) -> tuple[bool, list]:
     emissions = [
         emission
@@ -75,38 +77,34 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
 
     has_emissions = bool(emissions)
 
-    emissions_unpacked = flatten(
-        [
-            [
-                {
-                    "input-term-id": input.get('@id'),
-                    "input-term-type": input.get('termType'),
-                    "indicator-term-id": emission['term']['@id'],
-                    "indicator-is-valid": _valid_emission(emission),
-                    "input": input,
-                    "indicator-input-is-valid": _valid_waste(input),
-                    "value": _node_value(emission),
-                    "coefficient": get_table_value(lookup=download_lookup(filename="waste.csv"),
-                                                   col_match='termid',
-                                                   col_match_with=input.get('@id'),
-                                                   col_val=column_name(emission['term']['@id'])) if input else None
-                } for input in emission['inputs'] or [{}]]
-            for emission in emissions
-        ]
-    )
+    emissions_unpacked = [
+        {
+            "key-term-id": emission['key'].get('@id'),
+            "key-term-type": emission['key'].get('termType'),
+            "key-is-valid": _valid_key(emission['key']),
+            "indicator-term-id": emission['term']['@id'],
+            "value": _node_value(emission),
+            "coefficient": get_table_value(
+                lookup=download_lookup(filename="waste.csv"),
+                col_match='termid',
+                col_match_with=emission['key'].get('@id'),
+                col_val=column_name(emission['term']['@id'])
+            )
+        } | _include(emission, ['key', 'inputs'])
+        for emission in emissions
+        if emission.get('key')
+    ]
 
     valid_emission_with_cf = [
         em for em in emissions_unpacked if all([
             em['coefficient'] is not None,
-            em['indicator-is-valid'] is True,
-            em['indicator-input-is-valid'] is True
+            em['key-is-valid'] is True
         ])
     ]
 
-    valid_input_requirements = all([
+    valid_key_requirements = all([
         all([
-            em['indicator-is-valid'],
-            em['indicator-input-is-valid']
+            em['key-is-valid']
         ])
         for em in emissions_unpacked
     ])
@@ -117,12 +115,12 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
 
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     has_emissions=has_emissions,
-                    valid_input_requirements=valid_input_requirements,
+                    valid_key_requirements=valid_key_requirements,
                     all_emissions_have_known_CF=all_emissions_have_known_cf,
-                    emissions=log_as_table(emissions_unpacked)
+                    emissions=log_as_table([_omit(v, ['key', 'inputs']) for v in emissions_unpacked])
                     )
 
-    should_run = valid_input_requirements
+    should_run = all([emissions_unpacked, valid_key_requirements])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_emission_with_cf

hestia_earth/models/geospatialDatabase/awareWaterBasinId.py

@@ -16,9 +16,9 @@ RETURNS = {
 }
 MODEL_KEY = 'awareWaterBasinId'
 EE_PARAMS = {
-    'collection': 'AWARE',
+    'collection': 'AWARE_2_0_ids',
     'ee_type': 'vector',
-    'fields': 'Name'
+    'fields': 'Basin_ID'
 }
 
 

hestia_earth/models/geospatialDatabase/awareWaterBasinId_v1.py

@@ -0,0 +1,45 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from .utils import download, has_geospatial_data, should_download
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "or": [
+            {"latitude": "", "longitude": ""},
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
+        ]
+    }
+}
+RETURNS = {
+    "The AWARE water basin identifier as a `string`": ""
+}
+MODEL_KEY = 'awareWaterBasinId_v1'
+EE_PARAMS = {
+    'collection': 'AWARE',
+    'ee_type': 'vector',
+    'fields': 'Name'
+}
+
+
+def _download(site: dict):
+    return download(MODEL_KEY, site, EE_PARAMS)
+
+
+def _run(site: dict): return _download(site)
+
+
+def _should_run(site: dict):
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
+
+    logRequirements(site, model=MODEL, model_key=MODEL_KEY,
+                    contains_geospatial_data=contains_geospatial_data,
+                    below_max_area_size=below_max_area_size)
+
+    should_run = all([contains_geospatial_data, below_max_area_size])
+    logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)
+    return should_run
+
+
+def run(site: dict): return _run(site) if _should_run(site) else None

hestia_earth/models/hestia/default_emissions.py

@@ -1,7 +1,7 @@
 from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import flatten, safe_parse_float
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.emission import _new_emission, background_emissions_in_system_boundary
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
@@ -59,6 +59,10 @@ def _run_input(cycle: dict):
 
         for emission_id in required_emission_term_ids:
             logShouldRun(cycle, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+            debugValues(cycle, model=MODEL, term=emission_id,
+                        value=value,
+                        coefficient=1,
+                        input=term_id)
 
         return [
             _emission(term_id, value, input_term) for term_id in required_emission_term_ids

hestia_earth/models/hestia/default_resourceUse.py

@@ -1,7 +1,7 @@
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, safe_parse_float
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.emission import background_emissions_in_system_boundary
 from hestia_earth.models.utils.indicator import _new_indicator
@@ -63,6 +63,10 @@ def _run_input(impact: dict):
 
         for emission_id in required_resourceUse_term_ids:
             logShouldRun(impact, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+            debugValues(impact, model=MODEL, term=emission_id,
+                        value=value,
+                        coefficient=1,
+                        input=term_id)
 
         return [
             _indicator(term_id, value, input_term) for term_id in required_resourceUse_term_ids

hestia_earth/models/hestia/landCover.py

@@ -29,6 +29,7 @@ from .utils import (
     TOTAL_AGRICULTURAL_CHANGE,
     ALL_LAND_USE_TERMS,
     crop_ipcc_land_use_category,
+    LAND_USE_NAMES_FROM_ID
 )
 from . import MODEL
 
@@ -101,7 +102,8 @@ _BUILDING_SITE_TYPES = [
 _DEFAULT_WINDOW_IN_YEARS = 20
 _DATE_TOLERANCE_IN_YEARS = 2
 _OUTPUT_SIGNIFICANT_DIGITS = 3
-_ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
+_ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE, TOTAL_CROPLAND]
+_TOP_LEVEL_LAND_USE_TYPE_IDS = {"annualCropland", "permanentCropland", "permanentPasture", "cropland"}
 _LOOKUP_EXPANSION = "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv"
 _COMPLETE_CHANGES_OTHER_LAND = {
     OTHER_LAND: 1,
@@ -214,7 +216,7 @@ def _should_group_landCover(management_node: dict):
     )
 
 
-def _get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
+def _get_changes(country_id: str, end_year: int) -> tuple[dict, list]:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
     """
@@ -250,6 +252,25 @@ def _get_ratio_start_and_end_values(
     return max(0.0, _safe_divide(numerator=expansion, denominator=end_value))
 
 
+def _get_ratio_between_land_use_types(
+    country_id: str,
+    end_year: int,
+    first_land_use_term: str,
+    second_land_use_term: str
+) -> tuple:
+    """Returns a tuple of the values of the two land use terms for the same country and year."""
+    return tuple([
+        safe_parse_float(value=extract_grouped_data(
+            get_region_lookup_value(
+                'region-faostatArea.csv', country_id, land_use_term, model=MODEL, key=MODEL_KEY
+            ),
+            str(end_year)),
+            default=None
+        )
+        for land_use_term in [first_land_use_term, second_land_use_term]
+    ])
+
+
 def _estimate_maximum_forest_change(
     forest_change: float, total_cropland_change: float, pasture_change: float, total_agricultural_change: float
 ):
@@ -384,7 +405,7 @@ def _estimate_conversions_to_permanent_cropland(
     forest_loss_to_cropland: float,
     other_land_loss_to_annual_cropland: float
 ) -> dict:
-    """Estimate percentage of land sources when converted to: Annual cropland"""
+    """Estimate percentage of land sources when converted to: Permanent cropland"""
 
     def conversion_to_permanent_cropland(factor: float):
         return _safe_divide(
@@ -642,15 +663,92 @@ def _scale_site_area_errors(site_area: dict) -> dict:
         if negative_errors and abs(negative_errors[0]) < 1 and all([v < 1 for v in site_area.values()]) else site_area
 
 
+def _new_landCover_term(new_land_use_term) -> dict:
+    return {
+        "@id": LAND_USE_TERMS_FOR_TRANSFORMATION[new_land_use_term][0],
+        "name": LAND_USE_TERMS_FOR_TRANSFORMATION[new_land_use_term][1],
+        "@type": "Term",
+        "termType": TermTermType.LANDCOVER.value
+    }
+
+
+def _scaled_value(
+    permanent_crops_value: float,
+    annual_crops_value: float,
+    permanent_crops_factor: float,
+    annual_crops_factor: float,
+):
+    total_area = permanent_crops_factor + annual_crops_factor
+    permanent_crops_scaled = permanent_crops_value * permanent_crops_factor / total_area
+    annual_crops_scaled = annual_crops_value * annual_crops_factor / total_area
+    return annual_crops_scaled + permanent_crops_scaled
+
+
+def _scale_from_annual_and_permanent_results(
+    annual_cropland_results: dict,
+    permanent_cropland_results: dict,
+    annual_cropland_factor: float,
+    permanent_cropland_factor: float
+) -> dict:
+    return {
+        land_key: _scaled_value(
+            permanent_crops_value=permanent_cropland_results[land_key],
+            annual_crops_value=land_value,
+            permanent_crops_factor=permanent_cropland_factor,
+            annual_crops_factor=annual_cropland_factor
+        )
+        for land_key, land_value in annual_cropland_results.items()
+    }
+
+
 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(
+    return (
+        _should_run_historical_land_use_change_total_cropland(site, nodes) if land_use_type == TOTAL_CROPLAND else
+        _should_run_historical_land_use_change_single_crop(
+            site=site,
+            term=nodes[0].get("term", {}),
+            country_id=site.get("country", {}).get("@id"),
+            end_year=_get_year_from_landCover(nodes[0]),
+            land_use_type=land_use_type
+        )
+    )
+
+
+def _should_run_historical_land_use_change_total_cropland(site: dict, nodes: list) -> tuple[bool, dict]:
+    end_year = _get_year_from_landCover(nodes[0])
+    country_id = site.get("country", {}).get("@id")
+
+    # Run _should_run_historical_land_use_change_single_crop for annual and permanent
+    should_run_annual, areas_for_annual_cropland = _should_run_historical_land_use_change_single_crop(
         site=site,
-        term=nodes[0].get("term", {}),
-        country_id=site.get("country", {}).get("@id"),
-        end_year=_get_year_from_landCover(nodes[0]),
-        land_use_type=land_use_type
+        term=_new_landCover_term(ANNUAL_CROPLAND),
+        country_id=country_id,
+        end_year=end_year,
+        land_use_type=ANNUAL_CROPLAND
     )
+    should_run_permanent, areas_for_permanent_cropland = _should_run_historical_land_use_change_single_crop(
+        site=site,
+        term=_new_landCover_term(PERMANENT_CROPLAND),
+        country_id=country_id,
+        end_year=end_year,
+        land_use_type=PERMANENT_CROPLAND
+    )
+    # Get current ratios ("Arable land" vs "Permanent crops")
+    annual_cropland_factor, permanent_crops_factor = _get_ratio_between_land_use_types(
+        country_id=country_id,
+        end_year=end_year,
+        first_land_use_term=ANNUAL_CROPLAND,
+        second_land_use_term=PERMANENT_CROPLAND
+    ) if should_run_annual and should_run_permanent else tuple([0, 0])
+    scaled_results = _scale_from_annual_and_permanent_results(
+        annual_cropland_results=areas_for_annual_cropland,
+        permanent_cropland_results=areas_for_permanent_cropland,
+        annual_cropland_factor=annual_cropland_factor,
+        permanent_cropland_factor=permanent_crops_factor
+    ) if should_run_annual and should_run_permanent else {}
+    # Scale results according to current ratios.
+    return all([should_run_annual, should_run_permanent]), scaled_results
 
 
 def _should_run_historical_land_use_change_single_crop(
@@ -743,11 +841,11 @@ def _should_run_historical_land_use_change_single_crop(
 
     # Cell E8
     expansion_factor = _get_ratio_start_and_end_values(
-        expansion=changes[PERMANENT_PASTURE],
-        fao_name=PERMANENT_PASTURE,
+        expansion=changes[LAND_USE_NAMES_FROM_ID[term.get("@id")]],
+        fao_name=land_use_type,
         country_id=country_id,
         end_year=end_year
-    ) if land_use_type == PERMANENT_PASTURE else get_ratio_of_expanded_area(
+    ) if term.get("@id") in _TOP_LEVEL_LAND_USE_TYPE_IDS else get_ratio_of_expanded_area(
         country_id=country_id,
         fao_name=_get_faostat_name(term),
         end_year=end_year
@@ -774,7 +872,7 @@ def _should_run_historical_land_use_change_single_crop(
         ) if land_use_type == ANNUAL_CROPLAND else 1
     )
 
-    # E10: Compare changes to annual/perennial cropland from net expansion.
+    # E10: Compare changes to annual/permanent cropland from net expansion.
     net_expansion_cultivated_vs_harvested = _get_net_expansion_cultivated_vs_harvested(
         annual_crops_net_expansion=annual_crops_net_expansion,
         changes=changes,

hestia_earth/models/hestia/utils.py

@@ -35,6 +35,7 @@ LAND_USE_TERMS_FOR_TRANSFORMATION = {
     PERMANENT_PASTURE: ("permanentPasture", "Permanent pasture"),
     OTHER_LAND: ("otherLand", OTHER_LAND)  # Not used yet
 }
+LAND_USE_NAMES_FROM_ID = {v[0]: k for k, v in LAND_USE_TERMS_FOR_TRANSFORMATION.items()} | {"cropland": TOTAL_CROPLAND}
 
 
 def crop_ipcc_land_use_category(

hestia_earth/models/hestia/waterSalinity.py

@@ -1,13 +1,12 @@
-from functools import reduce
 from hestia_earth.schema import MeasurementMethodClassification, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, list_average, non_empty_list
+from hestia_earth.utils.blank_node import group_by_keys
 
 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.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.blank_node import group_by_keys
 from . import MODEL
 
 REQUIREMENTS = {
@@ -75,7 +74,7 @@ def _should_run(site: dict):
 
 def run(site: dict):
     should_run, values = _should_run(site)
-    grouped_values = reduce(group_by_keys(['start-date', 'end-date']), values, {})
+    grouped_values = group_by_keys(values, ['start-date', 'end-date'])
     return non_empty_list([
         _measurement(
             list_average([v.get('lookup-value') for v in value if v.get('lookup-value')], default=0),