flood-adapt 1.0.0rc1__py3-none-any.whl → 1.0.2__py3-none-any.whl

flood_adapt/dbs_classes/database.py

@@ -12,6 +12,7 @@ import xarray as xr
 from geopandas import GeoDataFrame
 
 from flood_adapt.config.hazard import SlrScenariosModel
+from flood_adapt.config.impacts import FloodmapType
 from flood_adapt.config.site import Site
 from flood_adapt.dbs_classes.dbs_benefit import DbsBenefit
 from flood_adapt.dbs_classes.dbs_event import DbsEvent
@@ -30,8 +31,11 @@ from flood_adapt.misc.path_builder import (
 from flood_adapt.misc.utils import finished_file_exists
 from flood_adapt.objects.events.events import Mode
 from flood_adapt.objects.forcing import unit_system as us
+from flood_adapt.objects.output.floodmap import FloodMap
 from flood_adapt.workflows.scenario_runner import ScenarioRunner
 
+logger = FloodAdaptLogging.getLogger("Database")
+
 
 class Database(IDatabase):
     """Implementation of IDatabase class that holds the site information and has methods to get static data info, and all the input information.
@@ -100,8 +104,7 @@ class Database(IDatabase):
 
         # If the database is not initialized, or a new path or name is provided, (re-)initialize
         re_option = "re-" if self._init_done else ""
-        self.logger = FloodAdaptLogging.getLogger("Database")
-        self.logger.info(
+        logger.info(
             f"{re_option}initializing database to {database_name} at {database_path}".capitalize()
         )
         self.database_path = database_path
@@ -209,6 +212,71 @@ class Database(IDatabase):
         finished = df.drop(columns="finished").reset_index(drop=True)
         return finished.to_dict()
 
+    def get_floodmap(self, scenario_name: str) -> FloodMap:
+        """Return the flood map for a given scenario.
+
+        Parameters
+        ----------
+        scenario_name : str
+            Name of the scenario
+
+        Returns
+        -------
+        FloodMap
+            Flood map object containing the paths to the flood map files and their type.
+        """
+        _type = self.site.fiat.config.floodmap_type
+        event = self.scenarios.get(scenario_name).event
+        mode = self.events.get(event).mode
+        base_dir = self.scenarios.output_path / scenario_name / "Flooding"
+
+        if mode == Mode.single_event:
+            if _type == FloodmapType.water_level:
+                paths = [base_dir / "max_water_level_map.nc"]
+            elif _type == FloodmapType.water_depth:
+                paths = [base_dir / f"FloodMap_{self.name}.tif"]
+        elif mode == Mode.risk:
+            if _type == FloodmapType.water_level:
+                paths = list(base_dir.glob("RP_*_maps.nc"))
+            elif _type == FloodmapType.water_depth:
+                paths = list(base_dir.glob("RP_*_maps.tif"))
+        else:
+            raise DatabaseError(
+                f"Flood map type '{_type}' is not valid. Must be one of 'water_level' or 'water_depth'."
+            )
+
+        return FloodMap(name=scenario_name, map_type=_type, mode=mode, paths=paths)
+
+    def get_impacts_path(self, scenario_name: str) -> Path:
+        """Return the path to the impacts folder containing the impact runs for a given scenario.
+
+        Parameters
+        ----------
+        scenario_name : str
+            Name of the scenario
+
+        Returns
+        -------
+        Path
+            Path to the impacts folder for the given scenario
+        """
+        return self.scenarios.output_path.joinpath(scenario_name, "Impacts")
+
+    def get_flooding_path(self, scenario_name: str) -> Path:
+        """Return the path to the flooding folder containing the hazard runs for a given scenario.
+
+        Parameters
+        ----------
+        scenario_name : str
+            Name of the scenario
+
+        Returns
+        -------
+        Path
+            Path to the flooding folder for the given scenario
+        """
+        return self.scenarios.output_path.joinpath(scenario_name, "Flooding")
+
     def get_topobathy_path(self) -> str:
         """Return the path of the topobathy tiles in order to create flood maps with water level maps.
 
@@ -317,7 +385,7 @@ class Database(IDatabase):
                 f"RP_{return_period:04d}_maps.tif",
             )
         if not file_path.is_file():
-            self.logger.warning(
+            logger.warning(
                 f"Flood map for scenario '{scenario_name}' at {file_path} does not exist."
             )
             return None
@@ -454,10 +522,9 @@ class Database(IDatabase):
             name of the scenario to check if needs to be rerun for hazard
         """
         scenario = self.scenarios.get(scenario_name)
-        runner = ScenarioRunner(self, scenario=scenario)
 
         # Dont do anything if the hazard model has already been run in itself
-        if runner.impacts.hazard.has_run:
+        if ScenarioRunner(self, scenario=scenario).hazard_run_check():
             return
 
         scenarios = [
@@ -476,16 +543,16 @@ class Database(IDatabase):
                 path_new = self.scenarios.output_path.joinpath(
                     scenario.name, "Flooding"
                 )
-                _runner = ScenarioRunner(self, scenario=scn)
 
-                if _runner.impacts.hazard.has_run:  # only copy results if the hazard model has actually finished and skip simulation folders
+                if ScenarioRunner(self, scenario=scn).hazard_run_check():
+                    # only copy results if the hazard model has actually finished and skip simulation folders
                     shutil.copytree(
                         existing,
                         path_new,
                         dirs_exist_ok=True,
                         ignore=shutil.ignore_patterns("simulations"),
                     )
-                    self.logger.info(
+                    logger.info(
                         f"Hazard simulation is used from the '{scn.name}' scenario"
                     )
 
@@ -509,9 +576,6 @@ class Database(IDatabase):
             (self.scenarios.output_path / dir).resolve()
             for dir in os.listdir(self.scenarios.output_path)
         ]
-        self.logger.info(
-            f"Cleaning up scenario outputs: {len(output_scenarios)} scenarios found."
-        )
 
         def _call_garbage_collector(func, path, exc_info, retries=5, delay=0.1):
             """Retry deletion up to 5 times if the file is locked."""
@@ -528,15 +592,16 @@ class Database(IDatabase):
 
             print(f"Giving up on deleting {path} after {retries} attempts.")
 
-        for dir in output_scenarios:
+        for _dir in output_scenarios:
             # Delete if: input was deleted or corrupted output due to unfinished run
-            if dir.name not in [
+            if _dir.name not in [
                 path.name for path in input_scenarios
-            ] or not finished_file_exists(dir):
-                shutil.rmtree(dir, onerror=_call_garbage_collector)
-            # If the scenario is finished, delete the simulation folders
-            elif finished_file_exists(dir):
-                self._delete_simulations(dir.name)
+            ] or not finished_file_exists(_dir):
+                logger.info(f"Cleaning up corrupted outputs of scenario: {_dir.name}.")
+                shutil.rmtree(_dir, onerror=_call_garbage_collector)
+            # If the scenario is finished, delete the simulation folders depending on `save_simulation`
+            elif finished_file_exists(_dir):
+                self._delete_simulations(_dir.name)
 
     def _delete_simulations(self, scenario_name: str) -> None:
         """Delete all simulation folders for a given scenario.
@@ -556,7 +621,6 @@ class Database(IDatabase):
             if sub_events:
                 for sub_event in sub_events:
                     overland._delete_simulation_folder(scn, sub_event=sub_event)
-
             else:
                 overland._delete_simulation_folder(scn)
 
@@ -570,7 +634,7 @@ class Database(IDatabase):
                         )
                         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()
                         ):
@@ -580,7 +644,7 @@ class Database(IDatabase):
                     sim_path = offshore._get_simulation_path_offshore(scn)
                     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

flood_adapt/dbs_classes/dbs_static.py

@@ -1,11 +1,13 @@
 from pathlib import Path
-from typing import Any, Callable, Tuple, Union
+from typing import Any, Callable, Optional, 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.interface.hazard_adapter import IHazardAdapter
+from flood_adapt.adapter.interface.impact_adapter import IImpactAdapter
 from flood_adapt.adapter.sfincs_adapter import SfincsAdapter
 from flood_adapt.config.config import Settings
 from flood_adapt.dbs_classes.interface.database import IDatabase
@@ -85,6 +87,7 @@ class DbsStatic(IDbsStatic):
     def get_model_boundary(self) -> gpd.GeoDataFrame:
         """Get the model boundary from the SFINCS model."""
         bnd = self.get_overland_sfincs_model().get_model_boundary()
+        bnd = bnd[["geometry"]]
         return bnd
 
     @cache_method_wrapper
@@ -100,19 +103,20 @@ class DbsStatic(IDbsStatic):
         return grid
 
     @cache_method_wrapper
-    def get_obs_points(self) -> gpd.GeoDataFrame:
+    def get_obs_points(self) -> Optional[gpd.GeoDataFrame]:
         """Get the observation points from the flood hazard model."""
+        if self._database.site.sfincs.obs_point is None:
+            return None
+
         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)
+        for pt in self._database.site.sfincs.obs_point:
+            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})
@@ -223,6 +227,26 @@ class DbsStatic(IDbsStatic):
         """
         return self.get_fiat_model().get_property_types()
 
+    def get_hazard_models(self) -> list[IHazardAdapter]:
+        """Get the hazard models from the database.
+
+        Returns
+        -------
+        list[HazardAdapter]
+            List of hazard models
+        """
+        return [self.get_overland_sfincs_model()]
+
+    def get_impact_models(self) -> list[IImpactAdapter]:
+        """Get the impact models from the database.
+
+        Returns
+        -------
+        list[ImpactAdapter]
+            List of impact models
+        """
+        return [self.get_fiat_model()]
+
     def get_overland_sfincs_model(self) -> SfincsAdapter:
         """Get the template offshore SFINCS model."""
         overland_path = (

flood_adapt/dbs_classes/interface/static.py

@@ -6,6 +6,8 @@ import geopandas as gpd
 import pandas as pd
 from cht_cyclones.cyclone_track_database import CycloneTrackDatabase
 
+from flood_adapt.adapter.interface.hazard_adapter import IHazardAdapter
+from flood_adapt.adapter.interface.impact_adapter import IImpactAdapter
 from flood_adapt.adapter.sfincs_adapter import SfincsAdapter
 
 
@@ -37,6 +39,12 @@ class IDbsStatic(ABC):
     @abstractmethod
     def get_property_types(self) -> list: ...
 
+    @abstractmethod
+    def get_impact_models(self) -> list[IImpactAdapter]: ...
+
+    @abstractmethod
+    def get_hazard_models(self) -> list[IHazardAdapter]: ...
+
     @abstractmethod
     def get_overland_sfincs_model(self) -> SfincsAdapter: ...
 

flood_adapt/flood_adapt.py

@@ -38,9 +38,10 @@ from flood_adapt.objects.projections.projections import Projection
 from flood_adapt.objects.scenarios.scenarios import Scenario
 from flood_adapt.objects.strategies.strategies import Strategy
 from flood_adapt.workflows.benefit_runner import BenefitRunner
-from flood_adapt.workflows.impacts_integrator import Impacts
 from flood_adapt.workflows.scenario_runner import ScenarioRunner
 
+logger = FloodAdaptLogging.getLogger()
+
 
 class FloodAdapt:
     database: Database
@@ -56,7 +57,6 @@ class FloodAdapt:
         self.database = Database(
             database_path=database_path.parent, database_name=database_path.name
         )
-        self.logger = FloodAdaptLogging.getLogger()
 
     # Measures
     def get_measures(self) -> dict[str, Any]:
@@ -718,8 +718,7 @@ class FloodAdapt:
 
         for scn in scenario_name:
             scenario = self.get_scenario(scn)
-            runner = ScenarioRunner(self.database, scenario=scenario)
-            runner.run()
+            ScenarioRunner(self.database, scenario=scenario).run()
 
     # Outputs
     def get_completed_scenarios(
@@ -858,7 +857,7 @@ class FloodAdapt:
         """
         return self.database.get_roads(name)
 
-    def get_obs_point_timeseries(self, name: str) -> gpd.GeoDataFrame:
+    def get_obs_point_timeseries(self, name: str) -> Optional[gpd.GeoDataFrame]:
         """Return the HTML strings of the water level timeseries for the given scenario.
 
         Parameters
@@ -868,27 +867,35 @@ class FloodAdapt:
 
         Returns
         -------
-        html_path : str
-            The HTML strings of the water level timeseries
-        """
+        gdf : GeoDataFrame, optional
+            A GeoDataFrame with the observation points and their corresponding HTML paths for the timeseries.
+            Each row contains the station name and the path to the HTML file with the timeseries.
+            None if no observation points are found or if the scenario has not been run yet.
+        """
+        obs_points = self.database.static.get_obs_points()
+        if obs_points is None:
+            logger.info(
+                "No observation points found in the sfincs model and site configuration."
+            )
+            return None
+
         # Get the impacts objects from the scenario
         scenario = self.database.scenarios.get(name)
-        hazard = Impacts(scenario).hazard
 
         # Check if the scenario has run
-        if not hazard.has_run:
-            raise ValueError(
-                f"Scenario {name} has not been run. Please run the scenario first."
+        if not ScenarioRunner(self.database, scenario=scenario).hazard_run_check():
+            logger.info(
+                f"Cannot retrieve observation point timeseries as the scenario {name} has not been run yet."
             )
+            return None
 
-        output_path = self.database.scenarios.output_path.joinpath(hazard.name)
-        gdf = self.database.static.get_obs_points()
-        gdf["html"] = [
-            str(output_path.joinpath("Flooding", f"{station}_timeseries.html"))
-            for station in gdf.name
+        output_path = self.database.get_flooding_path(scenario.name)
+        obs_points["html"] = [
+            str(output_path.joinpath(f"{station}_timeseries.html"))
+            for station in obs_points.name
         ]
 
-        return gdf
+        return obs_points
 
     def get_infographic(self, name: str) -> str:
         """Return the HTML string of the infographic for the given scenario.
@@ -1184,8 +1191,7 @@ class FloodAdapt:
         scenarios : pd.DataFrame
             A dataframe with the scenarios needed for this benefit assessment run.
         """
-        runner = BenefitRunner(self.database, benefit=benefit)
-        return runner.scenarios
+        return BenefitRunner(self.database, benefit=benefit).scenarios
 
     def create_benefit_scenarios(self, benefit: Benefit) -> None:
         """Create the benefit scenarios.
@@ -1195,8 +1201,7 @@ class FloodAdapt:
         benefit : Benefit
             The benefit object to create scenarios for.
         """
-        runner = BenefitRunner(self.database, benefit=benefit)
-        runner.create_benefit_scenarios()
+        BenefitRunner(self.database, benefit=benefit).create_benefit_scenarios()
 
     def run_benefit(self, name: Union[str, list[str]]) -> None:
         """Run the benefit assessment.
@@ -1210,8 +1215,7 @@ class FloodAdapt:
             benefit_name = [name]
         for name in benefit_name:
             benefit = self.database.benefits.get(name)
-            runner = BenefitRunner(self.database, benefit=benefit)
-            runner.run_cost_benefit()
+            BenefitRunner(self.database, benefit=benefit).run_cost_benefit()
 
     def get_aggregated_benefits(self, name: str) -> dict[str, gpd.GeoDataFrame]:
         """Get the aggregation benefits for a benefit assessment.

flood_adapt/objects/forcing/forcing.py

@@ -1,15 +1,13 @@
-import logging
 import os
 from abc import ABC, abstractmethod
 from enum import Enum
 from pathlib import Path
-from typing import Any, ClassVar, List, Type
+from typing import Any, List, Type
 
 import tomli
 from pydantic import BaseModel, field_serializer
 
 from flood_adapt.config.hazard import RiverModel
-from flood_adapt.misc.log import FloodAdaptLogging
 
 
 ### ENUMS ###
@@ -55,7 +53,6 @@ class IForcing(BaseModel, ABC):
 
     type: ForcingType
     source: ForcingSource
-    logger: ClassVar[logging.Logger] = FloodAdaptLogging.getLogger("Forcing")
 
     @classmethod
     def load_file(cls, path: Path):

flood_adapt/objects/forcing/tide_gauge.py

@@ -12,6 +12,8 @@ from flood_adapt.objects.forcing import unit_system as us
 from flood_adapt.objects.forcing.time_frame import TimeFrame
 from flood_adapt.objects.forcing.timeseries import CSVTimeseries
 
+logger = FloodAdaptLogging.getLogger("TideGauge")
+
 
 class TideGaugeSource(str, Enum):
     """The accepted input for the variable source in tide_gauge."""
@@ -61,7 +63,6 @@ class TideGauge(BaseModel):
     )  # units of the water levels in the downloaded file
 
     _cached_data: ClassVar[dict[str, pd.DataFrame]] = {}
-    logger: ClassVar = FloodAdaptLogging.getLogger("TideGauge")
 
     @model_validator(mode="after")
     def validate_selection_type(self) -> "TideGauge":
@@ -100,16 +101,14 @@ class TideGauge(BaseModel):
         pd.DataFrame
             Dataframe with time as index and the waterlevel for each observation station as columns.
         """
-        self.logger.info(f"Retrieving waterlevels for tide gauge {self.ID} for {time}")
+        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)
         else:
             gauge_data = self._download_tide_gauge_data(time=time)
 
         if gauge_data is None:
-            self.logger.warning(
-                f"Could not retrieve waterlevels for tide gauge {self.ID}"
-            )
+            logger.warning(f"Could not retrieve waterlevels for tide gauge {self.ID}")
             return pd.DataFrame()
 
         gauge_data.columns = [f"waterlevel_{self.ID}"]
@@ -159,7 +158,7 @@ class TideGauge(BaseModel):
         """
         cache_key = f"{self.ID}_{time.start_time}_{time.end_time}"
         if cache_key in self.__class__._cached_data:
-            self.logger.info("Tide gauge data retrieved from cache")
+            logger.info("Tide gauge data retrieved from cache")
             return self.__class__._cached_data[cache_key]
 
         try:
@@ -180,7 +179,7 @@ class TideGauge(BaseModel):
             df = pd.DataFrame(data=series, index=index)
 
         except COOPSAPIError as e:
-            self.logger.error(
+            logger.error(
                 f"Could not download tide gauge data for station {self.ID}. {e}"
             )
             return None

flood_adapt/objects/forcing/timeseries.py

@@ -535,7 +535,6 @@ class TimeseriesFactory:
                         raise ValueError("SCS configuration not found in database.")
                     scs_file_name = scs_file_name or scs_config.file
                     scs_type = scs_type or scs_config.type
-
                 return ScsTimeseries(
                     duration=duration,
                     peak_time=peak_time,

flood_adapt/objects/output/floodmap.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from flood_adapt.config.impacts import FloodmapType
+from flood_adapt.objects.events.events import Mode
+
+
+class FloodMap(BaseModel):
+    name: str
+    map_type: FloodmapType
+    mode: Mode
+    paths: list[Path]

flood_adapt/workflows/scenario_runner.py

@@ -3,7 +3,8 @@ from flood_adapt.dbs_classes.interface.database import IDatabase
 from flood_adapt.misc.log import FloodAdaptLogging
 from flood_adapt.misc.utils import finished_file_exists, write_finished_file
 from flood_adapt.objects.scenarios.scenarios import Scenario
-from flood_adapt.workflows.impacts_integrator import Impacts
+
+logger = FloodAdaptLogging.getLogger("ScenarioRunner")
 
 
 class ScenarioRunner:
@@ -11,12 +12,21 @@ class ScenarioRunner:
 
     def __init__(self, database: IDatabase, scenario: Scenario) -> None:
         """Create a Scenario object."""
-        self.logger = FloodAdaptLogging.getLogger("ScenarioRunner")
         self._database = database
-        self._load_objects(scenario)
+        self._scenario = scenario
         self.site_info = self._database.site
         self.results_path = self._database.scenarios.output_path / self._scenario.name
 
+    @property
+    def impact_models(self):
+        """Return the list of impact models."""
+        return self._database.static.get_impact_models()
+
+    @property
+    def hazard_models(self):
+        """Return the list of hazard models."""
+        return self._database.static.get_hazard_models()
+
     def _load_objects(self, scenario: Scenario) -> None:
         """Load objects from the database."""
         self._scenario = scenario
@@ -24,12 +34,7 @@ class ScenarioRunner:
         self._projection = self._database.projections.get(scenario.projection)
         self._strategy = self._database.strategies.get(scenario.strategy)
 
-    @property
-    def impacts(self) -> Impacts:
-        return Impacts(
-            scenario=self._scenario,
-        )
-
+    ### General methods ###
     def run(self) -> None:
         """Run hazard and impact models for the scenario."""
         self._database.has_run_hazard(self._scenario.name)
@@ -39,28 +44,11 @@ class ScenarioRunner:
         # Initiate the logger for all the integrator scripts.
         log_file = self.results_path.joinpath(f"logfile_{self._scenario.name}.log")
         with FloodAdaptLogging.to_file(file_path=log_file):
-            self.logger.info(f"FloodAdapt version `{__version__}`")
-            self.logger.info(f"Started evaluation of `{self._scenario.name}`")
-
-            hazard_models = [
-                self._database.static.get_overland_sfincs_model(),
-            ]
-            for hazard in hazard_models:
-                if not hazard.run_completed(self._scenario):
-                    hazard.run(self._scenario)
-                else:
-                    self.logger.info(
-                        f"Hazard for scenario '{self._scenario.name}' has already been run."
-                    )
-
-            if not self.impacts.has_run:
-                self.impacts.run()
-            else:
-                self.logger.info(
-                    f"Impacts for scenario `{self._scenario.name}` has already been run."
-                )
-
-            self.logger.info(f"Finished evaluation of `{self._scenario.name}`")
+            logger.info(f"FloodAdapt version `{__version__}`")
+            logger.info(f"Started evaluation of `{self._scenario.name}`")
+            self._run_hazards()
+            self._run_impacts()
+            logger.info(f"Finished evaluation of `{self._scenario.name}`")
 
         # write finished file to indicate that the scenario has been run
         write_finished_file(self.results_path)
@@ -68,3 +56,41 @@ class ScenarioRunner:
     def has_run_check(self):
         """Check if the scenario has been run."""
         return finished_file_exists(self.results_path)
+
+    ### Hazard methods ###
+    def _run_hazards(self) -> None:
+        """Run the hazard model for the scenario."""
+        if self.hazard_run_check():
+            logger.info(f"Hazards for {self._scenario.name} have already been run.")
+            return
+        for model in self.hazard_models:
+            model.run(self._scenario)
+
+    def hazard_run_check(self) -> bool:
+        """Check if the impact has been run.
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        return all(model.has_run(self._scenario) for model in self.hazard_models)
+
+    ### Impact methods ###
+    def _run_impacts(self) -> None:
+        """Run the impact model(s)."""
+        if self.impacts_run_check():
+            logger.info(f"Impacts for {self._scenario.name} have already been run.")
+            return
+        for model in self.impact_models:
+            model.run(self._scenario)
+
+    def impacts_run_check(self) -> bool:
+        """Check if the impact has been run.
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        return all(model.has_run(self._scenario) for model in self.impact_models)