flood-adapt 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

flood_adapt/workflows/floodmap.py

@@ -1,85 +1,85 @@
-import os
-from pathlib import Path
-
-from flood_adapt.config.sfincs import FloodmapType
-from flood_adapt.misc.database_user import DatabaseUser
-from flood_adapt.misc.log import FloodAdaptLogging
-from flood_adapt.objects.events.event_set import EventSet
-from flood_adapt.objects.events.events import Mode
-from flood_adapt.objects.strategies.strategies import Strategy
-
-
-class FloodMap(DatabaseUser):
-    logger = FloodAdaptLogging.getLogger("FloodMap")
-
-    type: FloodmapType
-
-    name: str
-    path: Path | os.PathLike | list[Path | os.PathLike]
-    event_set: EventSet
-
-    def __init__(self, scenario_name: str) -> None:
-        self.name = scenario_name
-        self.type = self.database.site.fiat.config.floodmap_type
-        self._get_flood_map_paths()
-
-    def _get_flood_map_paths(self):
-        base_dir = self.database.scenarios.output_path / self.name / "Flooding"
-        # TODO check naming of files
-        if self.mode == Mode.single_event:
-            if self.type == FloodmapType.water_level:
-                self.path = base_dir / "max_water_level_map.nc"
-            elif self.type == FloodmapType.water_depth:
-                self.path = base_dir / f"FloodMap_{self.name}.tif"
-        elif self.mode == Mode.risk:
-            if self.type == FloodmapType.water_level:
-                self.path = list(base_dir.glob("RP_*_maps.nc"))
-            elif self.type == FloodmapType.water_depth:
-                self.path = list(base_dir.glob("RP_*_maps.tif"))
-
-    @property
-    def has_run(self) -> bool:
-        if self.mode == Mode.single_event:
-            return self.path.exists()
-        elif self.mode == Mode.risk:
-            check_files = [RP_map.exists() for RP_map in self.path]
-            check_rps = len(self.path) == len(
-                self.database.site.fiat.risk.return_periods
-            )
-            return all(check_files) & check_rps
-
-    @property
-    def scenario(self):
-        if hasattr(self, "_scenario"):
-            return self._scenario
-        self._scenario = self.database.scenarios.get(self.name)
-        return self._scenario
-
-    @property
-    def mode(self):
-        if hasattr(self, "_mode"):
-            return self._mode
-        self._mode = self.database.events.get(self.scenario.event).mode
-        return self._mode
-
-    @property
-    def crs(self):
-        if hasattr(self, "_crs"):
-            return self._crs
-        self._crs = self.database.site.crs
-        return self._crs
-
-    @property
-    def hazard_strategy(self) -> Strategy:
-        return self.database.strategies.get(
-            self.scenario.strategy
-        ).get_hazard_strategy()
-
-    @property
-    def physical_projection(self):
-        if hasattr(self, "_physical_projection"):
-            return self._physical_projection
-        self._physical_projection = self.database.projections.get(
-            self.scenario.projection
-        ).physical_projection
-        return self._physical_projection
+import os
+from pathlib import Path
+
+from flood_adapt.config.sfincs import FloodmapType
+from flood_adapt.misc.database_user import DatabaseUser
+from flood_adapt.misc.log import FloodAdaptLogging
+from flood_adapt.objects.events.event_set import EventSet
+from flood_adapt.objects.events.events import Mode
+from flood_adapt.objects.strategies.strategies import Strategy
+
+
+class FloodMap(DatabaseUser):
+    logger = FloodAdaptLogging.getLogger("FloodMap")
+
+    type: FloodmapType
+
+    name: str
+    path: Path | os.PathLike | list[Path | os.PathLike]
+    event_set: EventSet
+
+    def __init__(self, scenario_name: str) -> None:
+        self.name = scenario_name
+        self.type = self.database.site.fiat.config.floodmap_type
+        self._get_flood_map_paths()
+
+    def _get_flood_map_paths(self):
+        base_dir = self.database.scenarios.output_path / self.name / "Flooding"
+        # TODO check naming of files
+        if self.mode == Mode.single_event:
+            if self.type == FloodmapType.water_level:
+                self.path = base_dir / "max_water_level_map.nc"
+            elif self.type == FloodmapType.water_depth:
+                self.path = base_dir / f"FloodMap_{self.name}.tif"
+        elif self.mode == Mode.risk:
+            if self.type == FloodmapType.water_level:
+                self.path = list(base_dir.glob("RP_*_maps.nc"))
+            elif self.type == FloodmapType.water_depth:
+                self.path = list(base_dir.glob("RP_*_maps.tif"))
+
+    @property
+    def has_run(self) -> bool:
+        if self.mode == Mode.single_event:
+            return self.path.exists()
+        elif self.mode == Mode.risk:
+            check_files = [RP_map.exists() for RP_map in self.path]
+            check_rps = len(self.path) == len(
+                self.database.site.fiat.risk.return_periods
+            )
+            return all(check_files) & check_rps
+
+    @property
+    def scenario(self):
+        if hasattr(self, "_scenario"):
+            return self._scenario
+        self._scenario = self.database.scenarios.get(self.name)
+        return self._scenario
+
+    @property
+    def mode(self):
+        if hasattr(self, "_mode"):
+            return self._mode
+        self._mode = self.database.events.get(self.scenario.event).mode
+        return self._mode
+
+    @property
+    def crs(self):
+        if hasattr(self, "_crs"):
+            return self._crs
+        self._crs = self.database.site.crs
+        return self._crs
+
+    @property
+    def hazard_strategy(self) -> Strategy:
+        return self.database.strategies.get(
+            self.scenario.strategy
+        ).get_hazard_strategy()
+
+    @property
+    def physical_projection(self):
+        if hasattr(self, "_physical_projection"):
+            return self._physical_projection
+        self._physical_projection = self.database.projections.get(
+            self.scenario.projection
+        ).physical_projection
+        return self._physical_projection

flood_adapt/workflows/impacts_integrator.py

@@ -1,82 +1,85 @@
-from pathlib import Path
-
-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.projections.projections import SocioEconomicChange
-from flood_adapt.objects.scenarios.scenarios import Scenario
-from flood_adapt.objects.strategies.strategies import Strategy
-from flood_adapt.workflows.floodmap import FloodMap
-
-
-class Impacts(DatabaseUser):
-    """All information related to the impacts of the scenario.
-
-    Includes methods to run the impact models or check if they has already been run.
-    """
-
-    logger = FloodAdaptLogging.getLogger("Impacts")
-    name: str
-
-    def __init__(self, scenario: Scenario):
-        self.name = scenario.name
-        self.scenario = scenario
-        self.site_info = self.database.site
-        self.models = [
-            self.database.static.get_fiat_model()
-        ]  # for now only FIAT adapter
-
-    @property
-    def hazard(self) -> FloodMap:
-        return FloodMap(self.name)
-
-    @property
-    def socio_economic_change(self) -> SocioEconomicChange:
-        return self.database.projections.get(
-            self.scenario.projection
-        ).socio_economic_change
-
-    @property
-    def impact_strategy(self) -> Strategy:
-        return self.database.strategies.get(
-            self.scenario.strategy
-        ).get_impact_strategy()
-
-    @property
-    def results_path(self) -> Path:
-        return db_path(
-            TopLevelDir.output, object_dir=ObjectDir.scenario, obj_name=self.name
-        )
-
-    @property
-    def impacts_path(self) -> Path:
-        return self.results_path / "Impacts"
-
-    @property
-    def has_run(self) -> bool:
-        return self.has_run_check()
-
-    def run(self):
-        """Run the impact model(s)."""
-        if self.has_run:
-            self.logger.info("Impacts have already been run.")
-            return
-        for model in self.models:
-            model.run(self.scenario)
-
-    def has_run_check(self) -> bool:
-        """Check if the impact has been run.
-
-        Returns
-        -------
-        bool
-            _description_
-        """
-        checks = []
-        for model in self.models:
-            checks.append(model.has_run(self.scenario))
-        return all(checks)
+from pathlib import Path
+
+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.projections.projections import SocioEconomicChange
+from flood_adapt.objects.scenarios.scenarios import Scenario
+from flood_adapt.objects.strategies.strategies import Strategy
+from flood_adapt.workflows.floodmap import FloodMap
+
+
+class Impacts(DatabaseUser):
+    """All information related to the impacts of the scenario.
+
+    Includes methods to run the impact models or check if they has already been run.
+    """
+
+    logger = FloodAdaptLogging.getLogger("Impacts")
+    name: str
+
+    def __init__(self, scenario: Scenario):
+        self.name = scenario.name
+        self.scenario = scenario
+        self.site_info = self.database.site
+
+    @property
+    def models(self):
+        """Return the list of impact models."""
+        models = [self.database.static.get_fiat_model()]  # for now only FIAT adapter
+        return models
+
+    @property
+    def hazard(self) -> FloodMap:
+        return FloodMap(self.name)
+
+    @property
+    def socio_economic_change(self) -> SocioEconomicChange:
+        return self.database.projections.get(
+            self.scenario.projection
+        ).socio_economic_change
+
+    @property
+    def impact_strategy(self) -> Strategy:
+        return self.database.strategies.get(
+            self.scenario.strategy
+        ).get_impact_strategy()
+
+    @property
+    def results_path(self) -> Path:
+        return db_path(
+            TopLevelDir.output, object_dir=ObjectDir.scenario, obj_name=self.name
+        )
+
+    @property
+    def impacts_path(self) -> Path:
+        return self.results_path / "Impacts"
+
+    @property
+    def has_run(self) -> bool:
+        return self.has_run_check()
+
+    def run(self):
+        """Run the impact model(s)."""
+        if self.has_run:
+            self.logger.info("Impacts have already been run.")
+            return
+        for model in self.models:
+            model.run(self.scenario)
+
+    def has_run_check(self) -> bool:
+        """Check if the impact has been run.
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        checks = []
+        for model in self.models:
+            checks.append(model.has_run(self.scenario))
+        return all(checks)

flood_adapt/workflows/scenario_runner.py

@@ -1,70 +1,70 @@
-from flood_adapt import __version__
-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
-
-
-class ScenarioRunner:
-    """class holding all information related to a scenario."""
-
-    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.site_info = self._database.site
-        self.results_path = self._database.scenarios.output_path / self._scenario.name
-
-    def _load_objects(self, scenario: Scenario) -> None:
-        """Load objects from the database."""
-        self._scenario = scenario
-        self._event = self._database.events.get(scenario.event)
-        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,
-        )
-
-    def run(self) -> None:
-        """Run hazard and impact models for the scenario."""
-        self._database.has_run_hazard(self._scenario.name)
-        self._load_objects(self._scenario)
-        self.results_path.mkdir(parents=True, exist_ok=True)
-
-        # 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}`")
-
-        # write finished file to indicate that the scenario has been run
-        write_finished_file(self.results_path)
-
-    def has_run_check(self):
-        """Check if the scenario has been run."""
-        return finished_file_exists(self.results_path)
+from flood_adapt import __version__
+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
+
+
+class ScenarioRunner:
+    """class holding all information related to a scenario."""
+
+    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.site_info = self._database.site
+        self.results_path = self._database.scenarios.output_path / self._scenario.name
+
+    def _load_objects(self, scenario: Scenario) -> None:
+        """Load objects from the database."""
+        self._scenario = scenario
+        self._event = self._database.events.get(scenario.event)
+        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,
+        )
+
+    def run(self) -> None:
+        """Run hazard and impact models for the scenario."""
+        self._database.has_run_hazard(self._scenario.name)
+        self._load_objects(self._scenario)
+        self.results_path.mkdir(parents=True, exist_ok=True)
+
+        # 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}`")
+
+        # write finished file to indicate that the scenario has been run
+        write_finished_file(self.results_path)
+
+    def has_run_check(self):
+        """Check if the scenario has been run."""
+        return finished_file_exists(self.results_path)