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

hestia_earth/models/cycle/product/revenue.py

@@ -9,9 +9,12 @@ REQUIREMENTS = {
     "Cycle": {
         "products": [{
             "@type": "Product",
-            "price": "",
             "optional": {
-                "value": ""
+                "value": "",
+                "price": ""
+            },
+            "none": {
+                "revenue": ""
             }
         }]
     }

hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -1,22 +1,19 @@
 from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 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
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [
-            {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "n2OToAirExcretaDirect"}
         ]
     }
 }
-LOOKUPS = {
-    "excretaManagement": "EF_NO-N"
-}
 RETURNS = {
     "Emission": [{
         "value": "",
@@ -25,6 +22,7 @@ RETURNS = {
 }
 TERM_ID = 'noxToAirExcreta'
 TIER = EmissionMethodTier.TIER_1.value
+N2O_TERM_ID = 'n2OToAirExcretaDirect'
 
 
 def _emission(value: float):
@@ -34,24 +32,22 @@ def _emission(value: float):
     return emission
 
 
-def _run(excretaKgN: float, NO_N_EF: float):
-    value = (NO_N_EF or 0) * (excretaKgN or 0) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+def _run(n2o: dict):
+    value = 0.1 * list_sum(n2o.get("value", [])) / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    value = value * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    excretaKgN = total_excreta(cycle.get('inputs', []))
-    NO_N_EF = get_lookup_factor(cycle.get('practices', []), LOOKUPS['excretaManagement'])
+    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    excretaKgN=excretaKgN,
-                    NO_N_EF=NO_N_EF)
+    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
 
-    should_run = all([excretaKgN is not None, NO_N_EF is not None])
+    should_run = all([n2o])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, excretaKgN, NO_N_EF
+    return should_run, n2o
 
 
 def run(cycle: dict):
-    should_run, excretaKgN, NO_N_EF = _should_run(cycle)
-    return _run(excretaKgN, NO_N_EF) if should_run else []
+    should_run, n2o = _should_run(cycle)
+    return _run(n2o) if should_run else []

hestia_earth/models/ecoinventV3/__init__.py

@@ -79,7 +79,7 @@ def _emission(term_id: str, value: float, input: dict):
     return emission
 
 
-def _add_emission(cycle: dict, input: dict):
+def _add_emission(cycle: dict, input: dict, **extra_logs):
     input_term_id = input.get('term', {}).get('@id')
     operation_term_id = input.get('operation', {}).get('@id')
     animal_term_id = input.get('animal', {}).get('@id')
@@ -89,7 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
-            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id, **extra_logs)
             debugValues(cycle, model=MODEL, term=emission_term_id,
                         value=value,
                         coefficient=coefficient,
@@ -112,6 +112,10 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = input.get('parent', {}).get('@id')
+        extra_logs = {'input_group_id': input_parent_term_id} if input_parent_term_id else {}
+
         # skip input that has background emissions we have already gap-filled (model run before)
         has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
@@ -119,13 +123,14 @@ def _run_input(cycle: dict):
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
-        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, **extra_logs)
 
-        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()))
+        grouped_emissions = reduce(_add_emission(cycle, input, **extra_logs), mappings, {}) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()), **extra_logs)
         return [
             _emission(term_id, value * input_value, input)
             for term_id, value in grouped_emissions.items()

hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -19,4 +19,4 @@ def get_input_coefficient(model: str, cycle: dict, country_id: str, ecoinventNam
     # find the ratio for the country / year
     data = get_region_lookup_value(REGION_EMBER_SOURCES_LOOKUP_NAME, country_id, source_name, model=model)
     percentage = extract_grouped_data(data, str(year))
-    return safe_parse_float(percentage, 0) / 100
+    return safe_parse_float(percentage, default=0) / 100

hestia_earth/models/emepEea2019/utils.py

@@ -95,7 +95,8 @@ def group_fuel_inputs(inputs: list):
 
 def _get_emissions_factor(animal: dict, lookup_col: str) -> float:
     return safe_parse_float(
-        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", ""))
+        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", "")),
+        default=None
     )
 
 

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.tools import list_sum
 from typing import List, Optional, Tuple
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL

hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandOccupation.py

@@ -60,17 +60,17 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     ]
 
     found_land_occupation_indicators = [{
-        'area-by-year': _node_value(land_occupation_indicator),
-        'area-unit': land_occupation_indicator.get('term', {}).get("units"),
-        'land-cover-id': land_occupation_indicator.get('landCover', {}).get("@id"),
-        'country-id': get_country_id(impact_assessment),
-        'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
-            land_occupation_indicator) > 0,
-        'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
-        'used-country': fallback_country(get_country_id(impact_assessment), [LOOKUP]),
-        'pef-grouping': get_pef_grouping(land_occupation_indicator.get('landCover', {}).get("@id"))
-
-    } for land_occupation_indicator in land_occupation_indicators]
+        'area-by-year': _node_value(indicator),
+        'area-unit': indicator.get('term', {}).get("units"),
+        'land-cover-id': indicator.get('landCover', {}).get("@id"),
+        'country-id': get_country_id(impact_assessment, blank_node=indicator),
+        'area-by-year-is-valid': _node_value(indicator) is not None and _node_value(
+            indicator) > 0,
+        'area-unit-is-valid': indicator.get('term', {}).get("units") == "m2*year",
+        'used-country': fallback_country(get_country_id(impact_assessment, blank_node=indicator), [LOOKUP]),
+        'pef-grouping': get_pef_grouping(indicator.get('landCover', {}).get("@id"))
+
+    } for indicator in land_occupation_indicators]
 
     found_indicators_with_coefficient = [
         indicator | {

hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandTransformation.py

@@ -92,21 +92,24 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
 
     found_transformations = [
         {
-            'value': _node_value(transformation_indicator),
-            'land-cover-id-from': transformation_indicator.get('previousLandCover', {}).get("@id"),
-            'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
-            'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
+            'value': _node_value(indicator),
+            'land-cover-id-from': indicator.get('previousLandCover', {}).get("@id"),
+            'land-cover-id-to': indicator.get('landCover', {}).get("@id"),
+            'indicator-id': indicator.get('term', {}).get('@id', ''),
             'good-land-cover-term': all([
-                bool(transformation_indicator.get('landCover')),
-                bool(transformation_indicator.get('previousLandCover'))
+                bool(indicator.get('landCover')),
+                bool(indicator.get('previousLandCover'))
             ]),
-            'country-id': get_country_id(impact_assessment),
+            'country-id': get_country_id(impact_assessment, blank_node=indicator),
             'value-is-valid': (
-                _node_value(transformation_indicator) is not None and
-                _node_value(transformation_indicator) >= 0
+                _node_value(indicator) is not None and
+                _node_value(indicator) >= 0
             ),
-            'lookup-country': fallback_country(get_country_id(impact_assessment), [from_lookup_file, to_lookup_file]),
-        } for transformation_indicator in resource_uses
+            'lookup-country': fallback_country(
+                get_country_id(impact_assessment, blank_node=indicator),
+                [from_lookup_file, to_lookup_file]
+            ),
+        } for indicator in resource_uses
     ]
 
     found_transformations_with_coefficient = [

hestia_earth/models/faostat2018/liveweightPerHead.py

@@ -55,7 +55,7 @@ def _product_value(product: dict, year: int, country_id: str):
     groupingFAO = get_animalProduct_lookup_value(MODEL, product_id, FAO_LOOKUP_COLUMN)
 
     data = get_region_lookup_value(LOOKUP_WEIGHT, country_id, groupingFAO, model=MODEL, term=TERM_ID)
-    average_carcass_weight = safe_parse_float(extract_grouped_data_closest_date(data, year), None)
+    average_carcass_weight = safe_parse_float(extract_grouped_data_closest_date(data, year), default=None)
     # average_carcass_weight is in hg, divide by 10 to go back to kg
     kg_carcass_weight = average_carcass_weight / 10 if average_carcass_weight else None
 

hestia_earth/models/faostat2018/product/price.py

@@ -65,7 +65,7 @@ def _lookup_data(
     def get_data(country_id):
         data = get_region_lookup_value(lookup_name, country_id, grouping, model=MODEL, term=term_id, key=MODEL_KEY)
         price = extract_grouped_data(data, str(year)) or extract_grouped_data(data, 'Average_price_per_tonne')
-        return safe_parse_float(price, None)
+        return safe_parse_float(price, default=None)
 
     # try get country data first, falls back to region data
     country_id = country.get('@id')
@@ -141,7 +141,7 @@ def _run_by_country(cycle: dict, product: dict, country: dict, year: int = None)
 
     # if units is number instead of kg, need to convert to number first
     conversion_to_number = safe_parse_float(
-        get_region_lookup_value(LOOKUP_UNITS_NUMBER.get(term_type), country.get('@id'), grouping), 1
+        get_region_lookup_value(LOOKUP_UNITS_NUMBER.get(term_type), country.get('@id'), grouping), default=1
     ) if term_units == Units.NUMBER.value else 1
 
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by='country',

hestia_earth/models/faostat2018/seed.py

@@ -43,8 +43,9 @@ def _input(value: float, sd: float):
 def _run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    value = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID)) * product_value
-    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID))
+    value = safe_parse_float(
+        get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID), default=0) * product_value
+    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID), default=0)
     return value, sd
 
 

hestia_earth/models/faostat2018/utils.py

@@ -1,9 +1,9 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data_closest_date
-from hestia_earth.utils.tools import safe_parse_float, flatten
+from hestia_earth.utils.tools import safe_parse_float, flatten, non_empty_list
 
-from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues
+from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.animalProduct import (
     FAO_LOOKUP_COLUMN, FAO_EQUIVALENT_LOOKUP_COLUMN, get_animalProduct_lookup_value
 )
@@ -34,10 +34,10 @@ def product_equivalent_value(product: dict, year: int, country: str):
         return None
 
     quantity_values = get_region_lookup_value(f"{LOOKUP_PREFIX}-productionQuantity.csv", country, grouping)
-    quantity = safe_parse_float(extract_grouped_data_closest_date(quantity_values, year))
+    quantity = safe_parse_float(extract_grouped_data_closest_date(quantity_values, year), default=0)
 
     head_values = get_region_lookup_value(f"{LOOKUP_PREFIX}-head.csv", country, grouping)
-    head = safe_parse_float(extract_grouped_data_closest_date(head_values, year))
+    head = safe_parse_float(extract_grouped_data_closest_date(head_values, year), default=0)
 
     # quantity is in Tonnes
     value = quantity * 1000 / head if head > 0 else 0
@@ -58,7 +58,7 @@ def product_equivalent_value(product: dict, year: int, country: str):
 def _split_delta(table_value: str, start_year: int, end_year: int):
     start_value = extract_grouped_data_closest_date(table_value, start_year)
     end_value = extract_grouped_data_closest_date(table_value, end_year)
-    return safe_parse_float(end_value) - safe_parse_float(start_value) if all([
+    return safe_parse_float(end_value, default=None) - safe_parse_float(start_value, default=None) if all([
         start_value is not None, end_value is not None
     ]) else None
 
@@ -69,7 +69,8 @@ def get_sum_of_columns(country: str, year: int, columns_list: list) -> float:
             extract_grouped_data_closest_date(
                 data=get_region_lookup_value(FAOSTAT_AREA_LOOKUP, country, col, model=MODEL),
                 year=year
-            )
+            ),
+            default=0
         ) for col in columns_list]
     )
 
@@ -128,7 +129,7 @@ def get_change_in_harvested_area_for_crop(country_id: str, crop_name: str, start
     lookup_name = 'region-crop-cropGroupingFaostatProduction-areaHarvested.csv'
     value = get_region_lookup_value(lookup_name, country_id, crop_name)
     return safe_parse_float(
-        extract_grouped_data_closest_date(value, start_year)
+        extract_grouped_data_closest_date(value, start_year), default=0
     ) if end_year == 0 or end_year == start_year else _split_delta(value, start_year, end_year)
 
 
@@ -151,24 +152,37 @@ def should_run_landTransformationFromCropland(term_id: str, impact: dict):
     return should_run, indicators
 
 
+def _map_indicator_value(impact: dict, start_year: int, end_year: int):
+    def mapper(indicator: dict):
+        country_id = get_country_id(impact, blank_node=indicator)
+        total, permanent, temporary = get_cropland_ratio(country_id, start_year, end_year)
+        return {
+            'landCover-id': indicator.get('landCover', {}).get('@id'),
+            'value': indicator.get('value'),
+            'country-id': country_id,
+            'diff-total-area': total,
+            'diff-temporary-area': temporary,
+            'diff-permanent-area': permanent
+        } if total is not None else None
+    return mapper
+
+
 def run_landTransformationFromCropland(term_id: str, impact: dict, indicators: list, years: int):
-    country_id = get_country_id(impact)
     end_year = impact_end_year(impact)
-    total, permanent, temporary = get_cropland_ratio(country_id, end_year - years, end_year)
+
+    values = non_empty_list(map(_map_indicator_value(impact, end_year - years, end_year), indicators))
 
     debugValues(impact, model=MODEL, term_id=term_id,
-                diff_temporary_area=temporary,
-                diff_permanent_area=permanent,
-                diff_total_area=total)
+                indicators_used=log_as_table(values))
 
     return flatten([
         [
-            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'annualCropland') | {
-                'value': indicator.get('value') * temporary / total
+            _new_indicator(term_id, MODEL, value.get('landCover-id'), 'annualCropland') | {
+                'value': value.get('value') * value.get('diff-temporary-area') / value.get('diff-total-area')
             },
-            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'permanentCropland') | {
-                'value': indicator.get('value') * permanent / total
+            _new_indicator(term_id, MODEL, value.get('landCover-id'), 'permanentCropland') | {
+                'value': value.get('value') * value.get('diff-permanent-area') / value.get('diff-total-area')
             }
         ]
-        for indicator in indicators
-    ]) if total is not None else []
+        for value in values
+    ])

hestia_earth/models/geospatialDatabase/altitude.py

@@ -42,7 +42,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/drainageClass.py

@@ -40,7 +40,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/organicCarbonPerKgSoil.py

@@ -69,8 +69,9 @@ def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
 
 def _run_depths(site: dict, params: dict):
     value = download(TERM_ID, site, params)
+    value = safe_parse_float(value, default=None)
     return None if value is None else (
-        _measurement(site, safe_parse_float(value) * 10, params.get('depthUpper'), params.get('depthLower'))
+        _measurement(site, value * 10, params.get('depthUpper'), params.get('depthLower'))
     )
 
 

hestia_earth/models/geospatialDatabase/totalNitrogenPerKgSoil.py

@@ -69,8 +69,9 @@ def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
 
 def _run_depths(site: dict, params: dict):
     value = download(TERM_ID, site, params)
+    value = safe_parse_float(value, default=None)
     return None if value is None else (
-        _measurement(site, safe_parse_float(value), params.get('depthUpper'), params.get('depthLower'))
+        _measurement(site, value, params.get('depthUpper'), params.get('depthLower'))
     )
 
 

hestia_earth/models/geospatialDatabase/totalPhosphorusPerKgSoil.py

@@ -44,7 +44,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/utils.py

@@ -101,17 +101,19 @@ def _get_region_area_size(site: dict):
 
 
 def get_area_size(site: dict):
-    return None if has_coordinates(site) else (
-        # fallback if `boundary` provided but no `boundaryArea` was computed
-        site.get('boundaryArea') or _get_boundary_area_size(site.get('boundary'))
-    ) if has_boundary(site) else _get_region_area_size(site)
+    return _cached_value(site, CACHE_AREA_SIZE) or (
+        None if has_coordinates(site) else (
+            # fallback if `boundary` provided but no `boundaryArea` was computed
+            site.get('boundaryArea') or _get_boundary_area_size(site.get('boundary'))
+        ) if has_boundary(site) else _get_region_area_size(site)
+    )
 
 
 def _is_below_max_size(term: str, site: dict) -> bool:
     current_size = _cached_value(site, CACHE_AREA_SIZE) or get_area_size(site)
     if current_size is not None:
         logRequirements(site, model=MODEL, term=term,
-                        current_size=int(current_size),
+                        current_size=round(float(current_size), 5),
                         max_area_size=MAX_AREA_SIZE)
         return current_size <= MAX_AREA_SIZE
     return True

hestia_earth/models/globalCropWaterModel2008/rootingDepth.py

@@ -60,7 +60,7 @@ def _get_value(cycle: dict, term: dict, irrigation_ids: list):
     else:
         column = 'Rooting_depth_average_m'
 
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, column), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, column), default=None)
 
 
 def _should_run_product(cycle: dict):

hestia_earth/models/hestia/brackishWater.py

@@ -34,7 +34,7 @@ def _should_run(site: dict):
     logRequirements(site, model=MODEL, term=TERM_ID,
                     waterSalinity=waterSalinity)
 
-    should_run = all([500 <= waterSalinity <= 18000])
+    should_run = all([500 <= (waterSalinity or 0) <= 18000])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/hestia/default_emissions.py

@@ -0,0 +1,105 @@
+from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import _omit
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.input import unique_background_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "none": {
+                "impactAssessment": {"@type": "ImpactAssessment"},
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "methodTier": "background"
+    }]
+}
+LOOKUPS = {
+    "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
+}
+MODEL_KEY = 'default_emissions'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['inputs'] = [input]
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _default_value(input: dict):
+    return safe_parse_float(get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser']), default=None)
+
+
+def _run_input(cycle: dict):
+    required_emission_term_ids = [
+        id for id in cycle_emissions_in_system_boundary(cycle)
+        if id.endswith('InputsProduction')
+    ]
+
+    def run(input: dict):
+        input_term = input.get('input').get('term')
+        term_id = input_term.get('@id')
+        value = input.get('default-value-from-lookup')
+
+        for emission_id in required_emission_term_ids:
+            logShouldRun(cycle, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+
+        return [
+            _emission(term_id, value, input_term) for term_id in required_emission_term_ids
+        ]
+
+    return run
+
+
+def _should_run(cycle: dict):
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+
+    inputs = [
+        input | {
+            'default-value-from-lookup': _default_value(input['input']),
+            'no-gap-filled-background-emissions': no_gap_filled_background_emissions_func(input['input'])
+        }
+        for input in unique_background_inputs(cycle)
+    ]
+    valid_inputs = [
+        input for input in inputs
+        if all([
+            input.get('default-value-from-lookup') is not None,
+            input.get('no-gap-filled-background-emissions')
+        ])
+    ]
+
+    should_run = all([bool(valid_inputs)])
+
+    for input in inputs:
+        term_id = input.get('input').get('term', {}).get('@id')
+
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        **_omit(input, ['input', 'input-value']))
+        logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+
+    return should_run, valid_inputs
+
+
+def run(cycle: dict):
+    should_run, grouped_inputs = _should_run(cycle)
+    return flatten(map(_run_input(cycle), grouped_inputs)) if should_run else []