hestia-earth-models 0.70.4__tar.gz → 0.70.6__tar.gz

{hestia_earth_models-0.70.4 → hestia_earth_models-0.70.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.70.4
+Version: 0.70.6
 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.70.4 → hestia_earth_models-0.70.6}/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -118,6 +118,7 @@ def _run_input(cycle: dict):
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        termType_electricityFuel_complete=electricity_complete,
                         input_value=input_value)
 
         should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])

hestia_earth_models-0.70.6/hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -0,0 +1,58 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "co2ToAirFuelCombustionEmepEea2019",
+    "operation": "co2ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'co2ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _should_run(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
+
+    should_run = any([bool(valid_inputs), electricity_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, group_fuel_inputs(valid_inputs)
+
+
+def run(cycle: dict):
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth_models-0.70.6/hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -0,0 +1,58 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "n2OToAirFuelCombustionEmepEea2019",
+    "operation": "n2OToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'n2OToAirFuelCombustionDirect'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _should_run(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
+
+    should_run = any([bool(valid_inputs), electricity_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, group_fuel_inputs(valid_inputs)
+
+
+def run(cycle: dict):
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth_models-0.70.6/hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -0,0 +1,58 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "noxToAirFuelCombustionEmepEea2019",
+    "operation": "noxToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'noxToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _should_run(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
+
+    should_run = any([bool(valid_inputs), electricity_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, group_fuel_inputs(valid_inputs)
+
+
+def run(cycle: dict):
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth_models-0.70.6/hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -0,0 +1,58 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "so2ToAirFuelCombustionEmepEea2019",
+    "operation": "so2ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'so2ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _should_run(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
+
+    should_run = any([bool(valid_inputs), electricity_complete])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, group_fuel_inputs(valid_inputs)
+
+
+def run(cycle: dict):
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth_models-0.70.6/hestia_earth/models/emepEea2019/utils.py

@@ -0,0 +1,142 @@
+from functools import reduce
+from hestia_earth.schema import TermTermType, SiteSiteType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.tools import list_sum, safe_parse_float
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.blank_node import group_by_keys
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.cycle import get_animals_by_period
+from hestia_earth.models.utils.emission import _new_emission
+from . import MODEL
+
+
+def _emission(value: float, tier: str, term_id: str, input: dict = None, operation: dict = None):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = tier
+    if input:
+        emission['inputs'] = [input]
+    if operation:
+        emission['operation'] = operation
+    return emission
+
+
+def _run_inputs(inputs: list, tier: str, term_id: str):
+    total_value = list_sum([
+        (i.get('input-value') or 0) * (i.get('operation-factor') or i.get('input-default-factor') or 0)
+        for i in inputs
+    ])
+    input_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('input-id'),
+        'termType': inputs[0].get('input-termType'),
+        'units': inputs[0].get('input-units'),
+    }
+    operation_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('operation-id'),
+        'termType': inputs[0].get('operation-termType'),
+        'units': inputs[0].get('operation-units'),
+    } if inputs[0].get('operation-id') else None
+    return _emission(
+        value=total_value,
+        tier=tier,
+        term_id=term_id,
+        input=input_term,
+        operation=operation_term
+    )
+
+
+def _fuel_input_data(term_id: str, lookup_col: str, input: dict):
+    input_term = input.get('term', {})
+    input_term_id = input_term.get('@id')
+    operation_term = input.get('operation', {})
+    input_value = list_sum(input.get('value', []), None)
+
+    operation_factor = extract_grouped_data(
+        data=get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id),
+        key=input_term_id
+    ) if operation_term else None
+    input_factor = get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+
+    return {
+        'input-id': input_term_id,
+        'input-termType': input_term.get('termType'),
+        'input-units': input_term.get('units'),
+        'input-value': input_value,
+        'input-default-factor': safe_parse_float(input_factor, default=None),
+        'operation-id': operation_term.get('@id'),
+        'operation-termType': operation_term.get('termType'),
+        'operation-units': operation_term.get('units'),
+        'operation-factor': safe_parse_float(operation_factor, default=None)
+    }
+
+
+def get_fuel_inputs(term_id: str, cycle: dict, lookup_col: str):
+    inputs = [
+        _fuel_input_data(term_id, lookup_col, i)
+        for i in filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
+    ]
+    valid_inputs = [
+        i for i in inputs if all([
+            i.get('input-value') is not None,
+            (i.get('operation-factor') or i.get('input-default-factor')) is not None
+        ])
+    ]
+    return inputs, valid_inputs
+
+
+def group_fuel_inputs(inputs: list):
+    return reduce(group_by_keys(['input-id', 'operation-id']), inputs, {}) if len(inputs) > 0 else None
+
+
+def _get_emissions_factor(animal: dict, lookup_col: str) -> float:
+    return safe_parse_float(
+        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", ""))
+    )
+
+
+def _duration_in_housing(cycle: dict) -> int:
+    other_sites = cycle.get("otherSites", [])
+    other_durations = cycle.get("otherSitesDuration", [])
+    return list_sum([
+        cycle.get("siteDuration", cycle.get("cycleDuration", 0))
+        if cycle.get("site", {}).get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value else 0
+    ] + ([
+        other_durations[x]
+        for x in range(len(other_sites))
+        if other_sites[x].get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value
+    ] if len(other_sites) == len(other_durations) else []))
+
+
+def get_live_animal_emission_value(animals: list[dict], duration: float, lookup_col: str) -> float:
+    return list_sum([
+        animal.get('value') * _get_emissions_factor(animal=animal, lookup_col=lookup_col)
+        for animal in animals
+    ]) * duration / 365
+
+
+def should_run_animal(cycle: dict, model: str, term: str, tier: str) -> tuple[list, bool]:
+    term_type_animalPopulation_complete = _is_term_type_complete(cycle=cycle, term="animalPopulation")
+
+    # models will be set as not relevant is primary `siteType` does not match, so check only `otherSites`.
+
+    total_duration = _duration_in_housing(cycle)
+
+    has_other_sites_and_duration = len(cycle.get("otherSites", [])) == len(cycle.get("otherSitesDuration", []))
+
+    animals = get_animals_by_period(cycle)
+    has_animals = len(animals) > 0
+
+    logRequirements(cycle, model=model, term=term,
+                    term_type_animalPopulation_complete=term_type_animalPopulation_complete,
+                    has_animals=has_animals,
+                    has_other_sites_and_duration=has_other_sites_and_duration,
+                    number_of_days_in_animal_housing=total_duration)
+
+    should_run = all([term_type_animalPopulation_complete, has_animals, has_other_sites_and_duration])
+    logShouldRun(cycle, model, term, should_run, methodTier=tier)
+    return should_run, animals, total_duration

{hestia_earth_models-0.70.4 → hestia_earth_models-0.70.6}/hestia_earth/models/hestia/management.py

@@ -31,6 +31,7 @@ REQUIREMENTS = {
                             "tillage",
                             "cropResidueManagement",
                             "landUseManagement",
+                            "pastureManagement",
                             "system",
                             "landCover"
                         ],
@@ -81,6 +82,7 @@ _PRACTICES_TERM_TYPES = [
     TermTermType.TILLAGE,
     TermTermType.CROPRESIDUEMANAGEMENT,
     TermTermType.LANDUSEMANAGEMENT,
+    TermTermType.PASTUREMANAGEMENT,
     TermTermType.SYSTEM,
     TermTermType.LANDCOVER
 ]
@@ -133,9 +135,9 @@ def management(data: dict):
     return node
 
 
-def _get_cycle_duration(cycle: dict, land_cover_id: str):
+def _get_cycle_duration(cycle: dict, land_cover_id: str = None):
     cycle_duration = cycle.get('cycleDuration')
-    lookup_value = None if cycle_duration else safe_parse_float(get_table_value(
+    lookup_value = None if cycle_duration or not land_cover_id else safe_parse_float(get_table_value(
         download_lookup("crop.csv"),
         column_name('landCoverTermId'),
         land_cover_id,
@@ -155,7 +157,7 @@ def _gap_filled_date_obj(date_str: str, mode: str = DatestrGapfillMode.END) -> d
     )
 
 
-def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> dict:
+def _gap_filled_start_date(cycle: dict, end_date: str, land_cover_id: str = None) -> dict:
     """If possible, gap-fill the startDate based on the endDate - cycleDuration"""
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
@@ -214,9 +216,9 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
         _include_with_date_gap_fill(cycle, ["startDate", "endDate"]) |
         _include(
             _gap_filled_start_date(
-                land_cover_id=get_landCover_term_id(item.get('term', {})),
+                cycle=cycle,
                 end_date=item.get("endDate") if "endDate" in item else cycle.get("endDate", ""),
-                cycle=cycle
+                land_cover_id=get_landCover_term_id(item.get('term', {})),
             ) if "startDate" not in item else {},
             "startDate"
         ) |
@@ -253,12 +255,17 @@ def _run_from_siteType(site: dict, cycle: dict):
     site_type = site.get('siteType')
     site_type_id = get_landCover_term_id_from_site_type(site_type) if site_type not in _SKIP_LAND_COVER_SITE_TYPES \
         else None
+    start_date = cycle.get('startDate') or _gap_filled_start_date(
+        cycle=cycle,
+        end_date=cycle.get('endDate'),
+        land_cover_id=site_type_id
+    ).get('startDate')
 
-    should_run = all([site_type_id])
+    should_run = all([site_type_id, start_date])
     return [{
         'id': site_type_id,
         'value': 100,
-        'startDate': cycle.get('startDate'),
+        'startDate': start_date,
         'endDate': cycle.get('endDate')
     }] if should_run else []