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

{hestia-earth-models-0.62.0/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.0
+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.0 → hestia-earth-models-0.62.2}/hestia_earth/models/blonkConsultants2016/utils.py

@@ -25,5 +25,6 @@ def get_emission_factor(term_id: str, cycle: dict, factor: str):
     data = safe_parse_float(value, None)
     # fallback to site.siteType data if possible
     return data if data is not None else safe_parse_float(
-        extract_grouped_data(
-            get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')), None)
+        extract_grouped_data(get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')),
+        None
+    )

{hestia-earth-models-0.62.0 → 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.0 → 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.0 → 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.0 → 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.0 → hestia-earth-models-0.62.2}/hestia_earth/models/cycle/post_checks/__init__.py

@@ -2,14 +2,15 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cache, site
+from . import cache, site, otherSites
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
     cache.run,
-    site.run
+    site.run,
+    otherSites.run
 ]
 
 

hestia-earth-models-0.62.2/hestia_earth/models/cycle/post_checks/otherSites.py

@@ -0,0 +1,40 @@
+"""
+Post Checks Other Sites
+
+This model is run only if the [pre model](../pre_checks/cycle.md) has been run before.
+This model will restore the `cycle.otherSites` as a list of "linked node"
+(i.e. it will be set with only `@type`, `@id` and `name` keys).
+"""
+from hestia_earth.utils.model import linked_node
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "@id": ""
+        }]
+    }
+}
+RETURNS = {
+    "Cycle": {
+        "otherSites": [{"@type": "Site"}]
+    }
+}
+MODEL_KEY = 'otherSites'
+
+
+def _run_site(site: dict): return linked_node(site)
+
+
+def _should_run_site(site: dict): return site.get('@id') is not None
+
+
+def _should_run(cycle: dict): return len(cycle.get(MODEL_KEY, [])) > 0
+
+
+def run(cycle: dict):
+    return cycle | (
+        ({
+            MODEL_KEY: [_run_site(site) if _should_run_site(site) else site for site in cycle.get(MODEL_KEY, [])]
+        }) if _should_run(cycle) else {}
+    )

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/cycle/pre_checks/__init__.py

@@ -2,12 +2,13 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import site, cache_sources
+from . import site, cache_sources, otherSites
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
+    otherSites.run,
     site.run,
     cache_sources.run
 ]

hestia-earth-models-0.62.2/hestia_earth/models/cycle/pre_checks/otherSites.py

@@ -0,0 +1,42 @@
+"""
+Pre Checks Other Sites
+
+Some Cycle models need a full version of the linked [Site](https://hestia.earth/schema/Site) to run.
+This model will fetch the complete version of the [Cycle Sites](https://hestia.earth/schema/Cycle#otherSites)
+and include them.
+"""
+from hestia_earth.schema import SchemaType
+
+from hestia_earth.models.utils import _load_calculated_node
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "@id": ""
+        }]
+    }
+}
+RETURNS = {
+    "Cycle": {
+        "otherSites": [{"@type": "Site"}]
+    }
+}
+MODEL_KEY = 'otherSites'
+
+
+def _run_site(site: dict): return _load_calculated_node(site, SchemaType.SITE)
+
+
+def _should_run_site(site: dict): return site.get('@id') is not None
+
+
+def _should_run(cycle: dict): return len(cycle.get(MODEL_KEY, [])) > 0
+
+
+def run(cycle: dict):
+    return cycle | (
+        ({
+            MODEL_KEY: [_run_site(site) if _should_run_site(site) else site for site in cycle.get(MODEL_KEY, [])]
+        }) if _should_run(cycle) else {}
+    )

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/cycle/pre_checks/site.py

@@ -2,7 +2,7 @@
 Pre Checks Site
 
 Some Cycle models need a full version of the linked [Site](https://hestia.earth/schema/Site) to run.
-This model will fetch the complete version of the [Site](https://hestia.earth/schema/Site) and include it.
+This model will fetch the complete version of the [Cycle Site](https://hestia.earth/schema/Cycle#site) and include it.
 """
 from hestia_earth.schema import SchemaType
 

{hestia-earth-models-0.62.0 → 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.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -33,7 +33,7 @@ def _extract_emission_value(value_iter: Any) -> Union[float, None]:
     value_list = list(value_iter)
     try:
         if len(list(value_list)) > 0 and len(list(value_list)[0]) > 1:
-            return safe_parse_float(list(value_list)[0][1])
+            return safe_parse_float(list(value_list)[0][1], None)
     except ValueError:
         return None
 

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/emepEea2019/utils.py

@@ -1,7 +1,7 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
-from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_lookup_value
@@ -19,14 +19,15 @@ def _get_fuel_input_value(term_id: str, lookup_col: str):
             get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id), input_term_id
         ) if operation_term else None
         input_factor = operation_factor or get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+        factor = safe_parse_float(input_factor, None)
 
-        return input_value * safe_parse_float(input_factor)
+        return input_value * factor if factor is not None else None
     return get_value
 
 
 def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
     inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
-    values = list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
+    values = non_empty_list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
 
     return [0] if all([
         len(values) == 0,

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/geospatialDatabase/heavyWinterPrecipitation.py

@@ -39,7 +39,7 @@ def _measurement(site: dict, value: float):
 
 def _download(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return 1 if value == 1 else (0 if value == 0.1 else None)
+    return value == 1
 
 
 def _run(site: dict):

{hestia-earth-models-0.62.0 → 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,40 +187,52 @@ 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)
-
-    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(cycle: 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)
-        value = (GE / meanECHHV) * (list_sum(practice.get('value', [0])) / 100)
 
-        logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
-                        GE=GE,
-                        meanECHHV=meanECHHV,
-                        key_id=key_id)
+        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)
 
-        logShouldRun(cycle, MODEL, input_term_id, True, model_key=MODEL_KEY)
+        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,
+                        animal_logs=logs,
+                        animal_lookups=animal_lookups,
+                        animal_properties=animal_properties)
+
+        logShouldRun(animal, MODEL, input_term_id, True, model_key=MODEL_KEY)
 
         return _input(input_term_id, value)
 
@@ -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(cycle, 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.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -7,7 +7,7 @@ from pydash.objects import merge
 from typing import NamedTuple, Optional, Union
 
 from hestia_earth.schema import (
-    CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification
+    CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification, SiteSiteType
 )
 from hestia_earth.utils.date import diff_in_days
 from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
@@ -15,7 +15,8 @@ from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import (
-    _get_datestr_format, _gapfill_datestr, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match
+    _get_datestr_format, _gapfill_datestr, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match,
+    cumulative_nodes_term_match
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.emission import _new_emission, min_emission_method_tier
@@ -82,6 +83,13 @@ The list of `MeasurementMethodClassification`s that can be used to calculate SOC
 order from strongest to weakest.
 """
 
+_SITE_TYPE_SYSTEMS_MAPPING = {
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
+        "protectedCroppingSystemSoilBased",
+        "protectedCroppingSystemSoilAndSubstrateBased"
+    ]
+}
+
 
 class _InventoryKey(Enum):
     """
@@ -207,19 +215,37 @@ def _should_run(cycle: dict) -> tuple[bool, str, dict]:
     soc_measurements = [node for node in site.get("measurements", []) if _validate_soc_measurement(node)]
     cycles = related_cycles(site)
 
+    site_type = site.get("siteType")
+    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
+        cumulative_nodes_term_match(
+            cycle.get("practices", []),
+            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
+            cumulative_threshold=0
+        ) for cycle in cycles
+    )
+
     has_soc_measurements = len(soc_measurements) > 0
     has_cycles = len(cycles) > 0
     has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
 
-    should_compile_inventory = all([has_cycles, has_functional_unit_1_ha, has_soc_measurements])
+    should_compile_inventory = all([
+        has_soil,
+        has_cycles,
+        has_functional_unit_1_ha,
+        has_soc_measurements,
+    ])
 
-    inventory, logs = _compile_inventory(cycle_id, cycles, soc_measurements) if should_compile_inventory else ({}, {})
+    inventory, logs = (
+        _compile_inventory(cycle_id, cycles, soc_measurements) if should_compile_inventory else ({}, {})
+    )
 
     has_valid_inventory = len(inventory) > 0
     has_consecutive_years = check_consecutive(inventory.keys())
 
     logRequirements(
         cycle, model=MODEL, term=TERM_ID,
+        site_type=site_type,
+        has_soil=has_soil,
         has_soc_measurements=has_soc_measurements,
         has_cycles=has_cycles,
         has_functional_unit_1_ha=has_functional_unit_1_ha,

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/n2OToAirExcretaDirect.py

@@ -1,7 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import total_excreta
 from hestia_earth.models.utils.excretaManagement import get_lookup_factor
@@ -9,6 +10,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "completeness.excreta": "True",
         "practices": [
             {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
         ]
@@ -42,10 +44,12 @@ def _run(excretaKgN: float, N2O_N_EF: float):
 def _should_run(cycle: dict):
     excretaKgN = 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,
-                    N2O_N_EF=N2O_N_EF)
+                    N2O_N_EF=N2O_N_EF,
+                    term_type_excreta_complete=term_type_complete)
 
     should_run = all([excretaKgN, N2O_N_EF])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/n2OToAirExcretaIndirect.py

@@ -88,7 +88,7 @@ def _should_run(cycle: dict):
                     no3_n=no3_n,
                     nh3_n=nh3_n,
                     nox_n=nox_n,
-                    term_type_cropResidue_complete=term_type_complete)
+                    term_type_excreta_complete=term_type_complete)
 
     should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserDirect.py

@@ -97,7 +97,7 @@ def _should_run(cycle: dict):
     flooded_rice = has_flooded_rice(cycle.get('products', []))
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    term_type_cropResidue_complete=term_type_complete,
+                    term_type_fertiliser_complete=term_type_complete,
                     N_total=N_total,
                     has_flooded_rice=flooded_rice,
                     ecoClimateZone=ecoClimateZone)

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserIndirect.py

@@ -88,7 +88,7 @@ def _should_run(cycle: dict):
                     no3_n=no3_n,
                     nh3_n=nh3_n,
                     nox_n=nox_n,
-                    term_type_cropResidue_complete=term_type_complete)
+                    term_type_fertiliser_complete=term_type_complete)
 
     should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/n2OToAirOrganicFertiliserIndirect.py

@@ -88,7 +88,7 @@ def _should_run(cycle: dict):
                     no3_n=no3_n,
                     nh3_n=nh3_n,
                     nox_n=nox_n,
-                    term_type_cropResidue_complete=term_type_complete)
+                    term_type_fertiliser_complete=term_type_complete)
 
     should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

{hestia-earth-models-0.62.0 → hestia-earth-models-0.62.2}/hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_1_utils.py

@@ -19,10 +19,11 @@ from typing import Callable, Optional, Union
 
 from hestia_earth.schema import MeasurementMethodClassification, SiteSiteType, TermTermType
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
+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, get_node_value,
+    cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match,
     node_lookup_match, node_term_match, group_nodes_by_year
 )
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -1952,6 +1953,7 @@ def _get_carbon_input_kwargs(
     crop_residue_management_nodes = filter_list_term_type(management_nodes, [TermTermType.CROPRESIDUEMANAGEMENT])
     land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
     land_use_management_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDUSEMANAGEMENT])
+    system_nodes = filter_list_term_type(management_nodes, [TermTermType.SYSTEM])
     water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
 
     has_animal_manure_used = any(
@@ -2006,7 +2008,7 @@ def _get_carbon_input_kwargs(
             node_lookup_match(node, PRACTICE_INCREASING_C_INPUT_LOOKUP, True)
             and not node_term_match(node, EXCLUDED_PRACTICE_TERM_IDS)
         ),
-        land_use_management_nodes,
+        land_use_management_nodes + system_nodes,
         cumulative_threshold=MIN_AREA_THRESHOLD
     )