hestia-earth-models 0.61.8__tar.gz → 0.62.0__tar.gz

{hestia-earth-models-0.61.8/hestia_earth_models.egg-info → hestia-earth-models-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.8
+Version: 0.62.0
 Summary: Hestia's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: Hestia Team

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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-0.61.8 → hestia-earth-models-0.62.0}/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