hestia-earth-models 0.64.6__py3-none-any.whl → 0.64.8__py3-none-any.whl

hestia_earth/models/cycle/animal/milkYield.py

@@ -1,18 +1,16 @@
 """
 Milk Yield
 
-This model gap-fills the practice "Milk yield per animal X (raw/FPCM)" (e.g. `Milk yield per cow (raw)`) when:
-- the practice is added to the Cycle itself, and we can match it with the `term` of an Animal blank node;
-- the Animal blank node Term has a lookup value of `kgDayMilkForFeedingOffspring`.
+This model gap-fills the practice "Milk yield per animal X (raw/FPCM)" (e.g. `Milk yield per cow (raw)`) when
+the practice is added to the Cycle itself, and we can match it with the `term` of an Animal blank node.
 """
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import non_empty_list, safe_parse_float
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_blank_nodes_id
 from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.practice import _new_practice
 from .. import MODEL
 
 REQUIREMENTS = {
@@ -21,12 +19,10 @@ REQUIREMENTS = {
             "@type": "Animal",
             "term.termType": "liveAnimal"
         }],
-        "optional": {
-            "practices": [{
-                "@type": "Practice",
-                "term.termType": "animalManagement"
-            }]
-        }
+        "practices": [{
+            "@type": "Practice",
+            "term.termType": "animalManagement"
+        }]
     }
 }
 RETURNS = {
@@ -38,27 +34,19 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "liveAnimal": ["milkYieldPracticeTermIds", "kgDayMilkForFeedingOffspring"]
+    "liveAnimal": "milkYieldPracticeTermIds"
 }
 
 MODEL_KEY = 'milkYield'
 
 
-def _default_practice(animal: dict, practice_term_id: str):
-    term = animal.get('term', {})
-    value = get_lookup_value(term, LOOKUPS['liveAnimal'][1], model=MODEL, model_key=MODEL_KEY)
-    return (_new_practice(practice_term_id) | {'value': [safe_parse_float(value)]}) if value else None
-
-
 def _run(cycle: dict, animal: dict):
     term = animal.get('term', {})
     term_id = term.get('@id')
-    value = get_lookup_value(term, LOOKUPS['liveAnimal'][0], model=MODEL, model_key=MODEL_KEY)
+    value = get_lookup_value(term, LOOKUPS['liveAnimal'], model=MODEL, model_key=MODEL_KEY)
     practice_ids = non_empty_list((value or '').split(';'))
     practices = non_empty_list(
-        [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids] or (
-            [_default_practice(animal, practice_ids[0])] if practice_ids else []
-        )
+        [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids]
     )
 
     logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,

hestia_earth/models/cycle/unknownPreSeasonWaterRegime.py

@@ -36,7 +36,6 @@ def _practice():
 def _should_run(cycle: dict):
     practices = cycle.get('practices', [])
     flooded_terms = get_flooded_pre_season_terms()
-    print(flooded_terms)
     existing_practice = next((p for p in practices if p.get('term', {}).get('@id') in flooded_terms), None)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -12,34 +12,34 @@ from . import MODEL
 from .utils import get_coefficient_factor
 
 REQUIREMENTS = {
-    "Cycle": {
-        "siteDuration": "> 0",
-        "siteArea": "> 0",
-        "site": {"siteType": "",
-                 "@type": "Site",
-                 "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
-                 "country": {"@type": "Term", "termType": "region"}
-                 },
-        "optional": {
-            "otherSitesDuration": "> 0",
-            "otherSitesArea": "> 0",
-            "otherSites": [
-                {
-                    "siteType": "",
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "siteDuration": "> 0",
+            "siteArea": "> 0",
+            "site": {
+                "siteType": "",
+                "@type": "Site",
+                "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
+                "country": {"@type": "Term", "termType": "region"}
+            },
+            "optional": {
+                "otherSitesDuration": "> 0",
+                "otherSitesArea": "> 0",
+                "otherSites": [{
                     "@type": "Site",
+                    "siteType": "",
                     "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
                     "country": {"@type": "Term", "termType": "region"}
-                }
-            ]
+                }]
+            }
         }
     }
 }
 LOOKUPS = {
     "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
     "region-pefTermGrouping-landOccupation": "",
-    "landCover": [
-        "pefTermGrouping"
-    ]
+    "landCover": "pefTermGrouping"
 }
 
 RETURNS = {
@@ -62,7 +62,8 @@ def _run(sites: list):
     return _indicator(list_sum(values)) if values else None
 
 
-def _should_run(cycle: dict):
+def _should_run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
     end_date = cycle.get('endDate')
 
     has_site = bool(cycle.get('site', False))
@@ -76,8 +77,8 @@ def _should_run(cycle: dict):
         {
             'site-type': site.get('siteType'),
             'country-id': site.get('country', {}).get('@id'),
-            'area': site_areas[index],
-            'duration': site_durations[index],
+            'area': site_areas[index] if len(site_areas) >= index + 1 else None,
+            'duration': site_durations[index] if len(site_durations) >= index + 1 else None,
             'landCover-id': (most_relevant_blank_node_by_type(
                 site.get("management", []),
                 term_type=TermTermType.LANDCOVER.value,
@@ -123,6 +124,6 @@ def _should_run(cycle: dict):
     return should_run, valid_sites
 
 
-def run(cycle: dict):
-    should_run, sites = _should_run(cycle)
+def run(impact_assessment: dict):
+    should_run, sites = _should_run(impact_assessment)
     return _run(sites) if should_run else None

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -0,0 +1,182 @@
+"""
+Characterises [soilQualityIndexLandTransformation](https://hestia.earth/term/soilQualityIndexLandTransformation)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from typing import List
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, safe_parse_date, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import hectar_to_square_meter
+from hestia_earth.models.utils import pairwise
+from . import MODEL
+from .utils import get_coefficient_factor
+from ..utils.indicator import _new_indicator
+from ..utils.landCover import get_pef_grouping
+from ..utils.lookup import fallback_country
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "site": {
+                "area": "> 0",
+                "@type": "Site",
+                "management": [{"@type": "Management", "term.termType": "landCover"}],
+                "optional": {"country": {"@type": "Term", "termType": "region"}}
+            },
+            "optional": {
+                "otherSitesArea": "> 0",
+                "otherSites": [{
+                    "@type": "Site",
+                    "management": [{"@type": "Management", "term.termType": "landCover"}],
+                    "optional": {"country": {"@type": "Term", "termType": "region"}}
+                }]
+            }
+        }
+    }
+}
+
+LOOKUPS = {
+    "@doc": "Uses `landCover.csv` for column headers and region-pefTermGrouping-landTransformation-X.csv for to/from CFs. (CFs in `region-pefTermGrouping-landTransformation-from.csv` appear to be the opposite values as those in `region-pefTermGrouping-landTransformation-to.csv` but can be different in some cases)",  # noqa: E501
+    "region-pefTermGrouping-landTransformation-from": "",
+    "region-pefTermGrouping-landTransformation-to": "",
+    "landCover": "pefTermGrouping"
+}
+
+from_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[2]}.csv"
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'soilQualityIndexLandTransformation'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(sites: List[dict]):
+    result = []
+    for site in sites:
+        values = [(transformation_from_factor + transformation_to_factor) * hectar_to_square_meter(site['area'])
+                  for transformation_from_factor, transformation_to_factor in site['transformation_factors']]
+        result.append(list_sum(values))
+    return _indicator(list_sum(result)) if result else None
+
+
+def _should_run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+
+    has_site = bool(cycle.get('site', {}))
+    site_area = cycle.get('site', {}).get("area", False)
+    has_area = site_area > 0
+
+    has_other_sites = bool(cycle.get('otherSites', []))
+
+    all_sites = non_empty_list([cycle.get('site')] + cycle.get('otherSites', []))
+    site_areas = [cycle.get('site', {}).get('area')] + cycle.get('otherSitesArea', [])
+
+    sites = [
+        {
+            'site_id': site.get('@id', site.get('id')),
+            'transformation_pairs': list(pairwise(
+                sorted(filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER.value),
+                       key=lambda d: safe_parse_date(d['endDate'])))),
+            'country_id_str': site.get('country', {}).get('@id', ''),
+            'area': site_areas[index] if len(site_areas) >= index + 1 else None,
+        }
+        for index, site in enumerate(all_sites)
+    ]
+
+    sites = [
+        site for site in sites
+        if all([
+            (site.get('area') or 0) > 0,
+            site.get('transformation_pairs', [])
+        ])
+    ]
+
+    sites = [
+        site |
+        {
+            'column_names': [(get_pef_grouping(from_transformation['term']['@id']),
+                              get_pef_grouping(to_transformation['term']['@id']))
+                             for from_transformation, to_transformation in site['transformation_pairs']],
+        } for site in sites
+    ]
+
+    has_lookup_column = lambda s: s['column_names'] and all([all(pair) for pair in s['column_names']])  # noqa: E731
+    valid_sites = [site for site in sites if has_lookup_column(site)]
+
+    has_valid_sites = bool(valid_sites)
+
+    valid_sites = [
+        site |
+        {
+            'country_id': fallback_country(site['country_id_str'],
+                                           [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]
+                                           )
+        } for site in valid_sites
+    ]
+
+    valid_sites = [
+        site |
+        {
+            'transformation_factors': [(get_coefficient_factor(lookup_name=from_lookup_file,
+                                                               country_id=site['country_id'], term_id=TERM_ID,
+                                                               occupation_type=from_transformation_header),
+                                        get_coefficient_factor(lookup_name=to_lookup_file,
+                                                               country_id=site['country_id'], term_id=TERM_ID,
+                                                               occupation_type=to_transformation_header))
+                                       for from_transformation_header, to_transformation_header in site['column_names']]
+        } for site in valid_sites
+    ]
+
+    log_equivalent_eu_pef_land_use_names = [
+        [{
+            'site-id': site['site_id'],
+            'hestia-term': hestia_term,
+            'corine-term': corine_term,
+        } for hestia_term, corine_term in site['column_names']
+        ] for site in valid_sites]
+
+    log_transformation_factors = [
+        [{
+            'site-id': site['site_id'],
+            'country-id-used-for-factors': site['country_id'],
+            'country-id-in-input': site['country_id_str'],
+            'factor-from': from_transformation_header,
+            'factor-to': to_transformation_header,
+        } for from_transformation_header, to_transformation_header in site['transformation_factors']
+        ] for site in valid_sites]
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_site=has_site,
+                    has_area=has_area,
+                    has_other_sites=has_other_sites,
+                    has_valid_sites=has_valid_sites,
+                    equivalent_EU_PEF_landUse_names=log_as_table(log_equivalent_eu_pef_land_use_names),
+                    transformation_factors=log_as_table(log_transformation_factors)
+                    )
+    should_run = has_valid_sites
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return should_run, valid_sites
+
+
+def run(impact_assessment: dict):
+    should_run, sites = _should_run(impact_assessment)
+    return _run(sites) if should_run else None

hestia_earth/models/environmentalFootprintV3/soilQualityIndexTotalLandUseEffects.py

@@ -0,0 +1,66 @@
+"""
+Characterises [soilQualityIndexTotalLandUseEffects](https://hestia.earth/term/soilQualityIndexTotalLandUseEffects)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from hestia_earth.utils.model import find_term_match
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandOccupation"},
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandTransformation"}
+        ]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }
+}
+TERM_ID = 'soilQualityIndexTotalLandUseEffects'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(land_occupation_indicator, transformation_indicator):
+    value = land_occupation_indicator['value'] + transformation_indicator['value']
+    return _indicator(value) if value else None
+
+
+def _should_run(impactassessment: dict):
+    land_occupation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
+                                                "soilQualityIndexLandOccupation")
+    transformation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
+                                               "soilQualityIndexLandTransformation")
+
+    has_valid_values = all([isinstance(land_occupation_indicator.get('value', None), (int, float)),
+                            isinstance(transformation_indicator.get('value', None), (int, float))])
+
+    logRequirements(impactassessment, model=MODEL, term=TERM_ID,
+                    transformation_indicator=transformation_indicator,
+                    land_occupation_indicator=land_occupation_indicator,
+                    has_valid_values=has_valid_values
+                    )
+
+    should_run = all([transformation_indicator, land_occupation_indicator, has_valid_values])
+
+    logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
+    return should_run, land_occupation_indicator, transformation_indicator
+
+
+def run(impactassessment: dict):
+    should_run, land_occupation_indicator, transformation_indicator = _should_run(impactassessment)
+    return _run(land_occupation_indicator, transformation_indicator) if should_run else None

hestia_earth/models/environmentalFootprintV3/utils.py

@@ -12,6 +12,6 @@ def get_coefficient_factor(lookup_name: str, country_id: str, occupation_type: O
     """
     coefficient = get_table_value(download_lookup(lookup_name), 'termid', country_id, column_name(occupation_type))
     debugMissingLookup(
-        lookup_name, 'termid', country_id, column_name(occupation_type), coefficient, model=MODEL, term=term_id
+        lookup_name, 'termid', country_id, occupation_type, coefficient, model=MODEL, term=term_id
     )
     return coefficient

hestia_earth/models/hyde32/utils.py

@@ -45,6 +45,8 @@ def _run(impact_assessment: dict, term_id: str, land_occupation_m2: float, facto
 
 
 def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteType, years: int):
+    site = get_site(impact_assessment)
+    has_site = bool(site)
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
     site = get_site(impact_assessment)
@@ -52,10 +54,12 @@ def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteT
     land_transformation_factor = _get_emission_factor(term_id, impact_assessment, years, from_site_type)
 
     logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    has_site=has_site,
                     land_occupation_m2_kg=land_occupation_m2_kg,
                     land_transformation_factor=land_transformation_factor)
 
     should_run = all([
+        has_site,
         land_occupation_m2_kg is not None,
         land_occupation_m2_kg == 0 or land_transformation_factor is not None
     ])

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -137,10 +137,12 @@ LOOKUPS = {
         "isWoolProducingAnimal"
     ],
     "system-liveAnimal-activityCoefficient-ipcc2019": "using animal term @id",
+    "landCover": "grazedPastureGrassInputId",
     "crop-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
     "crop": "grazedPastureGrassInputId",
     "forage-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
-    "landCover": "grazedPastureGrassInputId"
+    "feedFoodAdditive": "hasEnergyContent",
+    "feedFoodAdditive-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"]
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -0,0 +1,191 @@
+from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification, SiteSiteType
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
+from hestia_earth.models.utils.emission import _new_emission
+
+from .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "measurements": [
+                {
+                    "@type": "Measurement",
+                    "value": "",
+                    "dates": "",
+                    "depthUpper": "0",
+                    "depthLower": "30",
+                    "term.@id": "aboveGroundBiomass"
+                }
+            ]
+        },
+        "functionalUnit": "1 ha",
+        "endDate": "",
+        "optional": {
+            "startDate": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "statsDefinition": "simulated",
+        "observations": "",
+        "methodTier": ""
+    }]
+}
+TERM_ID = 'co2ToAirAboveGroundBiomassStockChangeLandUseChange'
+
+_CARBON_STOCK_TERM_ID = 'aboveGroundBiomass'
+
+_MEASUREMENT_METHOD_RANKING = [
+    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
+    MeasurementMethodClassification.TIER_3_MODEL,
+    MeasurementMethodClassification.TIER_2_MODEL,
+    MeasurementMethodClassification.TIER_1_MODEL,
+    MeasurementMethodClassification.GEOSPATIAL_DATASET
+]
+"""
+The list of `MeasurementMethodClassification`s that can be used to calculate SOC stock change emissions, ranked in
+order from strongest to weakest.
+"""
+
+_SITE_TYPE_SYSTEMS_MAPPING = {
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
+        "protectedCroppingSystemSoilBased",
+        "protectedCroppingSystemSoilAndSubstrateBased"
+    ]
+}
+
+
+def _emission(
+    *,
+    value: list[float],
+    method_tier: EmissionMethodTier,
+    sd: list[float] = None,
+    min: list[float] = None,
+    max: list[float] = None,
+    statsDefinition: str = None,
+    observations: list[int] = None
+) -> dict:
+    """
+    Create an emission node based on the provided value and method tier.
+
+    See [Emission schema](https://www.hestia.earth/schema/Emission) for more information.
+
+    Parameters
+    ----------
+    value : float
+        The emission value (kg CO2 ha-1).
+    sd : float
+        The standard deviation (kg CO2 ha-1).
+    method_tier : EmissionMethodTier
+        The emission method tier.
+
+    Returns
+    -------
+    dict
+        The emission dictionary with keys 'depth', 'value', and 'methodTier'.
+    """
+    update_dict = {
+        "value": value,
+        "sd": sd,
+        "min": min,
+        "max": max,
+        "statsDefinition": statsDefinition,
+        "observations": observations,
+        "methodTier": method_tier.value
+    }
+    emission = _new_emission(TERM_ID, MODEL) | {
+        key: value for key, value in update_dict.items() if value
+    }
+    return emission
+
+
+def run(cycle: dict) -> list[dict]:
+    """
+    Run the `ipcc2019.co2ToAirAboveGroundBiomassStockChangeManagementChange`.
+
+    Parameters
+    ----------
+    cycle : dict
+        A HESTIA (Cycle node)[https://www.hestia.earth/schema/Cycle].
+
+    Returns
+    -------
+    list[dict]
+        A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
+    """
+    should_run_exec = create_should_run_function(
+        _CARBON_STOCK_TERM_ID,
+        _should_compile_inventory_func,
+        measurement_method_ranking=_MEASUREMENT_METHOD_RANKING
+    )
+
+    run_exec = create_run_function(_emission)
+
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID, **logs)
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
+    return run_exec(cycle_id, inventory) if should_run else []
+
+
+def _should_compile_inventory_func(
+    site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]
+) -> tuple[bool, dict]:
+    """
+    Determine whether a site is suitable and has enough data to compile a carbon stock inventory.
+
+    Parameters
+    ----------
+    site : dict
+        A HESTIA (Site node)[https://www.hestia.earth/schema/Site]
+    cycles : list[dict]
+        A list of HESTIA (Cycle nodes)[https://www.hestia.earth/schema/Cycle] that are related to the site.
+    carbon_stock_measurements : list[dict]
+        A list of HESTIA carbon stock (Measurement nodes)[https://www.hestia.earth/schema/Measurement] that are related
+        to the site.
+
+    Returns
+    -------
+    tuple[bool, dict]
+        `(should_run, logs)`.
+    """
+    site_type = site.get("siteType")
+    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
+        cumulative_nodes_term_match(
+            cycle.get("practices", []),
+            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
+            cumulative_threshold=0
+        ) 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
+    ])
+
+    logs = {
+        "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,
+    }
+
+    return should_run, logs