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

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -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: 0)(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: 0)(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,13 +346,13 @@ def calculate_NEfeed(node: dict) -> tuple:
     return (NEfeed_m, NEfeed_g)
 
 
-def get_animal_values(cycle: dict, animal: dict, system: dict):
-    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)
+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)