flood-adapt 0.3.0__py3-none-any.whl

flood_adapt/objects/forcing/wind.py

@@ -0,0 +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))

flood_adapt/objects/measures/measure_factory.py

@@ -0,0 +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.")