hestia-earth-models 0.62.1__tar.gz → 0.62.2__tar.gz

{hestia-earth-models-0.62.1/hestia_earth_models.egg-info → hestia-earth-models-0.62.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.62.1
+Version: 0.62.2
 Summary: Hestia's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: Hestia Team

{hestia-earth-models-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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-0.62.1 → hestia-earth-models-0.62.2}/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)()