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

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,73 @@
+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(..., 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,
+        )

erad/probability_builder.py

@@ -0,0 +1,35 @@
+from infrasys import BaseQuantity
+import scipy.stats as stats
+
+
+class ProbabilityFunctionBuilder:
+    """Class containing utility fuctions for sceario definations."""
+
+    def __init__(self, dist, params: list[float | BaseQuantity]):
+        """Constructor for BaseScenario class.
+
+        Args:
+            dist (str): Name of teh distribution. Should follow Scipy naming convention
+            params (list): A list of parameters for the chosen distribution function. See Scipy.stats documentation
+        """
+        base_quantity = [p for p in params if isinstance(p, BaseQuantity)][0]
+        self.quantity = base_quantity.__class__
+        self.units = base_quantity.units
+        self.dist = getattr(stats, dist)
+        self.params = [p.magnitude if isinstance(p, BaseQuantity) else p for p in params]
+        return
+
+    def sample(self):
+        """Sample the distribution"""
+        return self.quantity(self.dist.rvs(*self.params, size=1)[0], self.units)
+
+    def probability(self, value: BaseQuantity) -> float:
+        """Calculates survival probability of a given asset.
+
+        Args:
+            value (float): value for vetor of interest. Will change with scenarions
+        """
+        assert isinstance(value, BaseQuantity), "Value must be a BaseQuantity"
+
+        cdf = self.dist.cdf
+        return cdf(value.to(self.units).magnitude, *self.params)

erad/quantities.py

@@ -0,0 +1,25 @@
+from infrasys.base_quantity import BaseQuantity
+
+
+class Speed(BaseQuantity):
+    """Quantity representing speed"""
+
+    __base_unit__ = "m/second"
+
+
+class Acceleration(BaseQuantity):
+    """Quantity representing acceleration."""
+
+    __base_unit__ = "m/second**2"
+
+
+class Temperature(BaseQuantity):
+    __base_unit__ = "degC"
+
+
+class Pressure(BaseQuantity):
+    __base_unit__ = "millibar"
+
+
+class Flow(BaseQuantity):
+    __base_unit__ = "feet**3/second"

erad/runner.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+
+from gdm.distribution import DistributionSystem
+from loguru import logger
+import numpy as np
+
+from gdm.tracked_changes import (
+    TrackedChange,
+    PropertyEdit,
+)
+
+from erad.default_fragility_curves import DEFAULT_FRAGILTY_CURVES
+from erad.models.fragility_curve import HazardFragilityCurves
+from erad.systems.hazard_system import HazardSystem
+from erad.systems.asset_system import AssetSystem
+from erad.constants import HAZARD_TYPES
+from erad.models.asset import Asset
+
+
+class HarzardSimulator:
+    def __init__(self, asset_system: AssetSystem):
+        self._asset_system = asset_system
+        self.assets: list[Asset] = list(asset_system.get_components(Asset))
+
+    @classmethod
+    def from_gdm(cls, dist_system: DistributionSystem) -> "HarzardSimulator":
+        """Create a HarzardSimulator from a DistributionSystem."""
+        asset_system = AssetSystem.from_gdm(dist_system)
+        return cls(asset_system)
+
+    @property
+    def asset_system(self) -> AssetSystem:
+        """Get the AssetSystem."""
+        return self._asset_system
+
+    def _get_time_stamps(self) -> list[datetime]:
+        timestamps = []
+        for model_type in HAZARD_TYPES:
+            for model in self.hazard_system.get_components(model_type):
+                timestamps.append(model.timestamp)
+        return sorted(timestamps)
+
+    def run(self, hazard_system: HazardSystem, curve_set: str = "DEFAULT_CURVES"):
+        probability_models = list(
+            hazard_system.get_components(
+                HazardFragilityCurves, filter_func=lambda x: x.name == curve_set
+            )
+        )
+
+        if not probability_models:
+            logger.warning(
+                "No HazardFragilityCurves definations found in the passed HazardSystem using default curve definations"
+            )
+            probability_models = DEFAULT_FRAGILTY_CURVES
+
+        self.hazard_system = hazard_system
+        self.timestamps = self._get_time_stamps()
+        for timestamp in self.timestamps:
+            for hazard_type in HAZARD_TYPES:
+                for hazard_model in self.hazard_system.get_components(
+                    hazard_type, filter_func=lambda x: x.timestamp == timestamp
+                ):
+                    for asset in self.assets:
+                        asset.update_survival_probability(
+                            timestamp, hazard_model, probability_models
+                        )
+
+
+class HazardScenarioGenerator:
+    def __init__(
+        self,
+        asset_system: AssetSystem,
+        hazard_system: HazardSystem,
+        curve_set: str = "DEFAULT_CURVES",
+    ):
+        self.assets = list(asset_system.iter_all_components())
+        self.harzard_simulator = HarzardSimulator(asset_system)
+        self.harzard_simulator.run(hazard_system, curve_set)
+
+    def _sample(self, scenario_name: str) -> list[TrackedChange]:
+        outaged_assets = []
+        tracked_changes = []
+
+        n_assets = len(self.assets)
+        n_timestamps = len(self.assets[0].asset_state)
+
+        ramdom_samples = np.random.random((n_assets, n_timestamps))
+
+        for ii, asset in enumerate(self.assets):
+            for jj, state in enumerate(
+                sorted(asset.asset_state, key=lambda asset_state: asset_state.timestamp)
+            ):
+                if (
+                    ramdom_samples[ii, jj] > state.survival_probability
+                    and asset.name not in outaged_assets
+                ):
+                    tracked_changes.append(
+                        TrackedChange(
+                            scenario_name=scenario_name,
+                            timestamp=state.timestamp,
+                            edits=[
+                                PropertyEdit(
+                                    component_uuid=asset.distribution_asset,
+                                    name="in_service",
+                                    value=False,
+                                )
+                            ],
+                        ),
+                    )
+                    outaged_assets.append(asset.name)
+
+        return tracked_changes
+
+    def samples(self, number_of_samples: int = 1, seed: int = 0) -> list[TrackedChange]:
+        if number_of_samples < 1:
+            raise ValueError("number_of_samples should be a positive integer")
+        np.random.seed(seed)
+        tracked_changes = []
+        for i in range(number_of_samples):
+            scenario_name = f"sample_{i}"
+            tracked_changes.extend(self._sample(scenario_name))
+        return tracked_changes