flood-adapt 0.3.0__py3-none-any.whl

flood_adapt/adapter/sfincs_offshore.py

@@ -0,0 +1,193 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+
+from flood_adapt.adapter.interface.offshore import IOffshoreSfincsHandler
+from flood_adapt.adapter.sfincs_adapter import SfincsAdapter
+from flood_adapt.misc.database_user import DatabaseUser
+from flood_adapt.misc.log import FloodAdaptLogging
+from flood_adapt.misc.path_builder import (
+    ObjectDir,
+    TopLevelDir,
+    db_path,
+)
+from flood_adapt.objects.events.event_set import EventSet
+from flood_adapt.objects.events.events import Event, Mode
+from flood_adapt.objects.events.historical import HistoricalEvent
+from flood_adapt.objects.forcing.forcing import (
+    ForcingSource,
+    IWind,
+)
+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
+
+
+class OffshoreSfincsHandler(IOffshoreSfincsHandler, DatabaseUser):
+    logger = FloodAdaptLogging.getLogger("OffshoreSfincsAdapter")
+    template_path: Path
+
+    def __init__(self, scenario: Scenario, event: Event) -> None:
+        self.template_path = (
+            self.database.static.get_offshore_sfincs_model().get_model_root()
+        )
+        self.scenario = scenario
+        if isinstance(event, EventSet):
+            raise ValueError(
+                "OffshoreSfincsHandler does not support EventSets. Provide the sub events directly "
+            )
+        self.event = event
+
+    def get_resulting_waterlevels(self) -> pd.DataFrame:
+        """Get the water levels from the offshore model.
+
+        Note that the returned water levels are relative to the reference datum of the offshore model.
+        To convert to a different datum, add the offshore reference datum height and subtract the desired reference datum height.
+
+        Returns
+        -------
+        pd.DataFrame
+            A DataFrame with the water levels for each boundary condition point. Relative to the reference datum of the offshore model.
+
+        """
+        path = self._get_simulation_path()
+        if not self.requires_offshore_run(self.event):
+            raise ValueError("Offshore model is not required for this event")
+
+        self.run_offshore()
+
+        with SfincsAdapter(model_root=path) as offshore_model:
+            waterlevels = offshore_model.get_wl_df_from_offshore_his_results()
+
+        return waterlevels
+
+    @staticmethod
+    def requires_offshore_run(event: Event) -> bool:
+        return any(
+            forcing.source in [ForcingSource.MODEL, ForcingSource.TRACK]
+            for forcing in event.get_forcings()
+        )
+
+    def run_offshore(self):
+        """Prepare the forcings of the historical event.
+
+        If the forcings require it, this function will:
+        - preprocess and run offshore model: prepare and run the offshore model to obtain water levels for the boundary condition of the nearshore model.
+
+        """
+        sim_path = self._get_simulation_path()
+
+        sim_path.mkdir(parents=True, exist_ok=True)
+        self._preprocess_sfincs_offshore()
+        self._execute_sfincs_offshore(sim_path)
+
+    def _preprocess_sfincs_offshore(self):
+        """Preprocess offshore model to obtain water levels for boundary condition of the nearshore model.
+
+        This function is reused for ForcingSources: MODEL & TRACK.
+
+        Args:
+            sim_path path to the root of the offshore model
+        """
+        self.logger.info(
+            f"Preparing offshore model to generate waterlevels for `{self.scenario.name}`"
+        )
+        sim_path = self._get_simulation_path()
+        # SfincsAdapter.write() doesnt write the bca file apparently so we need to copy the template
+        if sim_path.exists():
+            shutil.rmtree(sim_path)
+        shutil.copytree(self.template_path, sim_path)
+
+        with SfincsAdapter(model_root=sim_path) as _offshore_model:
+            if _offshore_model.sfincs_completed(sim_path):
+                _offshore_model.logger.info(
+                    f"Skip preprocessing offshore model as it has already been run for `{self.scenario.name}`."
+                )
+                return
+            # Load objects, set root & write template model
+            _offshore_model._load_scenario_objects(self.scenario, self.event)
+            _offshore_model.write(path_out=sim_path)
+            _offshore_model.set_timing(self.event.time)
+
+            # Add water levels
+            _offshore_model._add_bzs_from_bca(
+                _offshore_model._event, _offshore_model._projection.physical_projection
+            )
+
+            # Add spw if applicable
+            track_forcings = [
+                f
+                for f in _offshore_model._event.get_forcings()
+                if f.source == ForcingSource.TRACK
+            ]
+            if track_forcings:
+                for forcing in track_forcings:
+                    _offshore_model.add_forcing(forcing)
+
+            # Add wind and if applicable pressure forcing from meteo data
+            elif isinstance(_offshore_model._event, HistoricalEvent):
+                wind_forcings = [
+                    f
+                    for f in _offshore_model._event.get_forcings()
+                    if isinstance(f, IWind)
+                ]
+
+                if wind_forcings:
+                    if len(wind_forcings) > 1:
+                        raise ValueError("Only one wind forcing is allowed")
+                    wind_forcing = wind_forcings[0]
+
+                    # Add wind forcing
+                    if wind_forcing not in track_forcings:
+                        _offshore_model.add_forcing(wind_forcing)
+
+                    # Add pressure forcing for the offshore model (this doesnt happen normally in _add_forcing_wind() for overland models)
+                    if isinstance(wind_forcing, WindMeteo):
+                        ds = MeteoHandler().read(_offshore_model._event.time)
+                        _offshore_model._add_pressure_forcing_from_grid(ds=ds)
+
+            # write sfincs model in output destination
+            _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}")
+        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."
+                )
+                return
+            try:
+                _offshore_model.execute(path=sim_path)
+            except RuntimeError as e:
+                raise RuntimeError(
+                    f"Failed to run offshore model for {self.scenario.name}"
+                ) from e
+
+    def _get_simulation_path(self) -> Path:
+        main_event = self.database.events.get(self.scenario.event)
+        if main_event.mode == Mode.risk:
+            return (
+                db_path(
+                    TopLevelDir.output,
+                    object_dir=ObjectDir.scenario,
+                    obj_name=self.scenario.name,
+                )
+                / "Flooding"
+                / "simulations"
+                / self.event.name
+                / self.template_path.name
+            )
+        else:
+            return (
+                db_path(
+                    TopLevelDir.output,
+                    object_dir=ObjectDir.scenario,
+                    obj_name=self.scenario.name,
+                )
+                / "Flooding"
+                / "simulations"
+                / self.template_path.name
+            )

flood_adapt/config/config.py

@@ -0,0 +1,245 @@
+from os import environ, listdir
+from pathlib import Path
+from platform import system
+from typing import ClassVar
+
+import tomli
+import tomli_w
+from pydantic import (
+    Field,
+    computed_field,
+    field_serializer,
+    model_validator,
+)
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    The configuration settings for the FloodAdapt database and integrator.
+
+    Precedence is as follows: user arguments > environment variables > defaults in this class.
+    When loading is done, the settings are validated and the environment variables are updated with the loaded values.
+
+    If any required settings are missing or invalid, a ValidationError is raised.
+
+    Usage
+    -----
+    from flood_adapt.config import Settings
+
+    One of the following:
+
+    1) Load settings from environment variables, if no environment variables are set, use defaults defined in the class:
+        `settings = Settings()`
+
+    2) Load settings from a .toml file, overwriting any environment variables set:
+        `settings = Settings.read(toml_path: Path)`
+
+    3) Load settings from keyword arguments, overwriting any environment variables:
+        `settings = Settings(DATABASE_ROOT="path/to/database", DATABASE_NAME="database_name", SYSTEM_FOLDER="path/to/system_folder")`
+
+    Attributes
+    ----------
+    database_name : str
+        The name of the database.
+    database_root : Path
+        The root directory of the database.
+    system_folder : Path
+        The root directory of the system folder containing the kernels.
+    delete_crashed_runs : bool
+        Whether to delete crashed/corrupted runs immediately after they are detected.
+
+    Properties
+    ----------
+    database_path : Path
+        The full path to the database.
+    sfincs_path : Path
+        The path to the SFINCS binary.
+    fiat_path : Path
+        The path to the FIAT binary.
+
+    Raises
+    ------
+    ValidationError
+        If required settings are missing or invalid.
+    """
+
+    SYSTEM_SUFFIXES: ClassVar[dict[str, str]] = {
+        "Windows": ".exe",
+        "Linux": "",
+        "Darwin": "",
+    }
+
+    model_config = SettingsConfigDict(env_ignore_empty=True, validate_default=True)
+
+    database_root: Path = Field(
+        alias="DATABASE_ROOT",  # environment variable DATABASE_ROOT
+        default=Path(__file__).parents[3]
+        / "Database",  # If you clone FloodAdapt, default is to look for the Database next to the FloodAdapt folder
+        description="The root directory of the database that contains site(s). Usually the directory name is 'Database'. Default is to look for the Database in the same dir as the FloodAdapt cloned repo.",
+    )
+    database_name: str = Field(
+        alias="DATABASE_NAME",  # environment variable DATABASE_NAME
+        default="",
+        description="The name of the database site, should be a folder inside the database root. The site must contain an 'input' and 'static' folder.",
+    )
+    system_folder: Path = Field(
+        alias="SYSTEM_FOLDER",  # environment variable: SYSTEM_FOLDER
+        default=Path(__file__).parents[1] / "system",
+        description="The path of the system folder containing the kernels that run the calculations. Default is to look for the system folder in `FloodAdapt/flood_adapt/system`",
+    )
+    delete_crashed_runs: bool = Field(
+        alias="DELETE_CRASHED_RUNS",  # environment variable: DELETE_CRASHED_RUNS
+        default=True,
+        description="Whether to delete the output of crashed/corrupted runs. Be careful when setting this to False, as it may lead to a broken database that cannot be read in anymore.",
+        exclude=True,
+    )
+    validate_allowed_forcings: bool = Field(
+        alias="VALIDATE_ALLOWED_FORCINGS",  # environment variable: VALIDATE_ALLOWED_FORCINGS
+        default=True,
+        description="Whether to validate the forcing types and sources against the allowed forcings in the event model.",
+        exclude=True,
+    )
+
+    @computed_field
+    @property
+    def sfincs_path(self) -> Path:
+        return self.system_folder / "sfincs" / f"sfincs{Settings._system_extension()}"
+
+    @computed_field
+    @property
+    def fiat_path(self) -> Path:
+        return self.system_folder / "fiat" / f"fiat{Settings._system_extension()}"
+
+    @computed_field
+    @property
+    def database_path(self) -> Path:
+        return self.database_root / self.database_name
+
+    @model_validator(mode="after")
+    def validate_settings(self):
+        self._validate_database_path()
+        self._validate_system_folder()
+        self._validate_fiat_path()
+        self._validate_sfincs_path()
+        self._update_environment_variables()
+        return self
+
+    def _update_environment_variables(self):
+        environ["DATABASE_ROOT"] = str(self.database_root)
+        environ["DATABASE_NAME"] = self.database_name
+        environ["SYSTEM_FOLDER"] = str(self.system_folder)
+        environ["DELETE_CRASHED_RUNS"] = str(self.delete_crashed_runs)
+        environ["VALIDATE_ALLOWED_FORCINGS"] = str(self.validate_allowed_forcings)
+        return self
+
+    def _validate_database_path(self):
+        if not self.database_root.is_dir():
+            raise ValueError(f"Database root {self.database_root} does not exist.")
+
+        if self.database_name == "":
+            # If database_name is not given as arg or set in env, compute default as the first dir in database_root excluding 'system'
+            sites = [
+                d
+                for d in listdir(self.database_root)
+                if d != "system" and not d.startswith(".")
+            ]
+            if not sites:
+                raise ValueError(f"No databases found in {self.database_root}.")
+            self.database_name = sites[0]
+
+        if not self.database_path.is_dir():
+            raise ValueError(
+                f"Database {self.database_name} at {self.database_root} does not exist. Full path: {self.database_path}"
+            )
+
+        if not (self.database_path / "input").is_dir():
+            raise ValueError(
+                f"Database {self.database_name} at {self.database_path} does not contain an input folder."
+            )
+
+        if not (self.database_path / "static").is_dir():
+            raise ValueError(
+                f"Database {self.database_name} at {self.database_path} does not contain a static folder."
+            )
+
+        return self
+
+    def _validate_system_folder(self):
+        if not self.system_folder.is_dir():
+            raise ValueError(f"System folder {self.system_folder} does not exist.")
+        return self
+
+    def _validate_sfincs_path(self):
+        if not self.sfincs_path.exists():
+            raise ValueError(f"SFINCS binary {self.sfincs_path} does not exist.")
+        return self
+
+    def _validate_fiat_path(self):
+        if not self.fiat_path.exists():
+            raise ValueError(f"FIAT binary {self.fiat_path} does not exist.")
+        return self
+
+    @field_serializer(
+        "database_root", "system_folder", "sfincs_path", "fiat_path", "database_path"
+    )
+    def serialize_path(self, path: Path) -> str:
+        return str(path)
+
+    @staticmethod
+    def _system_extension() -> str:
+        if system() not in Settings.SYSTEM_SUFFIXES:
+            raise ValueError(f"Unsupported system {system()}")
+        return Settings.SYSTEM_SUFFIXES[system()]
+
+    @staticmethod
+    def read(toml_path: Path) -> "Settings":
+        """
+        Parse the configuration file and return the parsed settings.
+
+        Parameters
+        ----------
+        toml_path : Path
+            The path to the configuration file.
+
+        Returns
+        -------
+        Settings
+            The parsed configuration settings.
+
+        Raises
+        ------
+        ValidationError
+            If required configuration values are missing or if there is an error parsing the configuration file.
+        """
+        with open(toml_path, "rb") as f:
+            settings = tomli.load(f)
+
+        return Settings(**settings)
+
+    def write(self, toml_path: Path) -> None:
+        """
+        Write the configuration settings to a .toml file.
+
+        Parameters
+        ----------
+        toml_path : Path
+            The path to the configuration file.
+
+        Returns
+        -------
+        None
+
+        """
+        toml_path = Path(toml_path).resolve()
+        if not toml_path.parent.exists():
+            toml_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(toml_path, "wb") as f:
+            tomli_w.dump(
+                self.model_dump(
+                    by_alias=True,
+                    exclude={"sfincs_path", "fiat_path", "database_path"},
+                ),
+                f,
+            )

flood_adapt/config/fiat.py

@@ -0,0 +1,219 @@
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel
+from tomli import load as load_toml
+
+from flood_adapt.config.sfincs import FloodmapType
+
+
+class BenefitsModel(BaseModel):
+    """The accepted input for the variable benefits in Site.
+
+    Attributes
+    ----------
+    current_year : int
+        The current year used in benefits calculations.
+    current_projection : str
+        The current projection used in benefits calculations.
+    baseline_strategy : str
+        The baseline strategy used in benefits calculations.
+    event_set : str
+        The event set used in benefits calculations.
+    """
+
+    current_year: int
+    current_projection: str
+    baseline_strategy: str
+    event_set: str
+
+
+class EquityModel(BaseModel):
+    """
+    The accepted input for the variable equity in Site.
+
+    Attributes
+    ----------
+    census_data : str
+        TODO
+    percapitaincome_label : Optional[str], default="PerCapitaIncome"
+        TODO
+    totalpopulation_label : Optional[str], default="TotalPopulation"
+        TODO
+    """
+
+    census_data: str
+    percapitaincome_label: Optional[str] = "PerCapitaIncome"
+    totalpopulation_label: Optional[str] = "TotalPopulation"
+
+
+class AggregationModel(BaseModel):
+    """The accepted input for the variable aggregation in Site.
+
+    Attributes
+    ----------
+    name : str
+        TODO
+    file : str
+        TODO
+    field_name : str
+        TODO
+    equity : Optional[EquityModel], default=None
+        TODO
+    """
+
+    name: str
+    file: str
+    field_name: str
+    equity: Optional[EquityModel] = None
+
+
+class BFEModel(BaseModel):
+    """The accepted input for the variable bfe in Site.
+
+    Attributes
+    ----------
+    geom : str
+        TODO
+    table : Optional[str], default=None
+        TODO
+    field_name : str
+        TODO
+    """
+
+    geom: str
+    table: Optional[str] = None
+    field_name: str
+
+
+class SVIModel(BaseModel):
+    """The accepted input for the variable svi in Site.
+
+    Attributes
+    ----------
+    geom : str
+        TODO
+    field_name : str
+        TODO
+    """
+
+    geom: str
+    field_name: str
+
+
+class NoFootprintsModel(BaseModel):
+    """
+    The configuration on the how to show objects with no footprints.
+
+    Attributes
+    ----------
+    shape : Optional[str], default="triangle"
+        The shape of the object with no footprints.
+    diameter_meters : Optional[float], default=10
+        The diameter of the object with no footprints in meters.
+    """
+
+    shape: Optional[str] = "triangle"
+    diameter_meters: Optional[float] = 10
+
+
+class RiskModel(BaseModel):
+    """The accepted input for the variable risk in Site.
+
+    Attributes
+    ----------
+    return_periods : list[int]
+        The return periods for the risk model.
+    """
+
+    return_periods: list = [1, 2, 5, 10, 25, 50, 100]
+
+
+class DamageType(str, Enum):
+    """The accepted input for the variable footprints_dmg_type."""
+
+    absolute = "absolute"
+    relative = "relative"
+
+
+class FiatConfigModel(BaseModel):
+    """Configuration settings for the FIAT model.
+
+    Attributes
+    ----------
+    exposure_crs : str
+        The coordinate reference system of the exposure data.
+    bfe : Optional[BFEModel], default=None
+        The base flood elevation model.
+    aggregation : list[AggregationModel]
+        Configuration for the aggregation model.
+    floodmap_type : FloodmapType
+        The type of flood map to be used.
+    non_building_names : Optional[list[str]], default=None
+        List of non-building names to be used in the model.
+    damage_unit : str, default="$"
+        The unit of damage used in the model.
+    building_footprints : Optional[str], default=None
+        Path to the building footprints data.
+    roads_file_name : Optional[str], default=None
+        Path to the roads data.
+    new_development_file_name : Optional[str], default="new_development_area.gpkg"
+        Path to the new development area data.
+    save_simulation : Optional[bool], default=False
+        Whether to keep or delete the simulation files after the simulation is finished and all output files are created.
+        If True, the simulation files are kept. If False, the simulation files are deleted.
+    svi : Optional[SVIModel], default=None
+        The social vulnerability index model.
+    infographics : Optional[bool], default=False
+        Whether to create infographics or not.
+    no_footprints : Optional[NoFootprintsModel], default=NoFootprintsModel()
+        Configuration for objects with no footprints.
+    """
+
+    exposure_crs: str
+    bfe: Optional[BFEModel] = None
+    aggregation: list[AggregationModel]
+    floodmap_type: FloodmapType
+    non_building_names: Optional[list[str]]
+    damage_unit: str = "$"
+    building_footprints: Optional[str] = None
+    roads_file_name: Optional[str] = None
+    new_development_file_name: Optional[str] = "new_development_area.gpkg"
+    save_simulation: Optional[bool] = False
+    svi: Optional[SVIModel] = None
+    infographics: Optional[bool] = False
+    no_footprints: Optional[NoFootprintsModel] = NoFootprintsModel()
+
+    @staticmethod
+    def read_toml(path: Path) -> "FiatConfigModel":
+        with open(path, mode="rb") as fp:
+            toml_contents = load_toml(fp)
+
+        return FiatConfigModel(**toml_contents)
+
+
+class FiatModel(BaseModel):
+    """The expected variables and data types of attributes of the Fiat class.
+
+    Attributes
+    ----------
+    risk : RiskModel
+        Configuration of probabilistic risk runs.
+    config : FiatConfigModel
+        Configuration for the FIAT model.
+    benefits : BenefitsModel
+        Configuration for running benefit calculations.
+    """
+
+    risk: RiskModel
+
+    config: FiatConfigModel
+    benefits: BenefitsModel
+
+    @staticmethod
+    def read_toml(path: Path) -> "FiatModel":
+        with open(path, mode="rb") as fp:
+            toml_contents = load_toml(fp)
+
+        return FiatModel(**toml_contents)