hestia-earth-models 0.72.2__py3-none-any.whl → 0.73.1__py3-none-any.whl

hestia_earth/models/{akagiEtAl2011AndIpcc2006 → akagiEtAl2011}/__init__.py

@@ -6,7 +6,7 @@ from hestia_earth.models.utils.blank_node import run_if_required
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
-MODEL = 'akagiEtAl2011AndIpcc2006'
+MODEL = 'akagiEtAl2011'
 PKG = '.'.join(['hestia_earth', 'models', MODEL])
 
 

hestia_earth/models/akagiEtAl2011/ch4ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'ch4ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/nh3ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'nh3ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/noxToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'noxToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/pm25ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'pm25ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/so2ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'so2ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/utils.py

@@ -0,0 +1,45 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.cropResidue import get_crop_residue_burnt_value
+from . import MODEL
+
+TIER = EmissionMethodTier.TIER_1.value
+LOOKUP_NAME = 'akagiEtAl2011CropResidueBurningFactor'
+
+
+def _emission(term_id: str, value: float, sd: float = None):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    if sd is not None:
+        emission['sd'] = [sd]
+        emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    return emission
+
+
+def _run(term_id: str, product_value: list):
+    value = sum(product_value)
+    term = {'termType': TermTermType.EMISSION.value, '@id': term_id}
+    factor = get_lookup_value(term, LOOKUP_NAME)
+    factor_sd = get_lookup_value(term, LOOKUP_NAME + '-sd')
+    return [_emission(term_id, value * factor, value * factor_sd)]
+
+
+def _should_run(term_id: str, cycle: dict):
+    crop_residue_burnt_value = get_crop_residue_burnt_value(cycle)
+    has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
+
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    has_crop_residue_burnt=has_crop_residue_burnt)
+
+    should_run = all([has_crop_residue_burnt])
+    logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
+    return should_run, crop_residue_burnt_value
+
+
+def run_emission(term_id: str, cycle: dict):
+    should_run, crop_residue_burnt_value = _should_run(term_id, cycle)
+    return _run(term_id, crop_residue_burnt_value) if should_run else []

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -1,4 +1,5 @@
 from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name
 from hestia_earth.utils.tools import safe_parse_float
 
@@ -6,7 +7,7 @@ from hestia_earth.models.log import logRequirements, debugMissingLookup, logShou
 from hestia_earth.models.utils import sum_values, multiply_values
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.impact_assessment import (
-    convert_value_from_cycle, emission_value, get_product, get_site, get_region_id
+    convert_value_from_cycle, get_product, get_site, get_region_id
 )
 from hestia_earth.models.utils.input import sum_input_impacts
 from hestia_earth.models.utils.lookup import get_region_lookup_value
@@ -61,39 +62,39 @@ def _get_factor_from_basinId(site: dict, aware_id: str):
         download_lookup(f"{AWARE_KEY}.csv"), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
     )
     debugMissingLookup(f"{AWARE_KEY}.csv", AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
-def _get_factor_from_region(impact_assessment: dict, site: dict):
-    region_id = get_region_id(impact_assessment)
+def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
+    region_id = get_region_id(impact_assessment, fresh_water)
     site_type = site.get('siteType')
     lookup_name = 'region-aware-factors.csv'
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
     column = f"Agg_CF_{lookup_suffix}"
     value = get_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
 def run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    fresh_water = emission_value(impact_assessment, 'freshwaterWithdrawalsDuringCycle')
+    fresh_water = find_term_match(impact_assessment.get('emissionsResourceUse', []), 'freshwaterWithdrawalsDuringCycle')
     site = get_site(impact_assessment)
     aware_id = site.get(AWARE_KEY)
     factor = (
         _get_factor_from_basinId(site, aware_id) if aware_id else None
-    ) or _get_factor_from_region(impact_assessment, site)
+    ) or _get_factor_from_region(impact_assessment, fresh_water, site)
     inputs_value = convert_value_from_cycle(
         impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
 
     value = sum_values([
-        multiply_values([fresh_water, factor]),
+        multiply_values([fresh_water.get('value'), factor]),
         inputs_value
     ])
 
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
-                    fresh_water=fresh_water,
+                    fresh_water=fresh_water.get('value'),
                     aware_id=aware_id,
                     factor=factor,
                     inputs_value=inputs_value)

hestia_earth/models/cache_sites.py

@@ -132,10 +132,14 @@ def _run(sites: list, years: list = [], years_only: bool = False):
     rasters = list_rasters(years=years, years_only=years_only)
     vectors = [] if years_only else list_vectors(sites)
     filtered_data, sites_no_run = _group_sites(sites, not years_only)
-    return flatten([
-        _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
-        for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
-    ] + _run_values(sites_no_run, years=years))
+    return flatten(
+        [
+            _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
+            for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
+        ] + (
+            _run_values(sites_no_run, years=years) if sites_no_run else []
+        )
+    )
 
 
 def _run_by_years(sites: list, years: list, batch_size: int):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -1,8 +1,10 @@
+from hestia_earth.utils.model import find_term_match
+
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils import sum_values, multiply_values
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.impact_assessment import (
-    convert_value_from_cycle, emission_value, get_product, get_site
+    convert_value_from_cycle, get_product, get_site
 )
 from hestia_earth.models.utils.input import sum_input_impacts
 from .utils import get_region_factor
@@ -56,26 +58,27 @@ def _indicator(value: float):
     return indicator
 
 
-def _value(impact_assessment: dict, term_id: str):
-    value = emission_value(impact_assessment, term_id)
-    debugValues(impact_assessment, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
-    return value
-
-
 def _run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    landTransformation = _value(impact_assessment, _TRANSFORMATION_TERM_ID)
-    region_factor = get_region_factor(TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity')
+    landTransformation = find_term_match(impact_assessment.get('emissionsResourceUse', []), _TRANSFORMATION_TERM_ID)
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID,
+                node=_TRANSFORMATION_TERM_ID,
+                value=landTransformation.get('value'),
+                coefficient=1)
+
+    region_factor = get_region_factor(
+        TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity', blank_node=landTransformation
+    )
     inputs_value = convert_value_from_cycle(
         impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
-                    landTransformation=landTransformation,
+                    landTransformation=landTransformation.get('value'),
                     region_factor=region_factor,
                     inputs_value=inputs_value)
     value = sum_values([
-        multiply_values([landTransformation, region_factor]),
+        multiply_values([landTransformation.get('value'), region_factor]),
         inputs_value
     ])
     return _indicator(value) if value is not None else None

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsTotalLandUseEffects.py

@@ -45,7 +45,7 @@ def _indicator(value: float):
 def impact_value(impact_assessment: dict, term_id: str):
     impact = find_term_match(impact_assessment.get('impacts', []), term_id)
     value = impact.get('value')
-    value = safe_parse_float(value, None)
+    value = safe_parse_float(value, default=None)
     debugValues(impact, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
     return value
 

hestia_earth/models/chaudharyBrooks2018/utils.py

@@ -13,10 +13,12 @@ def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str,
     return value
 
 
-def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None):
+def get_region_factor(
+    term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None, blank_node: dict = None
+):
     site = get_site(impact_assessment)
     ecoregion = site.get('ecoregion')
-    country_id = get_country_id(impact_assessment)
+    country_id = get_country_id(impact_assessment, blank_node=blank_node)
     site_type = site.get('siteType')
 
     lookup_prefix = 'ecoregion' if ecoregion else 'region' if country_id else None
@@ -33,4 +35,4 @@ def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str,
         term_id, lookup_name, 'ecoregion', ecoregion, site_type
     )
     value = extract_grouped_data(value, group_key) if group_key else value
-    return safe_parse_float(value)
+    return safe_parse_float(value, default=None)

hestia_earth/models/config/Cycle.json

@@ -976,6 +976,17 @@
       },
       "stage": 2
     },
+    {
+      "key": "emissions",
+      "model": "hestia",
+      "value": "default_emissions",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 2
+    },
     [
       {
         "key": "emissions",
@@ -1649,7 +1660,7 @@
     [
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
+        "model": "akagiEtAl2011",
         "value": "ch4ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
@@ -1664,8 +1675,8 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "n2OToAirCropResidueBurningDirect",
+        "model": "akagiEtAl2011",
+        "value": "nh3ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1679,8 +1690,8 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "nh3ToAirCropResidueBurning",
+        "model": "akagiEtAl2011",
+        "value": "noxToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1694,8 +1705,23 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "noxToAirCropResidueBurning",
+        "model": "akagiEtAl2011",
+        "value": "pm25ToAirCropResidueBurning",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "akagiEtAl2011",
+        "value": "so2ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1767,6 +1793,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "n2OToAirCropResidueBurningDirect",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "ipcc2019",

hestia_earth/models/config/ImpactAssessment.json

@@ -56,6 +56,17 @@
       },
       "stage": 1
     },
+    {
+      "key": "emissionsResourceUse",
+      "model": "hestia",
+      "value": "default_resourceUse",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 1
+    },
     [
       {
         "key": "emissionsResourceUse",
@@ -216,6 +227,17 @@
         "stage": 1
       }
     ],
+    {
+      "key": "emissionsResourceUse",
+      "model": "resourceUseNotRelevant",
+      "value": "all",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceLowerTier": true
+      },
+      "stage": 1
+    },
     [
       {
         "key": "impacts",

hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.log import logRequirements, log_as_table
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
 

hestia_earth/models/cycle/completeness/freshForage.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils import is_from_model
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {

hestia_earth/models/cycle/completeness/soilAmendment.py

@@ -29,7 +29,7 @@ def run(cycle: dict):
     soilPh = measurement_value(soilPh_measurement)
 
     soilPh_added = is_from_model(soilPh_measurement)
-    soilPh_above_6_5 = soilPh > 6.5
+    soilPh_above_6_5 = soilPh is not None and soilPh > 6.5
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
                     soilPh_added=soilPh_added,

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -4,8 +4,7 @@ from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.crop import valid_site_type
-from hestia_earth.models.utils.blank_node import get_lookup_value
-from hestia_earth.models.utils.term import get_generic_crop, download_term
+from hestia_earth.models.utils.term import get_lookup_value, get_generic_crop, download_term
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date
 )

hestia_earth/models/cycle/product/economicValueShare.py

@@ -2,7 +2,7 @@ from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cycle import unique_currencies
 from .utils import lookup_share
 from .. import MODEL
@@ -31,8 +31,10 @@ RETURNS = {
 LOOKUPS = {
     "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
     "crop": "global_economic_value_share",
+    "processedFood": "global_economic_value_share",
     "excreta": "global_economic_value_share",
-    "animalProduct": "global_economic_value_share"
+    "animalProduct": "global_economic_value_share",
+    "waste": "global_economic_value_share"
 }
 MODEL_KEY = 'economicValueShare'
 MAX_VALUE = 100.5

hestia_earth/models/cycle/product/price.py

@@ -1,4 +1,4 @@
-from hestia_earth.utils.tools import non_empty_list
+from hestia_earth.utils.tools import list_sum, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.currency import DEFAULT_CURRENCY
@@ -7,7 +7,15 @@ from .. import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{"@type": "Product"}]
+        "products": [{
+            "@type": "Product",
+            "optional": {
+                "revenue": "0"
+            },
+            "none": {
+                "price": ""
+            }
+        }]
     }
 }
 RETURNS = {
@@ -15,6 +23,14 @@ RETURNS = {
         "price": ""
     }]
 }
+LOOKUPS = {
+    "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
+    "crop": "global_economic_value_share",
+    "processedFood": "global_economic_value_share",
+    "excreta": "global_economic_value_share",
+    "animalProduct": "global_economic_value_share",
+    "waste": "global_economic_value_share"
+}
 MODEL_KEY = 'price'
 
 
@@ -24,26 +40,35 @@ def _product(product: dict, value: float):
     return {'currency': DEFAULT_CURRENCY, **product, MODEL_KEY: value}
 
 
-def _should_run_product_by_share_0(cycle: dict, product: dict):
+def _should_run_product(cycle: dict, product: dict):
     term_id = product.get('term', {}).get('@id')
+
+    value = list_sum(product.get('value') or [], default=None)
+    is_yield_0 = value == 0
+
     share = lookup_share(MODEL_KEY, product)
     share_is_0 = share is not None and share == 0
 
+    revenue = product.get('revenue', -1)
+    revenue_is_0 = revenue == 0
+
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by='economicValueShare',
-                    share_is_0=share_is_0)
+                    global_economic_value_share=share,
+                    share_is_0=share_is_0,
+                    revenue=revenue,
+                    revenue_is_0=revenue_is_0,
+                    product_yield=value,
+                    is_yield_0=is_yield_0)
 
-    should_run = all([share_is_0])
+    should_run = any([share_is_0, revenue_is_0, is_yield_0])
     logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY, by='economicValueShare')
     return should_run
 
 
-def _should_run_product(product: dict): return product.get(MODEL_KEY) is None
-
-
 def run(cycle: dict):
-    products = list(filter(_should_run_product, cycle.get('products', [])))
+    products = list(filter(lambda p: p.get(MODEL_KEY) is None, cycle.get('products', [])))
     return non_empty_list([
         (
-            _product(p, 0) if _should_run_product_by_share_0(cycle, p) else None
+            _product(p, 0) if _should_run_product(cycle, p) else None
         ) for p in products
     ])