hestia-earth-models 0.57.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

hestia_earth/models/ipcc2019/organicCarbonPerHa.py

@@ -4,13 +4,8 @@ changes. This model combines the Tier 1 & Tier 2 methodologies. It first tries t
 remaining croplands). If Tier 2 cannot run, it will try to run Tier 1 (for croplands remaining croplands and for
 grasslands remaining grasslands). Source:
 [IPCC 2019, Vol. 4, Chapter 10](https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch05_Cropland.pdf).
-
-Currently, the Tier 2 implementation does not take into account the irrigation of cycles when estimating soil organic
-carbon stock changes.
 """
-from collections.abc import Iterable
 from enum import Enum
-from functools import reduce
 from numpy import exp
 from pydash.objects import merge
 from statistics import mean
@@ -21,21 +16,23 @@ from typing import (
     Union
 )
 from hestia_earth.schema import (
+    CycleFunctionalUnit,
     MeasurementMethodClassification,
     SiteSiteType,
-    TermTermType
+    TermTermType,
 )
-from hestia_earth.utils.date import diff_in_years
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
-from hestia_earth.utils.tools import flatten, list_sum, non_empty_list, safe_parse_date
+from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
 
-from hestia_earth.models.log import logShouldRun, log_as_table
+from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match,
     cumulative_nodes_lookup_match,
     cumulative_nodes_term_match,
     get_node_value,
+    group_nodes_by_year_and_month,
     group_nodes_by_year,
+    GroupNodesByYearMode,
     node_lookup_match,
     node_term_match
 )
@@ -43,8 +40,6 @@ from hestia_earth.models.utils.cycle import check_cycle_site_ids_identical
 from hestia_earth.models.utils.ecoClimateZone import get_ecoClimateZone_lookup_value
 from hestia_earth.models.utils.measurement import (
     _new_measurement,
-    group_measurement_values_by_year,
-    most_relevant_measurement_value_by_depth_and_date
 )
 from hestia_earth.models.utils.property import get_node_property
 from hestia_earth.models.utils.site import related_cycles
@@ -52,10 +47,13 @@ from hestia_earth.models.utils.term import (
     get_cover_crop_property_terms,
     get_crop_residue_incorporated_or_left_on_field_terms,
     get_irrigated_terms,
+    get_long_fallow_land_cover_terms,
     get_residue_removed_or_burnt_terms,
-    get_rice_plant_upland_terms
+    get_upland_rice_crop_terms,
+    get_upland_rice_land_cover_terms
 )
 
+from .utils import check_consecutive
 from . import MODEL
 
 REQUIREMENTS = {
@@ -115,6 +113,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
+    "crop": "IPCC_LAND_USE_CATEGORY",
     "ecoClimateZone": [
         "IPCC_2019_SOC_REF_KG_C_HECTARE_SAN",
         "IPCC_2019_SOC_REF_KG_C_HECTARE_WET",
@@ -168,6 +167,7 @@ TERM_ID = 'organicCarbonPerHa'
 
 MIN_AREA_THRESHOLD = 30  # 30% as per IPCC guidelines
 SUPER_MAJORITY_AREA_THRESHOLD = 100 - MIN_AREA_THRESHOLD
+MIN_YIELD_THRESHOLD = 1
 DEPTH_UPPER = 0
 DEPTH_LOWER = 30
 
@@ -221,6 +221,14 @@ DEFAULT_PARAMS = {
     "default_lignin_content": 0.073
 }
 
+VALID_SITE_TYPES_TIER_2 = [
+    SiteSiteType.CROPLAND.value
+]
+
+VALID_FUNCTIONAL_UNITS_TIER_2 = [
+    CycleFunctionalUnit._1_HA.value
+]
+
 # --- TIER 1 CONSTANTS ---
 
 CLAY_CONTENT_TERM_ID = "clayContent"
@@ -231,8 +239,6 @@ ANIMAL_MANURE_USED_TERM_ID = "animalManureUsed"
 INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID = "inorganicNitrogenFertiliserUsed"
 ORGANIC_FERTILISER_USED_TERM_ID = "organicFertiliserOrSoilCarbonIncreasingAmendmentUsed"
 
-DEFAULT_NODE_VALUE = 100
-
 CLAY_CONTENT_MAX = 8
 SAND_CONTENT_MIN = 70
 
@@ -242,6 +248,13 @@ The number of years required for soil organic carbon to reach equilibrium after
 a change in land use, management regime or carbon input regime.
 """
 
+VALID_SITE_TYPES_TIER_1 = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.FOREST.value,
+    SiteSiteType.OTHER_NATURAL_VEGETATION.value,
+    SiteSiteType.PERMANENT_PASTURE.value,
+]
+
 # --- SHARED TIER 1 & TIER 2 FORMAT MEASUREMENT OUTPUT ---
 
 
@@ -274,112 +287,115 @@ def _measurement(year: int, value: float, method_classification: str) -> dict:
 
 # --- SHARED TIER 1 & TIER 2 ENUMS ---
 
-
-IpccManagementCategory = Enum("IpccManagementCategory", [
-    "SEVERELY_DEGRADED",
-    "IMPROVED_GRASSLAND",
-    "HIGH_INTENSITY_GRAZING",
-    "NOMINALLY_MANAGED",
-    "FULL_TILLAGE",
-    "REDUCED_TILLAGE",
-    "NO_TILLAGE",
-    "OTHER"
-])
-"""
-Enum representing IPCC Management Categories for grasslands and annual
-croplands.
-
-See [IPCC (2019) Vol. 4, Ch. 5 and 6](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
-"""
-
-
-# --- TIER 2 ENUMS ---
-
-
-_InnerKey = Enum(
-    "_InnerKey",
-    [
-        "TEMPERATURES",
-        "PRECIPITATIONS",
-        "PETS",
-        "IS_IRRIGATEDS",
-        "CARBON_SOURCES",
-        "TILLAGE_CATEGORY"
-    ],
-)
-
-
-INNER_KEYS_RUN_WITH_IRRIGATION = [
-    _InnerKey.TEMPERATURES,
-    _InnerKey.PRECIPITATIONS,
-    _InnerKey.PETS,
-    _InnerKey.IS_IRRIGATEDS,
-    _InnerKey.CARBON_SOURCES,
-    _InnerKey.TILLAGE_CATEGORY,
+class IpccManagementCategory(Enum):
+    """
+    Enum representing IPCC Management Categories for grasslands and annual croplands.
+
+    See [IPCC (2019) Vol. 4, Ch. 5 and 6](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more
+    information.
+    """
+    SEVERELY_DEGRADED = "severely degraded"
+    IMPROVED_GRASSLAND = "improved grassland"
+    HIGH_INTENSITY_GRAZING = "high-intensity grazing"
+    NOMINALLY_MANAGED = "nominally managed"
+    FULL_TILLAGE = "full tillage"
+    REDUCED_TILLAGE = "reduced tillage"
+    NO_TILLAGE = "no tillage"
+    OTHER = "other"
+
+
+class _InventoryKey(Enum):
+    """
+    Enum representing the inner keys of the annual inventory is constructed from site and cycle data.
+    """
+    # Tier 1
+    LU_CATEGORY = 'ipcc land use category'
+    MG_CATEGORY = 'ipcc management category'
+    CI_CATEGORY = 'ipcc carbon input category'
+    SHOULD_RUN_TIER_1 = 'should run tier 1'
+    # Tier 2
+    TEMP_MONTHLY = 'temperature monthly'
+    PRECIP_MONTHLY = 'precipitation monthly'
+    PET_MONTHLY = 'PET monthly'
+    IRRIGATED_MONTHLY = 'irrigated monthly'
+    CARBON_INPUT = 'carbon input'
+    N_CONTENT = 'nitrogen content'
+    LIGNIN_CONTENT = 'lignin content'
+    TILLAGE_CATEGORY = 'ipcc tillage category'
+    SAND_CONTENT = 'sand content'
+    IS_PADDY_RICE = 'is paddy rice'
+    SHOULD_RUN_TIER_2 = 'should run tier 2'
+
+
+REQUIRED_KEYS_TIER_1 = [
+    _InventoryKey.LU_CATEGORY,
+    _InventoryKey.MG_CATEGORY,
+    _InventoryKey.CI_CATEGORY
 ]
 
-INNER_KEYS_RUN_WITHOUT_IRRIGATION = [
-    _InnerKey.TEMPERATURES,
-    _InnerKey.PRECIPITATIONS,
-    _InnerKey.PETS,
-    _InnerKey.CARBON_SOURCES,
-    _InnerKey.TILLAGE_CATEGORY,
+
+REQUIRED_KEYS_TIER_2 = [
+    _InventoryKey.TEMP_MONTHLY,
+    _InventoryKey.PRECIP_MONTHLY,
+    _InventoryKey.PET_MONTHLY,
+    _InventoryKey.CARBON_INPUT,
+    _InventoryKey.N_CONTENT,
+    _InventoryKey.LIGNIN_CONTENT,
+    _InventoryKey.TILLAGE_CATEGORY,
+    _InventoryKey.IS_PADDY_RICE
 ]
 
 
 # --- TIER 1 ENUMS ---
 
 
-IpccSoilCategory = Enum("IpccSoilCategory", [
-    "ORGANIC_SOILS",
-    "SANDY_SOILS",
-    "WETLAND_SOILS",
-    "VOLCANIC_SOILS",
-    "SPODIC_SOILS",
-    "HIGH_ACTIVITY_CLAY_SOILS",
-    "LOW_ACTIVITY_CLAY_SOILS",
-])
-"""
-Enum representing IPCC Soil Categories.
+class IpccSoilCategory(Enum):
+    """
+    Enum representing IPCC Soil Categories.
 
-See [IPCC (2019) Vol 4, Ch. 2 and 3](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
-"""
+    See [IPCC (2019) Vol 4, Ch. 2 and 3](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more
+    information.
+    """
+    ORGANIC_SOILS = "organic soils"
+    SANDY_SOILS = "sandy soils"
+    WETLAND_SOILS = "wetland soils"
+    VOLCANIC_SOILS = "volcanic soils"
+    SPODIC_SOILS = "spodic soils"
+    HIGH_ACTIVITY_CLAY_SOILS = "high-activity clay soils"
+    LOW_ACTIVITY_CLAY_SOILS = "low-activity clay soils"
 
 
-IpccLandUseCategory = Enum("IpccLandUseCategory", [
-    "GRASSLAND",
-    "PERENNIAL_CROPS",
-    "PADDY_RICE_CULTIVATION",
-    "ANNUAL_CROPS_WET",
-    "ANNUAL_CROPS",
-    "SET_ASIDE",
-    "FOREST",
-    "NATIVE",
-    "OTHER"
-])
-"""
-Enum representing IPCC Land Use Categories.
+class IpccLandUseCategory(Enum):
+    """
+    Enum representing IPCC Land Use Categories.
 
-See [IPCC (2019) Vol 4](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
-"""
+    See [IPCC (2019) Vol 4](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
+    """
+    GRASSLAND = "grassland"
+    PERENNIAL_CROPS = "perennial crops"
+    PADDY_RICE_CULTIVATION = "paddy rice cultivation"
+    ANNUAL_CROPS_WET = "annual crops (wet)"
+    ANNUAL_CROPS = "annual crops"
+    SET_ASIDE = "set aside"
+    FOREST = "forest"
+    NATIVE = "native"
+    OTHER = "other"
 
 
-IpccCarbonInputCategory = Enum("IpccCarbonInputCategory", [
-    "GRASSLAND_HIGH",
-    "GRASSLAND_MEDIUM",
-    "CROPLAND_HIGH_WITH_MANURE",
-    "CROPLAND_HIGH_WITHOUT_MANURE",
-    "CROPLAND_MEDIUM",
-    "CROPLAND_LOW",
-    "OTHER"
-])
-"""
-Enum representing IPCC Carbon Input Categories for improved grasslands
-and annual croplands.
+class IpccCarbonInputCategory(Enum):
+    """
+    Enum representing IPCC Carbon Input Categories for improved grasslands and annual croplands.
 
-See [IPCC (2019) Vol. 4, Ch. 4, 5 and 6](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html)
-for more information.
-"""
+    See [IPCC (2019) Vol. 4, Ch. 4, 5 and 6](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more
+    information.
+    """
+    GRASSLAND_HIGH = "grassland high"
+    GRASSLAND_MEDIUM = "grassland medium"
+    CROPLAND_HIGH_WITH_MANURE = "cropland high (with manure)"
+    CROPLAND_HIGH_WITHOUT_MANURE = "cropland high (without manure)"
+    CROPLAND_MEDIUM = "cropland medium"
+    CROPLAND_LOW = "cropland low"
+    OTHER = "other"
 
 
 # --- TIER 2 NAMED TUPLES FOR CARBON SOURCES AND MODEL RESULTS ---
@@ -448,33 +464,6 @@ annual_water_factors : list[float]
 """
 
 
-CarbonInputResult = NamedTuple(
-    "CarbonInputResult",
-    [
-        ("timestamps", list[float]),
-        ("organic_carbon_inputs", list[float]),
-        ("average_nitrogen_contents", list[float]),
-        ("average_lignin_contents", list[float]),
-    ]
-)
-"""
-A named tuple to hold the result of `_run_annual_organic_carbon_inputs`.
-
-Attributes
-----------
-timestamps : list[int]
-    A list of integer timestamps (e.g. `[1995, 1996]`) for each year in the inventory.
-organic_carbon_inputs : list[float]
-    A list of organic carbon inputs to the soil for each year in the inventory, kg C ha-1.
-average_nitrogen_contents : list[float]
-    A list of the average nitrogen contents of the carbon sources for each year in the inventory, decimal_proportion,
-    kg N (kg d.m.)-1.
-average_lignin_contents : list[float]
-    A list of the average lignin contents of the carbon sources for each year in the inventory, decimal_proportion,
-    kg lignin (kg d.m.)-1.
-"""
-
-
 Tier2SocResult = NamedTuple(
     "Tier2SocResult",
     [
@@ -522,45 +511,6 @@ carbon_input_factor : float
     The stock change factor for mineral soil organic C for the input of organic amendments, dimensionless.
 """
 
-CarbonInputArgs = NamedTuple("CarbonInputArgs", [
-    ("num_grassland_improvements", int),
-    ("has_irrigation", bool),
-    ("has_residue_removed_or_burnt", bool),
-    ("has_low_residue_producing_crops", bool),
-    ("has_bare_fallow", bool),
-    ("has_n_fixing_crop_or_inorganic_n_fertiliser_used", bool),
-    ("has_practice_increasing_c_input", bool),
-    ("has_cover_crop", bool),
-    ("has_organic_fertiliser_or_soil_amendment_used", bool),
-    ("has_animal_manure_used", bool)
-])
-"""
-Named tuple representing the arguments for the functions assigning `IpccCarbonInputCategories` to inventory years.
-
-Attributes
-----------
-num_grassland_improvements : int
-    The number of grassland improvements.
-    has_irrigation : bool
-        Indicates whether irrigation is applied to more than 30% of the site.
-    has_residue_removed_or_burnt : bool
-        Indicates whether residues are removed or burnt on more than 30% of the site.
-    has_low_residue_producing_crops : bool
-        Indicates whether low residue-producing crops are present on more than 70% of the site.
-    has_bare_fallow : bool
-        Indicates whether bare fallow is present on more than 30% of the site.
-    has_n_fixing_crop_or_inorganic_n_fertiliser_used : bool
-        Indicates whether a nitrogen-fixing crop or inorganic nitrogen fertiliser is used on more than 30% of the site.
-    has_practice_increasing_c_input : bool
-        Indicates whether practices increasing carbon input are present on more than 30% of the site.
-    has_cover_crop : bool
-        Indicates whether cover crops are present on more than 30% of the site.
-    has_organic_fertiliser_or_soil_amendment_used : bool
-        Indicates whether organic fertiliser or soil amendments are used on more than 30% of the site.
-    has_animal_manure_used : bool
-        Indicates whether animal manure is used on more than 30% of the site.
-"""
-
 
 # --- SHARED TIER 1 & TIER 2 MAPPING DICTS ---
 
@@ -650,8 +600,8 @@ IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE = {
     IpccSoilCategory.LOW_ACTIVITY_CLAY_SOILS: "Low-activity clay soils",
 }
 """
-A dictionary mapping IPCC soil categories to corresponding soil type and USDA soil type lookup values
-in the `"IPCC_SOIL_CATEGORY"` column.
+A dictionary mapping IPCC soil categories to corresponding soil type and USDA soil type lookup values in the
+`"IPCC_SOIL_CATEGORY"` column.
 """
 
 IPCC_LAND_USE_CATEGORY_TO_SITE_TYPE = {
@@ -675,8 +625,8 @@ IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE = {
     IpccLandUseCategory.ANNUAL_CROPS: "Annual crops"
 }
 """
-A dictionary mapping IPCC land use categories to corresponding land cover lookup values
-in the `"IPCC_LAND_USE_CATEGORY"` column.
+A dictionary mapping IPCC land use categories to corresponding land cover lookup values in the
+`"IPCC_LAND_USE_CATEGORY"` column.
 """
 
 IPCC_MANAGEMENT_CATEGORY_TO_GRASSLAND_MANAGEMENT_TERM_ID = {
@@ -687,8 +637,8 @@ IPCC_MANAGEMENT_CATEGORY_TO_GRASSLAND_MANAGEMENT_TERM_ID = {
     IpccManagementCategory.OTHER: "nativePasture"
 }
 """
-A dictionary mapping IPCC management categories to corresponding grassland management term IDs from the
-land cover glossary.
+A dictionary mapping IPCC management categories to corresponding grassland management term IDs from the land cover
+glossary.
 """
 
 
@@ -745,8 +695,7 @@ def _check_cycle_tillage_management_category(
         tillage_nodes,
         lookup=LOOKUP,
         target_lookup_values=target_lookup_values,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     ) and (
         key is not IpccManagementCategory.NO_TILLAGE
         or _check_zero_tillages(tillage_nodes)
@@ -1515,18 +1464,16 @@ def _run_soc_stocks(
     annual_temperature_factors: list[float],
     annual_water_factors: list[float],
     annual_organic_carbon_inputs: list[float],
-    annual_average_nitrogen_contents_of_organic_carbon_sources: list[float],
-    annual_average_lignin_contents_of_organic_carbon_sources: list[float],
+    annual_n_contents: list[float],
+    annual_lignin_contents: list[float],
     annual_tillage_categories: Union[list[IpccManagementCategory], None] = None,
     sand_content: float = 0.33,
     run_in_period: int = 5,
-    initial_soc_stock: Union[float, None] = None,
     params: Union[dict[str, float], None] = None,
 ) -> Tier2SocResult:
     """
     Run the IPCC Tier 2 SOC model with precomputed `annual_temperature_factors`, `annual_water_factors`,
-    `annual_organic_carbon_inputs`, `annual_average_nitrogen_contents_of_organic_carbon_sources`,
-    `annual_average_lignin_contents_of_organic_carbon_sources`.
+    `annual_organic_carbon_inputs`, `annual_n_contents`, `annual_lignin_contents`.
 
     Parameters
     ----------
@@ -1537,22 +1484,20 @@ def _run_soc_stocks(
     annual_water_factors : list[float]
         A list of water factors for each year in the inventory, dimensionless (see Equation 5.0F).
     annual_organic_carbon_inputs : list[float]
-        A list of organic carbon inputs to the soil for each year in the inventory, kg C ha-1 year-1
-        (see Equation 5.0H).
-    annual_average_nitrogen_contents_of_organic_carbon_sources : list[float]
-        A list of the average nitrogen contents of the organic carbon sources for each year in the inventory,
-        decimal proportion.
-    annual_average_lignin_contents_of_organic_carbon_sources : list[float]
-        A list of the average lignin contents of the organic carbon sources for each year in the inventory,
-        decimal proportion.
+        A list of organic carbon inputs to the soil for each year in the inventory, kg C ha-1 year-1 (see Equation
+        5.0H).
+    annual_n_contents : list[float]
+        A list of the average nitrogen contents of the organic carbon sources for each year in the inventory, decimal
+        proportion.
+    annual_lignin_contents : list[float]
+        A list of the average lignin contents of the organic carbon sources for each year in the inventory, decimal
+        proportion.
     annual_tillage_categories : list[IpccManagementCategory] | None
         A list of the site"s `IpccManagementCategory`s for each year in the inventory.
     sand_content : float
         The sand content of the site, decimal proportion, default value: `0.33`.
     run_in_period : int
         The length of the run-in period in years, must be greater than or equal to 1, default value: `5`.
-    initial_soc_stock : float | None
-        The measured or pre-computed initial SOC stock at the end of the run-in period, kg C ha-1.
     params : dict[str: float] | None
         Overrides for the model parameters. If `None` only default parameters will be used.
 
@@ -1597,29 +1542,16 @@ def _run_soc_stocks(
 
     # --- SPLIT ANNUAL DATA INTO RUN-IN AND INVENTORY PERIODS ---
 
-    inventory_temperature_factors = timeseries_to_inventory(
-        annual_temperature_factors, run_in_period
-    )
-    inventory_water_factors = timeseries_to_inventory(
-        annual_water_factors, run_in_period
-    )
-    inventory_carbon_inputs = timeseries_to_inventory(
-        annual_organic_carbon_inputs, run_in_period
-    )
-    inventory_nitrogen_contents = timeseries_to_inventory(
-        annual_average_nitrogen_contents_of_organic_carbon_sources, run_in_period
-    )
-    inventory_lignin_contents = timeseries_to_inventory(
-        annual_average_lignin_contents_of_organic_carbon_sources, run_in_period
-    )
+    inventory_temperature_factors = timeseries_to_inventory(annual_temperature_factors, run_in_period)
+    inventory_water_factors = timeseries_to_inventory(annual_water_factors, run_in_period)
+    inventory_carbon_inputs = timeseries_to_inventory(annual_organic_carbon_inputs, run_in_period)
+    inventory_n_contents = timeseries_to_inventory(annual_n_contents, run_in_period)
+    inventory_lignin_contents = timeseries_to_inventory(annual_lignin_contents, run_in_period)
     inventory_f_2s = timeseries_to_inventory(annual_f_2s, run_in_period)
-    inventory_tillage_factors = timeseries_to_inventory(
-        annual_tillage_factors, run_in_period
-    )
+    inventory_tillage_factors = timeseries_to_inventory(annual_tillage_factors, run_in_period)
 
-    inventory_timestamps = timestamps[
-        run_in_period - 1:
-    ]  # The last year of the run-in should be the first year of the inventory
+    # The last year of the run-in should be the first year of the inventory
+    inventory_timestamps = timestamps[run_in_period - 1:]
 
     # --- CALCULATE THE ACTIVE ACTIVE POOL STEADY STATES ---
 
@@ -1641,7 +1573,7 @@ def _run_soc_stocks(
             inventory_carbon_inputs,
             inventory_f_2s,
             inventory_lignin_contents,
-            inventory_nitrogen_contents,
+            inventory_n_contents,
         )
     ]
 
@@ -1731,39 +1663,9 @@ def _run_soc_stocks(
 
     # --- CALCULATE THE ACTIVE, SLOW AND PASSIVE SOC STOCKS ---
 
-    init_total_steady_state = (
-        inventory_active_pool_steady_states[0] +
-        inventory_slow_pool_steady_states[0] + inventory_passive_pool_steady_states[0]
-    )
-
-    init_active_frac = inventory_active_pool_steady_states[0]/init_total_steady_state
-    init_slow_frac = inventory_slow_pool_steady_states[0]/init_total_steady_state
-    init_passive_frac = 1 - (init_active_frac + init_slow_frac)
-
-    inventory_active_pool_soc_stocks = []
-    inventory_slow_pool_soc_stocks = []
-    inventory_passive_pool_soc_stocks = []
-
-    should_calc_run_in = initial_soc_stock is None
-
-    inventory_active_pool_soc_stocks.insert(
-        0,
-        inventory_active_pool_steady_states[0]
-        if should_calc_run_in
-        else init_active_frac * initial_soc_stock,
-    )
-    inventory_slow_pool_soc_stocks.insert(
-        0,
-        inventory_slow_pool_steady_states[0]
-        if should_calc_run_in
-        else init_slow_frac * initial_soc_stock,
-    )
-    inventory_passive_pool_soc_stocks.insert(
-        0,
-        inventory_passive_pool_steady_states[0]
-        if should_calc_run_in
-        else init_passive_frac * initial_soc_stock,
-    )
+    inventory_active_pool_soc_stocks = inventory_active_pool_steady_states[:1]
+    inventory_slow_pool_soc_stocks = inventory_slow_pool_steady_states[:1]
+    inventory_passive_pool_soc_stocks = inventory_passive_pool_steady_states[:1]
 
     for index in range(1, len(inventory_timestamps), 1):
         inventory_active_pool_soc_stocks.insert(
@@ -1804,26 +1706,6 @@ def _run_soc_stocks(
 # --- TIER 2 SUB-MODEL: ANNUAL TEMPERATURE FACTORS ---
 
 
-def _check_consecutive(ints: list[int]) -> bool:
-    """
-    Checks whether a list of integers are consecutive.
-
-    Used to determine whether annualised data is complete from every year from beggining to end.
-
-    Parameters
-    ----------
-    ints : list[int]
-        A list of integer values.
-
-    Returns
-    -------
-    bool
-        Whether or not the list of integers is consecutive.
-    """
-    range_list = list(range(min(ints), max(ints)+1)) if ints else []
-    return all(a == b for a, b in zip(ints, range_list))
-
-
 def _check_12_months(inner_dict: dict, keys: set[Any]):
     """
     Checks whether an inner dict has 12 months of data for each of the required inner keys.
@@ -1848,45 +1730,6 @@ def _check_12_months(inner_dict: dict, keys: set[Any]):
 # --- SUB-MODEL ANNUAL TEMPERATURE FACTORS ---
 
 
-def _should_run_annual_temperature_factors(
-    site: dict
-) -> tuple[bool, dict]:
-    """
-    Extracts, formats and checks data from the site node to determine whether or not to run the annual temperature
-    factors model on a specific Hestia `Site`.
-
-    Parameters
-    ----------
-    site : dict
-        A Hestia `Site` node, see: https://www.hestia.earth/schema/Site.
-
-    Returns
-    -------
-    tuple[bool, dict]
-        `(should_run, grouped_data)`.
-    """
-    measurements = site.get("measurements", [])
-    temperature_monthly = find_term_match(measurements, TEMPERATURE_MONTHLY_TERM_ID, {})
-
-    grouped_data = group_measurement_values_by_year(
-        temperature_monthly,
-        inner_key=_InnerKey.TEMPERATURES,
-        complete_years_only=True
-    )
-
-    should_run = all([
-        all(
-            _check_12_months(inner, {_InnerKey.TEMPERATURES})
-            for inner in grouped_data.values()
-        ),
-        len(grouped_data.keys()) >= MIN_RUN_IN_PERIOD,
-        _check_consecutive(grouped_data.keys())
-    ])
-
-    logShouldRun(site, MODEL, TERM_ID, should_run, sub_model="_run_annual_temperature_factors")
-    return should_run, grouped_data
-
-
 def _run_annual_temperature_factors(
     timestamps: list[int],
     temperatures: list[list[float]],
@@ -1926,77 +1769,6 @@ def _run_annual_temperature_factors(
 # --- TIER 2 SUB-MODEL: ANNUAL WATER FACTORS ---
 
 
-def _should_run_annual_water_factors(
-    site: dict,
-    cycles: list[dict]
-) -> tuple[bool, bool, dict]:
-    """
-    Extracts, formats and checks data from the site and cycle nodes to determine determine whether or not to run the
-    annual water factors model on a specific Hestia `Site` and `Cycle`s.
-
-    TODO: Implement checks for monthly is_irrigateds from cycles.
-
-    Parameters
-    ----------
-    site : dict
-        A Hestia `Site` node, see: https://www.hestia.earth/schema/Site.
-    cycles : list[dict]
-        A list of Hestia `Cycle` nodes, see: https://www.hestia.earth/schema/Cycle.
-
-    Returns
-    -------
-    tuple[bool, bool, dict]
-        `(should_run, run_with_irrigation, grouped_data)`.
-    """
-    measurements = site.get("measurements", [])
-    precipitation_monthly = find_term_match(measurements, PRECIPITATION_MONTHLY_TERM_ID, {})
-    potential_evapotranspiration_monthly = find_term_match(measurements, PET_MONTHLY_TERM_ID, {})
-
-    grouped_precipitations = group_measurement_values_by_year(
-        precipitation_monthly,
-        inner_key=_InnerKey.PRECIPITATIONS,
-        complete_years_only=True
-    )
-    grouped_pets = group_measurement_values_by_year(
-        potential_evapotranspiration_monthly,
-        inner_key=_InnerKey.PETS,
-        complete_years_only=True
-    )
-
-    is_irrigateds = None  # TODO: Implement is_irrigateds check.
-    run_with_irrigation = bool(is_irrigateds)
-
-    grouped_data = (
-        merge(grouped_precipitations, grouped_pets) if is_irrigateds is None else reduce(
-            merge, [grouped_precipitations, grouped_pets, is_irrigateds]
-        )
-    )
-
-    should_run = all([
-        all(
-            _check_12_months(inner, {_InnerKey.PRECIPITATIONS, _InnerKey.PETS})
-            for inner in grouped_data.values()
-        ),
-        not run_with_irrigation or all(
-            _check_12_months(inner, {_InnerKey.IS_IRRIGATEDS})
-            for inner in grouped_data.values()
-        ),
-        len(grouped_data.keys()) >= MIN_RUN_IN_PERIOD,
-        _check_consecutive(grouped_data.keys()),
-        check_cycle_site_ids_identical(cycles)
-    ])
-
-    logShouldRun(
-        site,
-        MODEL,
-        TERM_ID,
-        should_run,
-        sub_model="_run_annual_water_factors",
-        run_with_irrigation=run_with_irrigation
-    )
-    return should_run, run_with_irrigation, grouped_data
-
-
 def _run_annual_water_factors(
     timestamps: list[int],
     precipitations: list[list[float]],
@@ -2109,338 +1881,130 @@ def _get_carbon_sources_from_cycles(cycles: dict) -> list[CarbonSource]:
     return non_empty_list([_iterate_carbon_source(node) for node in inputs_and_products])
 
 
-def _should_run_annual_organic_carbon_inputs(
-    site: dict,
-    cycles: list[dict]
-) -> tuple[bool, dict]:
-    """
-    Extracts, formats and checks data from the site node to determine whether or not to run the annual organic carbon
-    inputs model on a specific set of Hestia `Cycle`s.
+# --- TIER 2 SOC MODEL ---
 
-    Parameters
-    ----------
-    cycles : list[dict]
-        A list of Hestia `Cycle` nodes, see: https://www.hestia.earth/schema/Cycle.
 
-    Returns
-    -------
-    tuple[bool, dict]
-        `(should_run, grouped_data)`.
+def _run_tier_2(
+    inventory: dict[int: dict[_InventoryKey: any]],
+    *,
+    run_in_period: int = 5,
+    run_with_irrigation: bool = True,
+    sand_content: float = 0.33,
+    params: Union[dict[str, float], None] = None,
+    **_
+) -> list[dict]:
     """
-    grouped_cycles = group_nodes_by_year(cycles)
-
-    grouped_data = {
-        year: {
-            _InnerKey.CARBON_SOURCES: _get_carbon_sources_from_cycles(_cycles)
-        } for year, _cycles in grouped_cycles.items()
+    Run the IPCC Tier 2 SOC model on a time series of annual data about a site and the mangagement activities taking
+    place on it. To avoid any errors, the `inventory` parameter must be pre-validated by the `should_run` function.
+
+    The inventory should be in the following shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SHOULD_RUN_TIER_2: bool,
+            _InventoryKey.TEMP_MONTHLY: list[float],
+            _InventoryKey.PRECIP_MONTHLY: list[float],
+            _InventoryKey.PET_MONTHLY: list[float],
+            _InventoryKey.IRRIGATED_MONTHLY: list[bool]
+            _InventoryKey.CARBON_INPUT: float,
+            _InventoryKey.N_CONTENT: float,
+            _InventoryKey.TILLAGE_CATEGORY: IpccManagementCategory,
+            _InventoryKey.SAND_CONTENT: float
+        },
+        ...
     }
+    ```
 
-    should_run = all([
-        len(grouped_data.keys()) >= MIN_RUN_IN_PERIOD,
-        _check_consecutive(grouped_data.keys()),
-        check_cycle_site_ids_identical(cycles)
-    ])
-
-    logShouldRun(site, MODEL, TERM_ID, should_run, sub_model="_run_annual_organic_carbon_inputs")
-    return should_run, grouped_data
-
-
-def _run_annual_organic_carbon_inputs(
-    timestamps: list[int],
-    annual_carbon_sources: list[list[CarbonSource]],
-    default_carbon_content: float = 0.42,
-    default_nitrogen_content: float = 0.0085,
-    default_lignin_content: float = 0.073,
-):
-    """
-    Calculate the organic carbon input, average nitrogen content of carbon sources and average lignin content of carbon
-    sources for each year of the inventory.
-
-    `timestamps` and `annual_carbon_sources` must have the same length.
+    TODO: interpolate between `sandContent` measurements for different years of the inventory
 
     Parameters
     ----------
-    timestamps : list[int]
-        A list of integer timestamps (e.g. `[1995, 1996]`) for each year in the inventory.
-    annual_carbon_sources : list[list[CarbonSource]]
-        A list of carbon sources for each year of the inventory, where each carbon source is a named tupled with the
-        format `(mass: float, carbon_content: float, nitrogen_content: float, lignin_content: float)`
-    default_carbon_content : float
-        The default carbon content of a carbon source, decimal proportion, kg C (kg d.m.)-1, default value: `0.42`.
-    default_nitrogen_content : float
-        The default nitrogen content of a carbon source, decimal proportion, kg N (kg d.m.)-1, default value: `0.0085`.
-    default_lignin_content : float)
-        The default lignin content of a carbon source, decimal proportion, kg lignin (kg d.m.)-1,
-        default value: `0.073`.
+    inventory : dict
+        The inventory built by the `_should_run` function.
+    run_in_period : int, optional
+        The length of the run-in period in years, must be greater than or equal to 1, default value: `5`.
+    run_with_irrigation : bool, optional
+        `True` if the model should run while taking into account irrigation, `False` if not.
+    params : dict | None, optional
+        Overrides for the model parameters. If `None` only default parameters will be used.
 
     Returns
     -------
-    CarbonInputResult
-        An inventory of annual carbon input data as a named tuple with the format
-        `(timestamps: list[int], organic_carbon_inputs: list[float], average_nitrogen_contents: list[float],
-        average_lignin_contents: list[float])`
-    """
-    return CarbonInputResult(
-        timestamps=timestamps,
-        organic_carbon_inputs=[
-            _calc_total_organic_carbon_input(sources, default_carbon_content=default_carbon_content)
-            for sources in annual_carbon_sources
-        ],
-        average_nitrogen_contents=[
-            _calc_average_nitrogen_content_of_organic_carbon_sources(
-                sources, default_nitrogen_content=default_nitrogen_content)
-            for sources in annual_carbon_sources
-        ],
-        average_lignin_contents=[
-            _calc_average_lignin_content_of_organic_carbon_sources(
-                sources, default_lignin_content=default_lignin_content)
-            for sources in annual_carbon_sources
-        ],
-    )
-
-
-# --- TIER 2 SOC MODEL ---
-
-
-def _should_run_tier_2(
-    site: dict
-) -> tuple:
+    list[dict]
+        A list of Hestia `Measurement` nodes containing the calculated SOC stocks and additional relevant data.
     """
-    Extracts, formats and checks data from the site and cycle nodes to determine
-    determine whether or not to run the Tier 2 SOC model.
+    valid_inventory = {
+        year: group for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN_TIER_2)
+    }
 
-    Parameters
-    ----------
-    site : dict
-        A Hestia `Site` node, see: https://www.hestia.earth/schema/Site.
-    cycles : list[dict]
-        A list of Hestia `Cycle` nodes, see: https://www.hestia.earth/schema/Cycle.
+    timestamps = [year for year in valid_inventory.keys()]
 
-    Returns
-    -------
-    tuple
-        `(should_run, timestamps, temperatures, precipitations, pets, carbon_sources, tillage_categories, sand_content,
-        is_irrigateds, run_in_period, initial_soc_stock)`
-    """
-    cycles = related_cycles(site.get("@id"))
+    annual_temperature_monthlys = [group[_InventoryKey.TEMP_MONTHLY] for group in valid_inventory.values()]
+    annual_precipitation_monthlys = [group[_InventoryKey.PRECIP_MONTHLY] for group in valid_inventory.values()]
+    annual_pet_monthlys = [group[_InventoryKey.PET_MONTHLY] for group in valid_inventory.values()]
 
-    should_run_t, grouped_temperature_data = _should_run_annual_temperature_factors(site)
-    should_run_w, run_with_irrigation, grouped_water_data = _should_run_annual_water_factors(site, cycles)
-    should_run_c, grouped_carbon_sources_data = _should_run_annual_organic_carbon_inputs(site, cycles)
+    annual_carbon_inputs = [group[_InventoryKey.CARBON_INPUT] for group in valid_inventory.values()]
+    annual_n_contents = [group[_InventoryKey.N_CONTENT] for group in valid_inventory.values()]
+    annual_lignin_contents = [group[_InventoryKey.LIGNIN_CONTENT] for group in valid_inventory.values()]
+    annual_tillage_categories = [group[_InventoryKey.TILLAGE_CATEGORY] for group in valid_inventory.values()]
+    annual_irrigated_monthly = (
+        [group[_InventoryKey.IRRIGATED_MONTHLY] for group in valid_inventory.values()] if run_with_irrigation else None
+    )
 
-    grouped_cycles = group_nodes_by_year(cycles)
+    sand_content = next(
+        group[_InventoryKey.SAND_CONTENT]/100 for group in valid_inventory.values()
+        if _InventoryKey.SAND_CONTENT in group
+    )
 
-    grouped_tillage_categories = {
-        year: {
-            _InnerKey.TILLAGE_CATEGORY: _assign_tier_2_ipcc_tillage_management_category(_cycles)
-        } for year, _cycles in grouped_cycles.items()
-    }
+    # --- MERGE ANY USER-SET PARAMETERS WITH THE IPCC DEFAULTS ---
 
-    # Combine all the grouped data into one dictionary
-    grouped_data = reduce(merge, [grouped_temperature_data, grouped_water_data,
-                          grouped_carbon_sources_data, grouped_tillage_categories])
+    params = DEFAULT_PARAMS | (params or {})
 
-    # Select the correct keys for data completeness based on `run_with_irrigation`
-    keys = INNER_KEYS_RUN_WITH_IRRIGATION if run_with_irrigation else INNER_KEYS_RUN_WITHOUT_IRRIGATION
+    # --- COMPUTE FACTORS AND CARBON INPUTS ---
 
-    # Filter out any incomplete years
-    complete_data = dict(filter(
-        lambda item: all([key in item[1].keys() for key in keys]),
-        grouped_data.items()
-    ))
+    _, annual_temperature_factors = _run_annual_temperature_factors(
+        timestamps,
+        annual_temperature_monthlys,
+        maximum_temperature=params.get("maximum_temperature"),
+        optimum_temperature=params.get("optimum_temperature")
+    )
 
-    timestamps = list(complete_data)
-    start_year = timestamps[0] if timestamps else 0
-    end_year = timestamps[-1] if timestamps else 0
-
-    measurements = site.get("measurements", [])
-
-    sand_content_value, _ = most_relevant_measurement_value_by_depth_and_date(
-        measurements,
-        SAND_CONTENT_TERM_ID,
-        f"{start_year}-12-31",
-        DEPTH_UPPER,
-        DEPTH_LOWER,
-        depth_strict=False
-    ) if timestamps else (None, None)
-    sand_content = sand_content_value/100 if sand_content_value else None
-
-    initial_soc_stock_value, initial_soc_stock_date = most_relevant_measurement_value_by_depth_and_date(
-        measurements,
-        TERM_ID,
-        f"{end_year}-12-31",
-        DEPTH_UPPER,
-        DEPTH_LOWER,
-        depth_strict=True
-    ) if timestamps else (None, None)
-
-    run_with_initial_soc_stock = bool(initial_soc_stock_value and initial_soc_stock_date)
-
-    run_in_period = (
-        int(abs(diff_in_years(f"{start_year}-12-31", initial_soc_stock_date)) + 1)
-        if run_with_initial_soc_stock else MIN_RUN_IN_PERIOD
-    ) if timestamps else 0
-
-    timestamps = list(complete_data.keys())
-    temperatures = [complete_data[year][_InnerKey.TEMPERATURES] for year in timestamps]
-    precipitations = [complete_data[year][_InnerKey.PRECIPITATIONS] for year in timestamps]
-    pets = [complete_data[year][_InnerKey.PETS] for year in timestamps]
-    annual_carbon_sources = [complete_data[year][_InnerKey.CARBON_SOURCES] for year in timestamps]
-    annual_tillage_categories = [complete_data[year][_InnerKey.TILLAGE_CATEGORY] for year in timestamps]
-    is_irrigateds = (
-        [complete_data[year][_InnerKey.IS_IRRIGATEDS] for year in timestamps] if run_with_irrigation else None
+    _, annual_water_factors = _run_annual_water_factors(
+        timestamps,
+        annual_precipitation_monthlys,
+        annual_pet_monthlys,
+        annual_irrigated_monthly,
+        water_factor_slope=params.get("water_factor_slope")
     )
 
-    should_run = all([
-        should_run_t,
-        should_run_w,
-        should_run_c,
-        sand_content is not None and 0 < sand_content <= 1,
-        run_in_period >= MIN_RUN_IN_PERIOD,
-        len(timestamps) >= run_in_period,
-        check_cycle_site_ids_identical(cycles),
-        _check_consecutive(timestamps)
-    ])
+    # --- RUN THE MODEL ---
 
-    logShouldRun(
-        site,
-        MODEL,
-        TERM_ID,
-        should_run,
-        sub_model="_run_tier_2",
-        run_with_irrigation=run_with_irrigation,
-        run_with_initial_soc_stock=run_with_initial_soc_stock,
-        run_in_period=run_in_period
+    result = _run_soc_stocks(
+        timestamps=timestamps,
+        annual_temperature_factors=annual_temperature_factors,
+        annual_water_factors=annual_water_factors,
+        annual_organic_carbon_inputs=annual_carbon_inputs,
+        annual_n_contents=annual_n_contents,
+        annual_lignin_contents=annual_lignin_contents,
+        annual_tillage_categories=annual_tillage_categories,
+        sand_content=sand_content,
+        run_in_period=run_in_period,
+        params=params
     )
 
-    return (
-        should_run,
-        timestamps,
-        temperatures,
-        precipitations,
-        pets,
-        annual_carbon_sources,
-        annual_tillage_categories,
-        sand_content,
-        is_irrigateds,
-        run_in_period,
-        initial_soc_stock_value
-    )
+    values = [
+        _calc_tier_2_soc_stock(
+            active,
+            slow,
+            passive
+        ) for active, slow, passive in zip(
+            result.active_pool_soc_stocks,
+            result.slow_pool_soc_stocks,
+            result.passive_pool_soc_stocks
+        )
+    ]
 
-
-def _run_tier_2(
-    timestamps: list[int],
-    temperatures: list[list[float]],
-    precipitations: list[list[float]],
-    pets: list[list[float]],
-    annual_carbon_sources: list[list[CarbonSource]],
-    annual_tillage_categories: list[IpccManagementCategory],
-    sand_content: float = 0.33,
-    is_irrigateds: Union[list[list[bool]], None] = None,
-    run_in_period: int = 5,
-    initial_soc_stock: Union[float, None] = None,
-    params: Union[dict[str, float], None] = None,
-) -> list[dict]:
-    """
-    Run the IPCC Tier 2 SOC model on a time series of annual data about a site and the mangagement activities taking
-    place on it. `timestamps` and `annual_`... lists must be the same length.
-
-    Parameters
-    ----------
-    timestamps : list[int]
-        A list of integer timestamps (e.g. [1995, 1996...]) for each year in the inventory.
-    temperatures : list[list[float]]
-        A list of monthly average temperatures for each year in the inventory.
-    precipitations : list[list[float]]
-        A list of monthly sum precipitations for each year in the inventory.
-    pets : list[list[float]]
-        A list of monthly sum potential evapotransiprations for each year in the inventory.
-    annual_carbon_sources : list[list[CarbonSource]]
-        A list of carbon sources for each year of the inventory, where each carbon source is a named tupled with the
-        format `(mass: float, carbon_content: float, nitrogen_content: float, lignin_content: float)`
-    annual_tillage_categories : list[IpccManagementCategory)
-        A list of the site"s IpccManagementCategory for each year in the inventory.
-    sand_content : float
-        The sand content of the site, decimal proportion, default value: `0.33`.
-    is_irrigateds : list[list[bool]] | None
-        A list of monthly booleans that describe whether irrigation is used in a particular calendar month for each
-        year in the inventory.
-    run_in_period : int
-        The length of the run-in period in years, must be greater than or equal to 1, default value: `5`.
-    initial_soc_stock : float | None]
-        The measured or pre-computed initial SOC stock at the end of the run-in period, kg C ha-1.
-    params : dict | None
-        Overrides for the model parameters. If `None` only default parameters will be used.
-
-    Returns
-    -------
-    list[dict]
-        A list of Hestia `Measurement` nodes containing the calculated SOC stocks and additional relevant data.
-    """
-
-    # --- MERGE ANY USER-SET PARAMETERS WITH THE IPCC DEFAULTS ---
-
-    params = DEFAULT_PARAMS | (params or {})
-
-    # --- COMPUTE FACTORS AND CARBON INPUTS ---
-
-    _, annual_temperature_factors = _run_annual_temperature_factors(
-        timestamps,
-        temperatures,
-        maximum_temperature=params.get("maximum_temperature"),
-        optimum_temperature=params.get("optimum_temperature")
-    )
-
-    _, annual_water_factors = _run_annual_water_factors(
-        timestamps,
-        precipitations,
-        pets,
-        is_irrigateds,
-        water_factor_slope=params.get("water_factor_slope")
-    )
-
-    (
-        _,
-        annual_organic_carbon_inputs,
-        annual_nitrogen_contents,
-        annual_lignin_contents
-    ) = _run_annual_organic_carbon_inputs(
-        timestamps,
-        annual_carbon_sources,
-        default_carbon_content=params.get("default_carbon_content"),
-        default_nitrogen_content=params.get("default_nitrogen_content"),
-        default_lignin_content=params.get("default_lignin_content")
-    )
-
-    # --- RUN THE MODEL ---
-
-    result = _run_soc_stocks(
-        timestamps=timestamps,
-        annual_temperature_factors=annual_temperature_factors,
-        annual_water_factors=annual_water_factors,
-        annual_organic_carbon_inputs=annual_organic_carbon_inputs,
-        annual_average_nitrogen_contents_of_organic_carbon_sources=annual_nitrogen_contents,
-        annual_average_lignin_contents_of_organic_carbon_sources=annual_lignin_contents,
-        annual_tillage_categories=annual_tillage_categories,
-        sand_content=sand_content,
-        run_in_period=run_in_period,
-        initial_soc_stock=initial_soc_stock,
-        params=params
-    )
-
-    values = [
-        _calc_tier_2_soc_stock(
-            active,
-            slow,
-            passive
-        ) for active, slow, passive in zip(
-            result.active_pool_soc_stocks,
-            result.slow_pool_soc_stocks,
-            result.passive_pool_soc_stocks
-        )
-    ]
-
-    # --- RETURN MEASUREMENT NODES ---
+    # --- RETURN MEASUREMENT NODES ---
 
     return [
         _measurement(
@@ -2457,32 +2021,6 @@ def _run_tier_2(
 # --- TIER 1 FUNCTIONS ---
 
 
-def _find_closest_value_index(
-    lst: Iterable[Union[int, float]], target_value: Union[int, float]
-) -> Optional[int]:
-    """
-    Find the index of the closest value in a list.
-
-    Parameters
-    ----------
-    lst : iterable[int | float]
-        The list of integers.
-    target : int | float
-        The target value.
-
-    Returns
-    -------
-    int
-        The index of the closest value.
-    """
-    should_run = all([
-        lst,
-        all(isinstance(element, (int, float)) for element in lst),
-        isinstance(target_value, (int, float))
-    ])
-    return min(range(len(lst)), key=lambda i: abs(lst[i] - target_value)) if should_run else None
-
-
 def _retrieve_soc_ref(
     eco_climate_zone: int,
     ipcc_soil_category: IpccSoilCategory
@@ -2519,9 +2057,8 @@ def _retrieve_soc_stock_factors(
     ipcc_carbon_input_category: IpccCarbonInputCategory
 ) -> StockChangeFactors:
     """
-    Retrieve the stock change factors for soil organic carbon (SOC)
-    based on a given combination of land use, management and carbon
-    input.
+    Retrieve the stock change factors for soil organic carbon (SOC) based on a given combination of land use,
+    management and carbon input.
 
     Parameters
     ----------
@@ -2581,8 +2118,8 @@ def _calc_soc_equilibrium(
     """
     Calculate the soil organic carbon (SOC) equilibrium based on reference SOC and factors.
 
-    In the tier 1 model, SOC equilibriums are considered to be reached after 20 years of
-    consistant land use, management and carbon input.
+    In the tier 1 model, SOC equilibriums are considered to be reached after 20 years of consistant land use,
+    management and carbon input.
 
     Parameters
     ----------
@@ -2648,8 +2185,8 @@ def _iterate_soc_equilibriums(
     timestamps: list[int], soc_equilibriums: list[float]
 ) -> tuple[list[int], list[float]]:
     """
-    Iterate over SOC equilibriums, inserting timestamps and soc_equilibriums for any
-    missing years where SOC would have reached equilibrium.
+    Iterate over SOC equilibriums, inserting timestamps and soc_equilibriums for any missing years where SOC would have
+    reached equilibrium.
 
     Parameters
     ----------
@@ -2689,7 +2226,6 @@ def _iterate_soc_equilibriums(
         )
 
     for index, (timestamp, soc_equilibrium) in enumerate(zip(timestamps, soc_equilibriums)):
-
         equilibrium_reached_timestamp = calc_equilibrium_reached_timestamp(index)
 
         if is_missing_equilibrium_year(timestamp, equilibrium_reached_timestamp):
@@ -2710,8 +2246,8 @@ def _run_soc_equilibriums(
     """
     Run the soil organic carbon (SOC) equilibriums calculation for each year in the inventory.
 
-    Missing years where SOC equilibrium would be reached are inserted to allow for annual
-    SOC change to be calculated correctly.
+    Missing years where SOC equilibrium would be reached are inserted to allow for annual SOC change to be calculated
+    correctly.
 
     Parameters
     ----------
@@ -2733,8 +2269,8 @@ def _run_soc_equilibriums(
     Returns
     -------
     tuple[list[int], list[float]]
-        `timestamps` and `soc_equilibriums` for each year in the inventory, including any
-        missing years where SOC equilibrium would have been reached.
+        `timestamps` and `soc_equilibriums` for each year in the inventory, including any missing years where SOC
+        equilibrium would have been reached.
     """
 
     # Calculate SOC equilibriums for each year
@@ -2767,8 +2303,7 @@ def _calc_tier_1_soc_stocks(
     soc_equilibriums: list[float],
 ) -> list[float]:
     """
-    Calculate soil organic carbon (SOC) stocks (kg C ha-1) in the 0-30cm depth interval for each year in
-    the inventory.
+    Calculate soil organic carbon (SOC) stocks (kg C ha-1) in the 0-30cm depth interval for each year in the inventory.
 
     Parameters
     ----------
@@ -2809,62 +2344,6 @@ def _calc_tier_1_soc_stocks(
     return soc_stocks
 
 
-def _calc_measurement_scaling_factor(
-    measured_soc: float, calculated_soc: float
-) -> float:
-    """
-    Calculate the scaling factor soil organic carbon (SOC) values based
-    on the ratio between measured and calculated values.
-
-    Parameters
-    ----------
-    measured_soc : float
-        The measured SOC value.
-    calculated_soc : float
-        The calculated SOC value.
-
-    Returns
-    -------
-    float
-        The scaling factor.
-    """
-    return measured_soc / calculated_soc
-
-
-def _scale_soc_stocks(
-    soc_stocks: list[float],
-    soc_measurement_value: Union[float, None] = None,
-    soc_measurement_index: Union[int, None] = None
-) -> list[float]:
-    """
-    Scale soil organic carbon (SOC) stocks based on a measurement value and index.
-
-    Parameters
-    ----------
-    soc_stocks : list[float]
-        The list of SOC stocks to be scaled.
-    soc_measurement_value : float | None, optional
-        The measured SOC value for scaling. If None, no scaling is applied.
-    soc_measurement_index : int | None, optional
-        The index of the calculated SOC stock to compare against the SOC measurement.
-
-    Returns
-    -------
-    list[float]
-        The scaled SOC stocks.
-    """
-
-    measurement_scaling_factor = (
-        _calc_measurement_scaling_factor(
-            soc_measurement_value,
-            soc_stocks[soc_measurement_index]
-        ) if soc_measurement_value and soc_measurement_index is not None
-        else 1
-    )
-
-    return [value * measurement_scaling_factor for value in soc_stocks]
-
-
 # --- GET THE ECO-CLIMATE ZONE FROM THE MEASUREMENTS ---
 
 
@@ -2883,7 +2362,6 @@ def _get_eco_climate_zone(measurements: list[dict]) -> Optional[int]:
         The eco-climate zone value if found, otherwise None.
     """
     eco_climate_zone = find_term_match(measurements, "ecoClimateZone")
-    # return measurement_value(eco_climate_zone) or None
     return get_node_value(eco_climate_zone) or None
 
 
@@ -2891,10 +2369,10 @@ def _get_eco_climate_zone(measurements: list[dict]) -> Optional[int]:
 
 
 def _check_soil_category(
-    soil_types: list[dict],
-    usda_soil_types: list[dict],
     *,
     key: IpccSoilCategory,
+    soil_types: list[dict],
+    usda_soil_types: list[dict],
     **_
 ) -> bool:
     """
@@ -2902,12 +2380,12 @@ def _check_soil_category(
 
     Parameters
     ----------
+    key : IpccSoilCategory
+        The IPCC soil category to check.
     soil_types : list[dict]
         List of soil type measurement nodes.
     usda_soil_types : list[dict]
         List of USDA soil type measurement nodes
-    key : IpccSoilCategory
-        The IPCC soil category to check.
 
     Returns
     -------
@@ -2923,26 +2401,25 @@ def _check_soil_category(
         soil_types,
         lookup=SOIL_TYPE_LOOKUP,
         target_lookup_values=target_lookup_values,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
     is_usda_soil_type_match = cumulative_nodes_lookup_match(
         usda_soil_types,
         lookup=USDA_SOIL_TYPE_LOOKUP,
         target_lookup_values=target_lookup_values,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
     return is_soil_type_match or is_usda_soil_type_match
 
 
-def _check_sandy_soils(
+def _check_sandy_soil_category(
+    *,
+    key: IpccSoilCategory,
     soil_types: list[dict],
     usda_soil_types: list[dict],
-    *,
-    is_sandy: bool,
+    has_sandy_soil: bool,
     **_
 ) -> bool:
     """
@@ -2952,11 +2429,13 @@ def _check_sandy_soils(
 
     Parameters
     ----------
+    key : IpccSoilCategory
+        The IPCC soil category to check.
     soil_types : list[dict]
         List of soil type measurement nodes.
     usda_soil_types : list[dict]
         List of USDA soil type measurement nodes
-    is_sandy : bool
+    has_sandy_soil : bool
         True if the soils are sandy, False otherwise.
 
     Returns
@@ -2964,13 +2443,12 @@ def _check_sandy_soils(
     bool
         `True` if the soil category matches, `False` otherwise.
     """
-    KEY = IpccSoilCategory.SANDY_SOILS
-    return _check_soil_category(soil_types, usda_soil_types, key=KEY) or is_sandy
+    return _check_soil_category(key=key, soil_types=soil_types, usda_soil_types=usda_soil_types) or has_sandy_soil
 
 
 SOIL_CATEGORY_DECISION_TREE = {
     IpccSoilCategory.ORGANIC_SOILS: _check_soil_category,
-    IpccSoilCategory.SANDY_SOILS: _check_sandy_soils,
+    IpccSoilCategory.SANDY_SOILS: _check_sandy_soil_category,
     IpccSoilCategory.WETLAND_SOILS: _check_soil_category,
     IpccSoilCategory.VOLCANIC_SOILS: _check_soil_category,
     IpccSoilCategory.SPODIC_SOILS: _check_soil_category,
@@ -3009,19 +2487,17 @@ def _assign_ipcc_soil_category(
 
     clay_content = get_node_value(find_term_match(measurements, CLAY_CONTENT_TERM_ID))
     sand_content = get_node_value(find_term_match(measurements, SAND_CONTENT_TERM_ID))
-    # clay_content = measurement_value(find_term_match(measurements, CLAY_CONTENT_TERM_ID))
-    # sand_content = measurement_value(find_term_match(measurements, SAND_CONTENT_TERM_ID))
 
-    is_sandy = clay_content < CLAY_CONTENT_MAX and sand_content > SAND_CONTENT_MIN
+    has_sandy_soil = clay_content < CLAY_CONTENT_MAX and sand_content > SAND_CONTENT_MIN
 
     return next(
         (
             key for key in SOIL_CATEGORY_DECISION_TREE
             if SOIL_CATEGORY_DECISION_TREE[key](
-                soil_types,
-                usda_soil_types,
                 key=key,
-                is_sandy=is_sandy
+                soil_types=soil_types,
+                usda_soil_types=usda_soil_types,
+                has_sandy_soil=has_sandy_soil
             )
         ),
         default
@@ -3048,182 +2524,174 @@ def _has_irrigation(water_regime_nodes: list[dict]) -> bool:
     return cumulative_nodes_term_match(
         water_regime_nodes,
         target_term_ids=get_irrigated_terms(),
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
 
-def _check_ipcc_land_use_category(
-    site_type: str,
-    *,
-    key: IpccLandUseCategory,
-    **_
-):
+def _has_long_fallow(land_cover_nodes: list[dict]) -> bool:
     """
-    Check if the site type matches the target site type for the given key.
+    Check if long fallow terms is present in the land cover nodes.
+
+    n.b., a super majority of the site area must be under long fallow for it to be classified as set aside.
 
     Parameters
     ----------
-    site_type : str
-        The site type to check.
-    key : IpccLandUseCategory
-        The IPCC land use category to check.
+    land_cover_nodes : List[dict]
+        List of land cover nodes to be checked.
 
     Returns
     -------
     bool
-        `True` if the conditions match the specified land use category, `False` otherwise.
-
+        `True` if long fallow is present, `False` otherwise.
     """
-    target_site_type = IPCC_LAND_USE_CATEGORY_TO_SITE_TYPE.get(key, None)
-
-    return site_type == target_site_type
+    return cumulative_nodes_term_match(
+        land_cover_nodes,
+        target_term_ids=get_long_fallow_land_cover_terms(),
+        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD
+    ) or cumulative_nodes_match(
+        lambda node: get_node_property(node, LONG_FALLOW_CROP_TERM_ID, False).get("value", 0),
+        land_cover_nodes,
+        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD
+    )
 
 
-def _check_cropland_land_use_category(
-    site_type: str,
-    *,
-    key: IpccLandUseCategory,
-    land_cover_nodes: list[dict],
-    **_
-) -> bool:
+def _has_upland_rice(land_cover_nodes: list[dict]) -> bool:
     """
-    Check if the site type and land cover nodes match the target conditions for a cropland IpccLandUseCategory.
-
-    This function is special case of `_check_cropland_land_use_category`.
+    Check if upland rice is present in the land cover nodes.
 
     Parameters
     ----------
-    site_type : str
-        The site type to check.
-    key : IpccLandUseCategory
-        The IPCC land use category to check.
-    land_cover_nodes : list[dict]
-        List of land cover nodes.
+    land_cover_nodes : List[dict]
+        List of land cover nodes to be checked.
 
     Returns
     -------
     bool
-        `True` if the conditions match the specified land use category, `False` otherwise.
+        `True` if upland rice is present, `False` otherwise.
     """
-    LOOKUP = LOOKUPS["landCover"][0]
-    target_lookup_values = IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE.get(key, None)
-
-    return _check_ipcc_land_use_category(site_type, key=key) and cumulative_nodes_lookup_match(
+    return cumulative_nodes_term_match(
         land_cover_nodes,
-        lookup=LOOKUP,
-        target_lookup_values=target_lookup_values,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        target_term_ids=get_upland_rice_land_cover_terms(),
+        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD
     )
 
 
-def _check_paddy_rice_cultivation_category(
-    site_type: str,
-    *,
-    land_cover_nodes: list[dict],
-    is_irrigated_upland_rice: bool,
-    **_
-) -> bool:
-    """
-    Check if the site type and land cover nodes match the target conditions for paddy rice cultivation.
+IPCC_LAND_USE_CATEGORY_TO_VALIDATION_KWARGS = {
+    IpccLandUseCategory.SET_ASIDE: {"has_long_fallow"},
+    IpccLandUseCategory.ANNUAL_CROPS_WET: {"has_wetland_soils"}
+}
+"""
+Keyword arguments that need to be checked for specific `IpccLandUseCategory`s.
+"""
 
-    This function is special case of `_check_cropland_land_use_category`.
+
+def _check_ipcc_land_use_category(*, key: IpccLandUseCategory, site_type: str, **kwargs) -> bool:
+    """
+    Check if the site type matches the target site type for the given key.
 
     Parameters
     ----------
+    key : IpccLandUseCategory
+        The IPCC land use category to check.
     site_type : str
         The site type to check.
-    land_cover_nodes : list[dict]
-        List of land cover nodes.
-    is_irrigated_upland_rice : bool
-        Flag indicating if the land cover irrigated upland rice.
+
+    Keyword Args
+    ------------
+    has_long_fallow : bool
+        Indicates whether long fallow is present on more than 30% of the site.
+    has_wetland_soils : bool
+        Indicates whether wetland soils are present to more than 30% of the site.
 
     Returns
     -------
     bool
         `True` if the conditions match the specified land use category, `False` otherwise.
+
     """
-    KEY = IpccLandUseCategory.PADDY_RICE_CULTIVATION
-    return _check_cropland_land_use_category(
-        site_type, key=KEY, land_cover_nodes=land_cover_nodes
-    ) or is_irrigated_upland_rice
+    target_site_type = IPCC_LAND_USE_CATEGORY_TO_SITE_TYPE.get(key, None)
+    validation_kwargs = IPCC_LAND_USE_CATEGORY_TO_VALIDATION_KWARGS.get(key, set())
+    valid_kwargs = all(v for k, v in kwargs.items() if k in validation_kwargs)
+    return site_type == target_site_type and valid_kwargs
 
 
-def _check_annual_crops_category(
-    site_type: str,
-    *,
-    land_cover_nodes: list[dict],
-    has_long_fallow: bool,
-    **_
+def _check_cropland_land_use_category(
+    *, key: IpccLandUseCategory, site_type: str, land_cover_nodes: list[dict], **kwargs
 ) -> bool:
     """
-    Check if the site type and land cover nodes match the target conditions for annual crops.
+    Check if the site type and land cover nodes match the target conditions for a cropland IpccLandUseCategory.
 
-    This function is special case of `_check_cropland_land_use_category`.
+    This function is special case of `_check_ipcc_land_use_category`.
 
     Parameters
     ----------
+    key : IpccLandUseCategory
+        The IPCC land use category to check.
     site_type : str
         The site type to check.
-    land_cover_nodes : list[dict]
-        List of land cover nodes.
+
+    Keyword Args
+    ------------
     has_long_fallow : bool
-        Flag indicating if there is long fallow.
+        Indicates whether long fallow is present on more than 30% of the site.
+    has_wetland_soils : bool
+        Indicates whether wetland soils are present to more than 30% of the site.
 
     Returns
     -------
     bool
         `True` if the conditions match the specified land use category, `False` otherwise.
     """
-    KEY = IpccLandUseCategory.ANNUAL_CROPS
-    return _check_cropland_land_use_category(
-        site_type, key=KEY, land_cover_nodes=land_cover_nodes
-    ) and not has_long_fallow
+    LOOKUP = LOOKUPS["landCover"][0]
+    target_lookup_values = IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE.get(key, None)
+    valid_lookup = cumulative_nodes_lookup_match(
+        land_cover_nodes,
+        lookup=LOOKUP,
+        target_lookup_values=target_lookup_values,
+        cumulative_threshold=MIN_AREA_THRESHOLD
+    )
+    return _check_ipcc_land_use_category(key=key, site_type=site_type, **kwargs) and valid_lookup
 
 
-def _check_annual_crops_wet_category(
-    site_type: str,
-    *,
-    land_cover_nodes: list[dict],
-    has_wetland_soils: bool,
-    has_long_fallow: bool,
-    **_
-):
+def _check_paddy_rice_cultivation_land_use_category(
+    *, key: IpccLandUseCategory, site_type: str, has_irrigated_upland_rice: bool, **kwargs
+) -> bool:
     """
-    Check if the site type and land cover nodes match the target conditions for annual crops on wetland soils.
+    Check if the site type and land cover nodes match the target conditions for a cropland IpccLandUseCategory.
 
     This function is special case of `_check_cropland_land_use_category`.
 
     Parameters
     ----------
+    key : IpccLandUseCategory
+        The IPCC land use category to check.
     site_type : str
         The site type to check.
-    land_cover_nodes : list[dict]
-        List of land cover nodes.
-    has_wetland_soils : bool
-        Flag indicating if the site is classified as `IpccSoilCategory.WETLAND_SOILS`
+
+    Keyword Args
+    ------------
+    has_irrigated_upland_rice : bool
+        Indicates whether irrigated upland rice is present on more than 30% of the site.
     has_long_fallow : bool
-        Flag indicating if there is long fallow.
+        Indicates whether long fallow is present on more than 30% of the site.
+    has_wetland_soils : bool
+        Indicates whether wetland soils are present to more than 30% of the site.
 
     Returns
     -------
     bool
         `True` if the conditions match the specified land use category, `False` otherwise.
     """
-    KEY = IpccLandUseCategory.ANNUAL_CROPS_WET
-    return _check_cropland_land_use_category(
-        site_type, key=KEY, land_cover_nodes=land_cover_nodes
-    ) and has_wetland_soils and not has_long_fallow
+    return _check_cropland_land_use_category(key=key, site_type=site_type, **kwargs) or has_irrigated_upland_rice
 
 
 LAND_USE_CATEGORY_DECISION_TREE = {
     IpccLandUseCategory.GRASSLAND: _check_ipcc_land_use_category,
-    IpccLandUseCategory.PERENNIAL_CROPS: _check_cropland_land_use_category,
-    IpccLandUseCategory.PADDY_RICE_CULTIVATION: _check_paddy_rice_cultivation_category,
-    IpccLandUseCategory.ANNUAL_CROPS_WET: _check_annual_crops_wet_category,
-    IpccLandUseCategory.ANNUAL_CROPS: _check_annual_crops_category,
     IpccLandUseCategory.SET_ASIDE: _check_ipcc_land_use_category,
+    IpccLandUseCategory.PERENNIAL_CROPS: _check_cropland_land_use_category,
+    IpccLandUseCategory.PADDY_RICE_CULTIVATION: _check_paddy_rice_cultivation_land_use_category,
+    IpccLandUseCategory.ANNUAL_CROPS_WET: _check_cropland_land_use_category,
+    IpccLandUseCategory.ANNUAL_CROPS: _check_cropland_land_use_category,
     IpccLandUseCategory.FOREST: _check_ipcc_land_use_category,
     IpccLandUseCategory.NATIVE: _check_ipcc_land_use_category,
     IpccLandUseCategory.OTHER: _check_ipcc_land_use_category
@@ -3238,9 +2706,7 @@ and land cover nodes.
 
 
 def _assign_ipcc_land_use_category(
-    site_type: str,
-    management_nodes: list[dict],
-    ipcc_soil_category: IpccSoilCategory
+    site_type: str, management_nodes: list[dict], ipcc_soil_category: IpccSoilCategory
 ) -> IpccLandUseCategory:
     """
     Assigns IPCC land use category based on site type, management nodes, and soil category.
@@ -3262,33 +2728,13 @@ def _assign_ipcc_land_use_category(
     DECISION_TREE = LAND_USE_CATEGORY_DECISION_TREE
     DEFAULT = IpccLandUseCategory.OTHER
 
-    land_cover_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.LANDCOVER]
-    )
-
-    water_regime_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.WATERREGIME]
-    )
+    land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
+    water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
 
     has_irrigation = _has_irrigation(water_regime_nodes)
-
-    is_upland_rice = cumulative_nodes_term_match(
-        land_cover_nodes,
-        target_term_ids=get_rice_plant_upland_terms(),
-        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
-    )
-
-    is_irrigated_upland_rice = is_upland_rice and has_irrigation
-
-    # SUPER_MAJORITY_AREA_THRESHOLD
-    has_long_fallow = cumulative_nodes_match(
-        lambda node: get_node_property(node, LONG_FALLOW_CROP_TERM_ID, False).get("value", 0),
-        land_cover_nodes,
-        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
-    )
-
+    has_upland_rice = _has_upland_rice(land_cover_nodes)
+    has_irrigated_upland_rice = has_upland_rice and has_irrigation
+    has_long_fallow = _has_long_fallow(land_cover_nodes)
     has_wetland_soils = ipcc_soil_category is IpccSoilCategory.WETLAND_SOILS
 
     should_run = bool(site_type)
@@ -3297,11 +2743,11 @@ def _assign_ipcc_land_use_category(
         (
             key for key in DECISION_TREE
             if DECISION_TREE[key](
-                site_type,
                 key=key,
+                site_type=site_type,
                 land_cover_nodes=land_cover_nodes,
-                is_irrigated_upland_rice=is_irrigated_upland_rice,
                 has_long_fallow=has_long_fallow,
+                has_irrigated_upland_rice=has_irrigated_upland_rice,
                 has_wetland_soils=has_wetland_soils
             )
         ),
@@ -3313,20 +2759,17 @@ def _assign_ipcc_land_use_category(
 
 
 def _check_grassland_ipcc_management_category(
-    *,
-    land_cover_nodes: list[dict],
-    key: IpccManagementCategory,
-    **_
+    *, key: IpccManagementCategory, land_cover_nodes: list[dict], **_
 ) -> bool:
     """
     Check if the land cover nodes match the target conditions for a grassland IpccManagementCategory.
 
     Parameters
     ----------
-    land_cover_nodes : List[dict]
-        List of land cover nodes to be checked.
     key : IpccManagementCategory
         The IPCC management category to check.
+    land_cover_nodes : List[dict]
+        List of land cover nodes to be checked.
 
     Returns
     -------
@@ -3334,25 +2777,25 @@ def _check_grassland_ipcc_management_category(
         `True` if the conditions match the specified management category, `False` otherwise.
     """
     target_term_id = IPCC_MANAGEMENT_CATEGORY_TO_GRASSLAND_MANAGEMENT_TERM_ID.get(key, None)
-
     return cumulative_nodes_term_match(
         land_cover_nodes,
         target_term_ids=target_term_id,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
 
-def _check_tillage_ipcc_management_category(*, tillage_nodes: list[dict], key: IpccManagementCategory, **_) -> bool:
+def _check_tillage_ipcc_management_category(
+    *, key: IpccManagementCategory, tillage_nodes: list[dict], **_
+) -> bool:
     """
     Check if the tillage nodes match the target conditions for a tillage IpccManagementCategory.
 
     Parameters
     ----------
-    tillage_nodes : List[dict]
-        List of tillage nodes to be checked.
     key : IpccManagementCategory
         The IPCC management category to check.
+    tillage_nodes : List[dict]
+        List of tillage nodes to be checked.
 
     Returns
     -------
@@ -3361,13 +2804,11 @@ def _check_tillage_ipcc_management_category(*, tillage_nodes: list[dict], key: I
     """
     LOOKUP = LOOKUPS["tillage"]
     target_lookup_values = IPCC_MANAGEMENT_CATEGORY_TO_TILLAGE_MANAGEMENT_LOOKUP_VALUE.get(key, None)
-
     return cumulative_nodes_lookup_match(
         tillage_nodes,
         lookup=LOOKUP,
         target_lookup_values=target_lookup_values,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
 
@@ -3423,8 +2864,7 @@ Value: Default IPCC management category for the given land use category.
 
 
 def _assign_ipcc_management_category(
-    management_nodes: list[dict],
-    ipcc_land_use_category: IpccLandUseCategory
+    management_nodes: list[dict], ipcc_land_use_category: IpccLandUseCategory
 ) -> IpccManagementCategory:
     """
     Assign an IPCC Management Category based on the given management nodes and IPCC Land Use Category.
@@ -3441,32 +2881,26 @@ def _assign_ipcc_management_category(
     IpccManagementCategory
         The assigned IPCC Management Category.
     """
-    decision_tree = IPCC_LAND_USE_CATEGORY_TO_DECISION_TREE.get(
-        ipcc_land_use_category, {}
-    )
+    decision_tree = IPCC_LAND_USE_CATEGORY_TO_DECISION_TREE.get(ipcc_land_use_category, {})
     default = IPCC_LAND_USE_CATEGORY_TO_DEFAULT_IPCC_MANAGEMENT_CATEGORY.get(
         ipcc_land_use_category, IpccManagementCategory.OTHER
     )
 
-    land_cover_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.LANDCOVER]
-    )
-    tillage_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.TILLAGE]
-    )
+    land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
+    tillage_nodes = filter_list_term_type(management_nodes, [TermTermType.TILLAGE])
 
-    should_run = (
-        len(land_cover_nodes) > 0 if decision_tree == GRASSLAND_IPCC_MANAGEMENT_CATEGORY_DECISION_TREE
-        else len(tillage_nodes) > 0
-    )
+    should_run = any([
+        decision_tree == GRASSLAND_IPCC_MANAGEMENT_CATEGORY_DECISION_TREE and len(land_cover_nodes) > 0,
+        decision_tree == TILLAGE_IPCC_MANAGEMENT_CATEGORY_DECISION_TREE and len(tillage_nodes) > 0
+    ])
 
     return next(
         (
             key for key in decision_tree
             if decision_tree[key](
+                key=key,
                 land_cover_nodes=land_cover_nodes,
                 tillage_nodes=tillage_nodes,
-                key=key
             )
         ),
         default
@@ -3489,9 +2923,7 @@ Value: Minimum number of improvements required for the corresponding Grassland C
 
 
 def _check_grassland_ipcc_carbon_input_category(
-    carbon_input_args: CarbonInputArgs,
-    *,
-    key: IpccCarbonInputCategory
+    *, key: IpccCarbonInputCategory, num_grassland_improvements: int, **_,
 ) -> bool:
     """
     Checks if the given carbon input arguments satisfy the conditions for a specific
@@ -3499,24 +2931,26 @@ def _check_grassland_ipcc_carbon_input_category(
 
     Parameters
     ----------
-    carbon_input_args : CarbonInputArgs
-        The carbon input arguments.
     key : IpccCarbonInputCategory
         The grassland IPCC Carbon Input Category to check.
+    num_grassland_improvements : int
+        The number of grassland improvements.
 
     Returns
     -------
     bool
         `True` if the conditions for the specified category are met; otherwise, `False`.
     """
-    min_improvements = (
-        GRASSLAND_IPCC_CARBON_INPUT_CATEGORY_TO_MIN_NUM_IMPROVEMENTS[key]
-    )
-    return carbon_input_args.num_grassland_improvements >= min_improvements
+    return num_grassland_improvements >= GRASSLAND_IPCC_CARBON_INPUT_CATEGORY_TO_MIN_NUM_IMPROVEMENTS[key]
 
 
 def _check_cropland_high_with_manure_category(
-    carbon_input_args: CarbonInputArgs,
+    *,
+    has_animal_manure_used: bool,
+    has_bare_fallow: bool,
+    has_low_residue_producing_crops: bool,
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used: bool,
+    has_residue_removed_or_burnt: bool,
     **_
 ) -> Optional[int]:
     """
@@ -3524,8 +2958,16 @@ def _check_cropland_high_with_manure_category(
 
     Parameters
     ----------
-    carbon_input_args : CarbonInputArgs
-        The carbon input arguments.
+    has_animal_manure_used : bool
+        Indicates whether animal manure is used on more than 30% of the site.
+    has_bare_fallow : bool
+        Indicates whether bare fallow is present on more than 30% of the site.
+    has_low_residue_producing_crops : bool
+        Indicates whether low residue-producing crops are present on more than 70% of the site.
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used : bool
+        Indicates whether a nitrogen-fixing crop or inorganic nitrogen fertiliser is used on more than 30% of the site.
+    has_residue_removed_or_burnt : bool
+        Indicates whether residues are removed or burnt on more than 30% of the site.
 
     Returns
     -------
@@ -3534,11 +2976,11 @@ def _check_cropland_high_with_manure_category(
     """
     conditions = {
         1: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_low_residue_producing_crops,
-            not carbon_input_args.has_bare_fallow,
-            carbon_input_args.has_n_fixing_crop_or_inorganic_n_fertiliser_used,
-            carbon_input_args.has_animal_manure_used
+            not has_residue_removed_or_burnt,
+            not has_low_residue_producing_crops,
+            not has_bare_fallow,
+            has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+            has_animal_manure_used
         ])
     }
 
@@ -3548,15 +2990,41 @@ def _check_cropland_high_with_manure_category(
 
 
 def _check_cropland_high_without_manure_category(
-    carbon_input_args: CarbonInputArgs, **_
+    *,
+    has_animal_manure_used: bool,
+    has_bare_fallow: bool,
+    has_cover_crop: bool,
+    has_irrigation: bool,
+    has_low_residue_producing_crops: bool,
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used: bool,
+    has_organic_fertiliser_or_soil_amendment_used: bool,
+    has_practice_increasing_c_input: bool,
+    has_residue_removed_or_burnt: bool,
+    **_
 ) -> Optional[int]:
     """
     Checks the Cropland High without Manure IPCC Carbon Input Category based on the given carbon input arguments.
 
     Parameters
     ----------
-    carbon_input_args : CarbonInputArgs
-        The carbon input arguments.
+    has_animal_manure_used : bool
+        Indicates whether animal manure is used on more than 30% of the site.
+    has_bare_fallow : bool
+        Indicates whether bare fallow is present on more than 30% of the site.
+    has_cover_crop : bool
+        Indicates whether cover crops are present on more than 30% of the site.
+    has_irrigation : bool
+        Indicates whether irrigation is applied to more than 30% of the site.
+    has_low_residue_producing_crops : bool
+        Indicates whether low residue-producing crops are present on more than 70% of the site.
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used : bool
+        Indicates whether a nitrogen-fixing crop or inorganic nitrogen fertiliser is used on more than 30% of the site.
+    has_organic_fertiliser_or_soil_amendment_used : bool
+        Indicates whether organic fertiliser or soil amendments are used on more than 30% of the site.
+    has_practice_increasing_c_input : bool
+        Indicates whether practices increasing carbon input are present on more than 30% of the site.
+    has_residue_removed_or_burnt : bool
+        Indicates whether residues are removed or burnt on more than 30% of the site.
 
     Returns
     -------
@@ -3565,17 +3033,17 @@ def _check_cropland_high_without_manure_category(
     """
     conditions = {
         1: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_low_residue_producing_crops,
-            not carbon_input_args.has_bare_fallow,
-            carbon_input_args.has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+            not has_residue_removed_or_burnt,
+            not has_low_residue_producing_crops,
+            not has_bare_fallow,
+            has_n_fixing_crop_or_inorganic_n_fertiliser_used,
             any([
-                carbon_input_args.has_irrigation,
-                carbon_input_args.has_practice_increasing_c_input,
-                carbon_input_args.has_cover_crop,
-                carbon_input_args.has_organic_fertiliser_or_soil_amendment_used
+                has_irrigation,
+                has_practice_increasing_c_input,
+                has_cover_crop,
+                has_organic_fertiliser_or_soil_amendment_used
             ]),
-            not carbon_input_args.has_animal_manure_used
+            not has_animal_manure_used
         ])
     }
 
@@ -3585,7 +3053,16 @@ def _check_cropland_high_without_manure_category(
 
 
 def _check_cropland_medium_category(
-    carbon_input_args: CarbonInputArgs,
+    *,
+    has_animal_manure_used: bool,
+    has_bare_fallow: bool,
+    has_cover_crop: bool,
+    has_irrigation: bool,
+    has_low_residue_producing_crops: bool,
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used: bool,
+    has_organic_fertiliser_or_soil_amendment_used: bool,
+    has_practice_increasing_c_input: bool,
+    has_residue_removed_or_burnt: bool,
     **_
 ) -> Optional[int]:
     """
@@ -3593,8 +3070,24 @@ def _check_cropland_medium_category(
 
     Parameters
     ----------
-    carbon_input_args : CarbonInputArgs
-        The carbon input arguments.
+    has_animal_manure_used : bool
+        Indicates whether animal manure is used on more than 30% of the site.
+    has_bare_fallow : bool
+        Indicates whether bare fallow is present on more than 30% of the site.
+    has_cover_crop : bool
+        Indicates whether cover crops are present on more than 30% of the site.
+    has_irrigation : bool
+        Indicates whether irrigation is applied to more than 30% of the site.
+    has_low_residue_producing_crops : bool
+        Indicates whether low residue-producing crops are present on more than 70% of the site.
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used : bool
+        Indicates whether a nitrogen-fixing crop or inorganic nitrogen fertiliser is used on more than 30% of the site.
+    has_organic_fertiliser_or_soil_amendment_used : bool
+        Indicates whether organic fertiliser or soil amendments are used on more than 30% of the site.
+    has_practice_increasing_c_input : bool
+        Indicates whether practices increasing carbon input are present on more than 30% of the site.
+    has_residue_removed_or_burnt : bool
+        Indicates whether residues are removed or burnt on more than 30% of the site.
 
     Returns
     -------
@@ -3603,43 +3096,43 @@ def _check_cropland_medium_category(
     """
     conditions = {
         1: all([
-            carbon_input_args.has_residue_removed_or_burnt,
-            carbon_input_args.has_animal_manure_used
+            has_residue_removed_or_burnt,
+            has_animal_manure_used
         ]),
         2: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
+            not has_residue_removed_or_burnt,
             any([
-                carbon_input_args.has_low_residue_producing_crops,
-                carbon_input_args.has_bare_fallow
+                has_low_residue_producing_crops,
+                has_bare_fallow
             ]),
             any([
-                carbon_input_args.has_irrigation,
-                carbon_input_args.has_practice_increasing_c_input,
-                carbon_input_args.has_cover_crop,
-                carbon_input_args.has_organic_fertiliser_or_soil_amendment_used,
+                has_irrigation,
+                has_practice_increasing_c_input,
+                has_cover_crop,
+                has_organic_fertiliser_or_soil_amendment_used,
             ])
         ]),
         3: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_low_residue_producing_crops,
-            not carbon_input_args.has_bare_fallow,
-            not carbon_input_args.has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+            not has_residue_removed_or_burnt,
+            not has_low_residue_producing_crops,
+            not has_bare_fallow,
+            not has_n_fixing_crop_or_inorganic_n_fertiliser_used,
             any([
-                carbon_input_args.has_irrigation,
-                carbon_input_args.has_practice_increasing_c_input,
-                carbon_input_args.has_cover_crop,
-                carbon_input_args.has_organic_fertiliser_or_soil_amendment_used
+                has_irrigation,
+                has_practice_increasing_c_input,
+                has_cover_crop,
+                has_organic_fertiliser_or_soil_amendment_used
             ])
         ]),
         4: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_low_residue_producing_crops,
-            not carbon_input_args.has_bare_fallow,
-            carbon_input_args.has_n_fixing_crop_or_inorganic_n_fertiliser_used,
-            not carbon_input_args.has_irrigation,
-            not carbon_input_args.has_organic_fertiliser_or_soil_amendment_used,
-            not carbon_input_args.has_practice_increasing_c_input,
-            not carbon_input_args.has_cover_crop
+            not has_residue_removed_or_burnt,
+            not has_low_residue_producing_crops,
+            not has_bare_fallow,
+            has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+            not has_irrigation,
+            not has_organic_fertiliser_or_soil_amendment_used,
+            not has_practice_increasing_c_input,
+            not has_cover_crop
         ])
     }
 
@@ -3649,7 +3142,16 @@ def _check_cropland_medium_category(
 
 
 def _check_cropland_low_category(
-    carbon_input_args: CarbonInputArgs,
+    *,
+    has_animal_manure_used: bool,
+    has_bare_fallow: bool,
+    has_cover_crop: bool,
+    has_irrigation: bool,
+    has_low_residue_producing_crops: bool,
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used: bool,
+    has_organic_fertiliser_or_soil_amendment_used: bool,
+    has_practice_increasing_c_input: bool,
+    has_residue_removed_or_burnt: bool,
     **_
 ) -> Optional[int]:
     """
@@ -3657,8 +3159,24 @@ def _check_cropland_low_category(
 
     Parameters
     ----------
-    carbon_input_args : CarbonInputArgs
-        The carbon input arguments.
+    has_animal_manure_used : bool
+        Indicates whether animal manure is used on more than 30% of the site.
+    has_bare_fallow : bool
+        Indicates whether bare fallow is present on more than 30% of the site.
+    has_cover_crop : bool
+        Indicates whether cover crops are present on more than 30% of the site.
+    has_irrigation : bool
+        Indicates whether irrigation is applied to more than 30% of the site.
+    has_low_residue_producing_crops : bool
+        Indicates whether low residue-producing crops are present on more than 70% of the site.
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used : bool
+        Indicates whether a nitrogen-fixing crop or inorganic nitrogen fertiliser is used on more than 30% of the site.
+    has_organic_fertiliser_or_soil_amendment_used : bool
+        Indicates whether organic fertiliser or soil amendments are used on more than 30% of the site.
+    has_practice_increasing_c_input : bool
+        Indicates whether practices increasing carbon input are present on more than 30% of the site.
+    has_residue_removed_or_burnt : bool
+        Indicates whether residues are removed or burnt on more than 30% of the site.
 
     Returns
     -------
@@ -3667,29 +3185,29 @@ def _check_cropland_low_category(
     """
     conditions = {
         1: all([
-            carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_animal_manure_used
+            has_residue_removed_or_burnt,
+            not has_animal_manure_used
         ]),
         2: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
+            not has_residue_removed_or_burnt,
             any([
-                carbon_input_args.has_low_residue_producing_crops,
-                carbon_input_args.has_bare_fallow
+                has_low_residue_producing_crops,
+                has_bare_fallow
             ]),
-            not carbon_input_args.has_irrigation,
-            not carbon_input_args.has_practice_increasing_c_input,
-            not carbon_input_args.has_cover_crop,
-            not carbon_input_args.has_organic_fertiliser_or_soil_amendment_used
+            not has_irrigation,
+            not has_practice_increasing_c_input,
+            not has_cover_crop,
+            not has_organic_fertiliser_or_soil_amendment_used
         ]),
         3: all([
-            not carbon_input_args.has_residue_removed_or_burnt,
-            not carbon_input_args.has_low_residue_producing_crops,
-            not carbon_input_args.has_bare_fallow,
-            not carbon_input_args.has_n_fixing_crop_or_inorganic_n_fertiliser_used,
-            not carbon_input_args.has_irrigation,
-            not carbon_input_args.has_organic_fertiliser_or_soil_amendment_used,
-            not carbon_input_args.has_practice_increasing_c_input,
-            not carbon_input_args.has_cover_crop
+            not has_residue_removed_or_burnt,
+            not has_low_residue_producing_crops,
+            not has_bare_fallow,
+            not has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+            not has_irrigation,
+            not has_organic_fertiliser_or_soil_amendment_used,
+            not has_practice_increasing_c_input,
+            not has_cover_crop
         ])
     }
 
@@ -3698,9 +3216,9 @@ def _check_cropland_low_category(
     )
 
 
-def _make_carbon_input_args(
+def _get_carbon_input_kwargs(
     management_nodes: list[dict]
-) -> CarbonInputArgs:
+) -> dict:
     """
     Creates CarbonInputArgs based on the provided list of management nodes.
 
@@ -3711,8 +3229,8 @@ def _make_carbon_input_args(
 
     Returns
     -------
-    CarbonInputArgs
-        The carbon input arguments.
+    dict
+        The carbon input keyword arguments.
     """
 
     PRACTICE_INCREASING_C_INPUT_LOOKUP = LOOKUPS["landUseManagement"]
@@ -3727,62 +3245,56 @@ def _make_carbon_input_args(
         ORGANIC_FERTILISER_USED_TERM_ID
     }
 
-    crop_residue_management_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.CROPRESIDUEMANAGEMENT]
+    crop_residue_management_nodes = filter_list_term_type(management_nodes, [TermTermType.CROPRESIDUEMANAGEMENT])
+    land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
+    land_use_management_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDUSEMANAGEMENT])
+    water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
+
+    has_animal_manure_used = any(
+        get_node_value(node) for node in land_use_management_nodes if node_term_match(node, ANIMAL_MANURE_USED_TERM_ID)
     )
 
-    land_cover_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.LANDCOVER]
+    has_bare_fallow = cumulative_nodes_term_match(
+        land_cover_nodes,
+        target_term_ids=SHORT_BARE_FALLOW_TERM_ID,
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
-    land_use_management_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.LANDUSEMANAGEMENT]
+    has_cover_crop = cumulative_nodes_match(
+        lambda node: any(
+            get_node_property(node, term_id, False).get("value", False) for term_id in get_cover_crop_property_terms()
+        ),
+        land_cover_nodes,
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
-    water_regime_nodes = filter_list_term_type(
-        management_nodes, [TermTermType.WATERREGIME]
+    has_inorganic_n_fertiliser_used = any(
+        get_node_value(node) for node in land_use_management_nodes
+        if node_term_match(node, INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID)
     )
 
     has_irrigation = _has_irrigation(water_regime_nodes)
 
-    has_residue_removed_or_burnt = cumulative_nodes_term_match(
-        crop_residue_management_nodes,
-        target_term_ids=get_residue_removed_or_burnt_terms(),
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
-    )
-
     # SUPER_MAJORITY_AREA_THRESHOLD
     has_low_residue_producing_crops = cumulative_nodes_lookup_match(
         land_cover_nodes,
         lookup=LOW_RESIDUE_PRODUCING_CROP_LOOKUP,
         target_lookup_values=True,
-        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
-    )
-
-    has_bare_fallow = cumulative_nodes_term_match(
-        land_use_management_nodes,
-        target_term_ids=SHORT_BARE_FALLOW_TERM_ID,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD
     )
 
     has_n_fixing_crop = cumulative_nodes_lookup_match(
         land_cover_nodes,
         lookup=N_FIXING_CROP_LOOKUP,
         target_lookup_values=True,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
-    has_inorganic_n_fertiliser_used = any(
-        get_node_value(node) for node in land_use_management_nodes
-        if node_term_match(node, INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID)
-    )
+    has_n_fixing_crop_or_inorganic_n_fertiliser_used = has_n_fixing_crop or has_inorganic_n_fertiliser_used
 
-    has_n_fixing_crop_or_inorganic_n_fertiliser_used = (
-        has_n_fixing_crop or has_inorganic_n_fertiliser_used
+    has_organic_fertiliser_or_soil_amendment_used = any(
+        get_node_value(node) for node in land_use_management_nodes
+        if node_term_match(node, ORGANIC_FERTILISER_USED_TERM_ID)
     )
 
     has_practice_increasing_c_input = cumulative_nodes_match(
@@ -3791,27 +3303,13 @@ def _make_carbon_input_args(
             and not node_term_match(node, EXCLUDED_PRACTICE_TERM_IDS)
         ),
         land_use_management_nodes,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
-    has_cover_crop = cumulative_nodes_match(
-        lambda node: any(
-            get_node_property(node, term_id, False).get("value", False) for term_id in get_cover_crop_property_terms()
-        ),
-        land_cover_nodes,
-        cumulative_threshold=MIN_AREA_THRESHOLD,
-        default_node_value=DEFAULT_NODE_VALUE
-    )
-
-    has_organic_fertiliser_or_soil_amendment_used = any(
-        get_node_value(node) for node in land_use_management_nodes
-        if node_term_match(node, ORGANIC_FERTILISER_USED_TERM_ID)
-    )
-
-    has_animal_manure_used = any(
-        get_node_value(node) for node in land_use_management_nodes
-        if node_term_match(node, ANIMAL_MANURE_USED_TERM_ID)
+    has_residue_removed_or_burnt = cumulative_nodes_term_match(
+        crop_residue_management_nodes,
+        target_term_ids=get_residue_removed_or_burnt_terms(),
+        cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
     num_grassland_improvements = [
@@ -3821,18 +3319,18 @@ def _make_carbon_input_args(
         has_organic_fertiliser_or_soil_amendment_used
     ].count(True)
 
-    return CarbonInputArgs(
-        num_grassland_improvements=num_grassland_improvements,
-        has_irrigation=has_irrigation,
-        has_residue_removed_or_burnt=has_residue_removed_or_burnt,
-        has_low_residue_producing_crops=has_low_residue_producing_crops,
-        has_bare_fallow=has_bare_fallow,
-        has_n_fixing_crop_or_inorganic_n_fertiliser_used=has_n_fixing_crop_or_inorganic_n_fertiliser_used,
-        has_practice_increasing_c_input=has_practice_increasing_c_input,
-        has_cover_crop=has_cover_crop,
-        has_organic_fertiliser_or_soil_amendment_used=has_organic_fertiliser_or_soil_amendment_used,
-        has_animal_manure_used=has_animal_manure_used
-    )
+    return {
+        "has_animal_manure_used": has_animal_manure_used,
+        "has_bare_fallow": has_bare_fallow,
+        "has_cover_crop": has_cover_crop,
+        "has_irrigation": has_irrigation,
+        "has_low_residue_producing_crops": has_low_residue_producing_crops,
+        "has_n_fixing_crop_or_inorganic_n_fertiliser_used": has_n_fixing_crop_or_inorganic_n_fertiliser_used,
+        "has_organic_fertiliser_or_soil_amendment_used": has_organic_fertiliser_or_soil_amendment_used,
+        "has_practice_increasing_c_input": has_practice_increasing_c_input,
+        "has_residue_removed_or_burnt": has_residue_removed_or_burnt,
+        "num_grassland_improvements": num_grassland_improvements
+    }
 
 
 GRASSLAND_IPCC_CARBON_INPUT_CATEGORY_DECISION_TREE = {
@@ -3908,14 +3406,12 @@ def _assign_ipcc_carbon_input_category(
     decision_tree = DECISION_TREE_FROM_IPCC_MANAGEMENT_CATEGORY.get(ipcc_management_category, {})
     default = DEFAULT_CARBON_INPUT_CATEGORY.get(ipcc_management_category, IpccCarbonInputCategory.OTHER)
 
-    carbon_input_args = _make_carbon_input_args(management_nodes)
-
     should_run = len(management_nodes) > 0
 
     return next(
         (key for key in decision_tree if decision_tree[key](
-            carbon_input_args,
             key=key,
+            **_get_carbon_input_kwargs(management_nodes)
         )),
         default
     ) if should_run else default
@@ -3924,50 +3420,477 @@ def _assign_ipcc_carbon_input_category(
 # --- TIER 1 SOC MODEL ---
 
 
-def _should_run_inventory_year(inner_dict: dict) -> bool:
+def _run_tier_1(
+    inventory: dict,
+    *,
+    eco_climate_zone: int,
+    soc_ref: float,
+    **_
+) -> list[dict]:
     """
-    Check if the given inventory year meets the required conditions for further processing.
+    Run the IPCC (2019) Tier 1 methodology for calculating SOC stocks (in kg C ha-1) for each year in the inventory
+    and wrap each of the calculated values in Hestia measurement nodes. To avoid any errors, the `inventory` parameter
+    must be pre-validated by the `should_run` function.
 
-    Check if the land use category is not "OTHER" and all required keys are present.
+    See [IPCC (2019) Vol. 4, Ch. 2](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
+
+    The inventory should be in the following shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SHOULD_RUN_TIER_1: bool,
+            _InventoryKey.LU_CATEGORY: IpccLandUseCategory,
+            _InventoryKey.MG_CATEGORY: IpccManagementCategory,
+            _InventoryKey.CI_CATEGORY: IpccCarbonInputCategory
+        },
+        ...
+    }
+    ```
 
     Parameters
     ----------
-    inner_dict : dict
-        Dictionary containing information for a specific inventory year.
+    inventory : dict
+        The inventory built by the `_should_run` function.
+    eco_climate_zone : int
+        The eco-climate zone identifier for the site corresponding to a row in the
+        [ecoClimateZone](https://gitlab.com/hestia-earth/hestia-glossary/-/blob/develop/Measurements/ecoClimateZone-lookup.csv)
+        lookup table.
+    ipcc_soil_category : IpccSoilCategory
+        The reference condition SOC stock in the 0-30cm depth interval, kg C ha-1.
 
     Returns
     -------
-    bool
-        True if the inventory year should be considered, False otherwise.
+    list[dict]
+        A list of Hestia `Measurement` nodes containing the calculated SOC stocks and additional relevant data.
     """
-    REQUIRED_KEYS = {IpccLandUseCategory, IpccManagementCategory, IpccCarbonInputCategory}
-    return (
-        inner_dict[IpccLandUseCategory] != IpccLandUseCategory.OTHER
-        and all(key in REQUIRED_KEYS for key in inner_dict)
+
+    valid_inventory = {
+        year: group for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN_TIER_1)
+    }
+
+    timestamps = [year for year in valid_inventory.keys()]
+    ipcc_land_use_categories = [group[_InventoryKey.LU_CATEGORY] for group in valid_inventory.values()]
+    ipcc_management_categories = [group[_InventoryKey.MG_CATEGORY] for group in valid_inventory.values()]
+    ipcc_carbon_input_categories = [group[_InventoryKey.CI_CATEGORY] for group in valid_inventory.values()]
+
+    iterated_timestamps, iterated_soc_equilibriums = _run_soc_equilibriums(
+        timestamps,
+        ipcc_land_use_categories,
+        ipcc_management_categories,
+        ipcc_carbon_input_categories,
+        eco_climate_zone,
+        soc_ref
     )
 
+    soc_stocks = _calc_tier_1_soc_stocks(iterated_timestamps, iterated_soc_equilibriums)
 
-def _should_run_tier_1(site: dict) -> tuple:
+    return [
+        _measurement(
+            year,
+            soc_stock,
+            MeasurementMethodClassification.TIER_1_MODEL.value
+        ) for year, soc_stock in zip(
+            iterated_timestamps,
+            soc_stocks
+        )
+    ]
+
+
+# --- SHOULD RUN ---
+
+
+def _should_run(site: dict) -> tuple[bool, dict]:
+    """
+    Extract data from site & related cycles, pre-process data and determine whether there is sufficient data to run the
+    tier 1 and/or tier 2 model.
+
+    The inventory dict should be in the following shape:
+    ```
+    {
+        year (int): {
+            _InventoryKey.SHOULD_RUN_TIER_2: bool,
+            _InventoryKey.TEMP_MONTHLY: list[float],
+            _InventoryKey.PRECIP_MONTHLY: list[float],
+            _InventoryKey.PET_MONTHLY: list[float],
+            _InventoryKey.IRRIGATED_MONTHLY: list[bool]
+            _InventoryKey.CARBON_INPUT: float,
+            _InventoryKey.N_CONTENT: float,
+            _InventoryKey.TILLAGE_CATEGORY: IpccManagementCategory,
+            _InventoryKey.SAND_CONTENT: float,
+            _InventoryKey.SHOULD_RUN_TIER_1: bool,
+            _InventoryKey.LU_CATEGORY: IpccLandUseCategory,
+            _InventoryKey.MG_CATEGORY: IpccManagementCategory,
+            _InventoryKey.CI_CATEGORY: IpccCarbonInputCategory
+        },
+        ...
+    }
+    ```
+
+    The kwargs dict should be in the following shape:
+    ```
+    {
+        "run_with_irrigation": bool,
+        "eco_climate_zone": int,
+        "ipcc_soil_category": IpccSoilCategory,
+        "soc_ref": float
+    }
+    ```
     """
-    Determines whether Tier 1 of the IPCC SOC model should run for a given site.
+    site_type = site.get("siteType", "")
+    management_nodes = site.get("management", [])
+    measurement_nodes = site.get("measurements", [])
+    cycles = related_cycles(site.get("@id"))
+
+    has_management = len(management_nodes) > 0
+    has_measurements = len(measurement_nodes) > 0
+    has_related_cycles = len(cycles) > 0
+    has_functional_unit_1_ha = all(cycle.get("functionalUnit") in VALID_FUNCTIONAL_UNITS_TIER_2 for cycle in cycles)
+
+    should_build_inventory_tier_1 = all([
+        site_type in VALID_SITE_TYPES_TIER_1,
+        has_management,
+        has_measurements
+    ])
+
+    should_build_inventory_tier_2 = all([
+        site_type in VALID_SITE_TYPES_TIER_2,
+        has_related_cycles,
+        check_cycle_site_ids_identical(cycles),
+        has_functional_unit_1_ha
+    ])
+
+    inventory_tier_1, kwargs_tier_1 = (
+        _build_inventory_tier_1(site_type, management_nodes, measurement_nodes)
+        if should_build_inventory_tier_1 else ({}, {})
+    )
+
+    inventory_tier_2, kwargs_tier_2 = (
+        _build_inventory_tier_2(cycles, measurement_nodes)
+        if should_build_inventory_tier_2 else ({}, {})
+    )
+
+    inventory = dict(sorted(merge(inventory_tier_1, inventory_tier_2).items()))
+    kwargs = kwargs_tier_1 | kwargs_tier_2
+
+    should_run_tier_1 = _should_run_tier_1(inventory, **kwargs) if should_build_inventory_tier_1 else False
+    should_run_tier_2 = _should_run_tier_2(inventory, **kwargs) if should_build_inventory_tier_2 else False
+
+    logRequirements(
+        site, model=MODEL, term=TERM_ID,
+        should_build_inventory_tier_1=should_build_inventory_tier_1,
+        should_build_inventory_tier_2=should_build_inventory_tier_2,
+        should_run_tier_1=should_run_tier_1,
+        should_run_tier_2=should_run_tier_2,
+        site_type=site_type,
+        has_management=has_management,
+        has_measurements=has_measurements,
+        has_related_cycles=has_related_cycles,
+        is_unit_hectare=has_functional_unit_1_ha,
+        **kwargs,
+        inventory=_log_inventory(inventory)
+    )
+
+    should_run = should_run_tier_1 or should_run_tier_2
+    logShouldRun(site, MODEL, TERM_ID, should_run)
+
+    return should_run_tier_1, should_run_tier_2, inventory, kwargs
+
+
+def _should_run_tier_1(
+    inventory: dict,
+    *,
+    eco_climate_zone: int = None,
+    soc_ref: float = None,
+    **_
+) -> bool:
+    """
+    Determines whether there is sufficient data in the inventory and keyword args to run the tier 1 model.
+    """
+    return all([
+        eco_climate_zone and eco_climate_zone > 0,
+        soc_ref and soc_ref > 0,
+        any(year for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN_TIER_1))
+    ])
+
+
+def _should_run_tier_2(
+    inventory: dict,
+    **_
+) -> bool:
+    """
+    Determines whether there is sufficient data in the inventory and keyword args to run the tier 2 model.
+    """
+    valid_years = [year for year, group in inventory.items() if group.get(_InventoryKey.SHOULD_RUN_TIER_2)]
+    return all([
+        len(valid_years) >= MIN_RUN_IN_PERIOD,
+        check_consecutive(valid_years),
+        any(inventory.get(year).get(_InventoryKey.SAND_CONTENT) for year in valid_years)
+    ])
+
+
+# --- LOGGING ---
+
+
+def _log_inventory(inventory: dict) -> str:
+    """
+    Format the inventory data as a table for logging.
+    """
+    log_table = log_as_table(
+        {
+            "year": year,
+            "should-run-tier-1": group.get(_InventoryKey.SHOULD_RUN_TIER_1, False),
+            "should-run-tier-2": group.get(_InventoryKey.SHOULD_RUN_TIER_2, False),
+            "ipcc-land-use-category": (
+                group.get(_InventoryKey.LU_CATEGORY).value if group.get(_InventoryKey.LU_CATEGORY) else None
+            ),
+            "ipcc-management-category": (
+                group.get(_InventoryKey.MG_CATEGORY).value if group.get(_InventoryKey.MG_CATEGORY) else None
+            ),
+            "ipcc-carbon-input-category": (
+                group.get(_InventoryKey.CI_CATEGORY).value if group.get(_InventoryKey.CI_CATEGORY) else None
+            ),
+            "temperature-monthly": (
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.TEMP_MONTHLY))
+                if group.get(_InventoryKey.TEMP_MONTHLY) else None
+            ),
+            "precipitation-monthly": (
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PRECIP_MONTHLY))
+                if group.get(_InventoryKey.PRECIP_MONTHLY) else None
+            ),
+            "pet-monthly": (
+                " ".join(f"{val:.1f}" for val in group.get(_InventoryKey.PET_MONTHLY))
+                if group.get(_InventoryKey.PET_MONTHLY) else None
+            ),
+            "irrigated-monthly": (
+                " ".join(str(val) for val in group.get(_InventoryKey.IRRIGATED_MONTHLY))
+                if group.get(_InventoryKey.PET_MONTHLY) else None
+            ),
+            "sand-content": group.get(_InventoryKey.SAND_CONTENT, None),
+            "carbon-input": group.get(_InventoryKey.CARBON_INPUT, None),
+            "n-content": group.get(_InventoryKey.N_CONTENT, None),
+            "lignin-content": group.get(_InventoryKey.LIGNIN_CONTENT, None),
+            "ipcc-tillage-category": (
+                group.get(_InventoryKey.TILLAGE_CATEGORY).value if group.get(_InventoryKey.TILLAGE_CATEGORY) else None
+            ),
+            "is-paddy-rice": group.get(_InventoryKey.IS_PADDY_RICE, None),
+        } for year, group in inventory.items()
+    )
+
+    return log_table or None
+
+
+# --- TIER 2 BUILD INVENTORY ---
+
+
+def _build_inventory_tier_2(
+    cycles: list[dict], measurement_nodes: list[dict]
+) -> tuple[dict, dict]:
+    """
+    Builds an annual inventory of data and a dictionary of keyword arguments for the tier 2 model.
+
+    TODO: implement long-term average climate data and annual climate data as back ups for monthly data
+    """
+    grouped_cycles = group_nodes_by_year(cycles)
+    grouped_measurements = group_nodes_by_year(measurement_nodes, mode=GroupNodesByYearMode.DATES)
+
+    grouped_climate_data = _get_grouped_climate_measurements(grouped_measurements)
+    grouped_irrigated_monthly = _get_grouped_irrigated_monthly(grouped_cycles)
+    grouped_sand_content_measurements = _get_grouped_sand_content_measurements(grouped_measurements)
+    grouped_carbon_input_data = _get_grouped_carbon_input_data(grouped_cycles)
+    grouped_tillage_categories = _get_grouped_tillage_categories(grouped_cycles)
+    grouped_is_paddy_rice = _get_grouped_is_paddy_rice(grouped_cycles)
+
+    grouped_data = merge(
+        grouped_climate_data,
+        grouped_irrigated_monthly,
+        grouped_sand_content_measurements,
+        grouped_carbon_input_data,
+        grouped_tillage_categories,
+        grouped_is_paddy_rice
+    )
+
+    grouped_should_run = {
+        year: {_InventoryKey.SHOULD_RUN_TIER_2: _should_run_inventory_year_tier_2(group)}
+        for year, group in grouped_data.items()
+    }
+
+    inventory = merge(grouped_data, grouped_should_run)
+    kwargs = {
+        "run_with_irrigation": True
+    }
+
+    return inventory, kwargs
+
+
+def _should_run_inventory_year_tier_2(group: dict) -> bool:
+    """
+    Determines whether there is sufficient data in an inventory year to run the tier 2 model.
+
+    1. Check that the cycle is not for paddy rice.
+    2. Check if monthly data has a value for each calendar month.
+    3. Check if all required keys are present.
 
     Parameters
     ----------
-    site : dict
-        A Hestia `Site` node, see: https://www.hestia.earth/schema/Site.
+    group : dict
+        Dictionary containing information for a specific inventory year.
 
     Returns
     -------
-    tuple
-        A tuple containing information to determine if Tier 1 should run, including timestamps,
-        IPCC land use categories, management categories, carbon input categories, eco-climate zone,
-        SOC reference, and initial SOC stock.
-    """
+    bool
+        True if the inventory year is valid, False otherwise.
+    """
+    monthly_data_complete = _check_12_months(
+        group,
+        {
+            _InventoryKey.TEMP_MONTHLY,
+            _InventoryKey.PRECIP_MONTHLY,
+            _InventoryKey.PET_MONTHLY,
+            _InventoryKey.IRRIGATED_MONTHLY
+        }
+    )
+
+    return all([
+        not group.get(_InventoryKey.IS_PADDY_RICE),
+        monthly_data_complete,
+        all(key in group.keys() for key in REQUIRED_KEYS_TIER_2),
+    ])
 
-    site_type = site.get("siteType", "")
-    management_nodes = site.get("management", [])
-    measurement_nodes = site.get("measurements", [])
 
+def _get_grouped_climate_measurements(grouped_measurements: dict) -> dict:
+    return {
+        year: {
+            _InventoryKey.TEMP_MONTHLY: find_term_match(measurements, TEMPERATURE_MONTHLY_TERM_ID, {}).get("value", []),
+            _InventoryKey.PRECIP_MONTHLY: (
+                find_term_match(measurements, PRECIPITATION_MONTHLY_TERM_ID, {}).get("value", [])
+            ),
+            _InventoryKey.PET_MONTHLY: find_term_match(measurements, PET_MONTHLY_TERM_ID, {}).get("value", [])
+        } for year, measurements in grouped_measurements.items()
+    }
+
+
+def _get_grouped_irrigated_monthly(grouped_cycles: dict) -> dict:
+    return {
+        year: {
+            _InventoryKey.IRRIGATED_MONTHLY: _get_irrigated_monthly(year, cycles)
+        } for year, cycles in grouped_cycles.items()
+    }
+
+
+def _get_irrigated_monthly(year: int, cycles: list[dict]) -> list[bool]:
+    # Get practice nodes and add "startDate" and "endDate" from cycle if missing.
+    irrigation_nodes = non_empty_list(flatten([
+        [
+            {
+                "startDate": cycle.get("startDate"),
+                "endDate": cycle.get("endDate"),
+                **node
+            } for node in cycle.get("practices", [])
+        ] for cycle in cycles
+    ]))
+
+    grouped_nodes = group_nodes_by_year_and_month(irrigation_nodes)
+
+    # For each month (1 - 12) check if irrigation is present.
+    return [
+        cumulative_nodes_term_match(
+            grouped_nodes.get(year, {}).get(month, []),
+            target_term_ids=get_irrigated_terms(),
+            cumulative_threshold=MIN_AREA_THRESHOLD
+        ) for month in range(1, 13)
+    ]
+
+
+def _get_grouped_sand_content_measurements(grouped_measurements: dict) -> dict:
+    grouped_sand_content_measurements = {
+        year: find_term_match(
+            [m for m in measurements if m.get("depthUpper") == DEPTH_UPPER and m.get("depthLower") == DEPTH_LOWER],
+            SAND_CONTENT_TERM_ID,
+            {}
+        ) for year, measurements in grouped_measurements.items()
+    }
+
+    return {
+        year: {_InventoryKey.SAND_CONTENT: get_node_value(measurement)}
+        for year, measurement in grouped_sand_content_measurements.items() if measurement
+    }
+
+
+def _get_grouped_carbon_input_data(grouped_cycles: dict) -> dict:
+    grouped_carbon_sources = {
+        year: _get_carbon_sources_from_cycles(cycle)
+        for year, cycle in grouped_cycles.items()
+    }
+
+    return {
+        year: {
+            _InventoryKey.CARBON_INPUT: _calc_total_organic_carbon_input(carbon_sources),
+            _InventoryKey.N_CONTENT: _calc_average_nitrogen_content_of_organic_carbon_sources(carbon_sources),
+            _InventoryKey.LIGNIN_CONTENT: _calc_average_lignin_content_of_organic_carbon_sources(carbon_sources)
+        } for year, carbon_sources in grouped_carbon_sources.items()
+    }
+
+
+def _get_grouped_tillage_categories(grouped_cycles):
+    return {
+        year: {
+            _InventoryKey.TILLAGE_CATEGORY: _assign_tier_2_ipcc_tillage_management_category(cycles)
+        } for year, cycles in grouped_cycles.items()
+    }
+
+
+def _get_grouped_is_paddy_rice(grouped_cycles: dict) -> dict:
+    return {
+        year: {
+            _InventoryKey.IS_PADDY_RICE: _check_is_paddy_rice(cycles)
+        } for year, cycles in grouped_cycles.items()
+    }
+
+
+def _check_is_paddy_rice(cycles: list[dict]) -> bool:
+    LOOKUP = LOOKUPS["crop"]
+    TARGET_LOOKUP_VALUES = IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE.get(
+        IpccLandUseCategory.PADDY_RICE_CULTIVATION, None
+    )
+
+    has_paddy_rice_products = any(cumulative_nodes_lookup_match(
+        filter_list_term_type(
+            cycle.get("products", []) + cycle.get("practices", []),
+            [TermTermType.CROP, TermTermType.FORAGE, TermTermType.LANDCOVER]
+        ),
+        lookup=LOOKUP,
+        target_lookup_values=TARGET_LOOKUP_VALUES,
+        cumulative_threshold=MIN_YIELD_THRESHOLD,
+        default_node_value=MIN_YIELD_THRESHOLD
+    ) for cycle in cycles)
+
+    has_upland_rice_products = any(cumulative_nodes_term_match(
+        filter_list_term_type(
+            cycle.get("products", []) + cycle.get("practices", []),
+            [TermTermType.CROP, TermTermType.FORAGE, TermTermType.LANDCOVER]
+        ),
+        target_term_ids=get_upland_rice_crop_terms() + get_upland_rice_land_cover_terms(),
+        cumulative_threshold=MIN_YIELD_THRESHOLD,
+        default_node_value=MIN_YIELD_THRESHOLD
+    ) for cycle in cycles)
+
+    has_irrigation = any(
+        _has_irrigation(filter_list_term_type(cycle.get("practices", []), [TermTermType.WATERREGIME]))
+        for cycle in cycles
+    )
+
+    return has_paddy_rice_products or (has_upland_rice_products and has_irrigation)
+
+
+# --- TIER 1 BUILD INVENTORY ---
+
+
+def _build_inventory_tier_1(
+    site_type: str, management_nodes: list[dict], measurement_nodes: list[dict]
+) -> tuple[dict, dict]:
+    """
+    Builds an annual inventory of data and a dictionary of keyword arguments for the tier 2 model.
+    """
     eco_climate_zone = _get_eco_climate_zone(measurement_nodes)
     ipcc_soil_category = _assign_ipcc_soil_category(measurement_nodes)
     soc_ref = _retrieve_soc_ref(eco_climate_zone, ipcc_soil_category)
@@ -3976,7 +3899,7 @@ def _should_run_tier_1(site: dict) -> tuple:
 
     grouped_land_use_categories = {
         year: {
-            IpccLandUseCategory: _assign_ipcc_land_use_category(
+            _InventoryKey.LU_CATEGORY: _assign_ipcc_land_use_category(
                 site_type,
                 nodes,
                 ipcc_soil_category
@@ -3986,171 +3909,72 @@ def _should_run_tier_1(site: dict) -> tuple:
 
     grouped_management_categories = {
         year: {
-            IpccManagementCategory: _assign_ipcc_management_category(
+            _InventoryKey.MG_CATEGORY: _assign_ipcc_management_category(
                 nodes,
-                grouped_land_use_categories[year][IpccLandUseCategory]
+                grouped_land_use_categories[year][_InventoryKey.LU_CATEGORY]
             )
         } for year, nodes in grouped_management.items()
     }
 
     grouped_carbon_input_categories = {
         year: {
-            IpccCarbonInputCategory: _assign_ipcc_carbon_input_category(
+            _InventoryKey.CI_CATEGORY: _assign_ipcc_carbon_input_category(
                 nodes,
-                grouped_management_categories[year][IpccManagementCategory]
+                grouped_management_categories[year][_InventoryKey.MG_CATEGORY]
             )
         } for year, nodes in grouped_management.items()
     }
 
-    grouped_data = reduce(merge, [
+    grouped_data = merge(
         grouped_land_use_categories,
         grouped_management_categories,
         grouped_carbon_input_categories
-    ])
-
-    complete_data = {
-        year: inner_dict for year, inner_dict in grouped_data.items()
-        if _should_run_inventory_year(inner_dict)
-    }
-
-    timestamps = list(complete_data)
-    start_year = timestamps[0] if timestamps else None
-    end_year = timestamps[-1] if timestamps else None
-
-    soc_measurement_value, soc_measurement_date = most_relevant_measurement_value_by_depth_and_date(
-        measurement_nodes,
-        TERM_ID,
-        f"{end_year}-12-31",  # Last year in inventory
-        DEPTH_UPPER,
-        DEPTH_LOWER,
-        depth_strict=True
-    ) if end_year else (None, None)
-
-    soc_measurement_datetime = safe_parse_date(soc_measurement_date)
-    soc_measurement_year = (
-        soc_measurement_datetime.year if soc_measurement_datetime else None
     )
 
-    ipcc_land_use_categories = [complete_data[year][IpccLandUseCategory] for year in timestamps]
-    ipcc_management_categories = [complete_data[year][IpccManagementCategory] for year in timestamps]
-    ipcc_carbon_input_categories = [complete_data[year][IpccCarbonInputCategory] for year in timestamps]
-
-    should_run = all([
-        soc_ref > 0,
-        isinstance(eco_climate_zone, int) and eco_climate_zone > 0,
-        len(timestamps) > 0,
-        (
-            start_year <= soc_measurement_year < end_year
-        ) if soc_measurement_value and soc_measurement_year else True
-    ])
+    grouped_should_run = {
+        year: {_InventoryKey.SHOULD_RUN_TIER_1: _should_run_inventory_year_tier_1(group)}
+        for year, group in grouped_data.items()
+    }
 
-    logShouldRun(
-        site, MODEL, TERM_ID, should_run,
-        timestamps=log_as_table(set(timestamps)),
-        ipcc_land_use_categories=log_as_table(set(ipcc_land_use_categories)),
-        ipcc_management_categories=log_as_table(set(ipcc_management_categories)),
-        ipcc_carbon_input_categories=log_as_table(set(ipcc_carbon_input_categories)),
-        eco_climate_zone=eco_climate_zone,
-        soc_ref=soc_ref,
-        run_with_soc_measurement=(soc_measurement_value and soc_measurement_year),
-        soc_measurement_value=soc_measurement_value,
-        soc_measurement_year=soc_measurement_year
-    )
+    inventory = merge(grouped_data, grouped_should_run)
+    kwargs = {
+        "eco_climate_zone": eco_climate_zone,
+        "ipcc_soil_category": ipcc_soil_category,
+        "soc_ref": soc_ref,
+    }
 
-    return (
-        should_run,
-        timestamps,
-        ipcc_land_use_categories,
-        ipcc_management_categories,
-        ipcc_carbon_input_categories,
-        eco_climate_zone,
-        soc_ref,
-        soc_measurement_value,
-        soc_measurement_year
-    )
+    return inventory, kwargs
 
 
-def _run_tier_1(
-    timestamps: list[int],
-    ipcc_land_use_categories: list[IpccLandUseCategory],
-    ipcc_management_categories: list[IpccManagementCategory],
-    ipcc_carbon_input_categories: list[IpccCarbonInputCategory],
-    eco_climate_zone: int,
-    soc_ref: float,
-    soc_measurement_value: Optional[float] = None,
-    soc_measurement_year: Optional[int] = None
-) -> list[dict]:
+def _should_run_inventory_year_tier_1(group: dict) -> bool:
     """
-    Run the IPCC (2019) Tier 1 methodology for calculating SOC stocks (in kg C ha-1) for each year in the inventory
-    and wrap each of the calculated values in Hestia measurement nodes.
+    Determines whether there is sufficient data in an inventory year to run the tier 1 model.
 
-    See [IPCC (2019) Vol. 4, Ch. 2](https://www.ipcc-nggip.iges.or.jp/public/2019rf/vol4.html) for more information.
+    1. Check if the land use category is not "OTHER"
+    2. Check if all required keys are present.
 
     Parameters
     ----------
-    timestamps : list[int]
-        A list of timestamps for each year in the inventory.
-    ipcc_land_use_categories : list[IpccLandUseCategory]
-        A list of IPCC land use categories for each year in the inventory.
-    ipcc_management_categories : list[IpccManagementCategory]
-        A list of IPCC management categories for each year in the inventory.
-    ipcc_carbon_input_categories : list[IpccCarbonInputCategory]
-        A list of IPCC carbon input categories for each year in the inventory.
-    eco_climate_zone : int
-        The eco-climate zone identifier for the site corresponding to a row in the
-        [ecoClimateZone](https://gitlab.com/hestia-earth/hestia-glossary/-/blob/develop/Measurements/ecoClimateZone-lookup.csv)
-        lookup table.
-    ipcc_soil_category : IpccSoilCategory
-        The reference condition SOC stock in the 0-30cm depth interval, kg C ha-1.
-    soc_measurement_value : float | None, optional
-        Measured SOC stock, if provided.
-    soc_measurement_year : int | None, optional
-        The year the SOC measurement took place, if provided.
+    group : dict
+        Dictionary containing information for a specific inventory year.
 
     Returns
     -------
-    tuple
+    bool
+        True if the inventory year is valid, False otherwise.
     """
-
-    iterated_timestamps, iterated_soc_equilibriums = _run_soc_equilibriums(
-        timestamps,
-        ipcc_land_use_categories,
-        ipcc_management_categories,
-        ipcc_carbon_input_categories,
-        eco_climate_zone,
-        soc_ref
-    )
-
-    soc_stocks = _calc_tier_1_soc_stocks(iterated_timestamps, iterated_soc_equilibriums)
-
-    soc_measurement_index = _find_closest_value_index(iterated_timestamps, soc_measurement_year)
-
-    scaled_soc_stocks = _scale_soc_stocks(
-        soc_stocks, soc_measurement_value, soc_measurement_index
-    )
-
-    slice_index = soc_measurement_index or 0
-    result_timestamps = iterated_timestamps[slice_index:]
-    result_soc_stocks = scaled_soc_stocks[slice_index:]
-
-    return [
-        _measurement(
-            year,
-            soc_stock,
-            MeasurementMethodClassification.TIER_1_MODEL.value
-        ) for year, soc_stock in zip(
-            result_timestamps,
-            result_soc_stocks
-        )
-    ]
+    return all([
+        group.get(_InventoryKey.LU_CATEGORY) != IpccLandUseCategory.OTHER,
+        all(key in group.keys() for key in REQUIRED_KEYS_TIER_1),
+    ])
 
 
-# --- SHARED TIER 1 & TIER 2 RUN FUNCTION ---
+# --- RUN ---
 
 
 def run(site: dict) -> list[dict]:
     """
-    Check which Tier of IPCC SOC model to run, run it and return the formatted output.
+    Check which Tiers of IPCC SOC model to run, run it and return the formatted output.
 
     Parameters
     ----------
@@ -4162,13 +3986,9 @@ def run(site: dict) -> list[dict]:
     list[dict]
         A list of Hestia `Measurement` nodes containing the calculated SOC stocks and additional relevant data.
     """
-    should_run_tier_2, *tier_2_args = _should_run_tier_2(site)
-    should_run_tier_1, *tier_1_args = (
-        _should_run_tier_1(site) if not should_run_tier_2
-        else (False, None)
-    )
+    should_run_tier_1, should_run_tier_2, inventory, kwargs = _should_run(site)
     return (
-        _run_tier_2(*tier_2_args) if should_run_tier_2
-        else _run_tier_1(*tier_1_args) if should_run_tier_1
+        _run_tier_2(inventory, **kwargs) if should_run_tier_2
+        else _run_tier_1(inventory, **kwargs) if should_run_tier_1
         else []
     )