hestia-earth-models 0.64.11__py3-none-any.whl → 0.64.13__py3-none-any.whl

hestia_earth/models/ipcc2013ExcludingFeedbacks/gwp100.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/ipcc2013IncludingFeedbacks/gwp100.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -7,11 +7,9 @@ from typing import Optional, Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
-    SiteSiteType,
-    TermTermType
+    SiteSiteType
 )
 
-from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
@@ -24,8 +22,8 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, detect_land_cover_change, group_by_biomass_category, group_by_term_id, sample_biomass_equilibrium,
-    summarise_land_cover_nodes
+    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category, group_by_term_id,
+    sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
 
@@ -94,8 +92,6 @@ _ITERATIONS = 10000
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
-_LAND_COVER_TERM_TYPE = TermTermType.LANDCOVER
-
 _EQUILIBRIUM_TRANSITION_PERIOD = 20
 _EXCLUDED_ECO_CLIMATE_ZONES = {EcoClimateZone.POLAR_MOIST, EcoClimateZone.POLAR_DRY}
 _EXCLUDED_SITE_TYPES = {
@@ -156,7 +152,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = filter_list_term_type(site.get("management", []), _LAND_COVER_TERM_TYPE)
+    land_cover = get_valid_land_cover_terms(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([

hestia_earth/models/ipcc2019/animal/fatContent.py

@@ -33,6 +33,6 @@ TERM_ID = 'fatContent'
 
 def run(cycle: dict):
     animals = should_run_by_productivity_lookup(
-        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_id=LOOKUPS['liveAnimal']
+        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_column=LOOKUPS['liveAnimal']
     )
     return list(map(run_animal_by_productivity(TERM_ID, include_practice=True), animals))

hestia_earth/models/ipcc2019/animal/milkYieldPerAnimal.py

@@ -0,0 +1,91 @@
+"""
+Milk Yield Per Animal
+
+This model gap-fills the practice "Milk yield per X, raw" for live animals added to the animal node,
+taking values from a lookup file.
+"""
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import merge_blank_nodes, get_lookup_value
+from hestia_earth.models.utils.practice import _new_practice
+from .utils import map_live_animals_by_productivity_lookup
+from .. import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "practices": {
+                "@type": "Practice",
+                "term.termType": "animalManagement"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-milkYieldPerAnimal": "yield value",
+    "liveAnimal": ["milkYieldPracticeTermIds", "ipcc2019MilkYieldPerAnimalTermId"]
+}
+RETURNS = {
+    "Animal": [{
+        "practices": [{
+            "@type": "Practice",
+            "value": ""
+        }]
+    }]
+}
+MODEL_KEY = 'milkYieldPerAnimal'
+
+
+def _practice(term_id: str, value: float):
+    node = _new_practice(term_id, MODEL)
+    node['value'] = [value]
+    return node
+
+
+def _run_animal(data: dict):
+    animal = data.get('animal')
+    value = data.get('value')
+    practice_id = get_lookup_value(animal.get('term'), LOOKUPS['liveAnimal'][1])
+    return animal | ({
+        'practices': merge_blank_nodes(animal.get('practices', []), [_practice(practice_id, value)])
+    } if practice_id else {})
+
+
+def _should_run(cycle: dict):
+    country = cycle.get('site', {}).get('country', {})
+    country_id = country.get('@id')
+    live_animals_with_value = map_live_animals_by_productivity_lookup(
+        None, cycle, list(LOOKUPS.keys())[0], practice_column=LOOKUPS['liveAnimal'][0]
+    )
+
+    def _should_run_animal(value: dict):
+        animal = value.get('animal')
+        lookup_value = value.get('value')
+        term_id = animal.get('term').get('@id')
+        practice = value.get('practice')
+
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        country_id=country_id,
+                        practice=practice.get('term', {}).get('@id'))
+
+        should_run = all([
+            country_id,
+            lookup_value is not None,
+            # must not have the practice already
+            not practice
+        ])
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
+
+        return should_run
+
+    return list(filter(_should_run_animal, live_animals_with_value))
+
+
+def run(cycle: dict):
+    animals = _should_run(cycle)
+    return list(map(_run_animal, animals))

hestia_earth/models/ipcc2019/animal/trueProteinContent.py

@@ -33,6 +33,6 @@ TERM_ID = 'trueProteinContent'
 
 def run(cycle: dict):
     animals = should_run_by_productivity_lookup(
-        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_id=LOOKUPS['liveAnimal']
+        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_column=LOOKUPS['liveAnimal']
     )
     return list(map(run_animal_by_productivity(TERM_ID, include_practice=True), animals))

hestia_earth/models/ipcc2019/animal/utils.py

@@ -11,9 +11,9 @@ from hestia_earth.models.utils.term import get_lookup_value
 from .. import MODEL
 
 
-def _get_practice(term_id: str, animal: dict, practice_id: str):
+def _get_practice(term_id: str, animal: dict, practice_column: str):
     term = animal.get('term', {})
-    value = get_lookup_value(term, practice_id, model=MODEL, term=term_id)
+    value = get_lookup_value(term, practice_column, model=MODEL, term=term_id)
     practice_ids = non_empty_list((value or '').split(';'))
     return next(
         (p for p in animal.get('practices', []) if p.get('term', {}).get('@id') in practice_ids),
@@ -36,7 +36,7 @@ def productivity_lookup_value(term_id: str, lookup: str, country: dict, animal:
     )
 
 
-def map_live_animals_by_productivity_lookup(term_id: str, cycle: dict, lookup_col: str, practice_id: str = None):
+def map_live_animals_by_productivity_lookup(term_id: str, cycle: dict, lookup_col: str, practice_column: str = None):
     country = cycle.get('site', {}).get('country', {})
     live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
     live_animals = list(filter(node_has_no_property(term_id), live_animals))
@@ -44,35 +44,40 @@ def map_live_animals_by_productivity_lookup(term_id: str, cycle: dict, lookup_co
         'animal': animal,
         'value': productivity_lookup_value(term_id, lookup_col, country, animal)
     } | ({
-        'practice': _get_practice(term_id, animal, practice_id)
-    } if practice_id else {}) for animal in live_animals]
+        'practice': _get_practice(term_id, animal, practice_column)
+    } if practice_column else {}) for animal in live_animals]
 
 
-def should_run_by_productivity_lookup(term_id: str, cycle: dict, lookup_col: str, practice_id: str = None):
+def should_run_by_productivity_lookup(
+    term_id: str,
+    cycle: dict,
+    lookup_col: str,
+    practice_column: str = None
+):
     country = cycle.get('site', {}).get('country', {})
     country_id = country.get('@id')
-    live_animals_with_value = map_live_animals_by_productivity_lookup(term_id, cycle, lookup_col, practice_id)
+    live_animals_with_value = map_live_animals_by_productivity_lookup(term_id, cycle, lookup_col, practice_column)
 
     def _should_run_animal(value: dict):
         animal = value.get('animal')
         lookup_value = value.get('value')
         practice = value.get('practice')
-        term_id = animal.get('term').get('@id')
+        animal_term_id = animal.get('term').get('@id')
 
-        logRequirements(cycle, model=MODEL, term=term_id, property=term_id,
+        logRequirements(cycle, model=MODEL, term=animal_term_id, property=term_id,
                         country_id=country_id,
                         **({
                             lookup_col.replace('-', '_'): lookup_value
                         } | ({
                             'practice': practice.get('term', {}).get('@id')
-                        } if practice_id else {})))
+                        } if practice_column else {})))
 
         should_run = all([
             country_id,
-            not practice_id or bool(practice),
+            not practice_column or bool(practice),
             lookup_value is not None
         ])
-        logShouldRun(cycle, MODEL, term_id, should_run, property=term_id)
+        logShouldRun(cycle, MODEL, animal_term_id, should_run, property=term_id)
 
         return should_run
 

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -7,11 +7,9 @@ from typing import Optional, Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
-    SiteSiteType,
-    TermTermType
+    SiteSiteType
 )
 
-from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
@@ -24,8 +22,8 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, detect_land_cover_change, group_by_biomass_category, sample_biomass_equilibrium,
-    summarise_land_cover_nodes
+    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category,
+    sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
 
@@ -81,8 +79,6 @@ _ITERATIONS = 10000
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
-_LAND_COVER_TERM_TYPE = TermTermType.LANDCOVER
-
 _EQUILIBRIUM_TRANSITION_PERIOD = 20
 _EXCLUDED_ECO_CLIMATE_ZONES = {EcoClimateZone.POLAR_MOIST, EcoClimateZone.POLAR_DRY}
 _EXCLUDED_SITE_TYPES = {
@@ -149,7 +145,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = filter_list_term_type(site.get("management", []), _LAND_COVER_TERM_TYPE)
+    land_cover = get_valid_land_cover_terms(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([

hestia_earth/models/ipcc2019/biomass_utils.py

@@ -5,9 +5,12 @@ from numpy import random
 from numpy.typing import NDArray
 from typing import Callable, Optional, Union
 
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.blank_node import get_node_value
+from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.utils.array_builders import repeat_single, truncated_normal_1d
+from hestia_earth.models.utils.blank_node import validate_start_date_end_date
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_ecoClimateZone_lookup_grouped_value
 from hestia_earth.models.utils.term import get_lookup_value
 
@@ -404,3 +407,11 @@ _KWARGS_TO_SAMPLE_FUNC = {
     ("value", "error"): sample_plus_minus_error,
     ("value",): sample_constant
 }
+
+
+def get_valid_land_cover_terms(site: dict) -> list[dict]:
+    """Retrieve valid `landCover` nodes from a site's management."""
+    return [
+        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        if validate_start_date_end_date(node)
+    ]

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -250,7 +250,7 @@ def _should_run(cycle: dict):
                 milk_yield=milk_yield,
                 enteric_factor=enteric_factor,
                 enteric_sd=enteric_sd,
-                default_values=default_values)
+                default_values=';'.join(map(str, default_values)))
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     term_type_animalFeed_complete=is_animalFeed_complete,

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -77,7 +77,9 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None
+    observations: list[int] = None,
+    start_date: str,
+    end_date: str
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -105,7 +107,9 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
-        "methodTier": method_tier.value
+        "startDate": start_date,
+        "endDate": end_date,
+        "methodTier": method_tier.value,
     }
     emission = _new_emission(term_id, MODEL) | {
         key: value for key, value in update_dict.items() if value
@@ -141,13 +145,13 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
+    should_run, kwargs, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(cycle_id, inventory) if should_run else []
+    return run_exec(**kwargs) if should_run else []
 
 
 def _should_compile_inventory_func(

hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -68,7 +68,9 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None
+    observations: list[int] = None,
+    start_date: str,
+    end_date: str
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -96,6 +98,8 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
+        "startDate": start_date,
+        "endDate": end_date,
         "methodTier": method_tier.value,
         "depth": _DEPTH_LOWER
     }
@@ -133,13 +137,13 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
+    should_run, kwargs, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(cycle_id, inventory) if should_run else []
+    return run_exec(**kwargs) if should_run else []
 
 
 def _should_run_measurement_func(node: dict) -> bool:

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -3,7 +3,7 @@ Utilities for calculating CO2 emissions based on changes in carbon stocks (e.g.,
 `aboveGroundBiomass` and `belowGroundBiomass`).
 """
 
-from datetime import datetime
+from datetime import datetime, timedelta
 from enum import Enum
 from functools import reduce
 from itertools import product
@@ -24,7 +24,7 @@ from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.array_builders import correlated_normal_2d, gen_seed
 from hestia_earth.models.utils.blank_node import (
     _gapfill_datestr, _get_datestr_format, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match,
-    split_node_by_dates
+    split_node_by_dates, validate_start_date_end_date
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -401,11 +401,15 @@ def create_should_run_function(
             `(should_run, cycle_id, inventory, logs)`
         """
         cycle_id = cycle.get("@id")
+        cycle_start_date = cycle.get("startDate")
+        cycle_end_date = cycle.get("endDate")
+
         site = _get_site(cycle)
         cycles = related_cycles(site)
 
         carbon_stock_measurements = [
-            node for node in site.get("measurements", []) if all([
+            node for node in site.get("measurements", [])
+            if all([
                 node_term_match(node, carbon_stock_term_id),
                 _has_valid_array_fields(node),
                 _has_valid_dates(node),
@@ -414,7 +418,10 @@ def create_should_run_function(
             ])
         ]
 
-        land_cover_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        land_cover_nodes = [
+            node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+            if validate_start_date_end_date(node)
+        ]
 
         seed = gen_seed(site)  # All cycles linked to the same site should be consistent
         rng = random.default_rng(seed)
@@ -445,13 +452,20 @@ def create_should_run_function(
 
         should_run_ = all([has_valid_inventory, has_consecutive_years])
 
+        kwargs = {
+            "cycle_id": cycle_id,
+            "cycle_start_date": cycle_start_date,
+            "cycle_end_date": cycle_end_date,
+            "inventory": inventory
+        }
+
         logs = should_compile_logs | inventory_logs | {
             "seed": seed,
             "has_valid_inventory": has_valid_inventory,
             "has_consecutive_years": has_consecutive_years
         }
 
-        return should_run_, cycle_id, inventory, logs
+        return should_run_, kwargs, logs
 
     return should_run
 
@@ -1413,7 +1427,7 @@ def create_run_function(
 
         return result | update_dict
 
-    def run(cycle_id: str, inventory: dict) -> list[dict]:
+    def run(cycle_id: str, cycle_start_date: str, cycle_end_date: str, inventory: dict) -> list[dict]:
         """
         Calculate emissions for a specific cycle using from a carbon stock change using pre-compiled inventory data.
 
@@ -1442,6 +1456,8 @@ def create_run_function(
             new_emission_func(
                 term_id=emission_term_id,
                 method_tier=total_emission.method,
+                start_date=_get_emission_start_date(total_emission, cycle_start_date),
+                end_date=_get_emission_end_date(total_emission, cycle_end_date),
                 **calc_descriptive_stats(
                     total_emission.value,
                     EmissionStatsDefinition.SIMULATED,
@@ -1451,3 +1467,33 @@ def create_run_function(
         ]
 
     return run
+
+
+def _get_emission_start_date(emission: CarbonStockChangeEmission, cycle_start_date: str) -> str:
+    cycle_datetime = safe_parse_date(_gapfill_datestr(cycle_start_date))
+    emission_datetime = safe_parse_date(emission.start_date)
+
+    should_run = (
+        cycle_datetime and emission_datetime
+        and cycle_datetime <= emission_datetime  # If the cycle starts before the emission, add a `startDate`
+    )
+
+    return (
+        (emission_datetime + timedelta(seconds=1)).strftime(DatestrFormat.YEAR_MONTH_DAY.value) if should_run
+        else None
+    )
+
+
+def _get_emission_end_date(emission: CarbonStockChangeEmission, cycle_end_date: str) -> str:
+    cycle_datetime = safe_parse_date(_gapfill_datestr(cycle_end_date))
+    emission_datetime = safe_parse_date(emission.end_date)
+
+    should_run = (
+        cycle_datetime and emission_datetime
+        and cycle_datetime >= emission_datetime  # If the cycle ends after the emission, add an `endDate`
+    )
+
+    return (
+        emission_datetime.strftime(DatestrFormat.YEAR_MONTH_DAY.value) if should_run
+        else None
+    )

hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChange.py

@@ -68,7 +68,9 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None
+    observations: list[int] = None,
+    start_date: str,
+    end_date: str
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -96,6 +98,8 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
+        "startDate": start_date,
+        "endDate": end_date,
         "methodTier": method_tier.value,
         "depth": _DEPTH_LOWER
     }
@@ -133,13 +137,13 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
+    should_run, kwargs, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(cycle_id, inventory) if should_run else []
+    return run_exec(**kwargs) if should_run else []
 
 
 def _should_run_measurement_func(node: dict) -> bool:

hestia_earth/models/ipcc2019/n2OToAirExcretaDirect.py

@@ -10,7 +10,12 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "completeness.excreta": "True",
+        "or": {
+            "completeness.excreta": "True",
+            "inputs": [
+                {"@type": "Input", "term.termType": "excreta", "units": "kg N"}
+            ]
+        },
         "practices": [
             {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
         ]
@@ -36,26 +41,26 @@ def _emission(value: float):
     return emission
 
 
-def _run(excretaKgN: float, N2O_N_EF: float):
-    value = N2O_N_EF * excretaKgN * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+def _run(N_total: float, N2O_N_EF: float):
+    value = (N2O_N_EF or 0) * (N_total or 0) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    excretaKgN = total_excreta(cycle.get('inputs', []))
+    N_total = total_excreta(cycle.get('inputs', []))
     N2O_N_EF = get_lookup_factor(cycle.get('practices', []), LOOKUPS['excretaManagement'])
     term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    excretaKgN=excretaKgN,
+                    N_total=N_total,
                     N2O_N_EF=N2O_N_EF,
                     term_type_excreta_complete=term_type_complete)
 
-    should_run = all([excretaKgN, N2O_N_EF])
+    should_run = all([N_total, N2O_N_EF]) or all([not N_total, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, excretaKgN, N2O_N_EF
+    return should_run, N_total, N2O_N_EF
 
 
 def run(cycle: dict):
-    should_run, excretaKgN, N2O_N_EF = _should_run(cycle)
-    return _run(excretaKgN, N2O_N_EF) if should_run else []
+    should_run, N_total, N2O_N_EF = _should_run(cycle)
+    return _run(N_total, N2O_N_EF) if should_run else []

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_1_utils.py

@@ -24,7 +24,7 @@ from hestia_earth.utils.blank_node import get_node_value
 from hestia_earth.models.utils.array_builders import gen_seed
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match,
-    node_lookup_match, node_term_match, group_nodes_by_year
+    node_lookup_match, node_term_match, group_nodes_by_year, validate_start_date_end_date
 )
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -1209,8 +1209,14 @@ def _assign_ipcc_land_use_category(
     DECISION_TREE = _LAND_USE_CATEGORY_DECISION_TREE
     DEFAULT = IpccLandUseCategory.OTHER
 
-    land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
-    water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
+    land_cover_nodes = [
+        node for node in filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
+        if validate_start_date_end_date(node)
+    ]
+    water_regime_nodes = [
+        node for node in filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
+        if validate_start_date_end_date(node)
+    ]
 
     has_irrigation = check_irrigation(water_regime_nodes)
     has_upland_rice = _has_upland_rice(land_cover_nodes)

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -1271,8 +1271,7 @@ def _get_irrigated_monthly(year: int, cycles: list[dict]) -> list[bool]:
     irrigation_nodes = non_empty_list(flatten([
         [
             {
-                "startDate": cycle.get("startDate"),
-                "endDate": cycle.get("endDate"),
+                **{key: cycle.get(key) for key in ["startDate", "endDate"] if cycle.get(key)},
                 **node
             } for node in cycle.get("practices", [])
         ] for cycle in cycles

hestia_earth/models/koble2014/aboveGroundCropResidue.py

@@ -94,6 +94,10 @@ def _model_value(term_id: str, products: list):
     return list_average(values) if len(values) > 0 else 0
 
 
+def _remaining_model_value(products: list):
+    return list_sum(find_term_match(products, REMAINING_MODEL).get('value', []), 0)
+
+
 def _run(cycle: dict, total_values: list):
     products = cycle.get('products', [])
     total_value = list_average(total_values)
@@ -126,7 +130,7 @@ def _run(cycle: dict, total_values: list):
 
     return values + [
         # whatever remains is "left on field"
-        _product(REMAINING_MODEL, remaining_value)
+        _product(REMAINING_MODEL, remaining_value + _remaining_model_value(products))
     ] if remaining_value > 0 else values
 
 

hestia_earth/models/lcImpactAllEffects100Years/damageToFreshwaterEcosystemsClimateChange.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None