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

hestia_earth/models/{site → hestia}/waterDepth.py

@@ -25,7 +25,7 @@ SITE_TYPE_TO_DEPTH = {
 
 
 def _measurement(site: dict, value: float):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data | get_source(site, BIBLIO_TITLE)

hestia_earth/models/hestia/waterSalinity.py

@@ -0,0 +1,78 @@
+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
+
+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.blank_node import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "related": {
+            "Cycle": {
+                "@type": "Cycle",
+                "products": [{
+                    "@type": "Product",
+                    "primary": "True",
+                    "term.termType": "liveAquaticSpecies"
+                }]
+            }
+        }
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "",
+        "startDate": "",
+        "endDate": "",
+        "methodClassification": "expert opinion"
+    }]
+}
+LOOKUPS = {
+    "liveAquaticSpecies": "defaultSalinity"
+}
+TERM_ID = 'waterSalinity'
+
+
+def _measurement(value: float, start_date: str = None, end_date: str = None):
+    data = _new_measurement(TERM_ID, MODEL)
+    data['value'] = [value]
+    data['endDate'] = end_date
+    if start_date:
+        data['startDate'] = start_date
+    data['methodClassification'] = MeasurementMethodClassification.EXPERT_OPINION.value
+    return data
+
+
+def _should_run(site: dict):
+    cycles = related_cycles(site)
+    relevant_products = [
+        {
+            'product-id': product.get('term', {}).get('@id'),
+            'lookup-value': safe_parse_float(
+                get_lookup_value(product.get('term', {}), LOOKUPS['liveAquaticSpecies']), default=None
+            ),
+            'start-date': product.get('startDate') or cycle.get('startDate'),
+            'end-date': product.get('endDate') or cycle.get('endDate')
+        }
+        for cycle in cycles
+        for product in filter_list_term_type(cycle.get('products', []), TermTermType.LIVEAQUATICSPECIES)
+    ]
+    has_valid_products = any([product.get('lookup-value') for product in relevant_products])
+
+    logRequirements(site, model=MODEL, term=TERM_ID,
+                    live_aquatic_products=log_as_table(relevant_products))
+
+    should_run = all([has_valid_products])
+    logShouldRun(site, MODEL, TERM_ID, should_run)
+    return should_run, relevant_products
+
+
+def run(site: dict):
+    should_run, values = _should_run(site)
+    return [
+        _measurement(value.get('lookup-value'), value.get('start-date'), value.get('end-date'))
+        for value in values if value.get('lookup-value') is not None
+    ] if should_run else []

hestia_earth/models/impact_assessment/emissions.py

@@ -8,7 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "product": {"@type": "Product", "term": {"@type": "Term"}},
+        "product": {"@type": "Product"},
         "cycle": {
             "@type": "Cycle",
             "products": [{

hestia_earth/models/impact_assessment/product/economicValueShare.py

@@ -4,7 +4,7 @@ from .. import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "product": {"@type": "Product", "term": {"@type": "Term"}, "none": {"economicValueShare": ""}},
+        "product": {"@type": "Product", "none": {"economicValueShare": ""}},
         "cycle": {
             "@type": "Cycle",
             "products": [{"@type": "Product", "economicValueShare": ""}]

hestia_earth/models/impact_assessment/product/value.py

@@ -4,7 +4,7 @@ from .. import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "product": {"@type": "Product", "term": {"@type": "Term"}, "none": {"value": ""}},
+        "product": {"@type": "Product", "none": {"value": ""}},
         "cycle": {
             "@type": "Cycle",
             "products": [{"@type": "Product", "value": ""}]

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -568,7 +568,7 @@ def _measurement(
         "dates": [f"{year}-12-31" for year in timestamps],
         "methodClassification": _METHOD_CLASSIFICATION
     }
-    measurement = _new_measurement(TERM_ID) | {
+    measurement = _new_measurement(TERM_ID, MODEL) | {
         key: value for key, value in update_dict.items() if value
     }
     return measurement

hestia_earth/models/ipcc2019/animal/fatContent.py

@@ -9,10 +9,10 @@ REQUIREMENTS = {
         "animals": [{
             "@type": "Animal",
             "term.termType": "liveAnimal",
-            "practices": {
+            "practices": [{
                 "@type": "Practice",
                 "term.termType": "animalManagement"
-            }
+            }]
         }]
     }
 }

hestia_earth/models/ipcc2019/animal/milkYieldPerAnimal.py

@@ -13,10 +13,10 @@ REQUIREMENTS = {
         "animals": [{
             "@type": "Animal",
             "term.termType": "liveAnimal",
-            "practices": {
+            "practices": [{
                 "@type": "Practice",
                 "term.termType": "animalManagement"
-            }
+            }]
         }]
     }
 }

hestia_earth/models/ipcc2019/animal/trueProteinContent.py

@@ -9,10 +9,10 @@ REQUIREMENTS = {
         "animals": [{
             "@type": "Animal",
             "term.termType": "liveAnimal",
-            "practices": {
+            "practices": [{
                 "@type": "Practice",
                 "term.termType": "animalManagement"
-            }
+            }]
         }]
     }
 }

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -551,7 +551,7 @@ def _measurement(
         "dates": [f"{year}-12-31" for year in timestamps],
         "methodClassification": _METHOD_CLASSIFICATION
     }
-    measurement = _new_measurement(TERM_ID) | {
+    measurement = _new_measurement(TERM_ID, MODEL) | {
         key: value for key, value in update_dict.items() if value
     }
     measurement["depthUpper"] = _DEPTH_UPPER

hestia_earth/models/ipcc2019/biomass_utils.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from functools import reduce
 from math import isclose
-from numpy import random
+from numpy import inf, random
 from numpy.typing import NDArray
 from typing import Callable, Optional, Union
 
@@ -393,9 +393,7 @@ def sample_plus_minus_error(
 ) -> NDArray:
     """Randomly sample a model parameter with a truncated normal distribution described using plus/minus error."""
     sd = value * (error / 200)
-    low = value - (value * (error / 100))
-    high = value + (value * (error / 100))
-    return truncated_normal_1d(shape=(1, iterations), mu=value, sigma=sd, low=low, high=high, seed=seed)
+    return truncated_normal_1d(shape=(1, iterations), mu=value, sigma=sd, low=0, high=inf, seed=seed)
 
 
 def sample_constant(*, iterations: int, value: float, **_) -> NDArray:

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -5,6 +5,7 @@ from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import debugMissingLookup, debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import get_total_value_converted_with_min_ratio
+from hestia_earth.models.utils.term import get_ionophore_terms
 from hestia_earth.models.utils.input import get_feed_inputs
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.liveAnimal import get_default_digestibility
@@ -48,7 +49,10 @@ REQUIREMENTS = {
                     }
                 }]
             }
-        ]
+        ],
+        "optional": {
+            "inputs": [{"@type": "Input", "term.@id": ["ionophores", "ionophoreAntibiotics"]}]
+        }
     }
 }
 LOOKUPS = {
@@ -192,7 +196,8 @@ def _get_DE_type(lookup, term_id: str, term_type: str):
 
 def _is_ionophore(cycle: dict, total_feed: float):
     inputs = cycle.get('inputs', [])
-    has_input = find_term_match(inputs, 'ionophores', None) is not None
+    ionophore_terms = get_ionophore_terms()
+    has_input = any([find_term_match(inputs, term_id, None) is not None for term_id in ionophore_terms])
     maize_input = find_term_match(inputs, 'maizeSteamFlaked')
     maize_feed = get_total_value_converted_with_min_ratio(MODEL, None, blank_nodes=[maize_input]) if maize_input else 0
     maize_feed_ratio = maize_feed / total_feed if all([maize_feed, total_feed]) else 0

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,18 +14,17 @@ 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"]}
+        ],
         "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": "",
@@ -32,28 +33,35 @@ REQUIREMENTS = {
                 }
             ],
             "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"}
-            ]
+            "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}]
         }
     }
 }
 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,138 @@ 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
 
-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
-    ])
 
-    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
+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])
+
+    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 +216,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/co2ToAirAboveGroundBiomassStockChange.py

@@ -11,6 +11,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "site": {
+            "@type": "Site",
             "measurements": [
                 {
                     "@type": "Measurement",

hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -11,6 +11,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "site": {
+            "@type": "Site",
             "measurements": [
                 {
                     "@type": "Measurement",
@@ -38,7 +39,7 @@ RETURNS = {
         "statsDefinition": "simulated",
         "observations": "",
         "methodTier": "",
-        "depth": "30"
+        "depth": 30
     }]
 }
 TERM_ID = 'co2ToAirBelowGroundBiomassStockChangeLandUseChange,co2ToAirBelowGroundBiomassStockChangeManagementChange'

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -796,26 +796,8 @@ def _preprocess_carbon_stocks(
     list[CarbonStock]
         A list of carbon stocks sorted by date.
     """
-    sorted_measurements = sorted(
-        flatten([split_node_by_dates(m) for m in carbon_stock_measurements]),
-        key=lambda node: _gapfill_datestr(node["dates"][0], DatestrGapfillMode.END)
-    )
-
-    values = flatten(node["value"] for node in sorted_measurements)
-
-    sds = flatten(
-        node.get("sd", []) or [_calc_nominal_sd(v, _NOMINAL_ERROR) for v in node["value"]]
-        for node in sorted_measurements
-    )
-
-    dates = flatten(
-        [_gapfill_datestr(datestr, DatestrGapfillMode.END) for datestr in node["dates"]]
-        for node in sorted_measurements
-    )
-
-    methods = flatten(
-        [MeasurementMethodClassification(node.get("methodClassification")) for _ in node["value"]]
-        for node in sorted_measurements
+    dates, values, sds, methods = _extract_node_data(
+        flatten([split_node_by_dates(m) for m in carbon_stock_measurements])
     )
 
     correlation_matrix = compute_time_series_correlation_matrix(
@@ -842,6 +824,35 @@ def _preprocess_carbon_stocks(
     ]
 
 
+def _extract_node_data(nodes: list[dict]) -> list[dict]:
+
+    def group_node(result, node) -> dict[str, dict]:
+        date = _gapfill_datestr(node["dates"][0], DatestrGapfillMode.END)
+        result[date] = result.get(date, []) + [node]
+        return result
+
+    grouped_nodes = reduce(group_node, nodes, dict())
+
+    def get_values(date):
+        return flatten(node.get("value", []) for node in grouped_nodes[date])
+
+    def get_sds(date):
+        return flatten(
+            node.get("sd", []) or [_calc_nominal_sd(v, _NOMINAL_ERROR) for v in node.get("value", [])]
+            for node in grouped_nodes[date]
+        )
+
+    def get_methods(date):
+        return flatten(node.get("methodClassification", []) for node in grouped_nodes[date])
+
+    dates = sorted(grouped_nodes.keys())
+    values = [mean(get_values(date)) for date in dates]
+    sds = [mean(get_sds(date)) for date in dates]
+    methods = [min_measurement_method_classification(get_methods(date)) for date in dates]
+
+    return dates, values, sds, methods
+
+
 def _calc_nominal_sd(value: float, error: float) -> float:
     """
     Calculate a nominal SD for a carbon stock measurement. Can be used to gap fill SD when information not present in