hestia-earth-models 0.70.1__py3-none-any.whl → 0.70.2__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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,
     }