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

hestia_earth/models/ipcc2019/n2OToAirOrganicSoilBurningIndirect.py

@@ -0,0 +1,43 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .n2OToAir_indirect_emissions_utils import run as run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.cropResidue": "True",
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "nh3ToAirOrganicSoilBurning"},
+            {"@type": "Emission", "value": "", "term.@id": "noxToAirOrganicSoilBurning"}
+        ],
+        "optional": {
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            }
+        }
+    }
+}
+LOOKUPS = {
+    "emission": [
+        "IPCC_2019_EF4_FACTORS", "IPCC_2019_EF4_FACTORS-max", "IPCC_2019_EF4_FACTORS-min",
+        "IPCC_2019_EF5_FACTORS", "IPCC_2019_EF5_FACTORS-max", "IPCC_2019_EF5_FACTORS-min"
+    ]
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+TERM_ID = 'n2OToAirOrganicSoilBurningIndirect'
+TIER = EmissionMethodTier.TIER_1.value
+_NO3_TERM_ID = None
+_NH3_TERM_ID = 'nh3ToAirOrganicSoilBurning'
+_NOX_TERM_ID = 'noxToAirOrganicSoilBurning'
+_EMISSION_IDS = [_NH3_TERM_ID, _NO3_TERM_ID, _NOX_TERM_ID]
+
+
+def run(cycle: dict):
+    return run_emission(TERM_ID, _EMISSION_IDS, cycle)

hestia_earth/models/ipcc2019/n2OToAirOrganicSoilCultivationIndirect.py

@@ -0,0 +1,43 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .n2OToAir_indirect_emissions_utils import run as run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.cropResidue": "True",
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "nh3ToAirOrganicSoilCultivation"},
+            {"@type": "Emission", "value": "", "term.@id": "noxToAirOrganicSoilCultivation"}
+        ],
+        "optional": {
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "", "term.@id": "ecoClimateZone"}
+                ]
+            }
+        }
+    }
+}
+LOOKUPS = {
+    "emission": [
+        "IPCC_2019_EF4_FACTORS", "IPCC_2019_EF4_FACTORS-max", "IPCC_2019_EF4_FACTORS-min",
+        "IPCC_2019_EF5_FACTORS", "IPCC_2019_EF5_FACTORS-max", "IPCC_2019_EF5_FACTORS-min"
+    ]
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+TERM_ID = 'n2OToAirOrganicSoilCultivationIndirect'
+TIER = EmissionMethodTier.TIER_1.value
+_NO3_TERM_ID = None
+_NH3_TERM_ID = 'nh3ToAirOrganicSoilCultivation'
+_NOX_TERM_ID = 'noxToAirOrganicSoilCultivation'
+_EMISSION_IDS = [_NH3_TERM_ID, _NO3_TERM_ID, _NOX_TERM_ID]
+
+
+def run(cycle: dict):
+    return run_emission(TERM_ID, _EMISSION_IDS, cycle)

hestia_earth/models/ipcc2019/n2OToAir_indirect_emissions_utils.py

@@ -0,0 +1,112 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.tools import safe_parse_float, non_empty_list, list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import multiply_values
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.emission import _new_emission, get_nh3_no3_nox_to_n
+from hestia_earth.models.utils.cycle import get_ecoClimateZone
+from hestia_earth.models.utils.term import get_lookup_value
+from .utils import _is_wet
+from . import MODEL
+
+_TIER = EmissionMethodTier.TIER_1.value
+_EF_4_FACTOR_NAME = 'IPCC_2019_EF4_FACTORS'
+_EF_5_FACTOR_NAME = 'IPCC_2019_EF5_FACTORS'
+
+
+def _get_emission_factors(log_term: str, emission_id: str, ecoClimateZone: str = None):
+    is_wet = _is_wet(ecoClimateZone)
+    factors_key = 'default' if is_wet is None else 'wet' if is_wet else 'dry'
+
+    emission = {'@id': emission_id, 'termType': TermTermType.EMISSION.value}
+
+    # emission either contains EF4 or EF5
+    ef4_factor = get_lookup_value(emission, _EF_4_FACTOR_NAME, model=MODEL, term=log_term)
+    ef5_factor = get_lookup_value(emission, _EF_5_FACTOR_NAME, model=MODEL, term=log_term) if not ef4_factor else None
+    values = {
+        'ef4-factor': extract_grouped_data(
+            data=ef4_factor,
+            key=factors_key
+        ),
+        'ef4-factor-min': extract_grouped_data(
+            data=get_lookup_value(emission, _EF_4_FACTOR_NAME + '-min', model=MODEL, term=log_term),
+            key=factors_key
+        ),
+        'ef4-factor-max': extract_grouped_data(
+            data=get_lookup_value(emission, _EF_4_FACTOR_NAME + '-max', model=MODEL, term=log_term),
+            key=factors_key
+        ),
+    } if ef4_factor else {
+        'ef5-factor': ef5_factor,
+        'ef5-factor-min': get_lookup_value(emission, _EF_5_FACTOR_NAME + '-min', model=MODEL, term=log_term),
+        'ef5-factor-max': get_lookup_value(emission, _EF_5_FACTOR_NAME + '-max', model=MODEL, term=log_term),
+    } if ef5_factor else {}
+    return {
+        k: safe_parse_float(v, default=None) for k, v in values.items()
+    }
+
+
+def _emission(emission_id: str, value: float, min: float, max: float, aggregated: bool = False):
+    emission = _new_emission(emission_id, MODEL)
+    emission['value'] = [value]
+    if min is not None:
+        emission['min'] = [min]
+    if max is not None:
+        emission['max'] = [max]
+    emission['methodTier'] = _TIER
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodModelDescription'] = 'Aggregated version' if aggregated else 'Disaggregated version'
+    return emission
+
+
+def _calculate_value(values: list, suffix: str = ''):
+    value = list_sum(non_empty_list([
+        multiply_values([
+            value.get('emission-value'),
+            value.get('ef4-factor' + suffix) or value.get('ef5-factor' + suffix)
+        ])
+        for value in values
+    ]), default=None)
+    return value * get_atomic_conversion(Units.KG_N2O, Units.TO_N) if value is not None else None
+
+
+def _run(emission_id: str, values: list, ecoClimateZone: str = None):
+    value = _calculate_value(values)
+    min = _calculate_value(values, suffix='-min')
+    max = _calculate_value(values, suffix='-max')
+    return [_emission(emission_id, value, min, max, aggregated=ecoClimateZone is None)]
+
+
+def _should_run(emission_id: str, emission_ids: list, cycle: dict):
+    ecoClimateZone = get_ecoClimateZone(cycle)
+
+    emission_values = get_nh3_no3_nox_to_n(cycle, *emission_ids)
+    values = [
+        {
+            'emission-id': emission_id,
+            'emission-value': emission_values[index]
+        } | _get_emission_factors(emission_id, emission_id, ecoClimateZone)
+        for index, emission_id in enumerate(emission_ids)
+        if emission_id is not None
+    ]
+
+    logRequirements(cycle, model=MODEL, term=emission_id,
+                    ecoClimateZone=ecoClimateZone,
+                    values=log_as_table(values))
+
+    should_run = all([
+        all([
+            value.get('emission-value') is not None,
+            value.get('ef4-factor') or value.get('ef5-factor') is not None
+        ])
+        for value in values
+    ])
+    logShouldRun(cycle, MODEL, emission_id, should_run, methodTier=_TIER)
+    return should_run, values, ecoClimateZone
+
+
+def run(emission_id: str, emission_ids: list, cycle: dict):
+    should_run, values, ecoClimateZone = _should_run(emission_id, emission_ids, cycle)
+    return _run(emission_id, values, ecoClimateZone) if should_run else []

hestia_earth/models/ipcc2019/utils.py

@@ -120,31 +120,6 @@ N2O_FACTORS = {
         'max': 0.029
     }
 }
-EF4_FACTORS = {
-    'dry': {
-        'value': 0.005,
-        'min': 0,
-        'max': 0.011
-
-    },
-    'wet': {
-        'value': 0.014,
-        'min': 0.011,
-        'max': 0.017
-    },
-    'default': {
-        'value': 0.01,
-        'min': 0.002,
-        'max': 0.018
-    }
-}
-EF5_FACTORS = {
-    'default': {
-        'value': 0.011,
-        'min': 0.0,
-        'max': 0.02
-    }
-}
 
 
 def _get_waterRegime_lookup(model_term_id: str, practice: dict, col: str):

hestia_earth/models/jarvisAndPain1994/n2ToAirExcreta.py

@@ -22,7 +22,7 @@ RETURNS = {
 }
 TERM_ID = 'n2ToAirExcreta'
 TIER = EmissionMethodTier.TIER_1.value
-N2O_TERM_ID = 'n2OToAirExcretaDirect'
+_N2O_TERM_ID = 'n2OToAirExcretaDirect'
 
 
 def _emission(value: float):
@@ -32,21 +32,23 @@ def _emission(value: float):
     return emission
 
 
-def _run(n2o: dict):
-    value = 3 * list_sum(n2o.get("value", [])) / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+def _run(n2o_value: float):
+    value = 3 * n2o_value / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
+    n2o = find_term_match(cycle.get('emissions', []), _N2O_TERM_ID)
+    n2o_value = list_sum(n2o.get("value", []), default=None)
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    **{_N2O_TERM_ID: n2o_value})
 
-    should_run = all([n2o])
+    should_run = all([n2o_value is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, n2o
+    return should_run, n2o_value
 
 
 def run(cycle: dict):
-    should_run, n2o = _should_run(cycle)
-    return _run(n2o) if should_run else []
+    should_run, n2o_value = _should_run(cycle)
+    return _run(n2o_value) if should_run else []

hestia_earth/models/linkedImpactAssessment/emissions.py

@@ -4,6 +4,7 @@ from hestia_earth.utils.lookup import download_lookup, get_table_value, column_n
 from hestia_earth.utils.tools import flatten, list_sum
 
 from hestia_earth.models.log import logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils import _include
 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
@@ -49,18 +50,17 @@ LOOKUPS = {
 MODEL_KEY = 'emissions'
 MODEL_AGGREGATED = 'hestiaAggregatedData'
 TIER = EmissionMethodTier.BACKGROUND.value
+_GROUP_BY_KEYS = ['term', 'key', 'operation', 'animal']
 
 
-def _emission(model: str, term_id: str, value: float, input: dict, operation={}, animal={}):
+def _emission(model: str, term_id: str, value: float, input: dict, animal={}, extra={}):
     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
+    return emission | extra
 
 
 def _run_emission(cycle: dict, emission_term_id: str, data: dict):
@@ -68,6 +68,7 @@ def _run_emission(cycle: dict, emission_term_id: str, data: dict):
         value = values.get('value', 0)
         input_term = values.get('term', {})
         input_term_id = input_term.get('@id')
+        key = values.get('key', {})
         operation = values.get('operation', {})
         animal = values.get('animal', {})
         is_aggregated = any(values.get('aggregated', []))
@@ -83,10 +84,18 @@ def _run_emission(cycle: dict, emission_term_id: str, data: dict):
                     coefficient=1,
                     details=log_as_table([{'impact-assessment-id': key} | value for key, value in details.items()]),
                     input=input_term_id,
+                    key=key.get('@id'),
                     operation=operation.get('@id'),
                     animal=animal.get('@id'))
 
-        return _emission(model, emission_term_id, value, input=input_term, operation=operation, animal=animal)
+        return _emission(
+            model=model,
+            term_id=emission_term_id,
+            value=value,
+            input=input_term,
+            animal=animal,
+            extra=_include(values, ['key', 'operation'])
+        )
 
     return list(map(run_input, data.values()))
 
@@ -130,14 +139,14 @@ def _group_inputs(group: dict, values: tuple):
         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 = (
+                group[emission_term_id].get(input_group_key) or
+                _include(input, _GROUP_BY_KEYS) | {
+                    '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
@@ -156,9 +165,9 @@ 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
+    # group inputs with same term/key/operation/animal to avoid adding emissions twice
     # inputs = {'group-id': [{'term': {},'value':[10],'impactAssessment': {}}]}
-    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    inputs = reduce(group_by_keys(_GROUP_BY_KEYS), inputs, {})
     inputs = {key: list(map(_group_input_emissions, value)) for key, value in inputs.items()}
 
     # finally group everything by emission so we can log inputs together

hestia_earth/models/linkedImpactAssessment/utils.py

@@ -42,13 +42,16 @@ def _run_indicators(impact_assessment: dict, product: dict, term_id: str, model:
 def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str, model: str):
     cycle = impact_assessment.get('cycle', {})
 
+    inputs = load_impacts(cycle.get('inputs', []))
+    inputs_with_impact = [i for i in inputs if i.get('impactAssessment')]
+
     # group all indicators per `landCover` and `previousLandCover`
     all_indicators = flatten([
         {
             'indicator': indicator,
             'input': input
         }
-        for input in load_impacts(cycle.get('inputs', []))
+        for input in inputs
         for indicator in (
             input.get('impactAssessment', {}).get('emissionsResourceUse', []) +
             input.get('impactAssessment', {}).get('impacts', [])
@@ -72,6 +75,7 @@ def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str,
     has_indicators = bool(valid_indicators)
 
     logRequirements(impact_assessment, model=model, term=term_id,
+                    inputs_with_linked_impact_assessment=len(inputs_with_impact),
                     indicators=log_as_table([
                         {
                             'indicator-id': value.get('indicator').get('term', {}).get('@id'),