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

hestia_earth/models/hestia/seed_emissions.py

@@ -0,0 +1,275 @@
+"""
+Seed Emissions
+
+This model uses the `emissions` recalculated from the current `Cycle` to estimate the `emissions` associated with
+producing the `Input` with `termType` = `seed`.
+
+These are the steps:
+
+1. Recalculate all emissions for the Cycle of interest;
+2. Group Cycle emissions based on their `inputProductionGroupId` lookup value and sum them up;
+3. Divide the sum of each emission group by the average crop yield (from FAOSTAT) to get emissions per kg of product;
+4. Multiply by `seed.value` to get total background `emissions` from seed production per ha.
+"""
+from functools import reduce
+from hestia_earth.schema import TermTermType, EmissionMethodTier, SiteSiteType
+from hestia_earth.utils.lookup import download_lookup, column_name, get_table_value, extract_grouped_data_closest_date
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import non_empty_list, flatten, list_sum, safe_parse_float
+from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.site import valid_site_type
+from hestia_earth.models.utils.cycle import cycle_end_year
+from hestia_earth.models.utils.crop import get_crop_grouping_faostat_production, get_landCover_term_id
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.product": "True",
+        "endDate": "",
+        "inputs": [{
+            "@type": "Input",
+            "term.termType": "seed",
+            "value": "> 0",
+            "none": {
+                "impactAssessment": "",
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }],
+        "products": [{
+            "@type": "Product",
+            "term.termType": "crop",
+            "optional": {
+                "economicValueShare": "> 0"
+            }
+        }],
+        "site": {
+            "@type": "Site",
+            "siteType": ["cropland", "glass or high accessible cover"],
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "emissions": [{"@type": "Emission"}]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "methodTier": "background"
+    }]
+}
+LOOKUPS = {
+    "region-crop-cropGroupingFaostatProduction-yield": "value from cropGroupingFaostatProduction and country",
+    "crop": [
+        "correspondingSeedTermIds",
+        "cropGroupingFaostatProduction",
+        "global_economic_value_share",
+        "landCoverTermId"
+    ],
+    "emission": "inputProductionGroupId"
+}
+MODEL_KEY = 'seed_emissions'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [round(value, 7)]
+    emission['inputs'] = [input]
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _run(cycle: dict, economicValueShare: float, total_yield: float, seed_input: dict, grouped_emissions: dict):
+    term = seed_input.get('term', {})
+    seed_value = list_sum(seed_input.get('value'))
+    return [
+        _emission(term_id, emission_value * economicValueShare / 100 / total_yield * seed_value, term)
+        for term_id, emission_value in grouped_emissions.items()
+    ]
+
+
+def _filter_emissions(cycle: dict):
+    required_emission_term_ids = cycle_emissions_in_system_boundary(cycle)
+
+    emissions = [
+        {
+            'id': i.get('term', {}).get('@id'),
+            'group-id': get_lookup_value(i.get('term', {}), LOOKUPS['emission'], model=MODEL, model_key=MODEL_KEY),
+            'value': list_sum(i.get('value'), 0)
+        }
+        for i in cycle.get('emissions', [])
+        if all([
+            i.get('term', {}).get('@id') in required_emission_term_ids,
+            list_sum(i.get('value'), 0) > 0
+        ])
+    ]
+    emission_ids = set([v.get('id') for v in emissions])
+    group_ids = set([v.get('group-id') for v in emissions if v.get('group-id')])
+
+    # for each group, get the list of all required emissions
+    lookup = download_lookup('emission.csv')
+    emissions_per_group = [
+        {
+            'id': group_id,
+            'emissions': list(filter(
+                lambda id: id in required_emission_term_ids,
+                list(lookup[lookup[column_name('inputProductionGroupId')] == group_id].termid)
+            ))
+        }
+        for group_id in group_ids
+    ]
+    emissions_per_group = [
+        {
+            'id': group.get('id'),
+            'total-emissions': len(group.get('emissions', [])),
+            'included-emissions': len([v in emission_ids for v in group.get('emissions', [])]),
+            'missing-emissions': '-'.join([v for v in group.get('emissions', []) if v not in emission_ids])
+        }
+        for group in emissions_per_group
+    ]
+    # only keep groups that have all emissions present in the Cycle
+    valid_groups = list(filter(
+        lambda group: group.get('total-emissions') == group.get('included-emissions'),
+        emissions_per_group
+    ))
+    valid_group_ids = set([v.get('id') for v in valid_groups])
+
+    # finally, only return emissions which groups are valid
+    return list(filter(
+        lambda emission: emission.get('group-id') in valid_group_ids,
+        emissions
+    )), emissions_per_group
+
+
+def _evs(product: dict):
+    return safe_parse_float(
+        get_lookup_value(product.get('term', {}), 'global_economic_value_share', model=MODEL, model_key=MODEL_KEY)
+    ) or product.get('economicValueShare')
+
+
+def _yield(country_id: str, end_year: int, product: dict):
+    grouping = get_crop_grouping_faostat_production(MODEL, product.get('term', {}))
+    return safe_parse_float(extract_grouped_data_closest_date(get_table_value(
+        download_lookup('region-crop-cropGroupingFaostatProduction-yield.csv'),
+        'termid',
+        country_id,
+        column_name(grouping)
+    ), end_year)) or list_sum(product.get('value'))
+
+
+def _group_seed_inputs(inputs: list):
+    def _group_by(group: dict, input: dict):
+        term_id = input.get('term', {}).get('@id')
+        group[term_id] = group.get(term_id, []) + [input]
+        return group
+
+    grouped_inputs = reduce(_group_by, inputs, {})
+    return [
+        inputs[0] | {'value': flatten([v.get('value') for v in inputs])}
+        for inputs in grouped_inputs.values()
+    ]
+
+
+def _should_run(cycle: dict):
+    crop_products = filter_list_term_type(cycle.get('products', []), TermTermType.CROP)
+    site_type_valid = valid_site_type(cycle.get('site', {}), [
+        SiteSiteType.CROPLAND.value, SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+    ])
+    is_product_complete = _is_term_type_complete(cycle, 'product')
+    end_year = cycle_end_year(cycle)
+    country_id = cycle.get('site', {}).get('country', {}).get('@id')
+
+    # only keep the crop products that map to a seed
+    crop_products = [
+        {
+            'product': product.get('term', {}).get('@id'),
+            'seed-id': get_lookup_value(
+                product.get('term', {}), 'correspondingSeedTermIds', model=MODEL, key=MODEL_KEY),
+            'economicValueShare': _evs(product),
+            'yield': _yield(country_id, end_year, product),
+            'landCover-id': get_landCover_term_id(product.get('term', {}), model=MODEL, key=MODEL_KEY)
+        }
+        for product in crop_products
+    ]
+    valid_crop_products = [
+        value for value in crop_products if all([
+            value.get('seed-id'),
+            value.get('economicValueShare'),
+            value.get('yield'),
+            value.get('landCover-id'),
+        ])
+    ]
+
+    # array of ; delimited values
+    seed_term_ids = list(set(flatten([v.get('seed-id').split(';') for v in valid_crop_products if v.get('seed-id')])))
+
+    seed_inputs = [
+        i
+        for i in cycle.get('inputs', [])
+        if all([
+            i.get('term', {}).get('termType') == TermTermType.SEED.value,
+            i.get('term', {}).get('@id') in seed_term_ids,
+            list_sum(i.get('value'), 0) > 0,
+            not i.get('impactAssessment'),
+            # ignore inputs which are flagged as Product of the Cycle
+            not i.get('fromCycle', False),
+            not i.get('producedInCycle', False)
+        ])
+    ]
+    # sum up seed inputs with the same id
+    seed_inputs = _group_seed_inputs(seed_inputs)
+
+    crop_land_cover_ids = list(set([p.get('landCover-id') for p in valid_crop_products]))
+    total_economicValueShare = list_sum([p.get('economicValueShare') for p in valid_crop_products])
+    total_yield = list_sum([p.get('yield') for p in valid_crop_products])
+
+    emissions, emissions_per_group = _filter_emissions(cycle)
+    # group emissions with the same group-id
+    grouped_emissions = reduce(
+        lambda p, c: p | {c.get('group-id'): p.get(c.get('group-id'), 0) + c.get('value', 0)},
+        emissions,
+        {}
+    )
+
+    should_run = all([
+        site_type_valid,
+        len(crop_land_cover_ids) <= 1,
+        is_product_complete,
+        total_economicValueShare,
+        total_yield,
+        bool(seed_inputs),
+        bool(emissions)
+    ])
+
+    for seed_input in seed_inputs:
+        term_id = seed_input.get('term', {}).get('@id')
+
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        site_type_valid=site_type_valid,
+                        crop_products=log_as_table(crop_products),
+                        crop_land_cover_ids=';'.join(crop_land_cover_ids),
+                        is_term_type_product_complete=is_product_complete,
+                        total_economicValueShare=total_economicValueShare,
+                        total_yield=total_yield,
+                        end_year=end_year,
+                        country_id=country_id,
+                        emissions=log_as_table(emissions),
+                        emissions_per_group=log_as_table(emissions_per_group))
+
+        logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY)
+
+    return should_run, total_economicValueShare, total_yield, seed_inputs, grouped_emissions
+
+
+def run(cycle: dict):
+    should_run, economicValueShare, total_yield, seed_inputs, grouped_emissions = _should_run(cycle)
+    return flatten(non_empty_list([
+        _run(cycle, economicValueShare, total_yield, seed_input, grouped_emissions)
+        for seed_input in seed_inputs
+    ])) if should_run else []

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -22,7 +22,7 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category, group_by_term_id,
+    BiomassCategory, get_valid_management_nodes, detect_land_cover_change, group_by_biomass_category, group_by_term_id,
     sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
@@ -152,7 +152,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = get_valid_land_cover_terms(site)
+    land_cover = get_valid_management_nodes(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -22,7 +22,7 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category,
+    BiomassCategory, get_valid_management_nodes, detect_land_cover_change, group_by_biomass_category,
     sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
@@ -70,12 +70,16 @@ RETURNS = {
         "statsDefinition": "simulated",
         "observations": "",
         "dates": "",
+        "depthUpper": "0",
+        "depthLower": "30",
         "methodClassification": "tier 1 model"
     }]
 }
 TERM_ID = 'belowGroundBiomass'
 
 _ITERATIONS = 10000
+_DEPTH_UPPER = 0
+_DEPTH_LOWER = 30
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
@@ -145,7 +149,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = get_valid_land_cover_terms(site)
+    land_cover = get_valid_management_nodes(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([
@@ -522,4 +526,6 @@ def _measurement(
     measurement = _new_measurement(TERM_ID) | {
         key: value for key, value in update_dict.items() if value
     }
+    measurement["depthUpper"] = _DEPTH_UPPER
+    measurement["depthLower"] = _DEPTH_LOWER
     return measurement

hestia_earth/models/ipcc2019/biomass_utils.py

@@ -10,9 +10,9 @@ from hestia_earth.utils.blank_node import get_node_value
 from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.utils.array_builders import repeat_single, truncated_normal_1d
-from hestia_earth.models.utils.blank_node import validate_start_date_end_date
+from hestia_earth.models.utils.blank_node import node_term_match, validate_start_date_end_date
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_ecoClimateZone_lookup_grouped_value
-from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.term import get_cover_crop_property_terms, get_lookup_value
 
 
 LOOKUPS = {
@@ -409,9 +409,16 @@ _KWARGS_TO_SAMPLE_FUNC = {
 }
 
 
-def get_valid_land_cover_terms(site: dict) -> list[dict]:
+def get_valid_management_nodes(site: dict) -> list[dict]:
     """Retrieve valid `landCover` nodes from a site's management."""
+    COVER_CROP_TERM_IDS = get_cover_crop_property_terms()
     return [
         node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-        if validate_start_date_end_date(node)
+        if (
+            validate_start_date_end_date(node)
+            and not any(
+                prop.get("value", False) for prop in node.get("properties", [])
+                if node_term_match(prop, COVER_CROP_TERM_IDS)
+            )
+        )
     ]

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.lookup import column_name, download_lookup, get_table_va
 from hestia_earth.utils.model import find_primary_product, find_term_match
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
-from hestia_earth.models.log import debugMissingLookup, debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugMissingLookup, debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import get_total_value_converted_with_min_ratio
 from hestia_earth.models.utils.input import get_feed_inputs
 from hestia_earth.models.utils.emission import _new_emission
@@ -103,13 +103,18 @@ def _emission(value: float, sd: float = None, min: float = None, max: float = No
     return emission
 
 
-def _run(feed: float, enteric_factor: float = None, enteric_sd: float = None, default_values=(None, None, None)):
-    value = (feed * ((enteric_factor or default_values[0]) / 100)) / METHANE_EC
-    min = (feed * (default_values[1] / 100)) / METHANE_EC if all([enteric_factor is None, default_values[1]]) else None
-    max = (feed * (default_values[2] / 100)) / METHANE_EC if all([enteric_factor is None, default_values[2]]) else None
-    description = f"Average Ym factor of {default_values[0]}% used as data missing to differentiate Ym." if all([
+def _run(feed: float, enteric_factor: float = None, enteric_sd: float = None, default_values: dict = {}):
+    default_value = default_values.get('value')
+    value = (feed * ((enteric_factor or default_value) / 100)) / METHANE_EC
+    min = (feed * (default_values.get('min') / 100)) / METHANE_EC if all([
+        enteric_factor is None, default_values.get('min')
+    ]) else None
+    max = (feed * (default_values.get('max') / 100)) / METHANE_EC if all([
+        enteric_factor is None, default_values.get('max')
+    ]) else None
+    description = f"Average Ym factor of {default_value}% used as data missing to differentiate Ym." if all([
         enteric_factor is None,
-        default_values[0] is not None
+        default_value is not None
     ]) else None
     return [
         _emission(value, enteric_sd, min, max, description)
@@ -204,7 +209,11 @@ def _get_default_values(lookup, term: dict):
     value = get_table_value(lookup, 'termid', term_id, column_name(LOOKUPS['liveAnimal'][3])) if term_id else None
     min = get_table_value(lookup, 'termid', term_id, column_name(LOOKUPS['liveAnimal'][4])) if term_id else None
     max = get_table_value(lookup, 'termid', term_id, column_name(LOOKUPS['liveAnimal'][5])) if term_id else None
-    return safe_parse_float(value, None), safe_parse_float(min, None), safe_parse_float(max, None)
+    return {
+        'value': safe_parse_float(value, None),
+        'min': safe_parse_float(min, None),
+        'max': safe_parse_float(max, None)
+    }
 
 
 def _should_run(cycle: dict):
@@ -250,7 +259,7 @@ def _should_run(cycle: dict):
                 milk_yield=milk_yield,
                 enteric_factor=enteric_factor,
                 enteric_sd=enteric_sd,
-                default_values=';'.join(map(str, default_values)))
+                default_values=log_as_table(default_values))
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     term_type_animalFeed_complete=is_animalFeed_complete,
@@ -259,7 +268,7 @@ def _should_run(cycle: dict):
 
     should_run = all([
         is_animalFeed_complete, is_freshForage_complete, total_feed,
-        enteric_factor or default_values[0]
+        enteric_factor or default_values.get('value')
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, total_feed, enteric_factor, enteric_sd, default_values

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -4,7 +4,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
-from .biomass_utils import detect_land_cover_change, summarise_land_cover_nodes
+from .biomass_utils import detect_land_cover_change, get_valid_management_nodes, summarise_land_cover_nodes
 from .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
 from . import MODEL
 
@@ -133,6 +133,7 @@ def run(cycle: dict) -> list[dict]:
     """
     should_run_exec = create_should_run_function(
         carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        get_valid_management_nodes_func=get_valid_management_nodes,
         should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=summarise_land_cover_nodes,
         detect_land_use_change_func=detect_land_cover_change,

hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -4,7 +4,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
-from .biomass_utils import detect_land_cover_change, summarise_land_cover_nodes
+from .biomass_utils import detect_land_cover_change, get_valid_management_nodes, summarise_land_cover_nodes
 from .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
 from . import MODEL
 
@@ -125,6 +125,7 @@ def run(cycle: dict) -> list[dict]:
     """
     should_run_exec = create_should_run_function(
         carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        get_valid_management_nodes_func=get_valid_management_nodes,
         should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=summarise_land_cover_nodes,
         detect_land_use_change_func=detect_land_cover_change,

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -13,10 +13,9 @@ from pydash.objects import merge
 from typing import Any, Callable, NamedTuple, Optional, Union
 
 from hestia_earth.schema import (
-    EmissionMethodTier, EmissionStatsDefinition, MeasurementMethodClassification, TermTermType
+    EmissionMethodTier, EmissionStatsDefinition, MeasurementMethodClassification
 )
 from hestia_earth.utils.date import diff_in_days, YEAR
-from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 
 from hestia_earth.models.log import log_as_table
@@ -24,7 +23,7 @@ from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.array_builders import correlated_normal_2d, gen_seed
 from hestia_earth.models.utils.blank_node import (
     _gapfill_datestr, _get_datestr_format, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match,
-    split_node_by_dates, validate_start_date_end_date
+    split_node_by_dates
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -327,6 +326,7 @@ def _add_carbon_stock_change_emissions(
 def create_should_run_function(
     *,
     carbon_stock_term_id: str,
+    get_valid_management_nodes_func: Callable[[dict], list[dict]],
     should_compile_inventory_func: Callable[[dict, list[dict], list[dict]], tuple[bool, dict]],
     summarise_land_use_func: Callable[[list[dict]], Any],
     detect_land_use_change_func: Callable[[Any, Any], bool],
@@ -351,6 +351,10 @@ def create_should_run_function(
         `(site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]) -> (should_run: bool, logs: dict)`, to
         determine whether there is enough site and cycles data available to compile the carbon stock change inventory.
 
+    get_valid_management_nodes_func : Callable[[dict], list[dict]]
+        A function, with the signature... `(site: dict) -> management_nodes: list[dict]` to extract valid management
+        nodes from the site for building the land use inventory.
+
     summarise_land_use_func: Callable[[list[dict]], Any]
         A function with the signature `(nodes: list[dict]) -> Any`, to reduce a list of `landCover`
         [Management](https://www.hestia.earth/schema/Management) nodes into a land use summary that can be compared
@@ -418,10 +422,7 @@ def create_should_run_function(
             ])
         ]
 
-        land_cover_nodes = [
-            node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-            if validate_start_date_end_date(node)
-        ]
+        land_cover_nodes = get_valid_management_nodes_func(site)
 
         seed = gen_seed(site)  # All cycles linked to the same site should be consistent
         rng = random.default_rng(seed)

hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChange.py

@@ -4,7 +4,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
-from .organicCarbonPerHa_tier_1_utils import _assign_ipcc_land_use_category
+from .organicCarbonPerHa_tier_1_utils import _assign_ipcc_land_use_category, get_valid_management_nodes
 from .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
 from . import MODEL
 
@@ -125,6 +125,7 @@ def run(cycle: dict) -> list[dict]:
     """
     should_run_exec = create_should_run_function(
         carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        get_valid_management_nodes_func=get_valid_management_nodes,
         should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=lambda nodes: _assign_ipcc_land_use_category(nodes, None),
         detect_land_use_change_func=lambda a, b: a != b,