hestia-earth-models 0.61.1__tar.gz → 0.61.3__tar.gz

{hestia-earth-models-0.61.1/hestia_earth_models.egg-info → hestia-earth-models-0.61.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.1
+Version: 0.61.3
 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.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/cycle/startDateDefinition.py

@@ -42,7 +42,6 @@ def _run(cycle: dict):
     product = find_primary_product(cycle)
     grouping = get_crop_grouping_fao(MODEL, MODEL_KEY, product.get('term', {}))
     is_permanent_crop = grouping == 'Permanent crops'
-    print(is_permanent_crop)
     return (
         CycleStartDateDefinition.START_OF_YEAR.value if _is_last_day_of_month(cycle.get('endDate'))
         else CycleStartDateDefinition.ONE_YEAR_PRIOR.value

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ecoinventV3/__init__.py

@@ -23,7 +23,8 @@ from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import group_by_keys
-from hestia_earth.models.utils.pesticideAI import get_from_inputs as get_pesticides
+from hestia_earth.models.utils.pesticideAI import get_pesticides_from_inputs
+from hestia_earth.models.utils.fertiliser import get_fertilisers_from_inputs
 
 REQUIREMENTS = {
     "Cycle": {
@@ -152,7 +153,10 @@ def _animal_inputs(animal: dict):
 def run(_, cycle: dict):
     # add all the properties of some Term that inlcude others with the mapping
     inputs = flatten(
-        cycle.get('inputs', []) + list(map(_animal_inputs, cycle.get('animals', []))) + get_pesticides(cycle)
+        cycle.get('inputs', []) +
+        list(map(_animal_inputs, cycle.get('animals', []))) +
+        get_pesticides_from_inputs(cycle) +
+        get_fertilisers_from_inputs(cycle)
     )
     inputs = list(filter(_should_run_input(cycle.get('products', [])), inputs))
     # group inputs with same id/operation to avoid adding emissions twice

hestia-earth-models-0.61.3/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -0,0 +1,125 @@
+"""
+ecoinvent v3 and Ember Climate
+
+All emissions to air for the cycle.
+"""
+from functools import reduce
+from typing import Tuple
+
+from hestia_earth.utils.tools import list_sum, flatten
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logShouldRun, logRequirements, log_blank_nodes_id
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.blank_node import group_by_keys
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.term import get_electricity_grid_mix_terms
+from .utils import get_emission, get_all_emission_terms
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "inputs": [{
+            "@type": "Input",
+            "term.@id": ["electricityGridMarketMix", "electricityGridRenewableMix"],
+            "value": ""
+        }],
+        "completeness.electricityFuel": "True"
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "background",
+        "@type": "Emission",
+        "inputs": ""
+    }]
+}
+LOOKUPS = {
+    "region-ember-energySources": "using `country`",
+    "ember-ecoinvent-mapping": ["ember", "ecoinventId", "ecoinventName"]
+}
+
+MODEL = 'ecoinventV3AndEmberClimate'
+MODEL_KEY = 'impactAssessment'  # keep to generate entry in "model-links.json"
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(value: float, term_id: str, inputs: list, operation: dict) -> dict:
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    emission["inputs"] = list(inputs)
+    if operation:
+        emission["operation"] = operation
+    return emission
+
+
+def _grid_inputs(inputs: list, electricity_grid_terms: list):
+    electricity_grid_term_ids = [v.get('@id') for v in electricity_grid_terms]
+    return [
+        i for i in inputs if i.get("term", {}).get("@id") in electricity_grid_term_ids
+    ]
+
+
+def _run_input(cycle: dict, inputs: list, emission_term_id: str, input_term: dict):
+    inputs = _grid_inputs(inputs, [input_term])
+    return [
+        _emission(
+            value=get_emission(
+                term_id=emission_term_id,
+                country=cycle.get("site", {}).get("country", {}).get("@id", ""),
+                energy=list_sum(flatten([i.get("value", []) for i in op_inputs])),
+                year=cycle.get("endDate", ""),
+                model=MODEL
+            ),
+            term_id=emission_term_id,
+            inputs=[input_term],
+            operation=op_inputs[0].get("operation")
+        )
+        for op_inputs in _group_by_operation(inputs).values()
+    ] if inputs else []
+
+
+def _group_by_operation(inputs: list) -> dict:
+    return reduce(group_by_keys(['operation']), inputs, {})
+
+
+def _run_emission(cycle: dict, electricity_grid_terms: list, inputs: list, emission_term_id: str) -> list:
+    return flatten([
+        _run_input(
+            cycle=cycle,
+            inputs=inputs,
+            emission_term_id=emission_term_id,
+            input_term=input_term
+        ) for input_term in electricity_grid_terms
+    ])
+
+
+def _should_run_emission(cycle: dict, electricity_grid_terms: list, term_id: str) -> Tuple[bool, list]:
+    term_type_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    inputs = _grid_inputs(cycle.get('inputs', []), electricity_grid_terms)
+    has_relevant_inputs = bool(inputs)
+    has_country = bool(cycle.get("site", {}).get("country", {}))
+
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    input_ids=log_blank_nodes_id(inputs))
+
+    should_run = all([term_type_complete, has_relevant_inputs, has_country])
+    logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
+    return should_run, inputs
+
+
+def _run_emissions(cycle: dict, electricity_grid_terms: list):
+    def run_emissions_for_term(term_id: str) -> list:
+        should_run, inputs = _should_run_emission(cycle, electricity_grid_terms, term_id)
+        return _run_emission(cycle, electricity_grid_terms, inputs, term_id) if should_run else []
+    return run_emissions_for_term
+
+
+def run(cycle: dict):
+    electricity_grid_terms = get_electricity_grid_mix_terms()
+    return flatten(list(map(_run_emissions(cycle, electricity_grid_terms), get_all_emission_terms())))

hestia-earth-models-0.61.3/hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -0,0 +1,125 @@
+from typing import Dict, Any, Union, List
+
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
+from hestia_earth.utils.tools import safe_parse_float, non_empty_list
+
+from hestia_earth.models.log import debugMissingLookup
+from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
+
+
+EMBER_ECOINVENT_LOOKUP_NAME = "ember-ecoinvent-mapping.csv"
+
+
+def _lookup_data(term_id: str, grouping: str, country_id: str, year: int, lookup_name: str, **log_args):
+    lookup = download_lookup(lookup_name)
+    data = get_table_value(lookup, 'termid', country_id, column_name(grouping))
+    debugMissingLookup(lookup_name, 'termid', country_id, grouping, data, term=term_id, **log_args)
+    percentage = extract_grouped_data(data, str(year))
+    return safe_parse_float(percentage, None)
+
+
+def _convert_name(name: str) -> str: return name.replace(";", ",")
+
+
+def _safe_parse_int(value: str, default=0):
+    """
+    Parse a string into an int.
+    """
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
+def _zero_from_non_numeric(value: Any) -> float:
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return 0.0
+
+
+def _extract_emission_value(value_iter: Any) -> Union[float, None]:
+    value_list = list(value_iter)
+    try:
+        if len(list(value_list)) > 0 and len(list(value_list)[0]) > 1:
+            return safe_parse_float(list(value_list)[0][1])
+    except ValueError:
+        return None
+
+
+def _get_emission_rate_per_source(ember_ecoinvent_mapping: Dict, emission_term_id: str) -> Dict:
+    """
+    Returns the emissions rate in kg/kWh as a mapping indexed by ember energy source name.
+    eg: {"bioenergy": 0.8947372128046288, "coal": 0.000124581084822, ... }
+    """
+
+    return {
+        ember_source: _extract_emission_value(filter(
+            lambda x: x[0] == emission_term_id,
+            ecoinventV3_emissions(ecoinvent_lookup["ecoinventname"])
+        ))
+        for ember_source, ecoinvent_lookup in ember_ecoinvent_mapping.items()
+    }
+
+
+def get_emission(term_id: str, country: str, year: str, energy: float, model: str) -> float:
+    """
+    Get the <term_id> emissions in kg for the energy consumed.
+        a: ecoInventId of each source        - from "ember-ecoinvent-mapping.csv"
+        b: Ember sources list                - from b
+        c: Percentages per source            - from region-ember-energySources.csv (country, ember-source, year:value)
+        d: Energy per source (kWh)           - from energy * each of c
+        e: Emissions/kWh per source          - from ecoinvent (using id from b)
+        f: Emissions per source (kg)         - from e * d for each source
+        g: Total emissions                   - from sum(f)
+    """
+    # a: ecoInventId of each source
+    ember_ecoinvent_lookup = download_lookup(EMBER_ECOINVENT_LOOKUP_NAME)
+    ember_ecoinvent_mapping = {
+        row["ember"].lower(): {"ecoinventid": row["ecoinventid"], "ecoinventname": _convert_name(row["ecoinventname"])}
+        for row in ember_ecoinvent_lookup
+    }
+
+    # b: Ember sources
+    ember_sources = list(ember_ecoinvent_mapping.keys())
+
+    # c: Percentages per source
+    percentages_per_source = {
+        source: _lookup_data(
+            term_id=source,
+            grouping=source,
+            country_id=country,
+            year=_safe_parse_int(year),
+            lookup_name="region-ember-energySources.csv",
+            model=model
+        )
+        for source in ember_sources
+    }
+
+    # d: Energy per source (kWh)
+    energy_per_source = {
+        source: energy * _zero_from_non_numeric(percentage) / 100
+        for source, percentage in percentages_per_source.items()
+    }
+
+    # e: Emissions/kWh per source
+    emission_rate_per_source = _get_emission_rate_per_source(
+        ember_ecoinvent_mapping=ember_ecoinvent_mapping,
+        emission_term_id=term_id
+    )
+
+    # f: Emissions per source (kg)
+    emissions_per_source = {
+        source: energy_per_source[source] * emission_rate_per_source[source]
+        for source in ember_sources
+        if energy_per_source[source] is not None and emission_rate_per_source[source] is not None
+    }
+
+    # g: Total emissions (kg of <term_id>)
+    return sum(emissions_per_source.values())
+
+
+def get_all_emission_terms() -> List[str]:
+    ember_ecoinvent_lookup = download_lookup(EMBER_ECOINVENT_LOOKUP_NAME)
+    eco_invent_name = _convert_name(ember_ecoinvent_lookup[0]["ecoinventname"])
+    return [e[0] for e in non_empty_list(ecoinventV3_emissions(eco_invent_name))]

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -1,14 +1,14 @@
 from functools import reduce
-from hestia_earth.schema import EmissionMethodTier, TermTermType
+from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.lookup import download_lookup
-from hestia_earth.utils.model import find_term_match, filter_list_term_type
+from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 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_NH3_emission_factor, get_terms, get_term_lookup, BREAKDOWN_LOOKUP, get_country_breakdown, get_cycle_inputs
 )
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.emission import _new_emission
@@ -26,6 +26,12 @@ REQUIREMENTS = {
                 "optional": {
                     "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
                 }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
         ],
         "site": {
@@ -115,7 +121,7 @@ def _should_run(cycle: dict):
         measurements, 'temperatureAnnual', end_date) or most_relevant_measurement_value(
         measurements, 'temperatureLongTermAnnualMean', end_date)
 
-    inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.INORGANICFERTILISER)
+    inputs = get_cycle_inputs(cycle)
     N_inputs = _filter_list_term_unit(inputs, Units.KG_N)
     has_N_inputs = len(N_inputs) > 0
 

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2006/n2OToAirInorganicFertiliserDirect.py

@@ -11,15 +11,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }]
+        ]
     }
 }
 RETURNS = {

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2006/n2OToAirInorganicFertiliserIndirect.py

@@ -12,15 +12,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "emissions": [
             {"@type": "Emission", "value": "", "term.@id": "no3ToGroundwaterInorganicFertiliser"},
             {"@type": "Emission", "value": "", "term.@id": "nh3ToAirInorganicFertiliser"},

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2006/n2OToAirOrganicFertiliserDirect.py

@@ -11,14 +11,22 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }]
+        ]
     }
 }
 RETURNS = {

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2006/n2OToAirOrganicFertiliserIndirect.py

@@ -12,14 +12,22 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }],
+        ],
         "emissions": [
             {"@type": "Emission", "value": "", "term.@id": "no3ToGroundwaterOrganicFertiliser"},
             {"@type": "Emission", "value": "", "term.@id": "nh3ToAirOrganicFertiliser"},

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -131,7 +131,7 @@ LOOKUPS = {
 }
 RETURNS = {
     "Animal": [{
-        "Input": [{
+        "inputs": [{
             "@type": "Input",
             "term.termType": ["crop", "forage"],
             "value": ""

hestia-earth-models-0.61.3/hestia_earth/models/ipcc2019/animal/weightAtMaturity.py

@@ -0,0 +1,104 @@
+"""
+Note: when the `liveweightPerHead` property is provided, this model will only work if the returned value is
+greater than or equal to `liveweightPerHead` value.
+"""
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type, find_term_match
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
+from hestia_earth.utils.tools import safe_parse_float
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugMissingLookup
+from hestia_earth.models.utils.property import _new_property, node_has_no_property
+from .. import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "none": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "weightAtMaturity"
+                }]
+            },
+            "optional": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "liveweightPerHead"
+                }]
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-weightAtMaturity": "weight at maturity"
+}
+RETURNS = {
+    "Animal": [{
+        "properties": [{
+            "@type": "Property",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'weightAtMaturity'
+
+
+def _property(value: float):
+    prop = _new_property(TERM_ID, MODEL)
+    prop['value'] = value
+    return prop
+
+
+def _run_animal(data: dict):
+    animal = data.get('animal')
+    value = data.get('value')
+    return animal | {
+        'properties': animal.get('properties', []) + [_property(value)]
+    }
+
+
+def _lookup_value(country_id: str, animal: dict):
+    lookup_name = f"{list(LOOKUPS.keys())[0]}.csv"
+    lookup = download_lookup(lookup_name)
+    column = column_name(animal.get('term').get('@id'))
+    value = get_table_value(lookup, 'termid', country_id, column)
+    debugMissingLookup(lookup_name, 'termid', country_id, column, value, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value)
+
+
+def _should_run(cycle: dict):
+    country_id = cycle.get('site', {}).get('country', {}).get('@id')
+    live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    live_animals = list(filter(node_has_no_property(TERM_ID), live_animals))
+    live_animals_with_value = [{'animal': a, 'value': _lookup_value(country_id, a)} for a in live_animals]
+
+    def _should_run_animal(value: dict):
+        lookup_value = value.get('value')
+        term_id = value.get('animal').get('term').get('@id')
+        liveweightPerHead = find_term_match(value.get('animal').get('properties', []), 'liveweightPerHead', {})
+        liveweightPerHead_value = liveweightPerHead.get('value')
+
+        logRequirements(cycle, model=MODEL, term=term_id,
+                        country_id=country_id,
+                        weightAtMaturity=lookup_value,
+                        liveweightPerHead=liveweightPerHead_value)
+
+        should_run = all([country_id, value.get('value') is not None, lookup_value >= liveweightPerHead_value])
+        logShouldRun(cycle, MODEL, term_id, should_run)
+
+        return should_run
+
+    return list(filter(_should_run_animal, live_animals_with_value))
+
+
+def run(cycle: dict):
+    animals = _should_run(cycle)
+    return list(map(_run_animal, animals))

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2019/ch4ToAirFloodedRice.py

@@ -7,6 +7,7 @@ from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.product import has_flooded_rice
+from hestia_earth.models.utils.organicFertiliser import get_cycle_inputs as get_organicFertiliser_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -17,7 +18,19 @@ REQUIREMENTS = {
             "country": {"@type": "Term", "termType": "region"}
         },
         "optional": {
-            "inputs": [{"@type": "Input", "value": "", "term.termType": "organicFertiliser"}],
+            "inputs": [
+                {
+                    "@type": "Input",
+                    "value": "",
+                    "term.termType": "organicFertiliser"
+                },
+                {
+                    "@type": "Input",
+                    "value": "",
+                    "term.termType": "fertiliserBrandName",
+                    "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
+                }
+            ],
             "products": [{"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"}],
             "practices": [
                 {"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"},
@@ -99,7 +112,7 @@ def _get_fertiliser_value(input: dict, suffix: str = ''):
 
 def _calculate_SFo(cycle: dict, suffix: str = ''):
     cropResidue = _get_cropResidue_value(cycle, suffix)
-    fertilisers = filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER)
+    fertilisers = get_organicFertiliser_inputs(cycle)
     fert_value = list_sum([_get_fertiliser_value(i, suffix) for i in fertilisers])
     return (1 + (fert_value/1000) + (cropResidue/1000)) ** 0.59
 

{hestia-earth-models-0.61.1 → hestia-earth-models-0.61.3}/hestia_earth/models/ipcc2019/n2OToAirInorganicFertiliserDirect.py

@@ -12,15 +12,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "optional": {
             "endDate": "",
             "site": {