flood-adapt 0.3.0__py3-none-any.whl

flood_adapt/dbs_classes/dbs_static.py

@@ -0,0 +1,261 @@
+from pathlib import Path
+from typing import Any, Callable, Tuple, Union
+
+import geopandas as gpd
+import pandas as pd
+from cht_cyclones.cyclone_track_database import CycloneTrackDatabase
+
+from flood_adapt.adapter.fiat_adapter import FiatAdapter
+from flood_adapt.adapter.sfincs_adapter import SfincsAdapter
+from flood_adapt.config.config import Settings
+from flood_adapt.dbs_classes.interface.database import IDatabase
+from flood_adapt.dbs_classes.interface.static import IDbsStatic
+
+
+def cache_method_wrapper(func: Callable) -> Callable:
+    def wrapper(self, *args: Tuple[Any], **kwargs: dict[str, Any]) -> Any:
+        if func.__name__ not in self._cached_data:
+            self._cached_data[func.__name__] = {}
+
+        args_key = (
+            str(args) + str(sorted(kwargs.items())) if args or kwargs else "no_args"
+        )
+        if args_key in self._cached_data[func.__name__]:
+            return self._cached_data[func.__name__][args_key]
+
+        result = func(self, *args, **kwargs)
+        self._cached_data[func.__name__][args_key] = result
+
+        return result
+
+    return wrapper
+
+
+class DbsStatic(IDbsStatic):
+    _cached_data: dict[str, Any] = {}
+    _database: IDatabase
+
+    def __init__(self, database: IDatabase):
+        """Initialize any necessary attributes."""
+        self._database = database
+
+    @cache_method_wrapper
+    def get_aggregation_areas(self) -> dict[str, gpd.GeoDataFrame]:
+        """Get a list of the aggregation areas that are provided in the site configuration.
+
+        These are expected to much the ones in the FIAT model.
+
+        Returns
+        -------
+        list[gpd.GeoDataFrame]
+            list of gpd.GeoDataFrames with the polygons defining the aggregation areas
+        """
+        aggregation_areas = {}
+        for aggr_dict in self._database.site.fiat.config.aggregation:
+            aggregation_areas[aggr_dict.name] = gpd.read_file(
+                self._database.static_path / aggr_dict.file,
+                engine="pyogrio",
+            ).to_crs(4326)
+            # Use always the same column name for name labels
+            aggregation_areas[aggr_dict.name] = aggregation_areas[
+                aggr_dict.name
+            ].rename(columns={aggr_dict.field_name: "name"})
+            # Make sure they are ordered alphabetically
+            aggregation_areas[aggr_dict.name].sort_values(by="name").reset_index(
+                drop=True
+            )
+        return aggregation_areas
+
+    @cache_method_wrapper
+    def get_model_boundary(self) -> gpd.GeoDataFrame:
+        """Get the model boundary from the SFINCS model."""
+        bnd = self.get_overland_sfincs_model().get_model_boundary()
+        return bnd
+
+    @cache_method_wrapper
+    def get_model_grid(self):
+        """Get the model grid from the SFINCS model.
+
+        Returns
+        -------
+        QuadtreeGrid
+            The model grid
+        """
+        grid = self.get_overland_sfincs_model().get_model_grid()
+        return grid
+
+    @cache_method_wrapper
+    def get_obs_points(self) -> gpd.GeoDataFrame:
+        """Get the observation points from the flood hazard model."""
+        names = []
+        descriptions = []
+        lat = []
+        lon = []
+        if self._database.site.sfincs.obs_point is not None:
+            obs_points = self._database.site.sfincs.obs_point
+            for pt in obs_points:
+                names.append(pt.name)
+                descriptions.append(pt.description)
+                lat.append(pt.lat)
+                lon.append(pt.lon)
+
+        # create gpd.GeoDataFrame from obs_points in site file
+        df = pd.DataFrame({"name": names, "description": descriptions})
+        # TODO: make crs flexible and add this as a parameter to site.toml?
+        gdf = gpd.GeoDataFrame(
+            df, geometry=gpd.points_from_xy(lon, lat), crs="EPSG:4326"
+        )
+        return gdf
+
+    @cache_method_wrapper
+    def get_static_map(self, path: Union[str, Path]) -> gpd.GeoDataFrame:
+        """Get a map from the static folder.
+
+        Parameters
+        ----------
+        path : Union[str, Path]
+            Path to the map relative to the static folder
+
+        Returns
+        -------
+        gpd.GeoDataFrame
+            gpd.GeoDataFrame with the map in crs 4326
+
+        Raises
+        ------
+        FileNotFoundError
+            If the file is not found
+        """
+        # Read the map
+        full_path = self._database.static_path / path
+        if full_path.is_file():
+            return gpd.read_file(full_path, engine="pyogrio").to_crs(4326)
+
+        # If the file is not found, throw an error
+        raise FileNotFoundError(f"File {full_path} not found")
+
+    @cache_method_wrapper
+    def get_slr_scn_names(self) -> list:
+        """Get the names of the sea level rise scenarios from the file provided.
+
+        Returns
+        -------
+        list
+            List of scenario names
+        """
+        input_file = self._database.static_path.joinpath(
+            self._database.site.sfincs.slr_scenarios.file
+        )
+        df = pd.read_csv(input_file)
+        names = df.columns[2:].to_list()
+        return names
+
+    @cache_method_wrapper
+    def get_green_infra_table(self, measure_type: str) -> pd.DataFrame:
+        """Return a table with different types of green infrastructure measures and their infiltration depths.
+
+        This is read by a csv file in the database.
+
+        Returns
+        -------
+        pd.DataFrame
+            Table with values
+        """
+        # Read file from database
+        df = pd.read_csv(
+            self._database.static_path.joinpath(
+                "green_infra_table", "green_infra_lookup_table.csv"
+            )
+        )
+
+        # Get column with values
+        val_name = "Infiltration depth"
+        col_name = [name for name in df.columns if val_name in name][0]
+        if not col_name:
+            raise KeyError(f"A column with a name containing {val_name} was not found!")
+
+        # Get list of types per measure
+        df["types"] = [
+            [x.strip() for x in row["types"].split(",")] for i, row in df.iterrows()
+        ]
+
+        # Show specific values based on measure type
+        inds = [i for i, row in df.iterrows() if measure_type in row["types"]]
+        df = df.drop(columns="types").iloc[inds, :]
+
+        return df
+
+    @cache_method_wrapper
+    def get_buildings(self) -> gpd.GeoDataFrame:
+        """Get the building footprints from the FIAT model.
+
+        This should only be the buildings excluding any other types (e.g., roads)
+        The parameters non_building_names in the site config is used for that.
+
+        Returns
+        -------
+        gpd.GeoDataFrame
+            building footprints with all the FIAT columns
+        """
+        return self.get_fiat_model().get_buildings()
+
+    @cache_method_wrapper
+    def get_property_types(self) -> list:
+        """_summary_.
+
+        Returns
+        -------
+        list
+            _description_
+        """
+        return self.get_fiat_model().get_property_types()
+
+    def get_overland_sfincs_model(self) -> SfincsAdapter:
+        """Get the template offshore SFINCS model."""
+        overland_path = (
+            self._database.static_path
+            / "templates"
+            / self._database.site.sfincs.config.overland_model.name
+        )
+        with SfincsAdapter(model_root=overland_path) as overland_model:
+            return overland_model
+
+    def get_offshore_sfincs_model(self) -> SfincsAdapter:
+        """Get the template overland Sfincs model."""
+        if self._database.site.sfincs.config.offshore_model is None:
+            raise ValueError("No offshore model defined in the site configuration.")
+
+        offshore_path = (
+            self._database.static_path
+            / "templates"
+            / self._database.site.sfincs.config.offshore_model.name
+        )
+        with SfincsAdapter(model_root=offshore_path) as offshore_model:
+            return offshore_model
+
+    def get_fiat_model(self) -> FiatAdapter:
+        """Get the path to the FIAT model."""
+        if self._database.site.fiat is None:
+            raise ValueError("No FIAT model defined in the site configuration.")
+        template_path = self._database.static_path / "templates" / "fiat"
+        with FiatAdapter(
+            model_root=template_path,
+            config=self._database.site.fiat.config,
+            exe_path=Settings().fiat_path,
+            delete_crashed_runs=Settings().delete_crashed_runs,
+            config_base_path=self._database.static_path,
+        ) as fm:
+            return fm
+
+    @cache_method_wrapper
+    def get_cyclone_track_database(self) -> CycloneTrackDatabase:
+        if self._database.site.sfincs.cyclone_track_database is None:
+            raise ValueError(
+                "No cyclone track database defined in the site configuration."
+            )
+        database_file = str(
+            self._database.static_path
+            / "cyclone_track_database"
+            / self._database.site.sfincs.cyclone_track_database.file
+        )
+        return CycloneTrackDatabase("ibtracs", file_name=database_file)

flood_adapt/dbs_classes/dbs_strategy.py

@@ -0,0 +1,147 @@
+from itertools import combinations
+
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.objects.measures.measures import MeasureType
+from flood_adapt.objects.strategies.strategies import Strategy
+
+
+class DbsStrategy(DbsTemplate[Strategy]):
+    dir_name = "strategies"
+    display_name = "Strategy"
+    _object_class = Strategy
+
+    def get(self, name: str) -> Strategy:
+        strategy = super().get(name)
+        measures = [
+            self._database.measures.get(measure) for measure in strategy.measures
+        ]
+        strategy.initialize_measure_objects(measures)
+        return strategy
+
+    def save(
+        self,
+        object_model: Strategy,
+        overwrite: bool = False,
+    ):
+        """Save an object in the database and all associated files.
+
+        This saves the toml file and any additional files attached to the object.
+
+        Parameters
+        ----------
+        object_model : Object
+            object to be saved in the database
+        overwrite : bool, optional
+            whether to overwrite the object if it already exists in the
+            database, by default False
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        object_exists = object_model.name in self.list_objects()["name"]
+
+        # If you want to overwrite the object, and the object already exists, first delete it. If it exists and you
+        # don't want to overwrite, raise an error.
+        if overwrite and object_exists:
+            self.delete(object_model.name, toml_only=True)
+        elif not overwrite and object_exists:
+            raise ValueError(
+                f"'{object_model.name}' name is already used by another {self.display_name}. Choose a different name"
+            )
+
+        # Check if any measures overlap
+        self._check_overlapping_measures(object_model.measures)
+
+        # If the folder doesnt exist yet, make the folder and save the object
+        if not (self.input_path / object_model.name).exists():
+            (self.input_path / object_model.name).mkdir()
+
+        # Save the object and any additional files
+        object_model.save(
+            self.input_path / object_model.name / f"{object_model.name}.toml",
+        )
+
+    def _check_overlapping_measures(self, measures: list[str]):
+        """Validate if the combination of impact measures can happen, since impact measures cannot affect the same properties.
+
+        Raises
+        ------
+        ValueError
+            information on which combinations of measures have overlapping properties
+        """
+        measure_objects = [self._database.measures.get(measure) for measure in measures]
+        impact_measures = [
+            measure
+            for measure in measure_objects
+            if MeasureType.is_impact(measure.type)
+        ]
+
+        adapter = self._database.static.get_fiat_model()
+
+        ids = [adapter.get_object_ids(measure) for measure in impact_measures]
+
+        # Get all possible pairs of measures and check overlapping buildings for each measure
+        combs = list(combinations(enumerate(ids), 2))
+        common_elements = []
+        for comb in combs:
+            common_elements.append(list(set(comb[0][1]).intersection(comb[1][1])))
+        # If there is any combination with overlapping buildings raise Error and do not allow for Strategy object creation
+        overlapping = [len(k) > 0 for k in common_elements]
+
+        if any(overlapping):
+            msg = "Cannot create strategy! There are overlapping buildings for which measures are proposed"
+            counter = 0
+            for i, comb in enumerate(combs):
+                if overlapping[i]:
+                    if counter > 0:
+                        msg += " and"
+                    msg += " between '{}' and '{}'".format(
+                        impact_measures[comb[0][0]].name,
+                        impact_measures[comb[1][0]].name,
+                    )
+                    counter += 1
+            raise ValueError(msg)
+
+    def _check_standard_objects(self, name: str) -> bool:
+        """Check if a strategy is a standard strategy.
+
+        Parameters
+        ----------
+        name : str
+            name of the strategy to be checked
+
+        Raises
+        ------
+        ValueError
+            Raise error if strategy is a standard strategy.
+        """
+        # Check if strategy is a standard strategy
+        if self._database.site.standard_objects:
+            if self._database.site.standard_objects.strategies:
+                if name in self._database.site.standard_objects.strategies:
+                    return True
+        return False
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if a strategy is used in a scenario.
+
+        Parameters
+        ----------
+        name : str
+            name of the strategy to be checked
+
+        Returns
+        -------
+        list[str]
+            list of scenarios that use the strategy
+        """
+        # Check if strategy is used in a scenario
+        used_in_scenario = [
+            scenario.name
+            for scenario in self._database.scenarios.list_objects()["objects"]
+            if name == scenario.strategy
+        ]
+
+        return used_in_scenario