hestia-earth-models 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

hestia_earth/models/linkedImpactAssessment/emissions.py

@@ -0,0 +1,168 @@
+"""
+Emissions
+
+A model which takes recalculated data from an Impact Assessment linked to an Input in a Cycle.
+"""
+from functools import reduce
+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, 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
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "impactAssessment": {
+                "@type": "ImpactAssessment",
+                "emissionsResourceUse": [{"@type": "Indicator", "value": ""}]
+            }
+        }],
+        "optional": {
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{
+                    "@type": "Input",
+                    "value": "> 0",
+                    "impactAssessment": {
+                        "@type": "ImpactAssessment",
+                        "emissionsResourceUse": [{"@type": "Indicator", "value": ""}]
+                    }
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": "",
+        "animals": ""
+    }]
+}
+MODEL_KEY = 'emissions'
+MODEL_AGGREGATED = 'hestiaAggregatedData'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+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]
+    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, key=MODEL_KEY,
+                        values=log_as_table([{'impact-assessment-id': key} | value for key, value in details.items()]))
+
+        logShouldRun(cycle, model, term_id, True, methodTier=TIER, key=MODEL_KEY,
+                     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(group: dict, emission: dict):
+        term_id = emission.get('term', {}).get('@id')
+        grouping = _emission_group(term_id)
+        value = emission.get('value') or 0
+        if grouping:
+            group[grouping] = group.get(grouping, 0) + value
+        return group
+
+    emissions = impact.get('emissionsResourceUse', [])
+    return reduce(_group_by, emissions, {})
+
+
+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', [])) +
+        list(map(_animal_inputs, cycle.get('animals', [])))
+    )
+    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, key=MODEL_KEY,
+                nb_inputs=len(inputs))
+
+    # 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/{impact_assessment → linkedImpactAssessment}/utils.py

@@ -9,7 +9,7 @@ from . import MODEL
 
 
 def _indicator(term_id: str, value: float):
-    indicator = _new_indicator(term_id)
+    indicator = _new_indicator(term_id, MODEL)
     indicator['value'] = value
     return indicator