hestia-earth-models 0.65.10__py3-none-any.whl → 0.66.0__py3-none-any.whl

hestia_earth/models/hestia/residueRemoved.py

@@ -0,0 +1,80 @@
+"""
+This model will gap-fill the value for `residueRemoved` when the only provided data is the incorporated residue.
+We are assuming that anything that was not incorporated must have been removed.
+"""
+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, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_incomplete
+from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils import is_from_model
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.cropResidue": "False",
+        "practices": [{
+            "@type": "Practice",
+            "term.@id": [
+                "residueIncorporated",
+                "residueIncorporatedLessThan30DaysBeforeCultivation",
+                "residueIncorporatedMoreThan30DaysBeforeCultivation"
+            ]
+        }],
+        "none": {
+            "practices": [{
+                "@type": "Practice",
+                "term.@id": [
+                    "residueRemoved",
+                    "residueBurnt",
+                    "residueLeftOnField"
+                ]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+TERM_ID = 'residueRemoved'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID, MODEL)
+    practice['value'] = [value]
+    return practice
+
+
+def _should_run(cycle: dict):
+    crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
+
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.CROPRESIDUEMANAGEMENT)
+    incorporated_practices = [
+        {'id': p.get('term', {}).get('@id'), 'value': list_sum(p.get('value'), None)}
+        for p in practices
+        if p.get('term', {}).get('@id').startswith('residueIncorporated') and not is_from_model(p)
+    ]
+    has_other_practices = any([
+        not p.get('term', {}).get('@id').startswith('residueIncorporated')
+        for p in practices
+    ])
+    incorporated_value = list_sum([p.get('value') for p in incorporated_practices], None)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_incomplete=crop_residue_incomplete,
+                    incorporated_practices=log_as_table(incorporated_practices),
+                    incorporated_value=incorporated_value,
+                    has_other_practices=has_other_practices)
+
+    should_run = all([crop_residue_incomplete, incorporated_value, not has_other_practices])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, 100 - (incorporated_value or 0)
+
+
+def run(cycle: dict):
+    should_run, value = _should_run(cycle)
+    return [_practice(value)] if should_run else []

hestia_earth/models/hestia/resourceUse_utils.py

@@ -8,7 +8,7 @@ from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import to_precision
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
 from hestia_earth.models.utils.impact_assessment import get_site
 from hestia_earth.models.utils.indicator import _new_indicator
@@ -46,26 +46,25 @@ def _gap_filled_date_obj(date_str: str) -> datetime:
     )
 
 
-def _should_run_close_date_found(
-    ia_end_date_str: str,
+def _find_closest_node(
+    ia_date_str: str,
     management_nodes: list,
-    historic_date_offset: int
-) -> tuple[bool, str]:
+    historic_date_offset: int,
+    node_date_field: str
+) -> str:
     historic_ia_date_obj = (
-        _gap_filled_date_obj(ia_end_date_str) - relativedelta(years=historic_date_offset)
-        if ia_end_date_str else None
+        _gap_filled_date_obj(ia_date_str) - relativedelta(years=historic_date_offset)
+        if ia_date_str else None
     )
     # Calculate all distances in days which are less than MAXIMUM_OFFSET_DAYS from historic date
-    # Assumption: if there are two dates are equidistant from the target chose the second.
+    # Assumption: if there are two dates are equidistant from the target, choose the second.
     filtered_dates = {
-        abs((_gap_filled_date_obj(node.get("endDate")) - historic_ia_date_obj).days): node.get("endDate")
+        abs((_gap_filled_date_obj(node.get(node_date_field)) - historic_ia_date_obj).days): node.get(node_date_field)
         for node in management_nodes
         if node.get("term", {}).get("termType", "") == TermTermType.LANDCOVER.value and
-        abs((_gap_filled_date_obj(node.get("endDate")) - historic_ia_date_obj).days) <= _MAXIMUM_OFFSET_DAYS
+        abs((_gap_filled_date_obj(node.get(node_date_field)) - historic_ia_date_obj).days) <= _MAXIMUM_OFFSET_DAYS
     }
-    nearest_date = filtered_dates[min(filtered_dates.keys())] if filtered_dates else ""
-
-    return nearest_date != "", nearest_date
+    return filtered_dates[min(filtered_dates.keys())] if filtered_dates else ""
 
 
 def should_run(
@@ -73,44 +72,59 @@ def should_run(
     site: dict,
     term_id: str,
     historic_date_offset: int
-) -> tuple[bool, dict, str]:
+) -> tuple[bool, dict, str, str]:
     relevant_emission_resource_use = [
         node for node in impact_assessment.get("emissionsResourceUse", [])
         if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID and node.get("value", -1) >= 0
     ]
-
     filtered_management_nodes = [
         node for node in site.get("management", [])
         if node.get("value", -1) >= 0 and node.get("term", {}).get("termType", "") == TermTermType.LANDCOVER.value
     ]
+    land_occupation_during_cycle_found = any(
+        node.get("term", {}).get("@id") in
+        {node.get("landCover", {}).get("@id") for node in relevant_emission_resource_use}
+        for node in filtered_management_nodes
+    )
+    match_mode = (
+        DatestrGapfillMode.START if impact_assessment.get("cycle", {}).get("aggregated") is True
+        else DatestrGapfillMode.END
+    )
+    match_date = "startDate" if match_mode == DatestrGapfillMode.START else "endDate"
+
+    closest_date = _find_closest_node(
+        ia_date_str=impact_assessment.get(match_date, ""),
+        management_nodes=filtered_management_nodes,
+        historic_date_offset=historic_date_offset,
+        node_date_field=match_date
+    )
+    closest_start_date, closest_end_date = (closest_date, None) if match_date == "startDate" else (None, closest_date)
     current_node_index = next(
         (i for i, node in enumerate(filtered_management_nodes)
-         if _str_dates_match(node.get("endDate", ""), impact_assessment.get("endDate", ""))),
+         if _str_dates_match(
+            date_str_one=node.get(match_date, ""),
+            date_str_two=impact_assessment.get(match_date, ""),
+            mode=match_mode
+        )),
         None
     )
     current_node = filtered_management_nodes.pop(current_node_index) if current_node_index is not None else None
 
-    close_date_found, closest_date_str = _should_run_close_date_found(
-        ia_end_date_str=impact_assessment.get("endDate", ""),
-        management_nodes=filtered_management_nodes,
-        historic_date_offset=historic_date_offset
-    )
-
-    logRequirements(
-        log_node=impact_assessment,
-        model=MODEL,
-        term_id=term_id,
-        site=site
-    )
+    logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    closest_end_date=closest_end_date,
+                    closest_start_date=closest_start_date,
+                    has_landOccupationDuringCycle=land_occupation_during_cycle_found,
+                    landCover_term_id=(current_node or {}).get('term', {}).get('@id'))
 
     should_run_result = all([
-        relevant_emission_resource_use != [],
+        relevant_emission_resource_use,
+        land_occupation_during_cycle_found,
         current_node,
-        close_date_found
+        closest_end_date or closest_start_date
     ])
-    logShouldRun(site, MODEL, term=term_id, should_run=should_run_result)
+    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
 
-    return should_run_result, current_node, closest_date_str
+    return should_run_result, current_node, closest_end_date, closest_start_date
 
 
 def _get_land_occupation_for_land_use_type(impact_assessment: dict, ipcc_land_use_category: str) -> float:
@@ -126,6 +140,7 @@ def _get_land_occupation_for_land_use_type(impact_assessment: dict, ipcc_land_us
 
 def _calculate_indicator_value(
     impact_assessment: dict,
+    term_id: str,
     management_nodes: list,
     ipcc_land_use_category: str,
     previous_land_cover_id: str,
@@ -143,13 +158,21 @@ def _calculate_indicator_value(
         node.get("value", 0) for node in management_nodes
         if node.get("term", {}).get("@id", "") == previous_land_cover_id
     )
+
+    debugValues(impact_assessment, model=MODEL, term=term_id,
+                ipcc_land_use_category=ipcc_land_use_category,
+                land_occupation_for_cycle=land_occupation_for_cycle,
+                historical_land_use=historical_land_use,
+                historic_date_offset=historic_date_offset)
+
     return ((land_occupation_for_cycle * historical_land_use) / 100) / historic_date_offset
 
 
 def _run_calculate_transformation(
     term_id: str,
     current_node: dict,
-    closest_date_str: str,
+    closest_end_date: str,
+    closest_start_date: str,
     impact_assessment: dict,
     site: dict,
     historic_date_offset: int
@@ -164,9 +187,11 @@ def _run_calculate_transformation(
             previous_land_cover_id=previous_land_cover_id,
             value=_calculate_indicator_value(
                 impact_assessment=impact_assessment,
+                term_id=term_id,
                 management_nodes=[
                     node for node in site.get("management", [])
-                    if _str_dates_match(node.get("endDate", ""), closest_date_str)
+                    if _str_dates_match(node.get("endDate", ""), closest_end_date) or
+                    _str_dates_match(node.get("startDate", ""), closest_start_date)
                 ],
                 ipcc_land_use_category=crop_ipcc_land_use_category(current_node.get("term", {}).get("@id", "")),
                 previous_land_cover_id=previous_land_cover_id,
@@ -184,17 +209,18 @@ def run_resource_use(
     term_id: str
 ) -> list:
     site = get_site(impact_assessment)
-    _should_run, current_node, closest_date_str = should_run(
+    _should_run, current_node, closest_end_date, closest_start_date = should_run(
         impact_assessment=impact_assessment,
         site=site,
         term_id=term_id,
         historic_date_offset=historic_date_offset
     )
     return _run_calculate_transformation(
+        impact_assessment=impact_assessment,
+        site=site,
         term_id=term_id,
         current_node=current_node,
-        closest_date_str=closest_date_str,
-        site=site,
-        impact_assessment=impact_assessment,
+        closest_end_date=closest_end_date,
+        closest_start_date=closest_start_date,
         historic_date_offset=historic_date_offset
     ) if _should_run else []

hestia_earth/models/hestia/utils.py

@@ -43,6 +43,5 @@ def crop_ipcc_land_use_category(
     return get_lookup_value(
         lookup_term={"@id": crop_term_id, "type": "Term", "termType": lookup_term_type},
         column='IPCC_LAND_USE_CATEGORY',
-        model=MODEL,
-        term={"@id": crop_term_id, "type": "Term", "termType": lookup_term_type}
+        model=MODEL
     )

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -229,6 +229,7 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         The inventory of data.
     """
     land_cover_grouped = group_nodes_by_year(land_cover_nodes)
+    min_year, max_year = min(land_cover_grouped.keys()), max(land_cover_grouped.keys())
 
     def build_inventory_year(inventory: dict, year_pair: tuple[int, int]) -> dict:
         """
@@ -262,15 +263,33 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         years_since_lcc_event = time_delta if is_lcc_event else prev_years_since_lcc_event + time_delta
         regime_start_year = current_year - years_since_lcc_event
 
+        equilibrium_year = regime_start_year + _EQUILIBRIUM_TRANSITION_PERIOD
+        inventory_years = set(list(inventory.keys()) + list(land_cover_grouped.keys()))
+
+        should_add_equilibrium_year = (
+            min_year < equilibrium_year < max_year       # Is the year relevant?
+            and equilibrium_year not in inventory_years  # Is the year missing?
+            and equilibrium_year < current_year          # Is it the first inventory year after the equilibrium?
+        )
+
+        current_data = {
+            _InventoryKey.BIOMASS_CATEGORY_SUMMARY: biomass_category_summary,
+            _InventoryKey.LAND_COVER_SUMMARY: land_cover_summary,
+            _InventoryKey.LAND_COVER_CHANGE_EVENT: is_lcc_event,
+            _InventoryKey.YEARS_SINCE_LCC_EVENT: years_since_lcc_event,
+            _InventoryKey.REGIME_START_YEAR: regime_start_year
+        }
+
+        equilibrium_data = {
+            **current_data,
+            _InventoryKey.YEARS_SINCE_LCC_EVENT: _EQUILIBRIUM_TRANSITION_PERIOD
+        }
+
         update_dict = {
-            current_year: {
-                _InventoryKey.BIOMASS_CATEGORY_SUMMARY: biomass_category_summary,
-                _InventoryKey.LAND_COVER_SUMMARY: land_cover_summary,
-                _InventoryKey.LAND_COVER_CHANGE_EVENT: is_lcc_event,
-                _InventoryKey.YEARS_SINCE_LCC_EVENT: years_since_lcc_event,
-                _InventoryKey.REGIME_START_YEAR: regime_start_year
-            }
+            current_year: current_data,
+            **({equilibrium_year: equilibrium_data} if should_add_equilibrium_year else {})
         }
+
         return inventory | update_dict
 
     start_year = list(land_cover_grouped)[0]
@@ -290,11 +309,13 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         }
     }
 
-    return reduce(
-        build_inventory_year,
-        pairwise(land_cover_grouped.keys()),  # Inventory years need data from previous year to be compiled.
-        initial
-    )
+    return dict(sorted(
+        reduce(
+            build_inventory_year,
+            pairwise(land_cover_grouped.keys()),  # Inventory years need data from previous year to be compiled.
+            initial
+        ).items()
+    ))
 
 
 def _format_inventory(inventory: dict) -> str:

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -233,7 +233,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
             'weightAtOneYear',
             'weightAtSlaughter'
         ])
-        has_positive_feed_values = all([NEm_feed > 0, NEg_feed > 0])
+        has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
         logRequirements(animal, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -222,6 +222,7 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         The inventory of data.
     """
     land_cover_grouped = group_nodes_by_year(land_cover_nodes)
+    min_year, max_year = min(land_cover_grouped.keys()), max(land_cover_grouped.keys())
 
     def build_inventory_year(inventory: dict, year_pair: tuple[int, int]) -> dict:
         """
@@ -253,14 +254,32 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         years_since_lcc_event = time_delta if is_lcc_event else prev_years_since_lcc_event + time_delta
         regime_start_year = current_year - years_since_lcc_event
 
+        equilibrium_year = regime_start_year + _EQUILIBRIUM_TRANSITION_PERIOD
+        inventory_years = set(list(inventory.keys()) + list(land_cover_grouped.keys()))
+
+        should_add_equilibrium_year = (
+            min_year < equilibrium_year < max_year       # Is the year relevant?
+            and equilibrium_year not in inventory_years  # Is the year missing?
+            and equilibrium_year < current_year          # Is it the first inventory year after the equilibrium?
+        )
+
+        current_data = {
+            _InventoryKey.BIOMASS_CATEGORY_SUMMARY: biomass_category_summary,
+            _InventoryKey.LAND_COVER_CHANGE_EVENT: is_lcc_event,
+            _InventoryKey.YEARS_SINCE_LCC_EVENT: years_since_lcc_event,
+            _InventoryKey.REGIME_START_YEAR: regime_start_year
+        }
+
+        equilibrium_data = {
+            **current_data,
+            _InventoryKey.YEARS_SINCE_LCC_EVENT: _EQUILIBRIUM_TRANSITION_PERIOD
+        }
+
         update_dict = {
-            current_year: {
-                _InventoryKey.BIOMASS_CATEGORY_SUMMARY: biomass_category_summary,
-                _InventoryKey.LAND_COVER_CHANGE_EVENT: is_lcc_event,
-                _InventoryKey.YEARS_SINCE_LCC_EVENT: years_since_lcc_event,
-                _InventoryKey.REGIME_START_YEAR: regime_start_year
-            }
+            current_year: current_data,
+            **({equilibrium_year: equilibrium_data} if should_add_equilibrium_year else {})
         }
+
         return inventory | update_dict
 
     start_year = list(land_cover_grouped)[0]
@@ -277,11 +296,13 @@ def _compile_inventory(land_cover_nodes: list[dict]) -> dict:
         }
     }
 
-    return reduce(
-        build_inventory_year,
-        pairwise(land_cover_grouped.keys()),  # Inventory years need data from previous year to be compiled.
-        initial
-    )
+    return dict(sorted(
+        reduce(
+            build_inventory_year,
+            pairwise(land_cover_grouped.keys()),  # Inventory years need data from previous year to be compiled.
+            initial
+        ).items()
+    ))
 
 
 def _format_inventory(inventory: dict) -> str:

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -237,24 +237,33 @@ def _should_run(cycle: dict):
 
     # only keep inputs that have a positive value
     inputs = list(filter(lambda i: list_sum(i.get('value', [])) > 0, feed_inputs))
-    DE = (
-        get_total_value_converted_with_min_ratio(MODEL, TERM_ID, cycle, inputs, DE_type) if DE_type else None
-    ) or get_default_digestibility(MODEL, TERM_ID, cycle)
-    NDF = get_total_value_converted_with_min_ratio(MODEL, TERM_ID, cycle, inputs, 'neutralDetergentFibreContent')
+    DE = get_total_value_converted_with_min_ratio(
+        MODEL, TERM_ID, cycle, inputs, prop_id=DE_type, is_sum=False
+    ) if DE_type else None
+    # set as a percentage in the properties
+    DE = DE * 100 if DE else DE
+    DE_default = get_default_digestibility(MODEL, TERM_ID, cycle)
+
+    # set as a percentage in the properties
+    NDF = get_total_value_converted_with_min_ratio(
+        MODEL, TERM_ID, cycle, inputs, prop_id='neutralDetergentFibreContent', is_sum=False
+    )
+    NDF = NDF * 100 if NDF else NDF
 
     enteric_factor = safe_parse_float(_get_lookup_value(
-        lookup, term, LOOKUPS['liveAnimal'][1], DE, NDF, ionophore, milk_yield
+        lookup, term, LOOKUPS['liveAnimal'][1], DE or DE_default, NDF, ionophore, milk_yield
     ), None)
     enteric_sd = safe_parse_float(_get_lookup_value(
-        lookup, term, LOOKUPS['liveAnimal'][2], DE, NDF, ionophore, milk_yield
+        lookup, term, LOOKUPS['liveAnimal'][2], DE or DE_default, NDF, ionophore, milk_yield
     ), None)
 
     default_values = _get_default_values(lookup, term)
 
     debugValues(cycle, model=MODEL, term=TERM_ID,
                 DE_type=DE_type,
-                digestibility=DE,
-                ndf=NDF,
+                DE=DE,
+                **({'DE_default_lookup': DE_default} if not DE else {}),
+                NDF=NDF,
                 ionophore=ionophore,
                 milk_yield=milk_yield,
                 enteric_factor=enteric_factor,

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -1315,7 +1315,8 @@ def _format_land_use_inventory(land_use_inventory: dict) -> str:
     """
     KEYS = [
         _InventoryKey.LAND_USE_CHANGE_EVENT,
-        _InventoryKey.YEARS_SINCE_LUC_EVENT
+        _InventoryKey.YEARS_SINCE_LUC_EVENT,
+        _InventoryKey.YEARS_SINCE_INVENTORY_START
     ]
 
     inventory_years = sorted(set(non_empty_list(years for years in land_use_inventory.keys())))
@@ -1374,7 +1375,8 @@ def _format_named_tuple(value: Optional[Union[CarbonStock, CarbonStockChange, Ca
 
 _LAND_USE_INVENTORY_KEY_TO_FORMAT_FUNC = {
     _InventoryKey.LAND_USE_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LUC_EVENT: _format_int
+    _InventoryKey.YEARS_SINCE_LUC_EVENT: _format_int,
+    _InventoryKey.YEARS_SINCE_INVENTORY_START: _format_int
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of
@@ -1416,7 +1418,7 @@ def create_run_function(
         years_since_inventory_start = data[_InventoryKey.YEARS_SINCE_INVENTORY_START]
 
         is_luc_emission = bool(years_since_luc_event) and years_since_luc_event <= _TRANSITION_PERIOD_YEARS
-        is_data_complete = bool(years_since_inventory_start) and years_since_inventory_start > _TRANSITION_PERIOD_YEARS
+        is_data_complete = bool(years_since_inventory_start) and years_since_inventory_start >= _TRANSITION_PERIOD_YEARS
 
         if is_luc_emission:
             # If LUC emission allocate emissions to land use change AND add corresponding zero emission to management

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -62,6 +62,7 @@ _ABOVE_GROUND_CROP_RESIDUE_TOTAL_TERM_ID = "aboveGroundCropResidueTotal"
 _CARBON_CONTENT_TERM_ID = "carbonContent"
 _NITROGEN_CONTENT_TERM_ID = "nitrogenContent"
 _LIGNIN_CONTENT_TERM_ID = "ligninContent"
+_DRY_MATTER_TERM_ID = "dryMatter"
 
 _CROP_RESIDUE_MANAGEMENT_TERM_IDS = [
     "residueIncorporated",
@@ -82,7 +83,8 @@ _DEFAULT_COVER_CROP_BIOMASS = 4000  # TODO: Confirm assumption, Source PAS 2050-
 _CARBON_INPUT_PROPERTY_TERM_IDS = [
     _CARBON_CONTENT_TERM_ID,
     _NITROGEN_CONTENT_TERM_ID,
-    _LIGNIN_CONTENT_TERM_ID
+    _LIGNIN_CONTENT_TERM_ID,
+    _DRY_MATTER_TERM_ID
 ]
 
 _CARBON_SOURCE_TERM_TYPES = [
@@ -1380,9 +1382,13 @@ def _calc_carbon_source_ag_crop_residue(node: dict, cycle: dict) -> Union[Carbon
     ])
     mass = value * max(residue_left_on_field, _MIN_RESIDUE_LEFT_ON_FIELD) / 100
 
+    carbon_content, nitrogen_content, lignin_content, dry_matter = _retrieve_carbon_source_properties(node)
+
     carbon_source = CarbonSource(
-        mass,
-        *_retrieve_carbon_source_properties(node)
+        mass * dry_matter if dry_matter else mass,
+        carbon_content / dry_matter if dry_matter else carbon_content,
+        nitrogen_content / dry_matter if dry_matter else nitrogen_content,
+        lignin_content / dry_matter if dry_matter else lignin_content
     )
 
     return carbon_source if _validate_carbon_source(carbon_source) else None
@@ -1390,7 +1396,7 @@ def _calc_carbon_source_ag_crop_residue(node: dict, cycle: dict) -> Union[Carbon
 
 def _should_run_carbon_source_cover_crop(node: dict) -> bool:
     """
-    Determine whether a product is a valid above cover crop carbon source.
+    Determine whether a product is a valid cover crop carbon source.
 
     Parameters
     ----------
@@ -1404,13 +1410,13 @@ def _should_run_carbon_source_cover_crop(node: dict) -> 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]
-        ),
-        is_cover_crop(node)
-    ])
+    TARGET_LOOKUP_VALUES = IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE[IpccLandUseCategory.ANNUAL_CROPS]
+
+    return (
+        node.get("term", {}).get("termType") in [TermTermType.LANDCOVER.value]
+        and is_cover_crop(node)
+        and node_lookup_match(node, LOOKUP, TARGET_LOOKUP_VALUES)
+    )
 
 
 def _calc_carbon_source_cover_crop(node: dict, *_) -> Union[CarbonSource, None]:
@@ -1475,15 +1481,20 @@ def _calc_carbon_source(node: dict, *_) -> Union[CarbonSource, None]:
     CarbonSource | None
         The carbon source data of the cover crop, or `None` if carbon source data incomplete.
     """
+    mass = get_node_value(node)
+    carbon_content, nitrogen_content, lignin_content, dry_matter = _retrieve_carbon_source_properties(node)
+
     carbon_source = CarbonSource(
-        get_node_value(node),
-        *_retrieve_carbon_source_properties(node)
+        mass * dry_matter if dry_matter else mass,
+        carbon_content / dry_matter if dry_matter else carbon_content,
+        nitrogen_content / dry_matter if dry_matter else nitrogen_content,
+        lignin_content / dry_matter if dry_matter else lignin_content
     )
 
     return carbon_source if _validate_carbon_source(carbon_source) else None
 
 
-def _retrieve_carbon_source_properties(node: dict) -> tuple[float, float, float]:
+def _retrieve_carbon_source_properties(node: dict) -> tuple[float, float, float, float]:
     """
     Extract the carbon source properties from an input or product node or, if required, retrieve them from default
     properties.
@@ -1497,12 +1508,11 @@ def _retrieve_carbon_source_properties(node: dict) -> tuple[float, float, float]
     Returns
     -------
     tuple[float, float, float]
-        `(carbon_content, nitrogen_content, lignin_content)`
+        `(carbon_content, nitrogen_content, lignin_content, dry_matter)`
     """
-    carbon_content, nitrogen_content, lignin_content = (
+    return (
         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
 
 
 def _validate_carbon_source(carbon_source: CarbonSource) -> bool:

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -212,7 +212,7 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
             'weightAtOneYear',
             'weightAtSlaughter'
         ])
-        has_positive_feed_values = all([NEm_feed > 0, NEg_feed > 0])
+        has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -323,7 +323,14 @@ def calculate_GE(values: list, REM: float, REG: float, NEwool: float, NEm_feed:
     NEp = _sum_values(values, 'NEp')
     NEg = _sum_values(values, 'NEg')
 
-    return ((NEm + NEa + NEl + NEwork + NEp - NEm_feed)/REM + (NEg + NEwool - NEg_feed)/REG) if all([REM, REG]) else 0
+    REM_factor = NEm + NEa + NEl + NEwork + NEp
+    REG_factor = NEg + NEwool
+
+    correction_factor = REM_factor + REG_factor
+    NEm_feed_corrected = NEm_feed * REM_factor/correction_factor if correction_factor != 0 else NEm_feed
+    NEg_feed_corrected = NEg_feed * REG_factor/correction_factor if correction_factor != 0 else NEg_feed
+
+    return ((REM_factor - NEm_feed_corrected)/REM + (REG_factor - NEg_feed_corrected)/REG) if all([REM, REG]) else 0
 
 
 def calculate_meanECHHV(practices: list, **log_args) -> float:

hestia_earth/models/log.py

@@ -65,7 +65,7 @@ def logShouldRun(log_node: dict, model: str, term: Union[str, None], should_run:
 def debugMissingLookup(lookup_name: str, row: str, row_value: str, col: str, value, **kwargs):
     if value is None or value == '':
         extra = (', ' + _join_args(**kwargs)) if len(kwargs.keys()) > 0 else ''
-        logger.warn('Missing lookup=%s, %s=%s, column=%s' + extra, lookup_name, row, row_value, col)
+        logger.warning('Missing lookup=%s, %s=%s, column=%s' + extra, lookup_name, row, row_value, col)
 
 
 def logErrorRun(model: str, term: str, error: str):