flood-adapt 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

flood_adapt/adapter/sfincs_adapter.py

@@ -88,6 +88,8 @@ from flood_adapt.objects.projections.projections import (
 )
 from flood_adapt.objects.scenarios.scenarios import Scenario
 
+logger = FloodAdaptLogging.getLogger("SfincsAdapter")
+
 
 class SfincsAdapter(IHazardAdapter):
     """Adapter for the SFINCS model.
@@ -100,7 +102,6 @@ class SfincsAdapter(IHazardAdapter):
         The settings for the SFINCS model.
     """
 
-    logger = FloodAdaptLogging.getLogger("SfincsAdapter")
     _site: Site
     _model: HydromtSfincsModel
 
@@ -119,9 +120,10 @@ class SfincsAdapter(IHazardAdapter):
         """
         self.settings = self.database.site.sfincs
         self.units = self.database.site.gui.units
-        self.sfincs_logger = self._setup_sfincs_logger(model_root)
         self._model = HydromtSfincsModel(
-            root=str(model_root.resolve()), mode="r", logger=self.sfincs_logger
+            root=str(model_root.resolve()),
+            mode="r",
+            logger=self._setup_sfincs_logger(model_root),
         )
         self._model.read()
 
@@ -150,12 +152,12 @@ class SfincsAdapter(IHazardAdapter):
 
     def close_files(self):
         """Close all open files and clean up file handles."""
-        for logger in [self.logger, self.sfincs_logger]:
-            if hasattr(logger, "handlers"):
-                for handler in logger.handlers:
+        for _logger in [logger, self.sfincs_logger]:
+            if hasattr(_logger, "handlers"):
+                for handler in _logger.handlers:
                     if isinstance(handler, logging.FileHandler):
                         handler.close()
-                        logger.removeHandler(handler)
+                        _logger.removeHandler(handler)
 
     def __enter__(self) -> "SfincsAdapter":
         return self
@@ -172,10 +174,18 @@ class SfincsAdapter(IHazardAdapter):
                 self._get_simulation_path(scenario, sub_event=sub_event)
                 for sub_event in event.sub_events
             ]
-            # No need to check postprocessing for risk scenarios
-            return all(self.sfincs_completed(sim_path) for sim_path in sim_paths)
+            if not all(sim_path.exists() for sim_path in sim_paths):
+                # simpaths dont exist, so check if the output files are still there
+                return self.run_completed(scenario)
+            else:
+                return all(self.sfincs_completed(sim_path) for sim_path in sim_paths)
         else:
-            return self.sfincs_completed(self._get_simulation_path(scenario))
+            if not self._get_simulation_path(scenario).exists():
+                # simpath doesnt exist, so check if the output files are still there
+                return self.run_completed(scenario)
+            else:
+                # Check if the simulation folder exists
+                return self.sfincs_completed(self._get_simulation_path(scenario))
 
     def execute(self, path: Path, strict: bool = True) -> bool:
         """
@@ -198,7 +208,7 @@ class SfincsAdapter(IHazardAdapter):
 
         """
         with cd(path):
-            self.logger.info(f"Running SFINCS in {path}")
+            logger.info(f"Running SFINCS in {path}")
             process = subprocess.run(
                 str(Settings().sfincs_bin_path),
                 stdout=subprocess.PIPE,
@@ -206,7 +216,7 @@ class SfincsAdapter(IHazardAdapter):
                 text=True,
             )
             self.sfincs_logger.info(process.stdout)
-            self.logger.debug(process.stdout)
+            logger.debug(process.stdout)
 
         self._cleanup_simulation_folder(path)
 
@@ -224,7 +234,7 @@ class SfincsAdapter(IHazardAdapter):
             if strict:
                 raise RuntimeError(f"SFINCS model failed to run in {path}.")
             else:
-                self.logger.error(f"SFINCS model failed to run in {path}.")
+                logger.error(f"SFINCS model failed to run in {path}.")
 
         return process.returncode == 0
 
@@ -261,7 +271,7 @@ class SfincsAdapter(IHazardAdapter):
         with SfincsAdapter(model_root=template_path) as model:
             model._load_scenario_objects(scenario, event)
             is_risk = "Probabilistic " if model._event_set is not None else ""
-            self.logger.info(
+            logger.info(
                 f"Preprocessing Scenario `{model._scenario.name}`: {is_risk}Event `{model._event.name}`, Strategy `{model._strategy.name}`, Projection `{model._projection.name}`"
             )
             # Write template model to output path and set it as the model root so focings can write to it
@@ -272,12 +282,11 @@ class SfincsAdapter(IHazardAdapter):
             for forcing in model._event.get_forcings():
                 model.add_forcing(forcing)
 
-            if self.rainfall is not None:
-                model.rainfall *= model._event.rainfall_multiplier
-            else:
-                model.logger.warning(
-                    "Failed to add event rainfall multiplier, no rainfall forcing found in the model."
+            if model.rainfall is not None:
+                logger.info(
+                    f"Adding event's rainfall multiplier: {model._event.rainfall_multiplier}"
                 )
+                model.rainfall *= model._event.rainfall_multiplier
 
             # Measures
             for measure in model._strategy.get_hazard_measures():
@@ -297,14 +306,14 @@ class SfincsAdapter(IHazardAdapter):
             raise ValueError(f"Unsupported event mode: {event.mode}.")
 
         sim_path = self._get_simulation_path(scenario=scenario, sub_event=event)
-        self.logger.info(f"Running SFINCS for single event Scenario `{scenario.name}`")
+        logger.info(f"Running SFINCS for single event Scenario `{scenario.name}`")
         self.execute(sim_path)
 
     def postprocess(self, scenario: Scenario, event: Event):
         if event.mode != Mode.single_event:
             raise ValueError(f"Unsupported event mode: {event.mode}.")
 
-        self.logger.info(f"Postprocessing SFINCS for Scenario `{scenario.name}`")
+        logger.info(f"Postprocessing SFINCS for Scenario `{scenario.name}`")
         if not self.sfincs_completed(
             self._get_simulation_path(scenario, sub_event=event)
         ):
@@ -316,7 +325,7 @@ class SfincsAdapter(IHazardAdapter):
 
     def set_timing(self, time: TimeFrame):
         """Set model reference times."""
-        self.logger.info(f"Setting timing for the SFINCS model: `{time}`")
+        logger.info(f"Setting timing for the SFINCS model: `{time}`")
         self._model.set_config("tref", time.start_time)
         self._model.set_config("tstart", time.start_time)
         self._model.set_config("tstop", time.end_time)
@@ -326,7 +335,7 @@ class SfincsAdapter(IHazardAdapter):
         if forcing is None:
             return
 
-        self.logger.info(
+        logger.info(
             f"Adding {forcing.type.capitalize()}: {forcing.source.capitalize()}"
         )
         if isinstance(forcing, IRainfall):
@@ -338,13 +347,13 @@ class SfincsAdapter(IHazardAdapter):
         elif isinstance(forcing, IWaterlevel):
             self._add_forcing_waterlevels(forcing)
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Skipping unsupported forcing type {forcing.__class__.__name__}"
             )
 
     def add_measure(self, measure: Measure):
         """Get measure data and add it."""
-        self.logger.info(
+        logger.info(
             f"Adding {measure.__class__.__name__.capitalize()} `{measure.name}`"
         )
 
@@ -355,38 +364,30 @@ class SfincsAdapter(IHazardAdapter):
         elif isinstance(measure, Pump):
             self._add_measure_pump(measure)
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Skipping unsupported measure type {measure.__class__.__name__}"
             )
 
     def add_projection(self, projection: Projection):
         """Get forcing data currently in the sfincs model and add the projection it."""
-        self.logger.info(f"Adding Projection `{projection.name}`")
+        logger.info(f"Adding Projection `{projection.name}`")
         phys_projection = projection.physical_projection
 
         if phys_projection.sea_level_rise:
-            self.logger.info(
-                f"Adding projected sea level rise `{phys_projection.sea_level_rise}`"
-            )
             if self.waterlevels is not None:
+                logger.info(
+                    f"Adding projected sea level rise `{phys_projection.sea_level_rise}`"
+                )
                 self.waterlevels += phys_projection.sea_level_rise.convert(
                     us.UnitTypesLength.meters
                 )
-            else:
-                self.logger.warning(
-                    "Failed to add sea level rise, no water level forcing found in the model."
-                )
 
         if phys_projection.rainfall_multiplier:
-            self.logger.info(
-                f"Adding projected rainfall multiplier `{phys_projection.rainfall_multiplier}`"
-            )
             if self.rainfall is not None:
-                self.rainfall *= phys_projection.rainfall_multiplier
-            else:
-                self.logger.warning(
-                    "Failed to add projected rainfall multiplier, no rainfall forcing found in the model."
+                logger.info(
+                    f"Adding projected rainfall multiplier `{phys_projection.rainfall_multiplier}`"
                 )
+                self.rainfall *= phys_projection.rainfall_multiplier
 
     ### GETTERS ###
     def get_model_time(self) -> TimeFrame:
@@ -554,7 +555,7 @@ class SfincsAdapter(IHazardAdapter):
         sim_path : Path, optional
             Path to the simulation folder, by default None.
         """
-        self.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
@@ -587,7 +588,7 @@ class SfincsAdapter(IHazardAdapter):
         self, scenario: Scenario, sim_path: Optional[Path] = None
     ):
         """Read simulation results from SFINCS and saves a netcdf with the maximum water levels."""
-        self.logger.info("Writing water level map to netcdf")
+        logger.info("Writing water level map to netcdf")
         results_path = self._get_result_path(scenario)
         sim_path = sim_path or self._get_simulation_path(scenario)
 
@@ -604,10 +605,10 @@ class SfincsAdapter(IHazardAdapter):
         Only for single event scenarios, or for a specific simulation path containing the written and processed sfincs model.
         """
         if not self.settings.obs_point:
-            self.logger.warning("No observation points provided in config.")
+            logger.warning("No observation points provided in config.")
             return
 
-        self.logger.info("Plotting water levels at observation points")
+        logger.info("Plotting water levels at observation points")
         sim_path = self._get_simulation_path(scenario)
 
         # read SFINCS model
@@ -690,7 +691,7 @@ class SfincsAdapter(IHazardAdapter):
         """Add observation points provided in the site toml to SFINCS model."""
         if self.settings.obs_point is None:
             return
-        self.logger.info("Adding observation points to the overland flood model")
+        logger.info("Adding observation points to the overland flood model")
 
         obs_points = self.settings.obs_point
         names = []
@@ -718,7 +719,7 @@ class SfincsAdapter(IHazardAdapter):
         wl_df: pd.DataFrame
             time series of water level.
         """
-        self.logger.info("Reading water levels from offshore model")
+        logger.info("Reading water levels from offshore model")
         ds_his = utils.read_sfincs_his_results(
             Path(self._model.root) / "sfincs_his.nc",
             crs=self._model.crs.to_epsg(),
@@ -778,7 +779,7 @@ class SfincsAdapter(IHazardAdapter):
                 zs_maps.append(zsmax)
 
         # Create RP flood maps
-        self.logger.info("Calculating flood risk maps, this may take some time")
+        logger.info("Calculating flood risk maps, this may take some time")
         rp_flood_maps = self.calc_rp_maps(
             floodmaps=zs_maps,
             frequencies=frequencies,
@@ -831,7 +832,7 @@ class SfincsAdapter(IHazardAdapter):
         self.process(scenario, event)
         self.postprocess(scenario, event)
 
-        if self.settings.config.save_simulation:
+        if not self.settings.config.save_simulation:
             self._delete_simulation_folder(scenario, sub_event=event)
 
     def _delete_simulation_folder(
@@ -841,7 +842,7 @@ class SfincsAdapter(IHazardAdapter):
         sim_path = self._get_simulation_path(scenario, sub_event=sub_event)
         if sim_path.exists():
             shutil.rmtree(sim_path, ignore_errors=True)
-            self.logger.info(f"Deleted simulation folder: {sim_path}")
+            logger.info(f"Deleted simulation folder: {sim_path}")
 
         if sim_path.parent.exists() and not any(sim_path.parent.iterdir()):
             # Remove the parent directory `simulations` if it is empty
@@ -860,7 +861,7 @@ class SfincsAdapter(IHazardAdapter):
 
             # Preprocess
             self.preprocess(scenario, event=sub_event)
-            self.logger.info(
+            logger.info(
                 f"Running SFINCS for Eventset Scenario `{scenario.name}`, Event `{sub_event.name}` ({i + 1}/{total})"
             )
             self.execute(sim_path)
@@ -972,9 +973,7 @@ class SfincsAdapter(IHazardAdapter):
                 direction=None,
             )
         else:
-            self.logger.warning(
-                f"Unsupported wind forcing type: {wind.__class__.__name__}"
-            )
+            logger.warning(f"Unsupported wind forcing type: {wind.__class__.__name__}")
             return
 
     def _add_forcing_rain(self, rainfall: IRainfall):
@@ -1041,7 +1040,7 @@ class SfincsAdapter(IHazardAdapter):
             ds *= conversion
             self._model.setup_precip_forcing_from_grid(precip=ds, aggregate=False)
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Unsupported rainfall forcing type: {rainfall.__class__.__name__}"
             )
             return
@@ -1059,7 +1058,7 @@ class SfincsAdapter(IHazardAdapter):
         if isinstance(forcing, (DischargeConstant, DischargeCSV, DischargeSynthetic)):
             self._set_single_river_forcing(discharge=forcing)
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Unsupported discharge forcing type: {forcing.__class__.__name__}"
             )
 
@@ -1133,7 +1132,7 @@ class SfincsAdapter(IHazardAdapter):
             self._set_waterlevel_forcing(df_ts)
             self._turn_off_bnd_press_correction()
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Unsupported waterlevel forcing type: {forcing.__class__.__name__}"
             )
 
@@ -1171,7 +1170,7 @@ class SfincsAdapter(IHazardAdapter):
             )
 
         sim_path = self.get_model_root()
-        self.logger.info(f"Adding spiderweb forcing to Sfincs model: {sim_path.name}")
+        logger.info(f"Adding spiderweb forcing to Sfincs model: {sim_path.name}")
 
         # prevent SameFileError
         output_spw_path = sim_path / forcing.path.name
@@ -1222,9 +1221,9 @@ class SfincsAdapter(IHazardAdapter):
                 for height in gdf_floodwall["z"]
             ]
             gdf_floodwall["z"] = heights
-            self.logger.info("Using floodwall height from shape file.")
+            logger.info("Using floodwall height from shape file.")
         except Exception:
-            self.logger.warning(
+            logger.warning(
                 f"Could not use height data from file due to missing `z` column or missing values therein. Using uniform height of {floodwall.elevation} instead."
             )
             gdf_floodwall["z"] = floodwall.elevation.convert(
@@ -1318,12 +1317,12 @@ class SfincsAdapter(IHazardAdapter):
         if not isinstance(
             discharge, (DischargeConstant, DischargeSynthetic, DischargeCSV)
         ):
-            self.logger.warning(
+            logger.warning(
                 f"Unsupported discharge forcing type: {discharge.__class__.__name__}"
             )
             return
 
-        self.logger.info(f"Setting discharge forcing for river: {discharge.river.name}")
+        logger.info(f"Setting discharge forcing for river: {discharge.river.name}")
 
         time_frame = self.get_model_time()
         model_rivers = self._read_river_locations()
@@ -1374,9 +1373,7 @@ class SfincsAdapter(IHazardAdapter):
 
     def _turn_off_bnd_press_correction(self):
         """Turn off the boundary pressure correction in the sfincs model."""
-        self.logger.info(
-            "Turning off boundary pressure correction in the offshore model"
-        )
+        logger.info("Turning off boundary pressure correction in the offshore model")
         self._model.set_config("pavbnd", -9999)
 
     def _set_waterlevel_forcing(self, df_ts: pd.DataFrame):
@@ -1426,7 +1423,7 @@ class SfincsAdapter(IHazardAdapter):
             - Required coordinates: ['time', 'y', 'x']
             - spatial_ref: CRS
         """
-        self.logger.info("Adding pressure forcing to the offshore model")
+        logger.info("Adding pressure forcing to the offshore model")
         self._model.setup_pressure_forcing_from_grid(press=ds)
 
     def _add_bzs_from_bca(self, event: Event, physical_projection: PhysicalProjection):
@@ -1435,7 +1432,7 @@ class SfincsAdapter(IHazardAdapter):
         if self.settings.config.offshore_model is None:
             raise ValueError("No offshore model found in sfincs config.")
 
-        self.logger.info("Adding water level forcing to the offshore model")
+        logger.info("Adding water level forcing to the offshore model")
         sb = SfincsBoundary()
         sb.read_flow_boundary_points(self.get_model_root() / "sfincs.bnd")
         sb.read_astro_boundary_conditions(self.get_model_root() / "sfincs.bca")
@@ -1656,10 +1653,10 @@ class SfincsAdapter(IHazardAdapter):
 
         # Rainfall
         start = "Including" if include_rainfall else "Excluding"
-        self.logger.info(f"{start} rainfall in the spiderweb file")
+        logger.info(f"{start} rainfall in the spiderweb file")
         tc.include_rainfall = include_rainfall
 
-        self.logger.info(
+        logger.info(
             f"Creating spiderweb file for hurricane event `{name}`. This may take a while."
         )
 
@@ -1678,7 +1675,7 @@ class SfincsAdapter(IHazardAdapter):
         ):
             return tc
 
-        self.logger.info(f"Translating the track of the tropical cyclone `{tc.name}`")
+        logger.info(f"Translating the track of the tropical cyclone `{tc.name}`")
         # First convert geodataframe to the local coordinate system
         crs = pyproj.CRS.from_string(self.settings.config.csname)
         tc.track = tc.track.to_crs(crs)
@@ -1756,6 +1753,7 @@ class SfincsAdapter(IHazardAdapter):
         )
         sfincs_logger.setLevel(logging.DEBUG)
         sfincs_logger.addHandler(file_handler)
+        self.sfincs_logger = sfincs_logger
         return sfincs_logger
 
     def _cleanup_simulation_folder(
@@ -1799,7 +1797,7 @@ class SfincsAdapter(IHazardAdapter):
         )
 
         if df_gauge is None:
-            self.logger.warning(
+            logger.warning(
                 "No water level data available for the tide gauge. Could not add it to the plot."
             )
             return

flood_adapt/adapter/sfincs_offshore.py

@@ -23,9 +23,10 @@ from flood_adapt.objects.forcing.meteo_handler import MeteoHandler
 from flood_adapt.objects.forcing.wind import WindMeteo
 from flood_adapt.objects.scenarios.scenarios import Scenario
 
+logger = FloodAdaptLogging.getLogger("OffshoreSfincsAdapter")
+
 
 class OffshoreSfincsHandler(IOffshoreSfincsHandler, DatabaseUser):
-    logger = FloodAdaptLogging.getLogger("OffshoreSfincsAdapter")
     template_path: Path
 
     def __init__(self, scenario: Scenario, event: Event) -> None:
@@ -90,7 +91,7 @@ class OffshoreSfincsHandler(IOffshoreSfincsHandler, DatabaseUser):
         Args:
             sim_path path to the root of the offshore model
         """
-        self.logger.info(
+        logger.info(
             f"Preparing offshore model to generate waterlevels for `{self.scenario.name}`"
         )
         sim_path = self._get_simulation_path()
@@ -149,13 +150,11 @@ class OffshoreSfincsHandler(IOffshoreSfincsHandler, DatabaseUser):
             _offshore_model.write(path_out=sim_path)
 
     def _execute_sfincs_offshore(self, sim_path: Path):
-        self.logger.info(f"Running offshore model in {sim_path}")
+        logger.info(f"Running offshore model in {sim_path}")
         sim_path = self._get_simulation_path()
         with SfincsAdapter(model_root=sim_path) as _offshore_model:
             if _offshore_model.sfincs_completed(sim_path):
-                self.logger.info(
-                    "Skip running offshore model as it has already been run."
-                )
+                logger.info("Skip running offshore model as it has already been run.")
                 return
             try:
                 _offshore_model.execute(path=sim_path)

flood_adapt/database_builder/database_builder.py

@@ -1,4 +1,5 @@
 import datetime
+import gc
 import logging
 import math
 import os
@@ -767,6 +768,7 @@ class DatabaseBuilder:
         logger.info(
             "Updating FIAT objects ground elevations from SFINCS ground elevation map."
         )
+        # Get unit conversion factor
         SFINCS_units = us.UnitfulLength(
             value=1.0, units=us.UnitTypesLength.meters
         )  # SFINCS is always in meters
@@ -777,11 +779,32 @@ class DatabaseBuilder:
             logger.info(
                 f"Ground elevation for FIAT objects is in '{FIAT_units}', while SFINCS ground elevation is in 'meters'. Values in the exposure csv will be converted by a factor of {conversion_factor}"
             )
-
+        # Read in DEM and objects
         exposure = self.fiat_model.exposure.exposure_db
         dem = rxr.open_rasterio(dem_file)
-
         gdf = self._get_fiat_gdf_full()
+
+        # Ensure gdf has the same CRS as dem
+        # Determine the CRS to use for sampling
+        if (
+            hasattr(self.sfincs_overland_model, "crs")
+            and self.sfincs_overland_model.crs is not None
+        ):
+            target_crs = self.sfincs_overland_model.crs
+        elif (
+            hasattr(dem, "rio") and hasattr(dem.rio, "crs") and dem.rio.crs is not None
+        ):
+            target_crs = dem.rio.crs
+        else:
+            target_crs = gdf.crs
+            logger.warning(
+                "Could not determine CRS from SFINCS model or DEM raster. Assuming the CRS is the same as the FIAT model."
+            )
+
+        if gdf.crs != target_crs:
+            gdf = gdf.to_crs(target_crs)
+
+        # Sample DEM at the centroid of each geometry
         gdf["centroid"] = gdf.geometry.centroid
         x_points = xr.DataArray(gdf["centroid"].x, dims="points")
         y_points = xr.DataArray(gdf["centroid"].y, dims="points")
@@ -790,6 +813,7 @@ class DatabaseBuilder:
             * conversion_factor
         )
 
+        # Merge updated elevation back into exposure DataFrame
         exposure = exposure.merge(
             gdf[[_FIAT_COLUMNS.object_id, "elev"]],
             on=_FIAT_COLUMNS.object_id,
@@ -1287,13 +1311,14 @@ class DatabaseBuilder:
     def create_dem_model(self) -> DemModel:
         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 = (
-                Path(self.sfincs_overland_model.root) / "subgrid" / "dep_subgrid.tif"
-            )
+            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)
         fa_subgrid_path = self.static_path / "dem" / dem_file.name
@@ -1324,6 +1349,13 @@ class DatabaseBuilder:
 
         shutil.copy2(dem_file, fa_subgrid_path)
         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():
+                shutil.rmtree(subgrid_sfincs_folder)
+
         return DemModel(
             filename=fa_subgrid_path.name, units=us.UnitTypesLength.meters
         )  # always in meters