hestia-earth-models 0.64.8__tar.gz → 0.64.10__tar.gz

{hestia-earth-models-0.64.8/hestia_earth_models.egg-info → hestia-earth-models-0.64.10}/PKG-INFO

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

hestia-earth-models-0.64.10/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-0.64.10/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-0.64.8 → hestia-earth-models-0.64.10}/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-0.64.10/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -0,0 +1,120 @@
+"""
+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.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.indicator import _new_indicator
+from hestia_earth.models.utils.landCover import get_pef_grouping
+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": {
+        "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": "",
+    "landCover": "pefTermGrouping"
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'soilQualityIndexLandOccupation'
+LOOKUP = f"{list(LOOKUPS.keys())[1]}.csv"
+
+authorised_indicators = ["landOccupationInputsProduction", "landOccupationDuringCycle"]
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(land_occupation_indicators: list):
+    values = [indicator['coefficient'] * indicator['area-by-year'] for indicator in land_occupation_indicators]
+    return _indicator(list_sum(values))
+
+
+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
+    ]
+
+    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
+            ),
+            "using-fallback-country-region-world-CFs": indicator['used-country'] != indicator['country-id']
+        } for indicator in found_land_occupation_indicators
+    ]
+
+    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']]
+
+    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 = 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, land_occupation_indicators = _should_run(impact_assessment)
+    return _run(land_occupation_indicators) if should_run else None

hestia-earth-models-0.64.10/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -0,0 +1,168 @@
+"""
+Characterises [soilQualityIndexLandTransformation](https://hestia.earth/term/soilQualityIndexLandTransformation)
+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 List, Tuple, Optional
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+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 . import MODEL
+from .utils import get_coefficient_factor
+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 get_land_cover_terms
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator",
+                "term.units": "m2 / year",
+                "term.termType": "resourceUse",
+                "term.name": "Land transformation from",
+                "value": "> 0",
+                "landCover": {"@type": "Term", "term.termType": "landCover"}
+            }
+        ],
+        "optional": {"country": {"@type": "Term", "termType": "region"}}
+    }
+}
+
+# Note: CFs in `region-pefTermGrouping-landTransformation-from.csv` appear to be the opposite values as those in
+# `region-pefTermGrouping-landTransformation-to.csv` but can be different in some cases.
+LOOKUPS = {
+    "region-pefTermGrouping-landTransformation-from": "using country and `pefTermGrouping` from `landCover`",
+    "region-pefTermGrouping-landTransformation-to": "using country and `pefTermGrouping` from `landCover`",
+    "landCover": "pefTermGrouping"
+}
+
+from_lookup_file = f"{list(LOOKUPS.keys())[0]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+
+LOOKUP = {
+    "from": from_lookup_file,
+    "to": to_lookup_file
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'soilQualityIndexLandTransformation'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(transformations: List[dict]):
+    values = [(transformation['factor-from'] + transformation['factor-to']) * transformation['area'] for transformation
+              in transformations]
+    return _indicator(list_sum(values))
+
+
+def _extract_land_cover_from_indicator_id(indicator: dict) -> Optional[str]:
+    """
+    Given a indicator with term type `resourceUse` return the equivalent `landCover` term
+    """
+    term_in_id = indicator.get('term', {}).get('@id', '') \
+        .removeprefix("landTransformationFrom") \
+        .removesuffix("20YearAverageInputsProduction") \
+        .removesuffix("20YearAverageDuringCycle")
+    term_in_id = term_in_id[0].lower() + term_in_id[1:] if term_in_id else None
+    return term_in_id
+
+
+def _is_valid_indicator(indicator: dict, land_cover_term_ids: list[str]) -> bool:
+    term_id = _extract_land_cover_from_indicator_id(indicator)
+    return term_id in land_cover_term_ids
+
+
+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 = 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)]
+
+    found_transformations = [
+        {
+            'area': _node_value(transformation_indicator) * 20,
+            'area-unit': transformation_indicator.get('term', {}).get("units"),
+            'land-cover-id-from': _extract_land_cover_from_indicator_id(transformation_indicator),
+            'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
+            'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
+            'good-land-cover-term': transformation_indicator.get('landCover', {}).get('termType') == 'landCover',
+            'country-id': get_country_id(impact_assessment),
+            'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
+                transformation_indicator) > 0,
+            'area-unit-is-valid': transformation_indicator.get('term', {}).get("units") == "m2 / year",
+            'lookup-country': fallback_country(get_country_id(impact_assessment),
+                                               [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
+        } for transformation_indicator in land_transformation_indicators
+    ]
+
+    found_transformations_with_coefficient = [
+        transformation | {
+            "using-fallback-country-region-world-CFs": transformation['lookup-country'] != transformation['country-id'],
+            'factor-from': get_coefficient_factor(
+                lookup_name=from_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-from'])) if
+            transformation['land-cover-id-from'] else None,
+            'factor-to': get_coefficient_factor(
+                lookup_name=to_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-to'])) if
+            transformation['land-cover-id-to'] else None
+        } for transformation in found_transformations
+    ]
+
+    valid_transformations_with_coef = [
+        t for t in found_transformations_with_coefficient if all([
+            t['area-is-valid'],
+            t['area-unit-is-valid'],
+            t['factor-from'] is not None,
+            t['factor-to'] is not None
+        ])
+    ]
+
+    has_land_transformation_indicators = bool(land_transformation_indicators)
+
+    all_transformations_are_valid = all(
+        [
+            all([t['area-is-valid'], t['area-unit-is-valid'], t['good-land-cover-term']])
+            for t in found_transformations_with_coefficient
+        ]
+    ) if found_transformations_with_coefficient else False
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_land_occupation_indicators=has_land_transformation_indicators,
+                    all_transformations_are_valid=all_transformations_are_valid,
+                    has_valid_transformations_with_coef=bool(valid_transformations_with_coef),
+                    found_transformations=log_as_table(found_transformations_with_coefficient)
+                    )
+
+    should_run = has_land_transformation_indicators is False or all([has_land_transformation_indicators,
+                                                                     all_transformations_are_valid])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_transformations_with_coef
+
+
+def run(impact_assessment: dict):
+    should_run, transformations = _should_run(impact_assessment)
+    return _run(transformations) if should_run else None