hestia-earth-models 0.74.2__py3-none-any.whl → 0.74.4__py3-none-any.whl

hestia_earth/models/config/Cycle.json

@@ -246,6 +246,14 @@
       "mergeStrategy": "list",
       "stage": 1
     },
+    {
+      "key": "products",
+      "model": "cycle",
+      "value": "aboveGroundCropResidueTotal",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     [
       {
         "key": "practices",
@@ -1763,6 +1771,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "nh3ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "emepEea2019",

hestia_earth/models/config/ImpactAssessment.json

@@ -67,18 +67,29 @@
       },
       "stage": 1
     },
-    [
-      {
-        "key": "emissionsResourceUse",
-        "model": "pooreNemecek2018",
-        "value": "landOccupationDuringCycle",
-        "runStrategy": "always",
-        "mergeStrategy": "list",
-        "mergeArgs": {
-          "replaceThreshold": ["value", 0.01]
-        },
-        "stage": 1
+    {
+      "key": "emissionsResourceUse",
+      "model": "hestia",
+      "value": "landOccupationDuringCycle",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 1
+    },
+    {
+      "key": "emissionsResourceUse",
+      "model": "pooreNemecek2018",
+      "value": "landOccupationDuringCycle",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
       },
+      "stage": 1
+    },
+    [
       {
         "key": "emissionsResourceUse",
         "model": "linkedImpactAssessment",

hestia_earth/models/cycle/aboveGroundCropResidueTotal.py

@@ -0,0 +1,50 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.completeness import _is_term_type_incomplete
+from hestia_earth.models.utils.product import _new_product
+from hestia_earth.models.utils.cropResidue import sum_above_ground_crop_residue
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.cropResidue": "False",
+        "products": [{
+            "@type": "Product",
+            "value": "> 0",
+            "term.@id": [
+                "aboveGroundCropResidueRemoved",
+                "aboveGroundCropResidueIncorporated",
+                "aboveGroundCropResidueBurnt",
+                "aboveGroundCropResidueLeftOnField"
+            ]
+        }]
+    }
+}
+RETURNS = {
+    "Product": [{
+        "value": ""
+    }]
+}
+TERM_ID = 'aboveGroundCropResidueTotal'
+
+
+def _product(value: float):
+    product = _new_product(TERM_ID, value)
+    return product
+
+
+def _should_run(cycle: dict):
+    term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
+    value = sum_above_ground_crop_residue(cycle)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    sum_above_ground_crop_residue=value)
+
+    should_run = all([term_type_incomplete, value > 0])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, value
+
+
+def run(cycle: dict):
+    should_run, value = _should_run(cycle)
+    return [_product(value)] if should_run else []

hestia_earth/models/cycle/completeness/freshForage.py

@@ -15,10 +15,10 @@ REQUIREMENTS = {
             "siteType": "permanent pasture"
         },
         "or": {
-            "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}],
+            "inputs": [{"@type": "Input", "termType": "forage", "value": ">= 0", "added": ["value"]}],
             "animals": [{
                 "@type": "Animal",
-                "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}]
+                "inputs": [{"@type": "Input", "termType": "forage", "value": ">= 0", "added": ["value"]}]
             }]
         }
     }

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -1,9 +1,6 @@
 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
+from .fuelCombustion_utils import run as run_fuelCombustion
 
 REQUIREMENTS = {
     "Cycle": {
@@ -33,26 +30,4 @@ 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 []
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/fuelCombustion_utils.py

@@ -0,0 +1,107 @@
+from hestia_earth.schema import EmissionMethodTier, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.blank_node import group_by_keys
+from hestia_earth.utils.tools import list_sum, safe_parse_float
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.term import get_lookup_value
+from .utils import _emission
+from . import MODEL
+
+_TIER = EmissionMethodTier.TIER_1.value
+
+
+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 group_by_keys(inputs, ['input-id', 'operation-id']) if len(inputs) > 0 else None
+
+
+def _should_run(cycle: dict, term_id: str, lookup_prefix: str = None):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(term_id, cycle, f"{lookup_prefix or term_id}EmepEea2019")
+
+    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, term_id: str, lookup_prefix: str = None):
+    should_run, fuel_inputs = _should_run(cycle, term_id, lookup_prefix)
+    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/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -1,9 +1,6 @@
 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
+from .fuelCombustion_utils import run as run_fuelCombustion
 
 REQUIREMENTS = {
     "Cycle": {
@@ -33,26 +30,4 @@ 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 []
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID, lookup_prefix='n2oToAirFuelCombustion')

hestia_earth/models/emepEea2019/nh3ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+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": "nh3ToAirFuelCombustionEmepEea2019",
+    "operation": "nh3ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'nh3ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -1,9 +1,6 @@
 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
+from .fuelCombustion_utils import run as run_fuelCombustion
 
 REQUIREMENTS = {
     "Cycle": {
@@ -33,26 +30,4 @@ 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 []
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -1,9 +1,6 @@
 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
+from .fuelCombustion_utils import run as run_fuelCombustion
 
 REQUIREMENTS = {
     "Cycle": {
@@ -33,26 +30,4 @@ 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 []
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/utils.py

@@ -1,7 +1,4 @@
-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.blank_node import group_by_keys
+from hestia_earth.schema import SiteSiteType
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
@@ -23,75 +20,6 @@ def _emission(value: float, tier: str, term_id: str, input: dict = None, operati
     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 group_by_keys(inputs, ['input-id', 'operation-id']) 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", "")),