hestia-earth-models 0.64.14__py3-none-any.whl → 0.65.0__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/excretaKgN.py

@@ -21,13 +21,13 @@ from hestia_earth.models.utils.property import _get_nitrogen_content
 from hestia_earth.models.utils.input import get_feed_inputs
 from hestia_earth.models.utils.product import _new_product, get_animal_produced_nitrogen
 from hestia_earth.models.utils.blank_node import convert_to_nitrogen
-from .utils import get_excreta_product
+from .utils import get_excreta_product_with_ratio
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "completeness.animalFeed": "",
-        "completeness.product": "",
+        "completeness.animalFeed": "True",
+        "completeness.product": "True",
         "products": [{
             "@type": "Product",
             "value": "",
@@ -63,7 +63,10 @@ REQUIREMENTS = {
                     ]
                 }]
             }
-        ]
+        ],
+        "optional": {
+            "practices": [{"@type": "Practice", "term.termType": "systemn"}]
+        }
     }
 }
 RETURNS = {
@@ -73,9 +76,9 @@ RETURNS = {
 }
 LOOKUPS = {
     "crop-property": ["nitrogenContent", "crudeProteinContent"],
-    "animalProduct": ["excretaKgNTermIds", "allowedExcretaKgNTermIds"],
-    "liveAnimal": ["excretaKgNTermIds", "allowedExcretaKgNTermIds"],
-    "liveAquaticSpecies": ["excretaKgNTermIds", "allowedExcretaKgNTermIds"]
+    "animalProduct": ["excretaKgNTermIds"],
+    "liveAnimal": ["excretaKgNTermIds"],
+    "liveAquaticSpecies": ["excretaKgNTermIds"]
 }
 MODEL_KEY = 'excretaKgN'
 
@@ -85,30 +88,29 @@ def _product(excreta_product: str, value: float):
     return excreta_product | product
 
 
-def _run(excreta_product: dict, mass_balance_items: list, alternate_items: list):
+def _run(excreta_products: list, mass_balance_items: list, alternate_items: list):
     inputs_n, products_n = mass_balance_items
     product_value, nitrogen_content = alternate_items
     value = inputs_n - products_n if all(mass_balance_items) else 3.31 * product_value * nitrogen_content / 100
-    return [_product(excreta_product, value)] if value > 0 else []
-
-
-def _get_excreta_product(cycle: dict, primary_product: dict):
-    term = primary_product.get('term', {})
-    return get_excreta_product(cycle, term, 'excretaKgNTermIds', 'allowedExcretaKgNTermIds')
+    # ratio is stored in product value
+    return [
+        _product(excreta_product, round(value * excreta_product.get('value')[0] / 100, 7))
+        for excreta_product in excreta_products
+    ] if value > 0 else []
 
 
 def _should_run(cycle: dict):
     primary_prod = find_primary_product(cycle) or {}
-    excreta_product = _get_excreta_product(cycle, primary_prod)
-    excreta_term_id = excreta_product.get('term', {}).get('@id')
-    should_add_product = all([not excreta_product.get('value', [])])
+
+    excreta_products = get_excreta_product_with_ratio(cycle, 'excretaKgNTermIds', model_key=MODEL_KEY)
+    first_term_id = excreta_products[0].get('term', {}).get('@id') if excreta_products else None
 
     dc = cycle.get('completeness', {})
     is_animalFeed_complete = dc.get('animalFeed', False)
     is_product_complete = dc.get('product', False)
 
     inputs_feed = get_feed_inputs(cycle)
-    inputs_n = convert_to_nitrogen(cycle, MODEL, excreta_term_id, inputs_feed, model_key=MODEL_KEY)
+    inputs_n = convert_to_nitrogen(cycle, MODEL, inputs_feed, term=first_term_id, model_key=MODEL_KEY)
 
     products_n = get_animal_produced_nitrogen(MODEL, cycle.get('products', []))
 
@@ -117,37 +119,39 @@ def _should_run(cycle: dict):
     product_value = list_sum(primary_prod.get('value', [0]))
     nitrogen_content = _get_nitrogen_content(primary_prod)
 
-    if is_liveAquaticSpecies:
-        logRequirements(cycle, model=MODEL, term=excreta_term_id, model_key=MODEL_KEY,
-                        is_liveAquaticSpecies=is_liveAquaticSpecies,
-                        product_value=product_value,
-                        nitrogen_content=nitrogen_content)
-
-    else:
-        logRequirements(cycle, model=MODEL, term=excreta_term_id, model_key=MODEL_KEY,
-                        is_animalFeed_complete=is_animalFeed_complete,
-                        is_product_complete=is_product_complete,
-                        inputs_n=inputs_n,
-                        products_n=products_n)
-
     mass_balance_items = [inputs_n, products_n]
     alternate_items = [product_value, nitrogen_content]
 
     should_run = all([
-        excreta_term_id,
-        should_add_product,
+        is_animalFeed_complete,
+        is_product_complete,
         any([
-            is_animalFeed_complete and is_product_complete and all(mass_balance_items),
+            all(mass_balance_items),
             is_liveAquaticSpecies and all(alternate_items)
         ])
     ])
-    # only log if the excreta term does not exist to avoid showing failure when it already exists
-    if should_add_product:
-        logShouldRun(cycle, MODEL, excreta_term_id, should_run, model_key=MODEL_KEY)
-    logShouldRun(cycle, MODEL, None, should_run)
-    return should_run, excreta_product, mass_balance_items, alternate_items
+
+    for excreta_product in excreta_products:
+        term_id = excreta_product.get('term', {}).get('@id')
+
+        if is_liveAquaticSpecies:
+            logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                            is_liveAquaticSpecies=is_liveAquaticSpecies,
+                            product_value=product_value,
+                            nitrogen_content=nitrogen_content)
+
+        else:
+            logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                            is_animalFeed_complete=is_animalFeed_complete,
+                            is_product_complete=is_product_complete,
+                            inputs_n=inputs_n,
+                            products_n=products_n)
+
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
+
+    return should_run, excreta_products, mass_balance_items, alternate_items
 
 
 def run(cycle: dict):
-    should_run, excreta_product, mass_balance_items, alternate_items = _should_run(cycle)
-    return _run(excreta_product, mass_balance_items, alternate_items) if should_run else []
+    should_run, excreta_products, mass_balance_items, alternate_items = _should_run(cycle)
+    return _run(excreta_products, mass_balance_items, alternate_items) if should_run else []

hestia_earth/models/pooreNemecek2018/excretaKgVs.py

@@ -9,23 +9,26 @@ If the mass balance fails
 (i.e. [animal feed](https://hestia.earth/schema/Completeness#animalFeed) is not complete, see requirements below),
 the fomula is = total excreta as N / [Volatile solids content](https://hestia.earth/term/volatileSolidsContent).
 """
-from hestia_earth.schema import SiteSiteType
-from hestia_earth.utils.model import find_primary_product, find_term_match
+from hestia_earth.schema import SiteSiteType, TermTermType
+from hestia_earth.utils.model import find_primary_product, find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import get_kg_VS_term_id, _filter_list_term_unit
+from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.property import get_node_property
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.input import get_feed_inputs
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
 from hestia_earth.models.utils.blank_node import convert_to_carbon
-from .utils import get_excreta_product
-from .excretaKgN import _get_excreta_product as get_excreta_n_product
+from .utils import get_excreta_product_with_ratio
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "completeness.animalFeed": "True",
+        "completeness.product": "True",
         "products": [{
             "@type": "Product",
             "primary": "True",
@@ -34,8 +37,20 @@ REQUIREMENTS = {
         }],
         "or": [
             {
-                "completeness.animalFeed": "",
-                "completeness.product": "",
+                "products": [{
+                    "@type": "Product",
+                    "primary": "True",
+                    "value": "",
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "carbonContent"}]
+                }],
+                "practices": [
+                    {"@type": "Practice", "value": "", "term.@id": "slaughterAge"},
+                    {"@type": "Practice", "value": "", "term.@id": "yieldOfPrimaryAquacultureProductLiveweightPerM2"}
+                ],
+                "site": {
+                    "@type": "Site",
+                    "measurements": [{"@type": "Measurement", "value": "", "term.@id": "netPrimaryProduction"}]
+                },
                 "or": [
                     {
                         "animals": [{
@@ -64,20 +79,18 @@ REQUIREMENTS = {
                         }]
                     }
                 ],
+                "optional": {
+                    "practices": [{"@type": "Practice", "term.termType": "systemn"}]
+                }
+            },
+            {
                 "products": [{
                     "@type": "Product",
-                    "primary": "True",
+                    "term.termType": "excreta",
+                    "term.units": "kg N",
                     "value": "",
-                    "properties": [{"@type": "Property", "value": "", "term.@id": "carbonContent"}]
-                }],
-                "practices": [
-                    {"@type": "Practice", "value": "", "term.@id": "slaughterAge"},
-                    {"@type": "Practice", "value": "", "term.@id": "yieldOfPrimaryAquacultureProductLiveweightPerM2"}
-                ],
-                "site": {
-                    "@type": "Site",
-                    "measurements": [{"@type": "Measurement", "value": "", "term.@id": "netPrimaryProduction"}]
-                }
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "volatileSolidsContent"}]
+                }]
             }
         ]
     }
@@ -89,9 +102,9 @@ RETURNS = {
 }
 LOOKUPS = {
     "crop-property": ["carbonContent", "energyContentHigherHeatingValue"],
-    "animalProduct": ["excretaKgVsTermIds", "allowedExcretaKgVsTermIds"],
-    "liveAnimal": ["excretaKgVsTermIds", "allowedExcretaKgVsTermIds"],
-    "liveAquaticSpecies": ["excretaKgVsTermIds", "allowedExcretaKgVsTermIds"]
+    "animalProduct": ["excretaKgVsTermIds"],
+    "liveAnimal": ["excretaKgVsTermIds"],
+    "liveAquaticSpecies": ["excretaKgVsTermIds"]
 }
 MODEL_KEY = 'excretaKgVs'
 
@@ -106,14 +119,20 @@ def _product(excreta_product: str, value: float):
     return excreta_product | product
 
 
-def _run(excreta_product: dict, mass_balance_items: list, inputs_c: float, alternate_items: list):
+def _run(excreta_vs_products: list, excreta_n_products: list, mass_balance_items: list, inputs_c: float):
     carbonContent, tsy, slaughterAge, aqocsed, npp = mass_balance_items
-    excretaKgN, vsc = alternate_items
     value = max(
         inputs_c + (npp * slaughterAge) / (tsy * 1000) - carbonContent - carbonContent * Conv_AQ_CLW_CO2CR,
         carbonContent * Conv_AQ_CLW_CExcr
-    ) * aqocsed if all(mass_balance_items) else excretaKgN * vsc / 100
-    return [_product(excreta_product, value)] if value > 0 else []
+    ) * aqocsed if all(mass_balance_items) else 0
+    return [
+        _product(excreta_product, excreta_product.get('value'))
+        for excreta_product in excreta_n_products
+    ] if excreta_n_products else [
+        # ratio is stored in product value
+        _product(excreta_product, round(value * excreta_product.get('value')[0] / 100, 7))
+        for excreta_product in excreta_vs_products
+    ] if value > 0 else []
 
 
 def _get_carbonContent(cycle: dict):
@@ -127,16 +146,9 @@ def _get_conv_aq_ocsed(siteType: str):
     return Conv_AQ_OC_OCSed_Marine if siteType == SiteSiteType.SEA_OR_OCEAN.value else Conv_AQ_OC_OCSed_Fresh
 
 
-def _get_excreta_product(cycle: dict, primary_product: dict):
-    term = primary_product.get('term', {})
-    return get_excreta_product(cycle, term, 'excretaKgVsTermIds', 'allowedExcretaKgVsTermIds')
-
-
 def _should_run(cycle: dict):
-    primary_prod = find_primary_product(cycle) or {}
-    excreta_product = _get_excreta_product(cycle, primary_prod)
-    excreta_term_id = excreta_product.get('term', {}).get('@id')
-    should_add_product = all([not excreta_product.get('value', [])])
+    excreta_vs_products = get_excreta_product_with_ratio(cycle, 'excretaKgVsTermIds', model_key=MODEL_KEY)
+    first_term_id = excreta_vs_products[0].get('term', {}).get('@id') if excreta_vs_products else None
 
     dc = cycle.get('completeness', {})
     is_animalFeed_complete = dc.get('animalFeed', False)
@@ -145,7 +157,7 @@ def _should_run(cycle: dict):
     carbonContent = _get_carbonContent(cycle)
 
     inputs_feed = get_feed_inputs(cycle)
-    inputs_c = convert_to_carbon(cycle, MODEL, excreta_term_id, inputs_feed, model_key=MODEL_KEY)
+    inputs_c = convert_to_carbon(cycle, MODEL, inputs_feed, term=first_term_id, model_key=MODEL_KEY)
 
     practices = cycle.get('practices', [])
     tsy = list_sum(find_term_match(practices, 'yieldOfPrimaryAquacultureProductLiveweightPerM2').get('value', []))
@@ -157,40 +169,54 @@ def _should_run(cycle: dict):
     npp = most_relevant_measurement_value(site.get('measurements', []), 'netPrimaryProduction', end_date, 0)
 
     # we can still run the model with excreta in "kg N" units
-    excreta_n_product = get_excreta_n_product(cycle, primary_prod)
-    excretaKgN = list_sum(excreta_n_product.get('value', [0]))
-    vsc = get_node_property(excreta_n_product, 'volatileSolidsContent').get('value', 0)
-
-    logRequirements(cycle, model=MODEL, term=excreta_term_id, model_key=MODEL_KEY,
-                    is_animalFeed_complete=is_animalFeed_complete,
-                    is_product_complete=is_product_complete,
-                    aqocsed=aqocsed,
-                    inputs_c=inputs_c,
-                    carbonContent=carbonContent,
-                    yield_of_target_species=tsy,
-                    slaughterAge=slaughterAge,
-                    netPrimaryProduction=npp,
-                    excretaKgN=excretaKgN,
-                    volatileSolidsContent=vsc)
+    excreta_products = filter_list_term_type(cycle.get('products', []), TermTermType.EXCRETA)
+    default_using_kg_N = not any([
+        find_term_match(excreta_products, product.get('term', {}).get('@id'))
+        for product in excreta_vs_products
+    ])
+    excreta_n_products = _filter_list_term_unit(excreta_products, Units.KG_N) if default_using_kg_N else []
+    excreta_n_products = [
+        (
+            excreta_n_product,
+            get_node_property(excreta_n_product, 'volatileSolidsContent').get('value', 0)
+        )
+        for excreta_n_product in excreta_n_products
+    ]
+    excreta_n_products = [
+        {
+            'term': {'@id': get_kg_VS_term_id(excreta_n_product.get('term', {}).get('@id'))},
+            'value': list_sum(excreta_n_product.get('value', [])) * vsc / 100
+        }
+        for (excreta_n_product, vsc) in excreta_n_products
+        if vsc > 0
+    ]
 
     mass_balance_items = [carbonContent, tsy, slaughterAge, aqocsed, npp]
-    alternate_items = [excretaKgN, vsc]
 
     should_run = all([
-        excreta_term_id,
-        should_add_product,
-        any([
-            is_animalFeed_complete and is_product_complete and all(mass_balance_items),
-            all(alternate_items)
-        ])
+        is_animalFeed_complete,
+        is_product_complete,
+        all(mass_balance_items) or excreta_n_products
     ])
-    # only log if the excreta term does not exist to avoid showing failure when it already exists
-    if should_add_product:
-        logShouldRun(cycle, MODEL, excreta_term_id, should_run, model_key=MODEL_KEY)
-    logShouldRun(cycle, MODEL, None, should_run)
-    return should_run, excreta_product, mass_balance_items, inputs_c, alternate_items
+
+    for excreta_product in excreta_vs_products + excreta_n_products:
+        term_id = excreta_product.get('term', {}).get('@id')
+
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        is_animalFeed_complete=is_animalFeed_complete,
+                        is_product_complete=is_product_complete,
+                        aqocsed=aqocsed,
+                        inputs_c=inputs_c,
+                        carbonContent=carbonContent,
+                        yield_of_target_species=tsy,
+                        slaughterAge=slaughterAge,
+                        netPrimaryProduction=npp,
+                        default_using_kg_N=default_using_kg_N)
+        logShouldRun(cycle, MODEL, term_id, should_run)
+
+    return should_run, excreta_vs_products, excreta_n_products, mass_balance_items, inputs_c
 
 
 def run(cycle: dict):
-    should_run, excreta_product, mass_balance_items, inputs_c, alternate_items = _should_run(cycle)
-    return _run(excreta_product, mass_balance_items, inputs_c, alternate_items) if should_run else []
+    should_run, excreta_vs_products, excreta_n_products, mass_balance_items, inputs_c = _should_run(cycle)
+    return _run(excreta_vs_products, excreta_n_products, mass_balance_items, inputs_c) if should_run else []

hestia_earth/models/pooreNemecek2018/saplingsDepreciatedAmountPerCycle.py

@@ -38,9 +38,9 @@ def _get_value(product: dict):
     return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop']), None)
 
 
-def _run(product: dict, plantation_duration: float, cycleDuration: float):
+def _run(product: dict, plantationLifespan: float, cycleDuration: float):
     value = _get_value(product)
-    return [_input(value / plantation_duration * cycleDuration)]
+    return [_input(value / plantationLifespan * cycleDuration)]
 
 
 def _should_run_product(product: dict): return _get_value(product) is not None
@@ -50,19 +50,19 @@ def _should_run(cycle: dict):
     cycleDuration = cycle.get('cycleDuration')
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
     product = next((p for p in cycle.get('products', []) if _should_run_product(p)), None)
-    plantation_duration = list_sum(find_term_match(cycle.get('practices', []), PRACTICE_TERM_ID).get('value'), None)
+    plantationLifespan = list_sum(find_term_match(cycle.get('practices', []), PRACTICE_TERM_ID).get('value'), None)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     term_type_seed_incomplete=term_type_incomplete,
                     product_id=(product or {}).get('term', {}).get('@id'),
-                    plantation_duration=plantation_duration,
+                    plantationLifespan=plantationLifespan,
                     cycleDuration=cycleDuration)
 
-    should_run = all([term_type_incomplete, product, plantation_duration, (cycleDuration or 0) > 0])
+    should_run = all([term_type_incomplete, product, plantationLifespan, (cycleDuration or 0) > 0])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, product, plantation_duration, cycleDuration
+    return should_run, product, plantationLifespan, cycleDuration
 
 
 def run(cycle: dict):
-    should_run, product, plantation_duration, cycleDuration = _should_run(cycle)
-    return _run(product, plantation_duration, cycleDuration) if should_run else []
+    should_run, product, plantationLifespan, cycleDuration = _should_run(cycle)
+    return _run(product, plantationLifespan, cycleDuration) if should_run else []

hestia_earth/models/pooreNemecek2018/utils.py

@@ -1,5 +1,7 @@
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import non_empty_list, list_average
+from functools import reduce
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import find_term_match, filter_list_term_type, find_primary_product
+from hestia_earth.utils.tools import non_empty_list, list_average, list_sum
 from hestia_earth.utils.lookup import extract_grouped_data
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_as_table
@@ -29,21 +31,60 @@ def run_products_average(cycle: dict, term_id: str, get_value_func):
     return list_average(values) if should_run else None
 
 
-def get_excreta_product(cycle: dict, term: dict, lookup_expected_id: str, lookup_allowed_ids: str):
-    primary_excreta_data = get_lookup_value(term, lookup_expected_id, model=MODEL) or (
-        # TODO: remove fallback when glossary is fixed for liveAquaticSpecies
-        get_lookup_value(term, lookup_expected_id[0:-1], model=MODEL) or ''
-    )
-    expected_term_id = extract_grouped_data(primary_excreta_data, 'default') if ':' in primary_excreta_data \
-        else primary_excreta_data
-    allowed_term_ids = (get_lookup_value(term, lookup_allowed_ids, model=MODEL) or '').split(';')
-    products = non_empty_list([
-        find_term_match(cycle.get('products', []), term_id) for term_id in non_empty_list(
-            [expected_term_id] + allowed_term_ids
-        )
-    ])
-    # take the first product available or create a new one with expected id
-    return products[0] if products else {
+def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
+    product = find_primary_product(cycle) or {}
+
+    data = get_lookup_value(product.get('term'), lookup, model=MODEL, **log_args)
+
+    default_product_id = extract_grouped_data(data, 'default')
+
+    # find matching practices and assign a ratio for each
+    # if no matches, use default id with 100% ratio
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.SYSTEM)
+    practices = [
+        {
+            'id': practice.get('term', {}).get('@id'),
+            'product-id': extract_grouped_data(data, practice.get('term', {}).get('@id')) or default_product_id,
+            'value': list_sum(practice.get('value'))
+        }
+        for practice in practices
+        # only keep practices with positive value
+        if list_sum(practice.get('value', [-1]), 0) > 0
+    ]
+    logRequirements(cycle, model=MODEL, **log_args,
+                    practices=log_as_table(practices),
+                    default_product_id=default_product_id)
+
+    total_value = list_sum([p.get('value') for p in practices])
+
+    # group practices by product id
+    grouped_practices = reduce(lambda p, c: p | {
+        c['product-id']: p.get(c['product-id'], []) + [c]
+    }, practices, {})
+    # calculate ratio for each product
+    grouped_practices = [
+        values[0] | {'ratio': round(list_sum([v.get('value') for v in values]) * 100 / total_value, 2)}
+        for values in grouped_practices.values()
+    ]
+
+    practices_with_products = [
+        (find_term_match(cycle.get('products', []), p.get('product-id')), p)
+        for p in grouped_practices
+    ]
+    products = [
+        (
+            product or {
+                '@type': 'Product',
+                'term': {'@type': 'Term', '@id': practice.get('product-id')}
+            }
+        ) | {'value': [practice.get('ratio')]}
+        for product, practice in practices_with_products
+        # ignore matching products with an existing value
+        if not product or not product.get('value', [])
+    ] if practices_with_products else None
+
+    return products or [{
         '@type': 'Product',
-        'term': {'@type': 'Term', '@id': expected_term_id}
-    }
+        'term': {'@type': 'Term', '@id': default_product_id},
+        'value': [100]
+    }]

hestia_earth/models/schererPfister2015/nErosionSoilFlux.py

@@ -84,10 +84,10 @@ def _should_run(cycle: dict):
     precipitation = _get_measurement_content('precipitationAnnual')
     water = get_water(cycle, precipitation)
 
-    practice_factor = get_practice_factor(site)
+    practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
-    p_ef_c1 = get_p_ef_c1(cycle)
-    ef_p_c2 = get_ef_p_c2(cycle)
+    p_ef_c1 = get_p_ef_c1(TERM_ID, cycle)
+    ef_p_c2 = get_ef_p_c2(TERM_ID, cycle)
 
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
@@ -96,6 +96,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_value = [nla_environment, soil_nitrogen_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    country=site.get('country', {}).get('@id'),
                     practice_factor=practice_factor,
                     erodibility=erodibility,
                     slope_length=slope_length,

hestia_earth/models/schererPfister2015/pErosionSoilFlux.py

@@ -85,10 +85,10 @@ def _should_run(cycle: dict):
     precipitation = _get_measurement_content('precipitationAnnual')
     water = get_water(cycle, precipitation)
 
-    practice_factor = get_practice_factor(site)
+    practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
-    p_ef_c1 = get_p_ef_c1(cycle)
-    ef_p_c2 = get_ef_p_c2(cycle)
+    p_ef_c1 = get_p_ef_c1(TERM_ID, cycle)
+    ef_p_c2 = get_ef_p_c2(TERM_ID, cycle)
 
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
@@ -97,6 +97,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_value = [nla_environment, soil_phosphorus_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    country=site.get('country', {}).get('@id'),
                     practice_factor=practice_factor,
                     erodibility=erodibility,
                     slope_length=slope_length,

hestia_earth/models/schererPfister2015/utils.py

@@ -6,6 +6,7 @@ from hestia_earth.models.utils.blank_node import get_total_value, get_P2O5_total
 from hestia_earth.models.utils.term import get_lookup_value, get_tillage_terms
 from hestia_earth.models.utils.input import match_lookup_value
 from hestia_earth.models.utils.organicFertiliser import get_cycle_inputs as get_organicFertiliser_inputs
+from . import MODEL
 
 SLOPE_RANGE = [
     [0.0, 0.03, 1.2],
@@ -41,24 +42,26 @@ def get_pcorr(slope: float):
     return next((element[2] for element in SLOPE_RANGE if slope >= element[0] and slope < element[1]), None)
 
 
-def _get_C2_factor(term: dict):
-    return safe_parse_float(get_lookup_value(term, 'C2_FACTORS'), None)
+def _get_C2_factor(term_id: str, term: dict):
+    return safe_parse_float(get_lookup_value(term, 'C2_FACTORS', model=MODEL, term=term_id), None)
 
 
-def get_practice_factor(site: dict):
-    return safe_parse_float(get_lookup_value(site.get('country', {}), 'Practice_Factor'), None)
+def get_practice_factor(term_id: str, site: dict):
+    return safe_parse_float(
+        get_lookup_value(site.get('country', {}), 'Practice_Factor', model=MODEL, term=term_id), None)
 
 
-def get_p_ef_c1(cycle: dict):
+def get_p_ef_c1(term_id: str, cycle: dict):
     primary_product = find_primary_product(cycle) or {}
-    return safe_parse_float(get_lookup_value(primary_product.get('term', {}), 'P_EF_C1'), None)
+    return safe_parse_float(
+        get_lookup_value(primary_product.get('term', {}), 'P_EF_C1', model=MODEL, term=term_id), None)
 
 
-def get_ef_p_c2(cycle: dict):
+def get_ef_p_c2(term_id: str, cycle: dict):
     tillage = _get_tillage(cycle)
     country = cycle.get('site', {}).get('country', {})
-    # TODO: handle pasture
-    return safe_parse_float(get_lookup_value(country, 'EF_P_C2'), None) if tillage is None else _get_C2_factor(tillage)
+    return _get_C2_factor(term_id, tillage) if tillage else safe_parse_float(
+        get_lookup_value(country, 'EF_P_C2', model=MODEL, term=term_id), None)
 
 
 def get_water(cycle: dict, precipitation: float):