hestia-earth-models 0.73.8__py3-none-any.whl → 0.74.0__py3-none-any.whl

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -38,8 +38,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "awareWaterBasinId": "",
-    "region-aware-factors": ""
+    "awareWaterBasinId": ["YR_IRRI", "YR_NONIRRI", "YR_TOT"],
+    "region-aware-factors": ["Agg_CF_irri", "Agg_CF_non_irri", "Agg_CF_unspecified"]
 }
 TERM_ID = 'scarcityWeightedWaterUse'
 AWARE_KEY = 'awareWaterBasinId'
@@ -48,6 +48,8 @@ IRRIGATED_SITE_TYPES = [
     SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value,
     SiteSiteType.PERMANENT_PASTURE.value
 ]
+_REGION_LOOKUP = 'region-aware-factors.csv'
+_AWARE_LOOKUP = 'awareWaterBasinId.csv'
 
 
 def _indicator(value: float):
@@ -59,19 +61,18 @@ def _indicator(value: float):
 def _get_factor_from_basinId(site: dict, aware_id: str):
     lookup_col = 'YR_IRRI' if site.get('siteType') in IRRIGATED_SITE_TYPES else 'YR_NONIRRI'
     value = _get_single_table_value(
-        download_lookup(f"{AWARE_KEY}.csv"), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
+        download_lookup(_AWARE_LOOKUP), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
     )
-    debugMissingLookup(f"{AWARE_KEY}.csv", AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
+    debugMissingLookup(_AWARE_LOOKUP, AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, default=None)
 
 
 def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
     region_id = get_region_id(impact_assessment, fresh_water)
     site_type = site.get('siteType')
-    lookup_name = 'region-aware-factors.csv'
     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_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
+    value = get_region_lookup_value(_REGION_LOOKUP, region_id, column, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, default=None)
 
 

hestia_earth/models/aware2_0/__init__.py

@@ -0,0 +1,14 @@
+import sys
+from importlib import import_module
+from os.path import dirname, abspath
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'aware2-0'
+MODEL_FOLDER = MODEL.replace('-', '_')
+PKG = '.'.join(['hestia_earth', 'models', MODEL_FOLDER])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/aware2_0/scarcityWeightedWaterUse.py

@@ -0,0 +1,115 @@
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.model import find_term_match
+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
+from hestia_earth.models.utils import sum_values, multiply_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import (
+    convert_value_from_cycle, 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 = {
+    "ImpactAssessment": {
+        "site": {
+            "@type": "Site",
+            "or": {
+                "awareWaterBasinId": "",
+                "country": {"@type": "Term", "termType": "region"}
+            }
+        },
+        "optional": {
+            "emissionsResourceUse": [{
+                "@type": "Indicator",
+                "term.@id": "freshwaterWithdrawalsDuringCycle",
+                "value": ""
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the situation",
+    "awareWaterBasinId-2-0": ["CFs_agri", "CFs_nonagri", "CFs_unspecified"],
+    "region-aware-2-0-factors": ["CFs_agri", "CFs_nonagri", "CFs_unspecified"]
+}
+TERM_ID = 'scarcityWeightedWaterUse'
+AWARE_KEY = 'awareWaterBasinId'
+AGRI_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value,
+    SiteSiteType.PERMANENT_PASTURE.value
+]
+_REGION_LOOKUP = 'region-aware-2-0-factors.csv'
+_AWARE_LOOKUP = 'awareWaterBasinId-2-0.csv'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _lookup_column(site: dict):
+    site_type = site.get('siteType')
+    return (
+        'CFs_unspecified' if not site_type else
+        'CFs_agri' if site_type in AGRI_SITE_TYPES else
+        'CFs_nonagri'
+    )
+
+
+def _get_factor_from_basinId(site: dict, aware_id: str):
+    lookup_col = _lookup_column(site)
+    lookup = download_lookup(_AWARE_LOOKUP)
+    try:
+        value = _get_single_table_value(lookup, column_name(AWARE_KEY), int(aware_id), column_name(lookup_col))
+    except Exception:
+        value = None
+    debugMissingLookup(_AWARE_LOOKUP, AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, default=None)
+
+
+def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
+    region_id = get_region_id(impact_assessment, fresh_water)
+    lookup_col = _lookup_column(site)
+    value = get_region_lookup_value(_REGION_LOOKUP, region_id, lookup_col, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, default=None)
+
+
+def run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    fresh_water = find_term_match(impact_assessment.get('emissionsResourceUse', []), 'freshwaterWithdrawalsDuringCycle')
+    site = get_site(impact_assessment)
+    aware_id = site.get(AWARE_KEY)
+    factor = (
+        _get_factor_from_basinId(site, aware_id) if aware_id else None
+    ) or _get_factor_from_region(impact_assessment, fresh_water, site)
+    inputs_value = convert_value_from_cycle(
+        impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+
+    value = sum_values([
+        multiply_values([fresh_water.get('value'), factor]),
+        inputs_value
+    ])
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    fresh_water=fresh_water.get('value'),
+                    aware_id=aware_id,
+                    factor=factor,
+                    inputs_value=inputs_value)
+
+    should_run = all([value is not None])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return [_indicator(value)] if should_run else []

hestia_earth/models/config/Cycle.json

@@ -955,7 +955,7 @@
     {
       "key": "emissions",
       "model": "ecoinventV3AndEmberClimate",
-      "value": "all",
+      "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",
       "mergeArgs": {
@@ -966,7 +966,7 @@
     {
       "key": "emissions",
       "model": "ecoinventV3",
-      "value": "all",
+      "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",
       "mergeArgs": {
@@ -1469,7 +1469,9 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 2
-      },
+      }
+    ],
+    [
       {
         "key": "emissions",
         "model": "dammgen2009",

hestia_earth/models/config/ImpactAssessment.json

@@ -806,7 +806,7 @@
       },
       {
         "key": "impacts",
-        "model": "aware",
+        "model": "aware2-0",
         "value": "scarcityWeightedWaterUse",
         "runStrategy": "always",
         "mergeStrategy": "list",

hestia_earth/models/config/__init__.py

@@ -1,10 +1,16 @@
 import os
 import json
+from enum import Enum
 from hestia_earth.utils.tools import flatten
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
+class AWARE_VERSION(Enum):
+    V1 = '1.2'
+    V2 = '2.0'
+
+
 def _is_aggregated_model(model: dict):
     return isinstance(model, dict) and 'aggregated' in model.get('value', '').lower()
 
@@ -17,12 +23,26 @@ def _remove_aggregated(models: list):
     return list(filter(lambda v: v is not None, values))
 
 
+def _use_aware_1(models: list):
+    return [
+        _use_aware_1(m) if isinstance(m, list) else
+        m | {'model': 'aware'} if m.get('model') == 'aware2-0' else
+        m | {'value': 'awareWaterBasinId_v1'} if m.get('value') == 'awareWaterBasinId' else
+        m
+        for m in models
+    ]
+
+
 def _load_config(filename: str) -> dict:
     with open(os.path.join(CURRENT_DIR, f"{filename}.json"), 'r') as f:
         return json.load(f)
 
 
-def load_config(node_type: str, skip_aggregated_models: bool = False) -> dict:
+def load_config(
+    node_type: str,
+    skip_aggregated_models: bool = False,
+    use_aware_version: AWARE_VERSION = AWARE_VERSION.V2
+) -> dict:
     """
     Load the configuration associated with the Node Type.
 
@@ -32,11 +52,15 @@ def load_config(node_type: str, skip_aggregated_models: bool = False) -> dict:
         The Node Type to load configuration. Can be: `Cycle`, `Site`, `ImpactAssessment`.
     skip_aggregated_models : bool
         Include models using aggregated data. Included by default.
+    use_aware_version : AWARE_VERSION
+        Choose which AWARE version to use. Defaults to using version `2.0`.
     """
     try:
         config = _load_config(node_type)
         models = config.get('models')
-        return config | {'models': _remove_aggregated(models) if skip_aggregated_models else models}
+        models = _remove_aggregated(models) if skip_aggregated_models else models
+        models = _use_aware_1(models) if use_aware_version == AWARE_VERSION.V1 else models
+        return config | {'models': models}
     except FileNotFoundError:
         raise Exception(f"Invalid type {node_type}.")
 

hestia_earth/models/cycle/animal/input/hestiaAggregatedData.py

@@ -56,12 +56,12 @@ def _should_run_animal(cycle: dict, animal: dict):
     inputs = list(filter(should_link_input_to_impact(cycle), inputs))
     nb_inputs = len(inputs)
 
-    logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY,
+    logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY, animalId=animal.get('animalId'),
                     end_date=end_date,
                     nb_inputs=nb_inputs)
 
     should_run = all([end_date, nb_inputs > 0])
-    logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY)
+    logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY, animalId=animal.get('animalId'))
     return should_run, inputs
 
 

hestia_earth/models/cycle/animal/input/properties.py

@@ -50,7 +50,7 @@ def _find_related_product(input: dict):
     return find_term_match(products, input.get('term', {}).get('@id'))
 
 
-def _run_input_by_impactAssessment(cycle: dict):
+def _run_input_by_impactAssessment(cycle: dict, **log_args):
     def exec(input: dict):
         term_id = input.get('term', {}).get('@id')
         product = _find_related_product(input)
@@ -58,7 +58,7 @@ def _run_input_by_impactAssessment(cycle: dict):
         all_properties = input.get('properties', [])
         new_properties = [p for p in properties if not find_term_match(all_properties, p.get('term', {}).get('@id'))]
         for prop in new_properties:
-            logShouldRun(cycle, MODEL, term_id, True, property=prop.get('term', {}).get('@id'))
+            logShouldRun(cycle, MODEL, term_id, True, property=prop.get('term', {}).get('@id'), **log_args)
         return {**input, 'properties': merge_blank_nodes(all_properties, new_properties)} if new_properties else input
     return exec
 
@@ -80,9 +80,10 @@ def _run_animal(cycle: dict, animal: dict):
             should_run_properties_value(i)
         ])
     ]
-    inputs = list(map(_run_input_by_impactAssessment(cycle), inputs))
-    inputs = rescale_properties_from_dryMatter(MODEL, cycle, inputs)
-    inputs = average_blank_node_properties_value(cycle, inputs)
+    log_args = {'animalId': animal.get('animalId')}
+    inputs = list(map(_run_input_by_impactAssessment(cycle, **log_args), inputs))
+    inputs = rescale_properties_from_dryMatter(MODEL, cycle, inputs, **log_args)
+    inputs = average_blank_node_properties_value(cycle, inputs, **log_args)
     return animal | {'inputs': inputs}
 
 

hestia_earth/models/cycle/animal/milkYield.py

@@ -42,12 +42,17 @@ def _run(cycle: dict, animal: dict):
     practices = non_empty_list(
         [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids]
     )
+    log_args = {
+        'model_key': MODEL_KEY,
+        'animalId': animal.get('animalId')
+    }
 
-    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                    practice_ids=log_blank_nodes_id(practices))
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    practice_ids=log_blank_nodes_id(practices),
+                    **log_args)
 
     for practice in practices:
-        logShouldRun(cycle, MODEL, practice.get('term', {}).get('@id'), True, model_key=MODEL_KEY)
+        logShouldRun(cycle, MODEL, practice.get('term', {}).get('@id'), True, **log_args)
 
     return {
         **animal,

hestia_earth/models/cycle/utils.py

@@ -11,21 +11,21 @@ def _should_run_property_by_min_max(property: dict):
     ])
 
 
-def _run_property(cycle: dict, property: dict):
+def _run_property(cycle: dict, property: dict, **log_args):
     term_id = property.get('term', {}).get('@id')
 
     should_run = _should_run_property_by_min_max(property)
-    logShouldRun(cycle, MODEL, term_id, should_run, key='value')
+    logShouldRun(cycle, MODEL, term_id, should_run, key='value', **log_args)
 
     return property | ({
         'value': list_average([property.get('min'), property.get('max')])
     } if should_run else {})
 
 
-def _run_properties(cycle: dict, blank_node: dict):
+def _run_properties(cycle: dict, blank_node: dict, **log_args):
     properties = blank_node.get('properties', [])
     return blank_node | ({
-        'properties': [_run_property(cycle, p) for p in properties]
+        'properties': [_run_property(cycle, p, **log_args) for p in properties]
     } if properties else {})
 
 
@@ -33,5 +33,5 @@ def should_run_properties_value(blank_node: dict):
     return any(map(_should_run_property_by_min_max, blank_node.get('properties', [])))
 
 
-def average_blank_node_properties_value(cycle: dict, blank_nodes: list):
-    return [_run_properties(cycle, v) for v in blank_nodes]
+def average_blank_node_properties_value(cycle: dict, blank_nodes: list, **log_args):
+    return [_run_properties(cycle, v, **log_args) for v in blank_nodes]

hestia_earth/models/data/ecoinventV3/__init__.py

@@ -1,36 +1,18 @@
 import os
-from functools import lru_cache
-from hestia_earth.utils.lookup import column_name, get_table_value, load_lookup, lookup_columns
-from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logger
 
 _CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-_ENV_NAME = 'ECOINVENT_V3_FILEPATH'
+_ENV_FOLDER = 'ECOINVENT_V3_FOLDER'
+_ECOINVENT_FOLDER = os.getenv(_ENV_FOLDER) or _CURRENT_DIR
+_ECOINVENT_VERSION = os.getenv('ECOINVENT_VERSION', '3.9')
 
 
-@lru_cache()
-def _get_file():
-    filepath = os.getenv(_ENV_NAME, f"{os.path.join(_CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
-
+def get_filepath(term_type: str):
+    filename = f"ecoinventV{_ECOINVENT_VERSION.replace('.', '_')}-{term_type}.csv"
+    filepath = os.path.join(_ECOINVENT_FOLDER, filename)
     if not os.path.exists(filepath):
-        logger.warning('Ecoinvent file not found. Please make sure to set env variable "%s".', _ENV_NAME)
+        logger.warning('Ecoinvent file not found. Please make sure to set env variable "%s".', _ENV_FOLDER)
         return None
 
-    return load_lookup(filepath=filepath, keep_in_memory=True)
-
-
-def ecoinventV3_emissions(ecoinventName: str):
-    lookup = _get_file()
-    col_name = column_name('ecoinventName')
-
-    def emission(column: str):
-        id = get_table_value(lookup, col_name, ecoinventName, column_name(column))
-        value = get_table_value(lookup, col_name, ecoinventName, column_name(column.replace('termid', 'value')))
-        return (id, value) if id else None
-
-    columns = [
-        col for col in lookup_columns(lookup)
-        if col.endswith(column_name('termid'))
-    ]
-    return non_empty_list(map(emission, columns))
+    return filepath

hestia_earth/models/ecoalimV9/cycle.py

@@ -1,17 +1,18 @@
-from functools import reduce
 from statistics import mean
 from hestia_earth.schema import EmissionMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logShouldRun, logRequirements
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.background_emissions import (
     get_background_inputs,
     no_gap_filled_background_emissions,
-    log_missing_emissions
+    log_missing_emissions,
+    parse_term_id,
+    process_input_mappings
 )
-from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, process_input, parse_term_id
+from .utils import get_input_mappings, extract_input_mapping
 from . import MODEL
 
 REQUIREMENTS = {
@@ -51,6 +52,7 @@ RETURNS = {
 }
 LOOKUPS = {
     "ecoalim-emission": "emission-",
+    "emission": "inputProductionGroupId",
     "animalProduct": "ecoalimMapping",
     "crop": "ecoalimMapping",
     "feedFoodAdditive": "ecoalimMapping",
@@ -84,6 +86,13 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = (input.get('parent', {})).get('@id') or input.get('animalId', {})
+        extra_logs = {
+            **({'input_group_id': input_parent_term_id} if input_parent_term_id else {}),
+            **({'animalId': input.get('animalId')} if input.get('animalId') else {})
+        }
+
         # skip input that has background emissions we have already gap-filled (model run before)
         has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
@@ -91,15 +100,22 @@ def _run_input(cycle: dict):
                         has_mappings=has_mappings,
                         mappings=';'.join([v[1] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
-        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY, **extra_logs)
 
-        results = process_input(
-            cycle, input, mappings, TermTermType.EMISSION, model_key=MODEL_KEY
+        results = process_input_mappings(
+            cycle, input, mappings, TermTermType.EMISSION,
+            extract_mapping=extract_input_mapping,
+            **(
+                extra_logs | {'model': MODEL, 'model_key': MODEL_KEY}
+            )
         ) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())), **(
+            extra_logs | {'has_mappings': has_mappings}
+        ))
         return [
             _emission(
                 term_id=parse_term_id(term_id),
@@ -115,5 +131,5 @@ def _run_input(cycle: dict):
 
 def run(cycle: dict):
     inputs = get_background_inputs(cycle)
-    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    grouped_inputs = group_by_keys(inputs, ['term', 'operation', 'animal'])
     return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -1,13 +1,17 @@
-from functools import reduce
 from statistics import mean
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logShouldRun, logRequirements
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.background_emissions import get_background_inputs, log_missing_emissions
-from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, process_input, parse_term_id
+from hestia_earth.models.utils.background_emissions import (
+    get_background_inputs,
+    log_missing_emissions,
+    parse_term_id,
+    process_input_mappings
+)
+from .utils import get_input_mappings, extract_input_mapping
 from . import MODEL
 
 REQUIREMENTS = {
@@ -74,6 +78,8 @@ def _indicator(
     indicator['inputs'] = [input.get('term')]
     if input.get('operation'):
         indicator['operation'] = input.get('operation')
+    if input.get('animal'):
+        indicator['animals'] = [input.get('animal')]
     return indicator
 
 
@@ -89,20 +95,34 @@ def _run_input(impact_assessment: dict):
         mappings = get_input_mappings(MODEL, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = (input.get('parent', {})).get('@id') or input.get('animalId', {})
+        extra_logs = {
+            **({'input_group_id': input_parent_term_id} if input_parent_term_id else {}),
+            **({'animalId': input.get('animalId')} if input.get('animalId') else {})
+        }
+
         logRequirements(impact_assessment, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         has_mappings=has_mappings,
                         mappings=';'.join([v[1] for v in mappings]),
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         should_run = all([has_mappings, input_value])
         logShouldRun(
-            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY
+            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY, **extra_logs
         )
 
-        results = process_input(
-            impact_assessment, input, mappings, TermTermType.RESOURCEUSE, model_key=MODEL_KEY
+        results = process_input_mappings(
+            impact_assessment, input, mappings, TermTermType.RESOURCEUSE,
+            extract_mapping=extract_input_mapping,
+            **(
+                extra_logs | {'model': MODEL, 'model_key': MODEL_KEY}
+            )
         ) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())), **(
+            extra_logs | {'has_mappings': has_mappings}
+        ))
         return [
             _indicator(
                 term_id=parse_term_id(term_id),
@@ -120,5 +140,5 @@ def _run_input(impact_assessment: dict):
 
 def run(impact_assessment: dict):
     inputs = get_background_inputs(impact_assessment.get('cycle', {}))
-    grouped_inputs = reduce(group_by_keys(['term', 'operation']), inputs, {})
+    grouped_inputs = group_by_keys(inputs, ['term', 'operation', 'animal'])
     return flatten(map(_run_input(impact_assessment), grouped_inputs.values()))