NREL-erad 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

erad/models/asset.py

@@ -1,287 +0,0 @@
-from datetime import datetime
-from uuid import UUID
-import math
-
-from pydantic import computed_field, Field
-from infrasys.quantities import Distance
-from geopy.distance import geodesic
-from shapely.geometry import Point
-from pyhigh import get_elevation
-from infrasys import Component
-
-from erad.quantities import Acceleration, Speed
-from erad.models.probability import (
-    AccelerationProbability,
-    DistanceProbability,
-    SpeedProbability,
-)
-from erad.enums import AssetTypes
-import erad.models.hazard as hz
-
-
-class AssetState(Component):
-    name: str = ""
-    timestamp: datetime
-    wind_speed: SpeedProbability | None = None
-    flood_velocity: SpeedProbability | None = None
-    flood_depth: DistanceProbability | None = None
-    fire_boundary_dist: DistanceProbability | None = None
-    peak_ground_velocity: SpeedProbability | None = None
-    peak_ground_acceleration: AccelerationProbability | None = None
-
-    def calculate_earthquake_vectors(
-        self, asset_coordinate: Point, hazard_model: hz.EarthQuakeModel
-    ):
-        """
-        Sources:
-
-        Atkinson, G.M., & Wald, D.J. (2007). “Did You Feel It?” intensity data: A surprisingly good
-        measure of earthquake ground motion. Seismological Research Letters, 78(3), 362–368.
-        """
-
-        epicenter_distance = Distance(
-            geodesic(
-                (hazard_model.origin.y, hazard_model.origin.x),
-                (asset_coordinate.y, asset_coordinate.x),
-            ).km,
-            "km",
-        )
-
-        hypocentral_distance = (hazard_model.depth**2 + epicenter_distance**2) ** 0.5
-
-        mmi = (
-            3.31
-            + 1.28 * hazard_model.magnitude
-            - 1.42 * math.log10(hypocentral_distance.to("km").magnitude)
-        )  # Modified Mercalli Intensity
-
-        log_pgv = (mmi - 3.78) / 1.47
-        pgv = 10**log_pgv  # cm/s
-        self.peak_ground_velocity = SpeedProbability(
-            speed=Speed(pgv, "centimeter/second"),
-            survival_probability=1,
-        )
-
-        log_pga = (mmi - 1.78) / 3.70
-        pga_per_g = 10**log_pga  # % of g
-        self.peak_ground_acceleration = AccelerationProbability(
-            acceleration=Acceleration(pga_per_g / 100.0 * 9.80665, "meter/second**2"),
-            survival_probability=1,
-        )
-
-    def calculate_fire_vectors(self, asset_coordinate: Point, hazard_model: hz.FireModel):
-        """
-        Sources:
-
-        “Integrating Wildfire Risk Modeling with Electric Grid Asset Management” (EPRI)
-        “Modeling and Mitigating Wildfire Risk to the Power Grid” (PNNL, 2021)
-        “A Framework for Assessing Wildfire Ignition Risk on Distribution Systems”
-            (IEEE Transactions on Power Systems, 2020)
-        Improving Grid Safety and Resilience to Mitigate Ignition Incident and Fire Risks – EPRI
-        Wildfire Risk Reduction Methods 2024 – EPRI
-        """
-
-        distances_to_wild_fire_boundaries = []
-        for wild_fire_area in hazard_model.affected_areas:
-            if wild_fire_area.affected_area.contains(asset_coordinate):
-                distance = 0
-            else:
-                distance = wild_fire_area.affected_area.exterior.distance(asset_coordinate)
-            distances_to_wild_fire_boundaries.append(distance)
-        minimum_distance_km = min(distances_to_wild_fire_boundaries)
-        self.fire_boundary_dist = DistanceProbability(
-            distance=Distance(minimum_distance_km, "kilometer"),
-            survival_probability=1,
-        )
-
-        # survival_probability = 1 - 0.95 * math.exp(-k * minimum_distance_km)
-
-    def calculate_wind_vectors(self, asset_coordinate: Point, hazard_model: hz.WindModel):
-        r = Distance(
-            geodesic(
-                (hazard_model.center.y, hazard_model.center.x),
-                (asset_coordinate.y, asset_coordinate.x),
-            ).km,
-            "km",
-        )
-
-        r = r.to("nautical_mile")
-        r_max = hazard_model.radius_of_closest_isobar.to("nautical_mile")
-        r_v_max = hazard_model.radius_of_max_wind.to("nautical_mile")
-        v_max = hazard_model.max_wind_speed.to("knot")
-
-        k = 1.14
-        b = 10
-
-        a = math.log(b) / (r_max - r_v_max)
-        m = (1 / r_v_max) * math.log(k / (k + 1))
-
-        if r >= 0 and r < r_v_max:
-            wind_speed = k * v_max * (1 - math.exp(-m * r))
-        elif r >= r_v_max and r < r_max:
-            wind_speed = v_max * math.exp(-a * (r - r_v_max))
-        else:
-            wind_speed = 0
-
-        self.wind_speed = SpeedProbability(
-            speed=wind_speed.to("miles/hour"),
-            survival_probability=1,
-        )
-
-    def calculate_flood_vectors(
-        self, asset_coordinate: Point, hazard_model: hz.FloodModel, asset_total_elevation: Distance
-    ):
-        for area in hazard_model.affected_areas:
-            if area.affected_area.contains(asset_coordinate):
-                self.flood_depth = DistanceProbability(
-                    distance=area.water_elevation - asset_total_elevation,
-                    survival_probability=1,
-                )
-                self.flood_velocity = SpeedProbability(
-                    speed=area.water_velocity,
-                    survival_probability=1,
-                )
-            else:
-                self.flood_depth = DistanceProbability(
-                    distance=Distance(-9999, "meter"),
-                    survival_probability=1,
-                )
-                self.flood_velocity = SpeedProbability(
-                    speed=Speed(0, "meter / second"),
-                    survival_probability=1,
-                )
-
-    @computed_field
-    @property
-    def survival_probability(self) -> float:
-        wind_survival_probability = self.wind_speed.survival_probability if self.wind_speed else 1
-        water_flow_survival_probability = (
-            self.flood_velocity.survival_probability if self.flood_velocity else 1
-        )
-        water_level_survivial_probability = (
-            self.flood_depth.survival_probability if self.flood_depth else 1
-        )
-        fire_survival_probability = (
-            self.fire_boundary_dist.survival_probability if self.fire_boundary_dist else 1
-        )
-        pgv_survival_probability = (
-            self.peak_ground_velocity.survival_probability if self.peak_ground_velocity else 1
-        )
-        pga_survival_probability = (
-            self.peak_ground_acceleration.survival_probability
-            if self.peak_ground_acceleration
-            else 1
-        )
-
-        return (
-            wind_survival_probability
-            * water_flow_survival_probability
-            * water_level_survivial_probability
-            * fire_survival_probability
-            * pgv_survival_probability
-            * pga_survival_probability
-        )
-
-    @classmethod
-    def example(cls) -> "AssetState":
-        return AssetState(
-            timestamp=datetime.now(),
-            wind_speed=SpeedProbability.example(),
-            flood_velocity=SpeedProbability.example(),
-            flood_depth=DistanceProbability.example(),
-            fire_boundary_dist=DistanceProbability.example(),
-            peak_ground_velocity=SpeedProbability.example(),
-            peak_ground_acceleration=AccelerationProbability.example(),
-        )
-
-
-class Asset(Component):
-    distribution_asset: UUID = Field(..., description="UUID of the distribution asset")
-    connections: list[UUID] = Field([], description="List of UUIDs of connected assets")
-    devices: list[UUID] = Field(
-        [], description="List of UUIDs of devices associated with the asset"
-    )
-    asset_type: AssetTypes
-    height: Distance = Field(..., gt=0, description="Height of the asset")
-    latitude: float = Field(..., ge=-90, le=90, description="Latitude in degrees")
-    longitude: float = Field(..., ge=-180, le=180, description="Longitude in degrees")
-    asset_state: list[AssetState]
-
-    @computed_field
-    @property
-    def elevation(self) -> Distance:
-        return Distance(get_elevation(lat=self.latitude, lon=self.longitude), "meter")
-
-    def _get_asset_state_at_timestamp(self, timestamp: datetime) -> AssetState | None:
-        for asset_state in self.asset_state:
-            if asset_state.timestamp == timestamp:
-                return asset_state
-        return AssetState(
-            timestamp=timestamp,
-        )
-
-    def update_survival_probability(
-        self, time_stamp: datetime, hazard_model: hz.BaseDisasterModel, frag_curves
-    ):
-        asset_state = self._get_asset_state_at_timestamp(time_stamp)
-        asset_location = Point(self.longitude, self.latitude)
-
-        if isinstance(hazard_model, hz.EarthQuakeModel):
-            asset_state.calculate_earthquake_vectors(asset_location, hazard_model)
-        elif isinstance(hazard_model, hz.FireModel):
-            asset_state.calculate_fire_vectors(asset_location, hazard_model)
-        elif isinstance(hazard_model, hz.WindModel):
-            asset_state.calculate_wind_vectors(asset_location, hazard_model)
-        elif isinstance(hazard_model, hz.FloodModel):
-            asset_state.calculate_flood_vectors(
-                asset_location, hazard_model, self.elevation + self.height
-            )
-        else:
-            raise (f"Unsupported hazard type {hazard_model.__class__.__name__}")
-
-        self.calculate_probabilities(asset_state, frag_curves)
-
-        if asset_state not in self.asset_state:
-            self.asset_state.append(asset_state)
-
-    def calculate_probabilities(self, asset_state: AssetState, frag_curves):
-        fields = [
-            model_field
-            for model_field in list(asset_state.model_fields.keys())
-            if model_field not in ["uuid", "name", "timestamp"]
-        ]
-        for field in fields:
-            prob_model = getattr(asset_state, field)
-            if prob_model and prob_model.survival_probability == 1:
-                curve = self.get_vadid_curve(frag_curves, field)
-                if curve is None:
-                    raise Exception(f"No fragility curve found for field - {field}")
-                prob_inst = curve.prob_model
-                quantity_name = [
-                    model_field
-                    for model_field in list(prob_model.model_fields.keys())
-                    if model_field not in ["uuid", "name", "survival_probability"]
-                ][0]
-                quantity = getattr(prob_model, quantity_name)
-                prob_model.survival_probability = 1 - prob_inst.probability(quantity)
-
-    def get_vadid_curve(self, frag_curves, field: SyntaxError) -> float:
-        for frag_curve in frag_curves:
-            if frag_curve.asset_state_param == field:
-                for curve in frag_curve.curves:
-                    if curve.asset_type == self.asset_type:
-                        return curve.prob_function
-
-        return None
-
-    @classmethod
-    def example(cls) -> "Asset":
-        return Asset(
-            name="Asset 1",
-            asset_type=AssetTypes.distribution_poles,
-            distribution_asset=UUID("123e4567-e89b-12d3-a456-426614174000"),
-            height=Distance(100, "m"),
-            latitude=37.7749,
-            longitude=-122.4194,
-            asset_state=[AssetState.example()],
-        )

erad/models/asset_mapping.py

@@ -1,20 +0,0 @@
-from typing import Type, Callable
-
-from pydantic import BaseModel, ConfigDict
-from infrasys import Component
-
-from erad.enums import AssetTypes
-
-
-class BaseEradScenarioModel(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
-
-
-class ComponentFilterModel(BaseEradScenarioModel):
-    component_type: Type[Component]
-    component_filter: Callable | None = None
-
-
-class AssetComponentMap(BaseEradScenarioModel):
-    asset_type: AssetTypes
-    filters: list[ComponentFilterModel] = []

erad/models/fragility_curve.py

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

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

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

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

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

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