hestia-earth-models 0.61.2__py3-none-any.whl → 0.61.4__py3-none-any.whl

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/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/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/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/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/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/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/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/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/ipcc2019/animal/pastureGrass.py

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

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/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/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": {