hestia-earth-models 0.64.14__py3-none-any.whl → 0.65.0__py3-none-any.whl

hestia_earth/models/agribalyse2016/fuelElectricity.py

@@ -108,7 +108,7 @@ def _should_run(cycle: dict):
     has_operations = len(operations) > 0
 
     logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
-                    is_incomplete=is_incomplete,
+                    is_term_type_electricityFuel_incomplete=is_incomplete,
                     has_operations=has_operations,
                     operations=';'.join(non_empty_list(map(lambda v: v.get('term', {}).get('@id'), operations))))
 

hestia_earth/models/cache_sites.py

@@ -46,13 +46,13 @@ def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors:
         'ee_type': 'raster',
         'collections': rasters,
         param_type.value: param_values
-    })
+    }) if rasters else []
 
     vector_results = _run_query({
         'ee_type': 'vector',
         'collections': vectors,
         param_type.value: param_values
-    })
+    }) if vectors else []
 
     def _process_site(site_values: tuple):
         site, area_size = site_values
@@ -114,7 +114,7 @@ def _group_sites(sites: dict, check_has_cache: bool = True):
     }
 
 
-def _run(sites: list, years: list, include_region: bool, years_only: bool = False):
+def _run(sites: list, years: list = [], include_region: bool = False, years_only: bool = False):
     rasters, vectors = list_collections(years, include_region, years_only)
     filtered_data = _group_sites(sites, not years_only)
     return flatten([
@@ -123,15 +123,6 @@ def _run(sites: list, years: list, include_region: bool, years_only: bool = Fals
     ])
 
 
-def _group_years(years: list, years_range: int):
-    batches = sorted(list(set(list(range(years[0], years[-1] + 1, years_range)) + [years[0], years[-1]])))
-    grouped_batches = [batches[i:i+2] for i in range(0, len(batches))]
-    return [
-        # make sure we don't overlap
-        [v[0] + (0 if v[0] == years[0] else 1), v[1]] for v in grouped_batches if len(v) == 2
-    ]
-
-
 def run(sites: list, years: list = None, include_region: bool = False):
     """
     Run all queries at once for the list of provided Sites.
@@ -147,15 +138,15 @@ def run(sites: list, years: list = None, include_region: bool = False):
         Prefecth region IDs.
         This will cache region-level data and will make the request slower. Only use if needed.
     """
-    try:
-        return _run(sites, years, include_region)
-    except Exception as e:
-        # when querying with multiple years, we can reach a compute memory limit, so run the years separately
-        if str(e) == 'User memory limit exceeded.' and years:
-            sites = _run(sites, [], include_region)
-            # query for subranges
-            for sub_years in _group_years(years, years_range=5):
-                sites = _run(sites, sub_years, include_region, years_only=True)
-            return sites
-
-    return []
+    sites = _run(sites, include_region=include_region)
+
+    # avoid memory limit errors by running only a few years at a time
+    unique_years = sorted(list(set(years)))
+    batch_size = 5
+    batches = range(0, len(unique_years), batch_size)
+
+    for batch_index in batches:
+        sub_years = unique_years[batch_index:batch_index + batch_size]
+        sites = _run(sites, sub_years, include_region, years_only=True)
+
+    return sites

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -29,8 +29,7 @@ REQUIREMENTS = {
         },
         "optional": {
             "emissionsResourceUse": [
-                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromForest20YearAverageDuringCycle"},
-                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle"}  # noqa: E501
+                {"@type": "Indicator", "value": "", "term.@id": "landTransformation20YearAverageDuringCycle"}
             ]
         }
     }
@@ -46,11 +45,9 @@ LOOKUPS = {
     "region-siteType-LandTransformationChaudaryBrooks2018CF": "using `country`"
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandTransformation'
-LOOKUP_SUFFIX = 'LandTransformationChaudaryBrooks2018CF'
-TRANSFORMATION_TERM_IDS = [
-    'landTransformationFromForest20YearAverageDuringCycle',
-    'landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle'
-]
+
+_LOOKUP_SUFFIX = 'LandTransformationChaudaryBrooks2018CF'
+_TRANSFORMATION_TERM_ID = 'landTransformation20YearAverageDuringCycle'
 
 
 def _indicator(value: float):
@@ -68,8 +65,8 @@ def _value(impact_assessment: dict, term_id: str):
 def _run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    landTransformation = sum_values([_value(impact_assessment, term_id) for term_id in TRANSFORMATION_TERM_IDS])
-    region_factor = get_region_factor(TERM_ID, impact_assessment, LOOKUP_SUFFIX, 'medium_intensity')
+    landTransformation = _value(impact_assessment, _TRANSFORMATION_TERM_ID)
+    region_factor = get_region_factor(TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity')
     inputs_value = convert_value_from_cycle(
         product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -5,12 +5,20 @@ This model adds `impactAssessment` to inputs based on data which has been aggreg
 Note: to get more accurate impacts, we recommend setting the
 [input.impactAssessment](https://hestia.earth/schema/Input#impactAssessment)
 instead of the region-level averages using this model.
+
+For `seed` inputs, we will match ImpactAssessment in the following order of priority:
+- match using the value from the lookup `linkedImpactAssessmentTermId`;
+- match using the primary crop product;
+- match using the "generic" crop product term.
 """
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_primary_product, find_term_match, linked_node
+from hestia_earth.utils.api import download_hestia
+from hestia_earth.utils.model import find_primary_product, linked_node, filter_list_term_type
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.crop import valid_site_type
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.term import get_generic_crop
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date
@@ -55,28 +63,35 @@ RETURNS = {
         "impactAssessmentIsProxy": "True"
     }]
 }
+LOOKUPS = {
+    "seed": "linkedImpactAssessmentTermId"
+}
 MODEL_ID = 'hestiaAggregatedData'
 MODEL_KEY = 'impactAssessment'
-SEED_TERM_ID = 'seed'
 
 
-def _run_seed(cycle: dict, primary_product: dict, seed_input: dict):
+def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term_id: str):
+    product = download_hestia(product_term_id)
     region = seed_input.get('region')
     country = seed_input.get('country')
     # to avoid double counting seed => aggregated impact => seed, we need to get the impact of the previous decade
     # if the data does not exist, use the aggregated impact of generic crop instead
     date = aggregated_end_date(cycle.get('endDate'))
-    impact = find_closest_impact(cycle, date, primary_product, region, country, [
+    match_end_date = [
         {'match': {'endDate': date - 10}}
-    ]) or find_closest_impact(cycle, date, {'term': get_generic_crop()}, region, country)
+    ]
+
+    impact = find_closest_impact(cycle, date, {'term': product}, region, country, match_end_date) or \
+        find_closest_impact(cycle, date, primary_product, region, country, match_end_date) or \
+        find_closest_impact(cycle, date, {'term': get_generic_crop()}, region, country)
 
-    debugValues(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
+    debugValues(cycle, model=MODEL_ID, term=seed_input.get('term', {}).get('@id'), key=MODEL_KEY,
                 input_region=(region or {}).get('@id'),
                 input_country=(country or {}).get('@id'),
                 date=date,
                 impact=(impact or {}).get('@id'))
 
-    return [{**seed_input, MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True}] if impact else []
+    return seed_input | {MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True} if impact else None
 
 
 def _should_run_seed(cycle: dict):
@@ -84,27 +99,33 @@ def _should_run_seed(cycle: dict):
     product_id = primary_product.get('term', {}).get('@id')
     term_type = primary_product.get('term', {}).get('termType')
     is_crop_product = term_type == TermTermType.CROP.value
-    input = find_term_match(cycle.get('inputs', []), SEED_TERM_ID, None)
-    has_input = input is not None
     site_type_valid = valid_site_type(cycle, True)
 
-    should_run = all([site_type_valid, is_crop_product, has_input])
+    seed_inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.SEED)
+    seed_inputs = [
+        {
+            'input': seed_input,
+            'product': get_lookup_value(seed_input.get('term', {}), LOOKUPS['seed'], key=MODEL_KEY)
+        }
+        for seed_input in seed_inputs
+    ]
+
+    should_run = all([site_type_valid, is_crop_product, bool(seed_inputs)])
 
-    # ignore logs if seed is not present
-    if has_input:
-        debugValues(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
-                    primary_product_id=product_id,
-                    primary_product_term_type=term_type)
+    for seed_input in seed_inputs:
+        term_id = seed_input.get('input').get('term', {}).get('@id')
+        linked_product_id = seed_input.get('product')
 
-        logRequirements(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
+        logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY,
                         site_type_valid=site_type_valid,
                         is_crop_product=is_crop_product,
-                        has_input=has_input)
+                        primary_product_id=product_id,
+                        linked_product_id=linked_product_id)
 
-        logShouldRun(cycle, MODEL_ID, SEED_TERM_ID, should_run)
-        logShouldRun(cycle, MODEL_ID, SEED_TERM_ID, should_run, key=MODEL_KEY)  # show specifically under Input
+        logShouldRun(cycle, MODEL_ID, term_id, should_run)
+        logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY)  # show specifically under Input
 
-    return should_run, primary_product, input
+    return should_run, primary_product, seed_inputs
 
 
 def _should_run(cycle: dict):
@@ -124,9 +145,12 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, inputs = _should_run(cycle)
-    should_run_seed, primary_product, seed_input = _should_run_seed(cycle)
+    should_run_seed, primary_product, seed_inputs = _should_run_seed(cycle)
     return (
         link_inputs_to_impact(MODEL_ID, cycle, inputs) if should_run else []
     ) + (
-        _run_seed(cycle, primary_product, seed_input) if should_run_seed else []
+        non_empty_list([
+            _run_seed(cycle, primary_product, seed_input.get('input'), seed_input.get('product'))
+            for seed_input in seed_inputs
+        ]) if should_run_seed else []
     )

hestia_earth/models/cycle/pre_checks/cache_sources.py

@@ -1,11 +1,9 @@
 """
 Pre Checks Cache Sources
 
-This model caches the sources of all models.
+This model caches the sources of all Cycle models.
 """
-from hestia_earth.models.log import debugValues
-from hestia_earth.models.utils import CACHE_KEY, cached_value
-from hestia_earth.models.utils.source import CACHE_SOURCES_KEY, find_sources
+from hestia_earth.models.utils.cache_sources import cache_sources
 
 REQUIREMENTS = {
     "Cycle": {}
@@ -15,24 +13,4 @@ RETURNS = {
 }
 
 
-def _should_run(site: dict):
-    sources = find_sources()
-    has_cache = cached_value(site, CACHE_SOURCES_KEY) is not None
-
-    debugValues(site,
-                sources=';'.join([str(title) for title in sources.keys()]),
-                has_cache=has_cache)
-
-    should_run = all([
-        not has_cache,
-        len(sources) > 0
-    ])
-    return should_run, sources
-
-
-def run(site: dict):
-    should_run, sources = _should_run(site)
-    return {
-        **site,
-        CACHE_KEY: cached_value(site) | {CACHE_SOURCES_KEY: sources}
-    } if should_run else site
+def run(cycle: dict): return cache_sources(cycle)

hestia_earth/models/cycle/product/economicValueShare.py

@@ -140,7 +140,7 @@ def _should_run_by_revenue(cycle: dict, products: list):
     for p in products:
         term_id = p.get('term', {}).get('@id')
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
-                        is_complete=is_complete,
+                        is_term_type_product_complete=is_complete,
                         total_economicValueShare=total_economicValueShare,
                         below_threshold=below_threshold,
                         all_with_revenue=all_with_revenue,
@@ -168,7 +168,7 @@ def _should_run_single_missing_evs(cycle: dict, products: list):
     term_id = missing_values[0].get('term', {}).get('@id') if single_missing_value else None
 
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
-                    is_complete=is_complete,
+                    is_term_type_product_complete=is_complete,
                     total_value=total_value,
                     below_threshold=below_threshold,
                     single_missing_value=single_missing_value)

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -4,7 +4,7 @@ based on an updated [LANCA model (De Laurentiis et al. 2019)](
 http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
 Factors version 2.5 (Horn and Meier, 2018).
 """
-from typing import List, Tuple, Optional
+from typing import List, Tuple
 
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import download_lookup
@@ -18,18 +18,17 @@ from ..utils.impact_assessment import get_country_id
 from ..utils.indicator import _new_indicator
 from ..utils.landCover import get_pef_grouping
 from ..utils.lookup import fallback_country, _node_value
-from ..utils.term import get_land_cover_terms
 
 REQUIREMENTS = {
     "ImpactAssessment": {
         "emissionsResourceUse": [
             {
                 "@type": "Indicator",
-                "term.units": "m2 / year",
                 "term.termType": "resourceUse",
-                "term.name": "Land transformation from",
+                "term.name": "Land transformation",
                 "value": "> 0",
-                "landCover": {"@type": "Term", "term.termType": "landCover"}
+                "landCover": {"@type": "Term", "term.termType": "landCover"},
+                "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
             }
         ],
         "optional": {"country": {"@type": "Term", "termType": "region"}}
@@ -73,44 +72,21 @@ def _run(transformations: List[dict]):
     return _indicator(list_sum(values))
 
 
-def _extract_land_cover_from_indicator_id(indicator: dict) -> Optional[str]:
-    """
-    Given a indicator with term type `resourceUse` return the equivalent `landCover` term
-    """
-    term_in_id = indicator.get('term', {}).get('@id', '') \
-        .removeprefix("landTransformationFrom") \
-        .removesuffix("20YearAverageInputsProduction") \
-        .removesuffix("20YearAverageDuringCycle")
-    term_in_id = term_in_id[0].lower() + term_in_id[1:] if term_in_id else None
-    return term_in_id
-
-
-def _is_valid_indicator(indicator: dict, land_cover_term_ids: list[str]) -> bool:
-    term_id = _extract_land_cover_from_indicator_id(indicator)
-    return term_id in land_cover_term_ids
-
-
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
-    land_cover_term_ids = get_land_cover_terms() if resource_uses else []
-
-    land_transformation_indicators = [i for i in resource_uses if _is_valid_indicator(i, land_cover_term_ids)]
-
     found_transformations = [
         {
             'area': _node_value(transformation_indicator) * 20,
-            'area-unit': transformation_indicator.get('term', {}).get("units"),
-            'land-cover-id-from': _extract_land_cover_from_indicator_id(transformation_indicator),
+            'land-cover-id-from': transformation_indicator.get('previousLandCover', {}).get("@id"),
             'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
             'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
             'good-land-cover-term': transformation_indicator.get('landCover', {}).get('termType') == 'landCover',
             'country-id': get_country_id(impact_assessment),
             'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
                 transformation_indicator) > 0,
-            'area-unit-is-valid': transformation_indicator.get('term', {}).get("units") == "m2 / year",
             'lookup-country': fallback_country(get_country_id(impact_assessment),
                                                [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
-        } for transformation_indicator in land_transformation_indicators
+        } for transformation_indicator in resource_uses
     ]
 
     found_transformations_with_coefficient = [
@@ -134,17 +110,19 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     valid_transformations_with_coef = [
         t for t in found_transformations_with_coefficient if all([
             t['area-is-valid'],
-            t['area-unit-is-valid'],
             t['factor-from'] is not None,
             t['factor-to'] is not None
         ])
     ]
 
-    has_land_transformation_indicators = bool(land_transformation_indicators)
+    has_land_transformation_indicators = any([
+        indicator.get('term', {}).get('@id').startswith('landTransformation')
+        for indicator in resource_uses
+    ])
 
     all_transformations_are_valid = all(
         [
-            all([t['area-is-valid'], t['area-unit-is-valid'], t['good-land-cover-term']])
+            all([t['area-is-valid'], t['good-land-cover-term']])
             for t in found_transformations_with_coefficient
         ]
     ) if found_transformations_with_coefficient else False

hestia_earth/models/faostat2018/landTransformation100YearAverageDuringCycle.py

@@ -0,0 +1,34 @@
+from .utils import should_run_landTransformationFromCropland, run_landTransformationFromCropland
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "endDate": "",
+        "country": {"@type": "Term", "termType": "region"},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "term.@id": "landTransformation100YearAverageDuringCycle",
+            "value": "",
+            "previousLandCover": {
+                "@type": "Term",
+                "termType": "landCover",
+                "@id": "cropland"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-faostatArea": ""
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": "",
+        "previousLandCover": ""
+    }]
+}
+TERM_ID = 'landTransformation100YearAverageDuringCycle'
+
+
+def run(impact: dict):
+    should_run, indicators = should_run_landTransformationFromCropland(TERM_ID, impact)
+    return run_landTransformationFromCropland(TERM_ID, impact, indicators, 100) if should_run else []

hestia_earth/models/faostat2018/landTransformation20YearAverageDuringCycle.py

@@ -0,0 +1,34 @@
+from .utils import should_run_landTransformationFromCropland, run_landTransformationFromCropland
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "endDate": "",
+        "country": {"@type": "Term", "termType": "region"},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "term.@id": "landTransformation20YearAverageDuringCycle",
+            "value": "",
+            "previousLandCover": {
+                "@type": "Term",
+                "termType": "landCover",
+                "@id": "cropland"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-faostatArea": ""
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": "",
+        "previousLandCover": ""
+    }]
+}
+TERM_ID = 'landTransformation20YearAverageDuringCycle'
+
+
+def run(impact: dict):
+    should_run, indicators = should_run_landTransformationFromCropland(TERM_ID, impact)
+    return run_landTransformationFromCropland(TERM_ID, impact, indicators, 20) if should_run else []

hestia_earth/models/faostat2018/utils.py

@@ -1,14 +1,16 @@
+from numpy import recarray
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data_closest_date
-from hestia_earth.utils.tools import safe_parse_float
-from numpy import recarray
+from hestia_earth.utils.tools import safe_parse_float, flatten
 
-from hestia_earth.models.log import logger, debugMissingLookup
+from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.animalProduct import (
     FAO_LOOKUP_COLUMN, FAO_EQUIVALENT_LOOKUP_COLUMN, get_animalProduct_lookup_value
 )
 from hestia_earth.models.utils.product import convert_product_to_unit
+from hestia_earth.models.utils.impact_assessment import get_country_id, impact_end_year
+from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
 
 LOOKUP_PREFIX = f"{TermTermType.REGION.value}-{TermTermType.ANIMALPRODUCT.value}-{FAO_LOOKUP_COLUMN}"
@@ -140,3 +142,45 @@ def get_change_in_harvested_area_for_crop(country_id: str, crop_name: str, start
         return _split_delta(
             get_table_value(lookup, 'termid', country_id, column_name(crop_name)), start_year, end_year
         )
+
+
+def should_run_landTransformationFromCropland(term_id: str, impact: dict):
+    indicators = [
+        i for i in impact.get('emissionsResourceUse', [])
+        if all([
+            i.get('term', {}).get('@id') == term_id,
+            i.get('previousLandCover', {}).get('@id') == 'cropland',
+            i.get('value', -1) > 0
+        ])
+    ]
+    has_cropland = bool(indicators)
+
+    should_run = all([has_cropland])
+    logRequirements(impact, model=MODEL, term=term_id,
+                    has_cropland_indicators=has_cropland)
+    logShouldRun(impact, MODEL, term_id, should_run)
+
+    return should_run, indicators
+
+
+def run_landTransformationFromCropland(term_id: str, impact: dict, indicators: list, years: int):
+    country_id = get_country_id(impact)
+    end_year = impact_end_year(impact)
+    total, permanent, temporary = get_cropland_ratio(country_id, end_year - years, end_year)
+
+    debugValues(impact, model=MODEL, term_id=term_id,
+                diff_temporary_area=temporary,
+                diff_permanent_area=permanent,
+                diff_total_area=total)
+
+    return flatten([
+        [
+            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'annualCropland') | {
+                'value': indicator.get('value') * temporary / total
+            },
+            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'permanentCropland') | {
+                'value': indicator.get('value') * permanent / total
+            }
+        ]
+        for indicator in indicators
+    ]) if total is not None else []

hestia_earth/models/hestia/landCover.py

@@ -198,14 +198,14 @@ def _estimate_maximum_forest_change(
         pasture_change=pasture_change,
         total_cropland_change=total_cropland_change
     ) if not positive_change else (
-        total_agricultural_change
+        -total_agricultural_change
         if -min(forest_change, 0) > total_agricultural_change else
         min(forest_change, 0)
     )
 
 
 def _negative_agricultural_land_change(forest_change, pasture_change, total_cropland_change):
-    return pasture_change if 0 < pasture_change < -min(forest_change, 0) \
+    return -pasture_change if 0 < pasture_change < -min(forest_change, 0) \
         else min(forest_change, 0) if pasture_change > 0 \
         else -total_cropland_change if 0 < total_cropland_change < -min(forest_change, 0) \
         else min(forest_change, 0) if 0 < total_cropland_change \
@@ -432,7 +432,7 @@ def _run_make_management_nodes(existing_nodes: list, percentage_transformed_from
                 LAND_USE_TERMS_FOR_TRANSFORMATION[land_type], f"{start_year}-01-01", f"{start_year}-12-31"
             ),
             "land_type": land_type,
-            "percentage": 0.0 if ratio == -0.0 else to_precision(
+            "percentage": 0 if ratio == -0.0 else to_precision(
                 number=ratio * 100,
                 digits=OUTPUT_SIGNIFICANT_DIGITS
             )
@@ -462,7 +462,7 @@ def get_ratio_of_expanded_area(country_id: str, fao_name: str, end_year: int) ->
         faostat_name=fao_name
     )
     return 0.0 if any([expansion is None, end_value is None]) else max(
-        0.0, _safe_divide(numerator=expansion, denominator=(end_value - expansion))
+        0.0, _safe_divide(numerator=expansion, denominator=end_value)
     )
 
 
@@ -619,7 +619,7 @@ def _should_run_historical_land_use_change_single_crop(
         other_land_loss_to_pasture=other_land_loss_to[PERMANENT_PASTURE]
     )
 
-    # BA to BD
+    # C14-G14
     shares_of_expansion = _get_shares_of_expansion(
         land_use_type=land_use_type,
         percent_annual_cropland_was=percent_annual_cropland_was,