hestia-earth-models 0.75.1__py3-none-any.whl → 0.75.3__py3-none-any.whl

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -10,6 +10,7 @@ from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_t
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from . import MODEL
 from .pastureGrass_utils import (
+    has_cycle_inputs_feed,
     practice_input_id,
     should_run_practice,
     calculate_meanDE,
@@ -56,7 +57,11 @@ REQUIREMENTS = {
                 "properties": [{
                     "@type": "Property",
                     "value": "",
-                    "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                    "term.@id": [
+                        "neutralDetergentFibreContent",
+                        "energyContentHigherHeatingValue",
+                        "energyDigestibilityRuminants"
+                    ]
                 }]
             }
         }],
@@ -175,6 +180,7 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
     GE = (
         calculate_GE(animal_values, REM, REG, NEwool, NEm_feed, NEg_feed) / (meanDE/100)
     ) if meanDE else 0
+    has_positive_GE_value = GE >= 0
 
     def run(practice: dict):
         key = practice.get('key', {})
@@ -206,11 +212,12 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),
                         has_positive_feed_values=has_positive_feed_values,
+                        has_positive_GE_value=has_positive_GE_value,
                         animal_logs=logs,
                         animal_lookups=animal_lookups,
                         animal_properties=animal_properties)
 
-        should_run = all([has_positive_feed_values])
+        should_run = all([has_positive_feed_values, has_positive_GE_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, model_key=MODEL_KEY)
 
         return _input(input_term_id, value) if should_run else None
@@ -225,10 +232,8 @@ def _should_run(cycle: dict, practices: dict):
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
 
-    has_cycle_inputs_feed = any([i.get('isAnimalFeed', False) for i in cycle.get('inputs', [])])
-
-    meanDE = calculate_meanDE(practices)
-    meanECHHV = calculate_meanECHHV(practices)
+    meanDE = calculate_meanDE(cycle, practices)
+    meanECHHV = calculate_meanECHHV(cycle, practices)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
@@ -239,7 +244,6 @@ def _should_run(cycle: dict, practices: dict):
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
-        has_cycle_inputs_feed,
         all_animals_have_value,
         has_practice_termType_system,
         has_practice_pastureGrass_with_landCover_key,
@@ -252,12 +256,11 @@ def _should_run(cycle: dict, practices: dict):
                         term_type_animalFeed_complete=animalFeed_complete,
                         term_type_animalPopulation_complete=animalPopulation_complete,
                         term_type_freshForage_incomplete=freshForage_incomplete,
-                        has_cycle_inputs_feed=has_cycle_inputs_feed,
                         all_animals_have_value=all_animals_have_value,
                         has_practice_termType_system=has_practice_termType_system,
                         has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
-                        grass_MeanDE=calculate_meanDE(practices, term=term_id),
-                        grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                        grass_MeanDE=calculate_meanDE(cycle, practices, term=term_id),
+                        grass_MeanECHHV=calculate_meanECHHV(cycle, practices, term=term_id),
                         grass_REM=REM,
                         grass_REG=REG)
 
@@ -266,9 +269,14 @@ def _should_run(cycle: dict, practices: dict):
     return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
-def run(cycle: dict):
+def _run(cycle: dict):
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, practices)
     return non_empty_list(
         map(_run_practice(cycle, meanDE, meanECHHV, REM, REG, systems), practices)
     ) if should_run else []
+
+
+def run(cycle: dict):
+    # determines if this model or animal model should run
+    return _run(cycle) if has_cycle_inputs_feed(cycle) else []

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -2,12 +2,13 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, extract_grouped_data
 from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.model import find_term_match
 
 from hestia_earth.models.log import debugValues
 from hestia_earth.models.utils import weighted_average
 from hestia_earth.models.utils.input import get_feed_inputs
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.property import get_node_property, get_node_property_value, node_property_lookup_value
+from hestia_earth.models.utils.property import get_node_property, get_node_property_value
 from .utils import get_milkYield_practice
 from . import MODEL
 
@@ -17,6 +18,9 @@ KEY_TERM_TYPES = [
 ]
 
 
+def has_cycle_inputs_feed(cycle: dict): return any([i.get('isAnimalFeed', False) for i in cycle.get('inputs', [])])
+
+
 def practice_input_id(practice: dict):
     return get_lookup_value(practice.get('key', {}), 'grazedPastureGrassInputId', model=MODEL, model_key=MODEL_KEY)
 
@@ -217,13 +221,16 @@ def _calculate_NEg(cycle: dict, animal: dict) -> float:
     return _NEg_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal)
 
 
-def _pastureGrass_key_property_value(column: dict, **log_args):
+def _pastureGrass_key_property_value(node: dict, property_id: dict, **log_args):
     def get_value(practice: dict):
         term_id = practice_input_id(practice)
-        term = download_hestia(term_id)
-        value = list_sum(practice.get('value', [0]))
-        lookup_value = node_property_lookup_value(MODEL, term_id, term.get('termType'), column, default=0, **log_args)
-        return (lookup_value, value)
+        # try to find the input with the same id, as it can contain the properties
+        input = find_term_match(node.get('inputs', []), term_id) or {
+            'term': download_hestia(term_id)
+        }
+        property_value = get_node_property_value(MODEL, input, property_id, default=0, **log_args)
+        practice_value = list_sum(practice.get('value', [0]))
+        return (property_value, practice_value)
     return get_value
 
 
@@ -337,16 +344,16 @@ def calculate_GE(values: list, REM: float, REG: float, NEwool: float, NEm_feed:
     return ((REM_factor - NEm_feed_corrected)/REM + (REG_factor - NEg_feed_corrected)/REG) if all([REM, REG]) else 0
 
 
-def calculate_meanECHHV(practices: list, **log_args) -> float:
-    values = list(map(_pastureGrass_key_property_value('energyContentHigherHeatingValue', **log_args), practices))
+def calculate_meanECHHV(node: dict, practices: list, **log_args) -> float:
+    values = list(map(_pastureGrass_key_property_value(node, 'energyContentHigherHeatingValue', **log_args), practices))
     total_weight = sum([weight/100 for _value, weight in values])
     return sum([
         (value * weight/100 if all([value, weight]) else 0) for value, weight in values
     ]) / total_weight if total_weight > 0 else 0
 
 
-def calculate_meanDE(practices: list, **log_args) -> float:
-    values = list(map(_pastureGrass_key_property_value('energyDigestibilityRuminants', **log_args), practices))
+def calculate_meanDE(node: dict, practices: list, **log_args) -> float:
+    values = list(map(_pastureGrass_key_property_value(node, 'energyDigestibilityRuminants', **log_args), practices))
     total_weight = sum([weight/100 for _value, weight in values])
     meanDE = sum([
         (value * weight/100 if all([value, weight]) else 0) for value, weight in values

hestia_earth/models/linkedImpactAssessment/emissions.py

@@ -53,7 +53,7 @@ _GROUP_BY_KEYS = ['term', 'key', 'operation', 'animal']
 
 
 def _emission(model: str, term_id: str, value: float, input: dict, animal={}, extra={}):
-    emission = _new_emission(term=term_id, model=MODEL, value=value)
+    emission = _new_emission(term=term_id, model=model, value=value)
     emission['methodTier'] = TIER
     emission['inputs'] = [input]
     if animal: