hestia-earth-models 0.70.1__tar.gz → 0.70.2__tar.gz

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.70.1
+Version: 0.70.2
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/cml2001Baseline/resourceUseMineralsAndMetalsDuringCycle.py

@@ -6,7 +6,8 @@ from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils import _filter_list_term_unit, Units
+from hestia_earth.models.utils import _filter_list_term_unit
+from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.blank_node import _sum_nodes_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/config/Cycle.json

@@ -1759,6 +1759,51 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "ch4ToAirOrganicSoilCultivation",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "co2ToAirOrganicSoilCultivation",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "n2OToAirOrganicSoilCultivationDirect",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "ipcc2019",
@@ -2178,6 +2223,21 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "hestia",
+        "value": "pToSurfaceWaterAquacultureSystems",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
       }
     ],
     {

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/config/Site.json

@@ -400,6 +400,14 @@
       "mergeStrategy": "list",
       "stage": 1
     },
+    {
+      "key": "measurements",
+      "model": "site",
+      "value": "grouped_measurement",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     {
       "key": "measurements",
       "model": "hestia",

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/hestia/excretaKgMass.py

@@ -70,7 +70,7 @@ def _run_product(cycle: dict, product_term_id: str):
     # convert to 1kg first, then apply ratio to current value
     term = download_term(product_term_id, TermTermType.EXCRETA)
     product = {
-        'term': term,
+        'term': term or {},
         'value': [1]
     }
 

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/hestia/management.py

@@ -147,7 +147,7 @@ def _get_cycle_duration(cycle: dict, land_cover_id: str):
         land_cover_id,
         column_name('maximumCycleDuration')
     ), default=None)
-    return cycle_duration or (lookup_value - 1 if lookup_value else None)
+    return cycle_duration or lookup_value
 
 
 def _gap_filled_date_only_str(date_str: str, mode: str = DatestrGapfillMode.END) -> str:
@@ -165,11 +165,9 @@ def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> di
     """If possible, gap-fill the startDate based on the endDate - cycleDuration"""
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
-        "startDate": max(
-            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration)
-            if cycle_duration else datetime.fromtimestamp(0),
-            _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START)
-            if cycle.get("startDate") else datetime.fromtimestamp(0)
+        "startDate": (
+            _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START) if cycle.get("startDate") else
+            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration - 1)
         )
     } if any([cycle_duration, cycle.get("startDate")]) else {}
 

hestia_earth_models-0.70.2/hestia_earth/models/hestia/pToSurfaceWaterAquacultureSystems.py

@@ -0,0 +1,148 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils import _filter_list_term_unit
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.constant import Units, convert_to_unit, get_atomic_conversion
+from hestia_earth.models.utils.product import convert_product_to_unit
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalFeed": "True",
+        "completeness.product": "True",
+        "completeness.fertiliser": "True",
+        "completeness.liveAnimalInput": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "term.termType": [
+                    "crop",
+                    "liveAnimal",
+                    "liveAquaticSpecies",
+                    "animalProduct",
+                    "processedFood",
+                    "feedFoodAdditive",
+                    "organicFertiliser",
+                    "forage",
+                    "excreta",
+                    "waste"
+                ],
+                "optional": {
+                    "properties": [
+                        {"@type": "Property", "value": "", "term.@id": "phosphorusContentAsP"},
+                        {"@type": "Property", "value": "", "term.@id": "phosphateContentAsP2O5"}
+                    ]
+                }
+            },
+            {
+                "@type": "Input",
+                "term.termType": "inorganicFertiliser",
+                "term.units": "kg P2O5"
+            }
+        ],
+        "products": [{
+            "@type": "Product",
+            "term.termType": ["liveAquaticSpecies", "liveAnimal", "animalProduct", "crop"],
+            "optional": {
+                "properties": [
+                    {"@type": "Property", "value": "", "term.@id": "phosphorusContentAsP"},
+                    {"@type": "Property", "value": "", "term.@id": "phosphateContentAsP2O5"}
+                ]
+            }
+        }]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+TERM_ID = 'pToSurfaceWaterAquacultureSystems'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _convert_to_P(blank_node: dict):
+    return {
+        'id': blank_node.get('term', {}).get('@id'),
+        'value': list_sum(blank_node.get('value'), default=None),
+        'value-converted': (
+            convert_product_to_unit(blank_node, Units.KG_P) or
+            convert_product_to_unit(blank_node, Units.KG_P2O5) / get_atomic_conversion(Units.KG_P2O5, Units.KG_P) or
+            convert_to_unit(blank_node, Units.KG_P)
+        )
+    }
+
+
+def _run(cycle: dict):
+    inputs = filter_list_term_type(cycle.get('inputs', []), [
+        TermTermType.CROP,
+        TermTermType.LIVEANIMAL,
+        TermTermType.LIVEAQUATICSPECIES,
+        TermTermType.ANIMALPRODUCT,
+        TermTermType.PROCESSEDFOOD,
+        TermTermType.FEEDFOODADDITIVE,
+        TermTermType.ORGANICFERTILISER,
+        TermTermType.FORAGE,
+        TermTermType.EXCRETA,
+        TermTermType.WASTE,
+    ]) + _filter_list_term_unit(filter_list_term_type(cycle.get('inputs', []), [
+        TermTermType.INORGANICFERTILISER
+    ]), Units.KG_P2O5)
+    inputs_P = list(map(_convert_to_P, inputs))
+    total_inputs_P = list_sum(non_empty_list([i.get('value-converted', 0) for i in inputs_P]))
+
+    products = filter_list_term_type(cycle.get('products', []), [
+        TermTermType.CROP,
+        TermTermType.LIVEANIMAL,
+        TermTermType.LIVEAQUATICSPECIES,
+        TermTermType.ANIMALPRODUCT
+    ])
+    products_P = list(map(_convert_to_P, products))
+    total_products_P = list_sum(non_empty_list([i.get('value-converted', 0) for i in products_P]))
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                inputs_P=log_as_table(inputs_P),
+                products_P=log_as_table(products_P))
+
+    return [_emission(total_inputs_P - total_products_P)]
+
+
+def _should_run(cycle: dict):
+    is_animalFeed_complete = _is_term_type_complete(cycle, 'animalFeed')
+    is_product_complete = _is_term_type_complete(cycle, 'product')
+    is_fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
+    is_liveAnimalInput_complete = _is_term_type_complete(cycle, 'liveAnimalInput')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_term_type_animalFeed_complete=is_animalFeed_complete,
+                    is_term_type_product_complete=is_product_complete,
+                    is_term_type_fertiliser_complete=is_fertiliser_complete,
+                    is_term_type_liveAnimalInput_complete=is_liveAnimalInput_complete)
+
+    should_run = all([
+        is_animalFeed_complete,
+        is_product_complete,
+        is_fertiliser_complete,
+        is_liveAnimalInput_complete
+    ])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/hestia/soilMeasurement.py

@@ -32,7 +32,7 @@ STANDARD_DEPTHS = {(0, 30), (0, 50)}
 
 
 def _measurement(value: float, date: str, term_id: str, standard_fields: dict):
-    data = _new_measurement(term_id)
+    data = _new_measurement(term_id, MODEL)
     data["value"] = [value]
     data["depthUpper"] = standard_fields["depthUpper"]
     data["depthLower"] = standard_fields["depthLower"]

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/ipcc2019/ch4ToAirFloodedRice.py

@@ -16,8 +16,10 @@ REQUIREMENTS = {
     "Cycle": {
         "practices": [
             {"@type": "Practice", "value": "", "term.@id": "croppingDuration"},
-            {"@type": "Practice", "value": "", "term.termType": ["landUseManagement", "waterRegime"]}
+            {"@type": "Practice", "value": "", "term.termType": ["landUseManagement", "waterRegime"]},
+            {"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}
         ],
+        "products": [{"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"}],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"}
@@ -31,9 +33,7 @@ REQUIREMENTS = {
                     "term.termType": "fertiliserBrandName",
                     "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
                 }
-            ],
-            "products": [{"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"}],
-            "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}]
+            ]
         }
     }
 }
@@ -160,8 +160,10 @@ def _get_fertiliser_value(cycle: dict, suffix: str = 'value'):
 def _calculate_SFo(cycle: dict, suffix: str = 'value'):
     cropResidue = _get_cropResidue_value(cycle, suffix)
     fertiliser = _get_fertiliser_value(cycle, suffix)
-
-    return (1 + (fertiliser/1000) + (cropResidue/1000)) ** 0.59
+    return (1 + (fertiliser/1000) + (cropResidue/1000)) ** 0.59 if all([
+        fertiliser is not None,
+        cropResidue is not None
+    ]) else None
 
 
 def _get_practice_values(practice: dict, col: str, default=None):

hestia_earth_models-0.70.2/hestia_earth/models/ipcc2019/ch4ToAirOrganicSoilCultivation.py

@@ -0,0 +1,270 @@
+import numpy as np
+import numpy.typing as npt
+from typing import Callable, Union
+
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.array_builders import (
+    discrete_uniform_1d, gen_seed, normal_1d, repeat_single, triangular_1d
+)
+from hestia_earth.models.utils.cycle import land_occupation_per_ha
+from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
+from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.measurement import most_relevant_measurement_value
+from hestia_earth.models.utils.site import valid_site_type
+
+from .organicSoilCultivation_utils import (
+    assign_ditch_category, assign_organic_soil_category, calc_emission, DitchCategory, get_ditch_frac,
+    get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
+)
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": [
+            {
+                "cycleDuration": "",
+                "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
+            },
+            {
+                "@doc": "for plantations, additional properties are required",
+                "practices": [
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDuration"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationProductiveLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "rotationDuration"}
+                ]
+            }
+        ],
+        "site": {
+            "@type": "Site",
+            "measurements": [
+                {"@type": "Measurement", "value": "", "term.@id": "histosol"},
+                {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+            ]
+        },
+        "optional": {
+            "cycleDuration": ""
+        }
+    }
+}
+LOOKUPS = {
+    "crop": [
+        "isPlantation",
+        "IPCC_2013_ORGANIC_SOIL_CULTIVATION_CATEGORY"
+    ],
+    "forage": [
+        "isPlantation",
+        "IPCC_2013_ORGANIC_SOIL_CULTIVATION_CATEGORY"
+    ],
+    "ecoClimateZone": [
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_ANNUAL_CROPS",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_PERENNIAL_CROPS",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_ACACIA",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_OIL_PALM",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_SAGO_PALM",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_PADDY_RICE_CULTIVATION",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_GRASSLAND",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_DITCH",
+        "IPCC_2013_ORGANIC_SOILS_TONNES_CH4_HECTARE_OTHER",
+        "IPCC_2013_DRAINED_ORGANIC_SOILS_DITCH_FRAC_AGRICULTURAL_LAND",
+        "IPCC_2013_DRAINED_ORGANIC_SOILS_DITCH_FRAC_NETHERLANDS"
+    ]
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "observations": "",
+        "statsDefinition": "simulated",
+        "methodTier": "tier 1"
+    }]
+}
+TERM_ID = 'ch4ToAirOrganicSoilCultivation'
+TIER = EmissionMethodTier.TIER_1.value
+
+_STATS_DEFINITION = EmissionStatsDefinition.SIMULATED.value
+_ITERATIONS = 100000
+
+_CATEGORY_REMAPPER = {
+    OrganicSoilCategory.ACACIA: OrganicSoilCategory.PERENNIAL_CROPS
+}
+
+
+def _emission(descriptive_stats: dict):
+    emission = _new_emission(TERM_ID, MODEL) | descriptive_stats
+    emission['methodTier'] = TIER
+    return emission
+
+
+def sample_emission_factor(
+    eco_climate_zone: EcoClimateZone,
+    organic_soil_category: OrganicSoilCategory,
+    seed: Union[int, np.random.Generator, None] = None,
+) -> npt.NDArray:
+    category = remap_categories(organic_soil_category, _CATEGORY_REMAPPER)  # fewer categories than CO2 model
+    factor_data = get_emission_factor(TERM_ID, eco_climate_zone, category)
+    sample_func = _get_sample_func(factor_data)
+    return sample_func(iterations=_ITERATIONS, seed=seed, **factor_data)
+
+
+def sample_ditch_frac(
+    eco_climate_zone: EcoClimateZone,
+    ditch_category: DitchCategory,
+    seed: Union[int, np.random.Generator, None] = None,
+) -> npt.NDArray:
+    factor_data = get_ditch_frac(eco_climate_zone, ditch_category, term=TERM_ID)
+    sample_func = _get_sample_func(factor_data)
+    return sample_func(iterations=_ITERATIONS, seed=seed, **factor_data)
+
+
+def _sample_normal(
+    *, iterations: int, value: float, sd: float, seed: Union[int, np.random.Generator, None] = None, **_
+) -> npt.NDArray:
+    return normal_1d(shape=(1, iterations), mu=value, sigma=sd, seed=seed)
+
+
+def _sample_uniform(
+    *, iterations: int, min: float, max: float, seed: Union[int, np.random.Generator, None] = None, **_
+) -> npt.NDArray:
+    return discrete_uniform_1d(shape=(1, iterations), low=min, high=max, seed=seed)
+
+
+def _sample_triangular(
+    *, iterations: int, value: float, min: float, max: float, seed: Union[int, np.random.Generator, None] = None, **_
+) -> npt.NDArray:
+    return triangular_1d(shape=(1, iterations), mode=value, low=min, high=max, seed=seed)
+
+
+def _sample_constant(*, value: float, **_) -> npt.NDArray:
+    """Sample a constant model parameter."""
+    return repeat_single(shape=(1, 1), value=value)
+
+
+_KWARGS_TO_SAMPLE_FUNC = {
+    ("value", "sd"): _sample_normal,
+    ("value", "min", "max"): _sample_triangular,
+    ("min", "max"): _sample_uniform,
+    ("value",): _sample_constant
+}
+"""
+Mapping from available distribution data to sample function.
+"""
+
+
+def _get_sample_func(kwargs: dict) -> Callable:
+    """
+    Select the correct sample function for a parameter based on the distribution data available. All possible
+    parameters for the model should have, at a minimum, a `value`, meaning that no default function needs to be
+    specified.
+
+    This function has been extracted into it's own method to allow for mocking of sample function.
+
+    Keyword Args
+    ------------
+    value : float
+        The distribution mean.
+    sd : float
+        The standard deviation of the distribution.
+    se : float
+        The standard error of the distribution.
+    n : float
+        Sample size.
+
+    Returns
+    -------
+    Callable
+        The sample function for the distribution.
+    """
+    return next(
+        sample_func for required_kwargs, sample_func in _KWARGS_TO_SAMPLE_FUNC.items()
+        if all(kwarg in kwargs.keys() for kwarg in required_kwargs)
+    )
+
+
+def _should_run(cycle: dict):
+    end_date = cycle.get('endDate')
+    site = cycle.get('site', {})
+    measurements = site.get('measurements', [])
+
+    seed = gen_seed(cycle, MODEL, TERM_ID)
+    rng = np.random.default_rng(seed)
+
+    def _get_measurement_content(term_id: str):
+        return most_relevant_measurement_value(measurements, term_id, end_date)
+
+    histosol = _get_measurement_content('histosol')
+    eco_climate_zone = get_eco_climate_zone_value(cycle, as_enum=True)
+    organic_soil_category = assign_organic_soil_category(cycle, log_id=TERM_ID)
+    ditch_category = assign_ditch_category(cycle)
+
+    emission_factor = (
+        sample_emission_factor(eco_climate_zone, organic_soil_category, seed=rng) if eco_climate_zone
+        else None
+    )
+    ditch_factor = (
+        sample_emission_factor(eco_climate_zone, OrganicSoilCategory.DITCH, seed=rng) if eco_climate_zone
+        else None
+    )
+    ditch_frac = (
+        sample_ditch_frac(eco_climate_zone, ditch_category, seed=rng) if eco_climate_zone
+        else None
+    )
+
+    land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
+
+    logRequirements(
+        cycle, model=MODEL, term=TERM_ID,
+        eco_climate_zone=eco_climate_zone,
+        organic_soil_category=organic_soil_category,
+        ditch_category=ditch_category,
+        emission_factor=f"{np.mean(emission_factor):.3f}",
+        ditch_factor=f"{np.mean(ditch_factor):.3f}",
+        ditch_frac=f"{np.mean(ditch_frac):.3f}",
+        land_occupation=land_occupation,
+        histosol=histosol
+    )
+
+    should_run = all([
+        valid_site_type(site),
+        valid_eco_climate_zone(eco_climate_zone),
+        all(
+            var is not None for var in [
+                emission_factor,
+                ditch_factor,
+                ditch_frac,
+                land_occupation,
+                histosol
+            ]
+        )
+    ])
+
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+
+    return should_run, emission_factor, ditch_factor, ditch_frac, histosol, land_occupation
+
+
+def _run(
+    emission_factor: npt.NDArray,
+    ditch_factor: npt.NDArray,
+    ditch_frac: npt.NDArray,
+    histosol: float,
+    land_occupation: float
+):
+    land_emission = calc_emission(TERM_ID, emission_factor, histosol, land_occupation)
+    ditch_emission = calc_emission(TERM_ID, ditch_factor, histosol, land_occupation)
+
+    result = (ditch_emission * ditch_frac) + (land_emission * (1 - ditch_frac))
+    descriptive_stats = calc_descriptive_stats(result, _STATS_DEFINITION)
+    return [_emission(descriptive_stats)]
+
+
+def run(cycle: dict):
+    should_run, *args = _should_run(cycle)
+    return _run(*args) if should_run else []

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -186,13 +186,11 @@ def _should_compile_inventory_func(
         ) for cycle in cycles
     )
 
-    has_stock_measurements = len(carbon_stock_measurements) > 0
     has_cycles = len(cycles) > 0
     has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
 
     should_run = all([
         has_soil,
-        has_stock_measurements,
         has_cycles,
         has_functional_unit_1_ha
     ])
@@ -201,7 +199,6 @@ def _should_compile_inventory_func(
         "site_type": site_type,
         "has_soil": has_soil,
         "carbon_stock_term": _CARBON_STOCK_TERM_ID,
-        "has_stock_measurements": has_stock_measurements,
         "has_cycles": has_cycles,
         "has_functional_unit_1_ha": has_functional_unit_1_ha,
     }

{hestia_earth_models-0.70.1 → hestia_earth_models-0.70.2}/hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -199,13 +199,11 @@ def _should_compile_inventory_func(
         ) for cycle in cycles
     )
 
-    has_stock_measurements = len(carbon_stock_measurements) > 0
     has_cycles = len(cycles) > 0
     has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
 
     should_run = all([
         has_soil,
-        has_stock_measurements,
         has_cycles,
         has_functional_unit_1_ha
     ])
@@ -214,7 +212,6 @@ def _should_compile_inventory_func(
         "site_type": site_type,
         "has_soil": has_soil,
         "carbon_stock_term": _CARBON_STOCK_TERM_ID,
-        "has_stock_measurements": has_stock_measurements,
         "has_cycles": has_cycles,
         "has_functional_unit_1_ha": has_functional_unit_1_ha,
     }