flood-adapt 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

flood_adapt/__init__.py

@@ -1,6 +1,5 @@
 # has to be here at the start to avoid circular imports
-
-__version__ = "1.0.6"
+__version__ = "1.1.1"
 
 from flood_adapt import adapter, database_builder, dbs_classes, objects
 from flood_adapt.config.config import Settings

flood_adapt/adapter/fiat_adapter.py

@@ -106,7 +106,7 @@ class FiatAdapter(IImpactAdapter):
         self.config_base_path = config_base_path
         self.exe_path = exe_path
         self.delete_crashed_runs = delete_crashed_runs
-        self._model_root = str(model_root.resolve())
+        self._model_root = model_root.resolve().as_posix()
         self.fiat_columns = _FIAT_COLUMNS
         self.impact_columns = _IMPACT_COLUMNS  # columns of FA impact output
 
@@ -135,7 +135,7 @@ class FiatAdapter(IImpactAdapter):
     def read(self, path: Path) -> None:
         """Read the fiat model from the current model root."""
         if Path(self.model.root).resolve() != Path(path).resolve():
-            self.model.set_root(root=str(path), mode="r")
+            self.model.set_root(root=path.as_posix(), mode="r")
         self.model.read()
 
     def write(self, path_out: Union[str, os.PathLike], overwrite: bool = True) -> None:
@@ -148,7 +148,7 @@ class FiatAdapter(IImpactAdapter):
 
         write_mode = "w+" if overwrite else "w"
         with cd(path_out):
-            self.model.set_root(root=str(path_out), mode=write_mode)
+            self.model.set_root(root=path_out.as_posix(), mode=write_mode)
             self.model.write()
 
     def close_files(self):
@@ -717,8 +717,8 @@ class FiatAdapter(IImpactAdapter):
         conversion_factor = wl_current_units.convert(self.model.exposure.unit)
 
         self.model.setup_hazard(
-            map_fn=map_fn,
-            map_type=map_type,
+            map_fn=[Path(p).as_posix() for p in map_fn],
+            map_type=map_type.value,
             rp=None,
             crs=None,  # change this in new version (maybe to str(floodmap.crs.split(':')[1]))
             nodata=-999,  # change this in new version
@@ -1160,7 +1160,7 @@ class FiatAdapter(IImpactAdapter):
                 object_dir=ObjectDir.measure,
                 obj_name=measure.name,
                 path=measure.polygon_file,
-            )
+            ).as_posix()
         else:
             polygon_file = None
 
@@ -1171,7 +1171,7 @@ class FiatAdapter(IImpactAdapter):
             non_building_names=self.config.non_building_names,
             aggregation=measure.aggregation_area_type,
             aggregation_area_name=measure.aggregation_area_name,
-            polygon_file=str(polygon_file),
+            polygon_file=polygon_file,
         )
 
         return ids
@@ -1365,6 +1365,11 @@ class FiatAdapter(IImpactAdapter):
             True,
             True,
         ]
+        metrics_new.loc["Show In Metrics Map", ["EW", "EWEAD", "EWCEAD"]] = [
+            False,
+            True,
+            False,
+        ]
         metrics_new.loc["Long Name", ["EW", "EWEAD", "EWCEAD"]] = [
             "Equity weight",
             "Equity weighted  expected annual damage",

flood_adapt/adapter/sfincs_adapter.py

@@ -121,7 +121,7 @@ class SfincsAdapter(IHazardAdapter):
         self.settings = self.database.site.sfincs
         self.units = self.database.site.gui.units
         self._model = HydromtSfincsModel(
-            root=str(model_root.resolve()),
+            root=model_root.resolve().as_posix(),
             mode="r",
             logger=self._setup_sfincs_logger(model_root),
         )
@@ -130,7 +130,7 @@ class SfincsAdapter(IHazardAdapter):
     def read(self, path: Path):
         """Read the sfincs model from the current model root."""
         if Path(self._model.root).resolve() != Path(path).resolve():
-            self._model.set_root(root=str(path), mode="r")
+            self._model.set_root(root=path.as_posix(), mode="r")
         self._model.read()
 
     def write(self, path_out: Union[str, os.PathLike], overwrite: bool = True):
@@ -147,7 +147,7 @@ class SfincsAdapter(IHazardAdapter):
 
         write_mode = "w+" if overwrite else "w"
         with cd(path_out):
-            self._model.set_root(root=str(path_out), mode=write_mode)
+            self._model.set_root(root=path_out.as_posix(), mode=write_mode)
             self._model.write()
 
     def close_files(self):
@@ -190,10 +190,16 @@ class SfincsAdapter(IHazardAdapter):
             True if the model ran successfully, False otherwise.
 
         """
+        sfincs_bin = Settings().sfincs_bin_path
+        if not sfincs_bin or not sfincs_bin.exists():
+            raise FileNotFoundError(
+                f"SFINCS binary not found at {sfincs_bin}. Please check your settings."
+            )
+
         with cd(path):
             logger.info(f"Running SFINCS in {path}")
             process = subprocess.run(
-                str(Settings().sfincs_bin_path),
+                sfincs_bin.as_posix(),
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
@@ -563,7 +569,7 @@ class SfincsAdapter(IHazardAdapter):
                 zsmax=floodmap_conversion * zsmax,
                 dep=dem_conversion * dem,
                 hmin=0.01,
-                floodmap_fn=str(floodmap_fn),
+                floodmap_fn=floodmap_fn.as_posix(),
             )
 
     def write_water_level_map(
@@ -803,7 +809,7 @@ class SfincsAdapter(IHazardAdapter):
                     zsmax=floodmap_conversion * zsmax,
                     dep=dem_conversion * dem,
                     hmin=0.01,
-                    floodmap_fn=str(floodmap_fn),
+                    floodmap_fn=floodmap_fn.as_posix(),
                 )
 
     ######################################
@@ -1304,14 +1310,10 @@ class SfincsAdapter(IHazardAdapter):
             )
             return
 
-        model_rivers = self._read_river_locations()
-        if model_rivers.empty:
-            logger.warning(
-                "Cannot add discharge forcing: No rivers defined in the sfincs model."
-            )
-            return
         logger.info(f"Setting discharge forcing for river: {discharge.river.name}")
+
         time_frame = self.get_model_time()
+        model_rivers = self._read_river_locations()
 
         # Check that the river is defined in the model and that the coordinates match
         river_loc = shapely.Point(
@@ -1630,7 +1632,7 @@ class SfincsAdapter(IHazardAdapter):
 
         # Initialize the tropical cyclone
         tc = TropicalCyclone()
-        tc.read_track(filename=str(track_forcing.path), fmt="ddb_cyc")
+        tc.read_track(filename=track_forcing.path.as_posix(), fmt="ddb_cyc")
 
         # Alter the track of the tc if necessary
         tc = self._translate_tc_track(
@@ -1709,22 +1711,17 @@ class SfincsAdapter(IHazardAdapter):
 
     def _read_river_locations(self) -> gpd.GeoDataFrame:
         path = self.get_model_root() / "sfincs.src"
-        lines = []
-        if path.exists():
-            with open(path) as f:
-                lines = f.readlines()
+
+        with open(path) as f:
+            lines = f.readlines()
         coords = [(float(line.split()[0]), float(line.split()[1])) for line in lines]
         points = [shapely.Point(coord) for coord in coords]
 
         return gpd.GeoDataFrame({"geometry": points}, crs=self._model.crs)
 
     def _read_waterlevel_boundary_locations(self) -> gpd.GeoDataFrame:
-        path = self.get_model_root() / "sfincs.bnd"
-        lines = []
-        if path.exists():
-            with open(path) as f:
-                lines = f.readlines()
-
+        with open(self.get_model_root() / "sfincs.bnd") as f:
+            lines = f.readlines()
         coords = [(float(line.split()[0]), float(line.split()[1])) for line in lines]
         points = [shapely.Point(coord) for coord in coords]
 

flood_adapt/config/fiat.py

@@ -87,7 +87,7 @@ class FiatModel(BaseModel):
     config: FiatConfigModel
 
     benefits: Optional[BenefitsModel] = None
-    risk: Optional[RiskModel] = RiskModel()
+    risk: RiskModel = RiskModel()
 
     @staticmethod
     def read_toml(path: Path) -> "FiatModel":

flood_adapt/config/gui.py

@@ -1,5 +1,7 @@
+import re
+from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import Any, Literal, Optional, Union
 
 import geopandas as gpd
 import numpy as np
@@ -25,6 +27,7 @@ class Layer(BaseModel):
 
     bins: list[float]
     colors: list[str]
+    decimals: Optional[int] = 0
 
     @model_validator(mode="after")
     def check_bins_and_colors(self) -> "Layer":
@@ -42,20 +45,118 @@ class FloodMapLayer(Layer):
     roads_min_zoom_level: int = 14
 
 
-class AggregationDmgLayer(Layer):
-    damage_decimals: Optional[int] = 0
-
-
 class FootprintsDmgLayer(Layer):
     type: DamageType = DamageType.absolute
-    damage_decimals: Optional[int] = 0
-    buildings_min_zoom_level: int = 13
 
 
 class BenefitsLayer(Layer):
     threshold: Optional[float] = None
 
 
+class LogicalOperator(str, Enum):
+    AND = "and"
+    OR = "or"
+
+
+class FieldName(str, Enum):
+    """Enum for valid field names with mapping to dictionary keys."""
+
+    NAME = "name"
+    LONG_NAME = "long_name"
+    DESCRIPTION = "description"
+
+    @property
+    def dict_key(self) -> str:
+        """Get the actual dictionary key for this field name."""
+        mapping = {
+            "name": "name",
+            "long_name": "Long Name",
+            "description": "Description",
+        }
+        return mapping[self.value]
+
+
+class FilterCondition(BaseModel):
+    """A single filter condition."""
+
+    field_name: FieldName
+    values: list[Any]
+    operator: LogicalOperator = (
+        LogicalOperator.OR
+    )  # How to combine values within this condition
+
+
+class FilterGroup(BaseModel):
+    """A group of filter conditions with logical operators."""
+
+    conditions: list[FilterCondition]
+    operator: LogicalOperator = (
+        LogicalOperator.OR
+    )  # How to combine conditions within this group
+
+
+class MetricLayer(Layer):
+    type: str
+    # Simplified: just a single FilterGroup or FilterCondition
+    filters: Union[FilterGroup, FilterCondition] = Field(
+        default_factory=lambda: FilterGroup(conditions=[])
+    )
+
+    def matches(self, data_dict: dict) -> bool:
+        """Check if the given data dictionary matches the filter criteria."""
+        if isinstance(self.filters, FilterCondition):
+            return self._evaluate_condition(self.filters, data_dict)
+        else:  # FilterGroup
+            return self._evaluate_filter_group(self.filters, data_dict)
+
+    def _evaluate_filter_group(self, group: FilterGroup, data_dict: dict) -> bool:
+        """Evaluate a single filter group."""
+        if not group.conditions:
+            return True
+
+        condition_results = []
+        for condition in group.conditions:
+            condition_results.append(self._evaluate_condition(condition, data_dict))
+
+        if group.operator == LogicalOperator.AND:
+            return all(condition_results)
+        else:  # OR
+            return any(condition_results)
+
+    def _evaluate_condition(self, condition: FilterCondition, data_dict: dict) -> bool:
+        """Evaluate a single condition."""
+        # Use the dict_key property to get the actual dictionary key
+        field_value = data_dict.get(condition.field_name.dict_key)
+        if field_value is None:
+            return False
+
+        value_matches = [value in field_value for value in condition.values]  # noqa: PD011
+
+        if condition.operator == LogicalOperator.AND:
+            return all(value_matches)
+        else:  # OR
+            return any(value_matches)
+
+
+class AggregationDmgLayer(MetricLayer):
+    type: str = "damage"
+    filters: FilterGroup = Field(
+        default_factory=lambda: FilterGroup(
+            conditions=[
+                FilterCondition(
+                    field_name=FieldName.NAME,
+                    values=[
+                        "TotalDamageEvent",
+                        "ExpectedAnnualDamages",
+                        "TotalDamageRP",
+                        "EWEAD",
+                    ],
+                )
+            ]
+        )
+    )
+
+
 class OutputLayers(BaseModel):
     """The configuration of the mapbox layers in the gui.
 
@@ -75,9 +176,84 @@ class OutputLayers(BaseModel):
     floodmap: FloodMapLayer
     aggregation_dmg: AggregationDmgLayer
     footprints_dmg: FootprintsDmgLayer
-
+    aggregated_metrics: list[MetricLayer] = Field(default_factory=list)
     benefits: Optional[BenefitsLayer] = None
 
+    def get_aggr_metrics_layers(
+        self,
+        metrics: list[dict],
+        type: Literal["single_event", "risk"] = "single_event",
+        rp: Optional[int] = None,
+        equity: bool = False,
+    ):
+        layer_types = [self.aggregation_dmg] + self.aggregated_metrics
+        filtered_input_metrics = self._filter_metrics(metrics, type, rp, equity)
+        return self._match_metrics_to_layers(filtered_input_metrics, layer_types)
+
+    def _should_skip_metric(
+        self, metric_name: str, rp: Optional[int], equity: bool
+    ) -> bool:
+        rp_match = re.search(r"RP(\d+)", metric_name)
+        y_match = re.search(r"(\d+)Y", metric_name)
+        name_match = rp_match or y_match
+
+        if rp is None:
+            if name_match:
+                return True
+            if not equity and "EW" in metric_name:
+                return True
+            if equity and "EW" not in metric_name:
+                return True
+        return False
+
+    def _process_metric_name(
+        self, metric_name: str, rp: Optional[int]
+    ) -> tuple[str, bool]:
+        rp_match = re.search(r"RP(\d+)", metric_name)
+        y_match = re.search(r"(\d+)Y", metric_name)
+        name_match = rp_match or y_match
+        if rp is not None:
+            if name_match:
+                extracted_rp = int(name_match.group(1))
+                name_check = extracted_rp == int(rp)
+                cleaned_name = re.sub(r"(RP\d+|\d+Y)", "", metric_name)
+                return cleaned_name.rstrip("_"), name_check
+            else:
+                return metric_name, False
+        return metric_name, True
+
+    def _filter_metrics(self, metrics, type, rp, equity):
+        filtered = []
+        for metric in metrics:
+            metric_name = metric.get("name", "")
+            metric["name_to_show"] = metric_name
+            if type == "risk":
+                if self._should_skip_metric(metric_name, rp, equity):
+                    continue
+                metric["name_to_show"], name_check = self._process_metric_name(
+                    metric_name, rp
+                )
+                if rp is not None and not name_check:
+                    continue
+            filtered.append(metric)
+        return filtered
+
+    def _match_metrics_to_layers(self, metrics, layer_types):
+        filtered_metrics = []
+        for metric in metrics:
+            for layer in layer_types:
+                if layer.matches(metric):
+                    filtered_metrics.append(
+                        {
+                            "metric": metric,
+                            "bins": getattr(layer, "bins", None),
+                            "colors": getattr(layer, "colors", None),
+                            "decimals": getattr(layer, "decimals", None),
+                        }
+                    )
+                    break
+        return filtered_metrics
+
 
 class VisualizationLayer(Layer):
     """The configuration of a layer to visualize in the gui.
@@ -157,6 +333,7 @@ class VisualizationLayers(BaseModel):
         The layers to visualize.
     """
 
+    buildings_min_zoom_level: int = 13
     layers: list[VisualizationLayer] = Field(default_factory=list)
 
     def add_layer(

flood_adapt/config/hazard.py

@@ -341,7 +341,7 @@ class SlrScenariosModel(BaseModel):
         # write html to results folder
         output_loc.parent.mkdir(parents=True, exist_ok=True)
         fig.write_html(output_loc)
-        return str(output_loc)
+        return output_loc.as_posix()
 
 
 class FloodModel(BaseModel):