hestia-earth-models 0.62.1__py3-none-any.whl → 0.62.2__py3-none-any.whl

hestia_earth/models/cycle/coldCarcassWeightPerHead.py

@@ -42,8 +42,10 @@ def _property(value: float):
 
 
 def _run(product: dict):
-    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead')
-    processingConversion = get_node_property_value(MODEL, product, 'processingConversionLiveweightToColdCarcassWeight')
+    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead', term=TERM_ID)
+    processingConversion = get_node_property_value(
+        MODEL, product, 'processingConversionLiveweightToColdCarcassWeight', term=TERM_ID
+    )
     value = liveweightPerHead * processingConversion if all([liveweightPerHead, processingConversion]) else None
     prop = _property(value) if value else None
     return {**product, 'properties': product.get('properties', []) + [prop]} if prop else None

hestia_earth/models/cycle/coldDressedCarcassWeightPerHead.py

@@ -46,9 +46,9 @@ def _property(value: float):
 
 
 def _run(product: dict):
-    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead')
+    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead', term=TERM_ID)
     processingConversion = get_node_property_value(
-        MODEL, product, 'processingConversionLiveweightToColdDressedCarcassWeight'
+        MODEL, product, 'processingConversionLiveweightToColdDressedCarcassWeight', term=TERM_ID
     )
     value = liveweightPerHead * processingConversion if all([liveweightPerHead, processingConversion]) else None
     prop = _property(value) if value else None

hestia_earth/models/cycle/concentrateFeed.py

@@ -79,7 +79,7 @@ def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str,
 def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id),
+        get_node_property_value(MODEL, i, property_id, term=TERM_ID),
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -88,8 +88,8 @@ def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_
 def _calculate_N_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id) or
-        get_node_property_value(MODEL, i, 'crudeProteinContent', default=0) * 0.16,
+        get_node_property_value(MODEL, i, property_id, term=TERM_ID) or
+        get_node_property_value(MODEL, i, 'crudeProteinContent', default=0, term=TERM_ID) * 0.16,
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)

hestia_earth/models/cycle/feedConversionRatio/feedConversionRatioNitrogen.py

@@ -72,5 +72,6 @@ TERM_ID = 'feedConversionRatioNitrogen'
 def run(cycle: dict, feed: float):
     inputs = get_feed_inputs(cycle)
     return list_sum(non_empty_list([
-        get_node_property_value_converted(MODEL, input, 'crudeProteinContent', default=0) / 6.25 for input in inputs
+        get_node_property_value_converted(MODEL, input, 'crudeProteinContent', default=0, term=TERM_ID) / 6.25
+        for input in inputs
     ]))

hestia_earth/models/cycle/readyToCookWeightPerHead.py

@@ -42,9 +42,9 @@ def _property(value: float):
 
 
 def _run(product: dict):
-    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead')
+    liveweightPerHead = get_node_property_value(MODEL, product, 'liveweightPerHead', term=TERM_ID)
     processingConversion = get_node_property_value(
-        MODEL, product, 'processingConversionLiveweightToReadyToCookWeight'
+        MODEL, product, 'processingConversionLiveweightToReadyToCookWeight', term=TERM_ID
     )
     value = liveweightPerHead * processingConversion if all([liveweightPerHead, processingConversion]) else None
     prop = _property(value) if value else None

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -12,7 +12,8 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils.blank_node import lookups_logs, properties_logs
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.term import get_wool_terms, get_lookup_value
 from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_term_type_incomplete
@@ -26,6 +27,7 @@ from ..pastureGrass_utils import (
     calculate_REM,
     calculate_REG,
     calculate_NEfeed,
+    calculate_GE,
     product_wool_energy,
     get_animals,
     get_animal_values
@@ -115,7 +117,8 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "animalManagement": [
-        "mjKgEvMilkIpcc2019"
+        "mjKgEvMilkIpcc2019",
+        "defaultFatContentEvMilkIpcc2019"
     ],
     "animalProduct": ["mjKgEvWoolNetEnergyWoolIpcc2019", "allowedLiveAnimalTermIds"],
     "liveAnimal": [
@@ -184,38 +187,50 @@ def calculate_NEwool(cycle: dict, animal: dict, products: list, total_weight: fl
     return total_energy * animal_weight/total_weight
 
 
-def _calculate_GE(
-    cycle: dict, animal: dict, REM: float, REG: float, NEwool: float, system: dict
-) -> float:
-    term_id = animal.get('term', {}).get('@id')
-
-    NEm, NEa, NEl, NEwork, NEp, NEg = get_animal_values(cycle, animal, system, log_node=animal)
-
-    NEm_feed, NEg_feed = calculate_NEfeed(animal)
-    debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                NEm=NEm,
-                NEa=NEa,
-                NEl=NEl,
-                NEwork=NEwork,
-                NEp=NEp,
-                NEg=NEg,
-                NEm_feed=NEm_feed,
-                NEg_feed=NEg_feed)
-
-    return (NEm + NEa + NEl + NEwork + NEp - NEm_feed)/REM + (NEg + NEwool - NEg_feed)/REG
-
-
-def _run_practice(animal: dict, GE: float, meanECHHV: float):
+def _run_practice(
+    animal: dict, values: dict, meanDE: float, meanECHHV: float, REM: float, REG: float,
+    NEwool: float, NEm_feed: float, NEg_feed: float
+):
     def run(practice: dict):
         key = practice.get('key', {})
         key_id = key.get('@id')
         input_term_id = practice_input_id(practice)
+
+        GE = (
+            calculate_GE([values], REM, REG, NEwool, NEm_feed, NEg_feed) / (meanDE/100)
+        ) if meanDE else 0
+
         value = (GE / meanECHHV) * (list_sum(practice.get('value', [0])) / 100)
 
+        logs = log_as_table(values | {
+            'animalId': animal.get('term', {}).get('@id'),
+            'practiceKeyId': key_id,
+            'GE': GE,
+            'NEmFeed': NEm_feed,
+            'NEgFeed': NEg_feed,
+            'REM': REM,
+            'REG': REG,
+            'NEwool': NEwool,
+            'meanECHHV': meanECHHV,
+            'meanDE': meanDE
+        })
+        animal_lookups = lookups_logs(MODEL, [animal], LOOKUPS, model_key=MODEL_KEY, term=input_term_id)
+        animal_properties = properties_logs([animal], properties=[
+            'liveweightPerHead',
+            'hoursWorkedPerDay',
+            'animalsPerBirth',
+            'pregnancyRateTotal',
+            'weightAtMaturity',
+            'liveweightGain',
+            'weightAtWeaning',
+            'weightAtOneYear',
+            'weightAtSlaughter'
+        ])
+
         logRequirements(animal, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
-                        GE=GE,
-                        meanECHHV=meanECHHV,
-                        practice_key_id=key_id)
+                        animal_logs=logs,
+                        animal_lookups=animal_lookups,
+                        animal_properties=animal_properties)
 
         logShouldRun(animal, MODEL, input_term_id, True, model_key=MODEL_KEY)
 
@@ -235,21 +250,16 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, system: dict, prac
     total_liveWeightPerHead = _sum_liveWeightPerHead(animals)
 
     def run(animal: dict):
-        term_id = animal.get('term', {}).get('@id')
-
         NEwool = calculate_NEwool(cycle, animal, wool_products, total_liveWeightPerHead) if (
             total_liveWeightPerHead > 0
         ) else 0
-        GE = (_calculate_GE(cycle, animal, REM, REG, NEwool, system) / (meanDE/100)) if all([REM, REG]) else 0
-
-        debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                    REM=REM,
-                    REG=REG,
-                    NEwool=NEwool,
-                    GE=GE,
-                    meanDE=meanDE)
+        NEm_feed, NEg_feed = calculate_NEfeed(animal)
+        animal_values = get_animal_values(cycle, animal, system)
 
-        inputs = list(map(_run_practice(animal, GE, meanECHHV), practices))
+        inputs = list(map(
+            _run_practice(animal, animal_values, meanDE, meanECHHV, REM, REG, NEwool, NEm_feed, NEg_feed),
+            practices
+        ))
         return animal | {
             'inputs': animal.get('inputs', []) + inputs
         }
@@ -289,8 +299,8 @@ def _should_run(cycle: dict, animals: list, practices: dict):
                             term_type_freshForage_incomplete=freshForage_incomplete,
                             no_cycle_inputs_feed=no_cycle_inputs_feed,
                             all_animals_have_value=all_animals_have_value,
-                            meanDE=meanDE,
-                            meanECHHV=meanECHHV)
+                            meanDE=calculate_meanDE(practices, term=term_id),
+                            meanECHHV=calculate_meanECHHV(practices, term=term_id))
 
             logShouldRun(animal, MODEL, term_id, should_run, model_key=MODEL_KEY)
 

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -26,7 +26,7 @@ from hestia_earth.models.utils.array_builders import (
 )
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_lookup_match, cumulative_nodes_term_match, group_nodes_by_year,
-    group_nodes_by_year_and_month, GroupNodesByYearMode, node_term_match
+    group_nodes_by_year_and_month, GroupNodesByYearMode, node_lookup_match, node_term_match
 )
 from hestia_earth.models.utils.cycle import check_cycle_site_ids_identical
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -36,16 +36,16 @@ from hestia_earth.models.utils.site import related_cycles
 
 from .organicCarbonPerHa_utils import (
     CarbonSource, check_consecutive, DEPTH_LOWER, DEPTH_UPPER, check_irrigation,
-    get_crop_residue_inc_or_left_terms_with_cache,
-    get_upland_rice_crop_terms_with_cache,
-    get_upland_rice_land_cover_terms_with_cache,
-    IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE, IPCC_MANAGEMENT_CATEGORY_TO_TILLAGE_MANAGEMENT_LOOKUP_VALUE,
-    IpccLandUseCategory, IpccManagementCategory, MIN_AREA_THRESHOLD, MIN_YIELD_THRESHOLD, sample_constant,
-    sample_plus_minus_uncertainty, sample_truncated_normal, STATS_DEFINITION
+    get_cover_crop_property_terms_with_cache, get_upland_rice_crop_terms_with_cache,
+    get_upland_rice_land_cover_terms_with_cache, IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE,
+    IPCC_MANAGEMENT_CATEGORY_TO_TILLAGE_MANAGEMENT_LOOKUP_VALUE, IpccLandUseCategory, IpccManagementCategory,
+    MIN_AREA_THRESHOLD, MIN_YIELD_THRESHOLD, sample_constant, sample_plus_minus_uncertainty, sample_truncated_normal,
+    STATS_DEFINITION
 )
 
 _LOOKUPS = {
     "crop": "IPCC_LAND_USE_CATEGORY",
+    "landCover": "IPCC_LAND_USE_CATEGORY",
     "tillage": "IPCC_TILLAGE_MANAGEMENT_CATEGORY"
 }
 
@@ -59,10 +59,27 @@ _NUMBER_OF_TILLAGES_TERM_ID = "numberOfTillages"
 _TEMPERATURE_MONTHLY_TERM_ID = "temperatureMonthly"
 _PRECIPITATION_MONTHLY_TERM_ID = "precipitationMonthly"
 _PET_MONTHLY_TERM_ID = "potentialEvapotranspirationMonthly"
+_ABOVE_GROUND_CROP_RESIDUE_TOTAL_TERM_ID = "aboveGroundCropResidueTotal"
 _CARBON_CONTENT_TERM_ID = "carbonContent"
 _NITROGEN_CONTENT_TERM_ID = "nitrogenContent"
 _LIGNIN_CONTENT_TERM_ID = "ligninContent"
 
+_CROP_RESIDUE_MANAGEMENT_TERM_IDS = [
+    "residueIncorporated",
+    "residueIncorporatedLessThan30DaysBeforeCultivation",
+    "residueIncorporatedMoreThan30DaysBeforeCultivation",
+    "residueLeftOnField"
+]
+
+_CARBON_SOURCE_TERM_IDS = [
+    "discardedCropIncorporated",
+    "discardedCropLeftOnField",
+    "belowGroundCropResidue",
+]
+
+_MIN_RESIDUE_LEFT_ON_FIELD = 20  # TODO: Confirm assumption
+_DEFAULT_COVER_CROP_BIOMASS = 4000  # TODO: Confirm assumption, Source PAS 2050-1:2012
+
 _CARBON_INPUT_PROPERTY_TERM_IDS = [
     _CARBON_CONTENT_TERM_ID,
     _NITROGEN_CONTENT_TERM_ID,
@@ -1284,8 +1301,8 @@ def _get_grouped_sand_content_measurements(grouped_measurements: dict) -> dict:
 
 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()
+        year: flatten([_get_carbon_sources(cycle) for cycle in cycles])
+        for year, cycles in grouped_cycles.items()
     }
 
     return {
@@ -1297,67 +1314,219 @@ def _get_grouped_carbon_input_data(grouped_cycles: dict) -> dict:
     }
 
 
-def _get_carbon_sources_from_cycles(cycles: dict) -> list[CarbonSource]:
+def _get_carbon_sources(cycle: dict) -> list[CarbonSource]:
     """
-    Retrieves and formats all of the valid carbon sources from a list of cycles.
+    Extract and format the carbon source data from a cycle's inputs and products.
 
     Carbon sources can be either a Hestia `Product` node (e.g. crop residue) or `Input` node (e.g. organic amendment).
 
     Parameters
     ----------
-    cycles : list[dict]
-        A list of Hestia `Cycle` nodes, see: https://www.hestia.earth/schema/Cycle.
+    cycle : list[dict]
+        A Hestia `Cycle` node, see: https://www.hestia.earth/schema/Cycle.
 
     Returns
     -------
     list[CarbonSource]
-        A formatted list of `CarbonSource`s for the inputted `Cycle`s.
+        A formatted list of `CarbonSource`s.
     """
-    inputs_and_products = non_empty_list(flatten(
-        [cycle.get("inputs", []) + cycle.get("products", []) for cycle in cycles]
-    ))
-
+    inputs_and_products = cycle.get("inputs", []) + cycle.get("products", [])
     return non_empty_list([
-        _iterate_carbon_source(node) for node in inputs_and_products
-        if any([
-            node.get("term", {}).get("@id") in get_crop_residue_inc_or_left_terms_with_cache(),
-            node.get("term", {}).get("termType") in _CARBON_SOURCE_TERM_TYPES
-        ])
+        next(
+            (_func(node, cycle) for validator, _func in _CARBON_SOURCE_DECISION_TREE.items() if validator(node)),
+            None
+        ) for node in inputs_and_products
+    ])
+
+
+def _should_run_carbon_source_ag_residue(node: dict) -> bool:
+    """
+    Determine whether an input or product is a valid above-ground biomass carbon source.
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Input](https://www.hestia.earth/schema/Input) or [Product](https://www.hestia.earth/schema/Product)
+        node.
+
+    Returns
+    -------
+    bool
+        Whether the node satisfies the critera.
+    """
+    return node.get("term", {}).get("@id") == _ABOVE_GROUND_CROP_RESIDUE_TOTAL_TERM_ID
+
+
+def _calc_carbon_source_ag_crop_residue(node: dict, cycle: dict) -> Union[CarbonSource, None]:
+    """
+    Extract and format the carbon source data for above-ground crop residues.
+
+    n.b., We assume that even if a cycle's residue management states that 100% of above-ground crop residues are
+    removed or burnt, a minimal amount of crop residues do remain on site to become a carbon source (see
+    `_MIN_RESIDUE_LEFT_ON_FIELD` variable).
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Product](https://www.hestia.earth/schema/Product) node with `term.termType` == `landCover`.
+
+    Returns
+    -------
+    CarbonSource | None
+        The carbon source data of the above-ground residues, or `None` if carbon source data incomplete.
+    """
+    value = get_node_value(node)
+    residue_left_on_field = list_sum([
+        get_node_value(practice) for practice in cycle.get("practices", [])
+        if node_term_match(practice, _CROP_RESIDUE_MANAGEMENT_TERM_IDS)
+    ])
+    mass = value * max(residue_left_on_field, _MIN_RESIDUE_LEFT_ON_FIELD) / 100
+
+    carbon_source = CarbonSource(
+        mass,
+        *_retrieve_carbon_source_properties(node)
+    )
+
+    return carbon_source if _validate_carbon_source(carbon_source) else None
+
+
+def _should_run_carbon_source_cover_crop(node: dict) -> bool:
+    """
+    Determine whether a product is a valid above cover crop carbon source.
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Input](https://www.hestia.earth/schema/Input) or [Product](https://www.hestia.earth/schema/Product)
+        node.
+
+    Returns
+    -------
+    bool
+        Whether the node satisfies the critera.
+    """
+    LOOKUP = _LOOKUPS["landCover"]
+    return all([
+        node.get("term", {}).get("termType") in [TermTermType.LANDCOVER.value],
+        node_lookup_match(
+            node, LOOKUP, IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE[IpccLandUseCategory.ANNUAL_CROPS]
+        ),
+        any(
+            get_node_property(node, term_id, False).get("value", False)
+            for term_id in get_cover_crop_property_terms_with_cache()
+        )
     ])
 
 
-def _iterate_carbon_source(node: dict) -> Union[CarbonSource, None]:
+def _calc_carbon_source_cover_crop(node: dict, *_) -> Union[CarbonSource, None]:
     """
-    Validates whether a node is a valid carbon source and returns a `CarbonSource` named tuple if yes.
+    Extract and format the carbon source data for an annual cover crop.
+
+    n.b., We make the assumption that the entirety of the cover crop's biomass remains on site.
 
     Parameters
     ----------
     node : dict
-        A Hestia `Product` or `Input` node, see: https://www.hestia.earth/schema/Product
-        or https://www.hestia.earth/schema/Input.
+        A Hestia [Product](https://www.hestia.earth/schema/Product) node with `term.termType` == `landCover`.
 
     Returns
     -------
     CarbonSource | None
-        A `CarbonSource` named tuple if the node is a carbon source with the required properties, else `None`.
+        The carbon source data of the cover crop, or `None` if carbon source data incomplete.
+    """
+    value = get_node_value(node)
+    carbon_source = CarbonSource(
+        _DEFAULT_COVER_CROP_BIOMASS * value / 100,
+        _Parameter.DEFAULT_CARBON_CONTENT.value.get("value"),
+        _Parameter.DEFAULT_NITROGEN_CONTENT.value.get("value"),
+        _Parameter.DEFAULT_NITROGEN_CONTENT.value.get("value")
+    )
+    return carbon_source
+
+
+def _should_run_carbon_source(node: dict) -> bool:
+    """
+    Determine whether an input or product is a valid carbon source.
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Input](https://www.hestia.earth/schema/Input) or [Product](https://www.hestia.earth/schema/Product)
+        node.
+
+    Returns
+    -------
+    bool
+        Whether the node satisfies the critera.
+    """
+    return any([
+        node.get("term", {}).get("@id") in _CARBON_SOURCE_TERM_IDS,
+        node.get("term", {}).get("termType") in _CARBON_SOURCE_TERM_TYPES
+    ])
+
+
+def _calc_carbon_source(node: dict, *_) -> Union[CarbonSource, None]:
+    """
+    Extract and format the carbon source data for an input or product.
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Input](https://www.hestia.earth/schema/Input) or [Product](https://www.hestia.earth/schema/Product)
+        node.
+
+    Returns
+    -------
+    CarbonSource | None
+        The carbon source data of the cover crop, or `None` if carbon source data incomplete.
+    """
+    carbon_source = CarbonSource(
+        get_node_value(node),
+        *_retrieve_carbon_source_properties(node)
+    )
+
+    return carbon_source if _validate_carbon_source(carbon_source) else None
+
+
+def _retrieve_carbon_source_properties(node: dict) -> tuple[float, float, float]:
+    """
+    Extract the carbon source properties from an input or product node or, if required, retrieve them from default
+    properties.
+
+    Parameters
+    ----------
+    node : dict
+        A Hestia [Input](https://www.hestia.earth/schema/Input) or [Product](https://www.hestia.earth/schema/Product)
+        node.
+
+    Returns
+    -------
+    tuple[float, float, float]
+        `(carbon_content, nitrogen_content, lignin_content)`
     """
-    mass = list_sum(node.get("value", []))
     carbon_content, nitrogen_content, lignin_content = (
         get_node_property(node, term_id).get("value", 0)/100 for term_id in _CARBON_INPUT_PROPERTY_TERM_IDS
     )
+    return carbon_content, nitrogen_content, lignin_content
 
-    should_run_ = all([
-        mass > 0,
-        0 < carbon_content <= 1,
-        0 < nitrogen_content <= 1,
-        0 < lignin_content <= 1
+
+def _validate_carbon_source(carbon_source: CarbonSource) -> bool:
+    """
+    Validate that a `CarbonSource` named tuple is data complete.
+    """
+    return all([
+        carbon_source.mass > 0,
+        0 < carbon_source.carbon_content <= 1,
+        0 < carbon_source.nitrogen_content <= 1,
+        0 < carbon_source.lignin_content <= 1
     ])
 
-    return (
-        CarbonSource(
-            mass, carbon_content, nitrogen_content, lignin_content
-        ) if should_run_ else None
-    )
+
+_CARBON_SOURCE_DECISION_TREE = {
+    _should_run_carbon_source_ag_residue: _calc_carbon_source_ag_crop_residue,
+    _should_run_carbon_source_cover_crop: _calc_carbon_source_cover_crop,
+    _should_run_carbon_source: _calc_carbon_source,
+}
 
 
 def _calc_total_organic_carbon_input(

hestia_earth/models/ipcc2019/organicCarbonPerHa_utils.py

@@ -10,8 +10,8 @@ from hestia_earth.models.utils.array_builders import (
 )
 from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 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_residue_removed_or_burnt_terms, get_upland_rice_crop_terms, get_upland_rice_land_cover_terms
+    get_cover_crop_property_terms, get_irrigated_terms, get_residue_removed_or_burnt_terms, get_upland_rice_crop_terms,
+    get_upland_rice_land_cover_terms
 )
 
 STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
@@ -27,10 +27,6 @@ def get_cover_crop_property_terms_with_cache():
     return lru_cache()(get_cover_crop_property_terms)()
 
 
-def get_crop_residue_inc_or_left_terms_with_cache():
-    return lru_cache()(get_crop_residue_incorporated_or_left_on_field_terms)()
-
-
 def get_irrigated_terms_with_cache():
     return lru_cache()(get_irrigated_terms)()