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

flood_adapt/dbs_classes/database.py

@@ -28,6 +28,7 @@ from flood_adapt.misc.path_builder import (
     db_path,
 )
 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.workflows.scenario_runner import ScenarioRunner
 
@@ -129,12 +130,11 @@ class Database(IDatabase):
             self, standard_objects=self.site.standard_objects.projections
         )
         self._benefits = DbsBenefit(self)
+        self._init_done = True
 
-        # Delete any unfinished/crashed scenario output
+        # Delete any unfinished/crashed scenario output after initialization
         self.cleanup()
 
-        self._init_done = True
-
     def shutdown(self):
         """Explicitly shut down the singleton and clear all references."""
         import gc
@@ -285,6 +285,44 @@ class Database(IDatabase):
                 zsmax = ds["risk_map"][:, :].to_numpy().T
         return zsmax
 
+    def get_flood_map_geotiff(
+        self,
+        scenario_name: str,
+        return_period: Optional[int] = None,
+    ) -> Optional[Path]:
+        """Return the path to the geotiff file with the flood map for the given scenario.
+
+        Parameters
+        ----------
+        scenario_name : str
+            name of scenario
+        return_period : int, optional
+            return period in years, by default None. Only for risk scenarios.
+
+        Returns
+        -------
+        Optional[Path]
+            path to the flood map geotiff file, or None if it does not exist
+        """
+        if not return_period:
+            file_path = self.scenarios.output_path.joinpath(
+                scenario_name,
+                "Flooding",
+                f"FloodMap_{scenario_name}.tif",
+            )
+        else:
+            file_path = self.scenarios.output_path.joinpath(
+                scenario_name,
+                "Flooding",
+                f"RP_{return_period:04d}_maps.tif",
+            )
+        if not file_path.is_file():
+            self.logger.warning(
+                f"Flood map for scenario '{scenario_name}' at {file_path} does not exist."
+            )
+            return None
+        return file_path
+
     def get_building_footprints(self, scenario_name: str) -> GeoDataFrame:
         """Return a geodataframe of the impacts at the footprint level.
 
@@ -471,6 +509,9 @@ 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."""
@@ -493,3 +534,59 @@ class Database(IDatabase):
                 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)
+
+    def _delete_simulations(self, scenario_name: str) -> None:
+        """Delete all simulation folders for a given scenario.
+
+        Parameters
+        ----------
+        scenario_name : str
+            Name of the scenario to delete simulations for.
+        """
+        scn = self.scenarios.get(scenario_name)
+        event = self.events.get(scn.event, load_all=True)
+        sub_events = event._events if event.mode == Mode.risk else None
+
+        if not self.site.sfincs.config.save_simulation:
+            # Delete SFINCS overland
+            overland = self.static.get_overland_sfincs_model()
+            if sub_events:
+                for sub_event in sub_events:
+                    overland._delete_simulation_folder(scn, sub_event=sub_event)
+
+            else:
+                overland._delete_simulation_folder(scn)
+
+            # Delete SFINCS offshore
+            if self.site.sfincs.config.offshore_model:
+                offshore = self.static.get_offshore_sfincs_model()
+                if sub_events:
+                    for sub_event in sub_events:
+                        sim_path = offshore._get_simulation_path_offshore(
+                            scn, sub_event=sub_event
+                        )
+                        if sim_path.exists():
+                            shutil.rmtree(sim_path, ignore_errors=True)
+                            self.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
+                            sim_path.parent.rmdir()
+                else:
+                    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}")
+
+                    if sim_path.parent.exists() and not any(sim_path.parent.iterdir()):
+                        # Remove the parent directory `simulations` if it is empty
+                        sim_path.parent.rmdir()
+
+        if not self.site.fiat.config.save_simulation:
+            # Delete FIAT
+            fiat = self.static.get_fiat_model()
+            fiat._delete_simulation_folder(scn)

flood_adapt/dbs_classes/dbs_benefit.py

@@ -9,6 +9,7 @@ class DbsBenefit(DbsTemplate[Benefit]):
     display_name = "Benefit"
     dir_name = "benefits"
     _object_class = Benefit
+    _higher_lvl_object = ""
 
     def save(self, object_model: Benefit, overwrite: bool = False):
         """Save a benefit object in the database.

flood_adapt/dbs_classes/dbs_event.py

@@ -11,6 +11,7 @@ class DbsEvent(DbsTemplate[Event]):
     dir_name = "events"
     display_name = "Event"
     _object_class = Event
+    _higher_lvl_object = "Scenario"
 
     def get(self, name: str, load_all: bool = False) -> Event | EventSet:
         """Return an event object.

flood_adapt/dbs_classes/dbs_measure.py

@@ -14,6 +14,7 @@ class DbsMeasure(DbsTemplate[Measure]):
     dir_name = "measures"
     display_name = "Measure"
     _object_class = Measure
+    _higher_lvl_object = "Strategy"
 
     def get(self, name: str) -> Measure:
         """Return a measure object.

flood_adapt/dbs_classes/dbs_projection.py

@@ -6,6 +6,7 @@ class DbsProjection(DbsTemplate[Projection]):
     dir_name = "projections"
     display_name = "Projection"
     _object_class = Projection
+    _higher_lvl_object = "Scenario"
 
     def check_higher_level_usage(self, name: str) -> list[str]:
         """Check if a projection is used in a scenario.

flood_adapt/dbs_classes/dbs_scenario.py

@@ -11,6 +11,7 @@ class DbsScenario(DbsTemplate[Scenario]):
     dir_name = "scenarios"
     display_name = "Scenario"
     _object_class = Scenario
+    _higher_lvl_object = "Benefit"
 
     def summarize_objects(self) -> dict[str, list[Any]]:
         """Return a dictionary with info on the events that currently exist in the database.

flood_adapt/dbs_classes/dbs_strategy.py

@@ -10,6 +10,7 @@ class DbsStrategy(DbsTemplate[Strategy]):
     dir_name = "strategies"
     display_name = "Strategy"
     _object_class = Strategy
+    _higher_lvl_object = "Scenario"
 
     def get(self, name: str) -> Strategy:
         strategy = super().get(name)

flood_adapt/dbs_classes/dbs_template.py

@@ -18,6 +18,7 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
     display_name: str
     dir_name: str
     _object_class: type[T_OBJECTMODEL]
+    _higher_lvl_object: str
 
     def __init__(
         self, database: IDatabase, standard_objects: Optional[list[str]] = None
@@ -161,7 +162,7 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
         # Check if object is used in a higher level object. If it is, raise an error
         if used_in := self.check_higher_level_usage(name):
             raise DatabaseError(
-                f"{self.display_name}: '{name}' cannot be deleted/modified since it is already used in: {', '.join(used_in)}"
+                f"{self.display_name}: '{name}' cannot be deleted/modified since it is already used in the {self._higher_lvl_object.capitalize()}(s): {', '.join(used_in)}"
             )
 
         # Once all checks are passed, delete the object

flood_adapt/flood_adapt.py

@@ -770,7 +770,9 @@ class FloodAdapt:
         """
         return self.database.get_depth_conversion()
 
-    def get_max_water_level_map(self, name: str, rp: int = None) -> np.ndarray:
+    def get_max_water_level_map(
+        self, name: str, rp: Optional[int] = None
+    ) -> np.ndarray:
         """
         Return the maximum water level for the given scenario.
 
@@ -788,6 +790,26 @@ class FloodAdapt:
         """
         return self.database.get_max_water_level(name, rp)
 
+    def get_flood_map_geotiff(
+        self, name: str, rp: Optional[int] = None
+    ) -> Optional[Path]:
+        """
+        Return the path to the geotiff file with the flood map for the given scenario.
+
+        Parameters
+        ----------
+        name : str
+            The name of the scenario.
+        rp : int, optional
+            The return period of the water level, by default None. Only for event set scenarios.
+
+        Returns
+        -------
+        flood_map_geotiff : Optional[Path]
+            The path to the geotiff file with the flood map for the scenario if it exists, otherwise None.
+        """
+        return self.database.get_flood_map_geotiff(name, rp)
+
     def get_building_footprint_impacts(self, name: str) -> gpd.GeoDataFrame:
         """
         Return a geodataframe of the impacts at the footprint level.

flood_adapt/misc/log.py

@@ -15,26 +15,24 @@ class FloodAdaptLogging:
     def __init__(
         self,
         file_path: Optional[Path] = None,
-        loglevel_console: int = logging.WARNING,
-        loglevel_root: int = logging.INFO,
-        loglevel_files: int = logging.DEBUG,
+        level: int = logging.INFO,
         formatter: logging.Formatter = _DEFAULT_FORMATTER,
         ignore_warnings: Optional[list[type[Warning]]] = None,
     ) -> None:
         """Initialize the logging system for the FloodAdapt."""
         self._formatter = formatter
 
-        self._root_logger.setLevel(loglevel_root)
+        self._root_logger.setLevel(level)
         if self._root_logger.hasHandlers():
             self._root_logger.handlers.clear()
 
         # Add file handler if provided
         if file_path is not None:
-            self.add_file_handler(file_path, loglevel_files, formatter)
+            self.add_file_handler(file_path, level, formatter)
 
         # Add console handler
         console_handler = logging.StreamHandler()
-        console_handler.setLevel(loglevel_console)
+        console_handler.setLevel(level)
         console_handler.setFormatter(formatter)
         self._root_logger.addHandler(console_handler)
 
@@ -46,7 +44,7 @@ class FloodAdaptLogging:
     def add_file_handler(
         cls,
         file_path: Path,
-        loglevel: int = logging.DEBUG,
+        level: int = logging.DEBUG,
         formatter: Optional[logging.Formatter] = None,
     ) -> None:
         """Add a file handler to the logger that directs outputs to a the file."""
@@ -60,7 +58,7 @@ class FloodAdaptLogging:
         file_path.parent.mkdir(parents=True, exist_ok=True)
 
         file_handler = logging.FileHandler(filename=file_path, mode="a")
-        file_handler.setLevel(loglevel)
+        file_handler.setLevel(level)
 
         formatter = formatter or cls._DEFAULT_FORMATTER
         file_handler.setFormatter(formatter)
@@ -79,7 +77,7 @@ class FloodAdaptLogging:
 
     @classmethod
     def getLogger(
-        cls, name: Optional[str] = None, level: int = logging.INFO
+        cls, name: Optional[str] = None, level: Optional[int] = None
     ) -> logging.Logger:
         """Get a logger with the specified name. If no name is provided, return the root logger.
 
@@ -101,9 +99,19 @@ class FloodAdaptLogging:
             logger = cls._root_logger
         else:
             logger = logging.getLogger(f"FloodAdapt.{name}")
-        logger.setLevel(level)
+
+        if level:
+            logger.setLevel(level)
+
         return logger
 
+    @classmethod
+    def set_global_level(cls, level: int) -> None:
+        """Set the logging level for FloodAdapt."""
+        loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
+        for logger in loggers:
+            logger.setLevel(level)
+
     @classmethod
     def shutdown(cls):
         root_logger = cls.getLogger()
@@ -120,7 +128,7 @@ class FloodAdaptLogging:
         cls,
         *,
         file_path: Path,
-        loglevel: int = logging.DEBUG,
+        level: int = logging.DEBUG,
         formatter: logging.Formatter = _DEFAULT_FORMATTER,
     ):
         """Open a file at filepath to write logs to. Does not affect other loggers.
@@ -131,7 +139,7 @@ class FloodAdaptLogging:
             raise ValueError(
                 "file_path must be provided as a key value pair: 'file_path=<file_path>'."
             )
-        cls.add_file_handler(file_path, loglevel, formatter)
+        cls.add_file_handler(file_path, level, formatter)
         try:
             yield
         finally:

flood_adapt/objects/events/events.py

@@ -53,11 +53,13 @@ class Template(str, Enum):
     def description(self) -> str:
         match self:
             case Template.Historical:
-                return "Select a time period for a historic event. This method can use offshore wind and pressure fields for the selected time period to simulate nearshore water levels or download gauged waterlevels to perform a realistic simulation. These water levels are used together with rainfall and river discharge input to simulate flooding in the site area."
+                return "Select and optionally modify a real event by specifying a past time period."
             case Template.Hurricane:
-                return "Select a historical hurricane track from the hurricane database, and shift the track if desired."
+                return (
+                    "Select a historical hurricane track from the hurricane database."
+                )
             case Template.Synthetic:
-                return "Customize a synthetic event by specifying the waterlevels, wind, rainfall and river discharges without being based on a historical event."
+                return "Build a custom event by specifying wind, water levels, rainfall, and discharge."
             case _:
                 raise ValueError(f"Invalid event template: {self}")
 

flood_adapt/objects/events/historical.py

@@ -34,17 +34,17 @@ class HistoricalEvent(Event):
     ALLOWED_FORCINGS: ClassVar[dict[ForcingType, List[ForcingSource]]] = {
         ForcingType.RAINFALL: [
             ForcingSource.CSV,
-            ForcingSource.METEO,
+            # ForcingSource.METEO, # Temporarily excluded due to bug in hydromt-sfincs. fixed in v1.3.0
             ForcingSource.SYNTHETIC,
             ForcingSource.CONSTANT,
         ],
         ForcingType.WIND: [
             ForcingSource.CSV,
-            ForcingSource.METEO,
+            # ForcingSource.METEO, # Temporarily excluded due to bug in hydromt-sfincs. fixed in v1.3.0
             ForcingSource.CONSTANT,
         ],
         ForcingType.WATERLEVEL: [
-            ForcingSource.MODEL,
+            # ForcingSource.MODEL, # Temporarily excluded due to the METEO bug in hydromt-sfincs. fixed in v1.3.0
             ForcingSource.CSV,
             ForcingSource.SYNTHETIC,
             ForcingSource.GAUGED,

flood_adapt/objects/events/hurricane.py

@@ -53,7 +53,7 @@ class HurricaneEvent(Event):
             ForcingSource.CSV,
             ForcingSource.SYNTHETIC,
             ForcingSource.TRACK,
-            ForcingSource.METEO,
+            # ForcingSource.METEO, # Temporarily excluded due to bug in hydromt-sfincs. fixed in v1.3.0
         ],
         ForcingType.WIND: [ForcingSource.TRACK],
         ForcingType.WATERLEVEL: [ForcingSource.MODEL],

flood_adapt/objects/forcing/plotting.py

@@ -5,7 +5,6 @@ from typing import List, Optional
 import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 
 from flood_adapt.config.site import Site
 from flood_adapt.misc.log import FloodAdaptLogging
@@ -395,36 +394,7 @@ def plot_wind(
         x_title = "Time"
 
     # Plot actual thing
-    # Create figure with secondary y-axis
-
-    fig = make_subplots(specs=[[{"secondary_y": True}]])
-
-    # Add traces
-    fig.add_trace(
-        go.Scatter(
-            x=data.index,
-            y=data.iloc[:, 0],
-            name="Wind speed",
-            mode="lines",
-        ),
-        secondary_y=False,
-    )
-    fig.add_trace(
-        go.Scatter(
-            x=data.index, y=data.iloc[:, 1], name="Wind direction", mode="markers"
-        ),
-        secondary_y=True,
-    )
-
-    # Set y-axes titles
-    fig.update_yaxes(
-        title_text=f"Wind speed [{site.gui.units.default_velocity_units.value}]",
-        secondary_y=False,
-    )
-    fig.update_yaxes(
-        title_text=f"Wind direction {site.gui.units.default_direction_units.value}",
-        secondary_y=True,
-    )
+    fig = px.line(x=data.index, y=data.iloc[:, 0])
 
     fig.update_layout(
         autosize=False,
@@ -434,11 +404,14 @@ def plot_wind(
         font={"size": 10, "color": "black", "family": "Arial"},
         title_font={"size": 10, "color": "black", "family": "Arial"},
         legend=None,
-        yaxis_title_font={"size": 10, "color": "black", "family": "Arial"},
-        xaxis_title_font={"size": 10, "color": "black", "family": "Arial"},
+        showlegend=False,
         xaxis={"range": [event.time.start_time, event.time.end_time]},
         xaxis_title={"text": x_title},
-        showlegend=False,
+        xaxis_title_font={"size": 10, "color": "black", "family": "Arial"},
+        yaxis_title_font={"size": 10, "color": "black", "family": "Arial"},
+        yaxis_title={
+            "text": f"Wind speed [{site.gui.units.default_velocity_units.value}]"
+        },
     )
 
     # Only save to the the event folder if that has been created already.

flood_adapt/objects/measures/measures.py

@@ -1,11 +1,12 @@
 import os
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, Type, TypeVar
 
 import geopandas as gpd
 import pyproj
-from pydantic import Field, field_validator, model_validator
+import tomli
+from pydantic import Field, field_serializer, field_validator, model_validator
 
 from flood_adapt.config.site import Site
 from flood_adapt.misc.utils import resolve_filepath, save_file_to_database
@@ -107,6 +108,9 @@ class SelectionType(str, Enum):
     all = "all"
 
 
+T = TypeVar("T", bound="Measure")
+
+
 class Measure(Object):
     """The expected variables and data types of attributes common to all measures.
 
@@ -120,9 +124,91 @@ class Measure(Object):
         Description of the measure.
     type: MeasureType
         Type of measure. Should be one of the MeasureType enum values.
+    selection_type: SelectionType
+        Type of selection. Should be one of the SelectionType enum values.
+    polygon_file: str, Optional
+        Path to a polygon file, either absolute or relative to the measure's toml path in the database.
+    aggregation_area_name: str, Optional
+        Name of the aggregation area. Required if `selection_type` is 'aggregation_area'.
+    aggregation_area_type: str, Optional
+        Type of aggregation area. Required if `selection_type` is 'aggregation_area'.
     """
 
     type: MeasureType
+    selection_type: SelectionType
+
+    polygon_file: Optional[str] = Field(
+        default=None,
+        min_length=1,
+        description="Path to a polygon file, either absolute or relative to the measure path.",
+    )
+
+    aggregation_area_type: Optional[str] = None
+    aggregation_area_name: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_selection_type(self) -> "Measure":
+        match self.selection_type:
+            case SelectionType.all:
+                pass
+            case SelectionType.polygon | SelectionType.polyline:
+                if not self.polygon_file:
+                    raise ValueError(
+                        "If `selection_type` is 'polygon' or 'polyline', then `polygon_file` needs to be set."
+                    )
+            case SelectionType.aggregation_area:
+                if not self.aggregation_area_name:
+                    raise ValueError(
+                        "If `selection_type` is 'aggregation_area', then `aggregation_area_name` needs to be set."
+                    )
+                if not self.aggregation_area_type:
+                    raise ValueError(
+                        "If `selection_type` is 'aggregation_area', then `aggregation_area_type` needs to be set."
+                    )
+            case _:
+                raise ValueError(
+                    f"Invalid selection type: {self.selection_type}. "
+                    "Must be one of 'aggregation_area', 'polygon', 'polyline', or 'all'."
+                )
+        return self
+
+    @field_serializer("polygon_file")
+    def serialize_polygon_file(self, value: Optional[str]) -> Optional[str]:
+        """Serialize the polygon_file attribute to a string of only the file name."""
+        if value is None:
+            return None
+        return Path(value).name
+
+    @classmethod
+    def load_file(cls: Type[T], file_path: Path | str | os.PathLike) -> T:
+        """Load the measure from a file.
+
+        Parameters
+        ----------
+        filepath : Path | str | os.PathLike
+            Path to the file to load the measure from.
+
+        Returns
+        -------
+        Measure
+            The loaded measure object.
+        """
+        with open(file_path, mode="rb") as fp:
+            toml = tomli.load(fp)
+        measure = cls.model_validate(toml)
+
+        if measure.polygon_file:
+            measure.polygon_file = str(Path(file_path).parent / measure.polygon_file)
+
+        return measure
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        if self.polygon_file:
+            Path(output_dir).mkdir(parents=True, exist_ok=True)
+            src_path = resolve_filepath("measures", self.name, self.polygon_file)
+            path = save_file_to_database(src_path, Path(output_dir))
+            # Update the shapefile path in the object so it is saved in the toml file as well
+            self.polygon_file = path.name
 
 
 class HazardMeasure(Measure):
@@ -143,39 +229,12 @@ class HazardMeasure(Measure):
 
     """
 
-    selection_type: SelectionType
-    polygon_file: Optional[str] = Field(
-        default=None,
-        min_length=1,
-        description="Path to a polygon file, either absolute or relative to the measure path.",
-    )
-
     @field_validator("type")
     def validate_type(cls, value):
         if not MeasureType.is_hazard(value):
             raise ValueError(f"Invalid hazard type: {value}")
         return value
 
-    @model_validator(mode="after")
-    def validate_selection_type(self) -> "HazardMeasure":
-        if (
-            self.selection_type
-            not in [SelectionType.aggregation_area, SelectionType.all]
-            and self.polygon_file is None
-        ):
-            raise ValueError(
-                "If `selection_type` is not 'aggregation_area' or 'all', then `polygon_file` needs to be set."
-            )
-        return self
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        if self.polygon_file:
-            Path(output_dir).mkdir(parents=True, exist_ok=True)
-            src_path = resolve_filepath("measures", self.name, self.polygon_file)
-            path = save_file_to_database(src_path, Path(output_dir))
-            # Update the shapefile path in the object so it is saved in the toml file as well
-            self.polygon_file = path.name
-
 
 class ImpactMeasure(Measure):
     """The expected variables and data types of attributes common to all impact measures.
@@ -200,15 +259,6 @@ class ImpactMeasure(Measure):
             Name of the aggregation area.
     """
 
-    type: MeasureType
-    selection_type: SelectionType
-    aggregation_area_type: Optional[str] = None
-    aggregation_area_name: Optional[str] = None
-    polygon_file: Optional[str] = Field(
-        default=None,
-        min_length=1,
-        description="Path to a polygon file, relative to the database path.",
-    )
     property_type: str  # TODO make enum
 
     @field_validator("type")
@@ -217,34 +267,6 @@ class ImpactMeasure(Measure):
             raise ValueError(f"Invalid impact type: {value}")
         return value
 
-    @model_validator(mode="after")
-    def validate_aggregation_area_name(self):
-        if (
-            self.selection_type == SelectionType.aggregation_area
-            and self.aggregation_area_name is None
-        ):
-            raise ValueError(
-                "If `selection_type` is 'aggregation_area', then `aggregation_area_name` needs to be set."
-            )
-        return self
-
-    @model_validator(mode="after")
-    def validate_polygon_file(self):
-        if self.selection_type == SelectionType.polygon and self.polygon_file is None:
-            raise ValueError(
-                "If `selection_type` is 'polygon', then `polygon_file` needs to be set."
-            )
-
-        return self
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        """Save the additional files to the database."""
-        if self.polygon_file:
-            src_path = resolve_filepath("measures", self.name, self.polygon_file)
-            path = save_file_to_database(src_path, Path(output_dir))
-            # Update the shapefile path in the object so it is saved in the toml file as well
-            self.polygon_file = path.name
-
 
 class Elevate(ImpactMeasure):
     """The expected variables and data types of the "elevate" impact measure.