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

hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserIndirect.py

@@ -88,7 +88,7 @@ def _should_run(cycle: dict):
                     no3_n=no3_n,
                     nh3_n=nh3_n,
                     nox_n=nox_n,
-                    term_type_cropResidue_complete=term_type_complete)
+                    term_type_fertiliser_complete=term_type_complete)
 
     should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

hestia_earth/models/ipcc2019/n2OToAirOrganicFertiliserIndirect.py

@@ -88,7 +88,7 @@ def _should_run(cycle: dict):
                     no3_n=no3_n,
                     nh3_n=nh3_n,
                     nox_n=nox_n,
-                    term_type_cropResidue_complete=term_type_complete)
+                    term_type_fertiliser_complete=term_type_complete)
 
     should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)

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_1_utils.py

@@ -19,10 +19,11 @@ from typing import Callable, Optional, Union
 
 from hestia_earth.schema import MeasurementMethodClassification, SiteSiteType, TermTermType
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
+from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.utils.array_builders import gen_seed
 from hestia_earth.models.utils.blank_node import (
-    cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match, get_node_value,
+    cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match,
     node_lookup_match, node_term_match, group_nodes_by_year
 )
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -1952,6 +1953,7 @@ def _get_carbon_input_kwargs(
     crop_residue_management_nodes = filter_list_term_type(management_nodes, [TermTermType.CROPRESIDUEMANAGEMENT])
     land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
     land_use_management_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDUSEMANAGEMENT])
+    system_nodes = filter_list_term_type(management_nodes, [TermTermType.SYSTEM])
     water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
 
     has_animal_manure_used = any(
@@ -2006,7 +2008,7 @@ def _get_carbon_input_kwargs(
             node_lookup_match(node, PRACTICE_INCREASING_C_INPUT_LOOKUP, True)
             and not node_term_match(node, EXCLUDED_PRACTICE_TERM_IDS)
         ),
-        land_use_management_nodes,
+        land_use_management_nodes + system_nodes,
         cumulative_threshold=MIN_AREA_THRESHOLD
     )
 

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -19,13 +19,14 @@ from hestia_earth.schema import (
 )
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
+from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.utils.array_builders import (
     avg_run_in_columnwise, gen_seed, grouped_avg, repeat_1d_array_as_columns
 )
 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
+    cumulative_nodes_lookup_match, cumulative_nodes_term_match, group_nodes_by_year,
+    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 +1228,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": "",
@@ -162,13 +165,24 @@ def calculate_NEwool(cycle: dict) -> float:
 def _calculate_GE(
     cycle: dict, animals: list, REM: float, REG: float, NEwool: float, NEm_feed: float, NEg_feed: float, system: dict
 ) -> float:
-    values = [get_animal_values(cycle, animal, system) for animal in animals]
+    values = [get_animal_values(cycle, animal, system, log_node=cycle) for animal in animals]
     NEm = _sum_values(values, 0)
     NEa = _sum_values(values, 1)
     NEl = _sum_values(values, 2)
     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
 
 
@@ -195,7 +209,7 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: dict):
                         NEm_feed=NEm_feed,
                         NEg_feed=NEg_feed,
                         GE=GE,
-                        key_id=key_id)
+                        practice_key_id=key_id)
 
         logShouldRun(cycle, MODEL, input_term_id, True, model_key=MODEL_KEY)
 
@@ -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,
@@ -225,11 +242,12 @@ def _should_run(cycle: dict, practices: dict):
         meanECHHV > 0
     ])
 
-    for term_id in [MODEL_KEY] + [practice_input_id(p) for p in practices]:
+    for term_id in [practice_input_id(p) for p in practices] or [MODEL_KEY]:
         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
@@ -25,20 +25,20 @@ def _get_grouping(animal: dict) -> str:
     return get_lookup_value(term, 'ipcc2019AnimalTypeGrouping', model=MODEL, model_key=MODEL_KEY)
 
 
-def _get_activityCoefficient(cycle: dict, animal: dict, system: dict) -> float:
+def _get_activityCoefficient(cycle: dict, animal: dict, system: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
     system_id = system.get('term', {}).get('@id')
     lookup = download_lookup('system-liveAnimal-activityCoefficient-ipcc2019.csv')
     activityCoefficient = safe_parse_float(get_table_value(lookup, 'termid', system_id, column_name(term_id)), 0)
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 activityCoefficient=activityCoefficient)
 
     return activityCoefficient
 
 
-def _calculate_NEm(cycle: dict, animal: dict) -> float:
+def _calculate_NEm(cycle: dict, animal: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -50,7 +50,7 @@ def _calculate_NEm(cycle: dict, animal: dict) -> float:
     cycleDuration = cycle.get('cycleDuration', 365)
     NEm = mjDayKgCfiNetEnergyMaintenance * pow(liveweightPerHead, 0.75) * animal_value * cycleDuration
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 mjDayKgCfiNetEnergyMaintenance=mjDayKgCfiNetEnergyMaintenance,
                 liveweightPerHead=liveweightPerHead,
                 NEm=NEm)
@@ -58,32 +58,32 @@ def _calculate_NEm(cycle: dict, animal: dict) -> float:
     return NEm
 
 
-def _calculate_NEa_cattleAndBuffalo(cycle: dict, animal: dict, system: dict, NEm: float) -> float:
+def _calculate_NEa_cattleAndBuffalo(cycle: dict, animal: dict, system: dict, NEm: float, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
-    activityCoefficient = _get_activityCoefficient(cycle, animal, system)
+    activityCoefficient = _get_activityCoefficient(cycle, animal, system, log_node)
 
     NEa = activityCoefficient * NEm
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 NEa=NEa)
 
     return NEa
 
 
-def _calculate_NEa_sheepAndGoat(cycle: dict, animal: dict, system: dict, _NEm: float) -> float:
+def _calculate_NEa_sheepAndGoat(cycle: dict, animal: dict, system: dict, _NEm: float, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
-    activityCoefficient = _get_activityCoefficient(cycle, animal, system)
+    activityCoefficient = _get_activityCoefficient(cycle, animal, system, log_node)
 
     liveweightPerHead = get_node_property(animal, 'liveweightPerHead', False).get('value', 0)
     animal_value = animal.get('value', 0)
     cycleDuration = cycle.get('cycleDuration', 365)
     NEa = activityCoefficient * liveweightPerHead * animal_value * cycleDuration
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 liveweightPerHead=liveweightPerHead,
                 NEa=NEa)
 
@@ -96,12 +96,12 @@ _NEa_BY_GROUPING = {
 }
 
 
-def _calculate_NEa(cycle: dict, animal: dict, system: dict, NEm: float) -> float:
+def _calculate_NEa(cycle: dict, animal: dict, system: dict, NEm: float, log_node: dict) -> 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, log_node)
 
 
-def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
+def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -112,7 +112,7 @@ def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
     cycleDuration = cycle.get('cycleDuration', 365)
     NEl = milkYield * (1.47 + (0.4 * fatContent)) * animal_value * cycleDuration
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 milkYield=milkYield,
                 fatContent=fatContent,
                 NEl=NEl)
@@ -120,7 +120,7 @@ def _calculate_NEl_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
     return NEl
 
 
-def _calculate_NEl_sheepAndGoat(cycle: dict, animal: dict) -> float:
+def _calculate_NEl_sheepAndGoat(cycle: dict, animal: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -140,7 +140,7 @@ def _calculate_NEl_sheepAndGoat(cycle: dict, animal: dict) -> float:
     cycleDuration = cycle.get('cycleDuration', 365)
     NEl = milkYield * (EV_milk * fatContent/default_fatContent) * animal_value * cycleDuration
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 milkYield=milkYield,
                 EV_milk=EV_milk,
                 NEl=NEl)
@@ -154,19 +154,19 @@ _NEl_BY_GROUPING = {
 }
 
 
-def _calculate_NEl(cycle: dict, animal: dict) -> float:
+def _calculate_NEl(cycle: dict, animal: dict, log_node: 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, log_node)
 
 
-def _calculate_NEwork(cycle: dict, animal: dict, NEm: float) -> float:
+def _calculate_NEwork(cycle: dict, animal: dict, NEm: float, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
     hoursWorkedPerDay = get_node_property(animal, 'hoursWorkedPerDay').get('value', 0)
     NEwork = 0.1 * NEm * hoursWorkedPerDay
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 hoursWorkedPerDay=hoursWorkedPerDay,
                 NEwork=NEwork)
 
@@ -193,7 +193,7 @@ def _get_pregnancy_ratio(animal: dict) -> float:
     return _get_pregnancy_ratio_per_birth(animal, value) if ';' in value else safe_parse_float(value, 0)
 
 
-def _calculate_NEp(cycle: dict, animal: dict, NEm: float) -> float:
+def _calculate_NEp(cycle: dict, animal: dict, NEm: float, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -201,7 +201,7 @@ def _calculate_NEp(cycle: dict, animal: dict, NEm: float) -> float:
     pregnancyRateTotal = get_node_property(animal, 'pregnancyRateTotal').get('value', 0)
     NEp = ratioCPregnancyNetEnergyPregnancy * pregnancyRateTotal/100 * NEm
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 ratioCPregnancyNetEnergyPregnancy=ratioCPregnancyNetEnergyPregnancy,
                 pregnancyRateTotal=pregnancyRateTotal,
                 NEp=NEp)
@@ -209,7 +209,7 @@ def _calculate_NEp(cycle: dict, animal: dict, NEm: float) -> float:
     return NEp
 
 
-def _calculate_NEg_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
+def _calculate_NEg_cattleAndBuffalo(cycle: dict, animal: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -228,7 +228,7 @@ def _calculate_NEg_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
             ratioCNetEnergyGrowthCattleBuffalo * weightAtMaturity > 0
         ]) else 0
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 ratioCNetEnergyGrowthCattleBuffalo=ratioCNetEnergyGrowthCattleBuffalo,
                 liveweightPerHead=liveweightPerHead,
                 weightAtMaturity=weightAtMaturity,
@@ -238,7 +238,7 @@ def _calculate_NEg_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
     return NEg
 
 
-def _calculate_NEg_sheepAndGoat(cycle: dict, animal: dict) -> float:
+def _calculate_NEg_sheepAndGoat(cycle: dict, animal: dict, log_node: dict) -> float:
     term = animal.get('term', {})
     term_id = term.get('@id')
 
@@ -253,7 +253,7 @@ def _calculate_NEg_sheepAndGoat(cycle: dict, animal: dict) -> float:
     cycleDuration = cycle.get('cycleDuration', 365)
     NEg = (BWf - BWi) * (MjKg_a + 0.5 * MjKg_b * (BWi + BWf)) / 365 * animal_value * cycleDuration
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 MjKg_a=MjKg_a,
                 MjKg_b=MjKg_b,
                 BWi=BWi,
@@ -269,9 +269,9 @@ _NEg_BY_GROUPING = {
 }
 
 
-def _calculate_NEg(cycle: dict, animal: dict) -> float:
+def _calculate_NEg(cycle: dict, animal: dict, log_node: dict) -> float:
     grouping = _get_grouping(animal)
-    return _NEg_BY_GROUPING.get(grouping, lambda *args: None)(cycle, animal)
+    return _NEg_BY_GROUPING.get(grouping, lambda *args: 0)(cycle, animal, log_node)
 
 
 def _pastureGrass_key_property_value(practice: dict, column: dict):
@@ -291,14 +291,14 @@ def calculate_REG(energy: float = 0) -> float:
     return 1.164 - (5.16/1000 * energy) + (1.308/100000 * pow(energy, 2)) - (37.4/energy) if energy > 0 else 0
 
 
-def _calculate_feed_meanDE(node: dict, input: dict) -> float:
+def _calculate_feed_meanDE(log_node: dict, input: dict) -> float:
     term_id = input.get('term', {}).get('@id')
 
     energyContent = get_node_property_value(MODEL, input, 'energyContentHigherHeatingValue')
     energyDigestibility = get_node_property_value(MODEL, input, 'energyDigestibilityRuminants')
     meanDE = energyContent * energyDigestibility if all([energyContent, energyDigestibility]) else 0
 
-    debugValues(node, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 energyContent=energyContent,
                 energyDigestibility=energyDigestibility,
                 meanDE=meanDE)
@@ -306,26 +306,26 @@ def _calculate_feed_meanDE(node: dict, input: dict) -> float:
     return meanDE
 
 
-def _calculate_NEfeed_m(node: dict, input: dict, meanDE: float) -> float:
+def _calculate_NEfeed_m(log_node: dict, input: dict, meanDE: float) -> float:
     term_id = input.get('term', {}).get('@id')
 
     energyDigestibility = get_node_property_value(MODEL, input, 'energyDigestibilityRuminants', default=0)
     REm = calculate_REM(energyDigestibility * 100)
 
-    debugValues(node, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 REm=REm)
 
     input_value = list_sum(input.get('value'))
     return meanDE * REm * input_value
 
 
-def _calculate_NEfeed_g(node: dict, input: dict, meanDE: float) -> float:
+def _calculate_NEfeed_g(log_node: dict, input: dict, meanDE: float) -> float:
     term_id = input.get('term', {}).get('@id')
 
     energyDigestibility = get_node_property_value(MODEL, input, 'energyDigestibilityRuminants', default=0)
     REg = calculate_REG(energyDigestibility * 100)
 
-    debugValues(node, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(log_node, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 REg=REg)
 
     input_value = list_sum(input.get('value'))
@@ -346,23 +346,13 @@ def calculate_NEfeed(node: dict) -> tuple:
     return (NEfeed_m, NEfeed_g)
 
 
-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)
-    NEwork = _calculate_NEwork(cycle, animal, NEm)
-    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)
+def get_animal_values(cycle: dict, animal: dict, system: dict, log_node: dict):
+    NEm = _calculate_NEm(cycle, animal, log_node=log_node)
+    NEa = _calculate_NEa(cycle, animal, system, NEm, log_node=log_node)
+    NEl = _calculate_NEl(cycle, animal, log_node=log_node)
+    NEwork = _calculate_NEwork(cycle, animal, NEm, log_node=log_node)
+    NEp = _calculate_NEp(cycle, animal, NEm, log_node=log_node)
+    NEg = _calculate_NEg(cycle, animal, log_node=log_node)
 
     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