hestia-earth-models 0.62.4__py3-none-any.whl → 0.62.6__py3-none-any.whl

hestia_earth/models/cycle/croppingIntensity.py

@@ -0,0 +1,57 @@
+from hestia_earth.schema import CycleStartDateDefinition
+from hestia_earth.utils.model import find_primary_product
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.crop import is_plantation
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "> 0",
+        "startDateDefinition": "harvest of previous crop"
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "crop": "isPlantation"
+}
+TERM_ID = 'croppingIntensity'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID)
+    practice['value'] = [round(value, 7)]
+    return practice
+
+
+def _run(cycle: dict):
+    cycleDuration = cycle.get('cycleDuration')
+    return [_practice(cycleDuration / 365)]
+
+
+def _should_run(cycle: dict):
+    product = find_primary_product(cycle) or {}
+    not_plantation = not is_plantation(MODEL, TERM_ID, product.get('term', {}).get('@id'))
+
+    cycleDuration = cycle.get('cycleDuration', 0)
+    has_cycleDuration = cycleDuration > 0
+    startDateDefinition = cycle.get('startDateDefinition')
+    harvest_previous_crop = CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
+    is_harvest_previous_crop = startDateDefinition == harvest_previous_crop
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    not_plantation=not_plantation,
+                    cycleDuration=cycleDuration,
+                    is_harvest_previous_crop=is_harvest_previous_crop)
+
+    should_run = all([not_plantation, has_cycleDuration, is_harvest_previous_crop])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

hestia_earth/models/cycle/longFallowRatio.py

@@ -0,0 +1,52 @@
+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
+from hestia_earth.models.utils.practice import _new_practice
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "practices": [
+            {"@type": "Practice", "value": "> 0", "term.@id": "longFallowPeriod"},
+            {"@type": "Practice", "value": "> 0", "term.@id": "rotationDuration"}
+        ]
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+TERM_ID = 'longFallowRatio'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID)
+    practice['value'] = [round(value, 7)]
+    return practice
+
+
+def _run(longFallowPeriod: float, rotationDuration: float):
+    value = rotationDuration / (rotationDuration - longFallowPeriod)
+    return [_practice(value)]
+
+
+def _should_run(cycle: dict):
+    practices = cycle.get('practices', [])
+
+    longFallowPeriod = list_sum(find_term_match(practices, 'longFallowPeriod', {}).get('value', 0), 0)
+    rotationDuration = list_sum(find_term_match(practices, 'rotationDuration', {}).get('value', 0), 0)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    longFallowPeriod=longFallowPeriod,
+                    rotationDuration=rotationDuration)
+
+    should_run = all([longFallowPeriod > 0, rotationDuration > 0])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, longFallowPeriod, rotationDuration
+
+
+def run(cycle: dict):
+    should_run, longFallowPeriod, rotationDuration = _should_run(cycle)
+    return _run(longFallowPeriod, rotationDuration) if should_run else []

hestia_earth/models/cycle/siteDuration.py

@@ -3,7 +3,12 @@ Site duration
 
 This model calculates the `siteDuration` on the `Cycle` to the same value as `cycleDuration`
 when only a single `Site` is present.
+
+Note: on `crop` production cycles, the model will only run if `startDateDefinition` = `harvest of previous crop`.
 """
+from hestia_earth.schema import TermTermType, CycleStartDateDefinition
+from hestia_earth.utils.model import find_primary_product
+
 from hestia_earth.models.log import logRequirements, logShouldRun
 from . import MODEL
 
@@ -12,11 +17,19 @@ REQUIREMENTS = {
         "cycleDuration": "> 0",
         "none": {
             "otherSites": ""
+        },
+        "optional": {
+            "products": {
+                "@type": "Product",
+                "primary": "True",
+                "term.termType": "crop"
+            },
+            "startDateDefinition": ""
         }
     }
 }
 RETURNS = {
-    "a `number` or `None` if the `Cycle` has multiple `Sites`": ""
+    "the duration as a `number`": ""
 }
 MODEL_KEY = 'siteDuration'
 
@@ -28,11 +41,18 @@ def _should_run(cycle: dict):
     cycleDuration = cycle.get('cycleDuration', 0)
     has_other_sites = len(cycle.get('otherSites', [])) == 0
 
+    product = find_primary_product(cycle)
+    is_primary_crop_product = (product or {}).get('term', {}).get('termType') == TermTermType.CROP.value
+    harvest_previous_crop = CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
+    is_harvest_previous_crop = cycle.get('startDateDefinition') == harvest_previous_crop
+
     logRequirements(cycle, model=MODEL, key=MODEL_KEY,
                     cycleDuration=cycleDuration,
-                    has_other_sites=has_other_sites)
+                    has_other_sites=has_other_sites,
+                    is_primary_crop_product=is_primary_crop_product,
+                    is_harvest_previous_crop=is_harvest_previous_crop)
 
-    should_run = all([cycleDuration > 0, has_other_sites])
+    should_run = all([cycleDuration > 0, has_other_sites, not is_primary_crop_product or is_harvest_previous_crop])
     logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
     return should_run
 

hestia_earth/models/cycle/siteUnusedDuration.py

@@ -0,0 +1,64 @@
+"""
+Site Unused Duration
+
+This model sets the [Cycle siteUnusedDuration](https://hestia.earth/schema/Cycle#siteUnusedDuration) based on
+the `siteDuration` and the `longFallowRatio` practice.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.site import valid_site_type
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "siteType": ["cropland", "glass and high accessible cover"]
+        },
+        "siteDuration": "> 0",
+        "practices": [{"@type": "Practice", "value": "> 0", "term.@id": "longFallowRatio"}]
+    }
+}
+RETURNS = {
+    "The siteUnusedDuration as a number": ""
+}
+MODEL_KEY = 'siteUnusedDuration'
+VALID_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+]
+
+
+def _run(cycle: dict, longFallowRatio: float):
+    siteDuration = cycle.get('siteDuration')
+    return siteDuration * (longFallowRatio - 1)
+
+
+def _should_run(cycle: dict):
+    site_type_valid = valid_site_type(cycle.get('site'), site_types=VALID_SITE_TYPES)
+
+    siteDuration = cycle.get('siteDuration', 0)
+
+    practices = cycle.get('practices', [])
+    longFallowRatio = list_sum(next((
+        p for p in practices if all([
+            p.get('term', {}).get('@id') == 'longFallowRatio',
+            p.get('site') is None or p.get('site', {}).get('@id') == cycle.get('site', {}).get('@id')
+        ])
+    ), {}).get('value'), None)
+
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY,
+                    site_type_valid=site_type_valid,
+                    siteDuration=siteDuration,
+                    longFallowRatio=longFallowRatio)
+
+    should_run = all([site_type_valid, siteDuration > 0, longFallowRatio is not None])
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
+    return should_run, longFallowRatio
+
+
+def run(cycle: dict):
+    should_run, longFallowRatio = _should_run(cycle)
+    return _run(cycle, longFallowRatio) if should_run else None

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/emepEea2019/nh3ToAirExcreta.py

@@ -7,9 +7,9 @@ from hestia_earth.models.log import logRequirements, debugMissingLookup, logShou
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.completeness import _is_term_type_complete
-from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import total_excreta_tan
 from . import MODEL
+from .utils import _emission
 
 REQUIREMENTS = {
     "Cycle": {
@@ -40,13 +40,6 @@ TERM_ID = 'nh3ToAirExcreta'
 TIER = EmissionMethodTier.TIER_2.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _get_nh3_factor(term_id: str, input: dict):
     input_term_id = input.get('term', {}).get('@id')
     lookup_name = f"{list(LOOKUPS.keys())[0]}.csv"
@@ -57,7 +50,7 @@ def _get_nh3_factor(term_id: str, input: dict):
 
 def _run(excreta_EF_product: float):
     value = excreta_EF_product * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -10,7 +10,7 @@ from hestia_earth.models.utils.inorganicFertiliser import (
     get_NH3_emission_factor, get_terms, get_term_lookup, get_country_breakdown, get_cycle_inputs
 )
 from hestia_earth.models.utils.constant import Units
-from hestia_earth.models.utils.emission import _new_emission
+from .utils import _emission
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
 from . import MODEL
 
@@ -58,13 +58,6 @@ TIER = EmissionMethodTier.TIER_2.value
 UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _input_with_factor(soilPh: float, temperature: float):
     def get_value(input: dict):
         term_id = input.get('term', {}).get('@id')
@@ -151,4 +144,4 @@ def _should_run(cycle: dict):
 def run(cycle: dict):
     should_run, N_inputs_with_factor = _should_run(cycle)
     value = list_sum([i.get('value') * i.get('factor') for i in N_inputs_with_factor]) if should_run else None
-    return [_emission(value)] if value is not None else []
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)] if value is not None else []

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/emepEea2019/pm10ToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "pm10ToAirEea2019",
+    "operation": "pm10ToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'pm10ToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

hestia_earth/models/emepEea2019/pm25ToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "pm25ToAirEea2019",
+    "operation": "pm25ToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'pm25ToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/emepEea2019/tspToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "tspToAirEea2019",
+    "operation": "tspToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'tspToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

hestia_earth/models/emepEea2019/utils.py

@@ -1,13 +1,23 @@
-from hestia_earth.schema import TermTermType
+from hestia_earth.schema import TermTermType, SiteSiteType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
 from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.cycle import get_animals_by_period
+from hestia_earth.models.utils.emission import _new_emission
 from . import MODEL
 
 
+def _emission(value: float, tier: str, term_id: str):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = tier
+    return emission
+
+
 def _get_fuel_input_value(term_id: str, lookup_col: str):
     def get_value(input: dict):
         input_term = input.get('term', {})
@@ -33,3 +43,52 @@ def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
         len(values) == 0,
         _is_term_type_complete(cycle, 'electricityFuel')
     ]) else values
+
+
+def _get_emissions_factor(animal: dict, lookup_col: str) -> float:
+    return safe_parse_float(
+        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", ""))
+    )
+
+
+def _duration_in_housing(cycle: dict) -> int:
+    other_sites = cycle.get("otherSites", [])
+    other_durations = cycle.get("otherSitesDuration", [])
+    return list_sum([
+        cycle.get("siteDuration", cycle.get("cycleDuration", 0))
+        if cycle.get("site", {}).get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value else 0
+    ] + ([
+        other_durations[x]
+        for x in range(len(other_sites))
+        if other_sites[x].get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value
+    ] if len(other_sites) == len(other_durations) else []))
+
+
+def get_live_animal_emission_value(animals: list[dict], duration: float, lookup_col: str) -> float:
+    return list_sum([
+        animal.get('value') * _get_emissions_factor(animal=animal, lookup_col=lookup_col)
+        for animal in animals
+    ]) * duration / 365
+
+
+def should_run_animal(cycle: dict, model: str, term: str, tier: str) -> tuple[list, bool]:
+    term_type_animalPopulation_complete = _is_term_type_complete(cycle=cycle, term="animalPopulation")
+
+    # models will be set as not relevant is primary `siteType` does not match, so check only `otherSites`.
+
+    total_duration = _duration_in_housing(cycle)
+
+    has_other_sites_and_duration = len(cycle.get("otherSites", [])) == len(cycle.get("otherSitesDuration", []))
+
+    animals = get_animals_by_period(cycle)
+    has_animals = len(animals) > 0
+
+    logRequirements(cycle, model=model, term=term,
+                    term_type_animalPopulation_complete=term_type_animalPopulation_complete,
+                    has_animals=has_animals,
+                    has_other_sites_and_duration=has_other_sites_and_duration,
+                    number_of_days_in_animal_housing=total_duration)
+
+    should_run = all([term_type_animalPopulation_complete, has_animals, has_other_sites_and_duration])
+    logShouldRun(cycle, model, term, should_run, methodTier=tier)
+    return should_run, animals, total_duration