NREL-erad 0.0.0a0__py3-none-any.whl → 0.1.1__py3-none-any.whl

erad/models/fragility_curve.py

@@ -0,0 +1,116 @@
+from functools import cached_property
+from typing import Literal
+from pathlib import Path
+
+
+from infrasys import Component, BaseQuantity
+from scipy.stats import _continuous_distns
+from pydantic import field_validator
+import plotly.express as px
+import numpy as np
+
+from erad.probability_builder import ProbabilityFunctionBuilder
+from erad.models.asset import AssetState
+from erad.enums import AssetTypes
+from erad.quantities import Speed
+
+
+FRAGILITY_CURVE_TYPES = [
+    fc for fc in AssetState.model_fields if fc not in ["name", "uuid", "timestamp"]
+]
+SUPPORTED_CONT_DIST = [name for name in dir(_continuous_distns) if not name.startswith("_")]
+
+
+class ProbabilityFunction(Component):
+    name: str = ""
+    distribution: Literal[*SUPPORTED_CONT_DIST]
+    parameters: list[float | BaseQuantity]
+
+    @field_validator("parameters")
+    def validate_parameters(cls, value):
+        if not any(isinstance(v, BaseQuantity) for v in value):
+            raise ValueError("There should be atleast one BaseQuantity in the parameters")
+
+        units = set([v.units for v in value if isinstance(v, BaseQuantity)])
+        if not len(units) == 1:
+            raise ValueError("All BaseQuantities should have the same units")
+        return value
+
+    @cached_property
+    def prob_model(self) -> ProbabilityFunctionBuilder:
+        return ProbabilityFunctionBuilder(self.distribution, self.parameters)
+
+    @classmethod
+    def example(cls) -> "ProbabilityFunction":
+        return ProbabilityFunction(
+            distribution="norm",
+            parameters=[Speed(1.5, "m/s"), 2],
+        )
+
+
+class FragilityCurve(Component):
+    name: str = ""
+    asset_type: AssetTypes
+    prob_function: ProbabilityFunction
+
+    @classmethod
+    def example(cls) -> "FragilityCurve":
+        return FragilityCurve(
+            asset_type=AssetTypes.substation,
+            prob_function=ProbabilityFunction.example(),
+        )
+
+
+class HazardFragilityCurves(Component):
+    name: str = "DEFAULT_CURVES"
+    asset_state_param: Literal[*FRAGILITY_CURVE_TYPES]
+    curves: list[FragilityCurve]
+
+    @classmethod
+    def example(cls) -> "HazardFragilityCurves":
+        return HazardFragilityCurves(
+            asset_state_param="peak_ground_acceleration",
+            curves=[FragilityCurve.example()],
+        )
+
+    def plot(
+        self, file_path: Path, x_min: float = 0, x_max: float = None, number_of_points: int = 100
+    ):
+        """Plot the fragility curves."""
+        file_path = Path(file_path)
+        assert file_path.suffix.lower() == ".html", "File path should be an HTML file"
+
+        if not self.curves:
+            raise ValueError("No curves to plot")
+
+        quantities = [
+            p for p in self.curves[0].prob_function.parameters if isinstance(p, BaseQuantity)
+        ]
+
+        x_label = self.asset_state_param.replace("_", " ").title()
+        x = np.linspace(x_min, x_max, number_of_points)
+
+        plot_data = {"x": [], "y": [], "Asset Type": []}
+
+        for curve in self.curves:
+            model_class = quantities[0].__class__
+            units = quantities[0].units
+            prob_model = curve.prob_function.prob_model
+            y = prob_model.probability(model_class(x, units))
+            label = curve.asset_type.name.replace("_", " ").title()
+
+            plot_data["x"].extend(x)
+            plot_data["y"].extend(y)
+            plot_data["Asset Type"].extend([label] * len(x))
+
+        fig = px.line(
+            plot_data,
+            x="x",
+            y="y",
+            color="Asset Type",
+            labels={"x": f"{x_label} [{units}]", "y": "Probability of Failure"},
+            title=f"Fragility Curves for {x_label}",
+        )
+
+        fig.show()
+        fig.write_html(file_path)

erad/models/hazard/__init__.py

@@ -0,0 +1,5 @@
+from erad.models.hazard.base_models import BaseDisasterModel
+from erad.models.hazard.earthquake import EarthQuakeModel
+from erad.models.hazard.wild_fire import FireModel, FireModelArea
+from erad.models.hazard.wind import WindModel
+from erad.models.hazard.flood import FloodModel, FloodModelArea

erad/models/hazard/base_models.py

@@ -0,0 +1,12 @@
+import plotly.graph_objects as go
+from pydantic import ConfigDict
+from infrasys import Component
+
+
+class BaseDisasterModel(Component):
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+    def plot(
+        self, time_index: int, figure: go.Figure, map_obj: go.Scattergeo | go.Scattermap
+    ) -> int:
+        raise NotImplementedError("This method should be implemented in the derived classes")

erad/models/hazard/common.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from loguru import logger
+import requests
+
+
+TEST_PATH = Path(__file__).parents[4] / "tests"
+DATA_FOLDER_NAME = "data"
+DATA_FOLDER = TEST_PATH / DATA_FOLDER_NAME
+DB_FILENAME = "erad_data.sqlite"
+ERAD_DB = TEST_PATH / DATA_FOLDER_NAME / DB_FILENAME
+BUCKET_NAME = "erad_v2_dataset"
+
+if not ERAD_DB.exists():
+    logger.info("Erad database not found. Downloading from Google Cloud.")
+    ERAD_DB.parent.mkdir(parents=True, exist_ok=True)
+    url = f"https://storage.googleapis.com/{BUCKET_NAME}/{DB_FILENAME}"
+    response = requests.get(url)
+
+    with open(ERAD_DB, "wb") as f:
+        f.write(response.content)
+    logger.info("Download complete...")
+
+HISTROIC_EARTHQUAKE_TABLE = "historic_earthquakes"
+HISTROIC_HURRICANE_TABLE = "historic_hurricanes"
+HISTROIC_FIRE_TABLE = "historic_fires"

erad/models/hazard/earthquake.py

@@ -0,0 +1,93 @@
+from datetime import datetime
+import sqlite3
+import os
+
+from pydantic import field_serializer, field_validator
+from gdm.quantities import Distance
+from shapely.geometry import Point
+import plotly.graph_objects as go
+import pandas as pd
+
+from erad.models.hazard.common import ERAD_DB, HISTROIC_EARTHQUAKE_TABLE
+from erad.models.hazard.base_models import BaseDisasterModel
+
+
+class EarthQuakeModel(BaseDisasterModel):
+    timestamp: datetime
+    origin: Point
+    depth: Distance
+    magnitude: float
+
+    @field_validator("origin", mode="before")
+    def deserialize_point(cls, value):
+        if isinstance(value, dict) and value.get("type") == "Point":
+            coords = value["coordinates"]
+            return Point(coords)
+        return value
+
+    @field_serializer("origin")
+    def serialize_location(self, point: Point, _info):
+        return {"type": "Point", "coordinates": (point.x, point.y)}
+
+    @classmethod
+    def example(cls) -> "EarthQuakeModel":
+        return EarthQuakeModel(
+            name="earthquake 1",
+            timestamp=datetime.now(),
+            origin=Point(-120.93036, 36.60144),
+            depth=Distance(300, "km"),
+            magnitude=5.0,
+        )
+
+    @classmethod
+    def from_earthquake_code(cls, earthquake_code: str) -> "EarthQuakeModel":
+        assert os.path.exists(ERAD_DB), f"The data file {ERAD_DB} not found"
+
+        conn = sqlite3.connect(ERAD_DB)
+        earthquake_data = pd.read_sql(
+            f"SELECT * FROM {HISTROIC_EARTHQUAKE_TABLE} WHERE ID = '{earthquake_code}'", conn
+        )
+        conn.close()
+
+        assert not earthquake_data.empty, f"No earthquake {earthquake_code} found in the database"
+
+        earthquake_data["Date"] = pd.to_datetime(earthquake_data["Date"])
+        earthquake_data["Time"] = pd.to_datetime(earthquake_data["Time"])
+        earthquake_data["DateTime"] = earthquake_data.apply(
+            lambda row: datetime.combine(row["Date"].date(), row["Time"].time()), axis=1
+        )
+
+        long = earthquake_data.Longitude.values[0]
+        lat = earthquake_data.Latitude.values[0]
+
+        return cls(
+            name=earthquake_code,
+            timestamp=earthquake_data.DateTime.values[0].astype("datetime64[ms]").astype(datetime),
+            origin=Point(long, lat),
+            depth=Distance(earthquake_data.Depth.values[0], "km"),
+            magnitude=earthquake_data.Magnitude.values[0],
+        )
+
+    def plot(
+        self,
+        time_index: int = 0,
+        figure: go.Figure = go.Figure(),
+        map_obj: type[go.Scattergeo | go.Scattermap] = go.Scattermap,
+    ) -> int:
+        figure.add_trace(
+            map_obj(
+                lat=[self.origin.y],
+                lon=[self.origin.x],
+                mode="markers",
+                marker=dict(size=[self.magnitude * 10], color=[self.depth.magnitude], opacity=0.4),
+                name="Earthquake",
+                hovertext=[
+                    f"""
+                    <br> <b>Earthquake depth:</b> {self.depth}
+                    <br> <b>Earthquake magnitude:</b> {self.magnitude}
+                    """
+                ],
+                visible=(time_index == 0),
+            )
+        )
+        return 1

erad/models/hazard/flood.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+
+from pydantic import field_serializer, field_validator
+from shapely.geometry import Polygon, Point
+from gdm.quantities import Distance
+import plotly.graph_objects as go
+from infrasys import Component
+
+from erad.models.hazard.base_models import BaseDisasterModel
+from erad.quantities import Speed
+
+
+class FloodModelArea(Component):
+    name: str = ""
+    affected_area: Polygon
+    water_velocity: Speed
+    water_elevation: Distance
+
+    @field_validator("affected_area", mode="before")
+    def deserialize_polygon(cls, value):
+        if isinstance(value, dict) and value.get("type") == "Polygon":
+            points = [Point(c) for c in value["coordinates"]]
+            return Polygon(points)
+        return value
+
+    @field_serializer("affected_area")
+    def serialize_polygon(self, poly: Polygon, _info):
+        return {"type": "Polygon", "coordinates": list(poly.exterior.coords)}
+
+    @classmethod
+    def example(cls) -> "FloodModelArea":
+        return FloodModelArea(
+            affected_area=Polygon(
+                [
+                    (-120.93036, 36.60144),
+                    (-120.91072, 36.60206),
+                    (-120.91127, 36.5712),
+                    (-120.93405, 36.58100),
+                ]
+            ),
+            water_velocity=Speed(50, "meter/second"),
+            water_elevation=Distance(10, "feet"),
+        )
+
+
+class FloodModel(BaseDisasterModel):
+    timestamp: datetime
+    affected_areas: list[FloodModelArea]
+
+    @classmethod
+    def example(cls) -> "FloodModel":
+        return FloodModel(
+            name="flood 1",
+            timestamp=datetime.now(),
+            affected_areas=[FloodModelArea.example()],
+        )
+
+    def plot(
+        self,
+        time_index: int = 0,
+        figure: go.Figure = go.Figure(),
+        map_obj: type[go.Scattergeo | go.Scattermap] = go.Scattermap,
+    ) -> int:
+        for area in self.affected_areas:
+            lon, lat = area.affected_area.exterior.xy  # returns x and y sequences
+            figure.add_trace(
+                map_obj(
+                    lon=lon.tolist(),
+                    lat=lat.tolist(),
+                    mode="markers+lines+text",
+                    fill="toself",
+                    marker={
+                        "size": 10,
+                        "color": [area.water_elevation.magnitude],
+                    },
+                    hovertemplate=f"""
+                        <br> <b>Water velocity:</b> {area.water_velocity}
+                        <br> <b>Water elevation:</b> {area.water_elevation}
+                        """,
+                    visible=(time_index == 0),
+                )
+            )
+        return len(self.affected_areas)

erad/models/hazard/wild_fire.py

@@ -0,0 +1,121 @@
+from datetime import datetime
+import sqlite3
+import os
+
+from shapely.geometry import MultiPolygon, Polygon, Point
+from pydantic import field_serializer, field_validator
+import plotly.graph_objects as go
+from gdm.quantities import Angle
+from infrasys import Component
+from shapely import wkb
+import pandas as pd
+
+from erad.models.hazard.common import ERAD_DB, HISTROIC_FIRE_TABLE
+from erad.models.hazard.base_models import BaseDisasterModel
+from erad.quantities import Speed
+
+
+class FireModelArea(Component):
+    name: str = ""
+    affected_area: Polygon
+    wind_speed: Speed
+    wind_direction: Angle
+
+    @field_validator("affected_area", mode="before")
+    def deserialize_polygon(cls, value):
+        if isinstance(value, dict) and value.get("type") == "Polygon":
+            points = [Point(c) for c in value["coordinates"]]
+            return Polygon(points)
+        return value
+
+    @field_serializer("affected_area")
+    def serialize_polygon(self, poly: Polygon, _info):
+        return {"type": "Polygon", "coordinates": list(poly.exterior.coords)}
+
+    @classmethod
+    def example(cls) -> "FireModelArea":
+        return FireModelArea(
+            affected_area=Polygon(
+                [
+                    (-120.93036, 36.60144),
+                    (-120.91072, 36.60206),
+                    (-120.91127, 36.5712),
+                    (-120.93405, 36.58100),
+                ]
+            ),
+            wind_speed=Speed(50, "miles/hour"),
+            wind_direction=Angle(45, "deg"),
+        )
+
+
+class FireModel(BaseDisasterModel):
+    timestamp: datetime
+    affected_areas: list[FireModelArea]
+
+    @classmethod
+    def example(cls) -> "FireModel":
+        return FireModel(
+            name="fire 1",
+            timestamp=datetime.now(),
+            affected_areas=[FireModelArea.example()],
+        )
+
+    @classmethod
+    def from_wildfire_name(cls, wildfire_name: str) -> "FireModel":
+        assert os.path.exists(ERAD_DB), f"The data file {ERAD_DB} not found"
+        conn = sqlite3.connect(ERAD_DB)
+        fire_data = pd.read_sql(
+            f"SELECT * FROM {HISTROIC_FIRE_TABLE} WHERE firename = '{wildfire_name}';", conn
+        )
+        if fire_data.empty:
+            raise ValueError(
+                f"Fire '{wildfire_name}'  not found in  table '{HISTROIC_FIRE_TABLE}' in the database"
+            )
+        conn.close()
+        fire_data["discoverydatetime"] = pd.to_datetime(fire_data["discoverydatetime"])
+        geometry: MultiPolygon = [wkb.loads(g) for g in fire_data.GEOMETRY][0]
+        areas = []
+        for i, poly in enumerate(geometry.geoms):
+            areas.append(
+                FireModelArea(
+                    affected_area=poly,
+                    wind_speed=Speed(-999, "miles/hour"),
+                    wind_direction=Angle(0, "deg"),
+                )
+            )
+        return cls(
+            name=wildfire_name,
+            timestamp=fire_data["discoverydatetime"]
+            .values[0]
+            .astype("datetime64[ms]")
+            .astype(datetime),
+            affected_areas=areas,
+        )
+
+    def plot(
+        self,
+        time_index: int = 0,
+        figure: go.Figure = go.Figure(),
+        map_obj: type[go.Scattergeo | go.Scattermap] = go.Scattermap,
+    ) -> int:
+        for area in self.affected_areas:
+            lon, lat = area.affected_area.exterior.xy  # returns x and y sequences
+            figure.add_trace(
+                map_obj(
+                    lon=lon.tolist(),
+                    lat=lat.tolist(),
+                    mode="markers+lines+text",
+                    fill="toself",
+                    marker={
+                        "size": 10,
+                        "color": [area.wind_speed.magnitude],
+                    },
+                    hovertemplate=f"""
+                        <br> <b>Wind speed:</b> {area.wind_speed}
+                        <br> <b>Wind direction:</b> {area.wind_direction}
+                        """,
+                    hoverinfo="text",
+                    visible=(time_index == 0),
+                )
+            )
+        return len(self.affected_areas)

erad/models/hazard/wind.py

@@ -0,0 +1,143 @@
+from datetime import datetime
+import sqlite3
+import os
+
+from pydantic import field_serializer, field_validator
+from infrasys.quantities import Distance
+from shapely.geometry import Point
+import plotly.graph_objects as go
+import geopandas as gpd
+import pandas as pd
+
+from erad.models.hazard.common import ERAD_DB, HISTROIC_HURRICANE_TABLE
+from erad.models.hazard.base_models import BaseDisasterModel
+from erad.quantities import Speed, Pressure
+
+
+class WindModel(BaseDisasterModel):
+    timestamp: datetime
+    center: Point
+    max_wind_speed: Speed
+    radius_of_max_wind: Distance
+    radius_of_closest_isobar: Distance
+    air_pressure: Pressure
+
+    @field_validator("center", mode="before")
+    def deserialize_point(cls, value):
+        if isinstance(value, dict) and value.get("type") == "Point":
+            coords = value["coordinates"]
+            return Point(coords)
+        return value
+
+    @field_serializer("center")
+    def serialize_location(self, point: Point, _info):
+        return {"type": "Point", "coordinates": (point.x, point.y)}
+
+    @classmethod
+    def example(cls) -> "WindModel":
+        return WindModel(
+            name="hurricane 1",
+            timestamp=datetime.now(),
+            center=Point(-121.93036, 36.60144),
+            max_wind_speed=Speed(50, "miles/hour"),
+            air_pressure=Pressure(1013.25, "hPa"),
+            radius_of_max_wind=Distance(50, "miles"),
+            radius_of_closest_isobar=Distance(300, "miles"),
+        )
+
+    @classmethod
+    def from_hurricane_sid(cls, hurricane_sid: str) -> list["WindModel"]:
+        assert os.path.exists(ERAD_DB), f"The data file {ERAD_DB} not found"
+        conn = sqlite3.connect(ERAD_DB)
+        hurricane_data = pd.read_sql(
+            f"SELECT * FROM {HISTROIC_HURRICANE_TABLE} WHERE `SID ` = '{hurricane_sid}';", conn
+        )
+        cols = [
+            "LAT (degrees_north)",
+            "LON (degrees_east)",
+            "USA_WIND (kts)",
+            "USA_ROCI (nmile)",
+            "USA_RMW (nmile)",
+            "USA_POCI (mb)",
+            "ISO_TIME ",
+        ]
+        hurricane_data = hurricane_data[cols]
+        for col in cols:
+            hurricane_data = hurricane_data[hurricane_data[col] != " "]
+        if hurricane_data.empty:
+            raise ValueError(
+                f"Hurricane '{hurricane_sid}'  not found in column 'SID', table '{HISTROIC_HURRICANE_TABLE}' in the database"
+            )
+        conn.close()
+        geometry = [
+            Point(lat, lon)
+            for lat, lon in zip(
+                hurricane_data["LAT (degrees_north)"], hurricane_data["LON (degrees_east)"]
+            )
+        ]
+        hurricane_data["ISO_TIME "] = pd.to_datetime(hurricane_data["ISO_TIME "])
+        hurricane_data = gpd.GeoDataFrame(hurricane_data, geometry=geometry)
+        hurricane_data.set_crs("epsg:4326")
+        track = []
+        for idx, row in hurricane_data.iterrows():
+            track.append(
+                WindModel(
+                    name=hurricane_sid,
+                    timestamp=row["ISO_TIME "],
+                    center=row["geometry"],
+                    max_wind_speed=Speed(float(row["USA_WIND (kts)"]), "knots"),
+                    radius_of_max_wind=Distance(float(row["USA_RMW (nmile)"]), "nautical_mile"),
+                    radius_of_closest_isobar=Distance(
+                        float(row["USA_ROCI (nmile)"]), "nautical_mile"
+                    ),
+                    air_pressure=Pressure(float(row["USA_POCI (mb)"]), "millibar"),
+                )
+            )
+
+        return track
+
+    def plot(
+        self,
+        time_index: int = 0,
+        figure: go.Figure = go.Figure(),
+        map_obj: type[go.Scattergeo | go.Scattermap] = go.Scattermap,
+    ) -> int:
+        figure.add_trace(
+            map_obj(
+                lat=[self.center.x],
+                lon=[self.center.y],
+                mode="markers",
+                marker=dict(
+                    size=[self.radius_of_closest_isobar.magnitude / 5],
+                    color="lightblue",
+                    opacity=0.4,
+                ),
+                name="Radius of closest isobar",  # Name for the legend
+                visible=(time_index == 0),
+            )
+        )
+
+        figure.add_trace(
+            map_obj(
+                lat=[self.center.x],
+                lon=[self.center.y],
+                mode="markers",
+                marker=dict(
+                    size=[self.radius_of_max_wind.magnitude / 5],
+                    color=[self.max_wind_speed.magnitude],
+                    showscale=False,
+                    opacity=0.4,
+                ),
+                visible=(time_index == 0),
+                hovertext=[
+                    f"""
+                    <br> <b>Max wind speed:</b> {self.max_wind_speed}
+                    <br> <b>Radius of max wind speed:</b> {self.radius_of_max_wind}
+                    <br> <b>Radius of closest isobar:</b> {self.radius_of_closest_isobar}
+                    <br> <b>Air pressure:</b> {self.air_pressure}
+                    """
+                ],
+                name="Radius of max wind",  # Name for the legend
+            )
+        )
+        return 2

erad/models/probability.py

@@ -0,0 +1,76 @@
+from typing import Annotated
+
+from gdm.quantities import Distance
+from infrasys import Component
+from pydantic import Field
+from abc import ABC
+
+from erad.quantities import Speed, Acceleration, Temperature
+
+
+class BaseProbabilityModel(Component, ABC):
+    name: str = ""
+    survival_probability: Annotated[
+        float,
+        Field(1.0, ge=0, le=1, description="Asset survival probability"),
+    ]
+
+
+class SpeedProbability(BaseProbabilityModel):
+    speed: Annotated[
+        Speed,
+        Field(
+            ...,
+            description="Represents the speed of a scenario parameter experienced by the asset e.g speed of wind",
+        ),
+    ]
+
+    @classmethod
+    def example(cls) -> "SpeedProbability":
+        return SpeedProbability(
+            speed=Speed(50, "m/s"),
+            survival_probability=1.0,
+        )
+
+
+class TemperatureProbability(BaseProbabilityModel):
+    temperature: Annotated[
+        Temperature,
+        Field(..., description="Temperature of the asset"),
+    ]
+
+    @classmethod
+    def example(cls) -> "TemperatureProbability":
+        return TemperatureProbability(
+            temperature=Temperature(0, "degC"),
+            survival_probability=1.0,
+        )
+
+
+class DistanceProbability(BaseProbabilityModel):
+    distance: Annotated[
+        Distance,
+        Field(
+            Distance(-9999, "m"),
+            description="Distance of asset from the source / boundary of a disaster event",
+        ),
+    ]
+
+    @classmethod
+    def example(cls) -> "DistanceProbability":
+        return DistanceProbability(
+            distance=Distance(0, "m"),
+            survival_probability=1.0,
+        )
+
+
+class AccelerationProbability(BaseProbabilityModel):
+    name: str = ""
+    acceleration: Acceleration = Acceleration(0, "m/s**2")
+
+    @classmethod
+    def example(cls) -> "AccelerationProbability":
+        return AccelerationProbability(
+            acceleration=Acceleration(0, "m/s**2"),
+            survival_probability=1.0,
+        )