hestia-earth-models 0.74.2__py3-none-any.whl → 0.74.4__py3-none-any.whl

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -0,0 +1,264 @@
+from functools import reduce
+from typing import NamedTuple
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+
+from hestia_earth.models.utils import hectar_to_square_meter
+from hestia_earth.models.utils.constant import DAYS_IN_YEAR
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import get_product
+from hestia_earth.models.utils.site import get_land_cover_term_id as get_landCover_term_id_from_site_type
+from hestia_earth.models.utils.crop import get_landCover_term_id
+from hestia_earth.schema import CycleFunctionalUnit
+
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "product": {
+            "@type": "Term",
+            "value": "> 0",
+            "optional": {
+                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
+                "economicValueShare": ">= 0"
+            }
+        },
+        "cycle": {
+            "@type": "Cycle",
+            "site": {
+                "@type": "Site",
+                "country": {"@type": "Term", "termType": "region"}
+            },
+            "siteArea": "",
+            "siteDuration": "",
+            "siteUnusedDuration": "",
+            "optional": {
+                "@doc": "When `otherSites` are provided, `otherSitesArea`, `otherSitesDuration` and `otherSitesUnusedDuration` are required",  # noqa: E501
+                "otherSites": [{
+                    "@type": "Site",
+                    "country": {"@type": "Term", "termType": "region"}
+                }],
+                "otherSitesArea": "",
+                "otherSitesDuration": "",
+                "otherSitesUnusedDuration": ""
+            }
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": ""
+    }]
+}
+TERM_ID = 'landOccupationDuringCycle'
+
+
+class SiteData(NamedTuple):
+    id: str  # site.@id
+    area: float
+    duration: float
+    unused_duration: float
+    land_cover_id: str
+    country_id: str
+
+
+def _indicator(term_id: str, value: float, land_cover_id: str, country_id: str):
+    indicator = _new_indicator(
+        term_id, model=MODEL, land_cover_id=land_cover_id, country_id=country_id
+    )
+    indicator['value'] = round(value, 6)
+    return indicator
+
+
+def _calc_land_occupation_m2_per_ha(
+    site_area: float, site_duration: float, site_unused_duration: float
+) -> float:
+    """
+    Parameters
+    ----------
+    site_area : float
+        Area of the site in hectares.
+    site_duration : float
+        Site duration in days.
+    site_unused_duration : float
+        Site unused duration in days.
+
+    Returns
+    -------
+    float
+    """
+    return hectar_to_square_meter(site_area) * (site_duration + site_unused_duration) / DAYS_IN_YEAR
+
+
+def _calc_land_occupation_m2_per_kg(
+    yield_: float, economic_value_share: float, land_occupation_m2_per_ha: float,
+) -> float:
+    """
+    Parameters
+    ----------
+    yield_ : float
+        Product yield in product units.
+    economic_value_share : float
+        Economic value share of the product in % (0-100).
+    land_occupation_m2_per_ha : float
+        Land occupation in m2 ha-1.
+
+    Returns
+    -------
+    float
+    """
+    return land_occupation_m2_per_ha * economic_value_share * 0.01 / yield_
+
+
+_CYCLE_KEYS = (
+    "site", "siteArea", "siteDuration", "siteUnusedDuration"
+)
+
+_CYCLE_KEY_MAPPING = {
+    field: field.replace("site", "otherSites", 1) for field in _CYCLE_KEYS
+}
+
+
+def _build_inventory(cycle: dict, product: dict):
+    product_land_cover_id = get_landCover_term_id(product.get("term", {}), skip_debug=True)
+
+    cycle_data = {
+        key: [value] + cycle.get(otherSites_key, []) for key, otherSites_key in _CYCLE_KEY_MAPPING.items()
+        if (value := cycle.get(key))
+    }
+
+    n_sites = len(cycle_data.get("site", []))
+    should_build_inventory = n_sites > 0 and all([
+        len(cycle_data.get(key, [])) == n_sites for key in _CYCLE_KEYS[1:]
+    ])
+
+    inventory = [
+        SiteData(
+            id=site.get("@id"),
+            area=cycle_data["siteArea"][i],
+            duration=cycle_data["siteDuration"][i],
+            unused_duration=cycle_data["siteUnusedDuration"][i],
+            country_id=site.get("country", {}).get("@id"),
+            land_cover_id=product_land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType", {}))
+        ) for i, site in enumerate(cycle_data.get("site", []))
+    ] if should_build_inventory else []
+
+    logs = {
+        "n_sites": n_sites
+    }
+
+    return inventory, logs
+
+
+def _should_run_site_data(site_data: SiteData) -> bool:
+    return all([
+        site_data.area >= 0,
+        site_data.duration >= 0,
+        site_data.unused_duration >= 0,
+        site_data.land_cover_id,
+        site_data.country_id
+    ])
+
+
+def _format_float(value: float, unit: str = "") -> str:
+    return " ".join(
+        string for string in [f"{value:.3g}", unit] if string
+    ) if value else "None"
+
+
+_INVALID_CHARS = {"_", ":", ",", "="}
+_REPLACEMENT_CHAR = "-"
+
+
+def _format_str(value: str) -> str:
+    """Format a string for logging in a table. Remove all characters used to render the table on the front end."""
+    return reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
+
+
+def _format_inventory(inventory: list[SiteData]) -> str:
+    return log_as_table(
+        {
+            "@id": _format_str(site_data.id),
+            "site-area": _format_float(site_data.area, "ha"),
+            "site-duration": _format_float(site_data.duration, "days"),
+            "site-unused-duration": _format_float(site_data.unused_duration, "days"),
+            "land-cover-id": _format_str(site_data.land_cover_id),
+            "country-id": _format_str(site_data.country_id)
+        } for site_data in inventory
+    ) if inventory else "None"
+
+
+def _should_run(impact_assessment: dict):
+
+    cycle = impact_assessment.get("cycle")
+    functional_unit = cycle.get("functionalUnit")
+
+    product = get_product(impact_assessment)
+    yield_ = sum(product.get("value", []))
+    economic_value_share = (
+        100 if functional_unit == CycleFunctionalUnit.RELATIVE.value
+        else product.get("economicValueShare")
+    )
+
+    inventory, logs = _build_inventory(cycle, product)
+
+    valid_inventory = inventory and all(_should_run_site_data(site_data) for site_data in inventory)
+
+    logRequirements(
+        impact_assessment,
+        model=MODEL,
+        term=TERM_ID,
+        functional_unit=functional_unit,
+        yield_=_format_float(yield_, product.get("term", {}).get("units")),
+        economic_value_share=_format_float(economic_value_share, "pct"),
+        site_inventory=_format_inventory(inventory),
+        valid_inventory=valid_inventory,
+        **logs
+    )
+
+    should_run = all([
+        yield_ > 0,
+        (
+            economic_value_share is not None
+            and economic_value_share >= 0
+        ),
+        valid_inventory
+    ])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return should_run, yield_, economic_value_share, inventory
+
+
+def _run(
+    yield_: float,
+    economic_value_share: float,
+    inventory: list[SiteData]
+) -> list[dict]:
+
+    def calc_occupation_by_group(result: dict, site_data: SiteData):
+        """Calculate the land occupation of a site and sum it with matching landCover/country groups."""
+
+        land_occupation_m2_per_ha = _calc_land_occupation_m2_per_ha(
+            site_data.area, site_data.duration, site_data.unused_duration
+        )
+
+        land_occupation_m2_per_kg = _calc_land_occupation_m2_per_kg(
+            yield_, economic_value_share, land_occupation_m2_per_ha
+        )
+
+        key = (site_data.land_cover_id, site_data.country_id)
+        return result | {key: result.get(key, 0) + land_occupation_m2_per_kg}
+
+    land_occupation_by_group = reduce(calc_occupation_by_group, inventory, {})
+
+    return [
+        _indicator(TERM_ID, value, land_cover_id, country_id)
+        for (land_cover_id, country_id), value in land_occupation_by_group.items()
+    ]
+
+
+def run(impact_assessment: dict):
+    should_run, yield_, economic_value_share, inventory = _should_run(impact_assessment)
+    return _run(yield_, economic_value_share, inventory) if should_run else []

hestia_earth/models/hestia/management.py

@@ -75,7 +75,8 @@ LOOKUPS = {
     "organicFertiliser": "inputGapFillManagementTermId",
     "soilAmendment": "inputGapFillManagementTermId",
     "landUseManagement": "GAP_FILL_TO_MANAGEMENT",
-    "property": "GAP_FILL_TO_MANAGEMENT"
+    "property": "GAP_FILL_TO_MANAGEMENT",
+    "landCover": "sumIs100Group"
 }
 MODEL_KEY = 'management'
 
@@ -241,9 +242,7 @@ def _cycle_has_existing_non_cover_land_cover_nodes(cycle: dict) -> bool:
     ])
 
 
-def _run_from_siteType(site: dict, cycle: dict):
-    site_type = site.get('siteType')
-    site_type_id = get_landCover_term_id_from_site_type(site_type)
+def _run_from_siteType(cycle: dict, site_type_id: str):
     start_date = cycle.get('startDate') or _gap_filled_start_date(
         cycle=cycle,
         end_date=cycle.get('endDate'),
@@ -261,15 +260,61 @@ def _run_from_siteType(site: dict, cycle: dict):
     }] if should_run else []
 
 
-def _should_run_practice(practice: dict):
+def _node_with_gap_filled_dates(node: dict, cycle: dict, site_type_id: str) -> dict:
+    return node | {
+        "endDate": node.get("endDate") or cycle.get("endDate"),
+        "startDate": node.get("startDate") or cycle.get('startDate') or _gap_filled_start_date(
+            cycle=cycle,
+            end_date=cycle.get('endDate'),
+            land_cover_id=site_type_id
+        ).get("startDate"),
+    }
+
+
+def _dates_overlap(target_practice: dict, node: dict, cycle: dict, site_type_id: str) -> bool:
+    target_practice = _node_with_gap_filled_dates(node=target_practice, cycle=cycle, site_type_id=site_type_id)
+    node = _node_with_gap_filled_dates(node=node, cycle=cycle, site_type_id=site_type_id)
+    return all([
+        node["startDate"],
+        node["endDate"],
+        target_practice["startDate"],
+        target_practice["endDate"],
+        (
+            node["startDate"] <= target_practice["startDate"] <= node["endDate"] or
+            node["startDate"] < target_practice["endDate"] <= node["endDate"]
+        )
+    ])
+
+
+def _should_run_practice(management_nodes: list, cycle: dict, site_type_id: str):
     """
     Include only landUseManagement practices where GAP_FILL_TO_MANAGEMENT = True
     """
-    term = practice.get('term', {})
-    return term.get('termType') != TermTermType.LANDUSEMANAGEMENT.value or _should_gap_fill(term)
+    landCover_management_nodes = [
+        _node_with_gap_filled_dates(node=node, cycle=cycle, site_type_id=site_type_id) | {
+            'sumIs100Group': get_lookup_value(node.get("term", {}), 'sumIs100Group', skip_debug=True, model=MODEL)
+        }
+        for node in filter_list_term_type(management_nodes, TermTermType.LANDCOVER)
+    ]
+
+    def run(practice: dict):
+        term = practice.get('term', {})
+        target_group = get_lookup_value(practice.get("term", {}), 'sumIs100Group', skip_debug=True, model=MODEL)
+        has_other_land_cover_in_same_group = next((
+            True for node in landCover_management_nodes
+            if (
+                node['sumIs100Group'] == target_group and
+                _dates_overlap(target_practice=practice, node=node, cycle=cycle, site_type_id=site_type_id)
+            )
+        ), None) is not None
+        return (
+            (term.get('termType') != TermTermType.LANDUSEMANAGEMENT.value or _should_gap_fill(term)) and
+            not has_other_land_cover_in_same_group
+        )
+    return run
 
 
-def _run_from_practices(cycle: dict):
+def _run_from_practices(site: dict, cycle: dict, site_type_id: str):
     practices = [
         _extract_node_value(
             _include_with_date_gap_fill(
@@ -283,13 +328,18 @@ def _run_from_practices(cycle: dict):
             completeness_mapping=_PRACTICES_COMPLETENESS_MAPPING
         )
     ]
-    return list(map(_map_to_value, filter(_should_run_practice, practices)))
+    management_nodes = site.get("management", [])
+    return list(map(_map_to_value, filter(
+        _should_run_practice(management_nodes=management_nodes, cycle=cycle, site_type_id=site_type_id), practices
+    )))
 
 
 def _run_cycle(site: dict, cycle: dict):
     inputs = _run_from_inputs(cycle)
-    site_types = _run_from_siteType(site=site, cycle=cycle)
-    practices = _run_from_practices(cycle)
+    site_type = site.get('siteType')
+    site_type_id = get_landCover_term_id_from_site_type(site_type)
+    site_types = _run_from_siteType(cycle=cycle, site_type_id=site_type_id)
+    practices = _run_from_practices(site=site, cycle=cycle, site_type_id=site_type_id)
     return [
         node | {'cycle-id': cycle.get('@id')}
         for node in inputs + site_types + practices

hestia_earth/models/ipcc2006/aboveGroundCropResidueTotal.py

@@ -7,6 +7,7 @@ from hestia_earth.models.utils.property import get_node_property
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.crop import get_crop_lookup_value
+from hestia_earth.models.utils.cropResidue import sum_above_ground_crop_residue
 from . import MODEL
 
 REQUIREMENTS = {
@@ -58,11 +59,6 @@ def _get_value_dm(product: dict, dm_percent: float):
     ]) else (yield_dm * slope + intercept * 1000)
 
 
-def _run(product: dict, dm_property: dict):
-    value = _get_value_dm(product, safe_parse_float(dm_property.get('value'), default=None))
-    return [_product(value)] if value is not None else []
-
-
 def _should_run_product(product: dict):
     term_id = product.get('term', {}).get('@id')
     value = list_sum(product.get('value', [0]))
@@ -79,17 +75,30 @@ def _should_run(cycle: dict):
     dm_property = get_node_property(products[0], PROPERTY_KEY) if single_crop_product else {}
     term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
 
+    dm_value = safe_parse_float(dm_property.get('value'), default=None)
+    value = _get_value_dm(products[0], dm_value) if single_crop_product else None
+
+    above_ground_crop_residue = sum_above_ground_crop_residue(cycle)
+    is_value_below_sum_above_ground_crop_residue = not not value and value >= above_ground_crop_residue
+
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     single_crop_product=single_crop_product,
                     nb_products=len(products),
                     dryMatter=dm_property.get('value'),
-                    term_type_cropResidue_incomplete=term_type_incomplete)
-
-    should_run = all([term_type_incomplete, single_crop_product, dm_property])
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    value=value,
+                    is_value_below_sum_above_ground_crop_residue=is_value_below_sum_above_ground_crop_residue)
+
+    should_run = all([
+        term_type_incomplete,
+        single_crop_product,
+        value is not None,
+        is_value_below_sum_above_ground_crop_residue
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, products, dm_property
+    return should_run, value
 
 
 def run(cycle: dict):
-    should_run, products, dm_property = _should_run(cycle)
-    return _run(products[0], dm_property) if should_run else []
+    should_run, value = _should_run(cycle)
+    return [_product(value)] if should_run else []

hestia_earth/models/ipcc2019/aboveGroundCropResidueTotal.py

@@ -2,10 +2,11 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.property import get_node_property
+from hestia_earth.models.utils.cropResidue import sum_above_ground_crop_residue
 from .utils import get_yield_dm
 from . import MODEL
 
@@ -43,10 +44,14 @@ def _product(value: float):
 def _product_value(product: dict):
     term = product.get('term', {})
     term_id = product.get('term', {}).get('@id')
-    value = list_sum(product.get('value'))
-    dm = get_node_property(product, PROPERTY_KEY).get('value', 0)
-    yield_dm = get_yield_dm(TERM_ID, term) or 0
-    total = value * dm / 100 * yield_dm
+    value = list_sum(product.get('value'), default=None)
+    dm = get_node_property(product, PROPERTY_KEY).get('value')
+    yield_dm = get_yield_dm(TERM_ID, term)
+    total = value * dm / 100 * yield_dm if all([
+        value is not None,
+        dm is not None,
+        yield_dm is not None,
+    ]) else None
     return {
         'id': term_id,
         'value': value,
@@ -56,38 +61,42 @@ def _product_value(product: dict):
     }
 
 
-def _run(cycle: dict, products: list):
-    values = list(map(_product_value, products))
-    debugValues(cycle, model=MODEL, term=TERM_ID,
-                details=log_as_table(values))
-    value = sum([value.get('total', 0) for value in values])
-    return [_product(value)]
-
-
-def _should_run_product(product: dict):
-    term = product.get('term', {})
-    value = list_sum(product.get('value', [0]))
-    prop = get_node_property(product, PROPERTY_KEY).get('value')
-    yield_dm = get_yield_dm(TERM_ID, term)
-    return all([value > 0, prop, yield_dm is not None])
+def _should_run_product(value: dict): return value.get('total') is not None
 
 
 def _should_run(cycle: dict):
+    term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
+
     # filter crop products with matching data in the lookup
     products = filter_list_term_type(cycle.get('products', []), [TermTermType.CROP, TermTermType.FORAGE])
-    products = list(filter(_should_run_product, products))
-    has_crop_forage_products = len(products) > 0
-    term_type_incomplete = _is_term_type_incomplete(cycle, TERM_ID)
+    values = list(map(_product_value, products))
+    valid_values = list(filter(_should_run_product, values))
+
+    has_crop_forage_products = len(valid_values) > 0
+
+    value = list_sum([(value.get('total') or 0) for value in valid_values], default=None)
+
+    above_ground_crop_residue = sum_above_ground_crop_residue(cycle)
+    is_value_below_sum_above_ground_crop_residue = not not value and value >= above_ground_crop_residue
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     has_crop_forage_products_with_dryMatter=has_crop_forage_products,
-                    term_type_cropResidue_incomplete=term_type_incomplete)
-
-    should_run = all([term_type_incomplete, has_crop_forage_products])
+                    term_type_cropResidue_incomplete=term_type_incomplete,
+                    sum_above_ground_crop_residue=above_ground_crop_residue,
+                    value=value,
+                    is_value_below_sum_above_ground_crop_residue=is_value_below_sum_above_ground_crop_residue,
+                    details=log_as_table(values))
+
+    should_run = all([
+        term_type_incomplete,
+        has_crop_forage_products,
+        value is not None,
+        is_value_below_sum_above_ground_crop_residue
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, products
+    return should_run, value
 
 
 def run(cycle: dict):
-    should_run, products = _should_run(cycle)
-    return _run(cycle, products) if should_run else []
+    should_run, value = _should_run(cycle)
+    return [_product(value)] if should_run else []

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -188,7 +188,9 @@ def calculate_NEwool(cycle: dict, animal: dict, products: list, total_weight: fl
     return total_energy * animal_weight/total_weight
 
 
-def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, REM: float, REG: float, NEwool: float):
+def _run_practice(
+    cycle: dict, animal: dict, values: dict, meanDE: float, meanECHHV: float, REM: float, REG: float, NEwool: float
+):
     NEm_feed, NEg_feed, log_feed = calculate_NEfeed(animal)
 
     def run(practice: dict):
@@ -225,7 +227,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
         ])
         has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
-        logRequirements(animal, model=MODEL, term=input_term_id, animalId=animal.get('animalId'), model_key=MODEL_KEY,
+        logRequirements(cycle, model=MODEL, term=input_term_id, animalId=animal.get('animalId'), model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),
                         has_positive_feed_values=has_positive_feed_values,
                         animal_logs=logs,
@@ -233,7 +235,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
                         animal_properties=animal_properties)
 
         should_run = all([has_positive_feed_values])
-        logShouldRun(animal, MODEL, input_term_id, should_run, animalId=animal.get('animalId'), model_key=MODEL_KEY)
+        logShouldRun(cycle, MODEL, input_term_id, should_run, animalId=animal.get('animalId'), model_key=MODEL_KEY)
 
         return _input(input_term_id, value) if should_run else None
 
@@ -254,7 +256,7 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG: f
         animal_values = get_animal_values(cycle, animal, systems)
 
         inputs = non_empty_list(map(
-            _run_practice(animal, animal_values, meanDE, meanECHHV, REM, REG, NEwool),
+            _run_practice(cycle, animal, animal_values, meanDE, meanECHHV, REM, REG, NEwool),
             practices
         ))
         return animal | {