hestia-earth-models 0.61.8__py3-none-any.whl → 0.62.0__py3-none-any.whl

hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -9,10 +9,12 @@ 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"}
@@ -42,6 +44,7 @@ def _practice_value(practice: dict):
 
 
 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
@@ -49,8 +52,9 @@ def run(cycle: dict):
     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([p.get('fuel_use') for p in practices_values])
+    is_complete = all([operation_complete] + [p.get('fuel_use') for p in practices_values])
 
     return is_complete

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/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/ipcc2019/organicCarbonPerHa.py

@@ -139,13 +139,11 @@ def run(site: dict) -> list[dict]:
     """
     should_run, run_data = _should_run(site)
     _log_data(site, should_run, run_data)
-    return next(
-        (
-            _run_method(method, **run_data[method]) for method in run_data.keys()
-            if run_data[method]["should_run"]
-        ),
+    return reduce(
+        lambda result, method: result + _run_method(method, **run_data[method]),
+        run_data,
         list()
-    ) if should_run else []
+    )
 
 
 def _should_run(site: dict) -> tuple[bool, dict[ModuleType, dict]]:

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -25,7 +25,7 @@ from hestia_earth.models.utils.array_builders import (
 )
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_lookup_match, cumulative_nodes_term_match, get_node_value, group_nodes_by_year,
-    group_nodes_by_year_and_month, GroupNodesByYearMode
+    group_nodes_by_year_and_month, GroupNodesByYearMode, node_term_match
 )
 from hestia_earth.models.utils.cycle import check_cycle_site_ids_identical
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -1227,15 +1227,15 @@ def _check_12_months(inner_dict: dict, keys: set[Any]):
 def _get_grouped_climate_measurements(grouped_measurements: dict) -> dict:
     return {
         year: {
-            _InventoryKey.TEMP_MONTHLY: non_empty_list(
-                find_term_match(measurements, _TEMPERATURE_MONTHLY_TERM_ID, {}).get("value", [])
-            ),
-            _InventoryKey.PRECIP_MONTHLY: non_empty_list(
-                find_term_match(measurements, _PRECIPITATION_MONTHLY_TERM_ID, {}).get("value", [])
-            ),
-            _InventoryKey.PET_MONTHLY: non_empty_list(
-                find_term_match(measurements, _PET_MONTHLY_TERM_ID, {}).get("value", [])
-            )
+            _InventoryKey.TEMP_MONTHLY: non_empty_list(flatten(
+                node.get("value", []) for node in measurements if node_term_match(node, _TEMPERATURE_MONTHLY_TERM_ID)
+            )),
+            _InventoryKey.PRECIP_MONTHLY: non_empty_list(flatten(
+                node.get("value", []) for node in measurements if node_term_match(node, _PRECIPITATION_MONTHLY_TERM_ID)
+            )),
+            _InventoryKey.PET_MONTHLY: non_empty_list(flatten(
+                node.get("value", []) for node in measurements if node_term_match(node, _PET_MONTHLY_TERM_ID)
+            ))
         } for year, measurements in grouped_measurements.items()
     }
 

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -1,15 +1,18 @@
 """
-Full Grass Consumption
+Cycle 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 Cycle level, if at least one Cycle Input is 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
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.term import get_wool_terms
 from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_term_type_incomplete
@@ -30,7 +33,7 @@ from .pastureGrass_utils import (
 REQUIREMENTS = {
     "Cycle": {
         "completeness.animalFeed": "True",
-        "completeness.animalPopulation": "False",
+        "completeness.animalPopulation": "True",
         "completeness.freshForage": "False",
         "site": {
             "@type": "Site",
@@ -45,6 +48,19 @@ REQUIREMENTS = {
                 "term.termType": "landCover"
             }
         }],
+        "inputs": [{
+            "@type": "Input",
+            "term.units": "kg",
+            "value": "> 0",
+            "isAnimalFeed": "True",
+            "optional": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                }]
+            }
+        }],
         "animals": [{
             "@type": "Animal",
             "value": "> 0",
@@ -93,19 +109,6 @@ REQUIREMENTS = {
             }
         }],
         "optional": {
-            "inputs": [{
-                "@type": "Input",
-                "term.units": "kg",
-                "value": "> 0",
-                "isAnimalFeed": "True",
-                "optional": {
-                    "properties": [{
-                        "@type": "Property",
-                        "value": "",
-                        "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
-                    }]
-                }
-            }],
             "products": [{
                 "@type": "Product",
                 "value": "",
@@ -169,6 +172,17 @@ def _calculate_GE(
     NEwork = _sum_values(values, 3)
     NEp = _sum_values(values, 4)
     NEg = _sum_values(values, 5)
+
+    debugValues(cycle, model=MODEL, term=MODEL_KEY, model_key=MODEL_KEY,
+                NEm=NEm,
+                NEa=NEa,
+                NEl=NEl,
+                NEwork=NEwork,
+                NEp=NEp,
+                NEg=NEg,
+                NEm_feed=NEm_feed,
+                NEg_feed=NEg_feed)
+
     return (NEm + NEa + NEl + NEwork + NEp - NEm_feed)/REM + (NEg + NEwool - NEg_feed)/REG
 
 
@@ -207,17 +221,20 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: 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')
-    animalPopulation_incomplete = _is_term_type_incomplete(cycle, 'animalPopulation')
+    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', [])])
 
+    has_cycle_inputs_feed = any([i.get('isAnimalFeed', False) for i in cycle.get('inputs', [])])
+
     meanDE = calculate_meanDE(practices)
     meanECHHV = calculate_meanECHHV(practices)
 
     should_run = all([
         animalFeed_complete,
-        animalPopulation_incomplete,
+        animalPopulation_complete,
         freshForage_incomplete,
+        has_cycle_inputs_feed,
         all_animals_have_value,
         len(systems) > 0,
         len(practices) > 0,
@@ -228,8 +245,9 @@ 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_incomplete=animalPopulation_incomplete,
+                        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,
                         meanDE=meanDE,
                         meanECHHV=meanECHHV)

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues
 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
@@ -98,7 +98,7 @@ _NEa_BY_GROUPING = {
 
 def _calculate_NEa(cycle: dict, animal: dict, system: dict, NEm: float) -> float:
     grouping = _get_grouping(animal)
-    return _NEa_BY_GROUPING.get(grouping, lambda *args: None)(cycle, animal, system, NEm)
+    return _NEa_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal, system, NEm)
 
 
 def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
@@ -156,7 +156,7 @@ _NEl_BY_GROUPING = {
 
 def _calculate_NEl(cycle: dict, animal: dict) -> float:
     grouping = _get_grouping(animal)
-    return _NEl_BY_GROUPING.get(grouping, lambda *args: None)(cycle, animal)
+    return _NEl_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal)
 
 
 def _calculate_NEwork(cycle: dict, animal: dict, NEm: float) -> float:
@@ -347,8 +347,6 @@ def calculate_NEfeed(node: dict) -> tuple:
 
 
 def get_animal_values(cycle: dict, animal: dict, system: dict):
-    term_id = animal.get('term', {}).get('@id')
-
     NEm = _calculate_NEm(cycle, animal)
     NEa = _calculate_NEa(cycle, animal, system, NEm)
     NEl = _calculate_NEl(cycle, animal)
@@ -356,14 +354,6 @@ def get_animal_values(cycle: dict, animal: dict, system: dict):
     NEp = _calculate_NEp(cycle, animal, NEm)
     NEg = _calculate_NEg(cycle, animal)
 
-    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                    NEm=NEm,
-                    NEa=NEa,
-                    NEl=NEl,
-                    NEwork=NEwork,
-                    NEp=NEp,
-                    NEg=NEg)
-
     return (NEm, NEa, NEl, NEwork, NEp, NEg)
 
 
@@ -394,14 +384,7 @@ def should_run_practice(cycle: dict):
         term_id = practice.get('term', {}).get('@id')
         key_term_type = practice.get('key', {}).get('termType')
         value = practice.get('value', [])
-
-        logRequirements(cycle, model=MODEL, term=term_id,
-                        practice_value=list_sum(value),
-                        practice_key_term_type=key_term_type)
-
-        should_run = all([len(value) > 0, term_id == MODEL_KEY, key_term_type in KEY_TERM_TYPES])
-        logShouldRun(cycle, MODEL, term_id, should_run)
-        return should_run
+        return all([len(value) > 0, term_id == MODEL_KEY, key_term_type in KEY_TERM_TYPES])
 
     return should_run