hestia-earth-models 0.61.7__tar.gz → 0.62.0__tar.gz

{hestia-earth-models-0.61.7/hestia_earth_models.egg-info → hestia-earth-models-0.62.0}/PKG-INFO

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

hestia-earth-models-0.62.0/hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -0,0 +1,60 @@
+"""
+Completeness Electricity Fuel
+
+This model checks if we have the requirements below and updates the
+[Data Completeness](https://hestia.earth/schema/Completeness#electricityFuel) value.
+"""
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.log import logRequirements, log_as_table
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.operation": "True",
+        "completeness.electricityFuel": "False",
+        "practices": [
+            {"@type": "Practice", "value": "", "term.termType": "operation"}
+        ]
+    }
+}
+RETURNS = {
+    "Completeness": {
+        "electricityFuel": ""
+    }
+}
+LOOKUPS = {
+    "operation": ["fuelUse", "combustionType"]
+}
+MODEL_KEY = 'electricityFuel'
+_VALID_COMBUSTION_TYPES = ['mobile', 'stationary']
+
+
+def _lookup_value(practice: dict, lookup_name: str):
+    return get_lookup_value(practice.get('term', {}), lookup_name, model=MODEL, model_key=MODEL_KEY)
+
+
+def _practice_value(practice: dict):
+    term = practice.get('term', {})
+    fuel_use = _lookup_value(practice, LOOKUPS['operation'][0])
+    return {'id': term.get('@id'), 'fuel_use': fuel_use}
+
+
+def run(cycle: dict):
+    operation_complete = _is_term_type_complete(cycle, TermTermType.OPERATION)
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.OPERATION)
+    combustion_practices = [
+        p for p in practices if _lookup_value(p, LOOKUPS['operation'][1]) in _VALID_COMBUSTION_TYPES
+    ]
+    practices_values = list(map(_practice_value, combustion_practices))
+
+    logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    term_type_operation_complete=operation_complete,
+                    values=log_as_table(practices_values))
+
+    is_complete = all([operation_complete] + [p.get('fuel_use') for p in practices_values])
+
+    return is_complete

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/cycle/product/economicValueShare.py

@@ -2,20 +2,21 @@
 Product Economic Value Share
 
 This model quantifies the relative economic value share of each marketable Product in a Cycle.
-Marketable Products are all Products in the Glossary with the exception of crop residue not sold.
+Marketable Products are all Products identified with the lookup "generateImpactAssessment = TRUE".
 
 It works in the following order:
-1. If revenue data are provided for all marketable products,
+1. For every product with no `value`, the `economicValueShare` is set to `0`.
+2. If revenue data are provided for all marketable products,
 the `economicValueShare` is directly calculated as the share of revenue of each Product;
-2. If the primary product is a crop and it is the only crop Product,
-`economicValueShare` is assigned based on a lookup table containing typical global average economic value shares
-drawn from [Poore & Nemecek (2018)](https://science.sciencemag.org/content/360/6392/987).
+3. Based on a lookup table containing typical global average economic value shares
+drawn from [Poore & Nemecek (2018)](https://science.sciencemag.org/content/360/6392/987), if all products have a
+corresponding value, the `economicValueShare` will be proportionally distributed among the products.
 """
-from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.cycle import unique_currencies
 from .utils import lookup_share
 from .. import MODEL
@@ -25,9 +26,11 @@ REQUIREMENTS = {
         "products": [{
             "@type": "Product",
             "value": "",
-            "economicValueShare": "",
-            "revenue": "",
-            "currency": ""
+            "optional": {
+                "economicValueShare": "",
+                "revenue": "",
+                "currency": ""
+            }
         }],
         "optional": {
             "completeness.product": ""
@@ -42,7 +45,8 @@ RETURNS = {
 LOOKUPS = {
     "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
     "crop": "global_economic_value_share",
-    "excreta": "global_economic_value_share"
+    "excreta": "global_economic_value_share",
+    "animalProduct": "global_economic_value_share"
 }
 MODEL_KEY = 'economicValueShare'
 MAX_VALUE = 100.5
@@ -60,7 +64,7 @@ def _is_complete(cycle: dict): return cycle.get('completeness', {}).get('product
 def _no_yield(product): return list_sum(product.get('value', [-1]), -1) == 0
 
 
-def _total_revenue(products: list): return sum([p.get(MODEL_KEY, 0) for p in products])
+def _total_evs(products: list): return sum([p.get(MODEL_KEY, 0) for p in products])
 
 
 def _product_with_value(product: dict):
@@ -72,18 +76,33 @@ def _rescale_value(products: list, total: float):
     return list(map(lambda p: {**p, MODEL_KEY: p.get(MODEL_KEY) * 100 / total}, products))
 
 
+def _should_run_by_default(cycle: dict, products: list):
+    run_by = 'default'
+    # only run if all products have the lookup data or value will be incorrect
+    products = list(map(_product_with_value, products))
+    all_with_economicValueShare = all([p.get(MODEL_KEY) is not None for p in products])
+
+    should_run = all([all_with_economicValueShare])
+
+    for p in products:
+        term_id = p.get('term', {}).get('@id')
+        logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
+                        all_with_economicValueShare=all_with_economicValueShare)
+        logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY, by=run_by)
+
+    return should_run
+
+
 def _run_by_default(cycle: dict, products: list):
     run_by = 'default'
     is_complete = _is_complete(cycle)
     products = list(map(_product_with_value, products))
-    # remove results where lookup share was not found
-    results = list(filter(lambda p: p.get(MODEL_KEY) is not None, products))
     # only return list if the new total of evs is not above threshold
-    total_revenue = _total_revenue(results)
-    below_max_threshold = total_revenue <= MAX_VALUE
-    should_rescale = is_complete and MIN_COMPLETE_VALUE <= total_revenue <= MAX_VALUE
-    above_min_threshold = True if should_rescale else total_revenue >= MIN_VALUE if is_complete else True
-    results = _rescale_value(results, total_revenue) if should_rescale else results
+    total_economicValueShare = _total_evs(products)
+    below_max_threshold = total_economicValueShare <= MAX_VALUE
+    should_rescale = is_complete and MIN_COMPLETE_VALUE <= total_economicValueShare <= MAX_VALUE
+    above_min_threshold = True if should_rescale else total_economicValueShare >= MIN_VALUE if is_complete else True
+    results = _rescale_value(products, total_economicValueShare) if should_rescale else products
 
     should_run = all([below_max_threshold, above_min_threshold])
 
@@ -93,7 +112,7 @@ def _run_by_default(cycle: dict, products: list):
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
                         below_max_threshold=below_max_threshold,
                         above_min_threshold=above_min_threshold,
-                        total_revenue=total_revenue)
+                        total_economicValueShare=total_economicValueShare)
         logShouldRun(cycle, MODEL, term_id, p_should_run, key=MODEL_KEY, by=run_by)
 
     return results if should_run else []
@@ -109,8 +128,8 @@ def _run_by_revenue(products: list):
 def _should_run_by_revenue(cycle: dict, products: list):
     run_by = 'revenue'
     is_complete = _is_complete(cycle)
-    total_value = _total_revenue(products)
-    below_threshold = total_value < MAX_VALUE
+    total_economicValueShare = _total_evs(products)
+    below_threshold = total_economicValueShare < MAX_VALUE
     # ignore products with no yield
     products = list(filter(lambda p: not _no_yield(p), products))
     currencies = unique_currencies(cycle)
@@ -122,7 +141,7 @@ def _should_run_by_revenue(cycle: dict, products: list):
         term_id = p.get('term', {}).get('@id')
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
                         is_complete=is_complete,
-                        total_value=total_value,
+                        total_economicValueShare=total_economicValueShare,
                         below_threshold=below_threshold,
                         all_with_revenue=all_with_revenue,
                         currencies=';'.join(currencies),
@@ -133,14 +152,14 @@ def _should_run_by_revenue(cycle: dict, products: list):
 
 
 def _run_single_missing_evs(products: list):
-    total_value = _total_revenue(products)
+    total_value = _total_evs(products)
     return list(map(lambda p: _product(p, 100 - total_value) if p.get(MODEL_KEY) is None else p, products))
 
 
 def _should_run_single_missing_evs(cycle: dict, products: list):
     run_by = '1-missing-evs'
     is_complete = _is_complete(cycle)
-    total_value = _total_revenue(products)
+    total_value = _total_evs(products)
     # ignore products with no yield
     products = list(filter(lambda p: not _no_yield(p), products))
     missing_values = [p for p in products if p.get(MODEL_KEY) is None]
@@ -175,20 +194,17 @@ def _should_run_no_value(cycle: dict, product: dict):
 
 
 def _should_have_evs(product: dict):
-    term_type = product.get('term', {}).get('termType')
-    return term_type not in [
-        TermTermType.CROPRESIDUE.value,
-        TermTermType.EXCRETA.value
-    ]
+    should_generate_ia = get_lookup_value(product.get('term', {}), 'generateImpactAssessment')
+    return str(should_generate_ia).lower() != 'false'
 
 
 def run(cycle: dict):
     products = cycle.get('products', [])
-    # skip any product that will never has value
+    # skip any product that is not marketable
     products = list(filter(_should_have_evs, products))
     products = list(map(lambda p: _product(p, 0) if _should_run_no_value(cycle, p) else p, products))
     return (
         _run_single_missing_evs(products) if _should_run_single_missing_evs(cycle, products) else
         _run_by_revenue(products) if _should_run_by_revenue(cycle, products) else
-        _run_by_default(cycle, products)
+        _run_by_default(cycle, products) if _should_run_by_default(cycle, products) else []
     )

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -1,14 +1,13 @@
 from functools import reduce
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.lookup import download_lookup
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, non_empty_list
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.inorganicFertiliser import (
-    get_NH3_emission_factor, get_terms, get_term_lookup, BREAKDOWN_LOOKUP, get_country_breakdown, get_cycle_inputs
+    get_NH3_emission_factor, get_terms, get_term_lookup, get_country_breakdown, get_cycle_inputs
 )
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.emission import _new_emission
@@ -66,23 +65,21 @@ def _emission(value: float):
     return emission
 
 
-def _get_input_value(cycle: dict, soilPh: float, temperature: float):
+def _input_with_factor(soilPh: float, temperature: float):
     def get_value(input: dict):
         term_id = input.get('term', {}).get('@id')
-        factor = get_NH3_emission_factor(term_id, soilPh, temperature)
-        value = list_sum(input.get('value'))
-        debugValues(cycle, model=MODEL, term=TERM_ID,
-                    product=term_id,
-                    factor=factor,
-                    value=value)
-        return value * factor
+        factor = get_NH3_emission_factor(term_id, soilPh, temperature) if all([
+            soilPh is not None,
+            temperature is not None
+        ]) else None
+        value = list_sum(input.get('value'), None)
+        return {'id': term_id, 'value': value, 'factor': factor} if all([
+            value is not None,
+            factor is not None
+        ]) else None
     return get_value
 
 
-def _run(cycle: dict, temperature: float, soilPh: float, inputs: float):
-    return list_sum(list(map(_get_input_value(cycle, soilPh, temperature), inputs)))
-
-
 def _get_groupings():
     term_ids = get_terms()
 
@@ -93,23 +90,22 @@ def _get_groupings():
     return reduce(get_grouping, term_ids, {})
 
 
-def _get_term_value(cycle: dict, soilPh: float, temperature: float, country_id: str, grouping: str, term_id: str):
-    factor = get_NH3_emission_factor(term_id, soilPh, temperature)
-    value = get_country_breakdown(MODEL, TERM_ID, country_id, grouping)
-    debugValues(cycle, model=MODEL, term=TERM_ID,
-                grouping=grouping,
-                NH3_factor=factor,
-                country_breakdown=value)
-    return value * factor
-
-
-def _run_with_unspecified(cycle: dict, temperature: float, soilPh: float, unspecifiedKgN_value: float, country_id: str):
+def _unspecified_inputs_with_factor(temperature: float, soilPh: float, unspecifiedKgN_value: float, site: dict):
+    country_id = site.get('country', {}).get('@id')
     # creates a dictionary grouping => term_id with only a single key per group (avoid counting twice)
     groupings = _get_groupings()
-    return list_sum([
-        _get_term_value(cycle, soilPh, temperature, country_id, grouping, term_id)
-        for grouping, term_id in groupings.items()
-    ]) * unspecifiedKgN_value
+    breakdown_inputs = [(
+        term_id, get_country_breakdown(MODEL, TERM_ID, country_id, grouping)
+    ) for grouping, term_id in groupings.items()] if all([country_id, unspecifiedKgN_value is not None]) else []
+    # create inputs from country breakdown
+    N_inputs = [
+        {
+            'term': {'@id': term_id},
+            'value': [value * unspecifiedKgN_value]
+        }
+        for term_id, value in breakdown_inputs if value is not None
+    ]
+    return non_empty_list(map(_input_with_factor(soilPh, temperature), N_inputs))
 
 
 def _should_run(cycle: dict):
@@ -121,49 +117,38 @@ def _should_run(cycle: dict):
         measurements, 'temperatureAnnual', end_date) or most_relevant_measurement_value(
         measurements, 'temperatureLongTermAnnualMean', end_date)
 
-    inputs = get_cycle_inputs(cycle)
-    N_inputs = _filter_list_term_unit(inputs, Units.KG_N)
+    N_inputs = _filter_list_term_unit(get_cycle_inputs(cycle), Units.KG_N)
     has_N_inputs = len(N_inputs) > 0
 
-    unspecifiedKgN = find_term_match(cycle.get('inputs', []), UNSPECIFIED_TERM_ID).get('value', [])
-    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
-    has_unspecifiedKgN = len(unspecifiedKgN) > 0 or fertiliser_complete
+    N_inputs_with_factor = non_empty_list(map(_input_with_factor(soilPh, temperature), N_inputs))
+    has_N_inputs_with_factor = len(N_inputs_with_factor) > 0
 
-    country_id = site.get('country', {}).get('@id')
-    lookup = download_lookup(BREAKDOWN_LOOKUP)
-    has_country_data = country_id in list(lookup.termid)
+    # fallback using country averages of fertilisers usage
+    unspecifiedKgN_value = list_sum(find_term_match(N_inputs, UNSPECIFIED_TERM_ID).get('value'), None)
+    unspecified_inputs_with_factor = _unspecified_inputs_with_factor(temperature, soilPh, unspecifiedKgN_value, site)
+    has_unspecified_inputs_with_factor = len(unspecified_inputs_with_factor) > 0
 
-    run_with_unspecified = (has_country_data and has_unspecifiedKgN) or fertiliser_complete
-    unspecifiedKgN = (
-        0 if len(unspecifiedKgN) == 0 and fertiliser_complete else list_sum(unspecifiedKgN, None)
-    ) if run_with_unspecified else None
+    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=fertiliser_complete,
                     temperature=temperature,
                     soilPh=soilPh,
-                    term_type_fertiliser_complete=fertiliser_complete,
-                    has_unspecifiedKgN=has_unspecifiedKgN,
-                    has_country_data=has_country_data,
-                    run_with_unspecified=run_with_unspecified,
-                    has_N_inputs=has_N_inputs)
+                    has_N_inputs=has_N_inputs,
+                    inorganic_fertiliser_inputs=log_as_table(N_inputs_with_factor),
+                    unspecified_fertiliser_inputs=log_as_table(unspecified_inputs_with_factor))
 
     should_run = all([
+        fertiliser_complete,
         temperature,
         soilPh,
-        any([
-            run_with_unspecified,
-            has_N_inputs,
-            not has_N_inputs and fertiliser_complete
-        ])
+        not has_N_inputs or has_N_inputs_with_factor or has_unspecified_inputs_with_factor
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, temperature, soilPh, N_inputs, unspecifiedKgN, country_id
+    return should_run, N_inputs_with_factor or unspecified_inputs_with_factor
 
 
 def run(cycle: dict):
-    should_run, temperature, soilPh, N_inputs, unspecifiedKgN, country_id = _should_run(cycle)
-    value = _run(cycle, temperature, soilPh, N_inputs) or (
-        _run_with_unspecified(cycle, temperature, soilPh, unspecifiedKgN, country_id)
-        if unspecifiedKgN is not None else None
-    ) if should_run else None
+    should_run, N_inputs_with_factor = _should_run(cycle)
+    value = list_sum([i.get('value') * i.get('factor') for i in N_inputs_with_factor]) if should_run else None
     return [_emission(value)] if value is not None else []

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/geospatialDatabase/histosol.py

@@ -21,6 +21,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Measurement": [{
         "value": "",
+        "depthUpper": "0",
+        "depthLower": "30",
         "methodClassification": "geospatial dataset"
     }]
 }
@@ -36,6 +38,8 @@ BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture
 def _measurement(site: dict, value: float):
     measurement = _new_measurement(TERM_ID)
     measurement['value'] = [round(value, 7)]
+    measurement['depthUpper'] = 0
+    measurement['depthLower'] = 30
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2006/co2ToAirOrganicSoilCultivation.py

@@ -1,6 +1,7 @@
 from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 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.ecoClimateZone import get_ecoClimateZone_lookup_value
@@ -39,7 +40,6 @@ RETURNS = {
 }
 TERM_ID = 'co2ToAirOrganicSoilCultivation'
 TIER = EmissionMethodTier.TIER_1.value
-CONVERT_FACTOR = 44 / 120
 
 
 def _emission(value: float):
@@ -55,7 +55,9 @@ def _run(histosol: float, organic_soil_factor: float, land_occupation: float):
 
 
 def _get_CO2_factor(eco_climate_zone: str, site_type: str):
-    return get_ecoClimateZone_lookup_value(eco_climate_zone, LOOKUPS['ecoClimateZone'], site_type) * CONVERT_FACTOR
+    return get_ecoClimateZone_lookup_value(
+        eco_climate_zone, LOOKUPS['ecoClimateZone'], site_type
+    ) * 1000 * get_atomic_conversion(Units.KG_CO2, Units.TO_C)
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2006/n2OToAirOrganicSoilCultivationDirect.py

@@ -57,7 +57,7 @@ def _run(histosol: float, organic_soil_factor: float, land_occupation: float):
 def _get_N2O_factor(eco_climate_zone: str):
     return get_ecoClimateZone_lookup_value(
         eco_climate_zone, LOOKUPS['ecoClimateZone']
-    ) * get_atomic_conversion(Units.KG_N2O, Units.TO_N) / 10000
+    ) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2019/aboveGroundCropResidueTotal.py

@@ -75,7 +75,7 @@ def _should_run(cycle: dict):
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_forage_products=has_crop_forage_products,
+                    has_crop_forage_products_with_dryMatter=has_crop_forage_products,
                     term_type_cropResidue_incomplete=term_type_incomplete)
 
     should_run = all([term_type_incomplete, has_crop_forage_products])

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -1,9 +1,12 @@
 """
-Full Grass Consumption
+Animal Pasture Grass
 
 This model estimates the energetic requirements of ruminants and can be used to estimate the amount of grass they graze.
 Source:
 [IPCC 2019, Vol.4, Chapter 10](https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch10_Livestock.pdf).
+
+This version of the model will run at the Animal Blank Node level, if none of the Cycle Input are given as feed
+(see https://www.hestia.earth/schema/Input#isAnimalFeed).
 """
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
@@ -138,7 +141,7 @@ RETURNS = {
         }]
     }]
 }
-MODEL_KEY = 'animal/pastureGrass'
+MODEL_KEY = 'pastureGrass'
 
 
 def _input(term_id: str, value: float):
@@ -173,7 +176,7 @@ def calculate_NEwool(cycle: dict, animal: dict, products: list, total_weight: fl
     ])
     animal_weight = _sum_liveWeightPerHead([animal])
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 total_energy=total_energy,
                 animal_liveWeightPerHead=animal_weight,
                 total_liveWeightPerHead=total_weight)
@@ -189,7 +192,13 @@ def _calculate_GE(
     NEm, NEa, NEl, NEwork, NEp, NEg = get_animal_values(cycle, animal, system)
 
     NEm_feed, NEg_feed = calculate_NEfeed(animal)
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                NEm=NEm,
+                NEa=NEa,
+                NEl=NEl,
+                NEwork=NEwork,
+                NEp=NEp,
+                NEg=NEg,
                 NEm_feed=NEm_feed,
                 NEg_feed=NEg_feed)
 
@@ -233,7 +242,7 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, system: dict, prac
         ) else 0
         GE = (_calculate_GE(cycle, animal, REM, REG, NEwool, system) / (meanDE/100)) if all([REM, REG]) else 0
 
-        debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+        debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
                     REM=REM,
                     REG=REG,
                     NEwool=NEwool,
@@ -248,17 +257,12 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, system: dict, prac
     return run
 
 
-def _run(cycle: dict, meanDE: float, meanECHHV: float, system: dict, practices: list):
-    animals = get_animals(cycle)
-    return list(map(_run_animal(cycle, meanDE, meanECHHV, system, practices), animals))
-
-
-def _should_run(cycle: dict, practices: dict):
+def _should_run(cycle: dict, animals: list, practices: dict):
     systems = filter_list_term_type(cycle.get('practices', []), TermTermType.SYSTEM)
     animalFeed_complete = _is_term_type_complete(cycle, 'animalFeed')
     animalPopulation_complete = _is_term_type_complete(cycle, 'animalPopulation')
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
-    all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
+    all_animals_have_value = all([a.get('value', 0) > 0 for a in animals])
 
     no_cycle_inputs_feed = all([not input.get('isAnimalFeed', False) for input in cycle.get('inputs', [])])
 
@@ -278,21 +282,23 @@ def _should_run(cycle: dict, practices: dict):
     ])
 
     for term_id in [MODEL_KEY] + [practice_input_id(p) for p in practices]:
-        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        term_type_animalFeed_complete=animalFeed_complete,
-                        term_type_animalPopulation_complete=animalPopulation_complete,
-                        term_type_freshForage_incomplete=freshForage_incomplete,
-                        no_cycle_inputs_feed=no_cycle_inputs_feed,
-                        all_animals_have_value=all_animals_have_value,
-                        meanDE=meanDE,
-                        meanECHHV=meanECHHV)
-
-        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
+        for animal in animals:
+            logRequirements(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                            term_type_animalFeed_complete=animalFeed_complete,
+                            term_type_animalPopulation_complete=animalPopulation_complete,
+                            term_type_freshForage_incomplete=freshForage_incomplete,
+                            no_cycle_inputs_feed=no_cycle_inputs_feed,
+                            all_animals_have_value=all_animals_have_value,
+                            meanDE=meanDE,
+                            meanECHHV=meanECHHV)
+
+            logShouldRun(animal, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
     return should_run, meanDE, meanECHHV, systems[0] if systems else None
 
 
 def run(cycle: dict):
+    animals = get_animals(cycle)
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
-    should_run, meanDE, meanECHHV, system = _should_run(cycle, practices)
-    return _run(cycle, meanDE, meanECHHV, system, practices) if should_run else []
+    should_run, meanDE, meanECHHV, system = _should_run(cycle, animals, practices)
+    return list(map(_run_animal(cycle, meanDE, meanECHHV, system, practices), animals)) if should_run else []

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2019/belowGroundCropResidue.py

@@ -82,7 +82,7 @@ def _should_run(cycle: dict):
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_forage_products=has_crop_forage_products,
+                    has_crop_forage_products_with_dryMatter=has_crop_forage_products,
                     term_type_cropResidue_incomplete=term_type_incomplete)
 
     should_run = all([term_type_incomplete, has_crop_forage_products])

{hestia-earth-models-0.61.7 → hestia-earth-models-0.62.0}/hestia_earth/models/ipcc2019/ch4ToAirExcreta.py

@@ -95,7 +95,7 @@ def _get_excreta_b0(country: dict, input: dict):
     )
 
 
-def _get_excretaManagement_MCF_from_lookup(term_id: str, ecoClimateZone: int, duration_key: DURATION_KEY):
+def _get_excretaManagement_MCF_from_lookup(term_id: str, ecoClimateZone: int, duration_key: DURATION):
     lookup_name = 'excretaManagement-ecoClimateZone-CH4conv.csv'
     lookup = download_lookup(lookup_name)
     data_values = get_table_value(lookup, 'termid', term_id, str(ecoClimateZone))