hestia-earth-models 0.61.6__py3-none-any.whl → 0.61.8__py3-none-any.whl

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/cycle/input/hestiaAggregatedData.py

@@ -10,7 +10,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import find_primary_product, find_term_match, linked_node
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
-from hestia_earth.models.utils.cycle import valid_site_type
+from hestia_earth.models.utils.crop import valid_site_type
 from hestia_earth.models.utils.term import get_generic_crop
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date

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/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/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/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/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/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/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))