hestia-earth-models 0.67.1__py3-none-any.whl → 0.68.1__py3-none-any.whl

hestia_earth/models/geospatialDatabase/altitude.py

@@ -0,0 +1,60 @@
+from hestia_earth.schema import MeasurementMethodClassification
+from hestia_earth.utils.tools import safe_parse_float
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.source import get_source
+from .utils import download, has_geospatial_data, should_download
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "or": [
+            {"latitude": "", "longitude": ""},
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
+        ]
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "",
+        "methodClassification": "geospatial dataset"
+    }]
+}
+TERM_ID = 'altitude'
+EE_PARAMS = {
+    'collection': 'USGS/GMTED2010_FULL',
+    'ee_type': 'raster',
+    'band_name': 'med',
+    'is_image': True
+}
+BIBLIO_TITLE = 'An Enhanced Global Elevation Model Generalized From Multiple Higher Resolution Source Datasets'
+
+
+def _measurement(site: dict, value: float):
+    measurement = _new_measurement(TERM_ID)
+    measurement['value'] = [value]
+    measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
+    return measurement | get_source(site, BIBLIO_TITLE)
+
+
+def _run(site: dict):
+    value = download(TERM_ID, site, EE_PARAMS)
+    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+
+
+def _should_run(site: dict):
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(TERM_ID, site)
+
+    logRequirements(site, model=MODEL, term=TERM_ID,
+                    contains_geospatial_data=contains_geospatial_data,
+                    below_max_area_size=below_max_area_size)
+
+    should_run = all([contains_geospatial_data, below_max_area_size])
+    logShouldRun(site, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(site: dict): return _run(site) if _should_run(site) else []

hestia_earth/models/geospatialDatabase/croppingIntensity.py

@@ -65,7 +65,7 @@ def _should_run(cycle: dict):
 
 
 def run(cycle: dict):
-    sites = get_allowed_sites(MODEL, TERM_ID, TermTermType.LANDUSEMANAGEMENT, cycle) if _should_run(cycle) else []
+    sites = get_allowed_sites(MODEL, TERM_ID, cycle) if _should_run(cycle) else []
     sites = [
         (site, get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)) for site in sites
     ]

hestia_earth/models/geospatialDatabase/ecoClimateZone.py

@@ -79,7 +79,7 @@ def _run_default(site: dict):
                     region_factor=region_factor)
 
     should_run = all([region_factor])
-    logShouldRun(site, MODEL, TERM_ID, should_run)
+    logShouldRun(site, MODEL, TERM_ID, should_run, run_by='Lookup')
     return [_measurement(site, round(region_factor))] if should_run else []
 
 
@@ -92,7 +92,7 @@ def _should_run(site: dict):
                     below_max_area_size=below_max_area_size)
 
     should_run = all([contains_geospatial_data, below_max_area_size])
-    logShouldRun(site, MODEL, TERM_ID, should_run)
+    logShouldRun(site, MODEL, TERM_ID, should_run, run_by='Earth Engine')
     return should_run
 
 

hestia_earth/models/geospatialDatabase/longFallowRatio.py

@@ -65,7 +65,7 @@ def _should_run(cycle: dict):
 
 
 def run(cycle: dict):
-    sites = get_allowed_sites(MODEL, TERM_ID, TermTermType.LANDUSEMANAGEMENT, cycle) if _should_run(cycle) else []
+    sites = get_allowed_sites(MODEL, TERM_ID, cycle) if _should_run(cycle) else []
     sites = [
         (site, get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)) for site in sites
     ]

hestia_earth/models/geospatialDatabase/utils.py

@@ -196,4 +196,7 @@ def download(term: str, site: dict, data: dict, only_coordinates=False) -> dict:
 def get_region_factor(term_id: str, site: dict, termType: TermTermType = TermTermType.MEASUREMENT):
     region_id = region_level_1_id(site.get('region', {}).get('@id'))
     country_id = site.get('country', {}).get('@id')
-    return region_factor(MODEL, region_id, term_id, termType) or region_factor(MODEL, country_id, term_id, termType)
+    return (
+        # `region-measurement` only exists for countries
+        region_factor(MODEL, region_id, term_id, termType) if termType != TermTermType.MEASUREMENT else None
+    ) or region_factor(MODEL, country_id, term_id, termType)

hestia_earth/models/globalCropWaterModel2008/rootingDepth.py

@@ -1,11 +1,10 @@
 from hestia_earth.schema import CycleFunctionalUnit, TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, non_empty_list, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.property import _new_property, node_has_no_property
-from hestia_earth.models.utils.term import get_irrigation_terms
+from hestia_earth.models.utils.term import get_irrigation_terms, download_term
 from hestia_earth.models.utils.crop import get_crop_lookup_value
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
@@ -81,7 +80,7 @@ def _should_run_product(cycle: dict):
 
 
 def _run_cycle(products: list):
-    term = download_hestia(TERM_ID)
+    term = download_term(TERM_ID, TermTermType.PROPERTY)
 
     def run_product(values: tuple):
         product, value = values

hestia_earth/models/haversineFormula/transport/distance.py

@@ -10,7 +10,7 @@ from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
-from hestia_earth.models.utils import _include_methodModel
+from hestia_earth.models.utils.method import include_methodModel
 from .. import MODEL
 
 REQUIREMENTS = {
@@ -39,8 +39,8 @@ MODEL_KEY = 'distance'
 
 def _run_transport(cycle: dict, distance_kms: float):
     def exec(transport: dict):
-        return _include_methodModel({
-            **transport, MODEL_KEY: distance_kms
+        return include_methodModel(transport | {
+            MODEL_KEY: distance_kms
         }, MODEL) if _should_run_transport(cycle, transport) else transport
     return exec
 

hestia_earth/models/hestia/landCover.py

@@ -10,7 +10,7 @@ from datetime import datetime, timedelta
 
 from hestia_earth.schema import SiteSiteType, TermTermType
 from hestia_earth.utils.lookup import (
-    download_lookup, get_table_value, column_name, _is_missing_value, extract_grouped_data
+    download_lookup, get_table_value, column_name, _is_missing_value, extract_grouped_data, lookup_columns
 )
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, to_precision
@@ -19,6 +19,7 @@ from hestia_earth.models.log import logRequirements, log_as_table, logShouldRun
 from hestia_earth.models.utils.constant import DAYS_IN_YEAR
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from hestia_earth.models.utils.blank_node import _node_date, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
 from .utils import (
     IPCC_LAND_USE_CATEGORY_ANNUAL,
@@ -71,9 +72,9 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion": "All crops",
-    "region-crop-cropGroupingFaostatProduction-areaHarvested": "All crops",
-    "region-faostatArea-UpTo20YearExpansion": "All land uses",
+    "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion": "",
+    "region-crop-cropGroupingFaostatProduction-areaHarvested": "",
+    "region-faostatArea-UpTo20YearExpansion": "",
     "region-faostatArea": [
         "Arable land",
         "Cropland",
@@ -99,6 +100,7 @@ SITE_TYPES = {
 DEFAULT_WINDOW_IN_YEARS = 20
 DATE_TOLERANCE_IN_YEARS = 2
 OUTPUT_SIGNIFICANT_DIGITS = 3
+_LOOKUP_EXPANSION = "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv"
 
 
 def _management(term_id: str, value: float, start_date: str, end_date: str):
@@ -117,10 +119,25 @@ def _safe_divide(numerator, denominator, default=0) -> float:
     return default if not denominator else numerator / denominator
 
 
+def scale_values_to_one(dictionary: dict) -> dict:
+    """
+    Takes a dictionary with numeric values.
+    Scales each value so that the sum of them all is one.
+    """
+    # Does not handle negative values.
+    sum_of_values = sum(dictionary.values())
+    return {key: value / sum_of_values for key, value in dictionary.items()} if sum_of_values != 0 else dictionary
+
+
+def cap_values(dictionary: dict, lower_limit: float = 0, upper_limit: float = 1) -> dict:
+    return {key: min([upper_limit, max([lower_limit, value])]) for key, value in dictionary.items()}
+
+
 def site_area_sum_to_100(dict_of_percentages: dict):
-    return False if dict_of_percentages == {} else \
-        (math.isclose(sum(dict_of_percentages.values()), 1.0, rel_tol=0.01) or
-         math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01))
+    return False if dict_of_percentages == {} else (
+        math.isclose(sum(dict_of_percentages.values()), 1.0, rel_tol=0.01) or
+        math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01)
+    )
 
 
 def _should_group_landCover(term: dict):
@@ -134,12 +151,13 @@ def get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
     """
-    lookup = download_lookup("region-faostatArea-UpTo20YearExpansion.csv")
+    lookup_name = "region-faostatArea-UpTo20YearExpansion.csv"
     changes_dict = {
         land_use_term: safe_parse_float(
             extract_grouped_data(
-                get_table_value(lookup, 'termid', country_id, column_name(land_use_term)),
-                str(end_year)),
+                get_region_lookup_value(lookup_name, country_id, land_use_term, model=MODEL, key=MODEL_KEY),
+                str(end_year)
+            ),
             default=None
         )
         for land_use_term in ALL_LAND_USE_TERMS + [LAND_AREA]
@@ -160,8 +178,7 @@ def _get_ratio_start_and_end_values(
     end_year: int
 ) -> float:
     # expansion over twenty years / current area
-    lookup = download_lookup('region-faostatArea.csv')
-    table_value = get_table_value(lookup, 'termid', country_id, column_name(fao_name))
+    table_value = get_region_lookup_value('region-faostatArea.csv', country_id, fao_name, model=MODEL, key=MODEL_KEY)
     end_value = safe_parse_float(value=extract_grouped_data(table_value, str(end_year)), default=None)
     return max(0.0, _safe_divide(numerator=expansion, denominator=end_value))
 
@@ -186,11 +203,13 @@ def _estimate_maximum_forest_change(
 
 
 def _negative_agricultural_land_change(forest_change, pasture_change, total_cropland_change):
-    return -pasture_change if 0 < pasture_change < -min(forest_change, 0) \
-        else min(forest_change, 0) if pasture_change > 0 \
-        else -total_cropland_change if 0 < total_cropland_change < -min(forest_change, 0) \
-        else min(forest_change, 0) if 0 < total_cropland_change \
+    return (
+        -pasture_change if 0 < pasture_change < -min(forest_change, 0)
+        else min(forest_change, 0) if pasture_change > 0
+        else -total_cropland_change if 0 < total_cropland_change < -min(forest_change, 0)
+        else min(forest_change, 0) if 0 < total_cropland_change
         else 0
+    )
 
 
 def _allocate_forest_loss(forest_loss: float, changes: dict):
@@ -271,12 +290,14 @@ def _estimate_conversions_to_annual_cropland(
     permanent_to_annual_cropland: float
 ) -> dict:
     """(AC-AG): Estimate percentage of land sources when converted to: Annual cropland"""
+
     # -> percent_annual_cropland_was[]
     def conversion_to_annual_cropland(factor: float):
         return factor * _safe_divide(
             numerator=_safe_divide(
                 numerator=max(changes[ANNUAL_CROPLAND], 0),
-                denominator=max(changes[ANNUAL_CROPLAND], 0) + max(changes[PERMANENT_CROPLAND], 0)),
+                denominator=max(changes[ANNUAL_CROPLAND], 0) + max(changes[PERMANENT_CROPLAND], 0)
+            ),
             denominator=-changes[ANNUAL_CROPLAND]
         )
 
@@ -297,11 +318,13 @@ def _estimate_conversions_to_permanent_cropland(
     other_land_loss_to_annual_cropland: float
 ) -> dict:
     """Estimate percentage of land sources when converted to: Annual cropland"""
+
     def conversion_to_permanent_cropland(factor: float):
         return _safe_divide(
             numerator=_safe_divide(
                 numerator=factor * max(changes[PERMANENT_CROPLAND], 0),
-                denominator=max(changes[ANNUAL_CROPLAND], 0) + max(changes[PERMANENT_CROPLAND], 0)),
+                denominator=max(changes[ANNUAL_CROPLAND], 0) + max(changes[PERMANENT_CROPLAND], 0)
+            ),
             denominator=-changes[PERMANENT_CROPLAND]
         )
 
@@ -360,10 +383,10 @@ def _get_shares_of_expansion(
         PERMANENT_CROPLAND: percent_permanent_cropland_was,
         PERMANENT_PASTURE: percent_pasture_was
     }
-    return {
+    return scale_values_to_one({
         k: expansion_for_type[land_use_type].get(k, 0)
         for k in LAND_USE_TERMS_FOR_TRANSFORMATION.keys()
-    }
+    })
 
 
 def _get_faostat_name(term: dict) -> str:
@@ -391,10 +414,11 @@ def _get_harvested_area(country_id: str, year: int, faostat_name: str) -> float:
     """
     Returns a dictionary of harvested areas for the country & year, indexed by landCover term (crop)
     """
-    lookup = download_lookup("region-crop-cropGroupingFaostatProduction-areaHarvested.csv")
+    lookup_name = "region-crop-cropGroupingFaostatProduction-areaHarvested.csv"
+
     return safe_parse_float(
         value=extract_grouped_data(
-            data=get_table_value(lookup, "termid", country_id, column_name(faostat_name)),
+            data=get_region_lookup_value(lookup_name, country_id, faostat_name, model=MODEL, key=MODEL_KEY),
             key=str(year)
         ),
         default=None
@@ -452,8 +476,7 @@ def _run(site: dict, existing_nodes: list, percentage_transformed_from: dict):
 
 
 def get_ratio_of_expanded_area(country_id: str, fao_name: str, end_year: int) -> float:
-    lookup = download_lookup("region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv")
-    table_value = get_table_value(lookup, 'termid', country_id, column_name(fao_name))
+    table_value = get_region_lookup_value(_LOOKUP_EXPANSION, country_id, fao_name, model=MODEL, key=MODEL_KEY)
     expansion = safe_parse_float(value=extract_grouped_data(table_value, str(end_year)), default=None)
     end_value = _get_harvested_area(
         country_id=country_id,
@@ -472,16 +495,16 @@ def _get_sum_for_land_category(
     fao_stat_to_ipcc_type: dict,
     include_negatives: bool = True
 ) -> float:
-    return sum(
-        [
-            safe_parse_float(value=extract_grouped_data(table_value, str(year)), default=None)
-            for fao_name, table_value in values.items()
-            if not _is_missing_or_none(extract_grouped_data(table_value, str(year))) and
-            fao_stat_to_ipcc_type[fao_name] == ipcc_land_use_category and
-            (include_negatives or
-             safe_parse_float(value=extract_grouped_data(table_value, str(year)), default=None) > 0.0)
-        ]
-    )
+    return sum([
+        safe_parse_float(value=extract_grouped_data(table_value, str(year)), default=None)
+        for fao_name, table_value in values.items()
+        if not _is_missing_or_none(extract_grouped_data(table_value, str(year))) and
+        fao_stat_to_ipcc_type[fao_name] == ipcc_land_use_category and
+        (
+            include_negatives or
+            safe_parse_float(value=extract_grouped_data(table_value, str(year)), default=None) > 0.0
+        )
+    ])
 
 
 def _get_sums_of_crop_expansion(country_id: str, year: int, include_negatives: bool = True) -> tuple[float, float]:
@@ -489,9 +512,12 @@ def _get_sums_of_crop_expansion(country_id: str, year: int, include_negatives: b
     Sum net expansion for all annual and permanent crops, returned as two values.
     Returns a tuple of (expansion of annual crops, expansion of permanent crops)
     """
-    lookup = download_lookup("region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv")
-    values = {name: get_table_value(lookup, 'termid', country_id, column_name(name))
-              for name in list(lookup.dtype.names) if name != "termid"}
+    lookup = download_lookup(_LOOKUP_EXPANSION.replace('region', f"{country_id}")) or download_lookup(_LOOKUP_EXPANSION)
+    columns = lookup_columns(lookup)
+    values = {
+        name: get_table_value(lookup, 'termid', country_id, column_name(name))
+        for name in columns if name != "termid"
+    }
 
     fao_stat_to_ipcc_type = _get_complete_faostat_to_crop_mapping()
 
@@ -513,8 +539,9 @@ def _get_sums_of_crop_expansion(country_id: str, year: int, include_negatives: b
     return annual_sum_of_expansion, permanent_sum_of_expansion
 
 
-def _get_net_expansion_cultivated_vs_harvested(annual_crops_net_expansion, changes, land_use_type,
-                                               permanent_crops_net_expansion):
+def _get_net_expansion_cultivated_vs_harvested(
+    annual_crops_net_expansion, changes, land_use_type, permanent_crops_net_expansion
+):
     if land_use_type == ANNUAL_CROPLAND:
         net_expansion_cultivated_vs_harvested = _safe_divide(numerator=max(0, changes[ANNUAL_CROPLAND]),
                                                              denominator=(annual_crops_net_expansion / 1000))
@@ -673,14 +700,14 @@ def _should_run_historical_land_use_change_single_crop(
 
     site_area = {
         land_type: (
-            shares_of_expansion[land_type] * expansion_factor * e9_net_expansion * net_expansion_cultivated_vs_harvested
-        )
-        for land_type in LAND_USE_TERMS_FOR_TRANSFORMATION.keys()
+           shares_of_expansion[land_type] * expansion_factor * e9_net_expansion * net_expansion_cultivated_vs_harvested
+        ) for land_type in LAND_USE_TERMS_FOR_TRANSFORMATION.keys()
         if land_type != land_use_type
     }
     site_area[land_use_type] = 1 - sum(site_area.values())
+    capped_site_area = cap_values(dictionary=site_area, lower_limit=0, upper_limit=1)
 
-    sum_of_site_areas_is_100 = site_area_sum_to_100(site_area)
+    sum_of_site_areas_is_100 = site_area_sum_to_100(capped_site_area)
     site_type_allowed = site.get("siteType") in SITE_TYPES
 
     logRequirements(
@@ -691,7 +718,7 @@ def _should_run_historical_land_use_change_single_crop(
         land_use_type=land_use_type,
         country_id=country_id,
         changes=log_as_table(changes),
-        site_area=log_as_table(site_area),
+        site_area=log_as_table(capped_site_area),
         sum_of_site_areas_is_100=sum_of_site_areas_is_100,
         site_type_allowed=site_type_allowed
     )
@@ -699,7 +726,7 @@ def _should_run_historical_land_use_change_single_crop(
     should_run = all([not missing_changes, country_id, site_type_allowed, sum_of_site_areas_is_100])
     logShouldRun(site, MODEL, term.get("@id"), should_run, model_key=MODEL_KEY)
 
-    return should_run, site_area
+    return should_run, capped_site_area
 
 
 def _get_land_use_term_from_node(node: dict) -> str:

hestia_earth/models/hestia/seed_emissions.py

@@ -13,7 +13,9 @@ These are the steps:
 """
 from functools import reduce
 from hestia_earth.schema import TermTermType, EmissionMethodTier, SiteSiteType
-from hestia_earth.utils.lookup import download_lookup, column_name, get_table_value, extract_grouped_data_closest_date
+from hestia_earth.utils.lookup import (
+    download_lookup, column_name, extract_grouped_data_closest_date, find_term_ids_by
+)
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list, flatten, list_sum, safe_parse_float
 from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
@@ -26,6 +28,7 @@ from hestia_earth.models.utils.cycle import cycle_end_year
 from hestia_earth.models.utils.crop import get_crop_grouping_faostat_production, get_landCover_term_id
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -65,7 +68,7 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "region-crop-cropGroupingFaostatProduction-yield": "value from cropGroupingFaostatProduction and country",
+    "region-crop-cropGroupingFaostatProduction-yield": "",
     "crop": [
         "correspondingSeedTermIds",
         "cropGroupingFaostatProduction",
@@ -133,7 +136,7 @@ def _filter_emissions(cycle: dict):
             'id': group_id,
             'emissions': list(filter(
                 lambda id: id in required_emission_term_ids,
-                set(list(lookup[lookup[column_name('inputProductionGroupId')] == group_id].termid))
+                find_term_ids_by(lookup, column_name('inputProductionGroupId'), group_id)
             ))
         }
         for group_id in group_ids
@@ -169,11 +172,12 @@ def _evs(product: dict):
 
 def _faostat_yield(country_id: str, end_year: int, product: dict):
     grouping = get_crop_grouping_faostat_production(MODEL, product.get('term', {}))
-    return safe_parse_float(extract_grouped_data_closest_date(get_table_value(
-        download_lookup('region-crop-cropGroupingFaostatProduction-yield.csv'),
-        'termid',
+    return safe_parse_float(extract_grouped_data_closest_date(get_region_lookup_value(
+        'region-crop-cropGroupingFaostatProduction-yield.csv',
         country_id,
-        column_name(grouping)
+        grouping,
+        model=MODEL,
+        model_key=MODEL_KEY
     ), end_year))
 
 

hestia_earth/models/impact_assessment/__init__.py

@@ -2,12 +2,12 @@ from os.path import dirname, abspath
 import sys
 from importlib import import_module
 
-from hestia_earth.models.utils.blank_node import run_if_required
-
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 MODEL = 'impact_assessment'
 PKG = '.'.join(['hestia_earth', 'models', MODEL])
 
 
-def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))
+def run(model: str, data):
+    run = getattr(import_module(f".{model}", package=PKG), 'run')
+    return run(data)

hestia_earth/models/ipcc2019/animal/fatContent.py

@@ -17,7 +17,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-milkFatContent": "fat content",
+    "region-liveAnimal-milkFatContent": "",
     "liveAnimal": "milkYieldPracticeTermIds"
 }
 RETURNS = {

hestia_earth/models/ipcc2019/animal/hoursWorkedPerDay.py

@@ -20,7 +20,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-hoursWorkedPerDay": "hours worked per day"
+    "region-liveAnimal-hoursWorkedPerDay": ""
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/animal/liveweightGain.py

@@ -20,7 +20,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-liveweightGain": "liveweight gain"
+    "region-liveAnimal-liveweightGain": ""
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/animal/liveweightPerHead.py

@@ -20,7 +20,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-liveweightPerHead": "liveweight per head"
+    "region-liveAnimal-liveweightPerHead": ""
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/animal/milkYieldPerAnimal.py

@@ -27,7 +27,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-milkYieldPerAnimal": "yield value",
+    "region-liveAnimal-milkYieldPerAnimal": "",
     "liveAnimal": ["milkYieldPracticeTermIds", "ipcc2019MilkYieldPerAnimalTermId"]
 }
 RETURNS = {

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -136,7 +136,7 @@ LOOKUPS = {
         "mjKgABNetEnergyGrowthSheepGoatsIpcc2019",
         "isWoolProducingAnimal"
     ],
-    "system-liveAnimal-activityCoefficient-ipcc2019": "using animal term @id",
+    "system-liveAnimal-activityCoefficient-ipcc2019": "",
     "landCover": "grazedPastureGrassInputId",
     "crop-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
     "crop": "grazedPastureGrassInputId",

hestia_earth/models/ipcc2019/animal/pregnancyRateTotal.py

@@ -20,7 +20,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-pregnancyRateTotal": "pregnancy rate"
+    "region-liveAnimal-pregnancyRateTotal": ""
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/animal/trueProteinContent.py

@@ -17,7 +17,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-milkTrueProteinContent": "protein content",
+    "region-liveAnimal-milkTrueProteinContent": "",
     "liveAnimal": "milkYieldPracticeTermIds"
 }
 RETURNS = {

hestia_earth/models/ipcc2019/animal/utils.py

@@ -1,13 +1,14 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
+from hestia_earth.utils.lookup import extract_grouped_data
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, non_empty_list
 
-from hestia_earth.models.log import logRequirements, logShouldRun, debugMissingLookup
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.property import _new_property, node_has_no_property
 from hestia_earth.models.utils.productivity import PRODUCTIVITY, get_productivity
 from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from .. import MODEL
 
 
@@ -24,11 +25,8 @@ def _get_practice(term_id: str, animal: dict, practice_column: str):
 def productivity_lookup_value(term_id: str, lookup: str, country: dict, animal: dict):
     country_id = country.get('@id')
     productivity_key = get_productivity(country)
-    lookup_name = f"{lookup}.csv"
-    lookup = download_lookup(lookup_name)
-    column = column_name(animal.get('term').get('@id'))
-    value = get_table_value(lookup, 'termid', country_id, column)
-    debugMissingLookup(lookup_name, 'termid', country_id, column, value, model=MODEL, term=term_id)
+    column = animal.get('term').get('@id')
+    value = get_region_lookup_value(f"{lookup}.csv", country_id, column, model=MODEL, term=term_id)
     return safe_parse_float(
         extract_grouped_data(value, productivity_key.value) or
         extract_grouped_data(value, PRODUCTIVITY.HIGH.value),  # defaults to high if low is not found

hestia_earth/models/ipcc2019/animal/weightAtMaturity.py

@@ -37,7 +37,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-liveAnimal-weightAtMaturity": "weight at maturity"
+    "region-liveAnimal-weightAtMaturity": ""
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -195,10 +195,10 @@ def _is_ionophore(cycle: dict, total_feed: float):
     has_input = find_term_match(inputs, 'ionophores', None) is not None
     maize_input = find_term_match(inputs, 'maizeSteamFlaked')
     maize_feed = get_total_value_converted_with_min_ratio(MODEL, None, blank_nodes=[maize_input]) if maize_input else 0
-    maize_feed_ratio = maize_feed / total_feed
+    maize_feed_ratio = maize_feed / total_feed if all([maize_feed, total_feed]) else 0
 
     debugValues(cycle, model=MODEL, term=TERM_ID,
-                maize_feed=maize_feed,
+                maize_feed_in_MJ=maize_feed,
                 maize_feed_ratio=maize_feed_ratio)
 
     return has_input and maize_feed_ratio >= 0.9