hestia-earth-models 0.70.0__py3-none-any.whl → 0.70.2__py3-none-any.whl

hestia_earth/models/cycle/utils.py

@@ -1,15 +1,9 @@
 from hestia_earth.utils.tools import list_average
 
 from hestia_earth.models.log import logShouldRun
-from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 
-def get_liveAnimal_term_id(product: dict, **log_ars):
-    term_id = get_lookup_value(product.get('term', {}), 'liveAnimalTermId', model=MODEL, **log_ars)
-    return term_id.split(';')[0] if term_id else None
-
-
 def _should_run_property_by_min_max(property: dict):
     return all([
         property.get('min') is not None,

hestia_earth/models/data/ecoinventV3/__init__.py

@@ -1,32 +1,34 @@
 import os
-from hestia_earth.utils.lookup import column_name, get_table_value, load_lookup
+from functools import lru_cache
+from hestia_earth.utils.lookup import column_name, get_table_value, load_lookup, lookup_columns
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logger
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-ECOINVENT_FILEPATH = os.getenv('ECOINVENT_V3_FILEPATH', f"{os.path.join(CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
+_FILEPATH = os.getenv('ECOINVENT_V3_FILEPATH', f"{os.path.join(CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
 
 
+@lru_cache()
 def _get_file():
-    if not os.path.exists(ECOINVENT_FILEPATH):
-        logger.warn('Ecoinvent file not found. Please make sure to set env variable "ECOINVENT_V3_FILEPATH".')
+    if not os.path.exists(_FILEPATH):
+        logger.warning('Ecoinvent file not found. Please make sure to set env variable "ECOINVENT_V3_FILEPATH".')
         return None
 
-    return load_lookup(filepath=ECOINVENT_FILEPATH, keep_in_memory=True)
+    return load_lookup(filepath=_FILEPATH, keep_in_memory=True)
 
 
 def ecoinventV3_emissions(ecoinventName: str):
     lookup = _get_file()
     col_name = column_name('ecoinventName')
 
-    def emission(index: int):
-        id = get_table_value(
-            lookup, col_name, ecoinventName, column_name(f"emissionsResourceUse.{index}.term.id")
-        )
-        value = get_table_value(
-            lookup, col_name, ecoinventName, column_name(f"emissionsResourceUse.{index}.value")
-        )
+    def emission(column: str):
+        id = get_table_value(lookup, col_name, ecoinventName, column_name(column))
+        value = get_table_value(lookup, col_name, ecoinventName, column_name(column.replace('termid', 'value')))
         return (id, value) if id else None
 
-    return non_empty_list(map(emission, range(0, 12)))
+    columns = [
+        col for col in lookup_columns(lookup)
+        if col.endswith(column_name('termid'))
+    ]
+    return non_empty_list(map(emission, columns))

hestia_earth/models/ecoalimV9/__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 = 'ecoalimV9'
+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/ecoalimV9/cycle.py

@@ -0,0 +1,128 @@
+from functools import reduce
+from statistics import mean
+from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import flatten, list_sum
+
+from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
+from hestia_earth.models.utils.blank_node import group_by_keys
+from .utils import get_input_mappings, ecoalim_values
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "none": {
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }],
+        "optional": {
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{
+                    "@type": "Input",
+                    "value": "> 0",
+                    "none": {
+                        "fromCycle": "True",
+                        "producedInCycle": "True"
+                    }
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "term": "",
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": "",
+        "animals": ""
+    }]
+}
+LOOKUPS = {
+    "ecoalim-emissionsResourceUse": "emission-",
+    "crop": "ecoalimMapping",
+    "processedFood": "ecoalimMapping",
+    "animalProduct": "ecoalimMapping",
+    "forage": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping"
+}
+MODEL_KEY = 'cycle'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    emission['inputs'] = [input.get('term')]
+    if input.get('operation'):
+        emission['operation'] = input.get('operation')
+    if input.get('animal'):
+        emission['animals'] = [input.get('animal')]
+    return emission
+
+
+def _add_emission(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        gadm_id, ecoalim_key = mapping
+        # all countries have the same coefficient
+        coefficient = 1
+        emissions = ecoalim_values(ecoalim_key, 'emission')
+        for emission_term_id, value in emissions:
+            # log run on each emission so we know it did run
+            debugValues(cycle, model=MODEL, term=emission_term_id, model_key=MODEL_KEY,
+                        value=value,
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            prev[emission_term_id] = prev.get(emission_term_id, []) + [value * coefficient]
+        return prev
+    return add
+
+
+def _run_input(cycle: dict):
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+
+    def run(inputs: list):
+        input = inputs[0]
+        input_term_id = input.get('term', {}).get('@id')
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        mappings = get_input_mappings(MODEL, input)
+        has_mappings = len(mappings) > 0
+
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
+
+        logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+                        has_ecoalim_mappings=has_mappings,
+                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        input_value=input_value)
+
+        should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+
+        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        return [
+            _emission(term_id, mean(value) * input_value, input)
+            for term_id, value in grouped_emissions.items()
+        ]
+    return run
+
+
+def run(cycle: dict):
+    inputs = get_background_inputs(cycle)
+    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -0,0 +1,125 @@
+from functools import reduce
+from statistics import mean
+from hestia_earth.schema import IndicatorMethodTier
+from hestia_earth.utils.tools import flatten, list_sum
+
+from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.background_emissions import get_background_inputs
+from hestia_earth.models.utils.blank_node import group_by_keys
+from .utils import get_input_mappings, ecoalim_values
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "inputs": [{
+                "@type": "Input",
+                "value": "> 0",
+                "none": {
+                    "fromCycle": "True",
+                    "producedInCycle": "True"
+                }
+            }],
+            "optional": {
+                "animals": [{
+                    "@type": "Animal",
+                    "inputs": [{
+                        "@type": "Input",
+                        "value": "> 0",
+                        "none": {
+                            "fromCycle": "True",
+                            "producedInCycle": "True"
+                        }
+                    }]
+                }]
+            }
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "term": "",
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": ""
+    }]
+}
+LOOKUPS = {
+    "ecoalim-emissionsResourceUse": "resourceUse-",
+    "crop": "ecoalimMapping",
+    "processedFood": "ecoalimMapping",
+    "animalProduct": "ecoalimMapping",
+    "forage": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping"
+}
+MODEL_KEY = 'impact_assessment'
+TIER = IndicatorMethodTier.BACKGROUND.value
+
+
+def _indicator(term_id: str, value: float, input: dict):
+    indicator = _new_indicator(term_id, MODEL)
+    indicator['value'] = value
+    indicator['methodTier'] = TIER
+    indicator['inputs'] = [input.get('term')]
+    if input.get('operation'):
+        indicator['operation'] = input.get('operation')
+    return indicator
+
+
+def _add_indicator(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        gadm_id, ecoalim_key = mapping
+        # all countries have the same coefficient
+        coefficient = 1
+        indicators = ecoalim_values(ecoalim_key, 'resourceUse')
+        for indicator_term_id, value in indicators:
+            # log run on each indicator so we know it did run
+            debugValues(cycle, model=MODEL, term=indicator_term_id, model_key=MODEL_KEY,
+                        value=value,
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            if value is not None:
+                prev[indicator_term_id] = prev.get(indicator_term_id, []) + [value * coefficient]
+        return prev
+    return add
+
+
+def _run_input(impact_assessment: dict):
+    def run(inputs: list):
+        input = inputs[0]
+        input_term_id = input.get('term', {}).get('@id')
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        mappings = get_input_mappings(MODEL, input)
+        has_mappings = len(mappings) > 0
+
+        logRequirements(impact_assessment, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+                        has_ecoalim_mappings=has_mappings,
+                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        input_value=input_value)
+
+        should_run = all([has_mappings, input_value])
+        logShouldRun(
+            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY
+        )
+
+        grouped_indicators = reduce(_add_indicator(impact_assessment, input), mappings, {}) if should_run else {}
+        return [
+            _indicator(term_id, mean(value) * input_value, input)
+            for term_id, value in grouped_indicators.items()
+        ]
+    return run
+
+
+def run(impact_assessment: dict):
+    inputs = get_background_inputs(impact_assessment.get('cycle', {}))
+    grouped_inputs = reduce(group_by_keys(['term', 'operation']), inputs, {})
+    return flatten(map(_run_input(impact_assessment), grouped_inputs.values()))

hestia_earth/models/ecoalimV9/utils.py

@@ -0,0 +1,31 @@
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, lookup_columns
+from hestia_earth.utils.tools import non_empty_list
+
+from hestia_earth.models.utils.term import get_lookup_value
+
+
+_LOOKUP = "ecoalim-emissionsResourceUse.csv"
+
+
+def get_input_mappings(model: str, input: dict):
+    term = input.get('term', {})
+    term_id = term.get('@id')
+    value = get_lookup_value(term, 'ecoalimMapping', model=model, term=term_id)
+    mappings = non_empty_list(value.split(';')) if value else []
+    return [(m.split(':')[0], m.split(':')[1]) for m in mappings]
+
+
+def ecoalim_values(mapping: str, column_prefix: str):
+    lookup = download_lookup(_LOOKUP)
+    col_name = column_name('ecoalimMappingName')
+
+    def emission(column: str):
+        id = get_table_value(lookup, col_name, mapping, column)
+        value = get_table_value(lookup, col_name, mapping, column.replace('term', 'value'))
+        return (id, value) if id else None
+
+    columns = [
+        col for col in lookup_columns(lookup)
+        if col.startswith(column_name(column_prefix)) and col.endswith(column_name('term'))
+    ]
+    return non_empty_list(map(emission, columns))

hestia_earth/models/ecoinventV3/__init__.py

@@ -4,12 +4,12 @@ from hestia_earth.utils.tools import flatten, list_sum
 
 from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
 from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
-from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.pesticideAI import get_pesticides_from_inputs
 from hestia_earth.models.utils.fertiliser import get_fertilisers_from_inputs
-from .utils import get_background_inputs, get_input_mappings
+from .utils import get_input_mappings
 
 REQUIREMENTS = {
     "Cycle": {
@@ -96,26 +96,17 @@ def _add_emission(cycle: dict, input: dict):
 
 
 def _run_input(cycle: dict):
-    emissions = cycle.get('emissions', [])
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
 
     def run(inputs: list):
         input = inputs[0]
         input_term_id = input.get('term', {}).get('@id')
-        operation_term_id = input.get('operation', {}).get('@id')
-        animal_term_id = input.get('animal', {}).get('@id')
         input_value = list_sum(flatten(input.get('value', []) for input in inputs))
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
+
         # skip input that has background emissions we have already gap-filled (model run before)
-        has_no_gap_filled_background_emissions = not any([
-            is_from_model(e)
-            for e in emissions
-            if all([
-                any([i.get('@id') == input_term_id for i in e.get('inputs', [])]),
-                e.get('operation', {}).get('@id') == operation_term_id,
-                e.get('animal', {}).get('@id') == animal_term_id
-            ])
-        ])
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
@@ -125,6 +116,7 @@ def _run_input(cycle: dict):
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
         return [
             _emission(term_id, value * input_value, input)

hestia_earth/models/ecoinventV3/utils.py

@@ -1,36 +1,8 @@
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import flatten, non_empty_list
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.utils.term import get_lookup_value
 
 
-def _animal_inputs(animal: dict):
-    inputs = animal.get('inputs', [])
-    return [(input | {'animal': animal.get('term', {})}) for input in inputs]
-
-
-def _should_run_input(products: list):
-    def should_run(input: dict):
-        return all([
-            # make sure Input is not a Product as well or we might double-count emissions
-            find_term_match(products, input.get('term', {}).get('@id'), None) is None,
-            # ignore inputs which are flagged as Product of the Cycle
-            not input.get('fromCycle', False),
-            not input.get('producedInCycle', False)
-        ])
-    return should_run
-
-
-def get_background_inputs(cycle: dict, extra_inputs: list = []):
-    # 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', []))) +
-        extra_inputs
-    )
-    return list(filter(_should_run_input(cycle.get('products', [])), inputs))
-
-
 def get_input_mappings(model: str, cycle: dict, input: dict):
     term = input.get('term', {})
     term_id = term.get('@id')

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -4,12 +4,13 @@ from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logShouldRun, logRequirements, debugValues
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
 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 hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
 from .utils import get_input_coefficient
-from ..ecoinventV3.utils import get_background_inputs, get_input_mappings
+from ..ecoinventV3.utils import get_input_mappings
 
 REQUIREMENTS = {
     "Cycle": {
@@ -101,6 +102,7 @@ def _add_emission(cycle: dict, input: dict):
 
 def _run_input(cycle: dict):
     electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
 
     def run(inputs: list):
         input = inputs[0]
@@ -109,12 +111,16 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
 
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
+
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
                         input_value=input_value)
 
-        should_run = all([electricity_complete, has_mappings, input_value])
+        should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
 
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -1,10 +1,11 @@
-from hestia_earth.schema import NodeType, EmissionMethodTier
+from hestia_earth.schema import NodeType, EmissionMethodTier, TermTermType
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids, lookup_columns, column_name
 from hestia_earth.utils.lookup_utils import is_in_system_boundary
+from hestia_earth.utils.tools import flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.blank_node import _run_required
-from hestia_earth.models.utils.term import get_all_emission_terms
+from hestia_earth.models.utils.blank_node import _run_required, _run_model_required
 
 REQUIREMENTS = {
     "Cycle": {
@@ -18,7 +19,17 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "emission": "inHestiaDefaultSystemBoundary"
+    "emission": [
+        "term.id",
+        "inHestiaDefaultSystemBoundary",
+        "inputTermTypesAllowed",
+        "productTermIdsAllowed",
+        "productTermTypesAllowed",
+        "siteTypesAllowed",
+        "typesAllowed"
+    ],
+    "emission-model-productTermIdsAllowed": "",
+    "emission-model-siteTypesAllowed": ""
 }
 MODEL = 'emissionNotRelevant'
 TIER = EmissionMethodTier.NOT_RELEVANT.value
@@ -31,9 +42,22 @@ def _emission(term_id: str):
     return emission
 
 
-def _should_run_emission(cycle: dict):
+def _emission_ids():
+    return lookup_term_ids(download_lookup(f"{TermTermType.EMISSION.value}.csv"))
+
+
+def _model_ids(lookup_suffix: str):
+    return [
+        col for col in lookup_columns(download_lookup(f"emission-model-{lookup_suffix}.csv"))
+        if col != column_name('term.id')
+    ]
+
+
+def _should_run_emission(cycle: dict, model_ids: list):
     def run(term_id: str):
-        is_not_relevant = not _run_required(MODEL, term_id, cycle)
+        is_not_relevant = not _run_required(MODEL, term_id, cycle) or any([
+            not _run_model_required(model_id, term_id, cycle, skip_logs=True) for model_id in model_ids
+        ])
         in_system_boundary = is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
@@ -49,8 +73,9 @@ def _should_run_emission(cycle: dict):
 
 
 def _run(cycle: dict):
-    emissions = get_all_emission_terms()
-    term_ids = list(filter(_should_run_emission(cycle), emissions))
+    emissions = _emission_ids()
+    model_ids = list(set(flatten(map(_model_ids, ['productTermIdsAllowed', 'siteTypesAllowed']))))
+    term_ids = list(filter(_should_run_emission(cycle, model_ids), emissions))
     return list(map(_emission, term_ids))
 
 

hestia_earth/models/{cycle → hestia}/aboveGroundCropResidue.py

@@ -33,6 +33,10 @@ TOTAL_TERM_ID = 'aboveGroundCropResidueTotal'
 REMAINING_MODEL = PRODUCT_ID_TO_PRACTICES_ID[-1]['product']
 
 
+def _product(term_id: str, value: float):
+    return _new_product(term_id, round(value, 7), MODEL)
+
+
 def _get_practices(term_id: str):
     return flatten([
         model.get('practices', []) for model in PRODUCT_ID_TO_PRACTICES_ID if all([
@@ -50,9 +54,6 @@ def _get_practice_value(term_ids: list, cycle: dict) -> float:
     return list_sum(values) / 100 if len(values) > 0 else None
 
 
-def _product(term_id: str, value: float): return _new_product(term_id, round(value, 7))
-
-
 def _should_run_model(model, cycle: dict, total_value: float):
     term_id = model.get('product')
     practice_value = _get_practice_value(model.get('practices'), cycle)

hestia_earth/models/{cycle → hestia}/aboveGroundCropResidueTotal.py

@@ -22,7 +22,7 @@ TERM_ID = 'aboveGroundCropResidueTotal'
 
 
 def _product(value: float):
-    product = _new_product(TERM_ID, value)
+    product = _new_product(TERM_ID, value, MODEL)
     return product
 
 

hestia_earth/models/{site → hestia}/brackishWater.py

@@ -22,7 +22,7 @@ TERM_ID = 'brackishWater'
 
 
 def _measurement():
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/{site → hestia}/cationExchangeCapacityPerKgSoil.py

@@ -30,7 +30,7 @@ BIBLIO_TITLE = 'Contribution of Organic Matter and Clay to Soil Cation-Exchange
 
 
 def _measurement(site: dict, value: float, depthUpper: int = None, depthLower: int = None):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     if depthUpper is not None:
         data['depthUpper'] = depthUpper

hestia_earth/models/{cycle → hestia}/coldCarcassWeightPerHead.py

@@ -36,7 +36,7 @@ TERM_ID = 'coldCarcassWeightPerHead'
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/coldDressedCarcassWeightPerHead.py

@@ -40,7 +40,7 @@ TERM_ID = 'coldDressedCarcassWeightPerHead'
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/concentrateFeed.py

@@ -45,7 +45,7 @@ INPUT_TERM_TYPES = [
 
 
 def _property(term_id: str, value: float):
-    prop = _new_property(term_id)
+    prop = _new_property(term_id, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/cropResidueManagement.py

@@ -31,7 +31,7 @@ PRACTICE_IDS = [
 
 
 def _practice(term_id: str):
-    practice = _new_practice(term_id)
+    practice = _new_practice(term_id, MODEL)
     practice['value'] = [0]
     return practice
 

hestia_earth/models/{cycle → hestia}/croppingIntensity.py

@@ -24,7 +24,7 @@ TERM_ID = 'croppingIntensity'
 
 
 def _practice(value: float):
-    practice = _new_practice(TERM_ID)
+    practice = _new_practice(TERM_ID, MODEL)
     practice['value'] = [round(value, 7)]
     return practice