hestia-earth-models 0.65.11__py3-none-any.whl → 0.67.0__py3-none-any.whl

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/cycle/input/hestiaAggregatedData.py

@@ -77,19 +77,22 @@ def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term
     # 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'))
-    match_end_date = [
-        {'match': {'endDate': date - 10}}
-    ]
+    match_end_date = [{'match': {'endDate': date - 10}}]
+    default_product = get_generic_crop()
 
-    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)
+    impact = (
+        find_closest_impact(cycle, date, product, region, country, match_end_date) or
+        find_closest_impact(cycle, date, primary_product.get('term', {}), region, country, match_end_date) or
+        find_closest_impact(cycle, date, default_product, region, country)
+    )
 
+    search_by_product_term_id = (product or primary_product or default_product).get('@id')
+    search_by_region_id = (region or country or {}).get('@id') or 'region-world'
     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'))
+                search_by_product_term_id=search_by_product_term_id,
+                search_by_region_id=search_by_region_id,
+                search_by_end_date=str(date),
+                impact_assessment_id_found=(impact or {}).get('@id'))
 
     return seed_input | {MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True} if impact else None
 

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 → environmentalFootprintV3_1}/__init__.py

@@ -1,13 +1,14 @@
-from os.path import dirname, abspath
 import sys
 from importlib import import_module
+from os.path import dirname, abspath
 
 from hestia_earth.models.utils.blank_node import run_if_required
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
-MODEL = 'environmentalFootprintV3'
-PKG = '.'.join(['hestia_earth', 'models', MODEL])
+MODEL = 'environmentalFootprintV3-1'
+MODEL_FOLDER = MODEL.replace('-', '_')
+PKG = '.'.join(['hestia_earth', 'models', MODEL_FOLDER])
 
 
 def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/environmentalFootprintV3_1/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_1/marineEutrophicationPotential.py

@@ -0,0 +1,36 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
+from hestia_earth.models.utils.indicator import _new_indicator
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+LOOKUPS = {
+    "emission": "nEqMarineEutrophicationEnvironmentalFootprintV3"
+}
+
+TERM_ID = 'marineEutrophicationPotential'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/environmentalFootprintV3_1/scarcityWeightedWaterUse.py

@@ -0,0 +1,40 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.impact_assessment import impact_country_value
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator",
+                                  "term.@id": "freshwaterWithdrawalsDuringCycle",
+                                  "value": ""
+                                  }],
+        "optional": {"country": {"@type": "Term", "termType": "region"}}
+    }
+}
+
+LOOKUPS = {
+    "region-resourceUse-environmentalFootprintV31WaterUse": ""
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'scarcityWeightedWaterUse'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_country_value(MODEL, TERM_ID, impact_assessment, f"{list(LOOKUPS.keys())[0]}.csv",
+                                 country_fallback=True)
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return None if value is None else _indicator(value)

hestia_earth/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/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": ""
+                }
             }
         ]
     }
@@ -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 []