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

flood_adapt/objects/forcing/waterlevels.py

@@ -1,108 +1,108 @@
-import math
-import os
-from pathlib import Path
-from typing import Annotated
-
-import numpy as np
-import pandas as pd
-from pydantic import BaseModel
-
-from flood_adapt.misc.utils import (
-    copy_file_to_output_dir,
-    validate_file_extension,
-)
-from flood_adapt.objects.forcing import unit_system as us
-from flood_adapt.objects.forcing.forcing import (
-    ForcingSource,
-    IWaterlevel,
-)
-from flood_adapt.objects.forcing.time_frame import (
-    TimeFrame,
-)
-from flood_adapt.objects.forcing.timeseries import (
-    CSVTimeseries,
-    SyntheticTimeseries,
-    TimeseriesFactory,
-)
-
-
-class SurgeModel(BaseModel):
-    """BaseModel describing the expected variables and data types for harmonic tide parameters of synthetic model."""
-
-    timeseries: SyntheticTimeseries
-
-
-class TideModel(BaseModel):
-    """BaseModel describing the expected variables and data types for harmonic tide parameters of synthetic model."""
-
-    harmonic_amplitude: us.UnitfulLength
-    harmonic_phase: us.UnitfulTime
-    harmonic_period: us.UnitfulTime = us.UnitfulTime(
-        value=12.4, units=us.UnitTypesTime.hours
-    )
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        index = pd.date_range(
-            start=time_frame.start_time,
-            end=time_frame.end_time,
-            freq=time_frame.time_step,
-            name="time",
-        )
-        seconds = np.arange(len(index)) * time_frame.time_step.total_seconds()
-        seconds.round(decimals=0)
-
-        amp = self.harmonic_amplitude.value
-        omega = 2 * math.pi / (self.harmonic_period.convert(us.UnitTypesTime.seconds))
-        phase_seconds = self.harmonic_phase.convert(us.UnitTypesTime.seconds)
-
-        tide = amp * np.cos(omega * (seconds - phase_seconds))
-        return pd.DataFrame(data=tide, index=index)
-
-
-class WaterlevelSynthetic(IWaterlevel):
-    source: ForcingSource = ForcingSource.SYNTHETIC
-
-    surge: SurgeModel
-    tide: TideModel
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        tide_df = self.tide.to_dataframe(time_frame=time_frame)
-
-        surge_df = TimeseriesFactory.from_object(self.surge.timeseries).to_dataframe(
-            time_frame=time_frame
-        )
-
-        # Combine
-        tide_df.columns = ["waterlevel"]
-        surge_df.columns = ["waterlevel"]
-        surge_df = surge_df.reindex(tide_df.index, method="nearest", limit=1).fillna(
-            value=self.surge.timeseries.fill_value
-        )
-
-        wl_df = tide_df.add(surge_df, axis="index", fill_value=0)
-        wl_df.columns = ["waterlevel"]
-
-        return wl_df
-
-
-class WaterlevelCSV(IWaterlevel):
-    source: ForcingSource = ForcingSource.CSV
-
-    path: Annotated[Path, validate_file_extension([".csv"])]
-    units: us.UnitTypesLength = us.UnitTypesLength.meters
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        return CSVTimeseries.load_file(
-            path=self.path, units=us.UnitfulLength(value=0, units=self.units)
-        ).to_dataframe(time_frame=time_frame)
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        self.path = copy_file_to_output_dir(self.path, Path(output_dir))
-
-
-class WaterlevelModel(IWaterlevel):
-    source: ForcingSource = ForcingSource.MODEL
-
-
-class WaterlevelGauged(IWaterlevel):
-    source: ForcingSource = ForcingSource.GAUGED
+import math
+import os
+from pathlib import Path
+from typing import Annotated
+
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel
+
+from flood_adapt.misc.utils import (
+    copy_file_to_output_dir,
+    validate_file_extension,
+)
+from flood_adapt.objects.forcing import unit_system as us
+from flood_adapt.objects.forcing.forcing import (
+    ForcingSource,
+    IWaterlevel,
+)
+from flood_adapt.objects.forcing.time_frame import (
+    TimeFrame,
+)
+from flood_adapt.objects.forcing.timeseries import (
+    CSVTimeseries,
+    SyntheticTimeseries,
+    TimeseriesFactory,
+)
+
+
+class SurgeModel(BaseModel):
+    """BaseModel describing the expected variables and data types for harmonic tide parameters of synthetic model."""
+
+    timeseries: SyntheticTimeseries
+
+
+class TideModel(BaseModel):
+    """BaseModel describing the expected variables and data types for harmonic tide parameters of synthetic model."""
+
+    harmonic_amplitude: us.UnitfulLength
+    harmonic_phase: us.UnitfulTime
+    harmonic_period: us.UnitfulTime = us.UnitfulTime(
+        value=12.4, units=us.UnitTypesTime.hours
+    )
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        index = pd.date_range(
+            start=time_frame.start_time,
+            end=time_frame.end_time,
+            freq=time_frame.time_step,
+            name="time",
+        )
+        seconds = np.arange(len(index)) * time_frame.time_step.total_seconds()
+        seconds.round(decimals=0)
+
+        amp = self.harmonic_amplitude.value
+        omega = 2 * math.pi / (self.harmonic_period.convert(us.UnitTypesTime.seconds))
+        phase_seconds = self.harmonic_phase.convert(us.UnitTypesTime.seconds)
+
+        tide = amp * np.cos(omega * (seconds - phase_seconds))
+        return pd.DataFrame(data=tide, index=index)
+
+
+class WaterlevelSynthetic(IWaterlevel):
+    source: ForcingSource = ForcingSource.SYNTHETIC
+
+    surge: SurgeModel
+    tide: TideModel
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        tide_df = self.tide.to_dataframe(time_frame=time_frame)
+
+        surge_df = TimeseriesFactory.from_object(self.surge.timeseries).to_dataframe(
+            time_frame=time_frame
+        )
+
+        # Combine
+        tide_df.columns = ["waterlevel"]
+        surge_df.columns = ["waterlevel"]
+        surge_df = surge_df.reindex(tide_df.index, method="nearest", limit=1).fillna(
+            value=self.surge.timeseries.fill_value
+        )
+
+        wl_df = tide_df.add(surge_df, axis="index", fill_value=0)
+        wl_df.columns = ["waterlevel"]
+
+        return wl_df
+
+
+class WaterlevelCSV(IWaterlevel):
+    source: ForcingSource = ForcingSource.CSV
+
+    path: Annotated[Path, validate_file_extension([".csv"])]
+    units: us.UnitTypesLength = us.UnitTypesLength.meters
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        return CSVTimeseries.load_file(
+            path=self.path, units=us.UnitfulLength(value=0, units=self.units)
+        ).to_dataframe(time_frame=time_frame)
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        self.path = copy_file_to_output_dir(self.path, Path(output_dir))
+
+
+class WaterlevelModel(IWaterlevel):
+    source: ForcingSource = ForcingSource.MODEL
+
+
+class WaterlevelGauged(IWaterlevel):
+    source: ForcingSource = ForcingSource.GAUGED

flood_adapt/objects/forcing/wind.py

@@ -1,124 +1,124 @@
-import os
-from pathlib import Path
-from typing import Annotated, Any
-
-import pandas as pd
-import xarray as xr
-
-from flood_adapt.misc.utils import (
-    copy_file_to_output_dir,
-    validate_file_extension,
-)
-from flood_adapt.objects.forcing import unit_system as us
-from flood_adapt.objects.forcing.forcing import (
-    ForcingSource,
-    IWind,
-)
-from flood_adapt.objects.forcing.netcdf import validate_netcdf_forcing
-from flood_adapt.objects.forcing.timeseries import (
-    CSVTimeseries,
-    SyntheticTimeseries,
-    TimeFrame,
-    TimeseriesFactory,
-)
-
-
-class WindConstant(IWind):
-    source: ForcingSource = ForcingSource.CONSTANT
-
-    speed: us.UnitfulVelocity
-    direction: us.UnitfulDirection
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        time = pd.date_range(
-            start=time_frame.start_time,
-            end=time_frame.end_time,
-            freq=time_frame.time_step,
-            name="time",
-        )
-        data = {
-            "mag": [self.speed.value for _ in range(len(time))],
-            "dir": [self.direction.value for _ in range(len(time))],
-        }
-        return pd.DataFrame(data=data, index=time)
-
-
-class WindSynthetic(IWind):
-    source: ForcingSource = ForcingSource.SYNTHETIC
-
-    magnitude: SyntheticTimeseries
-    direction: SyntheticTimeseries
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        time = pd.date_range(
-            start=time_frame.start_time,
-            end=time_frame.end_time,
-            freq=time_frame.time_step,
-            name="time",
-        )
-
-        magnitude = TimeseriesFactory.from_object(self.magnitude).to_dataframe(
-            time_frame=time_frame,
-        )
-
-        direction = TimeseriesFactory.from_object(self.direction).to_dataframe(
-            time_frame=time_frame,
-        )
-        return pd.DataFrame(
-            index=time,
-            data={
-                "mag": magnitude.reindex(time).to_numpy().flatten(),
-                "dir": direction.reindex(time).to_numpy().flatten(),
-            },
-        )
-
-
-class WindTrack(IWind):
-    source: ForcingSource = ForcingSource.TRACK
-
-    path: Annotated[Path, validate_file_extension([".cyc", ".spw"])]
-    # path to cyc file, set this when creating it
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        if self.path:
-            self.path = copy_file_to_output_dir(self.path, Path(output_dir))
-
-
-class WindCSV(IWind):
-    source: ForcingSource = ForcingSource.CSV
-
-    path: Annotated[Path, validate_file_extension([".csv"])]
-
-    units: dict[str, Any] = {
-        "speed": us.UnitTypesVelocity.mps,
-        "direction": us.UnitTypesDirection.degrees,
-    }
-
-    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
-        return CSVTimeseries.load_file(
-            path=self.path, units=us.UnitfulVelocity(value=0, units=self.units["speed"])
-        ).to_dataframe(time_frame)
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        self.path = copy_file_to_output_dir(self.path, Path(output_dir))
-
-
-class WindMeteo(IWind):
-    source: ForcingSource = ForcingSource.METEO
-
-
-class WindNetCDF(IWind):
-    source: ForcingSource = ForcingSource.NETCDF
-    units: us.UnitTypesVelocity = us.UnitTypesVelocity.mps
-
-    path: Annotated[Path, validate_file_extension([".nc"])]
-
-    def read(self) -> xr.Dataset:
-        required_vars = ("wind10_v", "wind10_u", "press_msl")
-        required_coords = ("time", "lat", "lon")
-        with xr.open_dataset(self.path) as ds:
-            validated_ds = validate_netcdf_forcing(ds, required_vars, required_coords)
-        return validated_ds
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        self.path = copy_file_to_output_dir(self.path, Path(output_dir))
+import os
+from pathlib import Path
+from typing import Annotated, Any
+
+import pandas as pd
+import xarray as xr
+
+from flood_adapt.misc.utils import (
+    copy_file_to_output_dir,
+    validate_file_extension,
+)
+from flood_adapt.objects.forcing import unit_system as us
+from flood_adapt.objects.forcing.forcing import (
+    ForcingSource,
+    IWind,
+)
+from flood_adapt.objects.forcing.netcdf import validate_netcdf_forcing
+from flood_adapt.objects.forcing.timeseries import (
+    CSVTimeseries,
+    SyntheticTimeseries,
+    TimeFrame,
+    TimeseriesFactory,
+)
+
+
+class WindConstant(IWind):
+    source: ForcingSource = ForcingSource.CONSTANT
+
+    speed: us.UnitfulVelocity
+    direction: us.UnitfulDirection
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        time = pd.date_range(
+            start=time_frame.start_time,
+            end=time_frame.end_time,
+            freq=time_frame.time_step,
+            name="time",
+        )
+        data = {
+            "mag": [self.speed.value for _ in range(len(time))],
+            "dir": [self.direction.value for _ in range(len(time))],
+        }
+        return pd.DataFrame(data=data, index=time)
+
+
+class WindSynthetic(IWind):
+    source: ForcingSource = ForcingSource.SYNTHETIC
+
+    magnitude: SyntheticTimeseries
+    direction: SyntheticTimeseries
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        time = pd.date_range(
+            start=time_frame.start_time,
+            end=time_frame.end_time,
+            freq=time_frame.time_step,
+            name="time",
+        )
+
+        magnitude = TimeseriesFactory.from_object(self.magnitude).to_dataframe(
+            time_frame=time_frame,
+        )
+
+        direction = TimeseriesFactory.from_object(self.direction).to_dataframe(
+            time_frame=time_frame,
+        )
+        return pd.DataFrame(
+            index=time,
+            data={
+                "mag": magnitude.reindex(time).to_numpy().flatten(),
+                "dir": direction.reindex(time).to_numpy().flatten(),
+            },
+        )
+
+
+class WindTrack(IWind):
+    source: ForcingSource = ForcingSource.TRACK
+
+    path: Annotated[Path, validate_file_extension([".cyc", ".spw"])]
+    # path to cyc file, set this when creating it
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        if self.path:
+            self.path = copy_file_to_output_dir(self.path, Path(output_dir))
+
+
+class WindCSV(IWind):
+    source: ForcingSource = ForcingSource.CSV
+
+    path: Annotated[Path, validate_file_extension([".csv"])]
+
+    units: dict[str, Any] = {
+        "speed": us.UnitTypesVelocity.mps,
+        "direction": us.UnitTypesDirection.degrees,
+    }
+
+    def to_dataframe(self, time_frame: TimeFrame) -> pd.DataFrame:
+        return CSVTimeseries.load_file(
+            path=self.path, units=us.UnitfulVelocity(value=0, units=self.units["speed"])
+        ).to_dataframe(time_frame)
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        self.path = copy_file_to_output_dir(self.path, Path(output_dir))
+
+
+class WindMeteo(IWind):
+    source: ForcingSource = ForcingSource.METEO
+
+
+class WindNetCDF(IWind):
+    source: ForcingSource = ForcingSource.NETCDF
+    units: us.UnitTypesVelocity = us.UnitTypesVelocity.mps
+
+    path: Annotated[Path, validate_file_extension([".nc"])]
+
+    def read(self) -> xr.Dataset:
+        required_vars = ("wind10_v", "wind10_u", "press_msl")
+        required_coords = ("time", "lat", "lon")
+        with xr.open_dataset(self.path) as ds:
+            validated_ds = validate_netcdf_forcing(ds, required_vars, required_coords)
+        return validated_ds
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        self.path = copy_file_to_output_dir(self.path, Path(output_dir))

flood_adapt/objects/measures/measure_factory.py

@@ -1,92 +1,92 @@
-import os
-from typing import Union
-
-import tomli
-
-from flood_adapt.objects.measures.measures import (
-    Buyout,
-    Elevate,
-    FloodProof,
-    FloodWall,
-    GreenInfrastructure,
-    Measure,
-    MeasureType,
-    Pump,
-)
-
-
-class MeasureFactory:
-    @staticmethod
-    def get_measure_type(filepath: Union[str, os.PathLike]):
-        """Get a measure type from toml file."""
-        with open(filepath, mode="rb") as fp:
-            toml = tomli.load(fp)
-        type = toml.get("type")
-        return MeasureType(type)
-
-    @staticmethod
-    def get_measure_object(filepath: Union[str, os.PathLike]) -> Measure:
-        measure_type = MeasureFactory.get_measure_type(filepath)
-
-        if MeasureType.is_impact(measure_type):
-            return ImpactMeasureFactory.get_impact_measure(measure_type).load_file(
-                filepath
-            )
-        elif MeasureType.is_hazard(measure_type):
-            return HazardMeasureFactory.get_hazard_measure(measure_type).load_file(
-                filepath
-            )
-        else:
-            raise ValueError(f"Measure type {measure_type} not recognized.")
-
-
-class ImpactMeasureFactory:
-    """Simple parser to get the respective measure subclass from a measure type string given in the config file.
-
-    Args:
-        type (str): name of measure type
-
-    Returns
-    -------
-        Measure: Measure subclass
-    """
-
-    @staticmethod
-    def get_impact_measure(impact_measure: str):
-        if impact_measure == "elevate_properties":
-            return Elevate
-        elif impact_measure == "buyout_properties":
-            return Buyout
-        elif impact_measure == "floodproof_properties":
-            return FloodProof
-        else:
-            raise ValueError(f"Measure type {impact_measure} not recognized.")
-
-
-class HazardMeasureFactory:
-    """Simple parser to get the respective measure subclass from a measure type string given in the config file.
-
-    Args:
-        type (str): name of measure type
-
-    Returns
-    -------
-        Measure: Measure subclass
-    """
-
-    @staticmethod
-    def get_hazard_measure(hazard_measure: str):
-        if (
-            hazard_measure == "floodwall" or hazard_measure == "levee"
-        ):  # these should use the same class right?
-            return FloodWall
-        elif (
-            hazard_measure == "water_square"
-            or hazard_measure == "total_storage"
-            or hazard_measure == "greening"
-        ):
-            return GreenInfrastructure
-        elif hazard_measure == "pump":
-            return Pump
-        else:
-            raise ValueError(f"Measure type {hazard_measure} not recognized.")
+import os
+from typing import Union
+
+import tomli
+
+from flood_adapt.objects.measures.measures import (
+    Buyout,
+    Elevate,
+    FloodProof,
+    FloodWall,
+    GreenInfrastructure,
+    Measure,
+    MeasureType,
+    Pump,
+)
+
+
+class MeasureFactory:
+    @staticmethod
+    def get_measure_type(filepath: Union[str, os.PathLike]):
+        """Get a measure type from toml file."""
+        with open(filepath, mode="rb") as fp:
+            toml = tomli.load(fp)
+        type = toml.get("type")
+        return MeasureType(type)
+
+    @staticmethod
+    def get_measure_object(filepath: Union[str, os.PathLike]) -> Measure:
+        measure_type = MeasureFactory.get_measure_type(filepath)
+
+        if MeasureType.is_impact(measure_type):
+            return ImpactMeasureFactory.get_impact_measure(measure_type).load_file(
+                filepath
+            )
+        elif MeasureType.is_hazard(measure_type):
+            return HazardMeasureFactory.get_hazard_measure(measure_type).load_file(
+                filepath
+            )
+        else:
+            raise ValueError(f"Measure type {measure_type} not recognized.")
+
+
+class ImpactMeasureFactory:
+    """Simple parser to get the respective measure subclass from a measure type string given in the config file.
+
+    Args:
+        type (str): name of measure type
+
+    Returns
+    -------
+        Measure: Measure subclass
+    """
+
+    @staticmethod
+    def get_impact_measure(impact_measure: str):
+        if impact_measure == "elevate_properties":
+            return Elevate
+        elif impact_measure == "buyout_properties":
+            return Buyout
+        elif impact_measure == "floodproof_properties":
+            return FloodProof
+        else:
+            raise ValueError(f"Measure type {impact_measure} not recognized.")
+
+
+class HazardMeasureFactory:
+    """Simple parser to get the respective measure subclass from a measure type string given in the config file.
+
+    Args:
+        type (str): name of measure type
+
+    Returns
+    -------
+        Measure: Measure subclass
+    """
+
+    @staticmethod
+    def get_hazard_measure(hazard_measure: str):
+        if (
+            hazard_measure == "floodwall" or hazard_measure == "levee"
+        ):  # these should use the same class right?
+            return FloodWall
+        elif (
+            hazard_measure == "water_square"
+            or hazard_measure == "total_storage"
+            or hazard_measure == "greening"
+        ):
+            return GreenInfrastructure
+        elif hazard_measure == "pump":
+            return Pump
+        else:
+            raise ValueError(f"Measure type {hazard_measure} not recognized.")