hestia-earth-models 0.57.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -22,7 +22,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.animalFeed": "True",
-        "completeness.grazedForage": "False",
+        "completeness.freshForage": "False",
         "site": {
             "@type": "Site",
             "siteType": "permanent pasture"
@@ -584,7 +584,7 @@ def _should_run_practice(cycle: dict):
 def _should_run(cycle: dict, practices: dict):
     systems = filter_list_term_type(cycle.get('practices', []), TermTermType.SYSTEM)
     animalFeed_complete = _is_term_type_complete(cycle, 'animalFeed')
-    grazedForage_incomplete = _is_term_type_incomplete(cycle, 'grazedForage')
+    freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
 
     meanDE = _calculate_meanDE(practices)
@@ -592,7 +592,7 @@ def _should_run(cycle: dict, practices: dict):
     GE = _calculate_GE(cycle, meanDE, systems[0]) if all([meanDE > 0, len(systems) > 0]) else 0
 
     should_run = all([
-        animalFeed_complete, grazedForage_incomplete,
+        animalFeed_complete, freshForage_incomplete,
         all_animals_have_value,
         len(systems) > 0, len(practices) > 0,
         GE > 0, meanECHHV > 0
@@ -601,7 +601,7 @@ 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,
                         term_type_animalFeed_complete=animalFeed_complete,
-                        term_type_grazedForage_incomplete=grazedForage_incomplete,
+                        term_type_freshForage_incomplete=freshForage_incomplete,
                         all_animals_have_value=all_animals_have_value,
                         meanDE=meanDE,
                         meanECHHV=meanECHHV,

hestia_earth/models/ipcc2019/utils.py

@@ -1,4 +1,5 @@
-from hestia_earth.utils.model import find_term_match
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import debugValues
@@ -7,6 +8,7 @@ from hestia_earth.models.utils.cycle import get_ecoClimateZone
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.blank_node import find_terms_value
 from hestia_earth.models.utils.term import get_lookup_value, get_milkYield_terms
+from hestia_earth.models.utils.ecoClimateZone import get_ecoClimateZone_lookup_value
 from . import MODEL
 
 # From IPCC2019 Indirect N2O emission factor, in N [avg, min, max, std]
@@ -69,3 +71,102 @@ def get_yield_dm(term_id: str, term: dict):
 def get_milkYield_practice(node: dict):
     terms = get_milkYield_terms()
     return next((p for p in node.get('practices', []) if p.get('term', {}).get('@id') in terms), {})
+
+
+def check_consecutive(ints: list[int]) -> bool:
+    """
+    Checks whether a list of integers are consecutive.
+
+    Used to determine whether annualised data is complete from every year from beggining to end.
+
+    Parameters
+    ----------
+    ints : list[int]
+        A list of integer values.
+
+    Returns
+    -------
+    bool
+        Whether or not the list of integers is consecutive.
+    """
+    range_list = list(range(min(ints), max(ints)+1)) if ints else []
+    return all(a == b for a, b in zip(ints, range_list))
+
+
+N2O_FACTORS = {
+    # All N inputs in dry climate
+    'dry': {
+        'value': 0.005,
+        'min': 0,
+        'max': 0.011
+    },
+    'wet': {
+        # Synthetic fertiliser inputs in wet climate
+        TermTermType.INORGANICFERTILISER: {
+            'value': 0.016,
+            'min': 0.013,
+            'max': 0.019
+        },
+        # Other N inputs in wet climate
+        TermTermType.ORGANICFERTILISER: {
+            'value': 0.006,
+            'min': 0.001,
+            'max': 0.011
+        },
+        TermTermType.CROPRESIDUE: {
+            'value': 0.006,
+            'min': 0.001,
+            'max': 0.011
+        }
+    },
+    'default': {
+        'value': 0.01,
+        'min': 0.001,
+        'max': 0.018
+    },
+    'flooded_rice': {
+        'value': 0.004,
+        'min': 0,
+        'max': 0.029
+    }
+}
+
+
+def _get_waterRegime_lookup(model_term_id: str, practice: dict, col: str):
+    return safe_parse_float(get_lookup_value(practice.get('term', {}), col, model=MODEL, term=model_term_id), None)
+
+
+def _is_wet(ecoClimateZone: str = None):
+    return get_ecoClimateZone_lookup_value(ecoClimateZone, 'wet') == 1 if ecoClimateZone else None
+
+
+def _ecoClimate_factors(input_term_type: TermTermType, ecoClimateZone: str = None):
+    is_wet = _is_wet(ecoClimateZone)
+    factors_key = 'default' if is_wet is None else 'wet' if is_wet else 'dry'
+    factors = N2O_FACTORS[factors_key]
+    return (factors.get(input_term_type) if factors_key == 'wet' else factors, is_wet is None)
+
+
+def _flooded_rice_factors(model_term_id: str, cycle: dict):
+    lookup_name = 'IPCC_2019_N2O_rice'
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.WATERREGIME)
+    practice = next((p for p in practices if _get_waterRegime_lookup(model_term_id, p, lookup_name) is not None), None)
+
+    factors = {
+        'value': _get_waterRegime_lookup(model_term_id, practice, lookup_name),
+        'min': _get_waterRegime_lookup(model_term_id, practice, lookup_name + '-min'),
+        'max': _get_waterRegime_lookup(model_term_id, practice, lookup_name + '-max')
+    } if practice else N2O_FACTORS['flooded_rice']
+
+    return (factors, practice is None)
+
+
+def get_N2O_factors(
+    model_term_id: str,
+    cycle: dict,
+    input_term_type: TermTermType,
+    ecoClimateZone: str = None,
+    flooded_rice: bool = False
+):
+    return _flooded_rice_factors(model_term_id, cycle) if flooded_rice \
+        else _ecoClimate_factors(input_term_type, ecoClimateZone)

hestia_earth/models/koble2014/aboveGroundCropResidue.py

@@ -12,6 +12,7 @@ from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import flatten, list_sum, list_average
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
+from hestia_earth.models.utils.cropResidue import PRODUCT_ID_TO_PRACTICES_ID
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from . import MODEL
@@ -38,20 +39,16 @@ RETURNS = {
 }
 TERM_ID = 'aboveGroundCropResidueLeftOnField,aboveGroundCropResidueBurnt,aboveGroundCropResidueIncorporated,aboveGroundCropResidueRemoved'  # noqa: E501
 TOTAL_TERM_ID = 'aboveGroundCropResidueTotal'
-MODELS = [
-    {'term': 'aboveGroundCropResidueRemoved', 'practices': ['residueRemoved']},
-    {'term': 'aboveGroundCropResidueIncorporated', 'practices': [
-        'residueIncorporated',
-        'residueIncorporatedLessThan30DaysBeforeCultivation',
-        'residueIncorporatedMoreThan30DaysBeforeCultivation'
-    ]},
-    {'term': 'aboveGroundCropResidueBurnt', 'practices': ['residueBurnt']}
-]
-REMAINING_MODEL = 'aboveGroundCropResidueLeftOnField'
+REMAINING_MODEL = PRODUCT_ID_TO_PRACTICES_ID[-1]['product']
 
 
 def _get_practices(term_id: str):
-    return flatten([model.get('practices', []) for model in MODELS if model.get('term') == term_id])
+    return flatten([
+        model.get('practices', []) for model in PRODUCT_ID_TO_PRACTICES_ID if all([
+            model.get('product') == term_id,
+            model.get('product') != REMAINING_MODEL
+        ])
+    ])
 
 
 def _get_practice_value(term_ids: list, cycle: dict) -> float:
@@ -63,12 +60,12 @@ def _get_practice_value(term_ids: list, cycle: dict) -> float:
 
 
 def _product(term_id: str, value: float):
-    product = _new_product(term_id, value, MODEL)
+    product = _new_product(term_id, round(value, 2), MODEL)
     return product
 
 
 def _should_run_model(model, cycle: dict, total_value: float):
-    term_id = model.get('term')
+    term_id = model.get('product')
     practice_value = _get_practice_value(model.get('practices'), cycle)
     has_product = find_term_match(cycle.get('products', []), term_id, None) is not None
 
@@ -102,15 +99,16 @@ def _run(cycle: dict, total_values: list):
     total_value = list_average(total_values)
     # first, calculate the remaining value available after applying all user-uploaded data
     remaining_value = reduce(
-        lambda prev, model: prev - _model_value(model.get('term'), products),
-        MODELS + [{'term': REMAINING_MODEL}],
+        lambda prev, model: prev - _model_value(model.get('product'), products),
+        PRODUCT_ID_TO_PRACTICES_ID,
         total_value
     )
 
     values = []
     # then run every model in order up to the remaining value
-    for model in MODELS:
-        term_id = model.get('term')
+    models = [model for model in PRODUCT_ID_TO_PRACTICES_ID if model.get('product') != REMAINING_MODEL]
+    for model in models:
+        term_id = model.get('product')
         value = _run_model(model, cycle, total_value)
         debugValues(cycle, model=MODEL, term=term_id,
                     total_value=total_value,

hestia_earth/models/koble2014/cropResidueManagement.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nodes_id
 from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.blank_node import get_total_value
 from .utils import _practice
@@ -66,7 +66,7 @@ def _should_run(cycle: dict):
     logRequirements(cycle, model=MODEL_LOG,
                     total_value=total_value,
                     recalculated_total_value=recalculated_total_value,
-                    recalculated_practices=';'.join([p.get('term', {}).get('@id') for p in recalculated_practices]))
+                    recalculated_practice_ids=log_blank_nodes_id(recalculated_practices))
 
     should_run = all([total_value > 0, total_value != 100, recalculated_total_value > 0])
     logShouldRun(cycle, MODEL_LOG, None, should_run)

hestia_earth/models/koble2014/utils.py

@@ -3,10 +3,12 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import find_primary_product, find_term_match
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, log_blank_nodes_id
+from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.term import get_crop_residue_management_terms
+from hestia_earth.models.utils.cropResidue import crop_residue_product_ids
 from . import MODEL
 
 
@@ -23,6 +25,7 @@ def _model_value(term_id: str, practices: list):
 def _should_run(term_id: str, cycle: dict, require_country: bool = False):
     primary_product = find_primary_product(cycle)
     has_primary_product = primary_product is not None
+
     crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
     practices = cycle.get('practices', [])
     residue_terms = get_crop_residue_management_terms()
@@ -32,6 +35,16 @@ def _should_run(term_id: str, cycle: dict, require_country: bool = False):
     ])
     has_remaining_value = remaining_value > 0
 
+    # make sure no above ground residue product has been added by the user, or values will be off
+    provided_cropResidue_products = [
+        p for p in cycle.get('products', []) if all([
+            p.get('term', {}).get('@id') in crop_residue_product_ids(),
+            p.get('value', []),
+            not is_from_model(p)
+        ])
+    ]
+    has_provided_cropResidue_products = len(provided_cropResidue_products) > 0
+
     country_id = cycle.get('site', {}).get('country', {}).get('@id')
 
     logRequirements(cycle, model=MODEL, term=term_id,
@@ -39,11 +52,14 @@ def _should_run(term_id: str, cycle: dict, require_country: bool = False):
                     term_type_cropResidue_incomplete=crop_residue_incomplete,
                     has_remaining_value=has_remaining_value,
                     crop_residue_values=residue_values,
-                    country_id=country_id)
+                    country_id=country_id,
+                    has_provided_cropResidue_products=has_provided_cropResidue_products,
+                    provided_cropResidue_product_ids=log_blank_nodes_id(provided_cropResidue_products))
 
     should_run = all([
         has_primary_product, crop_residue_incomplete, has_remaining_value,
-        not require_country or country_id
+        not require_country or country_id,
+        not has_provided_cropResidue_products
     ])
     logShouldRun(cycle, MODEL, term_id, should_run)
     return should_run, remaining_value, primary_product, country_id

hestia_earth/models/linkedImpactAssessment/__init__.py

@@ -83,8 +83,9 @@ def _group_emissions(impact: dict):
     def _group_by(prev: dict, emission: dict):
         term_id = emission.get('term', {}).get('@id')
         grouping = _emission_group(term_id)
+        value = emission.get('value') or 0
         if grouping:
-            prev[grouping] = prev.get(grouping, 0) + (emission.get('value', 0) or 0)
+            prev[grouping] = prev.get(grouping, 0) + value
         return prev
 
     emissions = impact.get('emissionsResourceUse', [])
@@ -101,7 +102,8 @@ def _run_input(cycle: dict):
         emissions = _group_emissions(impact)
 
         logRequirements(cycle, model=model, term=term_id,
-                        impact_assessment_id=input.get('impactAssessment', {}).get('@id'))
+                        impact_assessment_id=input.get('impactAssessment', {}).get('@id'),
+                        input_value=input_value)
         logShouldRun(cycle, model, term_id, True, methodTier=TIER)
 
         return [

hestia_earth/models/log.py

@@ -1,7 +1,7 @@
 import os
 import sys
 import logging
-from typing import Union
+from typing import Union, List
 
 LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
 
@@ -57,7 +57,7 @@ def logRequirements(log_node: dict, **kwargs):
     logger.info(_log_node_suffix(log_node) + 'requirements=true, ' + _join_args(**kwargs))
 
 
-def logShouldRun(log_node: dict, model: str, term: str, should_run: bool, **kwargs):
+def logShouldRun(log_node: dict, model: str, term: Union[str, None], should_run: bool, **kwargs):
     extra = (', ' + _join_args(**kwargs)) if len(kwargs.keys()) > 0 else ''
     logger.info(_log_node_suffix(log_node) + 'should_run=%s, model=%s, term=%s' + extra, should_run, model, term)
 
@@ -89,4 +89,16 @@ def log_as_table(values: Union[list, dict]):
         (
             '_'.join([f"{k}:{v}" for k, v in value.items()]) if isinstance(value, dict) else str(value)
         ) for value in values
-    ])
+    ]) or 'None'
+
+
+def log_blank_nodes_id(blank_nodes: List[dict]):
+    """
+    Log a list of blank node ids to display as a table.
+
+    Parameters
+    ----------
+    values : list
+        List of blank nodes, like Product, Input, Measurement, etc.
+    """
+    return ';'.join([p.get('term', {}).get('@id') for p in blank_nodes if p.get('term', {}).get('@id')]) or 'None'