hestia-earth-models 0.64.9__py3-none-any.whl → 0.64.11__py3-none-any.whl

hestia_earth/models/cml2001Baseline/abioticResourceDepletionFossilFuels.py

@@ -0,0 +1,175 @@
+"""
+This model calculates the abiotic resource depletion, fossil fuels. Based on the models CML 2002 (Guinée et al., 2002) and van Oers et al. 2002 (method, v.4.8)
+
+>The earth contains a finite amount of non-renewable resources, such as fossil fuels like coal, oil and gas. The basic idea behind this impact category is that extracting resources today will force future generations to extract less or different resources. For example, the depletion of V2.0 – 25th August 2023 28 fossil fuels may lead to the non-availability of fossil fuels for future generations. The amount of materials contributing to resource use, fossils, are converted into MJ.
+
+Source : [Life Cycle Assessment & the EF methods - Comprehensive coverage of impacts](https://green-business.ec.europa.eu/environmental-footprint-methods/life-cycle-assessment-ef-methods_en)
+
+The model accepts any non-renewable energy term that can be expressed in, or converted to, MegaJoules.
+
+Source: [JRC Technical reports Suggestions for updating the Product Environmental Footprint (PEF) method](https://eplca.jrc.ec.europa.eu/permalink/PEF_method.pdf#%5B%7B%22num%22%3A80%2C%22gen%22%3A0%7D%2C%7B%22name%22%3A%22XYZ%22%7D%2C68%2C363%2C0%5D)
+
+Source: [Differences between EF model versions](https://eplca.jrc.ec.europa.eu/EFVersioning.html)
+"""  # noqa: E501
+from itertools import chain
+from typing import Optional
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup, column_name
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, flatten
+
+from hestia_earth.models.log import logShouldRun, logRequirements, log_as_table
+from . import MODEL
+from ..utils.blank_node import convert_unit
+from ..utils.constant import Units
+from ..utils.indicator import _new_indicator
+from ..utils.lookup import _node_value
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator",
+                "term.termType": "resourceUse",
+                "term.@id": ["resourceUseEnergyDepletionInputsProduction", "resourceUseEnergyDepletionDuringCycle"],
+                "value": "> 0",
+                "inputs":
+                    {
+                        "@type": "Input",
+                        "term.name": "non-renewable\" energy terms only,\"",
+                        "term.units": ["kg", "m3", "kWh", "MJ"],
+                        "term.termType": ["fuel", "electricity"],
+                        "optional": {
+                            "defaultProperties": [
+                                {
+                                    "@type": "Property",
+                                    "value": "",
+                                    "term.@id": "energyContentHigherHeatingValue",
+                                    "term.units": "MJ / kg"
+                                },
+                                {
+                                    "@type": "Property",
+                                    "value": "",
+                                    "term.@id": "density",
+                                    "term.units": "kg / m3"
+                                }
+                            ]
+                        }
+                    }
+            }
+        ]
+    }
+}
+
+LOOKUPS = {
+    "fuel": ["energyContentHigherHeatingValue", "density", "abioticResourceDepletionFossilFuelsCml2001Baseline"],
+    "electricity": ["abioticResourceDepletionFossilFuelsCml2001Baseline"]
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'abioticResourceDepletionFossilFuels'
+
+ENERGY_CARRIERS_TERMIDS = REQUIREMENTS['ImpactAssessment']['emissionsResourceUse'][0]['term.@id']
+
+INPUTS_TYPES_UNITS = {
+    TermTermType.FUEL.value: [Units.KG.value, Units.M3.value, Units.MJ.value],
+    TermTermType.ELECTRICITY.value: [Units.KW_H.value, Units.MJ.value]
+}
+
+
+def download_all_non_renewable_terms(lookup_file_name: str) -> list:
+    """
+    returns all non renewable term ids in lookup files like `electricity.csv` or `fuel.csv`
+    """
+    lookup = download_lookup(lookup_file_name)
+    results = lookup[
+        lookup[column_name("abioticResourceDepletionFossilFuelsCml2001Baseline")] == True  # noqa: E712
+        ]["termid"]
+    terms_ids: list[str] = [str(entry) for entry in results]
+    return terms_ids
+
+
+def _valid_resource_indicator(resource: dict) -> bool:
+    return len(resource.get('inputs', [])) == 1 and \
+           isinstance(_node_value(resource), (int, float)) and \
+           _node_value(resource) > 0
+
+
+def _valid_input(input: dict) -> bool:
+    return input.get("@id") in list(chain.from_iterable([
+        download_all_non_renewable_terms(f"{termType}.csv") for termType in LOOKUPS.keys()
+    ])) and input.get("units", "") in INPUTS_TYPES_UNITS.get(input.get("termType", ""))
+
+
+def _get_value_in_mj(input: dict, indicator: dict) -> Optional[float]:
+    return convert_unit(input, dest_unit=Units.MJ, node_value=_node_value(indicator)) if _valid_input(input) else None
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator["value"] = value
+    return indicator
+
+
+def _run(energy_resources_in_mj: list):
+    return _indicator(list_sum(energy_resources_in_mj))
+
+
+def _should_run(impact_assessment: dict) -> tuple[bool, list]:
+    emissions_resource_use = [
+        resource for resource in
+        filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        resource.get('term', {}).get('@id', '') in ENERGY_CARRIERS_TERMIDS]
+
+    has_resource_use_entries = bool(emissions_resource_use)
+
+    resource_uses_unpacked = flatten(
+        [
+            [
+                {
+                    "input-term-id": input.get('@id'),
+                    "input-term-type": input.get('termType'),
+                    "indicator-term-id": resource_indicator['term']['@id'],
+                    "indicator-is-valid": _valid_resource_indicator(resource_indicator),
+                    "input": input,
+                    "indicator-input-is-valid": _valid_input(input),
+                    "value": _node_value(resource_indicator),
+                    "input-unit": input.get('units'),
+                    "value-in-MJ": _get_value_in_mj(input, resource_indicator)
+                } for input in resource_indicator['inputs'] or [{}]]
+            for resource_indicator in emissions_resource_use
+        ]
+    )
+
+    has_valid_input_requirements = all([
+        all([energy_input['indicator-is-valid'], energy_input['indicator-input-is-valid']])
+        for energy_input in resource_uses_unpacked
+    ])
+
+    energy_resources_in_mj = [energy_input['value-in-MJ'] for energy_input in resource_uses_unpacked]
+    valid_energy_resources_in_mj = [value for value in energy_resources_in_mj if value is not None]
+    all_inputs_have_valid_mj_value = all([energy is not None for energy in energy_resources_in_mj]
+                                         ) and bool(energy_resources_in_mj)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_resource_use_entries=has_resource_use_entries,
+                    has_valid_input_requirements=has_valid_input_requirements,
+                    all_inputs_have_valid_mj_value=all_inputs_have_valid_mj_value,
+                    energy_resources_used=log_as_table(resource_uses_unpacked))
+
+    should_run = has_resource_use_entries is False or all([has_resource_use_entries,
+                                                           has_valid_input_requirements,
+                                                           all_inputs_have_valid_mj_value])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_energy_resources_in_mj
+
+
+def run(impact_assessment: dict):
+    should_run, resources = _should_run(impact_assessment)
+    return _run(resources) if should_run else None

hestia_earth/models/cml2001Baseline/abioticResourceDepletionMineralsAndMetals.py

@@ -0,0 +1,136 @@
+"""
+Calculates the EU PEF Abiotic resource depletion, for minerals and metals Indicator
+
+Uses lookup factors from [eplca.jrc.ec.europa.eu](https://eplca.jrc.ec.europa.eu/permalink/EF3_1/EF-LCIAMethod_CF(EF-v3.1).xlsx), Accessed 2024-09-05.
+
+> The results of this impact category shall be interpreted with caution, because the results of ADP after
+> normalization may be overestimated. The European Commission intends to develop a new method moving
+> from depletion to dissipation model to better quantify the potential for conservation of resources
+
+Source: [JRC Technical reports Suggestions for updating the Product Environmental Footprint (PEF) method](https://eplca.jrc.ec.europa.eu/permalink/PEF_method.pdf#%5B%7B%22num%22%3A80%2C%22gen%22%3A0%7D%2C%7B%22name%22%3A%22XYZ%22%7D%2C68%2C363%2C0%5D)
+"""  # noqa: E501
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, flatten
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from . import MODEL
+from ..utils.indicator import _new_indicator
+from ..utils.lookup import _node_value
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator", "value": "", "term.termType": "resourceUse",
+                "term.@id": ["resourceUseMineralsAndMetalsInputsProduction", "resourceUseMineralsAndMetalsDuringCycle"],
+                "inputs": {
+                    "@type": "Term",
+                    "term.units": "kg",
+                    "term.termType": ["material", "soilAmendment", "otherInorganicChemical"]}
+            }]
+    }
+}
+
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the input material",
+    "soilAmendment": "abioticResourceDepletionMineralsAndMetalsCml2001Baseline",
+    "material": "abioticResourceDepletionMineralsAndMetalsCml2001Baseline",
+    "otherInorganicChemical": "abioticResourceDepletionMineralsAndMetalsCml2001Baseline"
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'abioticResourceDepletionMineralsAndMetals'
+
+authorised_resource_use_term_types = [TermTermType.MATERIAL.value,
+                                      TermTermType.SOILAMENDMENT.value,
+                                      TermTermType.OTHERINORGANICCHEMICAL.value]
+authorised_resource_use_term_ids = ['resourceUseMineralsAndMetalsInputsProduction',
+                                    'resourceUseMineralsAndMetalsDuringCycle']
+
+
+def _valid_input(input: dict) -> bool:
+    return input.get('units', '').startswith("kg") and input.get('termType', '') in authorised_resource_use_term_types
+
+
+def _valid_resource_indicator(resource: dict) -> bool:
+    return len(resource.get('inputs', [])) == 1 and isinstance(_node_value(resource), (int, float))
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(resources: list):
+    result = list_sum([indicator_input['value'] * indicator_input['coefficient'] for indicator_input in resources])
+    return _indicator(result)
+
+
+def _should_run(impact_assessment: dict) -> tuple[bool, list]:
+    emissions_resource_use = [
+        resource for resource in
+        filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        resource.get('term', {}).get('@id', '') in authorised_resource_use_term_ids]
+
+    has_resource_use_entries = bool(emissions_resource_use)
+
+    resource_uses_unpacked = flatten(
+        [
+            [
+                {
+                    "input-term-id": input.get('@id'),
+                    "input-term-type": input.get('termType'),
+                    "indicator-term-id": resource_indicator['term']['@id'],
+                    "indicator-is-valid": _valid_resource_indicator(resource_indicator),
+                    "input": input,
+                    "indicator-input-is-valid": _valid_input(input),
+                    "value": _node_value(resource_indicator),
+                    "coefficient": get_table_value(
+                        array=download_lookup(filename=f"{input.get('termType')}.csv"),
+                        col_match='termid',
+                        col_match_with=input.get('@id'),
+                        col_val=column_name(LOOKUPS.get(input.get('termType'), ''))) if input else None
+                } for input in resource_indicator['inputs'] or [{}]]
+            for resource_indicator in emissions_resource_use
+        ]
+    )
+    valid_resources_with_cf = [em for em in resource_uses_unpacked if em['coefficient'] is not None
+                               and em['indicator-is-valid'] is True
+                               and em['indicator-input-is-valid'] is True]
+
+    has_valid_input_requirements = all([
+        all([
+            em['indicator-is-valid'],
+            em['indicator-input-is-valid']
+        ])
+        for em in resource_uses_unpacked
+    ])
+
+    all_resources_have_cf = all([em['coefficient'] is not None for em in resource_uses_unpacked]
+                                ) and bool(resource_uses_unpacked)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_resource_use_entries=has_resource_use_entries,
+                    has_valid_input_requirements=has_valid_input_requirements,
+                    all_resources_have_cf=all_resources_have_cf,
+                    resource_uses=log_as_table(resource_uses_unpacked)
+                    )
+
+    should_run = has_valid_input_requirements
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_resources_with_cf
+
+
+def run(impact_assessment: dict):
+    should_run, resources = _should_run(impact_assessment)
+    return _run(resources) if should_run else None

hestia_earth/models/cml2001Baseline/eutrophicationPotentialExcludingFate.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001Baseline/terrestrialAcidificationPotentialIncludingFateAverageEurope.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001NonBaseline/eutrophicationPotentialIncludingFateAverageEurope.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001NonBaseline/terrestrialAcidificationPotentialExcludingFate.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cycle/completeness/cropResidue.py

@@ -5,6 +5,7 @@ This model checks if we have the requirements below and updates the
 [Data Completeness](https://hestia.earth/schema/Completeness#cropResidue) value.
 """
 from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils.term import get_crop_residue_terms
@@ -14,15 +15,15 @@ REQUIREMENTS = {
     "Cycle": {
         "completeness.cropResidue": "False",
         "products": [
-            {"@type": "Product", "value": "", "term.@id": "belowGroundCropResidue"},
-            {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueTotal"}
+            {"@type": "Product", "value": ">= 0", "term.@id": "belowGroundCropResidue"},
+            {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueTotal"}
         ],
         "optional": {
             "products": [
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueRemoved"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueBurnt"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueLeftOnField"}
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueRemoved"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueIncorporated"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueBurnt"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueLeftOnField"}
             ]
         }
     }
@@ -44,17 +45,21 @@ def _optional_term_ids():
     return [term for term in terms if term not in REQUIRED_TERM_IDS]
 
 
-def _has_product(products):
+def _has_product(products, zero_allowed=True):
     def has_product(term_id: str):
-        return (term_id, find_term_match(products, term_id, None) is not None)
+        value = list_sum(find_term_match(products, term_id).get('value', [-1]))
+        return (term_id, value >= 0 if zero_allowed else value > 0)
     return has_product
 
 
 def run(cycle: dict):
     products = cycle.get('products', [])
     # all required terms + at least one of the optional terms must be present
-    required_products_map = list(map(_has_product(products), REQUIRED_TERM_IDS))
-    optional_products_map = list(map(_has_product(products), _optional_term_ids()))
+    required_products_map = [
+        _has_product(products, zero_allowed=True)('belowGroundCropResidue'),
+        _has_product(products, zero_allowed=False)('aboveGroundCropResidueTotal'),
+    ]
+    optional_products_map = list(map(_has_product(products, zero_allowed=False), _optional_term_ids()))
 
     has_required_products = all([has_product for _term_id, has_product in required_products_map])
     has_optional_product = any([has_product for _term_id, has_product in optional_products_map])

hestia_earth/models/cycle/completeness/freshForage.py

@@ -0,0 +1,60 @@
+"""
+Completeness Fresh Forage
+
+This model checks if we have the requirements below and updates the
+[Data Completeness](https://hestia.earth/schema/Completeness#cropResidue) value.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements
+from hestia_earth.models.utils import is_from_model
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.freshForage": "False",
+        "site": {
+            "@type": "Site",
+            "siteType": "permanent pasture"
+        },
+        "or": {
+            "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}],
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Completeness": {
+        "freshForage": ""
+    }
+}
+MODEL_KEY = 'freshForage'
+ALLOWED_SITE_TYPES = [
+    SiteSiteType.PERMANENT_PASTURE.value
+]
+
+
+def _valid_input(input: dict): return is_from_model(input) and list_sum(input.get('value', [-1])) > 0
+
+
+def run(cycle: dict):
+    site_type = cycle.get('site', {}).get('siteType')
+    site_type_allowed = site_type in ALLOWED_SITE_TYPES
+
+    cycle_has_added_forage_input = any(map(_valid_input, cycle.get('inputs', [])))
+
+    animals = cycle.get('animals', [])
+    all_animals_have_added_forage_input = bool(animals) and all([
+        any(map(_valid_input, animal.get('inputs', []))) for animal in animals
+    ])
+
+    logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    site_type_allowed=site_type_allowed,
+                    cycle_has_added_forage_input=cycle_has_added_forage_input,
+                    all_animals_have_added_forage_input=all_animals_have_added_forage_input)
+
+    return all([site_type_allowed, cycle_has_added_forage_input or all_animals_have_added_forage_input])

hestia_earth/models/edip2003/ozoneDepletionPotential.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -27,7 +27,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -18,7 +18,7 @@ from ..utils.impact_assessment import get_country_id
 from ..utils.indicator import _new_indicator
 from ..utils.landCover import get_pef_grouping
 from ..utils.lookup import fallback_country, _node_value
-from ..utils.term import download_all_land_cover_terms
+from ..utils.term import get_land_cover_terms
 
 REQUIREMENTS = {
     "ImpactAssessment": {
@@ -92,7 +92,7 @@ def _is_valid_indicator(indicator: dict, land_cover_term_ids: list[str]) -> bool
 
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
-    land_cover_term_ids = [term.get("@id") for term in download_all_land_cover_terms()] if resource_uses else []
+    land_cover_term_ids = get_land_cover_terms() if resource_uses else []
 
     land_transformation_indicators = [i for i in resource_uses if _is_valid_indicator(i, land_cover_term_ids)]
 

hestia_earth/models/fantkeEtAl2016/damageToHumanHealthParticulateMatterFormation.py

@@ -1,33 +1,23 @@
-from hestia_earth.utils.lookup import column_name
-
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
+from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
-from ..utils.impact_assessment import impact_lookup_value
-from ..utils.indicator import _new_indicator
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "emissionsResourceUse": [
-            {
-                "@type": "Indicator", "value": "", "term.termType": "emission"
-            }
-        ]
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
     }
 }
-
-TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
-
 LOOKUPS = {
     "emission": "damageToHumanHealthParticulateMatterFormationFantkeEtAl2016"
 }
-
 RETURNS = {
     "Indicator": {
         "value": ""
     }
 }
 
-default_group_key = 'default'
+TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
 
 
 def _indicator(value: float):
@@ -37,9 +27,9 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(model=MODEL, term_id=TERM_ID, impact=impact_assessment,
-                                lookup_col=column_name(LOOKUPS['emission']),
-                                grouped_key=default_group_key)
+    value = impact_emission_lookup_value(
+        model=MODEL, term_id=TERM_ID, impact=impact_assessment, lookup_col=LOOKUPS['emission'], grouped_key='default'
+    )
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
 

hestia_earth/models/ipcc2013ExcludingFeedbacks/gwp100.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/ipcc2013IncludingFeedbacks/gwp100.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)