hestia-earth-models 0.72.2__py3-none-any.whl → 0.73.0__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

@@ -58,7 +58,7 @@ def _get_conveyancing_efficiency(impact_assessment: dict, product: dict):
     debugValues(impact_assessment, model=MODEL, term=TERM_ID,
                 grouping=grouping,
                 conveyancing_efficiency=value)
-    return safe_parse_float(value, 1)
+    return safe_parse_float(value, default=1)
 
 
 def _run(impact_assessment: dict, product: dict, irrigation: float):

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/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,5 +1,5 @@
 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
 
@@ -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):

hestia_earth/models/utils/inorganicFertiliser.py

@@ -31,12 +31,12 @@ def get_NH3_emission_factor(term_id: str, soilPh: float, temperature: float):
     soilPh_key = _get_soilPh_lookup_key(soilPh)
     temperature_key = _get_temperature_lookup_key(temperature)
     data = get_term_lookup(term_id, f"NH3_emissions_factor_{soilPh_key}")
-    return safe_parse_float(extract_grouped_data(data, temperature_key), None)
+    return safe_parse_float(extract_grouped_data(data, temperature_key), default=None)
 
 
 def get_country_breakdown(model: str, term_id: str, country_id: str, col_name: str):
     value = get_region_lookup_value(BREAKDOWN_LOOKUP, country_id, col_name, model=model, term=term_id)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
 def get_cycle_inputs(cycle: dict):

hestia_earth/models/utils/input.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.tools import list_sum, non_empty_list, list_average, fla
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
 
 from hestia_earth.models.log import logger
-from . import _filter_list_term_unit, _load_calculated_node
+from . import _filter_list_term_unit, _load_calculated_node, group_by
 from .constant import Units
 from .blank_node import get_total_value, get_total_value_converted, get_lookup_value
 from .term import download_term
@@ -148,3 +148,36 @@ def total_excreta(inputs: list, units=Units.KG_N):
 def get_total_irrigation_m3(cycle: dict):
     irrigation_inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.WATER)
     return sum([list_average(i.get('value')) for i in irrigation_inputs if len(i.get('value', [])) > 0])
+
+
+def _group_inputs(inputs: list):
+    grouped_inputs = group_by(inputs, ['input.term.@id'])
+    return [
+        inputs[0] | {'value': list_sum(flatten([v.get('input-value') for v in inputs]))}
+        for inputs in grouped_inputs.values()
+    ]
+
+
+def _input_data(input: dict):
+    return {
+        'input': input,
+        'input-value': list_sum(input.get('value'), default=None),
+        'has-linked-impact-assessment': bool(input.get('impactAssessment')),
+        'is-fromCycle': input.get('fromCycle', False),
+        'is-producedInCycle': input.get('producedInCycle', False)
+    }
+
+
+def unique_background_inputs(cycle: dict):
+    inputs = non_empty_list(map(_input_data, cycle.get('inputs', [])))
+
+    # sum up inputs with the same id
+    return _group_inputs([
+        v for v in inputs
+        if all([
+            v.get('input-value') or -1 > 0,
+            not v.get('has-linked-impact-assessment'),
+            not v.get('is-fromCycle'),
+            not v.get('is-producedInCycle')
+        ])
+    ])

hestia_earth/models/utils/liveAnimal.py

@@ -33,8 +33,8 @@ def get_default_digestibility(model: str, term_id: str, cycle: dict):
         lookup_col = column_name(product_id)
         value = get_table_value(lookup, 'termid', system_id, lookup_col)
         debugMissingLookup(lookup_name, 'termid', term_id, lookup_col, value, model=model, term=term_id)
-        min = safe_parse_float(extract_grouped_data(value, 'min'), None)
-        max = safe_parse_float(extract_grouped_data(value, 'max'), None)
+        min = safe_parse_float(extract_grouped_data(value, 'min'), default=None)
+        max = safe_parse_float(extract_grouped_data(value, 'max'), default=None)
         if min and max:
             return mean([min, max])
 

hestia_earth/models/utils/lookup.py

@@ -28,7 +28,7 @@ def _factor_value(model: str, term_id: str, lookup_name: str, lookup_col: str, g
         coefficient = safe_parse_float(
             extract_grouped_data(coefficient, grouped_data_key),
             default=None
-        ) if ':' in str(coefficient) else safe_parse_float(coefficient, None)
+        ) if ':' in str(coefficient) else safe_parse_float(coefficient, default=None)
         if value is not None and coefficient is not None:
             if model:
                 debugValues(data, model=model, term=term_id,

hestia_earth/models/utils/measurement.py

@@ -32,17 +32,18 @@ def _new_measurement(term, method=None):
     return include_method(node, term_id=method)
 
 
-def measurement_value(measurement: dict, is_larger_unit: bool = False) -> float:
+def measurement_value(measurement: dict, is_larger_unit: bool = False, default=None) -> float:
     term = measurement.get('term', {})
     reducer = get_lookup_value(term, 'arrayTreatmentLargerUnitOfTime' if is_larger_unit else 'arrayTreatment') or 'mean'
     value = non_empty_list(measurement.get('value', []))
     is_value_valid = value is not None and isinstance(value, list) and len(value) > 0
-    return MEASUREMENT_REDUCE.get(reducer, lambda v: v[0])(value) if is_value_valid else 0
+    print(reducer, value, is_value_valid)
+    return MEASUREMENT_REDUCE.get(reducer, lambda v: v[0])(value) if is_value_valid else default
 
 
 def most_relevant_measurement_value(measurements: list, term_id: str, date: str, default=None):
     measurement = most_relevant_blank_node_by_id(measurements, term_id, date)
-    return measurement_value(measurement) if measurement else default
+    return measurement_value(measurement, default=default) if measurement else default
 
 
 def _group_measurement_key(measurement: dict, include_dates: bool = True):
@@ -167,7 +168,7 @@ def most_relevant_measurement_value_by_depth_and_date(
 
     def depth_distance(depth_string):
         split = depth_string.split('_')
-        upper, lower = safe_parse_float(split[0]), safe_parse_float(split[2])  # "a_to_b"
+        upper, lower = safe_parse_float(split[0], default=0), safe_parse_float(split[2], default=0)  # "a_to_b"
         return abs(upper - depth_upper) + abs(lower - depth_lower)
 
     nearest_key = min(grouped_measurements.keys(), key=depth_distance)

hestia_earth/models/utils/productivity.py

@@ -17,5 +17,5 @@ PRODUCTIVITY_KEY = {
 
 
 def get_productivity(country: dict, default: PRODUCTIVITY = PRODUCTIVITY.HIGH):
-    hdi = safe_parse_float(get_lookup_value(country, 'hdi'), None)
+    hdi = safe_parse_float(get_lookup_value(country, 'hdi'), default=None)
     return next((key for key in PRODUCTIVITY_KEY if hdi and PRODUCTIVITY_KEY[key](hdi)), default)

hestia_earth/models/utils/property.py

@@ -132,9 +132,11 @@ def get_node_property_value_converted(model: str, node: dict, prop_id: str, defa
 
 def _get_nitrogen_content(node: dict):
     return safe_parse_float(
-        get_node_property(node, 'nitrogenContent').get('value', 0)) if node else 0
+        get_node_property(node, 'nitrogenContent').get('value', 0), default=0
+    ) if node else 0
 
 
 def _get_nitrogen_tan_content(node: dict):
     return safe_parse_float(
-        get_node_property(node, 'totalAmmoniacalNitrogenContentAsN').get('value', 0)) if node else 0
+        get_node_property(node, 'totalAmmoniacalNitrogenContentAsN').get('value', 0), default=0
+    ) if node else 0