hestia-earth-models 0.65.10__py3-none-any.whl → 0.66.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/geospatialDatabase/{aware.py → 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/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": ""
+                }
             }
         ]
     }
@@ -82,7 +84,8 @@ LOOKUPS = {
         "Permanent meadows and pastures"
     ],
     "crop": ["cropGroupingFaostatArea", "IPCC_LAND_USE_CATEGORY"],
-    "landCover": ["cropGroupingFaostatProduction", "FAOSTAT_LAND_AREA_CATEGORY"]
+    "landCover": ["cropGroupingFaostatProduction", "FAOSTAT_LAND_AREA_CATEGORY"],
+    "property": "CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"
 }
 MODEL_KEY = 'landCover'
 
@@ -120,7 +123,14 @@ def site_area_sum_to_100(dict_of_percentages: dict):
          math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01))
 
 
-def get_changes(country_id: str, end_year: int) -> dict:
+def _should_group_landCover(term: dict):
+    return any(
+        bool(get_lookup_value(lookup_term=prop.get("term", {}), column="CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"))
+        for prop in term.get("properties", [])
+    )
+
+
+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
     """
@@ -129,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(
@@ -148,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))
 
 
@@ -379,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
     )
@@ -399,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"))
@@ -421,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"),
@@ -507,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
     )
 
@@ -527,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(
@@ -657,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,
@@ -664,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
@@ -714,8 +734,7 @@ def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
     return len(previous_nodes) == 0
 
 
-def _should_run(site: dict) -> tuple[bool, dict]:
-    management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+def _should_run(site: dict, management_nodes: list) -> tuple[bool, dict]:
     summarised_nodes = _collect_land_use_types(management_nodes)
     allowed_land_use_types = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
     relevant_nodes = sorted(
@@ -751,10 +770,9 @@ def _should_run(site: dict) -> tuple[bool, dict]:
 
 
 def run(site: dict) -> list:
-    should_run, site_area = _should_run(site)
-    management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-    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 []
+    management_nodes = [
+        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        if not _should_group_landCover(node)
+    ]
+    should_run, site_area = _should_run(site=site, management_nodes=management_nodes)
+    return _run(site, management_nodes, site_area) if should_run else []