hestia-earth-models 0.64.8__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/cycle/siteArea.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import square_meter_to_hectare
 from . import MODEL
 
 REQUIREMENTS = {
@@ -48,7 +49,7 @@ def _run(cycle: dict):
     animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
     stocking_density = find_term_match(
         cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [])
-    return round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7)
+    return square_meter_to_hectare(round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7))
 
 
 def _should_run(cycle: dict, site: dict, key=MODEL_KEY):

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -1,41 +1,37 @@
+"""
+Characterises [soilQualityIndexLandOccupation](https://hestia.earth/term/soilQualityIndexLandOccupation)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from typing import Tuple
+
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import download_lookup
-from hestia_earth.utils.tools import list_sum, non_empty_list
+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, log_as_table
-from hestia_earth.models.utils import hectar_to_square_meter, days_to_years
-from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_type
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.landCover import get_pef_grouping
-from hestia_earth.models.utils.lookup import fallback_country
+from hestia_earth.models.utils.lookup import fallback_country, _node_value
 from . import MODEL
 from .utils import get_coefficient_factor
+from ..utils.impact_assessment import get_country_id
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "cycle": {
-            "@type": "Cycle",
-            "siteDuration": "> 0",
-            "siteArea": "> 0",
-            "site": {
-                "siteType": "",
-                "@type": "Site",
-                "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
-                "country": {"@type": "Term", "termType": "region"}
-            },
-            "optional": {
-                "otherSitesDuration": "> 0",
-                "otherSitesArea": "> 0",
-                "otherSites": [{
-                    "@type": "Site",
-                    "siteType": "",
-                    "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
-                    "country": {"@type": "Term", "termType": "region"}
-                }]
-            }
-        }
+        "optional": {"country": {"@type": "Term", "termType": "region"}},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": ">0",
+            "term.@id": ["landOccupationInputsProduction", "landOccupationDuringCycle"],
+            "term.units": "m2*year",
+            "landCover": {"@type": "Term", "term.termType": "landCover"}
+        }]
     }
 }
+
 LOOKUPS = {
     "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
     "region-pefTermGrouping-landOccupation": "",
@@ -50,6 +46,8 @@ RETURNS = {
 TERM_ID = 'soilQualityIndexLandOccupation'
 LOOKUP = f"{list(LOOKUPS.keys())[1]}.csv"
 
+authorised_indicators = ["landOccupationInputsProduction", "landOccupationDuringCycle"]
+
 
 def _indicator(value: float):
     indicator = _new_indicator(TERM_ID, MODEL)
@@ -57,73 +55,66 @@ def _indicator(value: float):
     return indicator
 
 
-def _run(sites: list):
-    values = [site['coeff'] * hectar_to_square_meter(site['area']) * days_to_years(site['duration']) for site in sites]
-    return _indicator(list_sum(values)) if values else None
-
-
-def _should_run(impact_assessment: dict):
-    cycle = impact_assessment.get('cycle', {})
-    end_date = cycle.get('endDate')
-
-    has_site = bool(cycle.get('site', False))
-    has_other_sites = bool(cycle.get('otherSites', []))
+def _run(land_occupation_indicators: list):
+    values = [indicator['coefficient'] * indicator['area-by-year'] for indicator in land_occupation_indicators]
+    return _indicator(list_sum(values))
 
-    all_sites = non_empty_list([cycle.get('site')] + cycle.get('otherSites', []))
-    site_areas = [cycle.get('siteArea')] + cycle.get('otherSitesArea', [])
-    site_durations = [cycle.get('siteDuration')] + cycle.get('otherSitesDuration', [])
 
-    sites = [
-        {
-            'site-type': site.get('siteType'),
-            'country-id': site.get('country', {}).get('@id'),
-            'area': site_areas[index] if len(site_areas) >= index + 1 else None,
-            'duration': site_durations[index] if len(site_durations) >= index + 1 else None,
-            'landCover-id': (most_relevant_blank_node_by_type(
-                site.get("management", []),
-                term_type=TermTermType.LANDCOVER.value,
-                date=end_date
-            ) or {}).get('term', {}).get('@id'),
-        }
-        for index, site in enumerate(all_sites)
+def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
+    land_occupation_indicators = [
+        i for i in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        i.get('landCover', {}).get('termType') == TermTermType.LANDCOVER.value and
+        i.get('term', {}).get('@id', '') in authorised_indicators
     ]
 
-    sites = [
-        site for site in sites
-        if all([
-            (site.get('area') or 0) > 0,
-            (site.get('duration') or 0) > 0,
-            site.get('landCover-id')
-        ])
-    ]
-
-    sites = [
-        site |
-        {
-            'coeff': get_coefficient_factor(
-                LOOKUP,
-                fallback_country(site.get('country-id'), [download_lookup(LOOKUP)]),
-                get_pef_grouping(site.get('landCover-id')),
+    found_land_occupation_indicators = [{
+        'area-by-year': _node_value(land_occupation_indicator),
+        'area-unit': land_occupation_indicator.get('term', {}).get("units"),
+        'land-cover-id': land_occupation_indicator.get('landCover', {}).get("@id"),
+        'country-id': get_country_id(impact_assessment),
+        'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
+            land_occupation_indicator) > 0,
+        'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
+        'used-country': fallback_country(get_country_id(impact_assessment), [download_lookup(LOOKUP)]),
+
+    } for land_occupation_indicator in land_occupation_indicators]
+
+    found_indicators_with_coefficient = [
+        indicator | {
+            'coefficient': get_coefficient_factor(
+                LOOKUP, indicator['used-country'],
+                get_pef_grouping(indicator['land-cover-id']),
                 term_id=TERM_ID
-            )
-        } for site in sites
+            ),
+            "using-fallback-country-region-world-CFs": indicator['used-country'] != indicator['country-id']
+        } for indicator in found_land_occupation_indicators
     ]
-    valid_sites = [site for site in sites if site.get('coeff') is not None]
 
-    has_valid_sites = bool(valid_sites)
+    has_valid_land_occupations = all(
+        [
+            indicator['area-by-year-is-valid'] and indicator['area-unit-is-valid']
+            for indicator in found_land_occupation_indicators
+        ]) if found_land_occupation_indicators else False
+
+    valid_indicator_with_coef = [indicator for indicator in found_indicators_with_coefficient if
+                                 indicator['coefficient'] is not None and
+                                 indicator['area-by-year-is-valid'] and
+                                 indicator['area-unit-is-valid']]
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_valid_sites=has_valid_sites,
-                    has_site=has_site,
-                    has_other_sites=has_other_sites,
-                    valid_sites=log_as_table(valid_sites),
+    has_land_occupation_indicators = bool(land_occupation_indicators)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_land_occupation_indicators=has_land_occupation_indicators,
+                    has_valid_land_occupations=has_valid_land_occupations,
+                    land_occupation_indicators=log_as_table(found_indicators_with_coefficient)
                     )
 
-    should_run = all([has_valid_sites])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, valid_sites
+    should_run = has_land_occupation_indicators and has_valid_land_occupations
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_indicator_with_coef
 
 
 def run(impact_assessment: dict):
-    should_run, sites = _should_run(impact_assessment)
-    return _run(sites) if should_run else None
+    should_run, land_occupation_indicators = _should_run(impact_assessment)
+    return _run(land_occupation_indicators) if should_run else None