flood-adapt 1.1.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

flood_adapt/__init__.py

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

flood_adapt/adapter/fiat_adapter.py

@@ -258,7 +258,7 @@ class FiatAdapter(IImpactAdapter):
             map_type=floodmap.map_type,
             var=var,
             is_risk=is_risk,
-            units=us.UnitTypesLength.meters,
+            units=self.database.site.sfincs.config.floodmap_units,
         )
 
         # Save any changes made to disk as well
@@ -489,7 +489,10 @@ class FiatAdapter(IImpactAdapter):
         fiat_results_path = impacts_output_path.joinpath(
             f"Impacts_detailed_{scenario.name}.csv"
         )
-        self.outputs["table"].to_csv(fiat_results_path, index=False)
+        try:
+            self.outputs["table"].to_csv(fiat_results_path, index=False)
+        except Exception as e:
+            logger.error(f"Error while saving detailed impacts file csv: {e}")
 
         # Add exceedance probabilities if needed (only for risk)
         if mode == Mode.risk:
@@ -500,13 +503,16 @@ class FiatAdapter(IImpactAdapter):
             )
             with open(config_path, mode="rb") as fp:
                 config = tomli.load(fp)["flood_exceedance"]
-            self.add_exceedance_probability(
-                column=config[
-                    "column"
-                ],  # TODO check how to the correct version of column
-                threshold=config["threshold"],
-                period=config["period"],
-            )
+            try:
+                self.add_exceedance_probability(
+                    column=config[
+                        "column"
+                    ],  # TODO check how to the correct version of column
+                    threshold=config["threshold"],
+                    period=config["period"],
+                )
+            except Exception as e:
+                logger.error(f"Error while adding exceedance probabilities: {e}")
 
         # Create the infometrics files
         if mode == Mode.risk:
@@ -531,7 +537,10 @@ class FiatAdapter(IImpactAdapter):
         metrics_outputs_path = impacts_output_path.parent.joinpath(
             f"Infometrics_{scenario.name}.csv"
         )
-        self.create_infometrics(metric_config_paths, metrics_outputs_path)
+        try:
+            self.create_infometrics(metric_config_paths, metrics_outputs_path)
+        except Exception as e:
+            logger.error(f"Error while creating infometrics: {e}")
 
         # Get paths of created aggregated infometrics
         aggr_metrics_paths = list(
@@ -543,20 +552,28 @@ class FiatAdapter(IImpactAdapter):
             config_base_path = self.database.static_path.joinpath(
                 "templates", "Infographics"
             )
-            self.create_infographics(
-                name=scenario.name,
-                output_base_path=impacts_output_path.parent,
-                config_base_path=config_base_path,
-                metrics_path=metrics_outputs_path,
-                mode=mode,
-            )
+            try:
+                self.create_infographics(
+                    name=scenario.name,
+                    output_base_path=impacts_output_path.parent,
+                    config_base_path=config_base_path,
+                    metrics_path=metrics_outputs_path,
+                    mode=mode,
+                )
+            except Exception as e:
+                logger.error(f"Error while creating infographics: {e}")
 
         # Calculate equity based damages
         if mode == Mode.risk:
             for file in aggr_metrics_paths:
                 # Load metrics
                 aggr_label = file.stem.split(f"{metrics_outputs_path.stem}_")[-1]
-                self.add_equity(aggr_label=aggr_label, metrics_path=file)
+                try:
+                    self.add_equity(aggr_label=aggr_label, metrics_path=file)
+                except Exception as e:
+                    logger.error(
+                        f"Error while calculating equity metrics for {aggr_label}: {e}"
+                    )
 
         # Save aggregated metrics to shapefiles
         for file in aggr_metrics_paths:
@@ -564,24 +581,35 @@ class FiatAdapter(IImpactAdapter):
             output_path = impacts_output_path.joinpath(
                 f"Impacts_aggregated_{scenario.name}_{aggr_label}.gpkg"
             )
-            self.save_aggregation_spatial(
-                aggr_label=aggr_label, metrics_path=file, output_path=output_path
-            )
+            try:
+                self.save_aggregation_spatial(
+                    aggr_label=aggr_label, metrics_path=file, output_path=output_path
+                )
+            except Exception as e:
+                logger.error(
+                    f"Error while saving aggregation spatial for {aggr_label}: {e}"
+                )
 
         # Merge points data to building footprints
-        self.save_building_footprints(
-            output_path=impacts_output_path.joinpath(
-                f"Impacts_building_footprints_{scenario.name}.gpkg"
+        try:
+            self.save_building_footprints(
+                output_path=impacts_output_path.joinpath(
+                    f"Impacts_building_footprints_{scenario.name}.gpkg"
+                )
             )
-        )
+        except Exception as e:
+            logger.error(f"Error while saving building footprints: {e}")
 
         # Create a roads spatial file
         if self.config.roads_file_name:
-            self.save_roads(
-                output_path=impacts_output_path.joinpath(
-                    f"Impacts_roads_{scenario.name}.gpkg"
+            try:
+                self.save_roads(
+                    output_path=impacts_output_path.joinpath(
+                        f"Impacts_roads_{scenario.name}.gpkg"
+                    )
                 )
-            )
+            except Exception as e:
+                logger.error(f"Error while saving roads spatial file: {e}")
 
         logger.info("Delft-FIAT post-processing complete!")
 

flood_adapt/adapter/sfincs_adapter.py

@@ -15,12 +15,12 @@ import plotly.express as px
 import pyproj
 import shapely
 import xarray as xr
+import xugrid as xu
 from cht_cyclones.tropical_cyclone import TropicalCyclone
 from cht_tide.read_bca import SfincsBoundary
 from cht_tide.tide_predict import predict
 from hydromt_sfincs import SfincsModel as HydromtSfincsModel
 from hydromt_sfincs.quadtree import QuadtreeGrid
-from numpy import matlib
 from shapely.affinity import translate
 
 from flood_adapt.adapter.interface.hazard_adapter import IHazardAdapter
@@ -308,9 +308,9 @@ class SfincsAdapter(IHazardAdapter):
         ):
             raise RuntimeError("SFINCS was not run successfully!")
 
+        self.write_water_level_map(scenario)
         self.write_floodmap_geotiff(scenario)
         self.plot_wl_obs(scenario)
-        self.write_water_level_map(scenario)
 
     def set_timing(self, time: TimeFrame):
         """Set model reference times."""
@@ -386,20 +386,27 @@ class SfincsAdapter(IHazardAdapter):
     def get_model_root(self) -> Path:
         return Path(self._model.root)
 
-    def get_mask(self):
+    def get_mask(self) -> xr.DataArray:
         """Get mask with inactive cells from model."""
-        mask = self._model.grid["msk"]
+        mask = self._model.mask
         return mask
 
-    def get_bedlevel(self):
+    def get_bedlevel(self) -> xr.DataArray:
         """Get bed level from model."""
         self._model.read_results()
         zb = self._model.results["zb"]
+        # Convert bed level from meters to floodmap units
+        conversion = us.UnitfulLength(
+            value=1.0, units=us.UnitTypesLength.meters
+        ).convert(self.settings.config.floodmap_units)
+        zb = zb * conversion
+        zb.attrs["units"] = self.settings.config.floodmap_units.value
         return zb
 
     def get_model_boundary(self) -> gpd.GeoDataFrame:
         """Get bounding box from model."""
-        return self._model.region
+        boundary = self._model.region[["geometry"]]
+        return boundary
 
     def get_model_grid(self) -> QuadtreeGrid:
         """Get grid from model.
@@ -411,6 +418,15 @@ class SfincsAdapter(IHazardAdapter):
         """
         return self._model.quadtree
 
+    def get_finest_res(self) -> float:
+        """Get the finest resolution of the model grid."""
+        if self._model.grid_type == "quadtree":
+            res0 = self._model.quadtree.dx
+            res = res0 / 2**self._model.quadtree.nr_refinement_levels
+        else:
+            res = self._model.res[0]
+        return res
+
     # Forcing properties
     @property
     def waterlevels(self) -> xr.Dataset | xr.DataArray | None:
@@ -543,7 +559,7 @@ class SfincsAdapter(IHazardAdapter):
         sim_path : Path, optional
             Path to the simulation folder, by default None.
         """
-        logger.info("Writing flood maps to geotiff")
+        logger.info("Writing flood maps to geotiff.")
         results_path = self._get_result_path(scenario)
         sim_path = sim_path or self._get_simulation_path(scenario)
         demfile = self.database.static_path / "dem" / self.settings.dem.filename
@@ -560,13 +576,8 @@ class SfincsAdapter(IHazardAdapter):
 
             floodmap_fn = results_path / f"FloodMap_{scenario.name}.tif"
 
-            # convert zsmax from meters to floodmap units
-            floodmap_conversion = us.UnitfulLength(
-                value=1.0, units=us.UnitTypesLength.meters
-            ).convert(self.settings.config.floodmap_units)
-
             utils.downscale_floodmap(
-                zsmax=floodmap_conversion * zsmax,
+                zsmax=zsmax,
                 dep=dem_conversion * dem,
                 hmin=0.01,
                 floodmap_fn=floodmap_fn.as_posix(),
@@ -582,7 +593,23 @@ class SfincsAdapter(IHazardAdapter):
 
         with SfincsAdapter(model_root=sim_path) as model:
             zsmax = model._get_zsmax()
-            zsmax.to_netcdf(results_path / "max_water_level_map.nc")
+            if hasattr(zsmax, "ugrid"):
+                # First write netcdf with quadtree water levels
+                zsmax.to_netcdf(results_path / "max_water_level_map_qt.nc")
+                # Rasterize to regular grid with the finest resolution
+                zsmax = self._rasterize_quadtree(zsmax)
+                # Add CRS to the rasterized xarray
+                zsmax = zsmax.rio.write_crs(model._model.config["epsg"])
+            # Save as a Cloud Optimized GeoTIFF (COG)
+            zsmax.rio.to_raster(
+                results_path / "max_water_level_map.tif",
+                driver="COG",
+                compress="deflate",
+                dtype="float32",
+                nodata=np.nan,
+                OVERVIEW_RESAMPLING="nearest",
+                tags={"units": self.settings.config.floodmap_units.value},
+            )
 
     def plot_wl_obs(
         self,
@@ -727,83 +754,117 @@ class SfincsAdapter(IHazardAdapter):
 
         TODO: make this robust and more efficient for bigger datasets.
         """
+        # Check if the scenario is a risk scenario
         event: EventSet = self.database.events.get(scenario.event, load_all=True)
         if not isinstance(event, EventSet):
             raise ValueError("This function is only available for risk scenarios.")
+        logger.info("Calculating flood risk maps, this may take some time.")
 
+        # Get the simulation paths and result path
         result_path = self._get_result_path(scenario)
         sim_paths = [
             self._get_simulation_path(scenario, sub_event=sub_event)
             for sub_event in event._events
         ]
 
+        # Get the required return periods for flood maps
+        floodmap_rp = self.database.site.fiat.risk.return_periods
+
+        # Get the frequencies for each sub-event
+        frequencies = [sub_event.frequency for sub_event in event.sub_events]
         phys_proj = self.database.projections.get(
             scenario.projection
         ).physical_projection
 
-        floodmap_rp = self.database.site.fiat.risk.return_periods
-        frequencies = [sub_event.frequency for sub_event in event.sub_events]
-
-        # adjust storm frequency for hurricane events
+        # adjust storm frequency for hurricane events if provided in the projection
         if not math.isclose(phys_proj.storm_frequency_increase, 0, abs_tol=1e-9):
             storminess_increase = phys_proj.storm_frequency_increase / 100.0
             for ii, event in enumerate(event._events):
                 if event.template == Template.Hurricane:
                     frequencies[ii] = frequencies[ii] * (1 + storminess_increase)
 
+        # Read static mask and bed level from the first simulation path
         with SfincsAdapter(model_root=sim_paths[0]) as dummymodel:
             # read mask and bed level
             mask = dummymodel.get_mask()
             zb = dummymodel.get_bedlevel()
 
+        # Read the max water level maps from each simulation path
         zs_maps = []
         for simulation_path in sim_paths:
             # read zsmax data from overland sfincs model
             with SfincsAdapter(model_root=simulation_path) as sim:
                 zsmax = sim._get_zsmax().load()
-                zs_maps.append(zsmax)
+                zs_maps.append(zsmax.values)
 
-        # Create RP flood maps
-        logger.info("Calculating flood risk maps, this may take some time")
+        # Calculate return period flood maps
+        # All units are in the floodmap units
         rp_flood_maps = self.calc_rp_maps(
             floodmaps=zs_maps,
             frequencies=frequencies,
-            zb=zb,
-            mask=mask,
+            zb=zb.values,
+            mask=mask.values,
             return_periods=floodmap_rp,
         )
 
+        # For each return period, save water level and flood depth maps
         for ii, rp in enumerate(floodmap_rp):
-            zs_rp_single = rp_flood_maps[ii]
-            zs_rp_single = zs_rp_single.rio.write_crs(
-                zsmax.raster.crs
-            )  # , inplace=True)
-            zs_rp_single = zs_rp_single.to_dataset(name="risk_map").transpose()
-            fn_rp = result_path / f"RP_{rp:04d}_maps.nc"
-            zs_rp_single.to_netcdf(fn_rp)
-
-            # write geotiff
+            # Prepare data array for the return period flood map
+            zs_rp_single = xr.DataArray(
+                rp_flood_maps[ii],
+                name="zsmax",
+                attrs={"units": self.settings.config.floodmap_units.value},
+            )
+            # If model is quadtree, write the quadtree netcdf with water levels since it is needed for visualizations
+            if self._model.grid_type == "quadtree":
+                # Use mask grid
+                zs_rp_single = xu.UgridDataArray.from_data(
+                    zs_rp_single, grid=mask.grid, facet="face"
+                )
+                # Save to netcdf
+                zs_rp_single.to_netcdf(
+                    result_path / f"RP_{rp:04d}_max_water_level_map_qt.nc"
+                )
+                # Rasterize to regular grid with the finest resolution
+                zs_rp_single = self._rasterize_quadtree(zs_rp_single)
+            # Prepare regular grid water level map
+            elif self._model.grid_type == "regular":
+                # Create a DataArray with the mask coordinates
+                zs_rp_single = xr.DataArray(
+                    zs_rp_single,
+                    dims=("y", "x"),
+                    coords={"y": mask.y, "x": mask.x},
+                    name="zsmax",
+                )
+            else:
+                raise ValueError("unsupported sfincs model type")
+            # Write COG geotiff with water levels
+            zs_rp_single = zs_rp_single.rio.write_crs(self._model.crs)
+            fn_rp = result_path / f"RP_{rp:04d}_max_water_level_map.tif"
+            zs_rp_single.transpose("y", "x").rio.to_raster(
+                fn_rp,
+                driver="COG",
+                compress="deflate",
+                dtype="float32",
+                nodata=np.nan,
+                OVERVIEW_RESAMPLING="nearest",
+                tags={"units": self.settings.config.floodmap_units.value},
+            )
+
             # dem file for high resolution flood depth map
             demfile = self.database.static_path / "dem" / self.settings.dem.filename
+            # convert dem from dem units to floodmap units
+            dem_conversion = us.UnitfulLength(
+                value=1.0, units=self.settings.dem.units
+            ).convert(self.settings.config.floodmap_units)
 
             # writing the geotiff to the scenario results folder
             with SfincsAdapter(model_root=sim_paths[0]) as dummymodel:
                 dem = dummymodel._model.data_catalog.get_rasterdataset(demfile)
-                zsmax = zs_rp_single.to_array().squeeze().transpose()
-                floodmap_fn = fn_rp.with_suffix(".tif")
-
-                # convert dem from dem units to floodmap units
-                dem_conversion = us.UnitfulLength(
-                    value=1.0, units=self.settings.dem.units
-                ).convert(self.settings.config.floodmap_units)
-
-                # convert zsmax from meters to floodmap units
-                floodmap_conversion = us.UnitfulLength(
-                    value=1.0, units=us.UnitTypesLength.meters
-                ).convert(self.settings.config.floodmap_units)
+                floodmap_fn = result_path / f"RP_{rp:04d}_FloodMap.tif"
 
                 utils.downscale_floodmap(
-                    zsmax=floodmap_conversion * zsmax,
+                    zsmax=zs_rp_single,
                     dep=dem_conversion * dem,
                     hmin=0.01,
                     floodmap_fn=floodmap_fn.as_posix(),
@@ -1525,9 +1586,9 @@ class SfincsAdapter(IHazardAdapter):
         if isinstance(event, EventSet):
             map_fn = []
             for rp in self.database.site.fiat.risk.return_periods:
-                map_fn.append(results_path / f"RP_{rp:04d}_maps.nc")
+                map_fn.append(results_path / f"RP_{rp:04d}_max_water_level_map.tif")
         elif isinstance(event, Event):
-            map_fn = [results_path / "max_water_level_map.nc"]
+            map_fn = [results_path / "max_water_level_map.tif"]
         else:
             raise ValueError(f"Unsupported mode: {event.mode}")
 
@@ -1541,7 +1602,14 @@ class SfincsAdapter(IHazardAdapter):
         """Read zsmax file and return absolute maximum water level over entire simulation."""
         self._model.read_results()
         zsmax = self._model.results["zsmax"].max(dim="timemax")
-        zsmax.attrs["units"] = "m"
+
+        # Convert from meters to floodmap units
+        floodmap_conversion = us.UnitfulLength(
+            value=1.0, units=us.UnitTypesLength.meters
+        ).convert(self.settings.config.floodmap_units)
+        zsmax = zsmax * floodmap_conversion
+        zsmax.attrs["units"] = self.settings.config.floodmap_units.value
+
         return zsmax
 
     def _get_zs_points(self):
@@ -1571,6 +1639,21 @@ class SfincsAdapter(IHazardAdapter):
         )
         return df, gdf
 
+    def _rasterize_quadtree(self, zsmax: xu.UgridDataArray) -> xr.DataArray:
+        """Rasterize the zsmax UgridDataArray to a regular grid."""
+        xmin, ymin, xmax, ymax = zsmax.ugrid.bounds["mesh2d"]
+        d = self.get_finest_res()
+        x = np.arange(xmin + 0.5 * d, xmax, d)
+        y = np.arange(ymax - 0.5 * d, ymin, -d)
+        # Create a template DataArray with the desired x and y coordinates
+        template = xr.DataArray(
+            np.zeros((len(y), len(x))),
+            coords={"y": y, "x": x},
+            dims=("y", "x"),
+        )
+        zsmax = zsmax.ugrid.rasterize_like(template)
+        return zsmax
+
     def _create_spw_file_from_track(
         self,
         track_forcing: Union[RainfallTrack, WindTrack],
@@ -1810,12 +1893,12 @@ class SfincsAdapter(IHazardAdapter):
 
     @staticmethod
     def calc_rp_maps(
-        floodmaps: list[xr.DataArray],
+        floodmaps: list[np.ndarray],
         frequencies: list[float],
-        zb: xr.DataArray,
-        mask: xr.DataArray,
+        zb: np.ndarray,
+        mask: np.ndarray,
         return_periods: list[float],
-    ) -> list[xr.DataArray]:
+    ) -> list[np.ndarray]:
         """
         Calculate return period (RP) flood maps from a set of flood simulation results.
 
@@ -1824,26 +1907,25 @@ class SfincsAdapter(IHazardAdapter):
         using exceedance probabilities and handles masked or dry cells appropriately.
 
         Args:
-            floodmaps (list[xr.DataArray]): List of water level maps (xarray DataArrays), one for each simulation.
+            floodmaps (list[np.ndarray]): List of water level maps (NumPy arrays), one for each simulation.
             frequencies (list[float]): List of frequencies (probabilities of occurrence) corresponding to each floodmap.
             zb (np.ndarray): Array of bed elevations for each grid cell.
-            mask (xr.DataArray): Mask indicating valid (1) and invalid (0) grid cells.
+            mask (np.ndarray): Mask indicating valid (1) and invalid (0) grid cells.
             return_periods (list[float]): List of return periods (in years) for which to generate hazard maps.
 
         Returns
         -------
-            list[xr.DataArray]: List of xarray DataArrays, each representing the hazard map for a given return period.
-                                Each DataArray contains water levels (meters) for the corresponding return period.
+            list[np.ndarray]: List of NumPy arrays, each representing the hazard map for a given return period.
+                            Each array contains water levels (meters) for the corresponding return period.
         """
-        floodmaps = floodmaps.copy()  # avoid modifying the original list
-        # Check that all floodmaps have the same shape and dimensions
+        floodmaps = [np.asarray(fm) for fm in floodmaps]
+        # Check that all floodmaps have the same shape
         first_shape = floodmaps[0].shape
-        first_dims = floodmaps[0].dims
         for i, floodmap in enumerate(floodmaps):
-            if floodmap.shape != first_shape or floodmap.dims != first_dims:
+            if floodmap.shape != first_shape:
                 raise ValueError(
-                    f"Floodmap at index {i} does not match the shape or dimensions of the first floodmap. "
-                    f"Expected shape {first_shape} and dims {first_dims}, got shape {floodmap.shape} and dims {floodmap.dims}."
+                    f"Floodmap at index {i} does not match the shape of the first floodmap. "
+                    f"Expected shape {first_shape}, got shape {floodmap.shape}."
                 )
 
         # Check that zb and mask have the same shape
@@ -1863,22 +1945,21 @@ class SfincsAdapter(IHazardAdapter):
                 f"Floodmap shape: {first_shape}, zb shape: {zb.shape}, mask shape: {mask.shape}."
             )
 
-        # stack dimensions if floodmaps are 2D
-        if len(floodmaps[0].shape) > 1:
-            stacking = True
-            for i, floodmap in enumerate(floodmaps):
-                floodmaps[i] = floodmap.stack(z=("x", "y"))
-            zb = zb.stack(z=("x", "y"))
-            mask = mask.stack(z=("x", "y"))
-        else:
-            stacking = False
-
+        # If input is 2D, reshape to 1D for processing and then reshape back to 2D
+        reshape_needed = False
+        if zb.ndim == 2:
+            reshape_needed = True
+            shape_orig = zb.shape
+            n_cells = zb.size
+            floodmaps = [fm.reshape(n_cells) for fm in floodmaps]
+            zb = zb.reshape(n_cells)
+            mask = mask.reshape(n_cells)
         # 1a: make a table of all water levels and associated frequencies
-        zs = xr.concat(floodmaps, pd.Index(frequencies, name="frequency"))
+        zs = np.stack(floodmaps, axis=0)
         # Get the indices of columns with all NaN values
         nan_cells = np.where(np.all(np.isnan(zs), axis=0))[0]
         # fill nan values with minimum bed levels in each grid cell, np.interp cannot ignore nan values
-        zs = xr.where(np.isnan(zs), np.tile(zb, (zs.shape[0], 1)), zs)
+        zs = np.where(np.isnan(zs), np.tile(zb, (zs.shape[0], 1)), zs)
         # Get table of frequencies
         freq = np.tile(frequencies, (zs.shape[1], 1)).transpose()
 
@@ -1886,7 +1967,7 @@ class SfincsAdapter(IHazardAdapter):
         # (i.e. each h-value should be linked to the same p-values as in step 1a)
         sort_index = zs.argsort(axis=0)
         sorted_prob = np.flipud(np.take_along_axis(freq, sort_index, axis=0))
-        sorted_zs = np.flipud(np.take_along_axis(zs.values, sort_index, axis=0))
+        sorted_zs = np.flipud(np.take_along_axis(zs, sort_index, axis=0))
 
         # 1c: Compute exceedance probabilities of water depths
         # Method: accumulate probabilities from top to bottom
@@ -1902,23 +1983,19 @@ class SfincsAdapter(IHazardAdapter):
         # h(T) = interp1 (log(T*), h*, log(T))
         # in which t* and h* are the values from the table and T is the return period (T) of interest
         # The resulting T-year water depths for all grids combined form the T-year hazard map
-        rp_da = xr.DataArray(rp_zs, dims=zs.dims)
-
-        # no_data_value = -999  # in SFINCS
-        # sorted_zs = xr.where(sorted_zs == no_data_value, np.nan, sorted_zs)
 
         valid_cells = np.where(mask == 1)[
             0
         ]  # only loop over cells where model is not masked
-        h = matlib.repmat(
-            np.copy(zb), len(return_periods), 1
+        h = np.tile(
+            zb, (len(return_periods), 1)
         )  # if not flooded (i.e. not in valid_cells) revert to bed_level, read from SFINCS results so it is the minimum bed level in a grid cell
 
         for jj in valid_cells:  # looping over all non-masked cells.
             # linear interpolation for all return periods to evaluate
             h[:, jj] = np.interp(
                 np.log10(return_periods),
-                np.log10(rp_da[::-1, jj]),
+                np.log10(rp_zs[::-1, jj]),
                 sorted_zs[::-1, jj],
                 left=0,
             )
@@ -1935,16 +2012,10 @@ class SfincsAdapter(IHazardAdapter):
 
         rp_maps = []
         for ii, rp in enumerate(return_periods):
-            da = xr.DataArray(
-                data=h[ii, :], coords={"z": zs["z"]}, attrs={"units": "meters"}
-            )
-            if stacking:
-                # Ensure unstacking creates (y, x) dimensions in the correct order
-                da = da.unstack()
-                # Reorder dimensions if needed
-                if set(da.dims) == {"y", "x"} and da.dims != ("y", "x"):
-                    da = da.transpose("y", "x")
-            # #create single nc
-            rp_maps.append(da)
+            rp_maps.append(h[ii, :])
+
+        if reshape_needed:
+            # Reshape back to 2D if needed
+            rp_maps = [rp_map.reshape(shape_orig) for rp_map in rp_maps]
 
         return rp_maps

flood_adapt/config/hazard.py

@@ -116,6 +116,7 @@ class DemModel(BaseModel):
 
     filename: str
     units: us.UnitTypesLength
+    index_filename: str = "index.tif"
 
 
 class DatumModel(BaseModel):

flood_adapt/database_builder/database_builder.py

@@ -2,7 +2,6 @@ import datetime
 import gc
 import logging
 import math
-import os
 import re
 import shutil
 import warnings
@@ -22,6 +21,7 @@ import xarray as xr
 from hydromt_fiat import FiatModel as HydromtFiatModel
 from hydromt_fiat.data_apis.open_street_maps import get_buildings_from_osm
 from hydromt_sfincs import SfincsModel as HydromtSfincsModel
+from hydromt_sfincs.workflows.downscaling import make_index_cog
 from pydantic import BaseModel, Field
 from shapely import MultiLineString, MultiPolygon, Polygon
 from shapely.ops import nearest_points
@@ -1414,61 +1414,60 @@ class DatabaseBuilder:
 
     @debug_timer
     def create_dem_model(self) -> DemModel:
+        subgrid_sfincs_folder = Path(self.sfincs_overland_model.root) / "subgrid"
+        subgrid_sfincs_folder_exist = subgrid_sfincs_folder.is_dir()
         if self.config.dem:
             subgrid_sfincs = Path(self.config.dem.filename)
-            delete_sfincs_folder = False
         else:
             logger.warning(
                 "No subgrid depth geotiff file provided in the config file. Using the one from the SFINCS model."
             )
-            subgrid_sfincs_folder = Path(self.sfincs_overland_model.root) / "subgrid"
-            subgrid_sfincs = subgrid_sfincs_folder / "dep_subgrid.tif"
-            delete_sfincs_folder = True
-
-        dem_file = self._check_exists_and_absolute(subgrid_sfincs)
+            if not subgrid_sfincs_folder_exist:
+                raise FileNotFoundError(
+                    f"Subgrid folder {subgrid_sfincs_folder} does not exist in the SFINCS model."
+                )
+            if self.sfincs_overland_model.grid_type == "quadtree":
+                # If SFINCS is quadtree use the 0 level
+                subgrid_sfincs = subgrid_sfincs_folder / "dep_subgrid_lev0.tif"
+            else:
+                subgrid_sfincs = subgrid_sfincs_folder / "dep_subgrid.tif"
+        # Check that file exists and get absolute path
+        dem_file = self._check_exists_and_absolute(str(subgrid_sfincs))
+        # Define where it will be stored in the database
         fa_subgrid_path = self.static_path / "dem" / dem_file.name
         fa_subgrid_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Check tiles
-        tiles_sfincs = Path(self.sfincs_overland_model.root) / "tiles"
-        fa_tiles_path = self.static_path / "dem" / "tiles"
-        if tiles_sfincs.exists():
-            shutil.move(tiles_sfincs, fa_tiles_path)
-            if (fa_tiles_path / "index").exists():
-                os.rename(fa_tiles_path / "index", fa_tiles_path / "indices")
-            logger.info(
-                "Tiles were already available in the SFINCS model and will directly be used in FloodAdapt."
-            )
-        else:
-            # Make tiles
-            fa_tiles_path.mkdir(parents=True)
-            self.sfincs_overland_model.setup_tiles(
-                path=fa_tiles_path,
-                datasets_dep=[{"elevtn": dem_file}],
-                zoom_range=[0, 13],
-                fmt="png",
-            )
-            logger.info(
-                f"Tiles were created using the {subgrid_sfincs.as_posix()} as the elevation map."
-            )
-
         shutil.copy2(dem_file, fa_subgrid_path)
+
+        fa_index_path = self.static_path / "dem" / "index.tif"
+        # Make index cog
+        make_index_cog(
+            model=self.sfincs_overland_model,
+            indices_fn=fa_index_path,
+            topobathy_fn=fa_subgrid_path,
+        )
+        logger.info(
+            f"An index file was created using the {subgrid_sfincs.as_posix()} as the elevation map, and save at {fa_index_path.as_posix()}."
+        )
+
         self._dem_path = fa_subgrid_path
 
         # Remove the original subgrid folder if it exists
-        if delete_sfincs_folder:
-            gc.collect()
-            if subgrid_sfincs_folder.exists() and subgrid_sfincs_folder.is_dir():
-                try:
-                    shutil.rmtree(subgrid_sfincs_folder)
-                except Exception:
-                    logger.warning(
-                        f"Could not delete temporary SFINCS subgrid folder at {subgrid_sfincs_folder.as_posix()}."
-                    )
+        gc.collect()
+        if subgrid_sfincs_folder_exist:
+            try:
+                shutil.rmtree(subgrid_sfincs_folder)
+            except Exception:
+                logger.warning(
+                    f"Could not delete temporary SFINCS subgrid folder at {subgrid_sfincs_folder.as_posix()}."
+                )
 
+        # Dem file always assumed to be in /static/dem
         return DemModel(
-            filename=fa_subgrid_path.name, units=us.UnitTypesLength.meters
-        )  # always in meters
+            filename=fa_subgrid_path.name,
+            units=us.UnitTypesLength.meters,  # SINFCS always in meters
+            index_filename=fa_index_path.name,
+        )
 
     @debug_timer
     def create_sfincs_model_config(self) -> SfincsConfigModel:
@@ -1663,7 +1662,7 @@ class DatabaseBuilder:
             db_file_path.parent.mkdir(parents=True, exist_ok=True)
             shutil.copyfile(self.config.tide_gauge.file, db_file_path)
 
-            rel_db_path = Path(db_file_path.relative_to(self.static_path))
+            rel_db_path = Path(db_file_path.relative_to(self.static_path)).as_posix()
             logger.warning(
                 f"Tide gauge from file {rel_db_path} assumed to be in {self.unit_system.default_length_units}!"
             )
@@ -1795,26 +1794,22 @@ class DatabaseBuilder:
         if self.sfincs_offshore_model is None:
             return None
         # Connect boundary points of overland to output points of offshore
+        # First read in the boundary locations from the overland model
         fn = Path(self.sfincs_overland_model.root) / "sfincs.bnd"
-        bnd = pd.read_csv(fn, sep=" ", lineterminator="\n", header=None)
-        bnd = bnd.rename(columns={0: "x", 1: "y"})
-        bnd_geo = gpd.GeoDataFrame(
-            bnd,
-            geometry=gpd.points_from_xy(bnd.x, bnd.y),
+        lines = []
+        if fn.exists():
+            with open(fn) as f:
+                lines = f.readlines()
+        coords = [(float(line.split()[0]), float(line.split()[1])) for line in lines]
+        x, y = zip(*coords)
+        bnd = gpd.GeoDataFrame(
+            geometry=gpd.points_from_xy(x, y),
             crs=self.sfincs_overland_model.config["epsg"],
         )
-        obs_geo = bnd_geo.to_crs(4326)
-        obs_geo["x"] = obs_geo.geometry.x
-        obs_geo["y"] = obs_geo.geometry.y
-        del obs_geo["geometry"]
-        obs_geo["name"] = [f"bnd_pt{num:02d}" for num in range(1, len(obs_geo) + 1)]
-        fn_off = Path(self.sfincs_offshore_model.root) / "sfincs.obs"
-        obs_geo.to_csv(
-            fn_off,
-            sep="\t",
-            index=False,
-            header=False,
-        )
+        # Then transform points to offshore crs and save them as observation points
+        obs_geo = bnd.to_crs(self.sfincs_offshore_model.config["epsg"])
+        self.sfincs_offshore_model.setup_observation_points(obs_geo)
+        self.sfincs_offshore_model.write()
         logger.info(
             "Output points of the offshore SFINCS model were reconfigured to the boundary points of the overland SFINCS model."
         )

flood_adapt/dbs_classes/database.py

@@ -55,16 +55,16 @@ class Database(IDatabase):
     static_path: Path
     output_path: Path
 
-    _site: Site
+    site: Site
 
-    _events: DbsEvent
-    _scenarios: DbsScenario
-    _strategies: DbsStrategy
-    _measures: DbsMeasure
-    _projections: DbsProjection
-    _benefits: DbsBenefit
+    events: DbsEvent
+    scenarios: DbsScenario
+    strategies: DbsStrategy
+    measures: DbsMeasure
+    projections: DbsProjection
+    benefits: DbsBenefit
 
-    _static: DbsStatic
+    static: DbsStatic
 
     def __new__(cls, *args, **kwargs):
         if not cls._instance:  # Singleton pattern
@@ -112,32 +112,39 @@ class Database(IDatabase):
         self.database_name = database_name
 
         # Set the paths
-
         self.base_path = Path(database_path) / database_name
         self.input_path = db_path(TopLevelDir.input)
         self.static_path = db_path(TopLevelDir.static)
         self.output_path = db_path(TopLevelDir.output)
 
-        self._site = Site.load_file(self.static_path / "config" / "site.toml")
+        # Read site configuration
+        self.read_site()
+
+        # Delete any unfinished/crashed scenario output after initialization
+        self._init_done = True
+        self.cleanup()
+
+    def read_site(self, site_name: str = "site") -> None:
+        """Read the site configuration from the static config folder and update database attributes."""
+        site_path = self.static_path / "config" / f"{site_name}.toml"
+        if not site_path.exists():
+            raise ConfigError(
+                f"Site configuration file '{site_path}' does not exist in the database."
+            )
+        self.site = Site.load_file(site_path)
 
         # Initialize the different database objects
-        self._static = DbsStatic(self)
-        self._events = DbsEvent(
-            self, standard_objects=self.site.standard_objects.events
-        )
-        self._scenarios = DbsScenario(self)
-        self._strategies = DbsStrategy(
+        self.static = DbsStatic(self)
+        self.events = DbsEvent(self, standard_objects=self.site.standard_objects.events)
+        self.scenarios = DbsScenario(self)
+        self.strategies = DbsStrategy(
             self, standard_objects=self.site.standard_objects.strategies
         )
-        self._measures = DbsMeasure(self)
-        self._projections = DbsProjection(
+        self.measures = DbsMeasure(self)
+        self.projections = DbsProjection(
             self, standard_objects=self.site.standard_objects.projections
         )
-        self._benefits = DbsBenefit(self)
-        self._init_done = True
-
-        # Delete any unfinished/crashed scenario output after initialization
-        self.cleanup()
+        self.benefits = DbsBenefit(self)
 
     def shutdown(self):
         """Explicitly shut down the singleton and clear all references."""
@@ -148,39 +155,6 @@ class Database(IDatabase):
         self.__dict__.clear()
         gc.collect()
 
-    # Property methods
-    @property
-    def site(self) -> Site:
-        return self._site
-
-    @property
-    def static(self) -> DbsStatic:
-        return self._static
-
-    @property
-    def events(self) -> DbsEvent:
-        return self._events
-
-    @property
-    def scenarios(self) -> DbsScenario:
-        return self._scenarios
-
-    @property
-    def strategies(self) -> DbsStrategy:
-        return self._strategies
-
-    @property
-    def measures(self) -> DbsMeasure:
-        return self._measures
-
-    @property
-    def projections(self) -> DbsProjection:
-        return self._projections
-
-    @property
-    def benefits(self) -> DbsBenefit:
-        return self._benefits
-
     def get_slr_scenarios(self) -> SlrScenariosModel:
         """Get the path to the SLR scenarios file.
 
@@ -203,7 +177,7 @@ class Database(IDatabase):
         dict[str, Any]
             Includes 'name', 'path', 'last_modification_date' and "finished" info
         """
-        all_scenarios = pd.DataFrame(self._scenarios.summarize_objects())
+        all_scenarios = pd.DataFrame(self.scenarios.summarize_objects())
         if len(all_scenarios) > 0:
             df = all_scenarios[all_scenarios["finished"]]
         else:
@@ -231,14 +205,14 @@ class Database(IDatabase):
 
         if mode == Mode.single_event:
             if _type == FloodmapType.water_level:
-                paths = [base_dir / "max_water_level_map.nc"]
+                paths = [base_dir / "max_water_level_map.tif"]
             elif _type == FloodmapType.water_depth:
                 paths = [base_dir / f"FloodMap_{scenario_name}.tif"]
         elif mode == Mode.risk:
             if _type == FloodmapType.water_level:
-                paths = list(base_dir.glob("RP_*_maps.nc"))
+                paths = list(base_dir.glob("RP_*_max_water_level_map.tif"))
             elif _type == FloodmapType.water_depth:
-                paths = list(base_dir.glob("RP_*_maps.tif"))
+                paths = list(base_dir.glob("RP_*_FloodMap.tif"))
         else:
             raise DatabaseError(
                 f"Flood map type '{_type}' is not valid. Must be one of 'water_level' or 'water_depth'."
@@ -284,7 +258,7 @@ class Database(IDatabase):
         str
             path to topobathy tiles
         """
-        path = self.input_path.parent.joinpath("static", "dem", "tiles", "topobathy")
+        path = self.static_path / "dem" / self.site.sfincs.dem.filename
         return path.as_posix()
 
     def get_index_path(self) -> str:
@@ -295,7 +269,7 @@ class Database(IDatabase):
         str
             path to index tiles
         """
-        path = self.input_path.parent.joinpath("static", "dem", "tiles", "indices")
+        path = self.static_path / "dem" / self.site.sfincs.dem.index_filename
         return path.as_posix()
 
     def get_depth_conversion(self) -> float:
@@ -333,23 +307,30 @@ class Database(IDatabase):
         np.array
             2D map of maximum water levels
         """
-        # If single event read with hydromt-sfincs
+        output_path = self.scenarios.output_path.joinpath(scenario_name, "Flooding")
+        # Check which file to use (if quadtree or regular)
         if not return_period:
-            map_path = self.scenarios.output_path.joinpath(
-                scenario_name,
-                "Flooding",
-                "max_water_level_map.nc",
-            )
-            with xr.open_dataarray(map_path) as map:
-                zsmax = map.to_numpy()
+            qt_path = output_path.joinpath("max_water_level_map_qt.nc")
+            if qt_path.is_file():
+                map_path = qt_path
+            else:
+                map_path = output_path.joinpath("max_water_level_map.tif")
         else:
-            file_path = self.scenarios.output_path.joinpath(
-                scenario_name,
-                "Flooding",
-                f"RP_{return_period:04d}_maps.nc",
+            qt_path = output_path.joinpath(
+                f"RP_{return_period:04d}_max_water_level_map_qt.nc"
             )
-            with xr.open_dataset(file_path) as ds:
-                zsmax = ds["risk_map"][:, :].to_numpy().T
+            if qt_path.is_file():
+                map_path = qt_path
+            else:
+                map_path = output_path.joinpath(
+                    f"RP_{return_period:04d}_max_water_level_map.tif"
+                )
+        # Open file
+        with xr.open_dataarray(map_path) as map:
+            zsmax = map.to_numpy()
+        # Make sure output is 1D array
+        if zsmax.ndim >= 2:
+            zsmax = zsmax.flatten("F")
         return zsmax
 
     def get_flood_map_geotiff(

flood_adapt/dbs_classes/interface/database.py

@@ -17,37 +17,14 @@ class IDatabase(ABC):
     output_path: Path
     static_path: Path
 
-    @property
-    @abstractmethod
-    def site(self) -> Site: ...
-
-    @property
-    @abstractmethod
-    def static(self) -> IDbsStatic: ...
-
-    @property
-    @abstractmethod
-    def events(self) -> AbstractDatabaseElement: ...
-
-    @property
-    @abstractmethod
-    def scenarios(self) -> AbstractDatabaseElement: ...
-
-    @property
-    @abstractmethod
-    def strategies(self) -> AbstractDatabaseElement: ...
-
-    @property
-    @abstractmethod
-    def measures(self) -> AbstractDatabaseElement: ...
-
-    @property
-    @abstractmethod
-    def projections(self) -> AbstractDatabaseElement: ...
-
-    @property
-    @abstractmethod
-    def benefits(self) -> AbstractDatabaseElement: ...
+    site: Site
+    static: IDbsStatic
+    events: AbstractDatabaseElement
+    scenarios: AbstractDatabaseElement
+    strategies: AbstractDatabaseElement
+    measures: AbstractDatabaseElement
+    projections: AbstractDatabaseElement
+    benefits: AbstractDatabaseElement
 
     @abstractmethod
     def __init__(

flood_adapt/objects/forcing/tide_gauge.py

@@ -8,6 +8,7 @@ import requests
 from noaa_coops.station import COOPSAPIError
 from pydantic import BaseModel, model_validator
 
+from flood_adapt.config import Settings
 from flood_adapt.misc.log import FloodAdaptLogging
 from flood_adapt.objects.forcing import unit_system as us
 from flood_adapt.objects.forcing.time_frame import TimeFrame
@@ -56,7 +57,7 @@ class TideGauge(BaseModel):
     source: TideGaugeSource
     reference: str
     ID: Optional[int] = None  # Attribute used to download from correct gauge
-    file: Optional[Path] = None  # for locally stored data
+    file: Optional[str] = None  # for locally stored data
     lat: Optional[float] = None
     lon: Optional[float] = None
     units: us.UnitTypesLength = (
@@ -104,7 +105,8 @@ class TideGauge(BaseModel):
         """
         logger.info(f"Retrieving waterlevels for tide gauge {self.ID} for {time}")
         if self.file:
-            gauge_data = self._read_imported_waterlevels(time=time, path=self.file)
+            abs_path = Settings().database_path / "static" / self.file
+            gauge_data = self._read_imported_waterlevels(time=time, path=abs_path)
         else:
             gauge_data = self._download_tide_gauge_data(time=time)
 

{flood_adapt-1.1.4.dist-info → flood_adapt-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 1.1.4
+Version: 2.0.0
 Summary: A software package support system which can be used to assess the benefits and costs of flood resilience measures
 Author-email: Gundula Winter <Gundula.Winter@deltares.nl>, Panos Athanasiou <Panos.Athanasiou@deltares.nl>, Frederique de Groen <Frederique.deGroen@deltares.nl>, Tim de Wilde <Tim.deWilde@deltares.nl>, Julian Hofer <Julian.Hofer@deltares.nl>, Daley Adrichem <Daley.Adrichem@deltares.nl>, Luuk Blom <Luuk.Blom@deltares.nl>
 License: ====================================================
@@ -717,7 +717,7 @@ Requires-Dist: fiona<2.0,>=1.0
 Requires-Dist: geojson<4.0,>=3.0
 Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: hydromt-fiat<1.0,>=0.5.9
-Requires-Dist: hydromt-sfincs<2.0,>=1.2.2
+Requires-Dist: hydromt-sfincs[quadtree]<2.0,>=1.2.2
 Requires-Dist: numpy<2.0,>=1.0
 Requires-Dist: numpy-financial<2.0,>=1.0
 Requires-Dist: pandas<3.0,>=2.0

{flood_adapt-1.1.4.dist-info → flood_adapt-2.0.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-flood_adapt/__init__.py,sha256=HuJSWvtJutuwuiXwgvArRmpnG72guATUP3IFvzowaJY,779
+flood_adapt/__init__.py,sha256=0Mmepm1Ybf2X10LM0cEeqbQkKiFRRCtOR95q9MEt58s,779
 flood_adapt/flood_adapt.py,sha256=HVFS4OFhcB0TqHtMw3kbEei0IfJxsciauHfG3XZ38-0,40747
 flood_adapt/adapter/__init__.py,sha256=vnF8NCkEVX-N-gtGS-J_A1H1YYAjihWjJZFyYGwcp8Q,180
-flood_adapt/adapter/fiat_adapter.py,sha256=seDjPoumkhUOd7qer3ni1_Ut3dwyq0-_yhJNaTEFc2E,60284
-flood_adapt/adapter/sfincs_adapter.py,sha256=_S-fABsi4flOkbrbIy_ROTuZrJyIMZtJu2wNh-TYSYs,79040
+flood_adapt/adapter/fiat_adapter.py,sha256=qUuyPeT9W2o_g8e8ZW38U7pCjLNqXY2MbPMk7_O2J-w,61579
+flood_adapt/adapter/sfincs_adapter.py,sha256=fuZOmLijmmz8RZY4aqSRUs_vAbcGrVwI4hmyTtaMd5c,82314
 flood_adapt/adapter/sfincs_offshore.py,sha256=DkqGwx0Fx4dojY1YH8tW3MUS4Omgd5DC6QINEsTP0Uk,7659
 flood_adapt/adapter/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flood_adapt/adapter/interface/hazard_adapter.py,sha256=S2NIUAMSRgxC_E-tZRJ2qIP06U1zEVdn-MnvMTrn86s,2828
@@ -13,12 +13,12 @@ flood_adapt/config/__init__.py,sha256=wfcPGORAGBXWUi8G7E5tLWvBS9A2ajJ9atHfxatExj
 flood_adapt/config/config.py,sha256=-aMmeBLE03O0Az-S9ms6Rz5hX8_5Kn2vr7IjjMI9w2o,9374
 flood_adapt/config/fiat.py,sha256=svx3zRp8ZcHifTl0hLbl2JCeYuqckxQFJjDd-C0oqok,3417
 flood_adapt/config/gui.py,sha256=9VFfzQOjRs4E6sY0bweBUpPGgHfKc7Az7yBlNetotcg,16784
-flood_adapt/config/hazard.py,sha256=Ev6mj78cZ_vQuJ11KYjhJOzmfRB6fz267OJeKI0bYaM,12216
+flood_adapt/config/hazard.py,sha256=NUBgIF7a72cSGPFsZtNHjjt6Uvov6TcEYJKrDl7WdV4,12255
 flood_adapt/config/impacts.py,sha256=O7vE7jB3GSXnkqAvv7TqJiJ_j1uJ3mck_KQ-ScsB3bo,3192
 flood_adapt/config/sfincs.py,sha256=y8C3PzFwwgMB_sb8rBzgteaQ8fCxep6DnZxuk0q__bc,4825
 flood_adapt/config/site.py,sha256=VR90jCHWcxgoQJptNyXy7LseGjXUDRtdOjNGCddFVzI,4328
 flood_adapt/database_builder/__init__.py,sha256=h4ietZ6sAZa7j2kvSzp5-58BueGrfJsXvq8PFu1RLyI,1112
-flood_adapt/database_builder/database_builder.py,sha256=cv_uwkKqgc8RLQ5lAmTqRN1fm5gBOYbIVR3v2MgD_gY,109935
+flood_adapt/database_builder/database_builder.py,sha256=GLhgceyj0R671XOQNbEah4d-OL3UBQN8IW3LgdZN4rQ,109986
 flood_adapt/database_builder/metrics_utils.py,sha256=aU7YfXLmBjFT0fQQQl3o0yIzdFJ6XJGlld0GnkJytGc,66258
 flood_adapt/database_builder/templates/default_units/imperial.toml,sha256=zIjPlxIa2kWLUjSYisd8UolXGo5iKdFoDDz_JkKBXTM,295
 flood_adapt/database_builder/templates/default_units/metric.toml,sha256=tc0XMKs7xGL9noB9lAb0gyQfjYxzokgHa3NqpccxWl0,302
@@ -56,7 +56,7 @@ flood_adapt/database_builder/templates/infographics/images/truck.png,sha256=0Ihv
 flood_adapt/database_builder/templates/infographics/images/walking_person.png,sha256=vaxO4oGejK5Q4KyGXuew2YgpGPabpnwLyxTFH1WMbmo,11080
 flood_adapt/database_builder/templates/output_layers/bin_colors.toml,sha256=yN3_h2IimOyjtfhZ-ZoWyNa-2cAeFRNlbvaNTLhEMfA,417
 flood_adapt/dbs_classes/__init__.py,sha256=J-a6BEkjDhuUzzRKuAn_AtTg_D9wNIsmY3BnVTiC2JA,731
-flood_adapt/dbs_classes/database.py,sha256=2OxzIrZOLmgv3wpq6cIKer1gchM6MuU2S9r2cHUZ4i8,23429
+flood_adapt/dbs_classes/database.py,sha256=D-x3n_YT230nccr30w-2LIy4VJYY4C1KrR79-uZibys,23447
 flood_adapt/dbs_classes/dbs_benefit.py,sha256=ayEYz8ga49HLdYuUsDWZOuZnpRnBpTuyhvfe2IyWAKI,1825
 flood_adapt/dbs_classes/dbs_event.py,sha256=ak3kHan6L1EfC8agDLKiCe8gaY5leOmj_qUBsI61q9A,1869
 flood_adapt/dbs_classes/dbs_measure.py,sha256=vVs-LtnHJN7eSGIFUglJdpbtfq_QI_Ftkv4lh5mfnNM,4085
@@ -65,7 +65,7 @@ flood_adapt/dbs_classes/dbs_scenario.py,sha256=LHWx3Dr1XR47bPyPRkR70h3VcT0f0MVgB
 flood_adapt/dbs_classes/dbs_static.py,sha256=Yzs-bsfAq2jkZ_-0_ojuzNf81Wifaxw8a1APNNS0mqM,10565
 flood_adapt/dbs_classes/dbs_strategy.py,sha256=qiEObHZeYL93GmdjSiGQls1ZmxdMZPkRkwzHgmoYwyE,4856
 flood_adapt/dbs_classes/dbs_template.py,sha256=b2x2sWNYTnaWU8Plgp51PFPrZGEv2kRRn9JBAgYhLbI,11578
-flood_adapt/dbs_classes/interface/database.py,sha256=kPHsmreB-vHaFD_FRXbP06tVs7pGxt4Rucim6aEqiKg,2550
+flood_adapt/dbs_classes/interface/database.py,sha256=uScyJ4HqKZv_zR5s_I-dRjkySL4WnSZ6zfpJiv-VG10,2112
 flood_adapt/dbs_classes/interface/element.py,sha256=XN3SjfEiAa4oZ61XJNnHkfKQu5Da42EH8PEkfosIJ9w,3528
 flood_adapt/dbs_classes/interface/static.py,sha256=amChHlParELA4vFMUn_kL1fx6z7fCFW-hJXBo7PGtbY,1588
 flood_adapt/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -95,7 +95,7 @@ flood_adapt/objects/forcing/meteo_handler.py,sha256=rTxY5WNobK_Ifzj2eVcoSPGgb3Tz
 flood_adapt/objects/forcing/netcdf.py,sha256=ZBzFtN5joVs36lVjvYErVaHEylUQ6eKIhR0uk_MD-zM,1388
 flood_adapt/objects/forcing/plotting.py,sha256=Y7f_9bY8d9jbd7BqEAeRmof-aaJhlznM3_wGBOI7g-s,14828
 flood_adapt/objects/forcing/rainfall.py,sha256=e6P3IMzItvnsmXbcMXl1oV-d9LDuh3jTIc_vt6Kz5zo,3282
-flood_adapt/objects/forcing/tide_gauge.py,sha256=XhplyNHtCn0hRM1oeD5v-fMYAOLAJIKidmxKxVxCUlw,7188
+flood_adapt/objects/forcing/tide_gauge.py,sha256=uPgvlcvDtZFQrtTyXX2d5YmSvCnjYYg0Xsu8NAwQZPQ,7299
 flood_adapt/objects/forcing/time_frame.py,sha256=1X3G0Ax18BHRvAomf-CW_ISRk_3qgAakwgZCIBxIkL4,2855
 flood_adapt/objects/forcing/timeseries.py,sha256=bD27JWzC3owq5ah3zPzJ7xoUzSH_t4J03s_SycYW0mQ,19740
 flood_adapt/objects/forcing/unit_system.py,sha256=7FFOmaxq6EOvXx64QDxlpNU4uMExqridFcdFwyTJ4Lo,16542
@@ -114,8 +114,8 @@ flood_adapt/objects/strategies/strategies.py,sha256=Jw-WJDCamL9p_7VEir3AdmYPMVAi
 flood_adapt/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flood_adapt/workflows/benefit_runner.py,sha256=eA21TuHdeZ6QYO8ehXri6BHlkyHsVsZphIdIca5g0KA,21824
 flood_adapt/workflows/scenario_runner.py,sha256=9_Y6GmMYhYoTRkBUIlju0eBy6DosGf4Zl2tgu1QEubI,4119
-flood_adapt-1.1.4.dist-info/LICENSE,sha256=Ui5E03pQ0EVKxvKA54lTPA1xrtgA2HMGLQai95eOzoE,36321
-flood_adapt-1.1.4.dist-info/METADATA,sha256=70kUiml9cQzOes7B0XAgpqzYCU1kAYuhSAiXLdmqa8U,48806
-flood_adapt-1.1.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-flood_adapt-1.1.4.dist-info/top_level.txt,sha256=JvzMi6cTcQPEThCfpgMEeVny3ghI1urSH0CCgVIqSzw,12
-flood_adapt-1.1.4.dist-info/RECORD,,
+flood_adapt-2.0.0.dist-info/LICENSE,sha256=Ui5E03pQ0EVKxvKA54lTPA1xrtgA2HMGLQai95eOzoE,36321
+flood_adapt-2.0.0.dist-info/METADATA,sha256=Wwh0sx_A5X37qDXGKZoTHgPUQiDtZe1nUOUeodSFt7I,48816
+flood_adapt-2.0.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+flood_adapt-2.0.0.dist-info/top_level.txt,sha256=JvzMi6cTcQPEThCfpgMEeVny3ghI1urSH0CCgVIqSzw,12
+flood_adapt-2.0.0.dist-info/RECORD,,