hestia-earth-models 0.65.11__tar.gz → 0.66.0__tar.gz

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.65.11
+Version: 0.66.0
 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.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/cache_sites.py

@@ -8,7 +8,7 @@ from .log import logger
 from .utils import CACHE_KEY, cached_value
 from .utils.site import CACHE_YEARS_KEY
 from .site.pre_checks.cache_geospatialDatabase import (
-    list_collections, cache_site_results, _should_run
+    list_vectors, list_rasters, cache_site_results, _should_run
 )
 from .geospatialDatabase.utils import (
     CACHE_VALUE as CACHE_GEOSPATIAL_KEY, CACHE_AREA_SIZE,
@@ -115,8 +115,9 @@ def _group_sites(sites: dict, check_has_cache: bool = True):
     }
 
 
-def _run(sites: list, years: list = [], include_region: bool = False, years_only: bool = False):
-    rasters, vectors = list_collections(years, include_region, years_only)
+def _run(sites: list, years: list = [], years_only: bool = False):
+    rasters = list_rasters(years=years, years_only=years_only)
+    vectors = [] if years_only else list_vectors(sites)
     filtered_data = _group_sites(sites, not years_only)
     return flatten([
         _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
@@ -124,7 +125,7 @@ def _run(sites: list, years: list = [], include_region: bool = False, years_only
     ])
 
 
-def run(sites: list, years: list = None, include_region: bool = False):
+def run(sites: list, years: list = None):
     """
     Run all queries at once for the list of provided Sites.
     Note: Earth Engine needs to be initiliased with `init_gee()` before running this function.
@@ -135,11 +136,8 @@ def run(sites: list, years: list = None, include_region: bool = False):
         List of Site as dict.
     years : list[int]
         List of related years to fetch annual data.
-    include_region : bool
-        Prefecth region IDs.
-        This will cache region-level data and will make the request slower. Only use if needed.
     """
-    sites = _run(sites, include_region=include_region)
+    sites = _run(sites)
 
     # avoid memory limit errors by running only a few years at a time
     unique_years = sorted(list(set(years)))
@@ -149,6 +147,6 @@ def run(sites: list, years: list = None, include_region: bool = False):
     for batch_index in batches:
         logger.info(f"Processing sites in batch {batch_index + 1} of {len(batches)}...")
         sub_years = unique_years[batch_index:batch_index + batch_size]
-        sites = _run(sites, sub_years, include_region, years_only=True)
+        sites = _run(sites, sub_years, years_only=True)
 
     return sites

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/config/Cycle.json

@@ -166,6 +166,14 @@
       "mergeStrategy": "list",
       "stage": 1
     },
+    {
+      "key": "practices",
+      "model": "hestia",
+      "value": "residueRemoved",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     {
       "key": "practices",
       "model": "cycle",
@@ -287,22 +295,6 @@
         "mergeStrategy": "list",
         "stage": 1
       },
-      {
-        "key": "inputs",
-        "model": "faostat2018",
-        "value": "seed",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
-      {
-        "key": "inputs",
-        "model": "pooreNemecek2018",
-        "value": "saplingsDepreciatedAmountPerCycle",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
       {
         "key": "practices",
         "model": "cycle",
@@ -441,6 +433,32 @@
         "stage": 1
       }
     ],
+    [
+      {
+        "key": "inputs",
+        "model": "faostat2018",
+        "value": "seed",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
+      },
+      {
+        "key": "inputs",
+        "model": "pooreNemecek2018",
+        "value": "saplingsDepreciatedAmountPerCycle",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
+      }
+    ],
+    {
+      "key": "completeness",
+      "model": "cycle",
+      "value": "completeness",
+      "runStrategy": "always",
+      "mergeStrategy": "node",
+      "stage": 1
+    },
     [
       {
         "key": "animals",

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/config/ImpactAssessment.json

@@ -1656,6 +1656,18 @@
       }
     ],
     [
+      {
+        "key": "endpoints",
+        "model": "environmentalFootprintV3",
+        "value": "environmentalFootprintSingleOverallScore",
+        "runStrategy": "always",
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01],
+          "sameMethodModel": true
+        },
+        "stage": 1
+      },
       {
         "key": "endpoints",
         "model": "lcImpactCertainEffects100Years",

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/config/Site.json

@@ -128,7 +128,7 @@
       {
         "key": "awareWaterBasinId",
         "model": "geospatialDatabase",
-        "value": "aware",
+        "value": "awareWaterBasinId",
         "runStrategy": "add_key_if_missing",
         "mergeStrategy": "default",
         "stage": 1
@@ -406,6 +406,9 @@
       "value": "management",
       "runStrategy": "always",
       "mergeStrategy": "list",
+      "mergeArgs": {
+        "matchDatesFormat": "%Y"
+      },
       "stage": 2
     },
     [

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/cycle/completeness/freshForage.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils import is_from_model
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,13 +33,17 @@ RETURNS = {
         "freshForage": ""
     }
 }
+LOOKUPS = {
+    "liveAnimal": "isGrazingAnimal",
+    "liveAquaticSpecies": "isGrazingAnimal"
+}
 MODEL_KEY = 'freshForage'
 ALLOWED_SITE_TYPES = [
     SiteSiteType.PERMANENT_PASTURE.value
 ]
 
 
-def _valid_input(input: dict): return is_from_model(input) and list_sum(input.get('value', [-1])) > 0
+def _valid_input(input: dict): return is_from_model(input) and list_sum(input.get('value', [-1])) >= 0
 
 
 def run(cycle: dict):
@@ -47,7 +52,10 @@ def run(cycle: dict):
 
     cycle_has_added_forage_input = any(map(_valid_input, cycle.get('inputs', [])))
 
-    animals = cycle.get('animals', [])
+    animals = [
+        a for a in cycle.get('animals', [])
+        if get_lookup_value(a.get('term', {}), 'isGrazingAnimal', model=MODEL, key=MODEL_KEY)
+    ]
     all_animals_have_added_forage_input = bool(animals) and all([
         any(map(_valid_input, animal.get('inputs', []))) for animal in animals
     ])

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/cycle/cropResidueManagement.py

@@ -30,6 +30,8 @@ PRACTICE_IDS = [
     residueIncorporated.TERM_ID,
     residueLeftOnField.TERM_ID,
     residueRemoved.TERM_ID,
+    'residueIncorporatedLessThan30DaysBeforeCultivation',
+    'residueIncorporatedMoreThan30DaysBeforeCultivation',
 ]
 
 
@@ -50,7 +52,7 @@ def _should_run(cycle: dict):
     ])]
     missing_practices = [term_id for term_id in practice_ids if term_id not in existing_practices]
 
-    should_run = all([sum_practices == 100])
+    should_run = all([99.5 <= sum_practices <= 100.5])
 
     for term_id in missing_practices:
         logRequirements(cycle, model=MODEL, term=term_id,

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/ecoinventV3/__init__.py

@@ -69,7 +69,8 @@ LOOKUPS = {
     "pesticideAI": "ecoinventMapping",
     "soilAmendment": "ecoinventMapping",
     "transport": "ecoinventMapping",
-    "veterinaryDrugs": "ecoinventMapping"
+    "veterinaryDrugs": "ecoinventMapping",
+    "feedFoodAdditive": "ecoinventMapping"
 }
 MODEL = 'ecoinventV3'
 MODEL_KEY = 'impactAssessment'  # keep to generate entry in "model-links.json"

hestia_earth_models-0.66.0/hestia_earth/models/environmentalFootprintV3/environmentalFootprintSingleOverallScore.py

@@ -0,0 +1,135 @@
+"""
+The inputs and outputs from the life cycle inventory are aggregated in 16 midpoint
+characterised impact categories. These impact categories are then normalised (i.e., the results are divided by
+the overall inventory of a reference unit, e.g., the entire world, to convert the characterised impact categories in
+relative shares of the impacts of the analysed system) and weighted (i.e., each impact category is multiplied by
+a weighting factor to reflect their perceived relative importance). The weighted impact categories can then be
+summed to obtain the EF single overall score. The number and the name of the impact categories is the same
+in EF3.0 and EF3.1.
+"""
+from typing import List, Optional, Tuple
+
+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 list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugMissingLookup
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.lookup import _node_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "impacts": [
+            {
+                "@type": "Indicator",
+                "value": "",
+                "term.name": "PEF indicators only"
+            }
+        ]
+    }
+}
+
+LOOKUPS = {
+    "@doc": "Normalisation factors in PEF v3.1 are calculated using a Global population number of 6,895,889,018",
+    "characterisedIndicator": ["pefTerm-normalisation-v3_1", "pefTerm-weighing-v3_1"]
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'environmentalFootprintSingleOverallScore'
+
+normalisation_column = LOOKUPS['characterisedIndicator'][0]
+weighing_column = LOOKUPS['characterisedIndicator'][1]
+
+
+def _is_a_PEF_indicator(indicator_id) -> bool:
+    return (_get_factor(indicator_id, normalisation_column) not in [None, 0, 0.0] and
+            _get_factor(indicator_id, weighing_column) not in [None, 0, 0.0])
+
+
+def _get_factor(indicator_id: str, column) -> Optional[float]:
+    factor = get_table_value(download_lookup(f"{list(LOOKUPS.keys())[1]}.csv", keep_in_memory=True),
+                             'termid', indicator_id, column_name(column))
+    if factor is None:
+        debugMissingLookup(f"{list(LOOKUPS.keys())[1]}.csv", 'termid', indicator_id, column, None, model=MODEL,
+                           term=TERM_ID)
+    return float(factor) if factor is not None else None
+
+
+def _normalise(indicator: dict) -> Optional[float]:
+    return (_node_value(indicator) / _get_factor(indicator['term']['@id'], normalisation_column)) \
+        if (_node_value(indicator) is not None and
+            _get_factor(indicator['term']['@id'], normalisation_column) not in [None, 0, 0.0]) else None
+
+
+def _weighted_normalise(indicator: dict) -> Optional[float]:
+    return (_normalise(indicator) * (_get_factor(indicator['term']['@id'], weighing_column) / 100)
+            ) if (_normalise(indicator) is not None and
+                  _get_factor(indicator['term']['@id'], weighing_column) not in [None, 0, 0.0]) else None
+
+
+def _indicator(value: float) -> dict:
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(indicators: List[dict]):
+    return _indicator(value=list_sum([indicator["weighted-normalised"] for indicator in indicators]))
+
+
+def _valid_indicator(indicator: Optional[dict]) -> bool:
+    return all([indicator is not None,
+                isinstance(_node_value(indicator), (int, float)),
+                _node_value(indicator) is not None,
+                _is_a_PEF_indicator(indicator.get('term', {}).get('@id', ''))])
+
+
+def _should_run(impact_assessment: dict) -> Tuple[bool, list[dict]]:
+    indicators = [
+        indicator for indicator in
+        filter_list_term_type(impact_assessment.get('impacts', []), TermTermType.CHARACTERISEDINDICATOR)
+        if _is_a_PEF_indicator(indicator.get('term', {}).get('@id', ''))
+    ]
+
+    has_pef_indicators = bool(indicators)
+
+    processed_indicators = [{
+        "indicator": indicator,
+        "valid-indicator": _valid_indicator(indicator),
+        "one-indicator-for-category": sum(1 for i in indicators if i['term']['@id'] == indicator['term']['@id']) == 1,
+        "indicator-pef-category": indicator['term']['@id'],
+        "value": _node_value(indicator),
+        "normalised": _normalise(indicator),
+        "normalisation-used": _get_factor(indicator['term']['@id'], normalisation_column),
+        "weighted-normalised": _weighted_normalise(indicator),
+        "weighting-used": _get_factor(indicator['term']['@id'], weighing_column),
+    }
+        for indicator in indicators
+    ]
+
+    no_duplicate_indicators = all([indicator['one-indicator-for-category'] for indicator in processed_indicators])
+    valid_indicators = [indicator for indicator in processed_indicators if indicator['valid-indicator']]
+    all_indicators_valid = all([indicator['valid-indicator'] for indicator in processed_indicators])
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_pef_indicators=has_pef_indicators,
+                    no_duplicate_indicators=no_duplicate_indicators,
+                    all_indicators_valid=all_indicators_valid,
+                    processed_indicators=log_as_table(processed_indicators),
+                    )
+
+    should_run = all([has_pef_indicators, all_indicators_valid, no_duplicate_indicators])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_indicators
+
+
+def run(impact_assessment: dict):
+    should_run, indicators = _should_run(impact_assessment)
+    return _run(indicators) if should_run else None

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -25,14 +25,25 @@ REQUIREMENTS = {
             {
                 "@type": "Indicator",
                 "term.termType": "resourceUse",
-                "term.@id": ["landTransformation20YearAverageInputsProduction",
-                             "landTransformation20YearAverageDuringCycle"],
+                "term.@id": "landTransformation20YearAverageDuringCycle",
                 "value": "> 0",
                 "landCover": {"@type": "Term", "term.termType": "landCover"},
                 "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
             }
         ],
-        "optional": {"country": {"@type": "Term", "termType": "region"}}
+        "optional": {
+            "country": {"@type": "Term", "termType": "region"},
+            "emissionsResourceUse": [
+                {
+                    "@type": "Indicator",
+                    "term.termType": "resourceUse",
+                    "term.@id": "landTransformation20YearAverageInputsProduction",
+                    "value": "> 0",
+                    "landCover": {"@type": "Term", "term.termType": "landCover"},
+                    "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
+                }
+            ]
+        }
     }
 }
 
@@ -76,7 +87,8 @@ def _run(transformations: List[dict]):
 
 
 def _is_valid_indicator(indicator: dict) -> bool:
-    return indicator['term']['@id'] in REQUIREMENTS['ImpactAssessment']['emissionsResourceUse'][0]['term.@id']
+    return indicator['term']['@id'] in ["landTransformation20YearAverageInputsProduction",
+                                        "landTransformation20YearAverageDuringCycle"]
 
 
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
@@ -144,8 +156,7 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
                     found_transformations=log_as_table(found_transformations_with_coefficient)
                     )
 
-    should_run = has_land_transformation_indicators is False or all([has_land_transformation_indicators,
-                                                                     all_transformations_are_valid])
+    should_run = all([has_land_transformation_indicators, all_transformations_are_valid])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_transformations_with_coef

hestia_earth_models-0.65.11/hestia_earth/models/geospatialDatabase/aware.py → hestia_earth_models-0.66.0/hestia_earth/models/geospatialDatabase/awareWaterBasinId.py

@@ -19,7 +19,7 @@ REQUIREMENTS = {
 RETURNS = {
     "The AWARE water basin identifier as a `string`": ""
 }
-MODEL_KEY = 'aware'
+MODEL_KEY = 'awareWaterBasinId'
 EE_PARAMS = {
     'collection': 'AWARE',
     'ee_type': 'vector',

{hestia_earth_models-0.65.11 → hestia_earth_models-0.66.0}/hestia_earth/models/hestia/landCover.py

@@ -1,8 +1,8 @@
 """
 Land Cover
 
-This model calculates historic land use change over a twenty-year period, extending the
-functionality of the Blonk model.
+This model calculates historic land use change over a twenty-year period,
+extending the functionality of the Blonk model.
 """
 import math
 from collections import defaultdict
@@ -10,15 +10,16 @@ from datetime import datetime, timedelta
 
 from hestia_earth.schema import SiteSiteType, TermTermType
 from hestia_earth.utils.lookup import (
-    download_lookup, get_table_value, column_name,
-    extract_grouped_data_closest_date, _is_missing_value, extract_grouped_data
+    download_lookup, get_table_value, column_name, _is_missing_value, extract_grouped_data
 )
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float, to_precision, non_empty_value
+from hestia_earth.utils.tools import safe_parse_float, to_precision
 
 from hestia_earth.models.log import logRequirements, log_as_table, logShouldRun
+from hestia_earth.models.utils.constant import DAYS_IN_YEAR
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.blank_node import _node_date, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
 from .utils import (
     IPCC_LAND_USE_CATEGORY_ANNUAL,
     IPCC_LAND_USE_CATEGORY_PERENNIAL,
@@ -34,8 +35,6 @@ from .utils import (
     crop_ipcc_land_use_category,
 )
 from . import MODEL
-from ..utils.blank_node import _node_date, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
-from ..utils.constant import DAYS_IN_YEAR
 
 REQUIREMENTS = {
     "Site": {
@@ -51,7 +50,10 @@ REQUIREMENTS = {
                 "@type": "Management",
                 "value": "",
                 "term.termType": "landCover",
-                "endDate": ""
+                "or": {
+                    "startDate": "",
+                    "endDate": ""
+                }
             }
         ]
     }
@@ -128,7 +130,7 @@ def _should_group_landCover(term: dict):
     )
 
 
-def get_changes(country_id: str, end_year: int) -> dict:
+def get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
     """
@@ -137,14 +139,18 @@ def get_changes(country_id: str, end_year: int) -> dict:
         land_use_term: safe_parse_float(
             extract_grouped_data(
                 get_table_value(lookup, 'termid', country_id, column_name(land_use_term)),
-                str(end_year))
+                str(end_year)),
+            default=None
         )
         for land_use_term in ALL_LAND_USE_TERMS + [LAND_AREA]
     }
-    changes_dict[TOTAL_AGRICULTURAL_CHANGE] = (float(changes_dict.get(TOTAL_CROPLAND, 0))
-                                               + float(changes_dict.get(PERMANENT_PASTURE, 0)))
+    missing_changes = any(val is None for val in changes_dict.values())
+    changes_dict = {k: v if v is not None else 0 for k, v in changes_dict.items()}
+    changes_dict[TOTAL_AGRICULTURAL_CHANGE] = (
+        float(changes_dict.get(TOTAL_CROPLAND, 0)) + float(changes_dict.get(PERMANENT_PASTURE, 0))
+    )
 
-    return changes_dict
+    return changes_dict, missing_changes
 
 
 def _get_ratio_start_and_end_values(
@@ -156,7 +162,7 @@ def _get_ratio_start_and_end_values(
     # expansion over twenty years / current area
     lookup = download_lookup('region-faostatArea.csv')
     table_value = get_table_value(lookup, 'termid', country_id, column_name(fao_name))
-    end_value = safe_parse_float(value=extract_grouped_data_closest_date(table_value, end_year), default=None)
+    end_value = safe_parse_float(value=extract_grouped_data(table_value, str(end_year)), default=None)
     return max(0.0, _safe_divide(numerator=expansion, denominator=end_value))
 
 
@@ -387,9 +393,9 @@ def _get_harvested_area(country_id: str, year: int, faostat_name: str) -> float:
     """
     lookup = download_lookup("region-crop-cropGroupingFaostatProduction-areaHarvested.csv")
     return safe_parse_float(
-        value=extract_grouped_data_closest_date(
+        value=extract_grouped_data(
             data=get_table_value(lookup, "termid", country_id, column_name(faostat_name)),
-            year=year
+            key=str(year)
         ),
         default=None
     )
@@ -407,7 +413,9 @@ def _get_term_id_for_crop(nodes: set, land_type: str) -> str:
     )
 
 
-def _run_make_management_nodes(existing_nodes: list, percentage_transformed_from: dict, start_year: int) -> list:
+def _run(site: dict, existing_nodes: list, percentage_transformed_from: dict):
+    start_year = _get_year_from_landCover(existing_nodes[0]) - DEFAULT_WINDOW_IN_YEARS
+
     """Creates a list of new management nodes, excluding any dates matching existing ones."""
     existing_nodes_set = {
         (node.get("term", {}).get("@id", ""), node.get("startDate"), node.get("endDate"))
@@ -429,6 +437,9 @@ def _run_make_management_nodes(existing_nodes: list, percentage_transformed_from
     ]
     values = [v for v in values if v.get("land_management_key") not in existing_nodes_set]
 
+    for value in values:
+        logShouldRun(site, MODEL, value.get("term_id"), True, model_key=MODEL_KEY)
+
     return [
         _management(
             term_id=value.get("term_id"),
@@ -515,13 +526,18 @@ def _get_net_expansion_cultivated_vs_harvested(annual_crops_net_expansion, chang
     return net_expansion_cultivated_vs_harvested
 
 
+def _get_year_from_landCover(node: dict):
+    date = node.get('startDate') or node.get('endDate')
+    return int(date[:4])
+
+
 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(
         site=site,
         term=nodes[0].get("term", {}),
         country_id=site.get("country", {}).get("@id"),
-        end_year=int(nodes[0].get("endDate")[:4]),
+        end_year=_get_year_from_landCover(nodes[0]),
         land_use_type=land_use_type
     )
 
@@ -535,7 +551,7 @@ def _should_run_historical_land_use_change_single_crop(
 ) -> tuple[bool, dict]:
     """Calculate land use change percentages for a single management node/crop."""
     # (C-H).
-    changes = get_changes(country_id=country_id, end_year=end_year)
+    changes, missing_changes = get_changes(country_id=country_id, end_year=end_year)
 
     # (L). Estimate maximum forest loss
     forest_loss = _estimate_maximum_forest_change(
@@ -665,6 +681,8 @@ def _should_run_historical_land_use_change_single_crop(
     site_area[land_use_type] = 1 - sum(site_area.values())
 
     sum_of_site_areas_is_100 = site_area_sum_to_100(site_area)
+    site_type_allowed = site.get("siteType") in SITE_TYPES
+
     logRequirements(
         log_node=site,
         model=MODEL,
@@ -672,19 +690,13 @@ def _should_run_historical_land_use_change_single_crop(
         model_key=MODEL_KEY,
         land_use_type=land_use_type,
         country_id=country_id,
+        changes=log_as_table(changes),
         site_area=log_as_table(site_area),
-        sum_of_site_areas_is_100=sum_of_site_areas_is_100
+        sum_of_site_areas_is_100=sum_of_site_areas_is_100,
+        site_type_allowed=site_type_allowed
     )
 
-    should_run = all(
-        [
-            site.get("siteType"),
-            country_id,
-            non_empty_value(term),
-            site.get("siteType") in SITE_TYPES,
-            sum_of_site_areas_is_100
-        ]
-    )
+    should_run = all([not missing_changes, country_id, site_type_allowed, sum_of_site_areas_is_100])
     logShouldRun(site, MODEL, term.get("@id"), should_run, model_key=MODEL_KEY)
 
     return should_run, site_area
@@ -763,8 +775,4 @@ def run(site: dict) -> list:
         if not _should_group_landCover(node)
     ]
     should_run, site_area = _should_run(site=site, management_nodes=management_nodes)
-    return _run_make_management_nodes(
-        existing_nodes=management_nodes,
-        percentage_transformed_from=site_area,
-        start_year=int(management_nodes[0].get("endDate")[:4]) - DEFAULT_WINDOW_IN_YEARS
-    ) if should_run else []
+    return _run(site, management_nodes, site_area) if should_run else []