hestia-earth-models 0.59.3__py3-none-any.whl → 0.59.5__py3-none-any.whl

hestia_earth/models/ipcc2019/organicCarbonPerHa.py

@@ -18,15 +18,12 @@ from typing import (
 from hestia_earth.schema import (
     CycleFunctionalUnit,
     MeasurementMethodClassification,
-    SchemaType,
     SiteSiteType,
     TermTermType,
 )
-from hestia_earth.utils.api import find_related
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
 
-from hestia_earth.models.utils import _load_calculated_node
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match,
@@ -49,12 +46,11 @@ from hestia_earth.models.utils.term import (
     get_cover_crop_property_terms,
     get_crop_residue_incorporated_or_left_on_field_terms,
     get_irrigated_terms,
-    get_long_fallow_land_cover_terms,
     get_residue_removed_or_burnt_terms,
     get_upland_rice_crop_terms,
     get_upland_rice_land_cover_terms
 )
-
+from hestia_earth.models.utils.site import related_cycles
 from .utils import check_consecutive
 from . import MODEL
 
@@ -613,25 +609,26 @@ A dictionary mapping IPCC soil categories to corresponding soil type and USDA so
 `"IPCC_SOIL_CATEGORY"` column.
 """
 
-IPCC_LAND_USE_CATEGORY_TO_SITE_TYPE = {
-    IpccLandUseCategory.GRASSLAND: SiteSiteType.PERMANENT_PASTURE.value,
-    IpccLandUseCategory.PERENNIAL_CROPS: SiteSiteType.CROPLAND.value,
-    IpccLandUseCategory.PADDY_RICE_CULTIVATION: SiteSiteType.CROPLAND.value,
-    IpccLandUseCategory.ANNUAL_CROPS_WET: SiteSiteType.CROPLAND.value,
-    IpccLandUseCategory.ANNUAL_CROPS: SiteSiteType.CROPLAND.value,
-    IpccLandUseCategory.SET_ASIDE: SiteSiteType.CROPLAND.value,
-    IpccLandUseCategory.FOREST: SiteSiteType.FOREST.value,
-    IpccLandUseCategory.NATIVE: SiteSiteType.OTHER_NATURAL_VEGETATION.value
+SITE_TYPE_TO_IPCC_LAND_USE_CATEGORY = {
+    SiteSiteType.PERMANENT_PASTURE.value: IpccLandUseCategory.GRASSLAND,
+    SiteSiteType.FOREST.value: IpccLandUseCategory.FOREST,
+    SiteSiteType.OTHER_NATURAL_VEGETATION.value: IpccLandUseCategory.NATIVE
 }
 """
-A dictionary mapping IPCC land use categories to corresponding site types.
+A dictionary mapping site types to corresponding IPCC land use categories.
 """
 
 IPCC_LAND_USE_CATEGORY_TO_LAND_COVER_LOOKUP_VALUE = {
+    IpccLandUseCategory.GRASSLAND: "Grassland",
     IpccLandUseCategory.PERENNIAL_CROPS: "Perennial crops",
     IpccLandUseCategory.PADDY_RICE_CULTIVATION: "Paddy rice cultivation",
     IpccLandUseCategory.ANNUAL_CROPS_WET: "Annual crops",
-    IpccLandUseCategory.ANNUAL_CROPS: "Annual crops"
+    IpccLandUseCategory.ANNUAL_CROPS: "Annual crops",
+    IpccLandUseCategory.SET_ASIDE: [
+        "Annual crops", "Paddy rice cultivation", "Perennial crops", "Set aside"
+    ],
+    IpccLandUseCategory.FOREST: "Forest",
+    IpccLandUseCategory.NATIVE: "Native"
 }
 """
 A dictionary mapping IPCC land use categories to corresponding land cover lookup values in the
@@ -2528,7 +2525,7 @@ def _has_irrigation(water_regime_nodes: list[dict]) -> bool:
 
     Parameters
     ----------
-    water_regime_nodes : List[dict]
+    water_regime_nodes : list[dict]
         List of water regime nodes to be checked.
 
     Returns
@@ -2545,13 +2542,13 @@ def _has_irrigation(water_regime_nodes: list[dict]) -> bool:
 
 def _has_long_fallow(land_cover_nodes: list[dict]) -> bool:
     """
-    Check if long fallow terms is present in the land cover nodes.
+    Check if long fallow terms are present in the land cover nodes.
 
     n.b., a super majority of the site area must be under long fallow for it to be classified as set aside.
 
     Parameters
     ----------
-    land_cover_nodes : List[dict]
+    land_cover_nodes : list[dict]
         List of land cover nodes to be checked.
 
     Returns
@@ -2559,9 +2556,12 @@ def _has_long_fallow(land_cover_nodes: list[dict]) -> bool:
     bool
         `True` if long fallow is present, `False` otherwise.
     """
-    return cumulative_nodes_term_match(
+    LOOKUP = LOOKUPS["landCover"][0]
+    TARGET_LOOKUP_VALUE = "Set aside"
+    return cumulative_nodes_lookup_match(
         land_cover_nodes,
-        target_term_ids=get_long_fallow_land_cover_terms(),
+        lookup=LOOKUP,
+        target_lookup_values=TARGET_LOOKUP_VALUE,
         cumulative_threshold=SUPER_MAJORITY_AREA_THRESHOLD
     ) or cumulative_nodes_match(
         lambda node: get_node_property(node, LONG_FALLOW_CROP_TERM_ID, False).get("value", 0),
@@ -2576,7 +2576,7 @@ def _has_upland_rice(land_cover_nodes: list[dict]) -> bool:
 
     Parameters
     ----------
-    land_cover_nodes : List[dict]
+    land_cover_nodes : list[dict]
         List of land cover nodes to be checked.
 
     Returns
@@ -2592,63 +2592,39 @@ def _has_upland_rice(land_cover_nodes: list[dict]) -> bool:
 
 
 IPCC_LAND_USE_CATEGORY_TO_VALIDATION_KWARGS = {
+    IpccLandUseCategory.ANNUAL_CROPS_WET: {"has_wetland_soils"},
     IpccLandUseCategory.SET_ASIDE: {"has_long_fallow"},
-    IpccLandUseCategory.ANNUAL_CROPS_WET: {"has_wetland_soils"}
 }
 """
-Keyword arguments that need to be checked for specific `IpccLandUseCategory`s.
+Keyword arguments that need to be validated in addition to the `landCover` lookup match for specific
+`IpccLandUseCategory`s.
 """
 
-
-def _check_ipcc_land_use_category(*, key: IpccLandUseCategory, site_type: str, **kwargs) -> bool:
-    """
-    Check if the site type matches the target site type for the given key.
-
-    Parameters
-    ----------
-    key : IpccLandUseCategory
-        The IPCC land use category to check.
-    site_type : str
-        The site type to check.
-
-    Keyword Args
-    ------------
-    has_long_fallow : bool
-        Indicates whether long fallow is present on more than 30% of the site.
-    has_wetland_soils : bool
-        Indicates whether wetland soils are present to more than 30% of the site.
-
-    Returns
-    -------
-    bool
-        `True` if the conditions match the specified land use category, `False` otherwise.
-
-    """
-    target_site_type = IPCC_LAND_USE_CATEGORY_TO_SITE_TYPE.get(key, None)
-    validation_kwargs = IPCC_LAND_USE_CATEGORY_TO_VALIDATION_KWARGS.get(key, set())
-    valid_kwargs = all(v for k, v in kwargs.items() if k in validation_kwargs)
-    return site_type == target_site_type and valid_kwargs
+IPCC_LAND_USE_CATEGORY_TO_OVERRIDE_KWARGS = {
+    IpccLandUseCategory.PADDY_RICE_CULTIVATION: {"has_irrigated_upland_rice"}
+}
+"""
+Keyword arguments that can override the `landCover` lookup match for specific `IpccLandUseCategory`s.
+"""
 
 
-def _check_cropland_land_use_category(
-    *, key: IpccLandUseCategory, site_type: str, land_cover_nodes: list[dict], **kwargs
-) -> bool:
+def _check_ipcc_land_use_category(*, key: IpccLandUseCategory, land_cover_nodes: list[dict], **kwargs) -> bool:
     """
-    Check if the site type and land cover nodes match the target conditions for a cropland IpccLandUseCategory.
-
-    This function is special case of `_check_ipcc_land_use_category`.
+    Check if the land cover nodes and keyword args satisfy the requirements for the given key.
 
     Parameters
     ----------
     key : IpccLandUseCategory
         The IPCC land use category to check.
-    site_type : str
-        The site type to check.
+    land_cover_nodes : list[dict]
+        List of land cover nodes to be checked.
 
     Keyword Args
     ------------
+    has_irrigated_upland_rice : bool
+        Indicates whether irrigated upland rice is present on more than 30% of the site.
     has_long_fallow : bool
-        Indicates whether long fallow is present on more than 30% of the site.
+        Indicates whether long fallow is present on more than 70% of the site.
     has_wetland_soils : bool
         Indicates whether wetland soils are present to more than 30% of the site.
 
@@ -2665,48 +2641,23 @@ def _check_cropland_land_use_category(
         target_lookup_values=target_lookup_values,
         cumulative_threshold=MIN_AREA_THRESHOLD
     )
-    return _check_ipcc_land_use_category(key=key, site_type=site_type, **kwargs) and valid_lookup
-
-
-def _check_paddy_rice_cultivation_land_use_category(
-    *, key: IpccLandUseCategory, site_type: str, has_irrigated_upland_rice: bool, **kwargs
-) -> bool:
-    """
-    Check if the site type and land cover nodes match the target conditions for a cropland IpccLandUseCategory.
 
-    This function is special case of `_check_cropland_land_use_category`.
+    validation_kwargs = IPCC_LAND_USE_CATEGORY_TO_VALIDATION_KWARGS.get(key, set())
+    valid_kwargs = all(v for k, v in kwargs.items() if k in validation_kwargs)
 
-    Parameters
-    ----------
-    key : IpccLandUseCategory
-        The IPCC land use category to check.
-    site_type : str
-        The site type to check.
+    override_kwargs = IPCC_LAND_USE_CATEGORY_TO_OVERRIDE_KWARGS.get(key, set())
+    valid_override = any(v for k, v in kwargs.items() if k in override_kwargs)
 
-    Keyword Args
-    ------------
-    has_irrigated_upland_rice : bool
-        Indicates whether irrigated upland rice is present on more than 30% of the site.
-    has_long_fallow : bool
-        Indicates whether long fallow is present on more than 30% of the site.
-    has_wetland_soils : bool
-        Indicates whether wetland soils are present to more than 30% of the site.
-
-    Returns
-    -------
-    bool
-        `True` if the conditions match the specified land use category, `False` otherwise.
-    """
-    return _check_cropland_land_use_category(key=key, site_type=site_type, **kwargs) or has_irrigated_upland_rice
+    return (valid_lookup and valid_kwargs) or valid_override
 
 
 LAND_USE_CATEGORY_DECISION_TREE = {
     IpccLandUseCategory.GRASSLAND: _check_ipcc_land_use_category,
     IpccLandUseCategory.SET_ASIDE: _check_ipcc_land_use_category,
-    IpccLandUseCategory.PERENNIAL_CROPS: _check_cropland_land_use_category,
-    IpccLandUseCategory.PADDY_RICE_CULTIVATION: _check_paddy_rice_cultivation_land_use_category,
-    IpccLandUseCategory.ANNUAL_CROPS_WET: _check_cropland_land_use_category,
-    IpccLandUseCategory.ANNUAL_CROPS: _check_cropland_land_use_category,
+    IpccLandUseCategory.PERENNIAL_CROPS: _check_ipcc_land_use_category,
+    IpccLandUseCategory.PADDY_RICE_CULTIVATION: _check_ipcc_land_use_category,
+    IpccLandUseCategory.ANNUAL_CROPS_WET: _check_ipcc_land_use_category,
+    IpccLandUseCategory.ANNUAL_CROPS: _check_ipcc_land_use_category,
     IpccLandUseCategory.FOREST: _check_ipcc_land_use_category,
     IpccLandUseCategory.NATIVE: _check_ipcc_land_use_category,
     IpccLandUseCategory.OTHER: _check_ipcc_land_use_category
@@ -2715,21 +2666,19 @@ LAND_USE_CATEGORY_DECISION_TREE = {
 A decision tree mapping IPCC soil categories to corresponding check functions.
 
 Key: IpccLandUseCategory
-Value: Corresponding function for checking the match of the given land use category based on site type
-and land cover nodes.
+Value: Corresponding function for checking the match of the given land use category based on land cover nodes
+and additional kwargs.
 """
 
 
 def _assign_ipcc_land_use_category(
-    site_type: str, management_nodes: list[dict], ipcc_soil_category: IpccSoilCategory
+    management_nodes: list[dict], ipcc_soil_category: IpccSoilCategory,
 ) -> IpccLandUseCategory:
     """
-    Assigns IPCC land use category based on site type, management nodes, and soil category.
+    Assigns IPCC land use category based on management nodes and soil category.
 
     Parameters
     ----------
-    site_type : str
-        The type of the site.
     management_nodes : list[dict]
         List of management nodes.
     ipcc_soil_category : IpccSoilCategory
@@ -2752,14 +2701,13 @@ def _assign_ipcc_land_use_category(
     has_long_fallow = _has_long_fallow(land_cover_nodes)
     has_wetland_soils = ipcc_soil_category is IpccSoilCategory.WETLAND_SOILS
 
-    should_run = bool(site_type)
+    should_run = bool(land_cover_nodes)
 
     return next(
         (
             key for key in DECISION_TREE
             if DECISION_TREE[key](
                 key=key,
-                site_type=site_type,
                 land_cover_nodes=land_cover_nodes,
                 has_long_fallow=has_long_fallow,
                 has_irrigated_upland_rice=has_irrigated_upland_rice,
@@ -2783,7 +2731,7 @@ def _check_grassland_ipcc_management_category(
     ----------
     key : IpccManagementCategory
         The IPCC management category to check.
-    land_cover_nodes : List[dict]
+    land_cover_nodes : list[dict]
         List of land cover nodes to be checked.
 
     Returns
@@ -2809,7 +2757,7 @@ def _check_tillage_ipcc_management_category(
     ----------
     key : IpccManagementCategory
         The IPCC management category to check.
-    tillage_nodes : List[dict]
+    tillage_nodes : list[dict]
         List of tillage nodes to be checked.
 
     Returns
@@ -3554,7 +3502,7 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     site_type = site.get("siteType", "")
     management_nodes = site.get("management", [])
     measurement_nodes = site.get("measurements", [])
-    cycles = _calculated_cycles(site.get("@id"))
+    cycles = related_cycles(site.get("@id"))
 
     has_management = len(management_nodes) > 0
     has_measurements = len(measurement_nodes) > 0
@@ -3611,26 +3559,6 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     return should_run_tier_1, should_run_tier_2, inventory, kwargs
 
 
-def _calculated_cycles(site_id: str):
-    """
-    Get the list of `Cycle`s related to the `Site`. Gets the `recalculated` data if available, else `original`.
-
-    Parameters
-    ----------
-    site_id : str
-        The `@id` of the `Site`.
-
-    Returns
-    -------
-    list[dict]
-        The related `Cycle`s as `dict`.
-    """
-    nodes = find_related(SchemaType.SITE, site_id, SchemaType.CYCLE)
-    return list(
-        map(lambda node: _load_calculated_node(node, SchemaType.CYCLE), nodes or [])
-    )
-
-
 def _should_run_tier_1(
     inventory: dict,
     *,
@@ -3806,11 +3734,15 @@ def _should_run_inventory_year_tier_2(group: dict) -> bool:
 def _get_grouped_climate_measurements(grouped_measurements: dict) -> dict:
     return {
         year: {
-            _InventoryKey.TEMP_MONTHLY: find_term_match(measurements, TEMPERATURE_MONTHLY_TERM_ID, {}).get("value", []),
-            _InventoryKey.PRECIP_MONTHLY: (
+            _InventoryKey.TEMP_MONTHLY: non_empty_list(
+                find_term_match(measurements, TEMPERATURE_MONTHLY_TERM_ID, {}).get("value", [])
+            ),
+            _InventoryKey.PRECIP_MONTHLY: non_empty_list(
                 find_term_match(measurements, PRECIPITATION_MONTHLY_TERM_ID, {}).get("value", [])
             ),
-            _InventoryKey.PET_MONTHLY: find_term_match(measurements, PET_MONTHLY_TERM_ID, {}).get("value", [])
+            _InventoryKey.PET_MONTHLY: non_empty_list(
+                find_term_match(measurements, PET_MONTHLY_TERM_ID, {}).get("value", [])
+            )
         } for year, measurements in grouped_measurements.items()
     }
 
@@ -3940,15 +3872,19 @@ def _build_inventory_tier_1(
     eco_climate_zone = _get_eco_climate_zone(measurement_nodes)
     ipcc_soil_category = _assign_ipcc_soil_category(measurement_nodes)
     soc_ref = _retrieve_soc_ref(eco_climate_zone, ipcc_soil_category)
+    grouped_management = group_nodes_by_year(management_nodes)
+
+    # If no `landCover` nodes in `site.management` use `site.siteType` to assign static `IpccLandUseCategory`
+    run_with_site_type = len(filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])) == 0
+    site_type_ipcc_land_use_category = SITE_TYPE_TO_IPCC_LAND_USE_CATEGORY.get(site_type, IpccLandUseCategory.OTHER)
 
     grouped_management = group_nodes_by_year(management_nodes)
 
     grouped_land_use_categories = {
         year: {
-            _InventoryKey.LU_CATEGORY: _assign_ipcc_land_use_category(
-                site_type,
-                nodes,
-                ipcc_soil_category
+            _InventoryKey.LU_CATEGORY: (
+                site_type_ipcc_land_use_category if run_with_site_type
+                else _assign_ipcc_land_use_category(nodes, ipcc_soil_category)
             )
         } for year, nodes in grouped_management.items()
     }
@@ -3986,7 +3922,8 @@ def _build_inventory_tier_1(
     kwargs = {
         "eco_climate_zone": eco_climate_zone,
         "ipcc_soil_category": ipcc_soil_category,
-        "soc_ref": soc_ref,
+        "run_with_site_type": run_with_site_type,
+        "soc_ref": soc_ref
     }
 
     return inventory, kwargs

hestia_earth/models/linkedImpactAssessment/__init__.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
 from hestia_earth.utils.tools import flatten, list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import load_impacts
 from hestia_earth.models.utils.blank_node import group_by_keys
@@ -52,71 +52,99 @@ MODEL_AGGREGATED = 'hestiaAggregatedData'
 TIER = EmissionMethodTier.BACKGROUND.value
 
 
-def _emission(cycle: dict, term_id: str, value: float, input: dict, model: str):
-    # log run on each emission so we know it did run
-    input_term_id = input.get('term', {}).get('@id')
-    operation_term_id = input.get('operation', {}).get('@id')
-    animal_term_id = input.get('animal', {}).get('@id')
-
-    logShouldRun(cycle, model, term_id, True, methodTier=TIER,
-                 input=input_term_id,
-                 operation=operation_term_id,
-                 animal=animal_term_id)
-
+def _emission(model: str, term_id: str, value: float, input: dict, operation={}, animal={}):
     emission = _new_emission(term_id, model)
     emission['value'] = [value]
     emission['methodTier'] = TIER
-    emission['inputs'] = [input.get('term')]
-    if input.get('operation'):
-        emission['operation'] = input.get('operation')
-    if input.get('animal'):
-        emission['animals'] = [input.get('animal')]
+    emission['inputs'] = [input]
+    if operation:
+        emission['operation'] = operation
+    if animal:
+        emission['animals'] = [animal]
     return emission
 
 
+def _run_emission(cycle: dict, term_id: str, data: dict):
+    def run_input(values: dict):
+        value = values.get('value', 0)
+        term = values.get('term', {})
+        operation = values.get('operation', {})
+        animal = values.get('animal', {})
+        is_aggregated = any(values.get('aggregated', []))
+        model = MODEL_AGGREGATED if is_aggregated else MODEL
+
+        details = values.get('details', {})
+        logRequirements(cycle, model=model, term=term_id,
+                        values=log_as_table([{'impact_assessment_id': key} | value for key, value in details.items()]))
+
+        logShouldRun(cycle, model, term_id, True, methodTier=TIER,
+                     input=term.get('@id'),
+                     operation=operation.get('@id'),
+                     animal=animal.get('@id'))
+
+        return _emission(model, term_id, value, input=term, operation=operation, animal=animal)
+
+    return list(map(run_input, data.values()))
+
+
 def _emission_group(term_id: str):
     lookup = download_lookup('emission.csv', True)
     return get_table_value(lookup, 'termid', term_id, column_name('inputProductionGroupId'))
 
 
 def _group_emissions(impact: dict):
-    def _group_by(prev: dict, emission: dict):
+    def _group_by(group: dict, emission: dict):
         term_id = emission.get('term', {}).get('@id')
         grouping = _emission_group(term_id)
         value = emission.get('value') or 0
         if grouping:
-            prev[grouping] = prev.get(grouping, 0) + value
-        return prev
+            group[grouping] = group.get(grouping, 0) + value
+        return group
 
     emissions = impact.get('emissionsResourceUse', [])
     return reduce(_group_by, emissions, {})
 
 
-def _run_input(cycle: dict):
-    def run(inputs: list):
-        input = inputs[0]
-        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
-        term_id = input.get('term', {}).get('@id')
-        impact = input.get('impactAssessment')
-        model = MODEL_AGGREGATED if impact.get('aggregated', False) else MODEL
-        emissions = _group_emissions(impact)
-
-        logRequirements(cycle, model=model, term=term_id,
-                        impact_assessment_id=input.get('impactAssessment', {}).get('@id'),
-                        input_value=input_value)
-        logShouldRun(cycle, model, term_id, True, methodTier=TIER)
-
-        return [
-            _emission(cycle, id, input_value * value, input, model) for id, value in emissions.items()
-        ]
-    return run
-
-
 def _animal_inputs(animal: dict):
     inputs = load_impacts(animal.get('inputs', []))
     return [(input | {'animal': animal.get('term', {})}) for input in inputs]
 
 
+def _group_input_emissions(input: dict):
+    impact = input.get('impactAssessment')
+    emissions = _group_emissions(impact)
+    return input | {'emissions': emissions}
+
+
+def _group_inputs(group: dict, values: tuple):
+    # input_group_key = 'group-id'
+    # inputs = [{'term': {}, 'value':[], 'impactAssessment': {}, 'emissions': {'co2ToAirInputsProduction': 10}}]
+    input_group_key, inputs = values
+    for input in inputs:
+        input_value = list_sum(input.get('value'))
+        emissions = input.get('emissions', {})
+        for emission_term_id, emission_value in emissions.items():
+            group[emission_term_id] = group.get(emission_term_id, {})
+
+            grouped_inputs = group[emission_term_id].get(input_group_key, {
+                'term': input.get('term', {}),
+                'operation': input.get('operation', {}),
+                'animal': input.get('animal', {}),
+                'value': 0,
+                'aggregated': [],
+                'details': {}
+            })
+            grouped_inputs['aggregated'].append(input.get('impactAssessment', {}).get('agregated', False))
+            grouped_inputs['value'] = grouped_inputs['value'] + (emission_value * input_value)
+            # for logging
+            grouped_inputs['details'][input.get('impactAssessment', {}).get('@id')] = {
+                'emission_value': emission_value,
+                'input_value': input_value
+            }
+            group[emission_term_id][input_group_key] = grouped_inputs
+    return group
+
+
 def run(_, cycle: dict):
     inputs = flatten(
         load_impacts(cycle.get('inputs', [])) +
@@ -124,9 +152,16 @@ def run(_, cycle: dict):
     )
     inputs = [i for i in inputs if list_sum(i.get('value', [])) > 0]
 
+    # group inputs with same term/operation/animal to avoid adding emissions twice
+    # inputs = {'group-id': [{'term': {},'value':[10],'impactAssessment': {}}]}
+    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    inputs = {key: list(map(_group_input_emissions, value)) for key, value in inputs.items()}
+
     debugValues(cycle, model=MODEL,
                 nb_inputs=len(inputs))
 
-    # group inputs with same id/operation to avoid adding emissions twice
-    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
-    return flatten(map(_run_input(cycle), inputs.values()))
+    # finally group everything by emission so we can log inputs together
+    # emissions = {'co2ToAirInputsProduct': {'group-id':{'term':{},'value':10,'details':{}}}}
+    emissions = reduce(_group_inputs, inputs.items(), {})
+
+    return flatten([_run_emission(cycle, term_id, data) for term_id, data in emissions.items()])

hestia_earth/models/mocking/search-results.json

@@ -918,11 +918,11 @@
       },
       {
         "@type": "Term",
-        "@id": "residueIncorporated"
+        "@id": "residueIncorporatedMoreThan30DaysBeforeCultivation"
       },
       {
         "@type": "Term",
-        "@id": "residueIncorporatedMoreThan30DaysBeforeCultivation"
+        "@id": "residueIncorporated"
       },
       {
         "@type": "Term",
@@ -1299,7 +1299,7 @@
         "@type": "Term",
         "name": "Generic crop, seed",
         "@id": "genericCropSeed",
-        "_score": 23.9092
+        "_score": 23.910892
       }
     ]
   },
@@ -1405,11 +1405,11 @@
     "results": [
       {
         "@type": "Term",
-        "@id": "waterMarine"
+        "@id": "waterDrainageCanal"
       },
       {
         "@type": "Term",
-        "@id": "waterDrainageCanal"
+        "@id": "waterMarine"
       },
       {
         "@type": "Term",
@@ -1532,45 +1532,6 @@
       }
     ]
   },
-  {
-    "name": "get_long_fallow_land_cover_terms",
-    "query": {
-      "bool": {
-        "must": [
-          {
-            "match": {
-              "@type": "Term"
-            }
-          },
-          {
-            "match": {
-              "termType.keyword": "landCover"
-            }
-          },
-          {
-            "match_phrase_prefix": {
-              "name": "long"
-            }
-          },
-          {
-            "match": {
-              "name": "fallow"
-            }
-          }
-        ]
-      }
-    },
-    "results": [
-      {
-        "@type": "Term",
-        "@id": "longFallow"
-      },
-      {
-        "@type": "Term",
-        "@id": "longBareFallow"
-      }
-    ]
-  },
   {
     "name": "get_milkYield_terms",
     "query": {
@@ -1740,15 +1701,15 @@
       },
       {
         "@type": "Term",
-        "@id": "fullInversionTillage"
+        "@id": "fullTillage"
       },
       {
         "@type": "Term",
-        "@id": "fullTillage"
+        "@id": "minimumTillage"
       },
       {
         "@type": "Term",
-        "@id": "minimumTillage"
+        "@id": "fullInversionTillage"
       },
       {
         "@type": "Term",