hestia-earth-models 0.61.7__tar.gz → 0.61.8__tar.gz

{hestia-earth-models-0.61.7/hestia_earth_models.egg-info → hestia-earth-models-0.61.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.7
+Version: 0.61.8
 Summary: Hestia's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: Hestia Team

hestia-earth-models-0.61.8/hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -0,0 +1,56 @@
+"""
+Completeness Electricity Fuel
+
+This model checks if we have the requirements below and updates the
+[Data Completeness](https://hestia.earth/schema/Completeness#electricityFuel) value.
+"""
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.log import logRequirements, log_as_table
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.electricityFuel": "False",
+        "practices": [
+            {"@type": "Practice", "value": "", "term.termType": "operation"}
+        ]
+    }
+}
+RETURNS = {
+    "Completeness": {
+        "electricityFuel": ""
+    }
+}
+LOOKUPS = {
+    "operation": ["fuelUse", "combustionType"]
+}
+MODEL_KEY = 'electricityFuel'
+_VALID_COMBUSTION_TYPES = ['mobile', 'stationary']
+
+
+def _lookup_value(practice: dict, lookup_name: str):
+    return get_lookup_value(practice.get('term', {}), lookup_name, model=MODEL, model_key=MODEL_KEY)
+
+
+def _practice_value(practice: dict):
+    term = practice.get('term', {})
+    fuel_use = _lookup_value(practice, LOOKUPS['operation'][0])
+    return {'id': term.get('@id'), 'fuel_use': fuel_use}
+
+
+def run(cycle: dict):
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.OPERATION)
+    combustion_practices = [
+        p for p in practices if _lookup_value(p, LOOKUPS['operation'][1]) in _VALID_COMBUSTION_TYPES
+    ]
+    practices_values = list(map(_practice_value, combustion_practices))
+
+    logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    values=log_as_table(practices_values))
+
+    is_complete = all([p.get('fuel_use') for p in practices_values])
+
+    return is_complete

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -1,14 +1,13 @@
 from functools import reduce
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.lookup import download_lookup
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, non_empty_list
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.inorganicFertiliser import (
-    get_NH3_emission_factor, get_terms, get_term_lookup, BREAKDOWN_LOOKUP, get_country_breakdown, get_cycle_inputs
+    get_NH3_emission_factor, get_terms, get_term_lookup, get_country_breakdown, get_cycle_inputs
 )
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.emission import _new_emission
@@ -66,23 +65,21 @@ def _emission(value: float):
     return emission
 
 
-def _get_input_value(cycle: dict, soilPh: float, temperature: float):
+def _input_with_factor(soilPh: float, temperature: float):
     def get_value(input: dict):
         term_id = input.get('term', {}).get('@id')
-        factor = get_NH3_emission_factor(term_id, soilPh, temperature)
-        value = list_sum(input.get('value'))
-        debugValues(cycle, model=MODEL, term=TERM_ID,
-                    product=term_id,
-                    factor=factor,
-                    value=value)
-        return value * factor
+        factor = get_NH3_emission_factor(term_id, soilPh, temperature) if all([
+            soilPh is not None,
+            temperature is not None
+        ]) else None
+        value = list_sum(input.get('value'), None)
+        return {'id': term_id, 'value': value, 'factor': factor} if all([
+            value is not None,
+            factor is not None
+        ]) else None
     return get_value
 
 
-def _run(cycle: dict, temperature: float, soilPh: float, inputs: float):
-    return list_sum(list(map(_get_input_value(cycle, soilPh, temperature), inputs)))
-
-
 def _get_groupings():
     term_ids = get_terms()
 
@@ -93,23 +90,22 @@ def _get_groupings():
     return reduce(get_grouping, term_ids, {})
 
 
-def _get_term_value(cycle: dict, soilPh: float, temperature: float, country_id: str, grouping: str, term_id: str):
-    factor = get_NH3_emission_factor(term_id, soilPh, temperature)
-    value = get_country_breakdown(MODEL, TERM_ID, country_id, grouping)
-    debugValues(cycle, model=MODEL, term=TERM_ID,
-                grouping=grouping,
-                NH3_factor=factor,
-                country_breakdown=value)
-    return value * factor
-
-
-def _run_with_unspecified(cycle: dict, temperature: float, soilPh: float, unspecifiedKgN_value: float, country_id: str):
+def _unspecified_inputs_with_factor(temperature: float, soilPh: float, unspecifiedKgN_value: float, site: dict):
+    country_id = site.get('country', {}).get('@id')
     # creates a dictionary grouping => term_id with only a single key per group (avoid counting twice)
     groupings = _get_groupings()
-    return list_sum([
-        _get_term_value(cycle, soilPh, temperature, country_id, grouping, term_id)
-        for grouping, term_id in groupings.items()
-    ]) * unspecifiedKgN_value
+    breakdown_inputs = [(
+        term_id, get_country_breakdown(MODEL, TERM_ID, country_id, grouping)
+    ) for grouping, term_id in groupings.items()] if all([country_id, unspecifiedKgN_value is not None]) else []
+    # create inputs from country breakdown
+    N_inputs = [
+        {
+            'term': {'@id': term_id},
+            'value': [value * unspecifiedKgN_value]
+        }
+        for term_id, value in breakdown_inputs if value is not None
+    ]
+    return non_empty_list(map(_input_with_factor(soilPh, temperature), N_inputs))
 
 
 def _should_run(cycle: dict):
@@ -121,49 +117,38 @@ def _should_run(cycle: dict):
         measurements, 'temperatureAnnual', end_date) or most_relevant_measurement_value(
         measurements, 'temperatureLongTermAnnualMean', end_date)
 
-    inputs = get_cycle_inputs(cycle)
-    N_inputs = _filter_list_term_unit(inputs, Units.KG_N)
+    N_inputs = _filter_list_term_unit(get_cycle_inputs(cycle), Units.KG_N)
     has_N_inputs = len(N_inputs) > 0
 
-    unspecifiedKgN = find_term_match(cycle.get('inputs', []), UNSPECIFIED_TERM_ID).get('value', [])
-    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
-    has_unspecifiedKgN = len(unspecifiedKgN) > 0 or fertiliser_complete
+    N_inputs_with_factor = non_empty_list(map(_input_with_factor(soilPh, temperature), N_inputs))
+    has_N_inputs_with_factor = len(N_inputs_with_factor) > 0
 
-    country_id = site.get('country', {}).get('@id')
-    lookup = download_lookup(BREAKDOWN_LOOKUP)
-    has_country_data = country_id in list(lookup.termid)
+    # fallback using country averages of fertilisers usage
+    unspecifiedKgN_value = list_sum(find_term_match(N_inputs, UNSPECIFIED_TERM_ID).get('value'), None)
+    unspecified_inputs_with_factor = _unspecified_inputs_with_factor(temperature, soilPh, unspecifiedKgN_value, site)
+    has_unspecified_inputs_with_factor = len(unspecified_inputs_with_factor) > 0
 
-    run_with_unspecified = (has_country_data and has_unspecifiedKgN) or fertiliser_complete
-    unspecifiedKgN = (
-        0 if len(unspecifiedKgN) == 0 and fertiliser_complete else list_sum(unspecifiedKgN, None)
-    ) if run_with_unspecified else None
+    fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_fertiliser_complete=fertiliser_complete,
                     temperature=temperature,
                     soilPh=soilPh,
-                    term_type_fertiliser_complete=fertiliser_complete,
-                    has_unspecifiedKgN=has_unspecifiedKgN,
-                    has_country_data=has_country_data,
-                    run_with_unspecified=run_with_unspecified,
-                    has_N_inputs=has_N_inputs)
+                    has_N_inputs=has_N_inputs,
+                    inorganic_fertiliser_inputs=log_as_table(N_inputs_with_factor),
+                    unspecified_fertiliser_inputs=log_as_table(unspecified_inputs_with_factor))
 
     should_run = all([
+        fertiliser_complete,
         temperature,
         soilPh,
-        any([
-            run_with_unspecified,
-            has_N_inputs,
-            not has_N_inputs and fertiliser_complete
-        ])
+        not has_N_inputs or has_N_inputs_with_factor or has_unspecified_inputs_with_factor
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, temperature, soilPh, N_inputs, unspecifiedKgN, country_id
+    return should_run, N_inputs_with_factor or unspecified_inputs_with_factor
 
 
 def run(cycle: dict):
-    should_run, temperature, soilPh, N_inputs, unspecifiedKgN, country_id = _should_run(cycle)
-    value = _run(cycle, temperature, soilPh, N_inputs) or (
-        _run_with_unspecified(cycle, temperature, soilPh, unspecifiedKgN, country_id)
-        if unspecifiedKgN is not None else None
-    ) if should_run else None
+    should_run, N_inputs_with_factor = _should_run(cycle)
+    value = list_sum([i.get('value') * i.get('factor') for i in N_inputs_with_factor]) if should_run else None
     return [_emission(value)] if value is not None else []

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/geospatialDatabase/histosol.py

@@ -21,6 +21,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Measurement": [{
         "value": "",
+        "depthUpper": "0",
+        "depthLower": "30",
         "methodClassification": "geospatial dataset"
     }]
 }
@@ -36,6 +38,8 @@ BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture
 def _measurement(site: dict, value: float):
     measurement = _new_measurement(TERM_ID)
     measurement['value'] = [round(value, 7)]
+    measurement['depthUpper'] = 0
+    measurement['depthLower'] = 30
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/ipcc2006/co2ToAirOrganicSoilCultivation.py

@@ -1,6 +1,7 @@
 from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
 from hestia_earth.models.utils.ecoClimateZone import get_ecoClimateZone_lookup_value
@@ -39,7 +40,6 @@ RETURNS = {
 }
 TERM_ID = 'co2ToAirOrganicSoilCultivation'
 TIER = EmissionMethodTier.TIER_1.value
-CONVERT_FACTOR = 44 / 120
 
 
 def _emission(value: float):
@@ -55,7 +55,9 @@ def _run(histosol: float, organic_soil_factor: float, land_occupation: float):
 
 
 def _get_CO2_factor(eco_climate_zone: str, site_type: str):
-    return get_ecoClimateZone_lookup_value(eco_climate_zone, LOOKUPS['ecoClimateZone'], site_type) * CONVERT_FACTOR
+    return get_ecoClimateZone_lookup_value(
+        eco_climate_zone, LOOKUPS['ecoClimateZone'], site_type
+    ) * 1000 * get_atomic_conversion(Units.KG_CO2, Units.TO_C)
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/ipcc2006/n2OToAirOrganicSoilCultivationDirect.py

@@ -57,7 +57,7 @@ def _run(histosol: float, organic_soil_factor: float, land_occupation: float):
 def _get_N2O_factor(eco_climate_zone: str):
     return get_ecoClimateZone_lookup_value(
         eco_climate_zone, LOOKUPS['ecoClimateZone']
-    ) * get_atomic_conversion(Units.KG_N2O, Units.TO_N) / 10000
+    ) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/ipcc2019/aboveGroundCropResidueTotal.py

@@ -75,7 +75,7 @@ def _should_run(cycle: dict):
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_forage_products=has_crop_forage_products,
+                    has_crop_forage_products_with_dryMatter=has_crop_forage_products,
                     term_type_cropResidue_incomplete=term_type_incomplete)
 
     should_run = all([term_type_incomplete, has_crop_forage_products])

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/ipcc2019/belowGroundCropResidue.py

@@ -82,7 +82,7 @@ def _should_run(cycle: dict):
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_forage_products=has_crop_forage_products,
+                    has_crop_forage_products_with_dryMatter=has_crop_forage_products,
                     term_type_cropResidue_incomplete=term_type_incomplete)
 
     should_run = all([term_type_incomplete, has_crop_forage_products])

{hestia-earth-models-0.61.7 → hestia-earth-models-0.61.8}/hestia_earth/models/ipcc2019/ch4ToAirExcreta.py

@@ -95,7 +95,7 @@ def _get_excreta_b0(country: dict, input: dict):
     )
 
 
-def _get_excretaManagement_MCF_from_lookup(term_id: str, ecoClimateZone: int, duration_key: DURATION_KEY):
+def _get_excretaManagement_MCF_from_lookup(term_id: str, ecoClimateZone: int, duration_key: DURATION):
     lookup_name = 'excretaManagement-ecoClimateZone-CH4conv.csv'
     lookup = download_lookup(lookup_name)
     data_values = get_table_value(lookup, 'termid', term_id, str(ecoClimateZone))