hestia-earth-models 0.72.2__py3-none-any.whl → 0.73.1__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/aboveGroundCropResidueTotal.py

@@ -31,7 +31,7 @@ def _product(value: float):
 
 def _get_lookup_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _run(product: dict):

hestia_earth/models/pooreNemecek2018/belowGroundCropResidue.py

@@ -31,7 +31,7 @@ def _product(value: float):
 
 def _get_lookup_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _run(product: dict):

hestia_earth/models/pooreNemecek2018/excretaKgVs.py

@@ -131,7 +131,7 @@ def _run(excreta_vs_products: list, excreta_n_products: list, mass_balance_items
 def _get_carbonContent(cycle: dict):
     primary_prod = find_primary_product(cycle) or {}
     return safe_parse_float(
-        get_lookup_value(primary_prod.get('term', {}), 'carbonContent', model=MODEL, model_key=MODEL_KEY)
+        get_lookup_value(primary_prod.get('term', {}), 'carbonContent', model=MODEL, model_key=MODEL_KEY), default=0
     ) / 100
 
 

hestia_earth/models/pooreNemecek2018/freshwaterWithdrawalsDuringCycle.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 from hestia_earth.utils.model import filter_list_term_type
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.impact_assessment import get_product, convert_value_from_cycle, get_site
@@ -25,6 +25,13 @@ REQUIREMENTS = {
                 "completeness.water": "True",
                 "inputs": [{"@type": "Input", "term.termType": "water", "value": "> 0"}]
             }
+        },
+        "optional": {
+            "practices": [{
+                "@type": "Practice",
+                "value": "> 0",
+                "term.termType": "waterRegime"
+            }]
         }
     }
 }
@@ -39,7 +46,8 @@ LOOKUPS = {
         "Conveyancing_Efficiency_Annual_crops",
         "Conveyancing_Efficiency_Permanent_crops",
         "Conveyancing_Efficiency_Perennial_crops"
-    ]
+    ],
+    "waterRegime": "conveyancingEfficiency"
 }
 TERM_ID = 'freshwaterWithdrawalsDuringCycle'
 
@@ -50,19 +58,49 @@ def _indicator(term_id: str, value: float):
     return indicator
 
 
-def _get_conveyancing_efficiency(impact_assessment: dict, product: dict):
+def _get_conveyancing_efficiency_from_waterRegime(impact_assessment: dict):
+    practices = filter_list_term_type(impact_assessment.get('cycle', {}).get('practices', []), TermTermType.WATERREGIME)
+    practices_with_factors = [
+        {
+            'practice-id': p.get('term', {}).get('@id'),
+            'practice-value': list_sum(p.get('value'), default=None),
+            'conveyancing': safe_parse_float(
+                get_lookup_value(p.get('term', {}), 'conveyancingEfficiency'), default=None)
+        }
+        for p in practices
+    ]
+    total_practice_value = list_sum([p.get('practice-value', 0) for p in practices_with_factors])
+    conveyancing_from_practices = list_sum([
+        (p.get('practice-value') or 0) * (p.get('conveyancing', 0) or 0) for p in practices_with_factors
+    ]) / total_practice_value if total_practice_value > 0 else None
+    valid_waterRegime_practices = all([
+        p.get('conveyancing') is not None or p.get('practice-value', 0) == 0
+        for p in practices_with_factors
+    ])
+
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID,
+                waterRegime_conveyancing_efficiency_values=log_as_table(practices_with_factors),
+                waterRegime_conveyancing_efficiency=conveyancing_from_practices)
+
+    return conveyancing_from_practices if valid_waterRegime_practices else None
+
+
+def _get_conveyancing_efficiency_from_country(impact_assessment: dict, product: dict):
     site = get_site(impact_assessment)
     country = impact_assessment.get('country', {}) or site.get('country', {})
     grouping = get_crop_grouping_fao(MODEL, TERM_ID, product.get('term', {}))
     value = get_lookup_value(country, f"Conveyancing_Efficiency_{grouping}", model=MODEL, term=TERM_ID)
     debugValues(impact_assessment, model=MODEL, term=TERM_ID,
                 grouping=grouping,
-                conveyancing_efficiency=value)
-    return safe_parse_float(value, 1)
+                country_conveyancing_efficiency=value)
+    return safe_parse_float(value, default=1)
 
 
 def _run(impact_assessment: dict, product: dict, irrigation: float):
-    conveyancing = _get_conveyancing_efficiency(impact_assessment, product)
+    conveyancing = (
+        _get_conveyancing_efficiency_from_waterRegime(impact_assessment) or
+        _get_conveyancing_efficiency_from_country(impact_assessment, product)
+    )
     # convert from m3 to litre
     value = convert_value_from_cycle(
         impact_assessment,

hestia_earth/models/pooreNemecek2018/longFallowDuration.py

@@ -29,7 +29,7 @@ def _practice(value: float):
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _run(product: dict):

hestia_earth/models/pooreNemecek2018/nurseryDensity.py

@@ -23,7 +23,7 @@ TERM_ID = 'nurseryDensity'
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _practice(value: float):

hestia_earth/models/pooreNemecek2018/nurseryDuration.py

@@ -29,7 +29,7 @@ def _practice(value: float):
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def run(cycle: dict):

hestia_earth/models/pooreNemecek2018/plantationDensity.py

@@ -29,7 +29,7 @@ def _practice(value: float):
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def run(cycle: dict):

hestia_earth/models/pooreNemecek2018/plantationLifespan.py

@@ -23,7 +23,7 @@ TERM_ID = 'plantationLifespan'
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _practice(value: float):

hestia_earth/models/pooreNemecek2018/plantationProductiveLifespan.py

@@ -33,7 +33,9 @@ def _get_value(cycle: dict):
     def get(product: dict):
         term_id = product.get('term', {}).get('@id', '')
         plantationLifespan = get_plantationLifespan(product)
-        nonProductiveLifespan = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+        nonProductiveLifespan = safe_parse_float(
+            get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None
+        )
         product_id = product.get('term').get('@id')
         product_id_logs = log_as_table({
             'plantationLifespan': plantationLifespan,

hestia_earth/models/pooreNemecek2018/saplingsDepreciatedAmountPerCycle.py

@@ -35,7 +35,7 @@ def _input(value: float):
 
 def _get_value(product: dict):
     term_id = product.get('term', {}).get('@id', '')
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), default=None)
 
 
 def _run(product: dict, plantationLifespan: float, cycleDuration: float):

hestia_earth/models/resourceUseNotRelevant/__init__.py

@@ -0,0 +1,65 @@
+from hestia_earth.schema import IndicatorMethodTier, TermTermType
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids
+from hestia_earth.utils.lookup_utils import is_in_system_boundary
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.blank_node import _run_required
+from hestia_earth.models.utils.impact_assessment import get_site
+from hestia_earth.models.utils.site import get_land_cover_term_id
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator"}]
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "0",
+        "methodTier": "not relevant"
+    }]
+}
+LOOKUPS = {
+    "resourceUse": [
+        "term.id",
+        "inHestiaDefaultSystemBoundary",
+        "siteTypesAllowed"
+    ]
+}
+MODEL = 'resourceUseNotRelevant'
+TIER = IndicatorMethodTier.NOT_RELEVANT.value
+
+
+def _indicator(term_id: str, land_cover_id: str):
+    indicator = _new_indicator(term_id, MODEL, land_cover_id)
+    indicator['value'] = 0
+    indicator['methodTier'] = TIER
+    return indicator
+
+
+def _resourceUse_ids():
+    return lookup_term_ids(download_lookup(f"{TermTermType.RESOURCEUSE.value}.csv"))
+
+
+def _should_run_resourceUse(impact: dict):
+    def run(term_id: str):
+        is_not_relevant = not _run_required(MODEL, term_id, impact.get('cycle', {}))
+        in_system_boundary = is_in_system_boundary(term_id)
+
+        should_run = all([is_not_relevant, in_system_boundary])
+        if should_run:
+            # no need to show the model failed
+            logRequirements(impact, model=MODEL, term=term_id,
+                            is_not_relevant=is_not_relevant,
+                            in_system_boundary=in_system_boundary,
+                            run_required=False)
+            logShouldRun(impact, MODEL, term_id, should_run)
+        return should_run
+    return run
+
+
+def run(_, impact: dict):
+    term_ids = _resourceUse_ids()
+    term_ids = list(filter(_should_run_resourceUse(impact), term_ids))
+    land_cover_term_id = get_land_cover_term_id(get_site(impact).get('siteType'))
+    return [_indicator(term_id, land_cover_term_id) for term_id in term_ids]

hestia_earth/models/schererPfister2015/nErosionSoilFlux.py

@@ -80,7 +80,7 @@ def _should_run(cycle: dict):
     measurements = site.get('measurements', [])
 
     def _get_measurement_content(term_id: str):
-        return most_relevant_measurement_value(measurements, term_id, end_date)
+        return most_relevant_measurement_value(measurements, term_id, end_date, default=None)
 
     nla_environment = _get_measurement_content('nutrientLossToAquaticEnvironment')
     soil_nitrogen_content = _get_measurement_content('totalNitrogenPerKgSoil')
@@ -91,6 +91,7 @@ def _should_run(cycle: dict):
 
     precipitation = _get_measurement_content('precipitationAnnual')
     inputs_water = get_water_input(cycle)
+    total_water = list_sum([(inputs_water or 0)/10, precipitation or 0])
 
     practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
@@ -100,7 +101,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
         pcorr, p_ef_c1, ef_p_c2]
-    list_of_contents_for_R = [heavy_winter_precipitation, list_sum([(inputs_water or 0)/10, precipitation or 0])]
+    list_of_contents_for_R = [heavy_winter_precipitation, total_water]
     list_of_contents_for_value = [nla_environment, soil_nitrogen_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
@@ -118,8 +119,9 @@ def _should_run(cycle: dict):
                     soil_nitrogen_content=soil_nitrogen_content)
 
     should_run = all([
+        heavy_winter_precipitation is not None,
+        total_water > 0,
         all(list_of_contents_for_A),
-        all(list_of_contents_for_R),
         all(list_of_contents_for_value)
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

hestia_earth/models/schererPfister2015/pErosionSoilFlux.py

@@ -80,7 +80,7 @@ def _should_run(cycle: dict):
     measurements = site.get('measurements', [])
 
     def _get_measurement_content(term_id: str):
-        return most_relevant_measurement_value(measurements, term_id, end_date)
+        return most_relevant_measurement_value(measurements, term_id, end_date, default=None)
 
     nla_environment = _get_measurement_content('nutrientLossToAquaticEnvironment')
     soil_phosphorus_content = _get_measurement_content('totalPhosphorusPerKgSoil')
@@ -91,6 +91,7 @@ def _should_run(cycle: dict):
 
     precipitation = _get_measurement_content('precipitationAnnual')
     inputs_water = get_water_input(cycle)
+    total_water = list_sum([(inputs_water or 0)/10, precipitation or 0])
 
     practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
@@ -100,7 +101,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
         pcorr, p_ef_c1, ef_p_c2]
-    list_of_contents_for_R = [heavy_winter_precipitation, list_sum([(inputs_water or 0)/10, precipitation or 0])]
+    list_of_contents_for_R = [heavy_winter_precipitation, total_water]
     list_of_contents_for_value = [nla_environment, soil_phosphorus_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
@@ -118,8 +119,9 @@ def _should_run(cycle: dict):
                     soil_phosphorus_content=soil_phosphorus_content)
 
     should_run = all([
+        heavy_winter_precipitation is not None,
+        total_water > 0,
         all(list_of_contents_for_A),
-        all(list_of_contents_for_R),
         all(list_of_contents_for_value)
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

hestia_earth/models/schererPfister2015/utils.py

@@ -43,25 +43,26 @@ def get_pcorr(slope: float):
 
 
 def _get_C2_factor(term_id: str, term: dict):
-    return safe_parse_float(get_lookup_value(term, 'C2_FACTORS', model=MODEL, term=term_id), None)
+    return safe_parse_float(get_lookup_value(term, 'C2_FACTORS', model=MODEL, term=term_id), default=None)
 
 
 def get_practice_factor(term_id: str, site: dict):
     return safe_parse_float(
-        get_lookup_value(site.get('country', {}), 'Practice_Factor', model=MODEL, term=term_id), None)
+        get_lookup_value(site.get('country', {}), 'Practice_Factor', model=MODEL, term=term_id), default=None)
 
 
 def get_p_ef_c1(term_id: str, cycle: dict):
     primary_product = find_primary_product(cycle) or {}
     return safe_parse_float(
-        get_lookup_value(primary_product.get('term', {}), 'P_EF_C1', model=MODEL, term=term_id), None)
+        get_lookup_value(primary_product.get('term', {}), 'P_EF_C1', model=MODEL, term=term_id), default=None)
 
 
 def get_ef_p_c2(term_id: str, cycle: dict):
     tillage = _get_tillage(cycle)
     country = cycle.get('site', {}).get('country', {})
     return _get_C2_factor(term_id, tillage) if tillage else safe_parse_float(
-        get_lookup_value(country, 'EF_P_C2', model=MODEL, term=term_id), None)
+        get_lookup_value(country, 'EF_P_C2', model=MODEL, term=term_id), default=None
+    )
 
 
 def get_water_input(cycle: dict):

hestia_earth/models/site/grouped_measurement.py

@@ -5,7 +5,7 @@ from hestia_earth.utils.tools import non_empty_list, flatten, is_number, list_su
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils import _include
 from hestia_earth.models.utils.measurement import _new_measurement
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {

hestia_earth/models/stehfestBouwman2006/n2OToAirSoilFlux_utils.py

@@ -150,7 +150,7 @@ def _get_value(cycle: dict, content_list_of_items: list, N_total: float, term=TE
     sand_factor = _sand_factor(sand, clay)
     eco_factor = get_ecoClimateZone_lookup_value(ecoClimateZone, 'STEHFEST_BOUWMAN_2006_N2O-N_FACTOR')
     crop_grouping_factor = N2O_FACTORS_BY_CROP[crop_grouping]
-    sum_factors = sum([carbon_factor, soil_factor, sand_factor, eco_factor, crop_grouping_factor])
+    sum_factors = sum([carbon_factor, soil_factor, sand_factor, eco_factor or 0, crop_grouping_factor])
     conversion_unit = get_atomic_conversion(Units.KG_N2O, Units.TO_N)
 
     try:

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirSoilFlux_utils.py

@@ -85,10 +85,10 @@ def _should_run(cycle: dict, term=TERM_ID, tier=TIER):
 
 
 def _get_value(cycle: dict, country: dict, N_total: float, term=TERM_ID):
-    noxToAirSoilFlux = safe_parse_float(get_lookup_value(country, LOOKUPS['region'], model=MODEL, term=TERM_ID))
+    EF_NOX = safe_parse_float(get_lookup_value(country, LOOKUPS['region'], model=MODEL, term=TERM_ID), default=0)
     debugValues(cycle, model=MODEL, term=term,
-                noxToAirSoilFlux=noxToAirSoilFlux)
-    return noxToAirSoilFlux * N_total
+                EF_NOX=EF_NOX)
+    return EF_NOX * N_total
 
 
 def _run(cycle: dict, country: dict, N_total: float):

hestia_earth/models/utils/background_emissions.py

@@ -1,11 +1,11 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import flatten
 from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
 
 from hestia_earth.models.log import logShouldRun
 from . import is_from_model
-from .blank_node import get_lookup_value
+from .term import get_lookup_value
 
 
 def _animal_inputs(animal: dict):
@@ -35,8 +35,10 @@ def get_background_inputs(cycle: dict, extra_inputs: list = []):
     return list(filter(_should_run_input(cycle.get('products', [])), inputs))
 
 
-def no_gap_filled_background_emissions(cycle: dict):
-    emissions = cycle.get('emissions', [])
+def no_gap_filled_background_emissions(
+    node: dict, list_key: str = 'emissions', term_type: TermTermType = TermTermType.EMISSION
+):
+    blank_nodes = filter_list_term_type(node.get(list_key, []), term_type)
 
     def check_input(input: dict):
         input_term_id = input.get('term', {}).get('@id')
@@ -44,12 +46,12 @@ def no_gap_filled_background_emissions(cycle: dict):
         animal_term_id = input.get('animal', {}).get('@id')
 
         return not any([
-            is_from_model(emission)
-            for emission in emissions
+            is_from_model(blank_node)
+            for blank_node in blank_nodes
             if all([
-                any([i.get('@id') == input_term_id for i in emission.get('inputs', [])]),
-                emission.get('operation', {}).get('@id') == operation_term_id,
-                emission.get('animal', {}).get('@id') == animal_term_id
+                any([i.get('@id') == input_term_id for i in blank_node.get('inputs', [])]),
+                blank_node.get('operation', {}).get('@id') == operation_term_id,
+                blank_node.get('animal', {}).get('@id') == animal_term_id
             ])
         ])
 
@@ -67,10 +69,12 @@ def all_background_emission_term_ids(cycle: dict):
 def log_missing_emissions(cycle: dict, **log_args):
     all_emission_term_ids = all_background_emission_term_ids(cycle)
 
-    def log_input(input_term_id: str, included_emission_term_ids: list):
+    def log_input(input_term_id: str, included_emission_term_ids: list, **extra_log_args):
         missing_emission_term_ids = [
             term_id for term_id in all_emission_term_ids if term_id not in included_emission_term_ids
         ]
         for emission_id in missing_emission_term_ids:
-            logShouldRun(cycle, term=input_term_id, should_run=False, emission_id=emission_id, **log_args)
+            logShouldRun(cycle, term=input_term_id, should_run=False, emission_id=emission_id,
+                         **log_args,
+                         **extra_log_args)
     return log_input

hestia_earth/models/utils/blank_node.py

@@ -159,7 +159,7 @@ def _run_required(model: str, term_id: str, data: dict):
                     input_id_allowed=input_id_allowed,
                     input_termType_allowed=input_termType_allowed)
         # logging this for the model would cause issues parsing statuses
-        if model != 'emissionNotRelevant':
+        if not model.endswith('NotRelevant'):
             debugValues(data, model=model, term=term_id, run_required=run_required)
     return run_required
 
@@ -1326,16 +1326,18 @@ def get_inputs_from_properties(input: dict, term_types: Union[TermTermType, List
     dict
         A dictionary of nodes grouped by latest date, in the format `{date: list[node]}`.
     """
+    term = input.get('term', {})
     input_value = list_sum(input.get('value', []))
     properties = (
         input.get('properties') or
-        input.get('term', {}).get('defaultProperties') or
-        download_term(input.get('term', {})).get('defaultProperties')
+        term.get('defaultProperties') or
+        download_term(term).get('defaultProperties')
     )
     inputs = non_empty_list([
         {
             'term': p.get('key'),
-            'value': [(p.get('value') / 100) * (p.get('share', 100) / 100) * input_value]
+            'value': [(p.get('value') / 100) * (p.get('share', 100) / 100) * input_value],
+            'parent': term
         } for p in (properties or []) if all([p.get('key'), p.get('value')])
     ]) if input_value > 0 else []
     return filter_list_term_type(inputs, term_types)

hestia_earth/models/utils/crop.py

@@ -30,7 +30,7 @@ def get_N2ON_fertiliser_coeff_from_primary_product(model: str, log_id: str, cycl
     product = find_primary_product(cycle)
     term_id = product.get('term', {}).get('@id') if product else None
     percent = get_crop_lookup_value(model, log_id, term_id, 'N2ON_FERT') if term_id else None
-    return safe_parse_float(percent, 0.01)
+    return safe_parse_float(percent, default=0.01)
 
 
 def is_plantation(model: str, log_id: str, term_id: str):

hestia_earth/models/utils/cropResidue.py

@@ -1,3 +1,9 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import flatten
+
+from .completeness import _is_term_type_complete
+
 PRODUCT_ID_TO_PRACTICES_ID = [
     {'product': 'aboveGroundCropResidueRemoved', 'practices': ['residueRemoved']},
     {'product': 'aboveGroundCropResidueIncorporated', 'practices': [
@@ -11,3 +17,13 @@ PRODUCT_ID_TO_PRACTICES_ID = [
 
 
 def crop_residue_product_ids(): return [v.get('product') for v in PRODUCT_ID_TO_PRACTICES_ID]
+
+
+def get_crop_residue_burnt_value(cycle: dict):
+    products = cycle.get('products', [])
+    value = flatten([
+        find_term_match(products, 'aboveGroundCropResidueBurnt').get('value', []),
+        find_term_match(products, 'discardedCropBurnt').get('value', [])
+    ])
+    data_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
+    return [0] if len(value) == 0 and data_complete else value

hestia_earth/models/utils/cycle.py

@@ -204,7 +204,7 @@ def get_inorganic_fertiliser_P_total(cycle: dict) -> float:
 
 def get_max_rooting_depth(cycle: dict) -> float:
     properties = list(map(lambda p: get_node_property(p, 'rootingDepth'), cycle.get('products', [])))
-    values = [safe_parse_float(p.get('value')) for p in properties if p.get('value') is not None]
+    values = [safe_parse_float(p.get('value'), default=0) for p in properties if p.get('value') is not None]
     return max(values) if len(values) > 0 else None
 
 

hestia_earth/models/utils/ecoClimateZone.py

@@ -87,7 +87,7 @@ def get_ecoClimateZone_lookup_value(eco_climate_zone: str, col_name: str, group_
         code = int(str(eco_climate_zone))
         data = _get_single_table_value(lookup, column_name('ecoClimateZone'), code, column_name(col_name))
         return safe_parse_float(
-            data if group_name is None else extract_grouped_data(data, group_name)
+            data if group_name is None else extract_grouped_data(data, group_name), default=None
         )
     except Exception:
         return 0
@@ -118,7 +118,7 @@ def get_ecoClimateZone_lookup_grouped_value(
         code = int(str(eco_climate_zone))
         data = _get_single_table_value(lookup, column_name('ecoClimateZone'), code, column_name(col_name))
         grouped_data = reduce(
-            lambda prev, curr: prev | {curr.split(':')[0]: safe_parse_float(curr.split(':')[1])},
+            lambda prev, curr: prev | {curr.split(':')[0]: safe_parse_float(curr.split(':')[1], default=None)},
             data.split(';'),
             {}
         ) if data is not None and isinstance(data, str) and len(data) > 1 else default

hestia_earth/models/utils/excretaManagement.py

@@ -19,7 +19,7 @@ def _get_nh3_factor(lookup_name: str, term_id: str, input: dict, **log_args):
     input_term_id = input.get('term', {}).get('@id')
     value = get_table_value(download_lookup(lookup_name), 'termid', term_id, column_name(input_term_id))
     debugMissingLookup(lookup_name, 'termid', term_id, input_term_id, value, **log_args)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
 def get_excreta_inputs_with_factor(cycle: dict, lookup_name: str, excreta_conversion_func, **log_args):

hestia_earth/models/utils/feedipedia.py

@@ -27,9 +27,9 @@ def _should_rescale_by_dm(property_id: str):
 def _dm_property(term_id: str, property_values: dict, dm_property_values: dict, dry_matter_property: dict):
     blank_node_data = {}
     for property_key in property_values.keys():
-        new_dm_value = safe_parse_float(dry_matter_property.get(property_key))
-        old_dm_value = safe_parse_float(dm_property_values.get(property_key))
-        old_property_value = safe_parse_float(property_values.get(property_key))
+        new_dm_value = safe_parse_float(dry_matter_property.get(property_key), default=None)
+        old_dm_value = safe_parse_float(dm_property_values.get(property_key), default=None)
+        old_property_value = safe_parse_float(property_values.get(property_key), default=None)
         if all([new_dm_value, old_dm_value, old_property_value]):
             new_value = round(
                 old_property_value / old_dm_value * new_dm_value,

hestia_earth/models/utils/fertiliser.py

@@ -5,7 +5,13 @@ from hestia_earth.utils.tools import flatten
 
 from .blank_node import get_inputs_from_properties
 
-_TERM_TYPES = [TermTermType.INORGANICFERTILISER, TermTermType.ORGANICFERTILISER]
+_TERM_TYPES = [
+    TermTermType.INORGANICFERTILISER,
+    TermTermType.ORGANICFERTILISER,
+    TermTermType.OTHERINORGANICCHEMICAL,
+    TermTermType.OTHERORGANICCHEMICAL,
+    TermTermType.PESTICIDEAI
+]
 
 
 def get_fertilisers_from_inputs(cycle: dict, term_types: Union[TermTermType, List[TermTermType]] = _TERM_TYPES):