hestia-earth-models 0.73.7__py3-none-any.whl → 0.74.0__py3-none-any.whl

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -88,20 +88,18 @@ def _indicator_factors(impact_assessment: dict, indicator: dict):
     }
 
 
-def _map_input_ids(value: dict) -> set[str]:
-    return set(map(lambda i: i.get('@id'), value.get('inputs', [])))
-
-
 def _count_duplicate_indicators(reference_indicator: dict, indicators: list) -> int:
     """
     Counts the number of `reference_indicator` indicators found in a list of indicators.
-    Uses indicator.term.@id and indicator.inputs to determine uniqueness.
+    Uses indicator.term.@id and indicator.key to determine uniqueness.
     """
     return sum([
         1
         for i in indicators
-        if (i["term"]["@id"] == reference_indicator["term"]["@id"]) and (
-                    _map_input_ids(i) == _map_input_ids(reference_indicator))
+        if all([
+            i["term"]["@id"] == reference_indicator["term"]["@id"],
+            i.get("key", {}).get("@id") == reference_indicator.get("key", {}).get("@id")
+        ])
     ])
 
 

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -1,11 +1,11 @@
-from functools import reduce
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils.blank_node import group_by_keys
+from hestia_earth.models.utils import unique_values, _omit, _include
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL
@@ -20,7 +20,7 @@ REQUIREMENTS = {
                 "ionisingCompoundsToWaterInputsProduction",
                 "ionisingCompoundsToSaltwaterInputsProduction"
             ],
-            "inputs": [{"@type": "Term", "term.termType": "waste", "term.units": "kg"}]
+            "key": {"@type": "Term", "term.termType": "waste", "term.units": "kg"}
         }]
     }
 }
@@ -34,6 +34,7 @@ LOOKUPS = {
 RETURNS = {
     "Indicator": [{
         "value": "",
+        "key": "",
         "inputs": ""
     }]
 }
@@ -41,31 +42,32 @@ RETURNS = {
 TERM_ID = 'ionisingRadiationKbqU235Eq'
 
 
-def _valid_waste(input: dict) -> bool:
-    return input.get('units', '').startswith("kg") and input.get('termType', '') == TermTermType.WASTE.value
-
-
-def _valid_emission(emission: dict) -> bool:
-    return len(emission.get('inputs', [])) == 1 and isinstance(_node_value(emission), (int, float))
-
-
-def _indicator(value: float, input: dict) -> dict:
+def _indicator(value: float, key: dict, inputs: list) -> dict:
     indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['key'] = key
     indicator['value'] = value
-    indicator['inputs'] = [input]
+    if inputs:
+        indicator['inputs'] = inputs
     return indicator
 
 
 def _run(emissions: list) -> list[dict]:
     indicators = [
-        _indicator(value=list_sum([emission['value'] * emission['coefficient'] for emission in emission_group]),
-                   input=emission_group[0]['input'])
-        for emission_group in reduce(group_by_keys(['input']), emissions, {}).values()
+        _indicator(
+            value=list_sum([emission['value'] * emission['coefficient'] for emission in emission_group]),
+            key=emission_group[0]['key'],
+            inputs=unique_values(flatten([emission.get('inputs', []) for emission in emission_group]))
+        )
+        for emission_group in group_by_keys(emissions, ['key']).values()
     ]
 
     return indicators
 
 
+def _valid_key(term: dict) -> bool:
+    return term.get('units', '').startswith("kg") and term.get('termType') == TermTermType.WASTE.value
+
+
 def _should_run(impact_assessment: dict) -> tuple[bool, list]:
     emissions = [
         emission
@@ -75,38 +77,34 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
 
     has_emissions = bool(emissions)
 
-    emissions_unpacked = flatten(
-        [
-            [
-                {
-                    "input-term-id": input.get('@id'),
-                    "input-term-type": input.get('termType'),
-                    "indicator-term-id": emission['term']['@id'],
-                    "indicator-is-valid": _valid_emission(emission),
-                    "input": input,
-                    "indicator-input-is-valid": _valid_waste(input),
-                    "value": _node_value(emission),
-                    "coefficient": get_table_value(lookup=download_lookup(filename="waste.csv"),
-                                                   col_match='termid',
-                                                   col_match_with=input.get('@id'),
-                                                   col_val=column_name(emission['term']['@id'])) if input else None
-                } for input in emission['inputs'] or [{}]]
-            for emission in emissions
-        ]
-    )
+    emissions_unpacked = [
+        {
+            "key-term-id": emission['key'].get('@id'),
+            "key-term-type": emission['key'].get('termType'),
+            "key-is-valid": _valid_key(emission['key']),
+            "indicator-term-id": emission['term']['@id'],
+            "value": _node_value(emission),
+            "coefficient": get_table_value(
+                lookup=download_lookup(filename="waste.csv"),
+                col_match='termid',
+                col_match_with=emission['key'].get('@id'),
+                col_val=column_name(emission['term']['@id'])
+            )
+        } | _include(emission, ['key', 'inputs'])
+        for emission in emissions
+        if emission.get('key')
+    ]
 
     valid_emission_with_cf = [
         em for em in emissions_unpacked if all([
             em['coefficient'] is not None,
-            em['indicator-is-valid'] is True,
-            em['indicator-input-is-valid'] is True
+            em['key-is-valid'] is True
         ])
     ]
 
-    valid_input_requirements = all([
+    valid_key_requirements = all([
         all([
-            em['indicator-is-valid'],
-            em['indicator-input-is-valid']
+            em['key-is-valid']
         ])
         for em in emissions_unpacked
     ])
@@ -117,12 +115,12 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
 
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     has_emissions=has_emissions,
-                    valid_input_requirements=valid_input_requirements,
+                    valid_key_requirements=valid_key_requirements,
                     all_emissions_have_known_CF=all_emissions_have_known_cf,
-                    emissions=log_as_table(emissions_unpacked)
+                    emissions=log_as_table([_omit(v, ['key', 'inputs']) for v in emissions_unpacked])
                     )
 
-    should_run = valid_input_requirements
+    should_run = all([emissions_unpacked, valid_key_requirements])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_emission_with_cf

hestia_earth/models/geospatialDatabase/awareWaterBasinId.py

@@ -16,9 +16,9 @@ RETURNS = {
 }
 MODEL_KEY = 'awareWaterBasinId'
 EE_PARAMS = {
-    'collection': 'AWARE',
+    'collection': 'AWARE_2_0_ids',
     'ee_type': 'vector',
-    'fields': 'Name'
+    'fields': 'Basin_ID'
 }
 
 

hestia_earth/models/geospatialDatabase/awareWaterBasinId_v1.py

@@ -0,0 +1,45 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from .utils import download, has_geospatial_data, should_download
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "or": [
+            {"latitude": "", "longitude": ""},
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
+        ]
+    }
+}
+RETURNS = {
+    "The AWARE water basin identifier as a `string`": ""
+}
+MODEL_KEY = 'awareWaterBasinId_v1'
+EE_PARAMS = {
+    'collection': 'AWARE',
+    'ee_type': 'vector',
+    'fields': 'Name'
+}
+
+
+def _download(site: dict):
+    return download(MODEL_KEY, site, EE_PARAMS)
+
+
+def _run(site: dict): return _download(site)
+
+
+def _should_run(site: dict):
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
+
+    logRequirements(site, model=MODEL, model_key=MODEL_KEY,
+                    contains_geospatial_data=contains_geospatial_data,
+                    below_max_area_size=below_max_area_size)
+
+    should_run = all([contains_geospatial_data, below_max_area_size])
+    logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)
+    return should_run
+
+
+def run(site: dict): return _run(site) if _should_run(site) else None

hestia_earth/models/hestia/default_emissions.py

@@ -1,10 +1,9 @@
 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.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils import _omit
-from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.emission import _new_emission, background_emissions_in_system_boundary
 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
@@ -51,10 +50,7 @@ def _default_value(input: dict):
 
 
 def _run_input(cycle: dict):
-    required_emission_term_ids = [
-        id for id in cycle_emissions_in_system_boundary(cycle)
-        if id.endswith('InputsProduction')
-    ]
+    required_emission_term_ids = background_emissions_in_system_boundary(cycle)
 
     def run(input: dict):
         input_term = input.get('input').get('term')
@@ -63,6 +59,10 @@ def _run_input(cycle: dict):
 
         for emission_id in required_emission_term_ids:
             logShouldRun(cycle, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+            debugValues(cycle, model=MODEL, term=emission_id,
+                        value=value,
+                        coefficient=1,
+                        input=term_id)
 
         return [
             _emission(term_id, value, input_term) for term_id in required_emission_term_ids

hestia_earth/models/hestia/default_resourceUse.py

@@ -1,9 +1,9 @@
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, safe_parse_float
-from hestia_earth.utils.emission import emissions_in_system_boundary
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils import _omit
+from hestia_earth.models.utils.emission import background_emissions_in_system_boundary
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
 from hestia_earth.models.utils.term import get_lookup_value
@@ -54,10 +54,7 @@ def _default_value(input: dict):
 
 
 def _run_input(impact: dict):
-    required_resourceUse_term_ids = [
-        id for id in emissions_in_system_boundary(TermTermType.RESOURCEUSE)
-        if id.endswith('InputsProduction')
-    ]
+    required_resourceUse_term_ids = background_emissions_in_system_boundary(impact, TermTermType.RESOURCEUSE)
 
     def run(input: dict):
         input_term = input.get('input').get('term')
@@ -66,6 +63,10 @@ def _run_input(impact: dict):
 
         for emission_id in required_resourceUse_term_ids:
             logShouldRun(impact, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+            debugValues(impact, model=MODEL, term=emission_id,
+                        value=value,
+                        coefficient=1,
+                        input=term_id)
 
         return [
             _indicator(term_id, value, input_term) for term_id in required_resourceUse_term_ids

hestia_earth/models/hestia/landCover.py

@@ -29,6 +29,7 @@ from .utils import (
     TOTAL_AGRICULTURAL_CHANGE,
     ALL_LAND_USE_TERMS,
     crop_ipcc_land_use_category,
+    LAND_USE_NAMES_FROM_ID
 )
 from . import MODEL
 
@@ -101,7 +102,8 @@ _BUILDING_SITE_TYPES = [
 _DEFAULT_WINDOW_IN_YEARS = 20
 _DATE_TOLERANCE_IN_YEARS = 2
 _OUTPUT_SIGNIFICANT_DIGITS = 3
-_ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
+_ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE, TOTAL_CROPLAND]
+_TOP_LEVEL_LAND_USE_TYPE_IDS = {"annualCropland", "permanentCropland", "permanentPasture", "cropland"}
 _LOOKUP_EXPANSION = "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv"
 _COMPLETE_CHANGES_OTHER_LAND = {
     OTHER_LAND: 1,
@@ -214,7 +216,7 @@ def _should_group_landCover(management_node: dict):
     )
 
 
-def _get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
+def _get_changes(country_id: str, end_year: int) -> tuple[dict, list]:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
     """
@@ -250,6 +252,25 @@ def _get_ratio_start_and_end_values(
     return max(0.0, _safe_divide(numerator=expansion, denominator=end_value))
 
 
+def _get_ratio_between_land_use_types(
+    country_id: str,
+    end_year: int,
+    first_land_use_term: str,
+    second_land_use_term: str
+) -> tuple:
+    """Returns a tuple of the values of the two land use terms for the same country and year."""
+    return tuple([
+        safe_parse_float(value=extract_grouped_data(
+            get_region_lookup_value(
+                'region-faostatArea.csv', country_id, land_use_term, model=MODEL, key=MODEL_KEY
+            ),
+            str(end_year)),
+            default=None
+        )
+        for land_use_term in [first_land_use_term, second_land_use_term]
+    ])
+
+
 def _estimate_maximum_forest_change(
     forest_change: float, total_cropland_change: float, pasture_change: float, total_agricultural_change: float
 ):
@@ -384,7 +405,7 @@ def _estimate_conversions_to_permanent_cropland(
     forest_loss_to_cropland: float,
     other_land_loss_to_annual_cropland: float
 ) -> dict:
-    """Estimate percentage of land sources when converted to: Annual cropland"""
+    """Estimate percentage of land sources when converted to: Permanent cropland"""
 
     def conversion_to_permanent_cropland(factor: float):
         return _safe_divide(
@@ -642,15 +663,92 @@ def _scale_site_area_errors(site_area: dict) -> dict:
         if negative_errors and abs(negative_errors[0]) < 1 and all([v < 1 for v in site_area.values()]) else site_area
 
 
+def _new_landCover_term(new_land_use_term) -> dict:
+    return {
+        "@id": LAND_USE_TERMS_FOR_TRANSFORMATION[new_land_use_term][0],
+        "name": LAND_USE_TERMS_FOR_TRANSFORMATION[new_land_use_term][1],
+        "@type": "Term",
+        "termType": TermTermType.LANDCOVER.value
+    }
+
+
+def _scaled_value(
+    permanent_crops_value: float,
+    annual_crops_value: float,
+    permanent_crops_factor: float,
+    annual_crops_factor: float,
+):
+    total_area = permanent_crops_factor + annual_crops_factor
+    permanent_crops_scaled = permanent_crops_value * permanent_crops_factor / total_area
+    annual_crops_scaled = annual_crops_value * annual_crops_factor / total_area
+    return annual_crops_scaled + permanent_crops_scaled
+
+
+def _scale_from_annual_and_permanent_results(
+    annual_cropland_results: dict,
+    permanent_cropland_results: dict,
+    annual_cropland_factor: float,
+    permanent_cropland_factor: float
+) -> dict:
+    return {
+        land_key: _scaled_value(
+            permanent_crops_value=permanent_cropland_results[land_key],
+            annual_crops_value=land_value,
+            permanent_crops_factor=permanent_cropland_factor,
+            annual_crops_factor=annual_cropland_factor
+        )
+        for land_key, land_value in annual_cropland_results.items()
+    }
+
+
 def _should_run_historical_land_use_change(site: dict, nodes: list, land_use_type: str) -> tuple[bool, dict]:
     # Assume a single management node for single-cropping.
-    return _should_run_historical_land_use_change_single_crop(
+    return (
+        _should_run_historical_land_use_change_total_cropland(site, nodes) if land_use_type == TOTAL_CROPLAND else
+        _should_run_historical_land_use_change_single_crop(
+            site=site,
+            term=nodes[0].get("term", {}),
+            country_id=site.get("country", {}).get("@id"),
+            end_year=_get_year_from_landCover(nodes[0]),
+            land_use_type=land_use_type
+        )
+    )
+
+
+def _should_run_historical_land_use_change_total_cropland(site: dict, nodes: list) -> tuple[bool, dict]:
+    end_year = _get_year_from_landCover(nodes[0])
+    country_id = site.get("country", {}).get("@id")
+
+    # Run _should_run_historical_land_use_change_single_crop for annual and permanent
+    should_run_annual, areas_for_annual_cropland = _should_run_historical_land_use_change_single_crop(
         site=site,
-        term=nodes[0].get("term", {}),
-        country_id=site.get("country", {}).get("@id"),
-        end_year=_get_year_from_landCover(nodes[0]),
-        land_use_type=land_use_type
+        term=_new_landCover_term(ANNUAL_CROPLAND),
+        country_id=country_id,
+        end_year=end_year,
+        land_use_type=ANNUAL_CROPLAND
     )
+    should_run_permanent, areas_for_permanent_cropland = _should_run_historical_land_use_change_single_crop(
+        site=site,
+        term=_new_landCover_term(PERMANENT_CROPLAND),
+        country_id=country_id,
+        end_year=end_year,
+        land_use_type=PERMANENT_CROPLAND
+    )
+    # Get current ratios ("Arable land" vs "Permanent crops")
+    annual_cropland_factor, permanent_crops_factor = _get_ratio_between_land_use_types(
+        country_id=country_id,
+        end_year=end_year,
+        first_land_use_term=ANNUAL_CROPLAND,
+        second_land_use_term=PERMANENT_CROPLAND
+    ) if should_run_annual and should_run_permanent else tuple([0, 0])
+    scaled_results = _scale_from_annual_and_permanent_results(
+        annual_cropland_results=areas_for_annual_cropland,
+        permanent_cropland_results=areas_for_permanent_cropland,
+        annual_cropland_factor=annual_cropland_factor,
+        permanent_cropland_factor=permanent_crops_factor
+    ) if should_run_annual and should_run_permanent else {}
+    # Scale results according to current ratios.
+    return all([should_run_annual, should_run_permanent]), scaled_results
 
 
 def _should_run_historical_land_use_change_single_crop(
@@ -743,11 +841,11 @@ def _should_run_historical_land_use_change_single_crop(
 
     # Cell E8
     expansion_factor = _get_ratio_start_and_end_values(
-        expansion=changes[PERMANENT_PASTURE],
-        fao_name=PERMANENT_PASTURE,
+        expansion=changes[LAND_USE_NAMES_FROM_ID[term.get("@id")]],
+        fao_name=land_use_type,
         country_id=country_id,
         end_year=end_year
-    ) if land_use_type == PERMANENT_PASTURE else get_ratio_of_expanded_area(
+    ) if term.get("@id") in _TOP_LEVEL_LAND_USE_TYPE_IDS else get_ratio_of_expanded_area(
         country_id=country_id,
         fao_name=_get_faostat_name(term),
         end_year=end_year
@@ -774,7 +872,7 @@ def _should_run_historical_land_use_change_single_crop(
         ) if land_use_type == ANNUAL_CROPLAND else 1
     )
 
-    # E10: Compare changes to annual/perennial cropland from net expansion.
+    # E10: Compare changes to annual/permanent cropland from net expansion.
     net_expansion_cultivated_vs_harvested = _get_net_expansion_cultivated_vs_harvested(
         annual_crops_net_expansion=annual_crops_net_expansion,
         changes=changes,

hestia_earth/models/hestia/seed_emissions.py

@@ -109,10 +109,11 @@ def _map_group_emissions(group_id: str, required_emission_term_ids: list, emissi
     missing_emissions = list(filter(lambda v: v not in emission_ids, emissions))
     return {
         'group-id': group_id,
+        'is-group-in-system-boundary': group_id in required_emission_term_ids,
         'total-emissions': len(emissions),
         'included-emissions': len(included_emissions),
         'missing-emissions': '-'.join(missing_emissions),
-        'is-valid': len(emissions) == len(included_emissions)
+        'has-all-emissions': len(emissions) == len(included_emissions)
     }
 
 
@@ -140,7 +141,10 @@ def _filter_emissions(cycle: dict):
         for group_id in group_ids
     ]
     # only keep groups that have all emissions present in the Cycle
-    valid_groups = list(filter(lambda group: group.get('is-valid'), emissions_per_group))
+    valid_groups = list(filter(lambda group: all([
+        group.get('has-all-emissions'),
+        group.get('is-group-in-system-boundary')
+    ]), emissions_per_group))
     valid_group_ids = set([v.get('group-id') for v in valid_groups])
 
     # finally, only return emissions which groups are valid
@@ -283,7 +287,7 @@ def _should_run(cycle: dict):
         # log failed emissions to show in the logs
         for group in emissions_per_group:
             emission_id = group.get('group-id')
-            if not group.get('is-valid') or not should_run:
+            if not group.get('has-all-emissions') or not should_run:
                 logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY, emission_id=emission_id,
                                 **group,
                                 **_omit(seed_input, 'input'),

hestia_earth/models/hestia/utils.py

@@ -35,6 +35,7 @@ LAND_USE_TERMS_FOR_TRANSFORMATION = {
     PERMANENT_PASTURE: ("permanentPasture", "Permanent pasture"),
     OTHER_LAND: ("otherLand", OTHER_LAND)  # Not used yet
 }
+LAND_USE_NAMES_FROM_ID = {v[0]: k for k, v in LAND_USE_TERMS_FOR_TRANSFORMATION.items()} | {"cropland": TOTAL_CROPLAND}
 
 
 def crop_ipcc_land_use_category(

hestia_earth/models/hestia/waterSalinity.py

@@ -1,13 +1,12 @@
-from functools import reduce
 from hestia_earth.schema import MeasurementMethodClassification, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, list_average, non_empty_list
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.blank_node import group_by_keys
 from . import MODEL
 
 REQUIREMENTS = {
@@ -75,7 +74,7 @@ def _should_run(site: dict):
 
 def run(site: dict):
     should_run, values = _should_run(site)
-    grouped_values = reduce(group_by_keys(['start-date', 'end-date']), values, {})
+    grouped_values = group_by_keys(values, ['start-date', 'end-date'])
     return non_empty_list([
         _measurement(
             list_average([v.get('lookup-value') for v in value if v.get('lookup-value')], default=0),

hestia_earth/models/impact_assessment/emissions.py

@@ -2,6 +2,7 @@ from hestia_earth.utils.tools import list_sum
 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 _include
 from hestia_earth.models.utils.impact_assessment import get_product, convert_value_from_cycle
 from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
@@ -44,11 +45,8 @@ def _indicator(impact_assessment: dict, product: dict):
 
         if len(emission.get('inputs', [])):
             indicator['inputs'] = emission['inputs']
-        if emission.get('operation'):
-            indicator['operation'] = emission.get('operation')
-        if emission.get('transformation'):
-            indicator['transformation'] = emission.get('transformation')
-        return indicator
+
+        return indicator | _include(emission, ['animals', 'operation', 'transformation', 'country', 'key'])
     return run
 
 

hestia_earth/models/ipcc2019/biocharOrganicCarbonPerHa.py

@@ -57,12 +57,16 @@ RETURNS = {
         "statsDefinition": "simulated",
         "observations": "",
         "dates": "",
+        "depthUpper": "",
+        "depthLower": "",
         "methodClassification": "tier 1 model"
     }]
 }
 TERM_ID = 'biocharOrganicCarbonPerHa'
 
 _ITERATIONS = 1000
+_DEPTH_UPPER = 0
+_DEPTH_LOWER = 30
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
@@ -172,7 +176,7 @@ def _compile_inventory(
     cycle_data = {
         cycle.get("@id"): {
             "biochar_nodes": filter_list_term_type(cycle.get("inputs", []), TermTermType.BIOCHAR),
-            **{field: cycle.get(field) for field in COPY_FIELDS}
+            **{k: v for k in COPY_FIELDS if (v := cycle.get(k)) is not None}
         } for cycle in cycles
     }
 
@@ -201,7 +205,7 @@ def _compile_inventory(
         [
             {
                 "total_oc": total_oc.get(id, 0),
-                **{field: data.get(field) for field in COPY_FIELDS}
+                **data
             } for id, data in cycle_data.items()
         ],
         include_spillovers=True
@@ -427,9 +431,11 @@ def _measurement(
         "statsDefinition": statsDefinition,
         "observations": observations,
         "dates": dates,
+        "depthUpper": _DEPTH_UPPER,
+        "depthLower": _DEPTH_LOWER,
         "methodClassification": _METHOD_CLASSIFICATION
     }
     measurement = _new_measurement(TERM_ID, MODEL) | {
-        key: value for key, value in update_dict.items() if value
+        key: value for key, value in update_dict.items() if value is not None
     }
     return measurement

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -78,9 +78,7 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None,
-    start_date: str,
-    end_date: str
+    observations: list[int] = None
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -108,8 +106,6 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
-        "startDate": start_date,
-        "endDate": end_date,
         "methodTier": method_tier.value,
     }
     emission = _new_emission(term_id, MODEL) | {