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

erad/default_fragility_curves/default_wind_speed.py

@@ -0,0 +1,94 @@
+import erad.models.fragility_curve as frag
+from erad.enums import AssetTypes
+from erad.quantities import Speed
+
+
+DEFAULT_WIND_SPEED_FRAGILITY_CURVES = frag.HazardFragilityCurves(
+    asset_state_param="wind_speed",
+    curves=[
+        frag.FragilityCurve(
+            asset_type=AssetTypes.switch,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.45, "m/s"), Speed(50, "m/s"), 1 / 0.45]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.battery_storage,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.45, "m/s"), Speed(50, "m/s"), 1 / 0.45]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(50, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(45, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_poles,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(45, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.solar_panels,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.3, "m/s"), Speed(55, "m/s"), 1 / 0.3]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.substation,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.40]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_mad_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(50, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_pole_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.3, "m/s"), Speed(45, "m/s"), 1 / 0.30]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.54, "m/s"), Speed(55, "m/s"), 1 / 0.54]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(50, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_tower,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.40]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(60, "m/s"), 1 / 0.40]
+            ),
+        ),
+    ],
+)

erad/enums.py

@@ -0,0 +1,40 @@
+from enum import IntEnum
+
+
+class ScenarioTypes(IntEnum):
+    flood_m = 0
+    wind_m_per_s = 1
+    fire_m = 2
+    earthquake_pga = 3
+
+
+class NodeTypes(IntEnum):
+    transmission_tower = 5
+    distribution_poles = 6
+    transmission_junction_box = 11
+    distribution_junction_box = 12
+
+
+class AssetTypes(IntEnum):
+    substation = 0
+    solar_panels = 1
+    distribution_underground_cables = 2
+    transmission_underground_cables = 3
+    battery_storage = 4
+    transmission_tower = 5
+    distribution_poles = 6
+    transmission_overhead_lines = 7
+    distribution_overhead_lines = 8
+    transformer_mad_mount = 9
+    transformer_pole_mount = 10
+    transmission_junction_box = 11
+    distribution_junction_box = 12
+    switch = 13
+
+    @classmethod
+    def has_value(cls, value):
+        return value in cls._value2member_map_
+
+    @classmethod
+    def has_asset(cls, asset):
+        return asset in cls.__members__

erad/gdm_mapping.py

@@ -0,0 +1,83 @@
+import gdm.distribution.components as gdc
+import gdm.distribution.equipment as gde
+
+from erad.enums import AssetTypes
+from erad.models.asset_mapping import ComponentFilterModel
+
+
+asset_to_gdm_mapping = {
+    AssetTypes.switch: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSwitchBase,
+        ),
+    ],
+    AssetTypes.switch: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSwitchBase,
+        ),
+    ],
+    AssetTypes.substation: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionVoltageSource,
+        ),
+    ],
+    AssetTypes.solar_panels: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSolar,
+        ),
+    ],
+    AssetTypes.battery_storage: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionBattery,
+        ),
+    ],
+    AssetTypes.distribution_underground_cables: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.ConcentricCableEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+        ComponentFilterModel(
+            component_type=gdc.MatrixImpedanceBranch,
+            component_filter=lambda x: x.equipment.c_matrix[0, 0]
+            .to("microfarad/kilometer")
+            .magnitude
+            > 0.05
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+    ],
+    AssetTypes.distribution_overhead_lines: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: (
+                x.equipment.conductors[0].__class__ == gde.BareConductorEquipment
+            )
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+        ComponentFilterModel(
+            component_type=gdc.MatrixImpedanceBranch,
+            component_filter=lambda x: x.equipment.c_matrix[0, 0]
+            .to("microfarad/kilometer")
+            .magnitude
+            < 0.05
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+    ],
+    AssetTypes.transmission_underground_cables: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.ConcentricCableEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude > 35.0,
+        ),
+    ],
+    AssetTypes.transmission_overhead_lines: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.BareConductorEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude > 35.0,
+        ),
+    ],
+}

erad/models/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

erad/models/asset.py

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

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

@@ -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"