hestia-earth-models 0.74.1__py3-none-any.whl → 0.74.3__py3-none-any.whl

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -0,0 +1,264 @@
+from functools import reduce
+from typing import NamedTuple
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+
+from hestia_earth.models.utils import hectar_to_square_meter
+from hestia_earth.models.utils.constant import DAYS_IN_YEAR
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import get_product
+from hestia_earth.models.utils.site import get_land_cover_term_id as get_landCover_term_id_from_site_type
+from hestia_earth.models.utils.crop import get_landCover_term_id
+from hestia_earth.schema import CycleFunctionalUnit
+
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "product": {
+            "@type": "Term",
+            "value": "> 0",
+            "optional": {
+                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
+                "economicValueShare": ">= 0"
+            }
+        },
+        "cycle": {
+            "@type": "Cycle",
+            "site": {
+                "@type": "Site",
+                "country": {"@type": "Term", "termType": "region"}
+            },
+            "siteArea": "",
+            "siteDuration": "",
+            "siteUnusedDuration": "",
+            "optional": {
+                "@doc": "When `otherSites` are provided, `otherSitesArea`, `otherSitesDuration` and `otherSitesUnusedDuration` are required",  # noqa: E501
+                "otherSites": [{
+                    "@type": "Site",
+                    "country": {"@type": "Term", "termType": "region"}
+                }],
+                "otherSitesArea": "",
+                "otherSitesDuration": "",
+                "otherSitesUnusedDuration": ""
+            }
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": ""
+    }]
+}
+TERM_ID = 'landOccupationDuringCycle'
+
+
+class SiteData(NamedTuple):
+    id: str  # site.@id
+    area: float
+    duration: float
+    unused_duration: float
+    land_cover_id: str
+    country_id: str
+
+
+def _indicator(term_id: str, value: float, land_cover_id: str, country_id: str):
+    indicator = _new_indicator(
+        term_id, model=MODEL, land_cover_id=land_cover_id, country_id=country_id
+    )
+    indicator['value'] = round(value, 6)
+    return indicator
+
+
+def _calc_land_occupation_m2_per_ha(
+    site_area: float, site_duration: float, site_unused_duration: float
+) -> float:
+    """
+    Parameters
+    ----------
+    site_area : float
+        Area of the site in hectares.
+    site_duration : float
+        Site duration in days.
+    site_unused_duration : float
+        Site unused duration in days.
+
+    Returns
+    -------
+    float
+    """
+    return hectar_to_square_meter(site_area) * (site_duration + site_unused_duration) / DAYS_IN_YEAR
+
+
+def _calc_land_occupation_m2_per_kg(
+    yield_: float, economic_value_share: float, land_occupation_m2_per_ha: float,
+) -> float:
+    """
+    Parameters
+    ----------
+    yield_ : float
+        Product yield in product units.
+    economic_value_share : float
+        Economic value share of the product in % (0-100).
+    land_occupation_m2_per_ha : float
+        Land occupation in m2 ha-1.
+
+    Returns
+    -------
+    float
+    """
+    return land_occupation_m2_per_ha * economic_value_share * 0.01 / yield_
+
+
+_CYCLE_KEYS = (
+    "site", "siteArea", "siteDuration", "siteUnusedDuration"
+)
+
+_CYCLE_KEY_MAPPING = {
+    field: field.replace("site", "otherSites", 1) for field in _CYCLE_KEYS
+}
+
+
+def _build_inventory(cycle: dict, product: dict):
+    product_land_cover_id = get_landCover_term_id(product.get("term", {}), skip_debug=True)
+
+    cycle_data = {
+        key: [value] + cycle.get(otherSites_key, []) for key, otherSites_key in _CYCLE_KEY_MAPPING.items()
+        if (value := cycle.get(key))
+    }
+
+    n_sites = len(cycle_data.get("site", []))
+    should_build_inventory = n_sites > 0 and all([
+        len(cycle_data.get(key, [])) == n_sites for key in _CYCLE_KEYS[1:]
+    ])
+
+    inventory = [
+        SiteData(
+            id=site.get("@id"),
+            area=cycle_data["siteArea"][i],
+            duration=cycle_data["siteDuration"][i],
+            unused_duration=cycle_data["siteUnusedDuration"][i],
+            country_id=site.get("country", {}).get("@id"),
+            land_cover_id=product_land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType", {}))
+        ) for i, site in enumerate(cycle_data.get("site", []))
+    ] if should_build_inventory else []
+
+    logs = {
+        "n_sites": n_sites
+    }
+
+    return inventory, logs
+
+
+def _should_run_site_data(site_data: SiteData) -> bool:
+    return all([
+        site_data.area >= 0,
+        site_data.duration >= 0,
+        site_data.unused_duration >= 0,
+        site_data.land_cover_id,
+        site_data.country_id
+    ])
+
+
+def _format_float(value: float, unit: str = "") -> str:
+    return " ".join(
+        string for string in [f"{value:.3g}", unit] if string
+    ) if value else "None"
+
+
+_INVALID_CHARS = {"_", ":", ",", "="}
+_REPLACEMENT_CHAR = "-"
+
+
+def _format_str(value: str) -> str:
+    """Format a string for logging in a table. Remove all characters used to render the table on the front end."""
+    return reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
+
+
+def _format_inventory(inventory: list[SiteData]) -> str:
+    return log_as_table(
+        {
+            "@id": _format_str(site_data.id),
+            "site-area": _format_float(site_data.area, "ha"),
+            "site-duration": _format_float(site_data.duration, "days"),
+            "site-unused-duration": _format_float(site_data.unused_duration, "days"),
+            "land-cover-id": _format_str(site_data.land_cover_id),
+            "country-id": _format_str(site_data.country_id)
+        } for site_data in inventory
+    ) if inventory else "None"
+
+
+def _should_run(impact_assessment: dict):
+
+    cycle = impact_assessment.get("cycle")
+    functional_unit = cycle.get("functionalUnit")
+
+    product = get_product(impact_assessment)
+    yield_ = sum(product.get("value", []))
+    economic_value_share = (
+        100 if functional_unit == CycleFunctionalUnit.RELATIVE.value
+        else product.get("economicValueShare")
+    )
+
+    inventory, logs = _build_inventory(cycle, product)
+
+    valid_inventory = inventory and all(_should_run_site_data(site_data) for site_data in inventory)
+
+    logRequirements(
+        impact_assessment,
+        model=MODEL,
+        term=TERM_ID,
+        functional_unit=functional_unit,
+        yield_=_format_float(yield_, product.get("term", {}).get("units")),
+        economic_value_share=_format_float(economic_value_share, "pct"),
+        site_inventory=_format_inventory(inventory),
+        valid_inventory=valid_inventory,
+        **logs
+    )
+
+    should_run = all([
+        yield_ > 0,
+        (
+            economic_value_share is not None
+            and economic_value_share >= 0
+        ),
+        valid_inventory
+    ])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return should_run, yield_, economic_value_share, inventory
+
+
+def _run(
+    yield_: float,
+    economic_value_share: float,
+    inventory: list[SiteData]
+) -> list[dict]:
+
+    def calc_occupation_by_group(result: dict, site_data: SiteData):
+        """Calculate the land occupation of a site and sum it with matching landCover/country groups."""
+
+        land_occupation_m2_per_ha = _calc_land_occupation_m2_per_ha(
+            site_data.area, site_data.duration, site_data.unused_duration
+        )
+
+        land_occupation_m2_per_kg = _calc_land_occupation_m2_per_kg(
+            yield_, economic_value_share, land_occupation_m2_per_ha
+        )
+
+        key = (site_data.land_cover_id, site_data.country_id)
+        return result | {key: result.get(key, 0) + land_occupation_m2_per_kg}
+
+    land_occupation_by_group = reduce(calc_occupation_by_group, inventory, {})
+
+    return [
+        _indicator(TERM_ID, value, land_cover_id, country_id)
+        for (land_cover_id, country_id), value in land_occupation_by_group.items()
+    ]
+
+
+def run(impact_assessment: dict):
+    should_run, yield_, economic_value_share, inventory = _should_run(impact_assessment)
+    return _run(yield_, economic_value_share, inventory) if should_run else []

hestia_earth/models/hestia/management.py

@@ -1,9 +1,9 @@
 from typing import List
 from datetime import timedelta, datetime
-from hestia_earth.schema import SchemaType, TermTermType, SiteSiteType, COMPLETENESS_MAPPING
+from hestia_earth.schema import SchemaType, TermTermType, COMPLETENESS_MAPPING
 from hestia_earth.utils.lookup import column_name, get_table_value, download_lookup
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float, flatten
+from hestia_earth.utils.tools import safe_parse_float, flatten, is_number, is_boolean
 from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
@@ -16,6 +16,7 @@ from hestia_earth.models.utils.site import (
     related_cycles, get_land_cover_term_id as get_landCover_term_id_from_site_type
 )
 from . import MODEL
+from ..utils.property import get_property_lookup_value
 
 REQUIREMENTS = {
     "Site": {
@@ -67,13 +68,15 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
+    "biochar": "inputGapFillManagementTermId",
     "crop": ["landCoverTermId", "maximumCycleDuration"],
     "forage": ["landCoverTermId"],
-    "inorganicFertiliser": "nitrogenContent",
-    "organicFertiliser": "ANIMAL_MANURE",
-    "soilAmendment": "PRACTICE_INCREASING_C_INPUT",
+    "inorganicFertiliser": "inputGapFillManagementTermId",
+    "organicFertiliser": "inputGapFillManagementTermId",
+    "soilAmendment": "inputGapFillManagementTermId",
     "landUseManagement": "GAP_FILL_TO_MANAGEMENT",
-    "property": "GAP_FILL_TO_MANAGEMENT"
+    "property": "GAP_FILL_TO_MANAGEMENT",
+    "landCover": "sumIs100Group"
 }
 MODEL_KEY = 'management'
 
@@ -87,41 +90,6 @@ _PRACTICES_TERM_TYPES = [
     TermTermType.LANDCOVER
 ]
 _PRACTICES_COMPLETENESS_MAPPING = COMPLETENESS_MAPPING.get(SchemaType.PRACTICE.value, {})
-_ANIMAL_MANURE_USED_TERM_ID = "animalManureUsed"
-_INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID = "inorganicNitrogenFertiliserUsed"
-_ORGANIC_FERTILISER_USED_TERM_ID = "organicFertiliserUsed"
-_AMENDMENT_INCREASING_C_USED_TERM_ID = "amendmentIncreasingSoilCarbonUsed"
-_INPUT_RULES = {
-    TermTermType.INORGANICFERTILISER.value: (
-        (
-            TermTermType.INORGANICFERTILISER.value,  # Lookup column
-            lambda x: safe_parse_float(x, default=0) > 0,  # Condition
-            _INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID  # New term.
-        ),
-    ),
-    TermTermType.SOILAMENDMENT.value: (
-        (
-            TermTermType.SOILAMENDMENT.value,
-            lambda x: bool(x) is True,
-            _AMENDMENT_INCREASING_C_USED_TERM_ID
-        ),
-    ),
-    TermTermType.ORGANICFERTILISER.value: (
-        (
-            TermTermType.SOILAMENDMENT.value,
-            lambda x: bool(x) is True,
-            _ORGANIC_FERTILISER_USED_TERM_ID
-        ),
-        (
-            TermTermType.ORGANICFERTILISER.value,
-            lambda x: bool(x) is True,
-            _ANIMAL_MANURE_USED_TERM_ID
-        )
-    )
-}
-_SKIP_LAND_COVER_SITE_TYPES = [
-    SiteSiteType.CROPLAND.value
-]
 
 
 def management(data: dict):
@@ -135,6 +103,10 @@ def management(data: dict):
     return node
 
 
+def _is_cover_crop(term_id: str) -> bool:
+    return get_property_lookup_value(model=MODEL, term_id=term_id, column="blankNodesGroup") == "Cover crops"
+
+
 def _get_cycle_duration(cycle: dict, land_cover_id: str = None):
     cycle_duration = cycle.get('cycleDuration')
     lookup_value = None if cycle_duration or not land_cover_id else safe_parse_float(get_table_value(
@@ -227,58 +199,122 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
     ]
 
 
-def _process_rule(node: dict, term: dict) -> list:
-    term_types = []
-    for column, condition, new_term in _INPUT_RULES[term.get('termType')]:
-        lookup_result = get_lookup_value(term, LOOKUPS[column], model=MODEL, term=term.get('@id'), model_key=MODEL_KEY)
+def _input_gap_fill_term_id(input: dict):
+    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId')
 
-        if condition(lookup_result):
-            term_types.append(node | {'id': new_term})
 
-    return term_types
+def _input_value_valid(input: dict):
+    value = get_node_value(input)
+    return value > 0 if is_number(value) else bool(value) is True if is_boolean(value) else False
 
 
-def _run_from_inputs(site: dict, cycle: dict) -> list:
-    inputs = flatten([
-        _process_rule(node={
+def _run_from_inputs(cycle: dict) -> list:
+    inputs_with_ids = [
+        {
+            'input-id': input.get('term', {}).get('@id'),
+            'input-valid': _input_value_valid(input),
+            'term-id': _input_gap_fill_term_id(input)
+        } for input in cycle.get('inputs', [])
+    ]
+    return [
+        {
+            'id': input.get('term-id'),
             'value': True,
             'startDate': cycle.get('startDate'),
             'endDate': cycle.get('endDate')
-        }, term=input.get('term'))
-        for input in cycle.get('inputs', [])
-        if input.get('term', {}).get('termType') in _INPUT_RULES
+        }
+        for input in inputs_with_ids
+        if all([
+            input.get('term-id'),
+            input.get('input-valid')
+        ])
+    ]
+
+
+def _cycle_has_existing_non_cover_land_cover_nodes(cycle: dict) -> bool:
+    # if there are any landCover blank nodes in Practices without a Property from the
+    # blankNodesGroup = Cover crops lookup, return True, else False
+    return any([
+        practice for practice in cycle.get("practices", [])
+        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
+        and not any(prop for prop in practice.get("properties", [])
+                    if _is_cover_crop(prop.get("term", {}).get("@id")))
     ])
-    return inputs
 
 
-def _run_from_siteType(site: dict, cycle: dict):
-    site_type = site.get('siteType')
-    site_type_id = get_landCover_term_id_from_site_type(site_type) if site_type not in _SKIP_LAND_COVER_SITE_TYPES \
-        else None
+def _run_from_siteType(cycle: dict, site_type_id: str):
     start_date = cycle.get('startDate') or _gap_filled_start_date(
         cycle=cycle,
         end_date=cycle.get('endDate'),
         land_cover_id=site_type_id
     ).get('startDate')
+    no_land_cover_blank_node = not _cycle_has_existing_non_cover_land_cover_nodes(cycle)
 
-    should_run = all([site_type_id, start_date])
+    should_run = all([site_type_id, start_date, no_land_cover_blank_node])
     return [{
         'id': site_type_id,
+        'termType': TermTermType.LANDCOVER.value,
         'value': 100,
         'startDate': start_date,
         'endDate': cycle.get('endDate')
     }] if should_run else []
 
 
-def _should_run_practice(practice: dict):
+def _node_with_gap_filled_dates(node: dict, cycle: dict, site_type_id: str) -> dict:
+    return node | {
+        "endDate": node.get("endDate") or cycle.get("endDate"),
+        "startDate": node.get("startDate") or cycle.get('startDate') or _gap_filled_start_date(
+            cycle=cycle,
+            end_date=cycle.get('endDate'),
+            land_cover_id=site_type_id
+        ).get("startDate"),
+    }
+
+
+def _dates_overlap(target_practice: dict, node: dict, cycle: dict, site_type_id: str) -> bool:
+    target_practice = _node_with_gap_filled_dates(node=target_practice, cycle=cycle, site_type_id=site_type_id)
+    node = _node_with_gap_filled_dates(node=node, cycle=cycle, site_type_id=site_type_id)
+    return all([
+        node["startDate"],
+        node["endDate"],
+        target_practice["startDate"],
+        target_practice["endDate"],
+        (
+            node["startDate"] <= target_practice["startDate"] <= node["endDate"] or
+            node["startDate"] < target_practice["endDate"] <= node["endDate"]
+        )
+    ])
+
+
+def _should_run_practice(management_nodes: list, cycle: dict, site_type_id: str):
     """
     Include only landUseManagement practices where GAP_FILL_TO_MANAGEMENT = True
     """
-    term = practice.get('term', {})
-    return term.get('termType') != TermTermType.LANDUSEMANAGEMENT.value or _should_gap_fill(term)
+    landCover_management_nodes = [
+        _node_with_gap_filled_dates(node=node, cycle=cycle, site_type_id=site_type_id) | {
+            'sumIs100Group': get_lookup_value(node.get("term", {}), 'sumIs100Group', skip_debug=True, model=MODEL)
+        }
+        for node in filter_list_term_type(management_nodes, TermTermType.LANDCOVER)
+    ]
 
+    def run(practice: dict):
+        term = practice.get('term', {})
+        target_group = get_lookup_value(practice.get("term", {}), 'sumIs100Group', skip_debug=True, model=MODEL)
+        has_other_land_cover_in_same_group = next((
+            True for node in landCover_management_nodes
+            if (
+                node['sumIs100Group'] == target_group and
+                _dates_overlap(target_practice=practice, node=node, cycle=cycle, site_type_id=site_type_id)
+            )
+        ), None) is not None
+        return (
+            (term.get('termType') != TermTermType.LANDUSEMANAGEMENT.value or _should_gap_fill(term)) and
+            not has_other_land_cover_in_same_group
+        )
+    return run
 
-def _run_from_practices(cycle: dict):
+
+def _run_from_practices(site: dict, cycle: dict, site_type_id: str):
     practices = [
         _extract_node_value(
             _include_with_date_gap_fill(
@@ -292,13 +328,18 @@ def _run_from_practices(cycle: dict):
             completeness_mapping=_PRACTICES_COMPLETENESS_MAPPING
         )
     ]
-    return list(map(_map_to_value, filter(_should_run_practice, practices)))
+    management_nodes = site.get("management", [])
+    return list(map(_map_to_value, filter(
+        _should_run_practice(management_nodes=management_nodes, cycle=cycle, site_type_id=site_type_id), practices
+    )))
 
 
 def _run_cycle(site: dict, cycle: dict):
-    inputs = _run_from_inputs(site, cycle)
-    site_types = _run_from_siteType(site=site, cycle=cycle)
-    practices = _run_from_practices(cycle)
+    inputs = _run_from_inputs(cycle)
+    site_type = site.get('siteType')
+    site_type_id = get_landCover_term_id_from_site_type(site_type)
+    site_types = _run_from_siteType(cycle=cycle, site_type_id=site_type_id)
+    practices = _run_from_practices(site=site, cycle=cycle, site_type_id=site_type_id)
     return [
         node | {'cycle-id': cycle.get('@id')}
         for node in inputs + site_types + practices

hestia_earth/models/hestia/utils.py

@@ -35,7 +35,6 @@ LAND_USE_TERMS_FOR_TRANSFORMATION = {
     PERMANENT_PASTURE: ("permanentPasture", "Permanent pasture"),
     OTHER_LAND: ("otherLand", OTHER_LAND)  # Not used yet
 }
-LAND_USE_NAMES_FROM_ID = {v[0]: k for k, v in LAND_USE_TERMS_FOR_TRANSFORMATION.items()} | {"cropland": TOTAL_CROPLAND}
 
 
 def crop_ipcc_land_use_category(

hestia_earth/models/ipcc2006/aboveGroundCropResidueTotal.py

@@ -7,6 +7,7 @@ from hestia_earth.models.utils.property import get_node_property
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.crop import get_crop_lookup_value
+from hestia_earth.models.utils.cropResidue import sum_above_ground_crop_residue
 from . import MODEL
 
 REQUIREMENTS = {
@@ -58,11 +59,6 @@ def _get_value_dm(product: dict, dm_percent: float):
     ]) else (yield_dm * slope + intercept * 1000)
 
 
-def _run(product: dict, dm_property: dict):
-    value = _get_value_dm(product, safe_parse_float(dm_property.get('value'), default=None))
-    return [_product(value)] if value is not None else []
-
-
 def _should_run_product(product: dict):
     term_id = product.get('term', {}).get('@id')
     value = list_sum(product.get('value', [0]))
@@ -79,17 +75,30 @@ def _should_run(cycle: dict):
     dm_property = get_node_property(products[0], PROPERTY_KEY) if single_crop_product else {}
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
+    dm_value = safe_parse_float(dm_property.get('value'), default=None)
+    value = _get_value_dm(products[0], dm_value) if single_crop_product else None
+
+    above_ground_crop_residue = sum_above_ground_crop_residue(cycle)
+    is_value_below_sum_above_ground_crop_residue = not not value and value >= above_ground_crop_residue
+
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     single_crop_product=single_crop_product,
                     nb_products=len(products),
                     dryMatter=dm_property.get('value'),
-                    term_type_cropResidue_incomplete=term_type_incomplete)
-
-    should_run = all([term_type_incomplete, single_crop_product, dm_property])
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    value=value,
+                    is_value_below_sum_above_ground_crop_residue=is_value_below_sum_above_ground_crop_residue)
+
+    should_run = all([
+        term_type_incomplete,
+        single_crop_product,
+        value is not None,
+        is_value_below_sum_above_ground_crop_residue
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, products, dm_property
+    return should_run, value
 
 
 def run(cycle: dict):
-    should_run, products, dm_property = _should_run(cycle)
-    return _run(products[0], dm_property) if should_run else []
+    should_run, value = _should_run(cycle)
+    return [_product(value)] if should_run else []

hestia_earth/models/ipcc2019/aboveGroundCropResidueTotal.py

@@ -2,10 +2,11 @@ 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 debugValues, logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.property import get_node_property
+from hestia_earth.models.utils.cropResidue import sum_above_ground_crop_residue
 from .utils import get_yield_dm
 from . import MODEL
 
@@ -43,10 +44,14 @@ def _product(value: float):
 def _product_value(product: dict):
     term = product.get('term', {})
     term_id = product.get('term', {}).get('@id')
-    value = list_sum(product.get('value'))
-    dm = get_node_property(product, PROPERTY_KEY).get('value', 0)
-    yield_dm = get_yield_dm(TERM_ID, term) or 0
-    total = value * dm / 100 * yield_dm
+    value = list_sum(product.get('value'), default=None)
+    dm = get_node_property(product, PROPERTY_KEY).get('value')
+    yield_dm = get_yield_dm(TERM_ID, term)
+    total = value * dm / 100 * yield_dm if all([
+        value is not None,
+        dm is not None,
+        yield_dm is not None,
+    ]) else None
     return {
         'id': term_id,
         'value': value,
@@ -56,38 +61,42 @@ def _product_value(product: dict):
     }
 
 
-def _run(cycle: dict, products: list):
-    values = list(map(_product_value, products))
-    debugValues(cycle, model=MODEL, term=TERM_ID,
-                details=log_as_table(values))
-    value = sum([value.get('total', 0) for value in values])
-    return [_product(value)]
-
-
-def _should_run_product(product: dict):
-    term = product.get('term', {})
-    value = list_sum(product.get('value', [0]))
-    prop = get_node_property(product, PROPERTY_KEY).get('value')
-    yield_dm = get_yield_dm(TERM_ID, term)
-    return all([value > 0, prop, yield_dm is not None])
+def _should_run_product(value: dict): return value.get('total') is not None
 
 
 def _should_run(cycle: dict):
+    term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
+
     # filter crop products with matching data in the lookup
     products = filter_list_term_type(cycle.get('products', []), [TermTermType.CROP, TermTermType.FORAGE])
-    products = list(filter(_should_run_product, products))
-    has_crop_forage_products = len(products) > 0
-    term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
+    values = list(map(_product_value, products))
+    valid_values = list(filter(_should_run_product, values))
+
+    has_crop_forage_products = len(valid_values) > 0
+
+    value = list_sum([(value.get('total') or 0) for value in valid_values], default=None)
+
+    above_ground_crop_residue = sum_above_ground_crop_residue(cycle)
+    is_value_below_sum_above_ground_crop_residue = not not value and value >= above_ground_crop_residue
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     has_crop_forage_products_with_dryMatter=has_crop_forage_products,
-                    term_type_cropResidue_incomplete=term_type_incomplete)
-
-    should_run = all([term_type_incomplete, has_crop_forage_products])
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    sum_above_ground_crop_residue=above_ground_crop_residue,
+                    value=value,
+                    is_value_below_sum_above_ground_crop_residue=is_value_below_sum_above_ground_crop_residue,
+                    details=log_as_table(values))
+
+    should_run = all([
+        term_type_incomplete,
+        has_crop_forage_products,
+        value is not None,
+        is_value_below_sum_above_ground_crop_residue
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, products
+    return should_run, value
 
 
 def run(cycle: dict):
-    should_run, products = _should_run(cycle)
-    return _run(cycle, products) if should_run else []
+    should_run, value = _should_run(cycle)
+    return [_product(value)] if should_run else []