hestia-earth-models 0.75.2__tar.gz → 0.75.3__tar.gz

{hestia_earth_models-0.75.2/hestia_earth_models.egg-info → hestia_earth_models-0.75.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_models
-Version: 0.75.2
+Version: 0.75.3
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia_earth_models-0.75.2 → hestia_earth_models-0.75.3}/hestia_earth/models/config/Cycle.json

@@ -755,22 +755,24 @@
       "mergeStrategy": "list",
       "stage": 2
     },
-    {
-      "key": "inputs",
-      "model": "ipcc2019",
-      "value": "pastureGrass",
-      "runStrategy": "always",
-      "mergeStrategy": "list",
-      "stage": 2
-    },
-    {
-      "key": "animals",
-      "model": "ipcc2019",
-      "value": "animal.pastureGrass",
-      "runStrategy": "always",
-      "mergeStrategy": "list",
-      "stage": 2
-    },
+    [
+      {
+        "key": "inputs",
+        "model": "ipcc2019",
+        "value": "pastureGrass",
+        "runStrategy": "always",
+        "mergeStrategy": "list",
+        "stage": 2
+      },
+      {
+        "key": "animals",
+        "model": "ipcc2019",
+        "value": "animal.pastureGrass",
+        "runStrategy": "always",
+        "mergeStrategy": "list",
+        "stage": 2
+      }
+    ],
     [
       {
         "key": "products",
@@ -1368,6 +1370,51 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToAirPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToSoilPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToWaterPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
       }
     ],
     [
@@ -1846,6 +1893,111 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "coToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "blackCarbonToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "nmvocToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "pm10ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "pm25ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "tspToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "ch4ToAirFuelCombustion",
+        "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-0.75.3/hestia_earth/models/emepEea2019/blackCarbonToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "blackCarbonToAirFuelCombustionEmepEea2019",
+    "operation": "blackCarbonToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'blackCarbonToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/ch4ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "ch4ToAirFuelCombustionEmepEea2019",
+    "operation": "ch4ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'ch4ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/coToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "coToAirFuelCombustionEmepEea2019",
+    "operation": "coToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'coToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/nmvocToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "nmvocToAirFuelCombustionEmepEea2019",
+    "operation": "nmvocToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'nmvocToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/pm10ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "pm10ToAirFuelCombustionEmepEea2019",
+    "operation": "pm10ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'pm10ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/pm25ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "pm25ToAirFuelCombustionEmepEea2019",
+    "operation": "pm25ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'pm25ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth_models-0.75.3/hestia_earth/models/emepEea2019/tspToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "tspToAirFuelCombustionEmepEea2019",
+    "operation": "tspToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'tspToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

{hestia_earth_models-0.75.2 → hestia_earth_models-0.75.3}/hestia_earth/models/faostat2018/seed.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
             "term.termType": "crop",
             "value": "> 0"
         }],
-        "completeness.other": "False"
+        "completeness.seed": "False"
     }
 }
 LOOKUPS = {
@@ -34,17 +34,18 @@ TERM_ID = 'seed'
 def _run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    value = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID), default=0) * product_value
-    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID), default=0)
-    return value, sd
+    value, sd = [
+        safe_parse_float(get_lookup_value(term, lookup, model=MODEL, term=TERM_ID), default=0)
+        for lookup in LOOKUPS['crop']
+    ]
+    return value * product_value, sd
 
 
 def _run(products: list):
     values = list(map(_run_product, products))
     total_value = list_sum([value for value, _ in values])
     # TODO: we only fill-in sd for single values as the total value is complicated to calculate
-    total_sd = values[0][1] if len(values) == 1 else 0
+    total_sd = values[0][1] if len(values) == 1 else None
     return [
         _new_input(term=TERM_ID, model=MODEL, value=total_value, sd=total_sd)
     ] if total_value > 0 else []
@@ -53,8 +54,8 @@ def _run(products: list):
 def _should_run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    has_all_lookups = all([get_lookup_value(term, col, model=MODEL, term=TERM_ID) for col in LOOKUPS['crop']])
-    return all([has_all_lookups, product_value > 0])
+    has_lookup = get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID)
+    return all([has_lookup, product_value > 0])
 
 
 def _should_run(cycle: dict):

{hestia_earth_models-0.75.2 → hestia_earth_models-0.75.3}/hestia_earth/models/hestia/management.py

@@ -206,7 +206,7 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
 
 
 def _input_gap_fill_term_id(input: dict):
-    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId')
+    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId', skip_debug=True)
 
 
 def _input_value_valid(input: dict):
@@ -242,9 +242,10 @@ def _cycle_has_existing_non_cover_land_cover_nodes(cycle: dict) -> bool:
     # blankNodesGroup = Cover crops lookup, return True, else False
     return any([
         practice for practice in cycle.get("practices", [])
-        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
-        and not any(prop for prop in practice.get("properties", [])
-                    if _is_cover_crop(prop.get("term", {}).get("@id")))
+        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value and not any(
+            prop for prop in practice.get("properties", [])
+            if _is_cover_crop(prop.get("term", {}).get("@id"))
+        )
     ])
 
 

{hestia_earth_models-0.75.2 → hestia_earth_models-0.75.3}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -11,6 +11,7 @@ from hestia_earth.models.utils.property import get_node_property
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from .. import MODEL
 from ..pastureGrass_utils import (
+    has_cycle_inputs_feed,
     practice_input_id,
     should_run_practice,
     calculate_meanDE,
@@ -79,7 +80,11 @@ REQUIREMENTS = {
                         "properties": [{
                             "@type": "Property",
                             "value": "",
-                            "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                            "term.@id": [
+                                "neutralDetergentFibreContent",
+                                "energyContentHigherHeatingValue",
+                                "energyDigestibilityRuminants"
+                            ]
                         }]
                     }
                 }],
@@ -274,10 +279,8 @@ def _should_run(cycle: dict, animals: list, practices: dict):
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in animals])
 
-    no_cycle_inputs_feed = all([not input.get('isAnimalFeed', False) for input in cycle.get('inputs', [])])
-
-    meanDE = calculate_meanDE(practices)
-    meanECHHV = calculate_meanECHHV(practices)
+    meanDE = calculate_meanDE(cycle, practices)
+    meanECHHV = calculate_meanECHHV(cycle, practices)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
@@ -288,7 +291,6 @@ def _should_run(cycle: dict, animals: list, practices: dict):
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
-        no_cycle_inputs_feed,
         all_animals_have_value,
         has_practice_termType_system,
         has_practice_pastureGrass_with_landCover_key,
@@ -302,12 +304,11 @@ def _should_run(cycle: dict, animals: list, practices: dict):
                             term_type_animalFeed_complete=animalFeed_complete,
                             term_type_animalPopulation_complete=animalPopulation_complete,
                             term_type_freshForage_incomplete=freshForage_incomplete,
-                            no_cycle_inputs_feed=no_cycle_inputs_feed,
                             all_animals_have_value=all_animals_have_value,
                             has_practice_termType_system=has_practice_termType_system,
                             has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
-                            grass_MeanDE=calculate_meanDE(practices, term=term_id),
-                            grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                            grass_MeanDE=calculate_meanDE(cycle, practices, term=term_id),
+                            grass_MeanECHHV=calculate_meanECHHV(cycle, practices, term=term_id),
                             grass_REM=REM,
                             grass_REG=REG)
 
@@ -316,8 +317,13 @@ def _should_run(cycle: dict, animals: list, practices: dict):
     return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
-def run(cycle: dict):
+def _run(cycle: dict):
     animals = get_animals_by_period(cycle)
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, animals, practices)
     return list(map(_run_animal(cycle, meanDE, meanECHHV, REM, REG, systems, practices), animals)) if should_run else []
+
+
+def run(cycle: dict):
+    # determines if this model or animal model should run
+    return _run(cycle) if not has_cycle_inputs_feed(cycle) else []

{hestia_earth_models-0.75.2 → hestia_earth_models-0.75.3}/hestia_earth/models/ipcc2019/pastureGrass.py

@@ -10,6 +10,7 @@ from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_t
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from . import MODEL
 from .pastureGrass_utils import (
+    has_cycle_inputs_feed,
     practice_input_id,
     should_run_practice,
     calculate_meanDE,
@@ -56,7 +57,11 @@ REQUIREMENTS = {
                 "properties": [{
                     "@type": "Property",
                     "value": "",
-                    "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                    "term.@id": [
+                        "neutralDetergentFibreContent",
+                        "energyContentHigherHeatingValue",
+                        "energyDigestibilityRuminants"
+                    ]
                 }]
             }
         }],
@@ -227,10 +232,8 @@ def _should_run(cycle: dict, practices: dict):
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
 
-    has_cycle_inputs_feed = any([i.get('isAnimalFeed', False) for i in cycle.get('inputs', [])])
-
-    meanDE = calculate_meanDE(practices)
-    meanECHHV = calculate_meanECHHV(practices)
+    meanDE = calculate_meanDE(cycle, practices)
+    meanECHHV = calculate_meanECHHV(cycle, practices)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
@@ -241,7 +244,6 @@ def _should_run(cycle: dict, practices: dict):
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
-        has_cycle_inputs_feed,
         all_animals_have_value,
         has_practice_termType_system,
         has_practice_pastureGrass_with_landCover_key,
@@ -254,12 +256,11 @@ def _should_run(cycle: dict, practices: dict):
                         term_type_animalFeed_complete=animalFeed_complete,
                         term_type_animalPopulation_complete=animalPopulation_complete,
                         term_type_freshForage_incomplete=freshForage_incomplete,
-                        has_cycle_inputs_feed=has_cycle_inputs_feed,
                         all_animals_have_value=all_animals_have_value,
                         has_practice_termType_system=has_practice_termType_system,
                         has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
-                        grass_MeanDE=calculate_meanDE(practices, term=term_id),
-                        grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                        grass_MeanDE=calculate_meanDE(cycle, practices, term=term_id),
+                        grass_MeanECHHV=calculate_meanECHHV(cycle, practices, term=term_id),
                         grass_REM=REM,
                         grass_REG=REG)
 
@@ -268,9 +269,14 @@ def _should_run(cycle: dict, practices: dict):
     return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
-def run(cycle: dict):
+def _run(cycle: dict):
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, practices)
     return non_empty_list(
         map(_run_practice(cycle, meanDE, meanECHHV, REM, REG, systems), practices)
     ) if should_run else []
+
+
+def run(cycle: dict):
+    # determines if this model or animal model should run
+    return _run(cycle) if has_cycle_inputs_feed(cycle) else []