hestia-earth-models 0.64.3__py3-none-any.whl → 0.64.5__py3-none-any.whl

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -0,0 +1,128 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.tools import list_sum, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import hectar_to_square_meter, days_to_years
+from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_type
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.landCover import get_pef_grouping
+from hestia_earth.models.utils.lookup import fallback_country
+from . import MODEL
+from .utils import get_coefficient_factor
+
+REQUIREMENTS = {
+    "Cycle": {
+        "siteDuration": "> 0",
+        "siteArea": "> 0",
+        "site": {"siteType": "",
+                 "@type": "Site",
+                 "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
+                 "country": {"@type": "Term", "termType": "region"}
+                 },
+        "optional": {
+            "otherSitesDuration": "> 0",
+            "otherSitesArea": "> 0",
+            "otherSites": [
+                {
+                    "siteType": "",
+                    "@type": "Site",
+                    "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
+                    "country": {"@type": "Term", "termType": "region"}
+                }
+            ]
+        }
+    }
+}
+LOOKUPS = {
+    "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
+    "region-pefTermGrouping-landOccupation": "",
+    "landCover": [
+        "pefTermGrouping"
+    ]
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'soilQualityIndexLandOccupation'
+LOOKUP = f"{list(LOOKUPS.keys())[1]}.csv"
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(sites: list):
+    values = [site['coeff'] * hectar_to_square_meter(site['area']) * days_to_years(site['duration']) for site in sites]
+    return _indicator(list_sum(values)) if values else None
+
+
+def _should_run(cycle: dict):
+    end_date = cycle.get('endDate')
+
+    has_site = bool(cycle.get('site', False))
+    has_other_sites = bool(cycle.get('otherSites', []))
+
+    all_sites = non_empty_list([cycle.get('site')] + cycle.get('otherSites', []))
+    site_areas = [cycle.get('siteArea')] + cycle.get('otherSitesArea', [])
+    site_durations = [cycle.get('siteDuration')] + cycle.get('otherSitesDuration', [])
+
+    sites = [
+        {
+            'site-type': site.get('siteType'),
+            'country-id': site.get('country', {}).get('@id'),
+            'area': site_areas[index],
+            'duration': site_durations[index],
+            'landCover-id': (most_relevant_blank_node_by_type(
+                site.get("management", []),
+                term_type=TermTermType.LANDCOVER.value,
+                date=end_date
+            ) or {}).get('term', {}).get('@id'),
+        }
+        for index, site in enumerate(all_sites)
+    ]
+
+    sites = [
+        site for site in sites
+        if all([
+            site.get('area', 0) > 0,
+            site.get('duration', 0) > 0,
+            site.get('landCover-id'),
+        ])
+    ]
+
+    sites = [
+        site |
+        {
+            'coeff': get_coefficient_factor(
+                LOOKUP,
+                fallback_country(site.get('country-id'), [download_lookup(LOOKUP)]),
+                get_pef_grouping(site.get('landCover-id')),
+                term_id=TERM_ID
+            )
+        } for site in sites
+    ]
+    valid_sites = [site for site in sites if site.get('coeff') is not None]
+
+    has_valid_sites = bool(valid_sites)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    has_valid_sites=has_valid_sites,
+                    has_site=has_site,
+                    has_other_sites=has_other_sites,
+                    valid_sites=log_as_table(valid_sites),
+                    )
+
+    should_run = all([has_valid_sites])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, valid_sites
+
+
+def run(cycle: dict):
+    should_run, sites = _should_run(cycle)
+    return _run(sites) if should_run else None

hestia_earth/models/environmentalFootprintV3/utils.py

@@ -0,0 +1,17 @@
+from typing import Optional
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.lookup import get_table_value, column_name
+
+from hestia_earth.models.log import debugMissingLookup
+from . import MODEL
+
+
+def get_coefficient_factor(lookup_name: str, country_id: str, occupation_type: Optional[str], term_id: str):
+    """
+    Gets the EU PEF Characteristic factor for a given eu site type and country
+    """
+    coefficient = get_table_value(download_lookup(lookup_name), 'termid', country_id, column_name(occupation_type))
+    debugMissingLookup(
+        lookup_name, 'termid', country_id, column_name(occupation_type), coefficient, model=MODEL, term=term_id
+    )
+    return coefficient

hestia_earth/models/fantkeEtAl2016/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'fantkeEtAl2016'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/fantkeEtAl2016/damageToHumanHealthParticulateMatterFormation.py

@@ -0,0 +1,49 @@
+from hestia_earth.utils.lookup import column_name
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.impact_assessment import impact_lookup_value
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator", "value": "", "term.termType": "emission"
+            }
+        ]
+    }
+}
+
+TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
+
+LOOKUPS = {
+    "emission": "damageToHumanHealthParticulateMatterFormationFantkeEtAl2016"
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+default_group_key = 'default'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_lookup_value(model=MODEL, term_id=TERM_ID, impact=impact_assessment,
+                                lookup_col=column_name(LOOKUPS['emission']),
+                                grouped_key=default_group_key)
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+
+    should_run = all([value is not None])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return _indicator(value) if should_run else None

hestia_earth/models/frischknechtEtAl2000/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'frischknechtEtAl2000'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -0,0 +1,90 @@
+from functools import reduce
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.tools import list_sum, flatten, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.emission import filter_emission_inputs
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.lookup import factor_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": "",
+            "term.@id": [
+                "ionisingCompoundsToAirInputsProduction",
+                "ionisingCompoundsToWaterInputsProduction",
+                "ionisingCompoundsToSaltwaterInputsProduction"
+            ],
+            "inputs": [{"@type": "Input", "term.termType": "waste"}]
+        }]
+    }
+}
+LOOKUPS = {
+    "waste": [
+        "ionisingCompoundsToAirInputsProduction",
+        "ionisingCompoundsToWaterInputsProduction",
+        "ionisingCompoundsToSaltwaterInputsProduction"
+    ]
+}
+RETURNS = {
+    "Indicator": {
+        "value": "",
+        "inputs": ""
+    }
+}
+
+TERM_ID = 'ionisingRadiationKbqU235Eq'
+
+
+def _indicator(value: float, input: dict):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    indicator['inputs'] = [input]
+    return indicator
+
+
+def _run(grouped_emissions_inputs: list):
+    input = grouped_emissions_inputs[0].get('input')
+    values = [
+        factor_value(
+            model=MODEL,
+            term_id=TERM_ID,
+            lookup_name=f"{TermTermType.WASTE.value}.csv",
+            lookup_col=i.get('emission').get('term', {}).get('@id')
+        )(data=i.get('emission') | {'term': i.get('input')})
+        for i in grouped_emissions_inputs
+    ]
+    value = list_sum(values)
+    return _indicator(value, input) if value else None
+
+
+def _should_run(impact_assessment: dict):
+    emissions = flatten([
+        ([
+            {'emission': emission, 'input': input}
+            for input in filter_emission_inputs(emission, TermTermType.WASTE)
+        ])
+        for emission in impact_assessment.get('emissionsResourceUse', [])
+        if emission.get('term', {}).get('@id') in LOOKUPS[TermTermType.WASTE.value]
+    ])
+    emissions_per_input = reduce(
+        lambda p, c: p | {c.get('input').get('@id'): p.get(c.get('input').get('@id'), []) + [c]},
+        emissions,
+        {}
+    )
+
+    logRequirements(impact_assessment, model=MODEL,
+                    has_emissions=bool(emissions_per_input))
+
+    should_run = all([emissions_per_input])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, emissions_per_input
+
+
+def run(impact_assessment: dict):
+    should_run, emissions_per_input = _should_run(impact_assessment)
+    return non_empty_list(map(_run, emissions_per_input.values())) if should_run else []

hestia_earth/models/ipcc2006/co2ToAirOrganicSoilCultivation.py

@@ -10,12 +10,23 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "primary": "True",
-            "value": "> 0",
-            "economicValueShare": "> 0"
-        }],
+        "or": [
+            {
+                "cycleDuration": "",
+                "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
+            },
+            {
+                "@doc": "for plantations, additional properties are required",
+                "practices": [
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDuration"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationProductiveLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "rotationDuration"}
+                ]
+            }
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/ipcc2006/n2OToAirOrganicSoilCultivationDirect.py

@@ -10,12 +10,23 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "primary": "True",
-            "value": "> 0",
-            "economicValueShare": "> 0"
-        }],
+        "or": [
+            {
+                "cycleDuration": "",
+                "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
+            },
+            {
+                "@doc": "for plantations, additional properties are required",
+                "practices": [
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "nurseryDuration"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationProductiveLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationDensity"},
+                    {"@type": "Practice", "value": "", "term.@id": "plantationLifespan"},
+                    {"@type": "Practice", "value": "", "term.@id": "rotationDuration"}
+                ]
+            }
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/ipcc2019/animal/liveweightGain.py

@@ -65,10 +65,11 @@ def _should_run(cycle: dict):
     } for animal in live_animals]
 
     def _should_run_animal(value: dict):
+        animal = value.get('animal')
         lookup_value = value.get('value')
-        term_id = value.get('animal').get('term').get('@id')
+        term_id = animal.get('term').get('@id')
 
-        logRequirements(cycle, model=MODEL, term=term_id,
+        logRequirements(cycle, model=MODEL, term=term_id, property=TERM_ID,
                         country_id=country_id,
                         liveweightGain=lookup_value)
 
@@ -76,7 +77,7 @@ def _should_run(cycle: dict):
             country_id,
             lookup_value is not None
         ])
-        logShouldRun(cycle, MODEL, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, property=TERM_ID)
 
         return should_run
 

hestia_earth/models/ipcc2019/animal/liveweightPerHead.py

@@ -65,10 +65,11 @@ def _should_run(cycle: dict):
     } for animal in live_animals]
 
     def _should_run_animal(value: dict):
+        animal = value.get('animal')
         lookup_value = value.get('value')
-        term_id = value.get('animal').get('term').get('@id')
+        term_id = animal.get('term').get('@id')
 
-        logRequirements(cycle, model=MODEL, term=term_id,
+        logRequirements(cycle, model=MODEL, term=term_id, property=TERM_ID,
                         country_id=country_id,
                         liveweightPerHead=lookup_value)
 
@@ -76,7 +77,7 @@ def _should_run(cycle: dict):
             country_id,
             lookup_value is not None
         ])
-        logShouldRun(cycle, MODEL, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, property=TERM_ID)
 
         return should_run
 

hestia_earth/models/ipcc2019/animal/weightAtMaturity.py

@@ -76,12 +76,13 @@ def _should_run(cycle: dict):
     } for animal in live_animals]
 
     def _should_run_animal(value: dict):
+        animal = value.get('animal')
         lookup_value = value.get('value')
-        term_id = value.get('animal').get('term').get('@id')
-        liveweightPerHead = find_term_match(value.get('animal').get('properties', []), 'liveweightPerHead', {})
+        term_id = animal.get('term').get('@id')
+        liveweightPerHead = find_term_match(animal.get('properties', []), 'liveweightPerHead', {})
         liveweightPerHead_value = liveweightPerHead.get('value')
 
-        logRequirements(cycle, model=MODEL, term=term_id,
+        logRequirements(cycle, model=MODEL, term=term_id, property=TERM_ID,
                         country_id=country_id,
                         weightAtMaturity=lookup_value,
                         liveweightPerHead=liveweightPerHead_value)
@@ -91,7 +92,7 @@ def _should_run(cycle: dict):
             lookup_value is not None,
             lookup_value is None or liveweightPerHead_value is None or lookup_value >= liveweightPerHead_value
         ])
-        logShouldRun(cycle, MODEL, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, property=TERM_ID)
 
         return should_run