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

hestia_earth/models/ipcc2019/ch4ToAirFloodedRice.py

@@ -1,8 +1,10 @@
+from functools import reduce
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
-from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
+from hestia_earth.models.utils import multiply_values
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.product import has_flooded_rice
@@ -12,48 +14,54 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [{"@type": "Practice", "value": "", "term.@id": "croppingDuration"}],
+        "practices": [
+            {"@type": "Practice", "value": "", "term.@id": "croppingDuration"},
+            {"@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"}
         },
         "optional": {
             "inputs": [
-                {
-                    "@type": "Input",
-                    "value": "",
-                    "term.termType": "organicFertiliser"
-                },
+                {"@type": "Input", "value": "", "term.termType": "organicFertiliser"},
                 {
                     "@type": "Input",
                     "value": "",
                     "term.termType": "fertiliserBrandName",
                     "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
                 }
-            ],
-            "products": [{"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"}],
-            "practices": [
-                {"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"},
-                {"@type": "Practice", "value": "", "term.termType": "landUseManagement"},
-                {"@type": "Practice", "value": "", "term.termType": "waterRegime"}
             ]
         }
     }
 }
 LOOKUPS = {
     "landUseManagement": [
-        "IPCC_2019_CH4_rice_SFw", "IPCC_2019_CH4_rice_SFw-min", "IPCC_2019_CH4_rice_SFw-max",
-        "IPCC_2019_CH4_rice_SFw-sd",
-        "IPCC_2019_CH4_rice_SFp", "IPCC_2019_CH4_rice_SFp-min", "IPCC_2019_CH4_rice_SFp-max",
+        "IPCC_2019_CH4_rice_SFp",
+        "IPCC_2019_CH4_rice_SFp-min",
+        "IPCC_2019_CH4_rice_SFp-max",
         "IPCC_2019_CH4_rice_SFp-sd"
     ],
     "waterRegime": [
-        "IPCC_2019_CH4_rice_SFw", "IPCC_2019_CH4_rice_SFw-min", "IPCC_2019_CH4_rice_SFw-max",
-        "IPCC_2019_CH4_rice_SFw-sd",
-        "IPCC_2019_CH4_rice_SFp", "IPCC_2019_CH4_rice_SFp-min", "IPCC_2019_CH4_rice_SFp-max",
-        "IPCC_2019_CH4_rice_SFp-sd"
+        "IPCC_2019_CH4_rice_SFw",
+        "IPCC_2019_CH4_rice_SFw-min",
+        "IPCC_2019_CH4_rice_SFw-max",
+        "IPCC_2019_CH4_rice_SFw-sd"
+    ],
+    "organicFertiliser": [
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_min",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_max",
+        "IPCC_2019_CH4_rice_CFOA_kg_fresh_weight_sd"
+    ],
+    "cropResidueManagement": [
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_min",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_max",
+        "IPCC_2019_CH4_rice_CFOA_kg_dry_weight_sd"
     ],
-    "organicFertiliser": ["IPCC_2019_CH4_rice_CFOA_kg_fresh_weight", "IPCC_2019_CH4_rice_CFOA_kg_dry_weight"],
     "region-ch4ef-IPCC2019": ["CH4_ef", "CH4_ef_min", "CH4_ef_max", "CH4_ef_sd"]
 }
 RETURNS = {
@@ -68,92 +76,140 @@ RETURNS = {
 }
 TERM_ID = 'ch4ToAirFloodedRice'
 TIER = EmissionMethodTier.TIER_1.value
+_STATS = ['value', 'min', 'max', 'sd']
 
 
 def _emission(value: float, min: float, max: float, sd: float):
     emission = _new_emission(TERM_ID, MODEL)
     emission['value'] = [value]
-    emission['min'] = [min]
-    emission['max'] = [max]
-    emission['sd'] = [sd]
+    if min is not None:
+        emission['min'] = [min]
+    if max is not None:
+        emission['max'] = [max]
+    if sd is not None:
+        emission['sd'] = [sd]
     emission['methodTier'] = TIER
     emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
     return emission
 
 
-def _get_CH4_ef(country: str, suffix: str = ''):
+def _get_CH4_ef(country: str, suffix: str = 'value'):
     lookup_name = 'region-ch4ef-IPCC2019.csv'
+    lookup = 'CH4_ef'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     return safe_parse_float(
-        get_region_lookup_value(lookup_name, country, 'CH4_ef' + suffix, model=MODEL, term=TERM_ID)
+        get_region_lookup_value(lookup_name, country, lookup, model=MODEL, term=TERM_ID),
+        default=None
     )
 
 
-def _get_practice_lookup(term: dict, col: str):
-    return safe_parse_float(get_lookup_value(term, col, model=MODEL, term=TERM_ID))
-
-
-def _get_cropResidue_value(cycle: dict, suffix: str = ''):
+def _get_cropResidue_value(cycle: dict, suffix: str = 'value'):
+    product_id = 'aboveGroundCropResidueIncorporated'
     abgIncorporated = list_sum(
-        find_term_match(cycle.get('products', []), 'aboveGroundCropResidueIncorporated').get('value', [])
+        find_term_match(cycle.get('products', []), product_id).get('value', []),
+        default=None
     )
     abgManagement = filter_list_term_type(cycle.get('practices', []), TermTermType.CROPRESIDUEMANAGEMENT)
     term = abgManagement[0].get('term', {}) if len(abgManagement) > 0 else None
+    lookup = 'IPCC_2019_CH4_rice_CFOA_kg_dry_weight'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     factor = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['organicFertiliser'][1] + suffix, model=MODEL, term=TERM_ID)
-    ) if term else 0
-    return abgIncorporated * factor
+        get_lookup_value(term, lookup, model=MODEL, term=TERM_ID),
+        default=None
+    ) if term else None
 
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{'cropResidue_' + suffix: log_as_table({
+                    'product-id': product_id,
+                    'product-value': abgIncorporated,
+                    'factor': factor
+                })})
 
-def _get_fertiliser_value(input: dict, suffix: str = ''):
+    return multiply_values([abgIncorporated, factor])
+
+
+def _get_fertiliser_values(input: dict, suffix: str = 'value'):
     term = input.get('term', {})
+    lookup = 'IPCC_2019_CH4_rice_CFOA_kg_fresh_weight'
+    lookup = '_'.join([lookup, suffix]) if suffix != 'value' else lookup
     factor = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['organicFertiliser'][0] + suffix, model=MODEL, term=TERM_ID)
+        get_lookup_value(term, lookup, model=MODEL, term=TERM_ID),
+        default=None
     )
-    return list_sum(input.get('value', [])) * factor
+    value = list_sum(input.get('value', []))
+    return {'input-id': term.get('@id'), 'input-value': value, 'factor': factor}
 
 
-def _calculate_SFo(cycle: dict, suffix: str = ''):
-    cropResidue = _get_cropResidue_value(cycle, suffix)
-    fertilisers = get_organicFertiliser_inputs(cycle)
-    fert_value = list_sum([_get_fertiliser_value(i, suffix) for i in fertilisers])
-    return (1 + (fert_value/1000) + (cropResidue/1000)) ** 0.59
+def _get_fertiliser_value(cycle: dict, suffix: str = 'value'):
+    fertiliser_values = [_get_fertiliser_values(i, suffix) for i in get_organicFertiliser_inputs(cycle)]
 
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{'fertiliser_' + suffix: log_as_table(fertiliser_values)})
 
-def _calculate_SF_average(practices: list, factor: str):
-    values = [
-        (_get_practice_lookup(p.get('term', {}), factor), list_sum(p.get('value', []), None)) for p in practices
+    valid_fertiliser_values = [
+        value for value in fertiliser_values
+        if all([value.get('input-value') is not None, value.get('factor') is not None])
     ]
-    # sum only values that are numbers
-    return list_sum([factor * percent / 100 for factor, percent in values if percent is not None])
+    fert_value = list_sum([
+        value.get('input-value') * value.get('factor')
+        for value in valid_fertiliser_values
+    ])
+    return fert_value
 
 
-def _calculate_factor(cycle: dict, country: str, practices: list, suffix: str = ''):
-    CH4_ef = _get_CH4_ef(country, suffix)
-    SFw = _calculate_SF_average(practices, 'IPCC_2019_CH4_rice_SFw' + suffix)
-    SFp = _calculate_SF_average(practices, 'IPCC_2019_CH4_rice_SFp' + suffix)
-    SFo = _calculate_SFo(cycle, suffix)
-    debugValues(cycle, model=MODEL, term=TERM_ID, **{
-        'CH4_ef' + suffix: CH4_ef,
-        'SFw' + suffix: SFw,
-        'SFp' + suffix: SFp,
-        'SFo' + suffix: SFo
-    })
-    return CH4_ef * (SFw if SFw > 0 else 1) * (SFp if SFp > 0 else 1) * SFo
+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 if all([
+        fertiliser is not None,
+        cropResidue is not None
+    ]) else None
 
 
-def _get_croppingDuration(croppingDuration: dict, key: str = 'value'):
-    return list_sum(croppingDuration.get(key, croppingDuration.get('value', [])))
+def _get_practice_values(practice: dict, col: str, default=None):
+    term = practice.get('term', {})
+    factor = safe_parse_float(get_lookup_value(term, col, model=MODEL, term=TERM_ID), default)
+    return {
+        'practice-id': term.get('@id'),
+        'factor': factor,
+        'practice-value': list_sum(practice.get('value', []), default=default)
+    } if factor is not None else None
 
 
-def _run(cycle: dict, croppingDuration: dict, country: str):
-    practices = filter_list_term_type(cycle.get('practices', []), [
-        TermTermType.WATERREGIME, TermTermType.LANDUSEMANAGEMENT
-    ])
+def _calculate_SF_total(cycle: dict, practices: list, lookup: str, suffix: str = 'value', default=None):
+    lookup_column = '-'.join([lookup, suffix]) if suffix != 'value' else lookup
+    values = non_empty_list([_get_practice_values(p, lookup_column) for p in practices])
 
-    value = _calculate_factor(cycle, country, practices) * _get_croppingDuration(croppingDuration)
-    min = _calculate_factor(cycle, country, practices, '_min') * _get_croppingDuration(croppingDuration, 'min')
-    max = _calculate_factor(cycle, country, practices, '_max') * _get_croppingDuration(croppingDuration, 'max')
-    sd = (max-min)/4
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                **{lookup_column: log_as_table(values)})
+
+    used_values = [value for value in values if value.get('practice-value') is not None]
+
+    # sum only values that are numbers
+    return (
+        list_sum([
+            value.get('factor') * value.get('practice-value') for value in used_values
+        ], default=None) / list_sum([
+            value.get('practice-value') for value in used_values
+        ])
+    ) if used_values else (
+        default if suffix == 'value' else None
+    )
+
+
+def _value_from_factors(values: list, key: str = 'value'):
+    # get the value from all factors, and only run if all are provided
+    all_values = [value.get(key) for value in values]
+    return multiply_values(all_values) if all([v is not None for v in all_values]) else None
+
+
+def _run(values: list):
+    value = _value_from_factors(values, 'value')
+    min = _value_from_factors(values, 'min')
+    max = _value_from_factors(values, 'max')
+    sd = _value_from_factors(values, 'sd')
+
+    sd = (max-min)/4 if all([max, min]) else None
 
     return [_emission(value, min, max, sd)]
 
@@ -162,20 +218,51 @@ def _should_run(cycle: dict):
     country = cycle.get('site', {}).get('country', {}).get('@id')
 
     flooded_rice = has_flooded_rice(cycle.get('products', []))
+    practices = cycle.get('practices', [])
 
-    croppingDuration = find_term_match(cycle.get('practices', []), 'croppingDuration', None)
+    croppingDuration = find_term_match(practices, 'croppingDuration', None)
     has_croppingDuration = croppingDuration is not None
+    croppingDuration = reduce(lambda p, key: p | {
+        key: list_sum(croppingDuration.get(key) or [], default=None)
+    }, _STATS, {}) if has_croppingDuration else {}
+
+    CH4_ef = reduce(lambda p, key: p | {key: _get_CH4_ef(country, key)}, _STATS, {})
+    SFo = reduce(lambda p, key: p | {key: _calculate_SFo(cycle, key)}, _STATS, {})
+
+    water_regime = filter_list_term_type(practices, TermTermType.WATERREGIME)
+    SFw = reduce(lambda p, key: p | {
+        key: _calculate_SF_total(cycle, water_regime, 'IPCC_2019_CH4_rice_SFw', key)
+    }, _STATS, {})
+
+    land_use_management = filter_list_term_type(practices, TermTermType.LANDUSEMANAGEMENT)
+    SFp = reduce(lambda p, key: p | {
+        key: _calculate_SF_total(cycle, land_use_management, 'IPCC_2019_CH4_rice_SFp', key, default=1)
+    }, _STATS, {})
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     has_flooded_rice=flooded_rice,
-                    has_croppingDuration=has_croppingDuration,
-                    country=country)
-
-    should_run = all([flooded_rice, has_croppingDuration, country])
+                    country=country,
+                    values=log_as_table([
+                        {'name': 'croppingDuration'} | croppingDuration,
+                        {'name': 'CH4-ef'} | CH4_ef,
+                        {'name': 'SFo'} | SFo,
+                        {'name': 'SFw'} | SFw,
+                        {'name': 'SFp'} | SFp,
+                    ]))
+
+    should_run = all([
+        flooded_rice,
+        has_croppingDuration,
+        country,
+        CH4_ef.get('value') is not None,
+        SFo.get('value') is not None,
+        SFw.get('value') is not None,
+        SFp.get('value') is not None,
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, croppingDuration, country
+    return should_run, [croppingDuration, CH4_ef, SFo, SFw, SFp]
 
 
 def run(cycle: dict):
-    should_run, croppingDuration, country = _should_run(cycle)
-    return _run(cycle, croppingDuration, country) if should_run else []
+    should_run, values = _should_run(cycle)
+    return _run(values) if should_run else []

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