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

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -3,7 +3,7 @@ This model calculates the scarcity weighted water use based on the geospatial AW
 (see UNEP (2016); Boulay et al (2016); Boulay et al (2020); EC-JRC (2017)).
 """
 from hestia_earth.schema import SiteSiteType
-from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name, get_table_value
+from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name
 from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun
@@ -13,6 +13,7 @@ from hestia_earth.models.utils.impact_assessment import (
     convert_value_from_cycle, emission_value, get_product, get_site, get_region_id
 )
 from hestia_earth.models.utils.input import sum_input_impacts
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -40,8 +41,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "awareWaterBasinId": "using `awareWaterBasinId` and `YR_IRRI` (for `cropland`, `glass or high accessible cover`, or `permanent pasture`) or `YR_NONIRRI`",  # noqa: E501
-    "region-aware-factors": "using `region` and `YR_IRRI` (for `cropland`, `glass or high accessible cover` or `permanent pasture`) or `YR_NONIRRI`"  # noqa: E501
+    "awareWaterBasinId": "",
+    "region-aware-factors": ""
 }
 TERM_ID = 'scarcityWeightedWaterUse'
 AWARE_KEY = 'awareWaterBasinId'
@@ -71,11 +72,9 @@ def _get_factor_from_region(impact_assessment: dict, site: dict):
     region_id = get_region_id(impact_assessment)
     site_type = site.get('siteType')
     lookup_name = 'region-aware-factors.csv'
-    lookup = download_lookup(lookup_name)
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
     column = f"Agg_CF_{lookup_suffix}"
-    value = get_table_value(lookup, 'termid', region_id, column_name(column))
-    debugMissingLookup(lookup_name, 'termid', region_id, column, value, model=MODEL, term=TERM_ID)
+    value = get_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, None)
 
 

hestia_earth/models/blonkConsultants2016/ch4ToAirNaturalVegetationBurning.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-ch4forestBiomassBurning": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-ch4forestBiomassBurning": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-co2LandUseChange": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-co2LandUseChange": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/n2OToAirNaturalVegetationBurningDirect.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-n2oforestBiomassBurning": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-n2oforestBiomassBurning": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/utils.py

@@ -1,9 +1,10 @@
 from hestia_earth.utils.model import find_primary_product
-from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
+from hestia_earth.utils.lookup import extract_grouped_data
 from hestia_earth.utils.tools import safe_parse_float
 
-from hestia_earth.models.log import debugMissingLookup, logger
+from hestia_earth.models.log import logger
 from hestia_earth.models.utils.crop import FAOSTAT_AREA_LOOKUP_COLUMN, get_crop_grouping_faostat_area
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 
@@ -18,13 +19,12 @@ def get_emission_factor(term_id: str, cycle: dict, factor: str):
                  MODEL, country_id, product_id, f"'{crop_grouping}'")
 
     lookup_name = f"region-crop-{FAOSTAT_AREA_LOOKUP_COLUMN}-{factor}.csv"
-    lookup = download_lookup(lookup_name)
-    value = get_table_value(lookup, 'termid', country_id, column_name(crop_grouping)) if crop_grouping else None
-    debugMissingLookup(lookup_name, 'termid', country_id, crop_grouping, value, model=MODEL, term=term_id)
+    value = get_region_lookup_value(
+        lookup_name, country_id, crop_grouping, model=MODEL, term=term_id
+    ) if crop_grouping else get_region_lookup_value(
+        lookup_name, country_id, 'NONE', model=MODEL, term=term_id
+    )
 
     data = safe_parse_float(value, None)
     # fallback to site.siteType data if possible
-    return data if data is not None else safe_parse_float(
-        extract_grouped_data(get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')),
-        None
-    )
+    return data if data is not None else safe_parse_float(extract_grouped_data(value, site.get('siteType')), None)

hestia_earth/models/cache_sites.py

@@ -2,7 +2,7 @@ from functools import reduce
 from enum import Enum
 from pydash.objects import merge
 from hestia_earth.utils.api import download_hestia
-from hestia_earth.utils.tools import flatten
+from hestia_earth.utils.tools import flatten, non_empty_list
 
 from .log import logger
 from .utils import CACHE_KEY, cached_value
@@ -30,14 +30,24 @@ _VALUE_AS_PARAM = {
 }
 
 
+def _value_as_param(param_type: ParamType = None): return _VALUE_AS_PARAM.get(param_type, lambda *args: None)
+
+
 def _cache_results(results: list, collections: list, index: int):
     start = index * len(collections)
     end = start + len(collections)
     return cache_site_results(results[start:end], collections)
 
 
-def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors: list = [], years: list = None):
-    param_values = list(map(_VALUE_AS_PARAM.get(param_type), sites))
+def _run_values(
+    sites: list,
+    param_type: ParamType = None,
+    rasters: list = [],
+    vectors: list = [],
+    years: list = None
+):
+    get_param_values = _value_as_param(param_type)
+    param_values = non_empty_list(map(get_param_values, sites))
     # unique list
     param_values = list(set(param_values)) if param_type == ParamType.GADM_IDS else list({
         str(v): v for v in param_values
@@ -59,13 +69,13 @@ def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors:
         site, area_size = site_values
 
         # get real index in values to handle duplicates
-        param_value = _VALUE_AS_PARAM.get(param_type)([site])
-        index = param_values.index(param_value)
+        param_value = get_param_values([site])
+        index = param_values.index(param_value) if param_value is not None else None
 
-        cached_data = {
+        cached_data = ({
             **_cache_results(raster_results, rasters, index),
             **_cache_results(vector_results, vectors, index)
-        } | ({CACHE_AREA_SIZE: area_size} if area_size is not None else {})
+        } if index is not None else {}) | ({CACHE_AREA_SIZE: area_size} if area_size is not None else {})
         cached_data = merge(cached_value(site, CACHE_GEOSPATIAL_KEY, {}), cached_data)
         site_cache = merge(
             site.get(CACHE_KEY, {}),
@@ -96,33 +106,35 @@ def _group_sites(sites: dict, check_has_cache: bool = True):
         (n, ) + (_should_run(n, area_size=get_region_area_size(n), check_has_cache=check_has_cache)) for n in sites
     ]
     # restrict sites based on should_cache result
-    sites = [(site, area_size) for site, should_cache, area_size in sites if should_cache]
+    sites_run = [(site, area_size) for site, should_cache, area_size in sites if should_cache]
+    # will only cache area and years
+    sites_no_run = [(site, area_size) for site, should_cache, area_size in sites if not should_cache]
 
     with_coordinates = [
-        (site, area_size) for site, area_size in sites if has_coordinates(site)
+        (site, area_size) for site, area_size in sites_run if has_coordinates(site)
     ]
     with_boundaries = [
-        (site, area_size) for site, area_size in sites if not has_coordinates(site) and has_boundary(site)
+        (site, area_size) for site, area_size in sites_run if not has_coordinates(site) and has_boundary(site)
     ]
     with_gadm_ids = [
-        (site, area_size) for site, area_size in sites if not has_coordinates(site) and not has_boundary(site)
+        (site, area_size) for site, area_size in sites_run if not has_coordinates(site) and not has_boundary(site)
     ]
 
     return {
         ParamType.COORDINATES: with_coordinates,
         ParamType.BOUNDARIES: with_boundaries,
         ParamType.GADM_IDS: with_gadm_ids
-    }
+    }, sites_no_run
 
 
 def _run(sites: list, years: list = [], years_only: bool = False):
     rasters = list_rasters(years=years, years_only=years_only)
     vectors = [] if years_only else list_vectors(sites)
-    filtered_data = _group_sites(sites, not years_only)
+    filtered_data, sites_no_run = _group_sites(sites, not years_only)
     return flatten([
         _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
         for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
-    ])
+    ] + _run_values(sites_no_run, years=years))
 
 
 def run(sites: list, years: list = None):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandOccupation.py

@@ -53,8 +53,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "ecoregion-siteType-LandOccupationChaudaryBrooks2018CF": "using `ecoregion`",
-    "region-siteType-LandOccupationChaudaryBrooks2018CF": "using `country`"
+    "ecoregion-siteType-LandOccupationChaudaryBrooks2018CF": "",
+    "region-siteType-LandOccupationChaudaryBrooks2018CF": ""
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandOccupation'
 LOOKUP_SUFFIX = 'LandOccupationChaudaryBrooks2018CF'

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -41,8 +41,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "ecoregion-siteType-LandTransformationChaudaryBrooks2018CF": "using `ecoregion`",
-    "region-siteType-LandTransformationChaudaryBrooks2018CF": "using `country`"
+    "ecoregion-siteType-LandTransformationChaudaryBrooks2018CF": "",
+    "region-siteType-LandTransformationChaudaryBrooks2018CF": ""
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandTransformation'
 

hestia_earth/models/chaudharyBrooks2018/utils.py

@@ -3,14 +3,14 @@ from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import debugMissingLookup, logRequirements
 from hestia_earth.models.utils.impact_assessment import get_site, get_country_id
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 
-def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str, column: str, group_key: str = None):
-    value = get_table_value(download_lookup(f"{lookup_name}.csv"), col_match, col_val, column_name(column))
-    value = extract_grouped_data(value, group_key) if group_key else value
-    debugMissingLookup(f"{lookup_name}.csv", col_match, col_val, column, value, model=MODEL, term=term_id)
-    return safe_parse_float(value)
+def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str, column: str):
+    value = get_table_value(download_lookup(lookup_name), col_match, col_val, column_name(column))
+    debugMissingLookup(lookup_name, col_match, col_val, column, value, model=MODEL, term=term_id)
+    return value
 
 
 def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None):
@@ -20,12 +20,17 @@ def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str,
     site_type = site.get('siteType')
 
     lookup_prefix = 'ecoregion' if ecoregion else 'region' if country_id else None
-    col_name = 'ecoregion' if ecoregion else 'termid'
-    col_val = ecoregion or country_id
+    lookup_name = f"{lookup_prefix}-siteType-{lookup_suffix}.csv"
 
     logRequirements(impact_assessment, model=MODEL, term=term_id,
                     site_type=site_type,
                     ecoregion=ecoregion,
                     country_id=country_id)
 
-    return _lookup_value(term_id, f"{lookup_prefix}-siteType-{lookup_suffix}", col_name, col_val, site_type, group_key)
+    value = get_region_lookup_value(
+        lookup_name, country_id, site_type, model=MODEL, term=term_id
+    ) if lookup_prefix == 'region' else _lookup_value(
+        term_id, lookup_name, 'ecoregion', ecoregion, site_type
+    )
+    value = extract_grouped_data(value, group_key) if group_key else value
+    return safe_parse_float(value)

hestia_earth/models/cml2001Baseline/abioticResourceDepletionFossilFuels.py

@@ -17,7 +17,7 @@ Source: [JRC Technical reports Suggestions for updating the Product Environmenta
 Source: [Differences between EF model versions](https://eplca.jrc.ec.europa.eu/EFVersioning.html)
 """  # noqa: E501
 from itertools import chain
-from hestia_earth.utils.lookup import download_lookup, column_name
+from hestia_earth.utils.lookup import download_lookup, column_name, find_term_ids_by
 from hestia_earth.utils.tools import list_sum, flatten
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_as_table
@@ -66,8 +66,7 @@ def get_all_non_renewable_terms(lookup_file_name: str, column: 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(column)] == True]["termid"]  # noqa: E712
-    return list(map(str, results))
+    return find_term_ids_by(lookup, column_name(column), True)
 
 
 def _valid_resource_indicator(resource: dict) -> bool:

hestia_earth/models/cml2001Baseline/abioticResourceDepletionMineralsAndMetals.py

@@ -95,7 +95,7 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
                     "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"),
+                        lookup=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

hestia_earth/models/config/Cycle.json

@@ -1183,6 +1183,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "nonCo2EmissionsToAirNaturalVegetationBurning",
+        "runStrategy": "always",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "schmidt2007",

hestia_earth/models/config/ImpactAssessment.json

@@ -865,7 +865,20 @@
       },
       "stage": 1
     },
-
+    {
+      "key": "impacts",
+      "model": "environmentalFootprintV3-1",
+      "value": "photochemicalOzoneCreationPotentialHumanHealthNmvocEq",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": [
+          "value",
+          0.01
+        ]
+      },
+      "stage": 1
+    },
     {
       "key": "impacts",
       "model": "environmentalFootprintV3-1",

hestia_earth/models/config/Site.json

@@ -340,6 +340,14 @@
         "runStrategy": "add_blank_node_if_missing",
         "mergeStrategy": "list",
         "stage": 1
+      },
+      {
+        "key": "measurements",
+        "model": "geospatialDatabase",
+        "value": "altitude",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
       }
     ],
     [

hestia_earth/models/cycle/excretaKgMass.py

@@ -4,12 +4,12 @@ Excreta (kg)
 This model calculates the amount of excreta in `kg` based on the amount of excreta in `kg N` or `kg Vs`.
 """
 from hestia_earth.schema import NodeType, TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import non_empty_list, list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils import get_kg_term_id, get_kg_N_term_id, get_kg_VS_term_id
+from hestia_earth.models.utils.term import download_term
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.product import _new_product, convert_product_to_unit
 from . import MODEL
@@ -68,7 +68,7 @@ def _run_product(cycle: dict, product_term_id: str):
     ]
 
     # convert to 1kg first, then apply ratio to current value
-    term = download_hestia(product_term_id)
+    term = download_term(product_term_id, TermTermType.EXCRETA)
     product = {
         'term': term,
         'value': [1]

hestia_earth/models/cycle/materialAndSubstrate.py

@@ -5,7 +5,7 @@ This model gap-fills depreciated amount per Cycle from Site Infrastructure node.
 """
 from typing import Union
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids
 from hestia_earth.utils.tools import to_precision, flatten, list_sum
 from hestia_earth.utils.model import filter_list_term_type
 
@@ -100,7 +100,8 @@ def _run_input(cycle: dict, input_node: dict) -> dict:
 
 def _has_depreciated_term(term: dict):
     lookup = download_lookup(f"{term.get('termType')}.csv")
-    return term.get('@id') + _ID_SUFFIX in list(lookup.termid)
+    term_ids = lookup_term_ids(lookup)
+    return term.get('@id') + _ID_SUFFIX in term_ids
 
 
 def _should_run_input(cycle: dict, input_node: dict) -> bool:

hestia_earth/models/cycle/pastureGrass.py

@@ -1,9 +1,9 @@
-from hestia_earth.schema import SiteSiteType
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import SiteSiteType, TermTermType
 from hestia_earth.utils.model import linked_node
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.term import download_term
 from . import MODEL
 
 REQUIREMENTS = {
@@ -27,7 +27,7 @@ KEY_TERM_ID = 'genericGrassPlant'
 def _practice():
     node = _new_practice(TERM_ID)
     node['value'] = [100]
-    node['key'] = linked_node(download_hestia(KEY_TERM_ID))
+    node['key'] = linked_node(download_term(KEY_TERM_ID, TermTermType.LANDCOVER))
     return node
 
 

hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "excretaManagement": "EF_NON-N"
+    "excretaManagement": "EF_NO-N"
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -64,7 +64,7 @@ RETURNS = {
 }
 LOOKUPS = {
     "electricity": "ecoinventMapping",
-    "region-ember-energySources": "using `country`",
+    "region-ember-energySources": "",
     "ember-ecoinvent-mapping": ["ember", "ecoinventId", "ecoinventName"]
 }
 

hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -1,8 +1,8 @@
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
 from hestia_earth.utils.tools import safe_parse_float
 
-from hestia_earth.models.log import debugMissingLookup
 from hestia_earth.models.utils.cycle import cycle_end_year
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 
 EMBER_ECOINVENT_LOOKUP_NAME = "ember-ecoinvent-mapping.csv"
 REGION_EMBER_SOURCES_LOOKUP_NAME = "region-ember-energySources.csv"
@@ -17,10 +17,6 @@ def get_input_coefficient(model: str, cycle: dict, country_id: str, ecoinventNam
     source_name = get_table_value(ember_ecoinvent_lookup, column_name('ecoinventName'), ecoinventName, 'ember')
 
     # find the ratio for the country / year
-    region_ember_sources_lookup = download_lookup(REGION_EMBER_SOURCES_LOOKUP_NAME)
-    data = get_table_value(region_ember_sources_lookup, 'termid', country_id, column_name(source_name))
+    data = get_region_lookup_value(REGION_EMBER_SOURCES_LOOKUP_NAME, country_id, source_name, model=model)
     percentage = extract_grouped_data(data, str(year))
-    debugMissingLookup(REGION_EMBER_SOURCES_LOOKUP_NAME,
-                       'termid', country_id, source_name, percentage, year=year, model=model)
-
     return safe_parse_float(percentage, 0) / 100

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -3,8 +3,8 @@ Emission not relevant
 
 The emission is not relevant for this Site, Cycle, or Product.
 """
-from hestia_earth.schema import NodeType, TermTermType, EmissionMethodTier
-from hestia_earth.utils.emission import emission_is_in_system_boundary
+from hestia_earth.schema import NodeType, EmissionMethodTier
+from hestia_earth.utils.lookup_utils import is_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -38,8 +38,8 @@ def _emission(term_id: str):
 
 def _should_run_emission(cycle: dict):
     def run(term_id: str):
-        is_not_relevant = not _run_required(MODEL, {'@id': term_id, 'termType': TermTermType.EMISSION.value}, cycle)
-        in_system_boundary = emission_is_in_system_boundary(term_id)
+        is_not_relevant = not _run_required(MODEL, term_id, cycle)
+        in_system_boundary = is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
         if should_run:

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -8,14 +8,15 @@ summed to obtain the EF single overall score. The number and the name of the imp
 in EF3.0 and EF3.1.
 """
 from typing import List, Optional, Tuple
+
 from hestia_earth.schema import TermTermType
 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.log import logRequirements, logShouldRun, log_as_table, debugValues
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
-from hestia_earth.models.utils.blank_node import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -71,16 +72,30 @@ def _get_pef_method_model(term: dict) -> List[str]:
     return entries.split(";")
 
 
-def _normalise(indicator: dict) -> Optional[float]:
-    return (
-        _node_value(indicator) / _get_factor(indicator.get('term', {}), normalisation_column)
-    ) if (_node_value(indicator) is not None and _get_factor(indicator.get('term', {}), normalisation_column)) else None
-
-
-def _weighted_normalise(indicator: dict) -> Optional[float]:
-    return (
-        _normalise(indicator) * (_get_factor(indicator.get('term', {}), weighing_column) / 100)
-    ) if (_normalise(indicator) is not None and _get_factor(indicator.get('term', {}), weighing_column)) else None
+def _indicator_factors(impact_assessment: dict, indicator: dict):
+    value = _node_value(indicator)
+    normalisation_factor = _get_factor(indicator.get('term', {}), normalisation_column)
+    weighting_factor = _get_factor(indicator.get('term', {}), weighing_column)
+    coefficient = 0 if all([
+        weighting_factor == 0,
+        normalisation_factor == 0
+    ]) else (weighting_factor / 100) / normalisation_factor if all([
+        weighting_factor is not None,
+        normalisation_factor is not None
+    ]) else None
+
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID,
+                node=indicator['term']['@id'],
+                value=value,
+                coefficient=coefficient)
+
+    return {
+        "value": value,
+        "normalisation-used": normalisation_factor,
+        "weighting-used": weighting_factor,
+        "coefficient": coefficient,
+        "weighted-value": value * coefficient if all([value is not None, coefficient is not None]) else None,
+    }
 
 
 def _indicator(value: float) -> dict:
@@ -90,7 +105,7 @@ def _indicator(value: float) -> dict:
 
 
 def _run(indicators: List[dict]):
-    return _indicator(value=list_sum([indicator["weighted-normalised"] for indicator in indicators]))
+    return _indicator(value=list_sum([indicator["weighted-value"] for indicator in indicators]))
 
 
 def _valid_indicator(indicator: Optional[dict]) -> bool:
@@ -104,20 +119,14 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list[dict]]:
         filter_list_term_type(impact_assessment.get('impacts', []), TermTermType.CHARACTERISEDINDICATOR)
         if _is_a_PEF_indicator(indicator)
     ]
-
     has_pef_indicators = bool(indicators)
 
     processed_indicators = [{
-        "indicator": indicator,
+        "indicator": indicator['term']['@id'],
         "valid-indicator": _valid_indicator(indicator),
         "one-indicator-for-category": sum(1 for i in indicators if i['term']['@id'] == indicator['term']['@id']) == 1,
         "indicator-pef-category": indicator.get('term', {}).get('@id'),
-        "value": _node_value(indicator),
-        "normalised": _normalise(indicator),
-        "normalisation-used": _get_factor(indicator.get('term', {}), normalisation_column),
-        "weighted-normalised": _weighted_normalise(indicator),
-        "weighting-used": _get_factor(indicator.get('term', {}), weighing_column),
-    } for indicator in indicators]
+    } | _indicator_factors(impact_assessment, indicator) for indicator in indicators]
 
     no_duplicate_indicators = all([indicator['one-indicator-for-category'] for indicator in processed_indicators])
     valid_indicators = [indicator for indicator in processed_indicators if indicator['valid-indicator']]

hestia_earth/models/environmentalFootprintV3_1/photochemicalOzoneCreationPotentialHumanHealthNmvocEq.py

@@ -0,0 +1,36 @@
+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
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {"@type": "Indicator", "value": "", "term.termType": "emission"}
+        ]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+LOOKUPS = {
+    "emission": "nmvocEqPhotochemicalOzoneFormationEnvironmentalFootprintV3-1"
+}
+TERM_ID = 'photochemicalOzoneCreationPotentialHumanHealthNmvocEq'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator["value"] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    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, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/environmentalFootprintV3_1/scarcityWeightedWaterUse.py

@@ -1,7 +1,7 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_country_value
+from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
-from ..utils.impact_assessment import impact_country_value
-from ..utils.indicator import _new_indicator
 
 REQUIREMENTS = {
     "ImpactAssessment": {