hestia-earth-models 0.64.9__py3-none-any.whl → 0.64.10__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/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)]