hestia-earth-models 0.62.0__py3-none-any.whl → 0.62.2__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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
     )