hestia-earth-models 0.64.1__py3-none-any.whl → 0.64.2__py3-none-any.whl

hestia_earth/models/cycle/concentrateFeed.py

@@ -15,7 +15,9 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "inputs": [{"@type": "Practice", "value": "", "term.termType": ["crop", "animalProduct"]}],
+        "inputs": [{
+            "@type": "Practice", "value": "", "term.termType": ["crop", "forage", "processedFood", "animalProduct"]
+        }],
         "products": [
             {
                 "@type": "Product",
@@ -34,10 +36,17 @@ RETURNS = {
 }
 LOOKUPS = {
     "crop-property": "crudeProteinContent",
+    "forage-property": "crudeProteinContent",
+    "processedFood-property": "crudeProteinContent",
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
-INPUT_TERM_TYPES = [TermTermType.CROP.value, TermTermType.ANIMALPRODUCT.value]
+INPUT_TERM_TYPES = [
+    TermTermType.CROP.value,
+    TermTermType.FORAGE.value,
+    TermTermType.PROCESSEDFOOD.value,
+    TermTermType.ANIMALPRODUCT.value
+]
 
 
 def _property(term_id: str, value: float):
@@ -60,7 +69,7 @@ def _weighted_value(values: list):
 
 def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str, values: list):
     values = [(prop_value, value) for id, prop_value, value in values if value and prop_value]
-    ratio_inputs_with_props = len(inputs) / len(values) if len(inputs) and len(values) else 0
+    ratio_inputs_with_props = len(values) / len(inputs) if len(inputs) and len(values) else 0
     min_ratio = _min_ratio(property_id)
 
     term_id = product.get('term', {}).get('@id')

hestia_earth/models/ipcc2019/ch4ToAirAquacultureSystems.py

@@ -0,0 +1,96 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, CycleFunctionalUnit
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import safe_parse_float, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.emission import _new_emission
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "",
+        "functionalUnit": "relative",
+        "site": {
+            "@type": "Site",
+            "area": "",
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "salineWater",
+                    "brackishWater",
+                    "freshWater"
+                ]
+            }]
+        }
+    }
+}
+LOOKUPS = {
+    "measurement": "IPCC_2019_CH4_aquaculture_EF"
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+TERM_ID = 'ch4ToAirAquacultureSystems'
+TIER = EmissionMethodTier.TIER_1.value
+_WATER_TERM_IDS = [
+    'salineWater',
+    'brackishWater',
+    'freshWater'
+]
+
+
+def _emission(value: float, min: float, max: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _find_measurement(site: dict):
+    measurements = non_empty_list([
+        find_term_match(site.get('measurements', []), term_id, None) for term_id in _WATER_TERM_IDS
+    ])
+    return measurements[0] if measurements else None
+
+
+def _run(cycle: dict):
+    cycle_duration = cycle.get('cycleDuration')
+    site = cycle.get('site', {})
+    site_area = site.get('area')
+    water_term = _find_measurement(site).get('term', {})
+    factor_value = safe_parse_float(get_lookup_value(water_term, LOOKUPS.get('measurement')))
+    factor_min = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-min"))
+    factor_max = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-max"))
+    ratio = site_area * cycle_duration / 365
+    return [_emission(ratio * factor_value, ratio * factor_min, ratio * factor_max)]
+
+
+def _should_run(cycle: dict):
+    cycle_duration = cycle.get('cycleDuration')
+    is_relative = cycle.get('functionalUnit') == CycleFunctionalUnit.RELATIVE.value
+    site = cycle.get('site', {})
+    site_area = site.get('area')
+    has_water_type = _find_measurement(site) is not None
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    cycle_duration=cycle_duration,
+                    is_relative=is_relative,
+                    site_area=site_area,
+                    has_water_type=has_water_type)
+
+    should_run = all([cycle_duration, is_relative, site_area, has_water_type])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []